#
# 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
}
MOB RULES (de) - Radical Peace (2009)
Label : AFM Records / Underclass
Sortie du Scud : 13 novembre 2009
Pays : Allemagne
Genre : Power Metal mélodique
Type : Album
Playtime : 7 Titres - 52 Mins
Au moment de rebaptiser son BLACK SABBATH avec Ronnie James Dio au micro, le père Tony Iommi n'a pas franchement eu le choix. Comme le nom de MOB RULES était déjà pris, il ne restait plus que les albums Heaven & Hell et Dehumanizer, avec le résultat que l'on sait ... Car mine de rien, le combo germanique MOB RULES n'est pas tombé de la dernière pluie. Fondé en 1994 par le guitariste Matthias Mineur, le sextet présente quand même avec Radical Peace sa sixième offrande studio (il existe aussi un live datant de 2005 et nommé Signs Of The Time).
MOB RULES n'a, en dehors de son nom, aucun autre point commun avec BLACK SABBATH, puisque niveau musique on officie ici dans un Power mélodique assez typique de toute la vague germanique. D'entrée, avec "Children Of The Flames", MOB RULES donne le ton : deux médiators qui font résonner des cordes étouffées, un clavier qui sonne comme un orgue, quelques influences orientales bienvenues, un brin de désespoir (ce titre parle des atrocités commises sur les enfants déportés dans les camps), et même si "Children Of The Flames" aurait gagné à être plus court pour un morceau d'ouverture, l'opération séduction est rondement menée.
Le single, "Astral Hand", s'avère idéalement choisi : ça commence comme une ballade celtique avant d'envoyer un bon Power digne du HELLOWEEN d'Andi Deris voire d'AXXIS. Radical Peace regorge d'influences respectables et d'éléments qui font mouche à coup sûr : MOB RULES aime les harmonies vocales, les refrains accrocheurs (du single à "The Glance Of Frame" en passant par "Trial By Fire"), les compos rapides ("Waiting For The Sun"), les mélodies plus ralenties et même mélancoliques (le superbe "Warchild" et son magnifique solo), les intros à la MAIDEN ("Trial By Fire") et son chanteur, Klaus Dirks, module sa voix suivant le contexte, évoquant fréquemment les pointures du genre (Tobias Sammet, Andi Deris, entre autres).
Evidemment cette diversité à tous points de vue traduit un certain manque de personnalité, mais finalement cela rend Radical Peace très équilibré. Le véritable faux pas viendrait plutôt de la pièce épique "The Oswald File", qui s'étend sur plus de 18 minutes, avec une intro au piano interminable et entrecoupée de longs temps morts. Le propos aborde un sujet intéressant (l'assassinat de JFK et l'enquête sur Harvey Lee Oswald) mais au bout du compte, "The Oswald File" casse le rythme de l'album, au risque même de s'en détacher complètement et de passer à côté des deux derniers titres. N'est pas Tobias Sammet qui veut ...
Dommage car avec un peu plus de lucidité dans l'ordre donné aux chansons (exemple : placer "The Oswald File" en dernière plage), on tenait avec Radical Peace une excellente surprise dans le genre.
Elle n'est "que" très bonne.
Et c'est déjà pas mal.
Tracklisting :
1 – Children Of The Flames
2 – Trial By Fire
3 – Warchild
4 – Astral Hand
5 – The Oswald File
6 – Waiting For The Sun
7 – The Glance Of Fame
Ajouté : Mercredi 10 Mars 2010
Chroniqueur : NicoTheSpur
Score : 
Lien en relation: Mob Rules Website
Hits: 10337
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
