# 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
}
I DECLARE WAR (usa) - Malevolence (2010)

Label : Artery Recordings
Sortie du Scud : 8 juin 2010
Pays : Etats-Unis
Genre : Brutal Deathcore
Type : Album
Playtime : 11 Titres - 39 Mins
A l’ouest, rien de nouveau. Mais vraiment rien. En périphérie de Seattle exactement, a éclot il y a six années un groupe de Deathcore (un de plus) très à l’ouest musicalement. On le sait, on le rabâche sans cesse, la scène est prolixe et saturée. Et pour une fois, je suis tombé sur une de ces formations qui justifie cette sale réputation, car elle n’apporte pas d’eau au moulin. Le seul moulin que nos amis d’I DECLARE WAR peuvent alimenter, c’est le moulin à paroles de leurs détracteurs. Avec Malevolence, leur troisième album sorti en 2010, les américains chient dans la colle en nous pondant un condensé incroyable de banalité et de médiocrité qui hérissera même le poil de l’aficionado le plus aguerri. Un hachis grossier et pâteux, difficile à déglutir pour peu qu’on ne s’étouffe pas avec, voilà ce que nous réserve I DECLARE WAR, qu’on m’avait présenté comme la relève triomphante des WHITECHAPEL et compagnie.
Groupe potentiellement « bankable », véhiculant une image de grosses brutes à la ALL SHALL PERISH, le quintette se vautre, non pas en reprenant les stéréotypes du genre (car ils procèdent tous ainsi), mais en les assemblant de façon complètement illogique et incohérente. La maitrise technique est présente, mais on n’entre jamais réellement dans les compositions, trop surfaites pour être sincère. Enchevêtrement inefficace de breakdowns, blasts, solos épars, mid-tempos et grognements artificiels, I DECLARE WAR enfile les poncifs comme des perles, sans porter attention aux accords de goûts et de couleurs. C’est à celui qui sera le plus brutal. A ce petit jeu, « Predetermined Path » décroche le pâle trophée, avec son solo en papier-mâché de mauvais aloi. Pourtant, on pourrait être tenté de penser que ce disque est un morceau de choix, s’il n’avait pas ces quelques années de retard. Flirtant parfois avec VOMITORY ou CANNIBAL CORPSE, osant pénétrer en territoire Brutal Death avec « Infinite Corruption » et ses relents de DYING FETUS, les compositions, en dépit d’une bestialité plus bête que méchante, sonnent creux. Jamie Hanks possède une ligne de chant évidement guttural mais sans relief. Ses gargarismes à répétition deviennent vite lassants. Pourtant, alors qu’on pensait que plus rien d’agréable ne pouvait nous arriver avant la fin de cet interrogatoire musclé, I DECLARE WAR déballe enfin le grand jeu avec « Putrification Of The Population », une création hautement addictive de par son intro mélodique recherchée et une énorme brisure rythmique en bout de piste, avec des breakdowns enfin syncopés et convaincants. Plus dans le groove, l’instrumentale « Alea Iacta Est » lui succède et nous fait prendre conscience que finalement, tout n’est peut-être pas bon à jeter dans cet opus. C’était sans compter sur « Fractions », une piste sans queue ni tête, amoncellement informe des riffs les plus bateaux, de breakdowns casse-gueules, qui achève la bête et nous ramène à la dure réalité : I DECLARE WAR nous a fait passer un moment particulièrement désagréable et nous fait d’autant plus apprécier le retour du silence.
Sans contester le fait que ces mecs ont réussi leur coup, à savoir passer pour de gros bûcherons d’sa mère, il faut aussi avouer qu’ils gagneraient probablement en crédibilité en essayant de se créer un truc du genre ; personnalité ou encore âme musicale. Autant d’éléments aujourd’hui inexistants. A partir du moment où ils parviendront à aligner deux compos correctes sur onze, on pourra considérer que ce n’est plus le fruit du hasard. Mais pour l’instant…
Ajouté : Mercredi 21 Septembre 2011 Chroniqueur : Stef. Score :   Lien en relation: I Declare War Website Hits: 9490
|