#
# 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
}
WINDS OF TORMENT (FRA) - Delighting in Relentless Ignorance (2007)
Label : Mascot Records / Socadisc
Sortie du Scud : 16 avril 2007
Pays : France
Genre : Death Metal
Type : Album
Playtime : 9 Titres - 49 Mins
Groupe originaire de la région de Saint Etienne, le quintet répondant au doux patronyme de WIND OF TORMENT a commencé à poser les bases de sa musique en 2001.Ce sera grâce à leur première démo The Cell of The Erased qui leur permit de se faire remarquer et de se qualifier ainsi pour la grande finale du tremplin musical organisé par Mascot Records et Rock Hard en 2005. Ce n’est qu’après avoir remporté le concours que WINDS OF TORMENT s’est vu confié par le label la signature pour son premier album Delighting in Relentless Ignorance. Après l’écoute de l’opus et de ses neufs titres, on comprend mieux pourquoi ce groupe a gagné de main de fer ce concours il y a deux ans. Hormis le travail réalisé par ce groupe, le talent ne leur est pas étranger.
Du très bon gros son enregistré au Kohlkekker Studio en Allemagne (CREMATORY, AGATHODAIMON, BENIGHTED tient…d’autres Stéphanois !), ce combo français composé de Xavier (chant) Bertrand et Jérôme (guitares) Alban (basse) et Jean-François (batterie) délivre pour un premier essai un album fort cohérent, à la cohésion évidente où des passages violents évoquant les grands noms du Death Metal sont voisins de passages calmes évoquant des morceaux à la OPETH tels que «The Other» ou «Swallowing the Ashes of Guilt», si bien que certains morceaux pourraient ressembler à une sorte de mélange entre le groupe suédois et BLOODBATH avec une pincée de malice à la MORBID ANGEL. Cette formation hexagonale mérite que l’on s’y intéresse. Le fait d’avoir remporter un concours de ce type ne fait qu’accentuer le crédit que l’on peut porter à ce genre d’événementiel. Le quintet nous immerge dans les tourments de ses compositions acerbes et chaudes à la fois comme sur «Devoid of Essence» et ses accélérations intempestives ou sur l’intro du titre à l’atmosphère démoniaque comme «The Unspoken Pact» qui montre toutes les aptitudes d’écriture des hommes du Pays de la Loire.
Le mariage de passages progressifs et des tempos Death n’a pas de secret pour WINDS OF TORMENT. Tous les instruments sont bien en place et on saluera la performance de WOT de produire un tel album pour leurs premiers pas dans le milieu. Mais tout n’est pas rose sur cette rondelle. Aussi surprenante et agréable soit-elle, on peut déplorer le fait qu’aucun titre de l’album ne se dégage ni se distingue, comme on l’a précédemment souligné, l’homogénéité de cet opus est sa grande force mais aussi sa faiblesse car toutes les pistes se valent. En plus le titre ayant donné en partie son nom à l’album en est de loin la meilleure plage. On se rabattra plutôt sur des morceaux tels que «Rules Overload», terrain où WOT n’hésite pas à hausser le ton avec ce titre de Death Thrash certes plus convenu et simpliste que les autres morceaux développés auparavant, mais qui demeure vraiment bien exécuté.
Quoi qu’il en soit, WINDS OF TORMENT offre une bonne surprise pour un premier essai. En attendant peut-être la signature chez un label de plus grande envergure leur permettant de voir plus haut. Un groupe d’avenir…
Ajouté : Mardi 10 Avril 2007
Chroniqueur : Loki
Score :  
Lien en relation: Winds Of Torment Website
Hits: 14241
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
