# Copyright (C) 2002-2004 gregoire HUBERT.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# Author : gregoire HUBERT
#
# 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;
}
}
# Copyright (C) 2003-2004 gregoire HUBERT.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# Author : gregoire HUBERT
#
# 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
}
IMMOLATION (usa) - Majesty And Decay (2010)

Label : Nuclear Blast / Pias
Sortie du Scud : 5 mars 2010
Pays : Etats-Unis
Genre : Death Metal
Type : Album
Playtime : 12 Titres - 45 Mins
Avec IMMOLATION, on sait où on va ! Et une chose est sûre, ce n’est pas droit dans le mur. Voilà bientôt un quart de siècle que les new-yorkais œuvrent au profit du monument Death Metal. Ils l’ont déjà érigé, soigné, embelli et aujourd’hui, ils le restaurent. Ce Majesty And Decay sera le béton qui viendra colmater les brèches, le magma en fusion qui baptisera les sceptiques. Le line-up est stable depuis maintenant huit années, autant dire que le quatuor se connaît sur le bout des doigts et marche dans la même direction. Il y a comme ça, des groupes qui, sans faire de bruit ni tapage médiatique, se sont glissés au sommet de l’affiche et règnent sans vraiment le vouloir sur un empire vaste à la mécanique huilée. IMMOLATION en est, et je vous mets au défi de trouver ne serait-ce qu’une faille handicapante dans la discographie des ricains. Régularité et puissance. Majesty And Decay.
Je crois même que si un jour, on devait écrire les lettres de noblesse du Death sur papier libre ou rédiger le cahier des charges du Death, on ferait appel à IMMOLATION pour diriger la rédaction, tant le combo connaît et maitrise son sujet. Ne vous attendez pas à des envolées mélodiques, à des frasques techniques ou à des futilités sans intérêt. Tout ce qui ne sert pas à te défoncer la gueule ne fait pas partie de cette potion magique. Ainsi, les grosses guitares vicieuses et rentre-dedans sont de sortie. Sans concessions, sans compromis, sans pitié, Rob et Bill s’en donnent à cœur-joie dans le riff bâtard et « in your face ». Il n’en découle pas tant que cela une violence à proprement parler mais davantage une grandeur imposante, une forme de respect. Ce sentiment de classe suprême qui fait qu’IMMOLATION, une fois de plus, survole sa copie. Les américains appuient là où ça fait le plus mal : le cœur. Ils savent parfaitement varier leur jeu et leurs ambiances, n’hésitant pas à placer une interlude ou un composition grandiloquente et plus hypnotique telle que l’éponyme. C’est un fait, le quatuor a beaucoup d’aisance et de métier dans les jambes. Les rares solos (« A Thunderous Consequence ») sont brefs et humbles, toujours soignés. Ross Dolan, s’il se fait plutôt discret derrière sa basse, va chercher les notes les plus gutturales possible du fond de son gosier. Sans retouches apparentes, son chant est impressionnant de profondeur et donne un relief vraiment intéressant à l’ensemble. Tout comme le jeu de batteur de Steve, un peu old-school sur lequel il n’y a vraiment rien à redire. IMMOLATION se montre ici un rien plus dynamique que sur Shadows In The Light et dévoile des compositions tantôt raffinées (« Majesty And Decay »), tantôt brutales (« Power And Shame ») qui affirment définitivement Masjesty And Decay comme classique parmi les classiques. Pourtant, cet album est ce qu’il est, un disque de Death… bon, certes, mais dépourvu de l’étincelle qui pourrait lui permettre de côtoyer les cimes… comme tout album de Death pur et dur, soit dit en passant.
In fine, IMMOLATION est resté fidèle à ses principes, sans grandes surprises. D’ailleurs, si vous êtes en quête d’un quelconque effet de surprise, je vous conseille de passer votre chemin. Majesty And Decay n’est que le fruit de vingt-quatre ans d’expérience au plus au niveau du Death Metal et cette maturité, en plus d’être flagrante, vous fait ravaler votre égo. Celui qui viendra faire chuter IMMOLATION de son trône n’est pas encore arrivé. Définitivement, la majesté sans la décadence.
Ajouté : Mardi 20 Juillet 2010 Chroniqueur : Stef. Score :     Lien en relation: Immolation Website Hits: 10322
|