#
# 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
}
SUNKEN (FRA) - Flooded (2005)
Label : Mono-Emotional Records
Sortie du Scud : 2005
Pays : France
Genre : Metal / Hardcore
Type : EP
Playtime : 6 Titres - 26 Mins
SUNKEN est un dossier. Pardonnez du peu, mais le line-up qui a fait de cet EP de Groove Metal l'énigme qu'il est devenu a quand même depuis écumé les gros noms de la scène bordelaise, parmi lesquels des pointures aujourd'hui reconnues (inter)nationalement. On y retrouve Nico (guitare), qui a trainé ses guêtres au sein de GORGASM (désormais GOROD) vers 2002. On y retrouve aussi Seb (chant), toujours dans SILICIUM aux dernières nouvelles. On y retrouve surtout Manu, le même qui tient la basse pour DEMENTED sur les albums Fields Of Suffering (2010) et Across The Nature's Stillness (2012) et qui vient d'intégrer OTARGOS sous son nom civil : Manu Pliszke. Quel chemin parcouru par certains, qui n'utilisaient finalement SUNKEN que comme un prétexte un peu léger pour se frotter à la dure loi du studio et de la scène. D'ailleurs, je préfère cette tournure des évènements, puisque Flooded, avec beaucoup beaucoup de recul, va se révéler être un EP pas franchement inoubliable.
Entre Groove Metal, Hardcore et Modern Metal énervé, cette sortie a néanmoins le mérite d'avoir forgé ses musiciens, puisqu'on appréciera tout autant le jeu de basse de Manu, précoce s'il en est, que la puissance vocale de Seb, qui ferait assurément le bonheur d'un groupe moins underground que SILICIUM (mais c'est une autre histoire). Avec ce relief qui le rapproche parfois d'un Post-Hardcore usant ("Realize"), parfois d'un Death Metal des familles ("My Mythomane"), Flooded joue en permanence sur les rythmes, la sensation de vitesse, l'opacité de son Metal, adoptant une teinte naturellement sombre. C'est principalement cette absence de lumière qui détruit le peu d'engouement qu'on manifestera à leur égard. Il y a les mauvais choix ("Alone", justement très seule dans la tracklist) et les erreurs d'appréciation ("La Frontière"). Cafouillant un ersatz de SLIPKNOT, d'HATEBREED et de PANTERA, SUNKEN se retrouve embarqué bien malgré lui dans un vaisseau qui navigue à vue, sans réelle destination ni disposition. Du coup, peu de lisibilité pour l'auditeur, qui n'aura réellement le temps que d'apprécier la fureur volcanique du combo. Seule certitude dans cet océan d'abstrait : SUNKEN est une formation survoltée qui alterne entre structures mazoutées et Hardcore bas du front. Une énergie d'autant plus appréciable quand elle prend une tournure plaisante. Je pense à surtout "So Far", le morceau le plus long de l'EP (9 minutes 30) et étrangement, celui qui déroule avec le plus de fluidité, fort de ce riffing épileptique qui n'est pas sans évoquer le Djent tel qu'on le côtoie aujourd'hui. Il aura fallu endurer un parcours du combattant, accepter de déambuler dans l'inconnu, avant de tomber sur une composition rassurante. Honnêtement, c'est pas cher payé.
Si cet EP venait juste de sortir, j'aurai pris le temps de m'inquiéter. Mais voilà bientôt dix ans que Flooded s'est fait oublier. On peut comprendre aujourd'hui pourquoi. Autre niveau, autres carrières, certains des musiciens de SUNKEN ont depuis eu la bonne idée de filer très bon coton, histoire de ne pas rester sur cet essai, qui revêt malgré lui de relatives allures d'échec...
Ajouté : Mercredi 18 Février 2015
Chroniqueur : Stef.
Score :  
Lien en relation: Sunken Website
Hits: 4968
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
