# 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
}
BRUTAL TRUTH (usa) - End Time (2011)

Label : Relapse Records
Sortie du Scud : 27 septembre 2011
Pays : Etats-Unis
Genre : Grind Core
Type : Album
Playtime : 23 Titres - 56 Mins
Il en va des albums de musiques extrêmes comme des attaques militaires. Il y a la méthode dite du Blitzkrieg, qui défonce tout sur son passage en moins de temps qu’il n’en faut pour dire « Aïe, j’ai mal ». On peut aussi la jouer Wehrmacht vs Front Russe. Ca charcle au début, et puis ça s’enlise, avant de devenir une catastrophe. Le Hiroshima/Nagasaki offre l’avantage de faire un max de bruit et de tout détruire. Mais le plus fin, le plus raffiné, reste quand même la dite « Frappe Chirurgicale », qui ne détruit que l’objectif, sans que celui-ci ait la moindre chance, tout en préservant les innocents.
Et puis, il reste aussi le cas de la méthode globale, qui résume un peu toutes ces techniques. C’est rusé, fin, mais aussi extrêmement violent, tout en ayant l’air de ne pas y toucher.
On appelle ça l’école BRUTAL TRUTH.
Ok, les ricains font du boucan, je ne vais pas le nier. Et les presque seize minutes du final cauchemardesque « Control Room » sont là pour le prouver. C’est inaudible pour le commun des mortels, et ferait passer les expérimentations de PSYCHIC TV et TROBBING GRISTLE pour une gentille ballade d’Hervé Vilard. Seulement voilà, si Capri, c’est fini, Dan Lilker et sa bande ont encore fait Ford (dépêchez vous de lire cette blague, elle va fondre dans quinze secondes), et à l’instar du reste de leur discographie, End Time est bourré ras la gueule de fonderies sonores en tout genre, qui raclent la gorge et laisse un étrange goût de sang dans le palais. Mais Dieu que ce groupe joue intelligemment…
Avec ce son de basse si caractéristique et irrésistible, le gosier ô combien grave de Kevin Sharp, les riffs dissonants de Erik Burke, et le jeu de batterie inventif de Richard Hoak (bah oui, en même temps, quand on joue dans TOTAL FUCKING DESTRUCTION, ça laisse des traces), il n’y a guère tromperie sur la marchandise. Et même si l’affaire commence avec le très glauque « Malice », qui sonne comme une fécondation in vitro d’un ovule de FETISH 69 avec le sperme des SWANS, tout s’emballe assez rapidement, et la vitesse de croisière prend rapidement des airs de vols à Mach 3. Mais même si les morceaux ne dépassent que très rarement les deux minutes, il n’est pas question ici de Grind gratos sans queue ni tête, mais bien d’un subtil alliage en fonte brute d’Indus, de Death sombre, de Hardcore opportuniste, et de ruines de Crust encore fumantes.
Pour vous en convaincre, écoutez les déflagrations inestimables que sont « Warm Embrace Of Poverty », et son atmosphère poisseuse comme une bonne crise économique, « Simple Math », qu’un 1349 franchement possédé aurait pu composer, et complétez le tout avec un « Gut-Check » qui doit autant aux RIGHTEOUS PIGS qu’à PSYOPUS, et vous aurez un aperçu de ce qui vous attend sur cet énorme pétard mammouth qu’est End Time.
Mais attention, aussi brutale et chaotique que soit la musique qui anime cette rondelle, rien ici n’est gratuit ou surfait. Cet album agit comme une agression incroyable de violence, un débordement de haine, mais canalisé, préparé à outrance, et donc contrôlé de A à Z.
Et c’est pourquoi, même si l’on est parfois débordé devant tant de violence instrumentale, on a toujours un garde fou sur lequel se reposer un instant.
Ce qui est la marque des vrais tarés, qui gardent toujours un pied solidement ancré dans la réalité.
End Time est une boucherie stérile, mais pas clinique. De quoi partir en laissant un beau tas de cadavres derrière soi, mais les mains propres.
Ajouté : Mercredi 21 Septembre 2011 Chroniqueur : Mortne2001 Score :      Lien en relation: Brutal Truth Website Hits: 12042
|