#
# 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
}
GATTACA (cz) - Gattaca (2015)
Label : Halo Of Flies
Sortie du Scud : 24 juillet 2015
Pays : République Tchèque
Genre : Post Crust
Type : EP
Playtime : 6 Titres - 25 Mins
Les GATTACA nous viennent donc de République Tchèque, et font partie de ces groupes qui se débrouillent tout seuls, tout en adhérant à plusieurs collectifs de DIY, dont certains prônent le végétarisme et l'éveil des consciences.
Bien, je ne suis pas contre, après tout, il est peut être temps d'ouvrir les yeux sur certains problèmes majeurs... Responsables de nombres de 7'', de splits, de démos, ils passent enfin par la case longue durée, toute proportion gardée puisque ce premier LP a quand même des airs de EP caché...
Pratiquant un genre de crossover entre le Post Metal, le Hardcore, et le Crust, Gattaca n'est rien de moins qu'un EP à haute teneur en vigueur, qui brasse des courants tout en proposant quelque chose de personnel, et l'affaire se présente sous un jour assez intéressant.
Sorti une fois de plus sur le label activiste Halo Of Flies, Gattaca a bien des atouts à mettre en avant, et ne se gêne pas pour le faire. Sur une trame sombre et opaque, le groupe tisse un tapis de riffs qui oscillent entre les agressions franches et nette du Hardcore le plus violent, et les longues dissonances propres au Post, sans vraiment choisir entre les deux.
Une description assez fidèle de leur musique les situerait dans un créneau novateur de Crust Progressif, avec une grosse option Post Rock, caractérisée par des guitares nostalgiques aux thèmes noirs et tristes, disons le.
Une des forces indéniables de cette troupe hétéroclite et engagée, c'est sa chanteuse, qui d'une voix rauque et grave domine les débats, et offre une caution Death/Crust de premier choix. Elle survole des débats qui se veulent variés, comme le prouve le titre d'ouverture qui passe en revue toutes les possibilités d'expression extrêmes.
"Zase Vytahují Oprátky" (Again, They Are Taking Nooses Out en version anglaise), se démène comme un beau diable et assure son rôle d'éclaireur à merveille. Tonalités Nostalgic Doom, presque Sludge parfois, avant de s'envoler vers des cieux Post, sans oublier d'accélérer le propos d'une belle énergie Crust/Grind, version âpre et sans concessions. Production un peu sourde, basse lointaine et grouillante, cymbales grésillantes... Le décor est planté, et l'horizon restera le même.
"Řekni ne" (Say no) se complait à se dépêtrer dans les mêmes eaux, mais se rapproche dangereusement de rivages presque Black avec ses blasts sans pitié et son chant grave et écorché. Mais - et c'est une constante sur l'intégralité de cet EP - ce sont ces passages mid tempo écrasés qui dévoilent le réel talent du groupe à libérer la puissance d'une manière larvée.
"Dej všem co chtějí" (Give Everyone What They Want), accélère les débats, et fonce tête baissée dans un Crust/Post aux couleurs passées, avant de briser le moule et de laisser exploser une série de contretemps rageurs, qui rappellent évidemment les grandes heures du Post Hardcore le plus ténu. Enchevêtrement des voix, guitares compressées au bord de l'explosion, et retour à la case départ sur le dos d'une rythmique échevelée.
"Panoptikon" laisse de côté la vitesse pour se concentrer sur un discours heurté et syncopé, accumulant les breaks, virevoltant de tempi cassés en un mid tempo assuré, tandis que la basse s'enroule autour du kit comme un serpent en mode approche furtive. Nous avons même droit à quelques tierces bien senties, avant que le groupe ne se laisse aller au Hardcore le plus virulent.
"Něco za něco" (Quid Pro Quo) cite les grandes influences Post Rock des 80's, en les agrémentant d'un son typiquement 00's. Guitares qui tournoient, batterie solide et inamovible, chant un peu plus posé, c'est le morceau le plus carré et classique du lot.
Mais rien ne les empêchera de finir leur travail avec une exaction très personnelle, qui reprend à son compte toutes les influences internes, et "Přijdeme znovu" (We will come back) et son titre en forme d'avertissement vogue d'un courant à l'autre, propose même quelques arpèges brûlants, oublie l'agression pure pour privilégier les tensions progressives, à la NEUROSIS/ISIS, avant de s'évanouir dans une coda plombée, qui appelle clairement et simplement une suite, qu'on espère rapide...
Il est toujours difficile pour un groupe de passer du format court (7'', Split) à une durée plus développée, mais c'est un pari que GATTACA a gagné haut la main.
Certes, certaines répétitions ressemblent encore à des automatismes dont il faudra s'affranchir, mais l'identité des Tchèques est déjà bien affirmée, et je ne doute à aucun moment de leur potentiel à établir des règles un poil plus libres et personnelles.
En attendant, si le mélange des genres vous sied, si la violence revêt pour vous des déguisements multiples, jetez une oreille sur Gattaca, qui n'hésite pas à changer d'apparence en cours de route pour mieux surprendre l'auditeur que vous serez.
Dommage que si peu d'informations soient disponibles à leur sujet, et uniquement dans leur langue d'origine. Mais bon, après tout seule la musique compte, mais au vu de la créativité dont ils font preuve, j'aurais aimé en savoir un peu plus sur leur message.
Celui de leur musique est clair toutefois. Ne rien céder, ne rien lâcher, et éviter les évidences. Ce qui somme toute, reste une attitude fort noble dans le petit monde de l'extrême.
Ajouté : Lundi 12 Octobre 2015
Chroniqueur : Mortne2001
Score : 
Lien en relation: https://gattaca.bandcamp.com
Hits: 6914
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
