# 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
}
TERRORTORY (se) - The Seed Left Behind (2011)
Label : Discouraged Records
Sortie du Scud : 25 novembre 2011
Pays : Suède
Genre : Death / Thrash Metal Mélodique
Type : Album
Playtime : 7 Titres - 40 Mins
La Suède a beau être le pays du Death Metal Mélodique, cela n’empêche pas certaines formations de patauger un bon bout de temps avant de pouvoir sortir un premier album. TERRORTORY en est l’exemple puisque, formé fin 2000, ce n’est qu’onze ans plus tard qu’ils ont enfin la possibilité de proposer un support concret à leurs idées. Si le groupe était au départ fondé juste pour délirer (en témoigne le patronyme parodique de la scène Death), quelques changements de line-up anecdotiques ont eu vite fait d’y instaurer le sérieux. Ainsi, l’opus qui nous est présenté ici, The Seed Left Behind, est le résultat de cinq années de maturation, dont trois passées en studio depuis 2008.
Tout ce temps leur a donc permis d’affiner leur écriture, d’une qualité indéniable. La tracklist affiche d’ailleurs plusieurs compositions fleuves, aux atmosphères et allures progressistes que l’on sent inspirées d’OPETH. Pour ce faire, les guitaristes ont souvent recours à la distillation d’arpèges solennels, ou légers breaks acoustiques laissant planer une certaine fragilité, au milieu d’une instrumentation qui parvient à trouver le bon compromis entre violence et mélodie. Renforçant le côté ambiancé des titres, de subtiles orchestrations sont disséminées pour ajouter davantage de gravité aux plans dévastateurs. En effet, les riffs de Michael Bergvall se montrent agressifs, accompagnant sans faille les vocaux noirs. Ses jeux pesants et déchiqueteurs ne sont toutefois pas exempts d’harmonies. Qui plus est, Stefan Vidmark met en avant une virtuosité assez Prog dans l’âme, insufflée au sein de la rythmique oppressante (« The Seed Left Behind »). Ses solos ne sont pas tous techniques, mais toujours justement calibrés dans la course des morceaux. En outre, l’usage d’un EBow permet d’apposer de lancinants accords harmonisés désolés à la manière de cordes frottées, telles que sur « Concept: Anarchy ». La paire d’instrumentiste donne donc le ton de ses riffs solides et mélodiques, se confondant avec la basse vigoureuse. Sur les pistes conséquentes, les Suédois essaient au possible d’amener différentes variations à leurs épopées, organisant les structures de telle sorte à captiver l’auditeur et ne jamais laisser apparaître une once d’ennui. Quant aux morceaux plus courts, ils affirment aussi un caractère épique dans leur approche, de par les lignes expressives des six cordes et d’une dynamique imparable.
La production n’est pas d’une netteté immaculée, mais possède un grain rocailleux qui intensifie la puissance de la basse saturée et monstrueuse d’Olov Häggmark. Le son est lourd, mais organique, déambulant sous diverses latitudes pour nuancer la base Death/Thrash nordique. A l’instar de « DeReign », la cadence évolutive illumine le parcours soigné emprunté par les cordes grondantes. Les riffs délivrés sont massifs et concordent avec les impacts explosifs lâchés par Peter Hägglund. Lui-aussi est responsable de la véhémence impressionnante prédominante. De sa batterie, où chaque composant ressort allègrement, il s’élance sur des allures viles et enragées que les blast beats intensifient sans peine, en compagnie des accords mastodontes (« The Destroyer »). En dépit du ton imposant établi par celle-ci, la basse sait également se faire groovy en secondement de syncopes marquées, comme sur « I, You ». Les célérités des plages ne sont jamais constantes et quelques fluctuations permettent de dispenser des atmosphères captivantes, au travers des breaks, mais aussi de l’influence du chant hargneux.
Dernier élément participant à la bestialité des titres, mais également à leur affliction : les vocaux de Johan Norström. Sa voix tire ses racines des années 90, avec des pointes Black râpeuses qui peuvent faire penser à Mikael Stanne. La prestation du frontman apparaît impulsive, et d’un incroyable charisme. Ses hurlements déchirés se révèlent démentiels, notamment grâce au support des riffs gras, sans pour autant être désagréables à la longue. Malgré le peu de variations dans la tonalité, Johan offre un chant extrême suffisamment manifeste pour partager son accablement. Même les refrains ne sont pas forcés et tombent sous le sens. Certains, tel celui de « The Soils Turn Red », atteignent leur paroxysme avec la présence du growl abyssal de Stefan en backing, qui se fait aussi entendre sur quelques couplets pour densifier l’atmosphère. Qui plus est, Johan laisse parfois échapper des phrases claires qui, loin d’être niaises, sont plutôt une addition bienvenue dans leur tonalité désespérée. On en retrouve aussi bien lors des breaks acoustiques, qui deviennent à la fois intimistes et augustes, qu’en travers des sections furieuses. Leur présence est parcimonieuse, et surprend en s’emparant du refrain de « Saviour », dernier titre au tempo impétueux, mais qui profite de cet instant pour révéler une beauté décontenançante.
Loin d’être un groupe parodique, TERRORTORY connaît son terrain sur le bout des doigts et présente, au travers de The Seed Left Behind, un ensemble de compositions musicalement riches et éloquentes. Intelligemment orchestrées, les pistes traversent aussi bien des atmosphères austères et contemplatives, que des vagues rythmiques d’une rare férocité. Ainsi, tirant sa force de jeux sagaces exécutés avec fougue et poésie, ce premier album aux multiples états marque sans conteste de sa puissance émotionnelle.
Ajouté : Mercredi 01 Février 2012 Chroniqueur : CyberIF. Score : Lien en relation: Terrortory Website Hits: 8680
|