#
# 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
}
RUNNING WILD (de) - Branded & Exiled (1985)
Label : Noise Records
Sortie du Scud : Décembre 1985
Pays : Allemagne
Genre : Heavy Speed Metal
Type : Album
Playtime : 8 Titres - 34 Mins
RUNNING WILD ! Tout un programme pour cette légende du Heavy Metal teutonique ! Le groupe qui lança la mode du pirate, des corsaires et autres flibustiers ! A l’abordage ! Des albums cultes comme Under Jolly Roger ou Port Royal authentifieront bien plus tard ce tournant thématique et musical. Mais bien avant cela, RUNNING WILD, formation allemande vénérée originaire de Hambourg conduite et guidée par une main de fer en la personne du démiurge Rock’n’Rolf Kasparek œuvrait dans un Metal, dirons-nous, plus occulte et ténébreux. Et ce n’est pas le chimérique Branded & Exiled jailli du magma du centre de la terre en 1985 qui fera dire le contraire. En ce milieu des années 80, face à la déferlante des groupes de Thrash de la Bay Area (METALLICA, EXODUS, etc.), RUNNING WILD démontrait que la scène issue de l’autre côté du Rhin rencontrait un regain de forme et pouvait rivaliser avec les formations britanniques et américaines. La fête de la bière à Munich, ok, mais avec de bons gros riffs alors ! Les germains, ils aiment bien déconner avec un bock de cervoise à la main !
Après un Gates of Purgatory prometteur sorti juste un an plus tôt, RUNNING WILD poursuit son bonhomme de chemin en amplifiant même la puissance de feu dans les rythmiques lourdes et véloces comme l’illustrent des morceaux Heavy cultes tels que «Realms of Shades» ou «Marching to Die» tandis que les parties vocales de S.A.S. Rock’n’Rolf sont encore graves et dramatiques mais parfois annonciatrices du Speed Metal dont le groupe sera bientôt l’un des plus respectable fers de lance ! Mais cela ils ne le savent pas encore. Ainsi, les titres à consonance Speed débarquent sous la forme de hits tels que «Fight The Oppression» et «Gods of Iron» qui posent là les jalons d’un style dont les allemands seront friands. Dans le même temps, le quartet savait également proposer des mid-tempos ravageurs pour l’époque avec «Evil Spirit» et surtout le titre Tolkinien «Mordor» au final dantesque qui aurait presque mérité de figurer dans la BO d’un des Seigneurs des Anneaux lors d’une bonne scène de baston générale ! Faciles mais ô combien énergiques, les morceaux de cet album sont intemporels bien que la production ait pris un sale coup de vieux depuis le temps.
Edité chez Noise Records qui était en quelque sorte le label en vogue durant ces années 80 en Europe, rien qu’à en juger aux groupes distribués par le label (KREATOR, TANKARD, VOIVOD, DRAGONFORCE, CELTIC FROST, etc.), le spectre sonore des années 80 se fait cruellement sentir sans pour autant bouder notre plaisir. Au bout de deux albums, RUNNING WILD a semble t-il fait le tour de la question occulte et obscure pour se diriger vers des thèmes plus aventureux et intrépides ! Le plus sombre des albums de RUNNING WILD, l’un des meilleurs à mon humble sens également ! Un tournant dans l’histoire du Heavy Metal européen ! A posséder absolument pour tout fans de Heavy qui se respecte ! Précurseur d’un futur Ready for Boarding !
Ajouté : Lundi 15 Octobre 2007
Chroniqueur : Loki
Score :  
Lien en relation: Running Wild Website
Hits: 14071
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
