# Copyright (C) 2002-2004 gregoire HUBERT.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# Author : gregoire HUBERT
#
# 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;
}
}
# Copyright (C) 2003-2004 gregoire HUBERT.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# Author : gregoire HUBERT
#
# 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
}
TROPHALLAXY (ch) - Resilience (2013)
Label : Auto-Production
Sortie du Scud : 28 mars 2013
Pays : Suisse
Genre : Power Metal symphonique
Type : Album
Playtime : 12 Titres - 56 Mins
Que de chemin parcouru pour TROPHALLAXY depuis Unfairytale ! Vous le savez, je ne renonce jamais à me la péter un peu et ce lundi s’annonce bien pour moi car aujourd’hui plus que tout autre jour, les Suisses m’offrent une superbe occasion de ramener ma science. Ça va maintenant faire cinq ans que le nom TROPHALLAXY m’est familier. J’ai découvert le projet lors de l’été 2008 avec la démo susnommée, généreuse, agréable, mais bourrée d’amateurisme. Puis pour une raison que j’ignore encore, j’ai eu envie de poursuivre le suivi en m’accrochant à DawnFall, un premier album bien plus prometteur paru en décembre 2009. J’imagine que de rester scotché par un disque de Power Metal symphonique est une façon originale de faire son outing pour quelqu’un d’habitué au Grind et au Crust… Ou bien encore que de se jeter à cor et à cri sur Resilience, ce second full-lenght dont il sera question dans ce papier, signifie que quelque part, j’ai grandi en parallèle de TROPHALLAXY et qu’avec cinq ans de plus dans le crâne, j’ai bêtement voulu comparer nos progressions respectives. Un raisonnement idiot à reconnaître, mais qui ne saurait être justifié autrement.
Pour être honnête, cette formation helvète ne m’a jamais vraiment lâché. La faute à une seule création. « Lost On A Dying World ». Présente sur la démo Unfairytale, cette composition est celle qui trotte dans ma tête, me répétant « n’oublie pas le frisson que je t’ai donné et grave le nom de TROPHALLAXY dans un de tes deux neurones ». C’est justement pour ce frisson qu’aujourd’hui, Resilience a toutes les qualités d’un grand et tous les défauts d’un petit. Avec cette œuvre, les Suisses restent à leur place, celle d’un groupe en devenir qui construit sur la durée. Il y a un lien extrêmement étroit dans l’écriture entre ces différents morceaux et ceux présents sur DawnFall, comme si Resilience était un prolongement étoffé qui balaie d’un revers de main trois ans et demi de travail et donc, de silence. Qu’on soit d’accord, il s’agit de Power Metal symphonique. Pianos enflammés, arrangements orchestraux, claviers stellaires, cavalcades épiques, violons survoltés, tous les plus beaux atouts du style sont concentrés dans cet opus, qui pousse le bouchon jusqu’à sombrer dans les ambiances moyenâgeuses avec « Hellvetia », se rappelant au bon souvenir des regrettés HAGGARD. « Resurrection », qui s’échappe délicatement d’une boîte à musique, « Living Dead, Dying Alive », absolument magistrale ou encore « Nothing », timide transition, sont autant de moments percutants qui font de Resilience un disque varié. Constamment symphonique mais pas forcément toujours Power, il se démarque également d’une manière bien surprenante, en révélant furtivement des intonations qui penchent vers le Death Metal. C’est bien évidement flagrant dans la voix de Jonathan qui s’occupe des claviers et des « harsh vocals », mais ça l’est encore plus sur certains riffs, qui sont soudainement moins cœur d’artichaut. Je pense notamment à l’ouverture de « The Condemnation », ô combien couillue. Quant à la belle et plantureuse Joëlle Graz, d’album en album, elle s’affirme derrière le micro comme une cantatrice expérimentée, en totale harmonie avec la grandiloquence de la musique proposée. Ça n’a vraiment plus rien à voir avec ce que j’avais connu et je dois bien le reconnaître, c’est bandant d’être déboussolé ainsi.
Que de chemin parcouru pour TROPHALLAXY depuis Unfairytale ! Comment ça je l’ai déjà dit ? Tant pis, je le répète. Vous n’en avez surement rien à faire de mon ressenti personnel et vous avez bien raison. Pourtant, j’espère toujours secrètement vous avoir donné envie à trois reprises de donner sa chance à ce projet, qui en plus d’être talentueux, singulier, créatif, dispose désormais dans son chapeau de l’atout le plus précieux qui soit pour gravir les marches du succès : le professionnalisme. On se reverra une quatrième fois, c’est une certitude.
Ajouté : Jeudi 23 Mai 2013 Chroniqueur : Stef. Score : Lien en relation: Trophallaxy Website Hits: 7722
|