#
# 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
}
LORD DYING (usa) - Summon The Faithless (2013)
Label : Relapse Records
Sortie du Scud : 9 juillet 2013
Pays : Etats-Unis
Genre : Sludge Metal
Type : Album
Playtime : 8 Titres - 40 Mins
Après une désolante mais enrichissante escapade dans l’univers de la superficialité, de l’intolérance et du Deathcore-botox en compagnie du dernier ATTILA, c’est avec un brin de soulagement que je m’apprête à redécouvrir le terme "musique" avec LORD DYING. Pour être tout à fait franc, je ne connais ce groupe ni d’Eve, ni d’Adam et s’il y a bien une raison pour laquelle j’ai voulu écrire pour eux, c’est cette pochette hypnotique, œuvre du génialissime Orion Landau (qui a signé le End Time de BRUTAL TRUTH, le Reign Supreme de DYING FETUS, le Behold The Failure de MUMAKIL ou encore le Book Burner de PIG DESTROYER). Pour ainsi dire, LORD DYING doit bien être le groupe le plus soft avec lequel il a jamais collaboré et à l’écoute de ce Summon The Faithless, ça n’avait rien d’évident. Relativement extrême dans son style de prédilection, le quatuor américain dévoile donc en ce mois de juillet 2013 ensoleillé des ressources aussi prometteuses qu’étouffantes.
Au-delà d’une signature chez Relaspe qui fait déjà bel effet quand on ouvre leur catalogue, LORD DYING possède un petit truc qui fait immédiatement la différence. Ce son grésillant et cradingue sur "In A Frightful State Of Gnawed Dismemberment" n’est pas le fruit d’une approximation. Il guidera Summon The Faithless tout du long au travers de sentiers tortueux et d’atmosphères morbides et psychédéliques. Ces mecs font du Sludge et franchement, faudrait être sourd pour le contester. Seulement voilà, à l’inverse d’HIGH ON FIRE, d’ELECTRIC WIZARD, de DOWN ou de KYLESA, LORD DYING se sépare de toute influence trop sudistes ou Stoner pour ne garder que la moelle épinière de la bête. Des rythmiques lourdes qui rappellent constamment que le Sludge est un croisement de Doom et de Punk / Hardcore, un chant brut de décoffrage, un peu laxiste mais sans rajouts ni retouches et pour finir, des nuances de Heavy éparses et subtiles qui ajoutent du contraste au contraste. Assurément, LORD DYING connaît son métier et ne semble pas réellement forcer pour instaurer un climat délétère et captivant au cœur de son œuvre. Summon The Faithless déroule avec une relative aisance, peut-être dérangeante quand on entend la facilité avec laquelle s’exécute "Dreams Of Mercy" mais preuve surtout d’une grande richesse artistique. Pas de compromis, ces messieurs ressemblent fort à de très mauvais communicants mais leur musique touche à l’essentiel. Ce Sludge là n’est pas revisité ni remanié mais il suffit à faire patienter en attendant des nouvelles de ce qui est pour moi le plus grand et plus influent groupe de Sludge de cette maudite planète : 16 ! C’est donc quelque chose de relativement gratifiant d’être rattaché à ce nom et pourquoi pas, 16 se faisant désormais vieux, LORD DYING pourrait bénéficier d’un ou deux derniers conseils avant de reprendre le flambeau. C’est tout le mal qu’on peut leur souhaiter après un premier album plus que correct mais loin d’être culte.
Quant au fait de relativiser la chose, s’il ne faut pas écarter cette hypothèse, LORD DYING n’étant qu’au début de sa vie de groupe, on ne prendra pas de risque inconsidéré en affirmant que leur route est déjà plus ou moins tracée. Ainsi, le challenge sera aussi de savoir sortir des idées reçues pour ne pas rebooter encore et encore les inébranlables Pain Of Mind, Curves That Kick, Take As Needed For Pain ou Blind. On tient les paris ?
Ajouté : Dimanche 23 Février 2014
Chroniqueur : Stef.
Score :  
Lien en relation: Lord Dying Website
Hits: 5176
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
