#
# 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
}
IN FREE STRUCTURE (FRA) - Inner Stories (2008)
Label : Auto-Production
Sortie du Scud : 3 juin 2008
Pays : France
Genre : Metal qui tâche
Type : Album
Playtime : 12 Titres - 49 Mins
IN FREE STRUCTURE. Avec un nom comme ça, on se doute que le groupe ne veut pas se laisser enfermer dans un carcan musical particulier. Est-ce ce qu’ils ont réussit à faire ? Oui, plutôt (nan, moi c’est Wong Li… ok, je sors). Ils n’ont pas poussé le vice à se lancer dans des compositions complètement barrées et très difficiles à suivre. Par contre, il est vrai qu’ils mélangent différents ingrédients pour les agrémenter à leur sauce. Et pas forcément des ingrédients provenant de la sphère Metal.
La base de la musique d’IN FREE STRUCTURE, c’est quand même un bon gros Metal qui tâche, rythmiquement chiadé et puissant (« Am I Mad »). Des accords simples et profonds soutenus par une basse qui, même si on ne l’entend pas forcément tout le temps, apporte de la lourdeur à l’ensemble et une batterie bien présente dont la double grosse caisse assène ses coups comme un marteau pilon épileptique. Donc, ça c’est pour la génoise. En ce qui concerne la garniture, on retrouve des influences Ska pour certaines rythmiques (point de trompette dans cet opus), comme sur « Remember », ou encore Techno. Ce sont bien de grosses guitares qui saturent tout ça mais il y a beaucoup d’intentions différentes dans les riffs pour celui qui écoute bien. Après, on retrouve quand même pas mal de passages avec des guitares à effet divers et variés. Delay, flanger et j’en passe et des pas mûrs, qui donne une texture autre aux morceaux. On oscille donc entre de gros passages gras et d’autres plus en finesse. Pas forcément ultra mélodique, mais qui aère la musique du groupe qui aurait pu, sinon, n’être qu’un nouveau groupe au Metal rythmique puissant. Et c’est justement là la force d’IN FREE STRUCTURE. Au niveau du chant, c’est bien hurlé comme il faut avec une soutenance plus claire lors des passages calmes et même certains phrasés Rap qui parsème certains titres. Le chant est principalement en anglais mais on retrouve parfois quelques phrases en bon françois bien de chez nous.
Bon, quelques remarques tout de même. On sent que le groupe a encore une marge de progression sur certains passages qui sont encore un peu bancals. Mais rien qui empêche l’écoute. Par contre, au niveau du son des guitares, il y aurait encore quelque chose à faire. C’est un rien froid, distant. De plus, cela donne un grain assez propice à déceler les pains ou les coups de médiator un peu foireux. Ok, vous me direz qu’il ne devrait pas y en avoir, mais il y en a un peu quand même, et ils s’entendent plus à cause de ce son, justement. Enfin, j’avoue que j’ai trouvé que les effets étaient un peu trop soutenus pour les passages plus calmes. Quelque chose de plus soft aurait été sympa, même s’il est clair que le groupe doit garder cette identité sur leurs morceaux.
En résumé, j’ai bien apprécié l’écoute de ce Inner Stories. Le groupe possède encore une bonne marge de progression mais démontre déjà un talent certain et une volonté d’en découdre. A suivre de près, donc.
Ajouté : Jeudi 03 Juillet 2008
Chroniqueur : Wong Li
Score :  
Lien en relation: In Free Structure Website
Hits: 13441
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
