#
# 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
}
POWER TRIP (usa) - Nightmare Logic (2017)
Label : Southern Lord
Sortie du Scud : 24 février 2017
Pays : Etats-Unis
Genre : Crossover
Type : Album
Playtime : 8 Titres - 32 Mins
Quatre ans après leur remarquable debut album, Manifest Decimation (2013), les texans de POWER TRIP remettent une louche avec un deuxième album qui fait comme le premier, mais en mieux.
On retrouve dans ce nouvel opus tout ce qui faisait de Manifest Decimation un disque intéressant : des riff inspirés, un chant enragé, un jeu de guitare lead bluffant, des textes engagés sans être pontifiants, une production respectueuse, où chaque instrument a sa place et une sorte de génie d'écriture qui distingue immédiatement le gang de la masse grouillante des groupes médiocres.
Pour l'occasion, le gang s'est fendu du premier vidéo clip officiel de sa (déjà) longue carrière. Sans surprise, c'est un live filmé de la chanson "Executioner's tax". Trois minutes d'une intensité rare où chaque musicien donne le meilleur de lui même. Les gratteux headbanguent comme des épileptiques, crinière au vent. Le batteur semble avoir douze bras et le chanteur Riley Gale fait des moulinets avec son pied de micro avant d'entonner sa charge cynique contre les religions. Le public bouillant, les stages divers qui se succèdent à un rythme effrayant, le groupe à 2000 pourcents et cette chanson taillée pour la scène auront tôt fait de vous convaincre que POWER TRIP est avant tout un groupe de live. Vous n'auriez pas tout à fait tort. Voir le groupe sur scène est une expérience forte, surtout dans les trois premiers rangs du pit. Mais l'énergie du groupe en live le dispute à la créativité de leurs disques. Dans la fosse ou dans votre salon, POWER TRIP vous offre un voyage en première classe au pays du Thrash. La formation ne réinvente pas le Thrash, ne tente pas une hybridation improbable. Bien au contraire, POWER TRIP fait une superbe synthèse de tout ce qu'il y a de bon dans le Thrash et le Crossover et le restitue avec une maestria remarquable, servie par une prod aux petits oignons.
Ce génie du riff ("Executioner's Tax"), ces intros super léchées ("Soul Sacrifice"), ces soli à 250 km à l'heure ("Firing Squad"), ces lyrics inspirés et intelligents ("Waiting Around To Die"). A l'instar de cet artwork torturé qu'on doit une fois de plus à Paolo "Madman" Girardi (il a déjà signé la pochette de Manifest Decimation), Nightmare Logic est un disque plus cérébral qu'il y paraît.
Le seul reproche qu'on puisse légitimement faire à l'album c'est sa trop grande ressemblance avec son aîné. POWER TRIP semble avoir disséqué Manifest Decimation recherché les bonnes idées, le bon riff, le bon break, la belle transition, la chouette intro et en a amplifié l'effet dans son nouveau projet. Celui-ci n'est pas un un copier coller mais une nouvelle itération, plus puissante, plus mûre. Le fan que je suis a trouvé des passerelles entre les deux disques comme vous pouvez en voir entre Heaven and Hell et Mob Rules de BLACK SABBATH.
En trente trois petites minutes la messe est dite. POWER TRIP négocie avec brio le virage du deuxième album. Il y a dans les compos de POWER TRIP ce petit quelque chose en plus qui distingue les grands groupes des bons groupes. Nightmare Logic en est l'éclatante démonstration.
Ajouté : Dimanche 30 Avril 2017
Chroniqueur : Rivax
Score :  
Lien en relation: Power Trip Website
Hits: 8354
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
