# 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
}
SONS OF SEASONS (de) - Gods Of Vermin (2009)

Label : Napalm Records / Season Of Mist
Sortie du Scud : 30 avril 2009
Pays : Allemagne
Genre : Dark Metal Symphonique
Type : Album
Playtime : 12 Titres - 65 Mins
Je suis une vraie branque aux échecs ! Autant l’avouer de suite, dès que j’ai vu cette pochette (tout à fait dans mon style, au niveau des couleurs comme du graphisme), je me suis immédiatement dit que si SONS OF SEASONS allait envoyer son plus bel atout faire une partie contre ma pauvre personne, je n’allais pas faire illusion longtemps. Puis j’ai écouté l’album et finalement, c’est eux qui n’ont pas fait illusion longtemps. Mais regardez de plus près cette cover, ne serait-ce pas le joli minois de la belle rousse Simone Simons d’EPICA décorée comme un sapin de Noël ? Je n’en suis pas sur mais il y’a quelques « arguments » charnels qui me font penser que oui, la dame s’est bien prêtée au jeu de la collaboration sur ce premier disque des allemands. Je ne sais pas s’ils en avaient vraiment besoin car rien que leur CV est impressionnant. Oliver Palotai (guitares et claviers), c’est aussi KAMELOT et DORO. Henning Basse (chant), c’est METALIUM et la scène avec GAMMA RAY et FIREWIND tandis que Jürgen Steinmetz, c’est SILENT FORCE. En bref, ces musiciens ne sont ni jeunes, ni inexpérimentés.
Pourtant, c’est de très loin ce qui ressort le plus de ce Gods Of Vermin. On dirait que ces mecs n’ont jamais touché d’instruments de leur vie, tellement ils ont l’air d’avoir peur d’être trop bruyants. Les vocaux d’Henning Basse sont à l’ancienne. On dirait donc un vieillard revanchard (« Wheel Of Guilt »), quand il n’est pas accompagné par des chœurs Heavy ringards. Les guitares auraient aussi matière à faire quelques choses, mais le mixage est étrange. C’est comme si on avait affaire à une grosse voice-over d’une heure. On n’entend que la voix et la musique est passée comme si elle était une musique de fond, secondaire. Par conséquent, il n’y a aucune percussion, aucun rythme. Et encore, si les compositions étaient un peu vivantes, ça aurait pu suffire à dissimuler ces quelques carences, mais à ce niveau aussi, les teutons déconnent. On ne peut décemment pas affirmer qu’il n’y a aucune recherche d’effectuée, mais ça manque de peps et de naturel. Il y’aura bien « Belial’s Tower » ou la très réussie « Dead Man’s Shadows » et ses pianos endiablés pour vous sortir de votre torpeur… Hélas, ces élans de violence sont trop rares et trop souvent entrecoupés par une parodie de Metal Symphonique (« Gods Of Vermin ») pour espérer marquer les esprits durablement. L’apparition des guests est également anecdotique puisqu’on entend brièvement et sans conviction la doublette d’EPICA : Simone Simons / Tijs Vanneste sur la médiocre « Fallen Family » ou la belle rouquine accompagner Henning sur la ballade un peu fluette « Wintersmith ». De plus, les nombreuses pistes de six, sept voire huit minutes ne sont pas là pour me calmer. Je veux bien que ces caractéristiques soient celles du Dark Metal ou du Metal Symphonique en général, mais à l’écoute de « Fall Of Byzanz » ou de « Third Moon Rising », ça fais plus remplissage qu’autre chose.
C’est donc un vrai casse-tête que ce Gods Of Vermin car nous sommes quand même en présence de quatre virtuoses et leurs états de service dans leurs groupes respectifs jouent pour eux. Aussi semble t’il qu’ils aient voulu créer quelque chose de nouveau mais pas forcément d’utile ni d’intelligent. Il n’y a qu’un vainqueur au concours Lépine. Et à cette partie d’échecs, ou j’avais pourtant les deux mains clouées sur la table, j’ai presque envie d’hurler « échec et mat ! ».
Ajouté : Mardi 02 Juin 2009 Chroniqueur : Stef. Score :   Lien en relation: Sons Of Seasons Website Hits: 11575
|