# 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
}
THE RED CHORD (usa) - Fed Through The Teeth Machine (2009)

Label : Metal Blade Records
Sortie du Scud : 27 octobre 2009
Pays : Etats-Unis
Genre : Death / Grindcore technique
Type : Album
Playtime : 12 Titres - 36 Mins
Il y a THE RED SHORE et il y a THE RED CHORD. Entre les deux, pas moins de 15 000 kilomètres. De Geelong dans l’Etat de Victoria en Australie à Revere dans le Massachussetts (USA), il y a un univers. Et pourtant, on ne peut que constater que malgré la distance qui les sépare, on a en face de nous deux groupes immenses, qui se sont donné le mot. Le premier a déjà fait l’objet d’une analyse poussée (voir par ailleurs). Le deuxième va subir une nouvelle dissection, après la très barbare autopsie réalisée par mon collègue Wong Li sur le Prey For Eyes de 2007. Parce qu’il y en a, des choses à dire sur leur musique. THE RED CHORD, ou ce geyser d’où jaillit un talent monstrueux. Quatre albums au compteur et pas un pour rattraper l’autre. Quatre bombes atomiques. Le dernier de la fratrie, un certain Fed Through The Teeth Machine pose un terrible constat. Trois ans après sa sortie, le temps commence à devenir long. Et les Américains me manquent cruellement.
Erigé sur des fondations Death en papier-mâché qui menacent à chaque instant de rompre, cet opus représente une forme d’idéal pour tous ceux qui aiment résoudre des équations tout en prenant une soufflante dans les oreilles. La vérité du moment présent n’est jamais la même que celle du moment à venir. Tout fout l’camp et c’est un bonheur. Beaucoup plus « in your face » que Prey For Eyes, Fed Through The Teeth Machine est une avalanche de riffs mathématiquement improbables et de structures surprenantes. « Demoralizer » résume à lui seul cette œuvre, mais ce serait une erreur de la résumer à ce simple titre. Détaillé comme une peinture rupestre, aussi sincère qu’un maître-boucher devant une carcasse de chevreuil innocent, ce savant mélange de Death Metal, de Grind et de musique expérimentale vous explose à la tronche. Il y a une folie qui gangrène ce full-lenght. On ne sait pas exactement d’où elle sort, mais elle œuvre dans la discrétion la plus totale, pour finir par se matérialiser épisodiquement, grâce à des motifs insidieux (« Floating Through The Vein ») et à des samples écrasants (« Ingest The Ash »). Quant à savoir comment ces mecs s’y sont pris pour exécuter ces quelques morceaux en live, c’est un des grands mystères de l’ère Metal moderne, tant certains passages relèvent du freestyle pur et dur. On pourrait évoquer des influences Mathcore ou même Djent dans cette rondelle, mais THE RED CHORD ne se laisse pas prendre au jeu de compositions Meshuggiennes fallacieuses. Ce serait trop facile. Non, les Américains préfèrent se compliquer un peu la tâche, à l’image d’un Brad Fickeisen qui, derrière sa batterie, a réalisé une véritable prouesse. Sa prestation déglinguée et tentaculaire est juste surréaliste. De très loin, il est l’un des frappeurs les plus doués de sa génération. Et avec lui, THE RED CHORD semblait intouchable. Mais je vous l’ai dit, « la vérité du moment présent n’est jamais la même que celle du moment à venir ». Et ce moment, choisi avec minutie par l’ex-quatuor, c’est « Mouthful Of Precious Stones ». Sans en avoir l’air, cette piste beaucoup plus mélodique que les autres est une forme d’apothéose artistique, avant les expéditives « The Ugliest Truth » et « Face Area Solution » qui souffriront de la comparaison. Il y a de la finesse chez THE RED CHORD. Mais il faut la mériter. Rageur et complet comme le bon pain, Fed Through The Teeth Machine s’achève avec de longues plaintes hurlantes, qui résonnent encore comme un appel à l’aide. L’effet est génial, pour la simple et bonne raison qu’il est un écho musical intense à la performance presque quarantenaire de Marilyn Burns.
Qu’on aime ou pas, le résultat de cette expérience crève les yeux et les oreilles. THE RED CHORD est un groupe de tueurs dont les efforts ne sont pas toujours appréciés à leur juste valeur. Fed Through The Teeth Machine demeure effectivement un disque difficile d’accès, à la brutalité parfois évidente et à la technicité souvent exubérante. Il est d’autant plus inabordable qu’il succède à un Prey For Eyes plus varié et aéré. Et pourtant, cet assemblage musical, qui semble si difficile à comprendre, découle sur une formule à la logique avérée, qu’on peut confondre avec une inéquation. Il nous suffira de tendre un peu l’oreille pour avoir la solution.
Ajouté : Vendredi 19 Octobre 2012 Chroniqueur : Stef. Score :     Lien en relation: The Red Chord Website Hits: 8126
|