# 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
}
MISERY INDEX (usa) - The Killing Gods (2014)
Label : Season Of Mist
Sortie du Scud : 23 mai 2014
Pays : Etats-Unis
Genre : Death Metal / Grindcore
Type : Album
Playtime : 12 Titres - 44 Mins
Jamais une pochette de MISERY INDEX n'avait arboré si peu de couleurs. J'aime bien y voir un signe. On pourra parler à l'avenir d'un disque "saignant comme Heirs To Thievery" ou "sombre comme The Killing Gods", comme si ce quatuor américain se laissait envahir par des sentiments colorés, comme s'ils étaient un nuancier à quatre plis, alors que c'est loin d'être le cas. J'en veux pour souvenir leur prestation envahissante au Hellfest 2013. A part le large sourire qui barrait le visage de Mark Kloeppel, confidence d'un show réussi, aucune émotion ne trahissait l'insensibilité du groupe, d'une régularité technique inimaginable, en parfaite harmonie avec ce qu'ils pondent en studio depuis leur formation en 2001. Alors quand déboule The Killing Gods en mai 2014, déjà solidement appréhendé par nos petites fesses endolories, c'est comme si notre microcosme était frappé par un don de voyance. On sait exactement le prix à payer, mais on ne soupçonnait pas encore l'ampleur de la dette laissée par ce cinquième full-lenght.
Comment va s'y prendre cet album pour surpasser Heirs To Thievery ? En fait, la réponse consiste en une simple continuité, auréolée de quelques spasmes de spontanéité jamais entendus sur une sortie estampillée MISERY INDEX. Tout commence avec "Urfaust", une introduction instrumentale et mélodique. Si ce n'est pas une première les concernant, qu'on m'amène une potence, je m'y accrocherai. Signe plus que révélateur du changement d'intensité qui va littéralement foudroyer The Killing Gods, cette ouverture en appelle à "The Calling", un premier titre qui balaie d'un faisceau de suprématie technique et rythmique toute une discographie. Pachyderme enragé dans un magasin de cristal, MISERY INDEX broie, savate, explose, viole, démembre, compresse, torture, bastonne. Hautement addictogène, ce morceau, doublé par une autre instrumentale ("The Oath"), va révéler la vraie nature de cet opus, qui sera le plus dense, le plus mature, le plus structuré jamais écrit par les américains. On a vraiment du mal a y entrer, notamment parce que les cinq premiers titres sont les cinq branches d'une même chanson et qu'une fois encore, pareille conceptualisation semble tout à fait hors de propos dans un disque de MISERY INDEX. Sauf que MISERY INDEX a toujours eu ce goût du contre-pied parfait sous le derme de ses sorties et que fort d'une compo sournoise et mid-tempo comme "Conjuring The Cull", qui est à The Killing Gods ce que "The Carrion Call" était à Heirs To Thievery, le groupe va perpétuer sa vilaine manie du tube Death / Grind par excellence, alors que cette pratique est, par définition, génétiquement impossible. Puis "The Harrowing" marque la fin de "Faust", ville dans la ville, et laisse les lumières de la nuit pénétrer au cœur de l'œuvre, d'abord par l'éponyme, ses chants grégoriens en intro, ses guitares placides, son envolée rythmique décoiffante, son groove alternatif final, ensuite par "Cross To Bear", bestial, hargneux, mais décidément indépendant dans le répertoire de ces garçons. D'ailleurs, c'est The Killing Gods tout entier qui rompt avec les habitudes discographiques du quatuor. Avec cette force de frappe entre Brutal Death et proto-Punk sur "Gallows Hunter", cette patate dans la gueule portée par l'énergie folle de la paire de chanteurs Jason Netherton / Mark Kloeppel, ce riffing partagé entre virilité, mid-tempos et solos mélodieux, ce "blasting" parfait en toile de fond, ce cinquième opus accumule les cadavres, comme l'a toujours fait MISERY INDEX. Par contre, ce qui cause la vraie rupture avec Heirs To Thievery et les autres, c'est ce songwriting, d'une intensité, d'une classe, d'une originalité et d'une efficacité encore jamais atteinte par le groupe, qui continue d'avoir une longueur d'avance sur les autres pendant que les autres continuent de dégueuler des leçons apprises par coeur avec l'autosatisfaction d'un premier de la classe.
Simplement excellent, The Killing Gods, je n'ai pas peur de le dire, est le meilleur album de la discographie de MISERY INDEX. Et pourtant, qu'est-ce que j'aime Discordia, qu'est-ce que j'aime Traitors, sans même oser parler du superbe Heirs To Thievery. Groupe à part qui n'aura jamais cessé de se bonifier avec le temps, c'est désormais une certitude, MISERY INDEX fera encore mieux au prochain coup, car c'est leur marque de fabrique depuis maintenant 14 ans et que si ce n'est pas mieux, ça ne mérite pas de s'appeler MISERY INDEX.
Ajouté : Dimanche 09 Août 2015 Chroniqueur : Stef. Score : Lien en relation: Misery Index Website Hits: 5302
|