#
# 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
}
NANOWAR (it) - Into Gay Pride Ride (2010)
Label : Auto-Production
Sortie du Scud : septembre 2010
Pays : Italie
Genre : Heavy Metal Parodique
Type : Album
Playtime : 16 Titres - 53 Mins
Contrairement à ce que l’on pourrait croire, la blague de potache est un art majeur, dont il convient de respecter toutes les limites sous prétexte de tomber dans la gaudriole et le non sens affligeant de médiocrité. Première condition pour en maximiser la portée : avoir du talent. Seconde condition : prendre tout le recul nécessaire pour ne pas tomber dans le pastiche répétitif trop facile qui lasse. Et c’est pour ça que Y’a-t-il Un Pilote Dans L’avion sera toujours plus drôle que l’énième resucée de Scary Movie.
Ca, NANOWAR l’a bien compris. Et c’est pour cela que Into Gay Pride Ride est drôle. Parce que les musiciens sont tous d’un très bon niveau instrumental, et qu’ils ont un solide sens de l’humour, basé sur l’inventivité, et non le démarquage pur et simple.
Et c’est aussi parce qu’ils aiment ce qu’ils font, et ce qu’ils parodient. Ils ne sont pas juste là pour foutre le bordel et tourner le Metal en dérision, mais à l’instar de SPINAL TAP, ils soulignent les travers un peu trop virils de certains de nos combos de prédilection, je veux bien sur parler des MANOWAR, RHAPSODY et autres HAMMERFALL, qui confondent parfois amour de l’acier et reconstitution Moyenâgeuse en carton pâte.
Alors forcément, avec une telle attitude, on tombe souvent sur des perles hilarantes, qui témoignent de la grande culture musicale des gus, qui savent en plus, fondre des styles diamétralement opposés au sein d’une seule et même compo.
Si vous ne me croyez pas, jetez une oreille sur l’énorme « Odino & Valhalla », qui mixe le meilleur de RHAPSODY, avec le solo et les chœurs de Kaoma (« La Lambada »…), et un pont emprunté d’une manière éhontée à PINK FLOYD.
« Blood Of The Queens », outre son propos très menstruel, se permet de citer l’intemporel « What a Wonderful World » de M.Amstrong, et ce, de manière impeccable. Quant à la fausse ballade « Surprise Love », elle parodie autant les Boys Band des années 90 que Shaggy, tout en offrant une mélodie parfaite et entêtante (on a même doit à la descente de toms du « I’d Die For You » de BON JOVI !).
Mais tout vous révéler vous gâcherait le plaisir, et il est hors de question que je me substitue à vous pour découvrir cet album qui, on peut le dire, est une réussite totale de bout en bout.
NANOWAR a de plus eu l’idée géniale de parsemer Into Gay Pride Ride d’inserts réguliers, qui ventilent l’ensemble, proposant parfois des idées carrément géniales, comme ce dialogue entre un père et son fils, qui tourne à la démonstration crooner irrésistible.
Alors, les non anglophones auront parfois du mal à saisir toute l’ironie précieuse du propos, mais la lecture du livret devrait les aider sans peine.
Equivalent « rose » d’ULTRA VOMIT chez nous, NANOWAR (OF STEEL, particule rajoutée pour bien se foutre de RHAPSODY (OF FIRE)…), est un groupe indispensable, qui n’a pas oublié qu’avant de se moquer d’autrui, il fallait d’abord avoir une identité solide, et des moyens techniques équivalents, sinon supérieurs.
Into Gay Pride Ride s’écoute d’une traite, et se réécoute avec plaisir, d’une part parce que les chansons tiennent debout en tant que telles avant d’être des blagues, et parce que leur humour est bien senti, et tape toujours juste là où ça fait mal, mais paradoxalement, sans méchanceté aucune.
Ajouté : Mercredi 23 Mars 2011
Chroniqueur : Mortne2001
Score : 
Lien en relation: Nanowar Website
Hits: 11439
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
