#
# 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
}
GLADENFOLD (fi) - From Dusk To Eternity (2014)
Label : Buil2kill Records
Sortie du Scud : 22 avril 2014
Pays : Finlande
Genre : Power Black Metal mélodique
Type : Album
Playtime : 11 Titres - 46 Mins
Quelle belle pochette ! Même si ce genre de visuel n'a rien d'exceptionnel (en plus d'être photoshopé à mort), j'ai toujours la rétine qui frétille à la vue de couleurs chatoyantes. Quoi qu'il en soit, on devine facilement de quelle contrée provient GLADENFOLD : la Finlande. C'est donc dans le pays de WINTERSUN et autre SONATA ARCTICA que ces gaillards ont fait germer leur musique. Même si la formation existe depuis un petit moment déjà (2003), il aura fallu attendre plus d'une décennie pour voir apparaître ce premier album, From Dusk To Eternity. Bon, il n'y a pas cinquante options qui s'offrent à nous. Soit la formation a cherché à acquérir assez de maturité avant de sortir une grosse production, soit c'est un sacré bordel dans leur emploi du temps. Verdict ?
Même sans être friand de mélodies sucrées à paillettes, je dois bien avouer que From Dusk To Eternity ne m'a pas laissé indifférent. Sans non plus révolutionner le genre, la musique de GLADENFOLD reste bien agréable à écouter. On se surprendra donc à chanter à tue-tête les refrains à la "Game Of Shadow" et ses hurlements un tantinet blackisants. Dans l'ensemble, tous les morceaux présentent ce qu'on peut attendre d'une formation de Metal mélodique, que ce soit les orchestrations omniprésentes ou encore le chant épique d'Esko Itälä (pas de doute ils sont bien finlandais). En somme, on pourrait facilement cantonner cette production au rang de simple bon moment à passer. Mais arrivé à la moitié de l'album, c'est un "Starforge" de toute beauté qui se fracasse contre nos oreilles. Rapide, virevoltant, bondissant, en bref, c'est LE morceau à écouter en priorité pour pouvoir se plonger dans l'univers de From Dusk To Eternity. Avec sa technicité et son aura lumineuse, cette piste vous fera remuer la crinière sans problème. A partir de là, on évitera de se poser davantage de questions. Cette production est de qualité et offre de bien belles perspectives quant à l'avenir des finlandais. GLADENFOLD propose ici une musique riche et touchant à plusieurs styles ("Bloodfeather" qui tire un peu sur le Folk) sans pour autant s'éparpiller. Il est clair que si le style mélodique n'est pas votre tasse de thé, ce n'est pas la peine de tenter l'aventure. Même si on a parfois droit à des atmosphères très inquiétantes à la "Six Soldiers Stand", From Dusk To Eternity mise avant tout sur la beauté et la chaleur.
Il n'y a plus qu'à espérer que ce jet va permettre au groupe de continuer sur sa lancée. Là où on n'attendait pas forcément grand chose d'une formation de ce calibre, GLADENFOLD nous apporte un album carré, composé avec passion et qui pourrait facilement rivaliser avec les professionnels du genre. Nul doute qu'avec une telle inspiration, ces finnish vont grandir vite, très vite. Et j'espère bien pouvoir me trouver aux premières loges pour voir ça.
Ajouté : Dimanche 11 Juin 2017
Chroniqueur : Nash
Score : 
Lien en relation: Gladenfold Website
Hits: 6213
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
