# 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
}
WINDS OF PLAGUE (usa) - Against The World (2011)

Label : Century Media Records
Sortie du Scud : 19 avril 2011
Pays : Etats-Unis
Genre : Deathcore
Type : Album
Playtime : 12 Titres - 38 Mins
Que peut bien vouloir nous compter la bande de mioches glauques qui chantonnent dans cette entrée en matière funeste ? Ils alertent tout simplement les misérables villageois modernes que nous sommes qu’une armée de samouraïs revenants d’une autre époque va envahir nos pavillons civilisés.
A l’ère où tout résonne comme une routine et où chacun d’entre nous aurait tendance à croire que tout a toujours été régi de manière organisée, WINDS OF PLAGUE vient nous rappeler à sa façon qu’il fut un temps où il fallait se battre pour obtenir quelque chose et je ne parle pas de compet’ entre miss blondasse et mam’zelle binoclarde pour obtenir les faveurs de big boss, mais de vraies batailles aiguisées, aux lames sanglantes, qui ont fait tomber un paquet de têtes. Il n’y a qu’à jeter un œil sur l’artwork de la pochette, les têtes ici sont bien accrochées et c’est peu dire.
La hargne développée aura l’impact d’une chaîne lancée tel un lasso vous happant par la gorge et dissuadant même le plus téméraire de tenter une quelconque évasion aussi infime soit elle.
« Raised The Dead » et « One For The Butcher » s’enchaîneront à la perfection pour installer cette menace qui s’en va grandissante et c’est « Drop The Match » qui clamera haut et fort le patronyme des guerriers assaillants : WINDS OF PLAGUEEEEEEEEEEEE !
Chaque titre teintera l’opus d’une révolte meurtrière et en mettant de côté les paroles, on aura malgré tout dans les dents des riffs saccadés, mais toujours ultra vifs nous laissant à peine le temps de reprendre notre souffle. Le peu d’air léger présent s’humera sur les chœurs discrets de « Refined In The Fire » donnant à sa musicalité un aspect plus orchestré et accentuant la rythmique nonchalamment maîtrisée.
Après un discours servi par le chef bridé de la troupe sur fond d’intonation orientale, les bataillons s’engageront pour une guerre contre le monde, « Against The World », laissant à la traine une pourtant bien belle harmonisation aux archets.
Et pour y croire encore davantage on laissera « Monsters » développer ses changements de cadences incroyablement judicieux et surprenants. Vraisemblablement les soldats n’ont pas le loisir de lésiner sur la quantité d’attaques et de coups assenés à l’ennemi, mais il est clair qu’à ce stade de la rivalité, bon nombre d’entre nous sont déjà à terre et vont peiner à se relever.
La qualité est emprunte d’originalité, mélangeant aisément les notes d’instrument peu engagés dans le Death comme ce petit carillon du temple bouddhiste se mouvant au gré du vent ou encore ce piano possédé.
C’est pour mieux compter les défunts que l’on dégustera une pause (si je puis dire) et qu’on se délectera d’une composition courte mais indéniablement construite et intense.
Bon et bien certes il ne fallait pas s’attendre à une once de baisse de régime, la tension haletante est à son paroxysme d’un bout à l’autre de l’œuvre, mais le poids de l’armure, la musique tonitruante, le tout allié à la sueur des mâles enragés, toutes princesses Mononoké qui se respectent auraient apprécié un temps de rencontre avec son prince combattant. Bref là on n’a pas à faire à de la romance mais bon sang ce que c’est bon d’en prendre plein la tête surtout quand la vôtre n’apparaît pas au tableau de chasse. En effet, je vous vois d’ici, inutile de compter, les victimes trop nombreuses n’ont pas toutes trouvé leur place dans l’ornement du tombeau du dernier samouraï.
Ajouté : Mercredi 27 Avril 2011 Chroniqueur : Line44 Score :      Lien en relation: Winds Of Plague Website Hits: 10402
|