# 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
}
LO! (au) - Look And Behold (2011)

Label : Pelagic Records
Sortie du Scud : 26 septembre 2011
Pays : Australie
Genre : Hardcore / Sludge
Type : Album
Playtime : 10 Titres - 39 Mins
Le 10 juillet 2011, un accident de train fait 53 morts et 250 blessés au nord de l’Inde. Alors quand je lis que « le son dépoli et abrasif de LO! est à l’image d’un train qui déraille », permettez-moi de penser que le public indien trouvera la comparaison d’un goût douteux. D’autant que le Metal n’a pas de beaux jours devant lui dans cet immense pays, à l’image des échauffourées qu’a provoqué l’annulation récente d’un concert de METALLICA. Mais les australiens de LO! s’en préoccupent-ils vraiment ? Tout laisse à croire que non, puisque ces derniers insistent dans leur entreprise de démolition de masse avec Look And Behold, un premier full-lenght qui semble avoir l’ambition d’affranchir la scène extrême australienne aux yeux de ceux qui pensent qu’elle ne tient qu’aux prouesses de THE BERZERKER. Ces quatre mecs nous viennent donc de Sydney, proposent un Hardcore stéroïdé, bruyant et dépressif dont les multiples expérimentations ne sauraient trahir un besoin certain d’innovation et une démarcation d’avec leurs compatriotes studieux d’AIRBOURNE.
Un premier indice m’a tout de suite confirmé cette sensation d’avant-gardisme annoncé, c’est la durée des chansons. Quand une piste longue de 8 minutes succède à une autre qui dure à peine 89 secondes, on imagine assez facilement que ce disque sera varié sur les autres points capitaux. « Abrasif », le son de LO! l’est, assurément ! Après une courte intro, « Deluge (Carnivorous Flux) » explose au visage du petit public. Loin de moi l’idée de m’engager également sur le terrain des comparaisons cyniques, surtout après un début d’année 2011 marqué par la tragédie nucléaire de Fukushima, mais quelle autre image serait plus appropriée ? Il ne m’en vient pas pour la simple et bonne raison que les australiens ont la main lourde au niveau des ambiances chaotiques et spectaculaires. Défigurer l’auditeur, lui crever les tympans, chercher l’assourdir, c’est l’objectif annoncé de ce groupe. Et pour ça, ils s’y prennent avec subtilité. Adrian Griffin n’est pas le style de batteur qui enchaîne les bpm pour vous faire imploser la boite crânienne, non ! Ses frappes minutieuses en mid-tempo vous endorment, vous détendent et c’est là qu’il cartonne ses cymbales comme des lames qui vous transpercent. Apocalyptique à la manière d’un CROWBAR, massif à l’image d’un MASTODON et torturé comme un bon NEUROSIS, voyez un peu les ingrédients du succès. Et le pire dans tout ça, c’est qu’aucune composition n’est apte à se détacher des autres, car elles n’ont aucun corps, aucune structure. Entre riffs Noise, pauses brumeuses, claviers névralgiques, chant râpeux ou interludes Lounge, LO! rassemble le côté free-stylé d’IWRESTLEDABEARONCE avec le sérieux et le l’antipathie d’HELLMOUTH. Avec sa guitare, Carl Whitbread fait des miracles, jouant sur des bases techniques solides, teintant sa prestation de psychédélisme et offrant un dialogue poignant avec son chanteur en final de « Moira Kindle ». Insaisissable, inestimable, ce Hardcore, qui n’en est pas vraiment, est à l’image de ce qu’on attend des formations exotiques, c'est-à-dire qu’il est aux antipodes des groupes de Hardcore conventionnels qui officient au somment de leur scène, qu’elle soit européenne ou américaine.
Avec Look And Behold, LO! est le nouveau joueur qui change déjà les règles du jeu. Peut-être encore trop ancrée dans la réalité, cette sortie prendra probablement de la valeur en même temps que ces mecs planteront d’autres jalons dans une terre fertile. En attendant, on s’en contente en espérant secrètement qu’ils pousseront le bouchon encore plus loin au prochain coup, pour qu’on puisse avoir vraiment matière à parler de potentiel artistique.
Ajouté : Mardi 15 Novembre 2011 Chroniqueur : Stef. Score :     Lien en relation: Lo! Website Hits: 9338
|