#
# 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
}
RHAPSODY OF FIRE (it) - From Chaos To Eternity (2011)
Label : Nuclear Blast
Sortie du Scud : 17 juin 2011
Pays : Italie
Genre : Fantasy Metal
Type : Album
Playtime : 9 Titres - 57 Mins
RHAPSODY OF FIRE n’a jamais été autant prolifique depuis son « grand retour ». Souvenez-vous, le combo italien s’était retrouvé mêlé à une sombre affaire juridico-bordélique avec le label de Joey DeMaio (MANOWAR) qui avait décidé de les prendre sous son aile … pour leur plus grand malheur.
De ce fait, dès que la paire Luca Turilli / Alex Staropoli a retrouvé la liberté, RHAPSODY OF FIRE a pu enchaîner sur un album (The Frozen Tears Of Angel) et un EP (The Cold Embrace Of Fear), le tout dans la même année, mais pour un résultat bien en dessous de ce qu’on espérait après des mois d’absence. Certes, avec un peu de recul, RHAPSODY OF FIRE a su mettre au monde quelques nouvelles pépites (« Sea Of Fate » et « Raging Startfire » sur The Frozen Tears Of Angel, ou encore « Erian’s Lost Secrets » sur The Cold Embrace Of Fear). Mais venant d’un groupe qui a un jour accouché des superbes Symphony Of Enchanted Lands, Dawn Of Victory ou Triumph Or Agony, le public attend tellement mieux. On conseille alors, en général, à ses idoles de se reposer un peu et de prendre son temps pour revenir avec un VRAI album. Chez RHAPSODY OF FIRE, attendre, on n’aime vraiment pas ça. Alors From Chaos To Eternity déboule en moins de temps qu’il n’en faut pour le dire, quelques mois plus tard.
Doit-on considérer l’impatience de nos Italiens préférés comme un vilain défaut ? Le fait est que RHAPSODY OF FIRE sort, avec From Chaos To Eternity, son neuvième album. Que la créativité de Turilli et Staropoli ne semble pas s’essouffler. Que la détermination avec laquelle ils persistent à prolonger cette aventure symphonique, chevaleresque et épique force le respect. Quatorze ans après Legendary Tales, RHAPSODY OF FIRE a encore des choses à dire …
Une fois n’est pas coutume, c’est le légendaire Christopher Lee qui ouvre le bal, dans son rôle de narrateur à la voix grave. Et d’emblée, un constat s’impose. Une guitare diabolique s’invite et donne le ton : jamais, mais alors jamais un album de RHAPSODY OF FIRE n’avait donné lieu à autant de démonstrations techniques. Les parties rythmiques de Turilli sur le titre éponyme renvoient aux vieux HELLOWEEN (lorsque Kai Hansen et Michael Weikath tricotaient à la vitesse de la lumière), quand le beau guitariste ne se gêne pas pour rappeler quel virtuose il est, doit-on le rappeler, par le biais de soli très inspirés (dont un monumental sur « Tornado »). Au sein d’une production aérée et intelligente, c’est la basse de Patrice Guers qui ressort grandie. Alex Staropoli (claviers), lui, fait preuve de tout son talent sur un virevoltant « Tempesta Di Fuoco ». Le monstrueux Alex Holzwarth, à la batterie, s’autorise même des parties très agressives sur le maléfique « Aeons Of Raging Darkness ». RHAPSODY OF FIRE aime d’ailleurs s’aventurer sur des terres plus hostiles, puisque sur ce même morceau, Fabio Lione (chants, parfait tout au long de l’album) se risque une fois encore au chant typé « Black Metal ». Le résultat ne s’avèrerait pas si efficace sans une ambiance des plus travaillées, un climat horrifique que l’on retrouve à plusieurs reprises (« Ghosts Of Forgotten Worlds »). On reste très loin d’un album de Black, mais au moins note-t-on une vraie audace, qui donne à ses auteurs un sentiment de diversification musicale.
Quelque part, on préfère 100 fois RHAPSODY OF FIRE lorsqu’il se « retrouve ». Quand les chœurs épiques embrasent le refrain, quand les orchestrations démesurées envahissent chaque couplet, quand les influences néo-classiques ressortent au grand jour, quand les flûtes côtoient les guitares saturées … Quand les énormes « I Belong To The Stars » (un mid-tempo à la mélodie entraînante et au refrain ravageur !!!), « From Chaos To Eternity » et « Tornado » donnent envie de grimper à cheval et d’aller en découdre avec le monde entier. Histoire de terminer en beauté et de façon grandiloquente, une habitude, RHAPSODY OF FIRE nous offre « Heroes Of The Waterfall’s Kingdom » et ses 19 minutes.
Un mot sur la pochette, superbe, encore une fois l’œuvre de Felipe Machado Franco. Voyez-vous, au milieu de brûlants démons, cet ange si pur, sur sa monture resplendissante et armé d’une épée, qui semble s’extirper du Chaos ? C’est peut-être tout simplement RHAPSODY OF FIRE qui renaît peu à peu de ses cendres et retrouve progressivement le droit chemin. La route sera longue pour le chevalier fatigué, mais au bout, il y aura la lumière.
Discographie Complète de RHAPSODY OF FIRE :
Legendary Tales (Album - 1997),
Symphony Of Enchanted Lands (Album - 1998),
Dawn Of Victory (Album - 2000),
Rain Of A Thousand Flames (Album - 2001),
Power Of The Dragonflame (Album - 2002),
Symphony Of Enchanted Lands Part II : The Dark Secret (Album - 2004),
Triumph Or Agony (Album - 2006),
Live In Canada 2005 (The Dark Secret) (Album - 2006),
The Frozen Tears Of Angels (Album - 2010),
The Cold Embrace Of Fear (Album - 2010),
From Chaos To Eternity (Album - 2011),
Into The Legend (Album - 2016)
MI Bonus :
RHAPSODY (it) - Fabio Lione (Juil-2004),
RHAPSODY OF FIRE (it) - Luca Turilli (Mars-2010),
LUCA TURILLI'S RHAPSODY (it) - Luca Turilli (Mai-2012),
RHAPSODY OF FIRE (it) - Alex Staropoli (Oct-2013),
Ajouté : Vendredi 27 Mai 2011
Chroniqueur : NicoTheSpur
Score : 
Lien en relation: Rhapsody Of Fire Website
Hits: 12046
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
