#
# XML_node.objet
#
# This object is an XML node representation
#
# /- name (string)
# xml_node --- attributes (array)
# \- children (array) or value (string)
class xml_node {
var $name;
var $attributes = array();
var $children = array();
var $value = "";
function xml_node($name,$attributes,$children=array(),$value="") {
$this->name = $name;
if (is_array($attributes)) {
$this->attributes = $attributes;
}
$this->children = $children;
$this->value = $value;
}
}
#
# xml_tree class
#
# This object parses an XML stream and offers a tree composed by xml_nodes
#
class xml_tree {
var $xml_stream;
var $current_node;
var $root_node;
var $index;
var $value;
function xml_tree() {
$this->root_node = new xml_node("__ROOT_NODE",array());
$this->current_node = $this->root_node;
}
function add_tree($xml_stream) {
# Managing the parser
$this->xml_stream = $xml_stream;
$xml_parser = xml_parser_create();
xml_parser_set_option($xml_parser,XML_OPTION_CASE_FOLDING,0);
xml_parser_set_option($xml_parser,XML_OPTION_SKIP_WHITE,1);
if (!xml_parse_into_struct($xml_parser,$this->xml_stream,$this->value,$this->index)) {
xml_parser_free($xml_parser);
die("XML Parse error");
}
xml_parser_free($xml_parser);
# Now, $this->value and $this->index are informed, we can use the get_node methode.
$tab_result = $this->get_node(0,count($this->value) - 1);
$this->root_node->children[] = $tab_result[0];
$this->current_node = $this->root_node;
}
function get_node($index_start,$index_stop) {
#echo "
\n";
#echo "GET-NODE($index_start,$index_stop)
\n";
# What we are going to return is an array of xml_nodes
$return_tab = array();
# depth is only here to check if everything is all right
$tab_node = $this->value[$index_start];
$depth = $tab_node["level"]-1;
# Now we have to be sure we do not forget a single node
for ($index = $index_start;$index <= $index_stop;$index++) {
#echo "\$index = $index
";
# get the current node
$tab_node = $this->value[$index];
# what type of node is it ?
switch($tab_node["type"]) {
case "complete" :
# Depth integrity check
if ($tab_node["level"] != $depth+1) {
die("ERREUR # contrainte d'intégrité au noeud complet $index, niveau $depth + 1 au lieu de ".$tab_node["level"]);
}
#echo "Noeud complet trouvé position $index TAG ".$tab_node["tag"]."
\n";
# Easy one, no children to manage, only a value...
$return_tab[] = new xml_node($tab_node["tag"],$tab_node["attributes"],"",$tab_node["value"]);
break;
case "open" :
# Depth integrity check
if ($tab_node["level"] != $depth +1 ) {
die("ERREUR # contrainte d'intégrité au noeud ouvert $index, niveau $depth au lieu de ".$tab_node["level"]);
}
# Open tag, we re-use this methode to return its children
# Where is the correspondong close tag ?
$node_index = $this->index[$tab_node["tag"]];
$flipped_node_index = array_flip($node_index);
#echo "This ".$tab_node["tag"]." is at coords ".$flipped_node_index[$index]."
";
$i=1;
do {
$next_index = $node_index[$flipped_node_index[$index] + $i++];
$next_tag=$this->value[$next_index];
}
while ($next_tag["level"]!=$tab_node["level"]);
#echo "Ouverture de noeud détectée pos $index TAG ".$tab_node["tag"]."
\n Parcours jusqu au $next_index
\n";
# good, we can now instanciate our node
$return_tab[] = new xml_node($tab_node["tag"],$tab_node["attributes"],$this->get_node($index+1,$next_index),"");
# As we called the get_node methode, we are sure that nodes have been parsed to the corresponding close tag
$index = $next_index;
break;
case "close" :
# Depth integrity check
if ($tab_node["level"] != $depth ){
die("ERREUR # contrainte d'intégrité au noeud fermé $index, niveau $depth au lieu de ".$tab_node["level"]);
}
#echo "Fermeture de noeud detectée pos $index TAG ".$tab_node["tag"]."
\n";
# This ugly thing is useless because reaching a close tag means that $index==$index_stop but who knows ? =)
# it will be skipped soon
$index = $index_stop;
break;
default:
die("Erreur de type de TAG non déterminé :'".$tab_node["type"]."'");
}
}
# We are out ... returns the array with collected children...
return ($return_tab);
}
# this function browse the xml tree and set the current node to the selected node
function give_node($path) {
if ($path[0]=="/") {
$current_node=$this->root_node;
$path=substr($path,1);
#echo "ABSOLUTE PATH GIVEN=$path
";
}
else {
$current_node = $this->current_node;
}
#echo "PATH GIVEN=$path
";
$tab_path = split("/",$path);
foreach ($tab_path as $node_expr) {
#echo "STUDYING EXPR='$node_expr'
";
$node = $current_node;
$expr_tab = split("\?",$node_expr);
$node_name = $expr_tab[0];
$attr_tab = 0;
if (count($expr_tab)>1) {
##echo "TROUVE AU MOINS UNE CONDITION SUR LES ATTRIBUTS...
";
$attr_expr_tab=split(",",$expr_tab[1]);
$attr_tab=array();
foreach($attr_expr_tab as $attr_expr) {
$attr_split_expr=split("=",$attr_expr);
$attr_tab[$attr_split_expr[0]]=$attr_split_expr[1];
}
}
$last=0;
foreach ($node->children as $children) {
#echo "COMPARING WITH '$children->name'
";
if ($children->name == $node_name) {
##echo "TROUVE NOEUD CORRESPONDANT $node_name
";
if (is_array($attr_tab)) {
$node_attributes = $children->attributes;
foreach ($attr_tab as $key=>$value) {
if ($node_attributes[$key] == $value) {
#echo "ATTRIBUTE & CHANGE CURRENT NODE TO ".$children->name."
";
$current_node = $children;
$last = 1;
}
}
}
else {
##echo "CHILD=".$children->name."
";
#echo "CHANGE CURRENT NODE TO ".$children->name."
";
$current_node = $children;
$last=1;
}
}
if ($last) {
break;
}
}
if (!$last) {
#echo "PATH ERROR $node_name
";
#die("MMmmmh It seems that this file is not a DIA XML format...sorry...");
return 0;
}
}
return $current_node;
}
function browse_tree($path) {
$node = $this->give_node($path);
if (is_object($node)) {
$this->current_node = $node;
return 1;
}
return 0;
}
# this method dumps an html representation of the xml tree
function xml_show($node = "",$level=0,$last=0) {
if ($node=="") {
$node=$this->root_node;
}
if (!is_object($node)) {
die("ERROR : node is not an object");
}
$line="";
for($i=1;$i<=$level;$i++) {
if ((i==$level-1) and ($last)) {
$line.=" ";
}
else {
$line.=" |";
}
if ($i==$level) {
$line.="`-";
}
}
$line.=$node->name;
#echo $line;
$line.="".count($node->children)."";
if (count($node->children)==1) {
$line.=" (".$node->value.")
\n";
echo "$line";
}
else {
$line.="
\n";
echo "$line";
$i=1;
foreach($node->children as $children) {
if ($i==count($node->children)) {
$this->xml_show($children,$level+1,1);
}
else {
$this->xml_show($children,$level+1);
}
$i++;
}
}
}
#END_CLASS
}
HATE FOREST (ua) - Purity (2003)
Label : Supernal Music
Sortie du Scud : 2003
Pays : Ukraine
Genre : Black / Death Metal
Type : Album
Playtime : 7 Titres - 44 Mins
Mené de main de maitre par Roman Saenko (BLOOD OF KINGU, DRUDKH,) et Thurios (ASTROFAES), le duo d'HATE FOREST vous sert ici son deuxième album sorti sur Supernal Music tout comme son prédécesseur et premier album plus qu'énorme, The Most Ancient Ones. Il convient de rajouter que les deux compères on sorti beaucoup de splits et de démos sur les labels Ancient Nation Productions et Night Birds Records.
Apres une très légère intro d'à peine 40 secondes, la puissance est lâchée d'entrée de jeu. Le riff de la première chanson vous prend directement à la gorge autant techniquement qu'émotionnellement, accompagné de cette double pédale et de ce blast-beat ultra violent. Petite précision : ce n'est pas l'œuvre d'un vrai batteur mais d'une boite à rythmes. C'est le choix du groupe et pour une fois cela ne me fera pas râler, n'étant pas fan de l'utilisation de la boite à rythmes en général. Cette fois, j'y trouve mon compte car cette dernière participe à la noirceur et à l'ambiance glaciale voulue et dégagée avec succès par HATE FOREST. Là où un vrai batteur aurait pu humaniser quelque peu la percussion, ici la machine avec un son au plus proche de l’instrument réel rend encore plus martiale et organique la musique du groupe. Ecoutez ces blasts martelant avec puissance et rage accompagnés de ce son de guitare qui se fait à la fois lourd et oppressant. Mes amis, nous avons affaire ici à une machine de guerre qui détruira tout sur son passage. Cette impression est confortée quand les vocaux gutturaux et inhumains résolument plus Death que Black se mettent en place. On ressent toute l'envie de destruction des deux ukrainiens. La composition sont assez longues mais grâce à la richesse et à la diversité des riffs, on est vite pris aux tripes par cette rage malsaine qui vous enveloppe tout au long des 7 titres de cet opus. Malgré l'ultra brutalité et la longueur des chansons (on atteint les 11 minutes à deux reprises), on y trouve quand même quelques breaks bien efficaces comme sur la chanson "The Gates" qui casse le rythme mais qui repart de plus belle et vous assène une claque en pleine figure et vous déleste de vos derniers espoirs d'humanité. Car c'est réellement ce qui se passe à l'écoute de cette galette : on ne ressort pas indemne d'un CD d’HATE FOREST. C’est probablement du aux compositions, excellentes, et aussi à la production qui est assez massive, rajoute une puissance certaine et sublime cette musique sombre et destructrice à souhait.
Pour résumer, c'est une grosse claque qui dure 44 minutes et vous emmène directement au cœur d'un paysage dénué de chaleur, de réconfort ou d'humanité. Sincèrement, ce Black/Death ultra brutal est dépourvu d’émotion ou de positivité, comme cela peut-être le cas quand on entend Death Metal, surtout dans les groupes modernes. Ici, votre bonne humeur n'existera plus après l'écoute du second opus de HATE FOREST. Pour les aficionados du genre, c'est une référence. Pour les néophytes, ce sera surement un gros choc à la première écoute. Mais dans tous les cas, ce sera un voyage musical qui ne sera pas assuré dans la joie et la bonne humeur. Passer à coté serait une réelle erreur.
Ajouté : Mercredi 13 Juin 2012
Chroniqueur : Nekkro
Score :  
Hits: 7912
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
