#
# 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
}
MAGNUM (uk) - Escape From The Shadow Garden (2014)
Label : Steamhammer
Sortie du Scud : 21 mars 2014
Pays : Angleterre
Genre : Hard Rock mélodique
Type : Album
Playtime : 11 Titres - 62 Mins
Depuis sa reformation en 2001, les Britanniques de MAGNUM n'ont pas eu le temps de chômer, puisque le guitariste Tony Clarkin – principal compositeur du groupe – n'a jamais été aussi prolifique. Et dans le bon sens du terme en plus, car On The Thirteenth Day (2012) regorgeait de tubes en puissance. Et contrairement à ce que semble dire la "vox populi", son successeur Escape From The Shadow Garden n'a rien de ridicule en comparaison. On The Thirteenth Day était très direct dans le genre, disons que ce nouvel album mérite un peu plus d'attention et d'écoutes.
Evidemment, débuter par l'excellent "Live ‘Til You Die" est franchement trompeur : ce titre direct au riff efficace semble tout droit sorti des sessions de On The Thirteenth Day (on pourrait faire la même remarque concernant son petit frère "Burning River" qui s'avère beaucoup moins réussi). Du coup, on s'attend à découvrir le même type d'album. Mais MAGNUM maitrise l'art du contre pied, à l'image de "The Art Of Compromise" : on croit écouter une ballade sur le concept voix / claviers, mais tout ce petit monde s'emballe sur un rythme entrainant avec ces chœurs à l'appui dont seul MAGNUM a le secret. Et MAGNUM utilise ce schéma à plusieurs reprises pour faire de Escape From The Shadow Garden un album imprévisible. "Falling For The Big Plan", typique du Rock mélodique à l'anglaise, s'inscrit un peu dans la même lignée que "The Art Of Compromise", avec des débuts timides, un refrain qui rentre bien dans la tête, un solo super bluesy de Clarkin, et surtout le jeu dynamique de Harry James (batterie) qui fait toute la différence. "Unwritten Sacrifice", un poil plus progressif, plus modéré malgré les rythmiques très Heavy de Clarkin, finit quand même par exploser dans tous les sens avec encore une fois des chœurs accrocheurs.
On croit à tort qu'il en sera de même pour "Crying In The Rain", amorcé par quelques mesures tribales. Mais là resurgissent les vieux démons de MAGNUM : voilà le genre de titre progressif – avec des lignes vocales qui s'enchainent difficilement – auquel on accroche terriblement ou alors pas du tout... Bien qu'on préfère voir MAGNUM évoluer dans ses sphères originales plutôt que se vautrer lamentablement en faisant du Rock'n'Roll ("Too Many Clowns"), d'autant que le frontman Bob Catley y montre clairement ses limites. Et à l'inverse, MAGNUM n'a jamais été très doué pour les ballades, la palme de l'ennui revenant à "Don't Fall Asleep" (alors mets plutôt un caleçon, Bob) et à "The Valley Of Tears". "Wisdom's Had Its Day", par le charisme de Catley et les claviers de Mark Stanway, se veut plus poignante et dramatique. Et que dire de l'hymne ultime "Midnight Angel", celle qui entretient l'espoir, celle qui procure cette émotion palpable ? Il n'y a décidément que Tony Clarkin pour écrire des chansons aussi belles...
Alors Escape From The Shadow Garden n'arrive certes pas à la cheville des albums mythiques de MAGNUM, mais il n'a rien de l'album raté comme on voudrait nous le faire croire. Il y a fort à parier qu'on appréciera le fait de redécouvrir cet album et ses titres les plus séduisants dans quelques années. Il est même possible que Escape From The Shadow Garden vieillisse mieux que d'autres galettes du quintet de Birmingham.
Ajouté : Samedi 26 Juillet 2014
Chroniqueur : NicoTheSpur
Score :  
Lien en relation: Magnum Website
Hits: 11790
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
