#
# 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
}
FALCONER (se) - Among Beggars And Thieves (2008)
Label : Metal Blade / Season Of Mist
Sortie du Scud : 25 août 2008
Pays : Suède
Genre : Heavy Metal Folklorique
Type : Album
Playtime : 11 Titres - 55 Mins
Depuis le temps que je voulais découvrir FALCONER, c’est avec une certaine honte que je vous avoue : ce n’est qu’au bout de leur sixième album que je me suis enfin jeté à l’eau. Pourquoi ne me suis-je pas penché sur le cas de ce combo suédois plus tôt ? Peut-être à cause de cette désagréable sensation de me faire insulter par un type avec un cheveu sur la langue … Je plaisante bien sûr. Avec Among Beggars And Thieves, l’occasion était trop belle, c’était pour moi le bon moment.
Il faut savoir que FALCONER (eh ! toi-même … OK j’arrête là) est né des cendres de MITHOTYN, groupe de « Viking Death Folk Metal », et qu’à la dissolution de ce dernier, le guitariste Stefan Weinerhall a lancé son nouveau groupe avec pour ambition de perdurer dans le Metal Folk, le côté extrême en moins.
FALCONER se veut donc atypique dans la scène Metal actuelle, quoique plus tant que ça avec tous ces groupes aux éléments folk qui émergent de partout, mais ici l’hommage aux périodes médiévales est fortement prononcé. Vulgairement, on pourrait comparer FALCONER à BLIND GUARDIAN … mais en moins bien. Ou alors en différent. Difficile à expliquer. La vraie comparaison avec le Gardien Aveugle tient du fait que les « orchestrations » folk sont le fruit de la guitare de Weinerhall et de la prestation vocale de Mathias Blad. Ce chanteur au timbre si différent d’Hansi Kürsch (on croirait entendre par moment Roy Khan de KAMELOT) se plonge totalement dans son rôle de troubadour et participe activement au paysage musical dépeint par FALCONER.
Cette musique cultive d’ailleurs un certain paradoxe, celui de toujours proposer quelque chose d’original et parfois de flirter avec le ridicule déjà entendu, comme le faisait RHAPSODY (OF FIRE) sur « The Village Of Dwarves ». Je pense notamment à « Mountain Men », où Blad prend son rôle bien trop à cœur. A moins que vous aimiez entonner des « là là là làà là làààààà » sur du Power Metal … Ce titre est également le symbole d’un groupe qui, à force de vouloir enrichir ses titres d’éléments festifs voire dansants, se perd un peu en chemin et nous balance une partition bordélique.
Mais au bout de quelques écoutes, Among Beggars And Thieves passe mieux, beaucoup mieux. D’autant que l’album est également constitué de titres Power plus rentre-dedans, rappelant une fois encore BLIND GUARDIAN, mais celui des débuts cette fois (comme Follow The Blind). Entendre ces power-chords qui résonnent et la voix puissante de Blad a quelque chose de rassurant. Et quand le groupe s’aventure sur un break moyenâgeux, l’effet est divertissant.
Alors clairement, Among Beggars And Thieves ne plaira pas à tout le monde et aurait pu être moins fouillis. Mais il mérite qu’on y accorde un minimum d’attention. « Au moins pour ne pas paffer pour un fale connard étroit d’efprit … »
Ajouté : Mercredi 24 Septembre 2008
Chroniqueur : NicoTheSpur
Score :  
Lien en relation: Falconer Website
Hits: 11611
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
