#
# 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
}
LAMB OF GOD (usa) - The Duke (2016)
Label : Nuclear Blast
Sortie du Scud : 18 novembre 2016
Pays : Etats-Unis
Genre : Groove Metal
Type : EP
Playtime : 5 Titres - 22 Mins
"The Duke" est une chanson écrite par Randy Blythe en hommage à Wayne Ford, un fan américain décédé en juillet 2015 d'une leucémie. Il était âgé de 33 ans. Trois années avant son décès, Wayne a assisté à un concert de LAMB OF GOD à l'occasion duquel il a fait la connaissance de Randy Blythe. Trois ans plus tard, pendant que le groupe enregistre VII : Sturm Und Drang, Wayne Ford a repris contact avec Randy Blythe. Après 36 mois passés en hospitalisation sans que sa situation se soit améliorée, Wayne avait décidé de quitter l'hôpital pour retourner vivre ses dernières semaines en compagnie des siens. Le chanteur et son fan ont eu une longue conversation téléphonique à l'issue de laquelle Wayne a été invité à assister à distance à l'enregistrement des pistes de chant du hurleur pour le prochain album. Les deux amis ont encore échangé quelques mail avant que Wayne ne décède. L'histoire de cette chanson est longuement racontée par le chanteur sur le site internet de LAMB OF GOD.
"The Duke" est une chanson à message. Un message chargé d'émotion et servi des paroles fortes à la fois fatalistes et pleines d'espoir : "No one live forever but you can't escape from life / every day could be the list so consider your demise". Pour l'occasion, les couplets sont interprétés en chant clair, doublés par moment par l'inimitable cri enragé de Randy Blythe. On pourrait craindre que cette option desserve ou affaiblisse le propos, que la chanson ne sonne pas comme du LAMB OF GOD. Mais que les fans se rassurent, il n'en est rien. Bien au contraire, c'est un pur joyau de LOG auquel le chant clair donne une résonnance particulière, bien moins bas du front que le reste du répertoire des américains.
"The Duke" aurait pu figurer sur VII : Sturm Und Drang, mais le groupe a choisi de ne pas inclure la chanson à la tracklist. Le morceau est donc publié sur un EP qui sort presque 18 mois après l'album. La chanson aurait tout aussi bien pu sortir en single inédit, le choix de l'EP est étonnant. C'est la première fois que la formation utilise ce format. Certes, ce disque permet de donner un support "physique" à la chanson titre, et au label d'en sortir plusieurs déclinaisons pour les fans, mais pour qu'il ait du sens, il faut que le reste de la tracklist présente un intérêt. Par exemple, puisque Randy Blythe s'essaye au chant clair et à une compo plus mélodique que le répertoire habituel des américains, pourquoi ne pas continuer sur la lancée en enregistrant d'autres chansons sur le même mode ? On pourrait comprendre que le gang n'en fasse pas tout un album, mais pour une formation installée et reconnue, le choix du format EP peut justement servir à ouvrir une nouvelle voie, en mode test. Oser quelque chose en petite série pour prendre la température de la fanbase avant une sortie grandeur nature.
Malheureusement il n'en est rien. Le soufflé retombe très vite car les quatre autres pistes de The Duke sentent le remplissage à moindre frais.
Si le combo avait sorti un 45 tours "Culling" aurait fait une Face B honnête. C'est une chanson sans grande originalité, qui reprend les ingrédients signature du combo. Elle est éclairé par un beau petit solo de guitare (tout comme "The Duke") mais n'apporte pas grand chose à leur discographie et vous l'aurez bien vite oubliée.
Enfin, quand on n'a pas d'idées pour boucler un EP, les deux possibilités sont l'enregistrement de cover ou les extraits de concerts. C'est ce choix que fait LOG puisque les trois dernières pistes sont des extraits de la tournée de concerts promotionnels de VII : Sturm Und Drang enregistrés au Rock Am Ring et à Bonnaroo. Ces trois morceaux sont assez pauvrement mixé. Le tout est emballé dans un artwork aussi laid qu'une pochette de bootleg, en nuances de gris baveuses, comme si le label avait bossé à l'économie, investissant le moins possible sur ce disque.
Si sa chanson titre est une vraie bonne surprise, le reste manque carrément d'audace et de corps. Cet EP qui sent le réchauffé n'apporte rien à une discographie déjà bien pourvue en grosses mandales. Moitié fan service, moitié disque promotionnel pour montrer aux tourneurs et aux radios que le groupe a une actualité, The Duke est l'archétype d'un EP raté.
Ajouté : Dimanche 30 Avril 2017
Chroniqueur : Rivax
Score : 
Lien en relation: Lamb Of God Website
Hits: 5142
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
