# 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
}
EXPIRE (usa) - Pretty Low (2014)
Label : Bridge Nine Records
Sortie du Scud : 17 juin 2014
Pays : Etats-Unis
Genre : Hardcore
Type : Album
Playtime : 11 Titres - 24 Mins
"Imagine being at the lowest point of your life, the lowest you've ever felt. There's nowhere to go but up from there."
Ainsi débute le concept de Pretty Low, selon son auteur, Josh Kelting. Et en cette fin d'année, cette observation prend en effet tout son sens. Lorsque les festivités semblent être la seule obsession de millions de personnes dans le monde, le désespoir des plus démunis s'en trouve décuplé, et la rage prend le dessus. Pourquoi ? Comment ? Autant de questions en suspens, auxquelles EXPIRE ne prétend pas répondre.
EXPIRE, c'est un premier album Pendulum Swings, sorti il y a deux ans. Les coreux du Midwest s'en sont vite taillé une réputation d'ailleurs. Guitares abrasives, chant tranchant, rythmique implacable, la tradition des années 80 en étendard, on attendait beaucoup d'eux. Même si le systématisme semblait encore un peu plombant, on les savait capables de plus, beaucoup plus, et on avait raison. Pretty Low nous en apporte la preuve.
Pretty Low, c'est l'académisme de FUGAZI confronté aux théories haineuses et contemporaines de CONVERGE. C'est la rigueur millimétrée de HELMET dessinant les plans sombres de BREACH. C'est une attaque sèche à l'arme blanche, dont la lame effilée tranche à vif dans les chairs. Bien plus difficile d'accès que son prédécesseur, c'est un discours riche, un animal individualiste qu'on apprivoise qu'avec patience. Une mise aux poings salvatrice, mais douloureuse. Et plus concrètement, un des meilleurs albums de Hardcore de ces cinq dernières années.
Onze titres pour moins de vingt cinq minutes, le propos est concis. Mais là est la force de ce deuxième LP. Ne pas parler pour ne rien dire. Laisser la musique seule lorsque le verbe est inutile. Mettre celui ci en avant, en parfaite adéquation avec une rythmique volatile et pourtant solide.
"La société essaie de nous persuader de ce qu'est la beauté, et à quoi notre conjoint idéal doit ressembler." Et justement, Pretty Low combat lui les idées reçues, les postulats imposés, il les combat avec les mots, mais aussi la musique. Ici, rien n'est fait pour être assimilable rapidement. Il faut faire un effort, aller plus loin qu'une simple écoute, chercher les rimes assassines, et au final, découvrir une richesse insoupçonnée puisque cachée sous des atours arides. Les chansons de EXPIRE sont sèches, très sèches. Elles restent en travers de la gorge comme une parole malhonnête qui voudrait sortir, mais qui reste désespérément coincée par la vérité. Ici, tout est cru, mais réfléchi, ça écorche, mais la douleur de la plaie fait finalement entrevoir la liberté. Mais assez de métaphores, parlons musique.
Pretty Low n'est rien de plus, ni de moins, qu'une collection de onze morceaux compacts de moins de trois minutes. Et si l'ambiance générale est résolument Hardcore, les guitares empruntent plus d'une fois des accents métalliques qui alourdissent le ton.
On pourrait penser à la vue du tracklisting global que le groupe à assuré le minimum, mais il n'en est rien. Ils ont juste condensé leurs idées pour les réduire à l'essentiel, leur apportant ainsi un impact énorme. Une fois les scories enlevées, on se retrouve au coeur de la colère, et rien ne fera dévier cette ligne de conduite.
Pretty Low se permet toutes les audaces, et fait mouche à chaque fois. Oui, à chaque fois, vous avez bien lu. Car il ne suffit pas de rester sous la barre de la demie heure pour être convaincant, encore faut il la remplir avec brio.
Et à contrario de beaucoup de leurs collègues, EXPIRE reste mesuré, agressif mais précis. Même les tueries en règle comme "If It Were Up To Me" sentent la maîtrise absolue, la haine posée et construite. L'héritage de Ian MacKaye réactualisé pour coller à l'époque. Et ça fait mal...
Mais la blessure est nette. La saillie sanglante d'EXPIRE se fait au rasoir, effilé, brillant. D'abord, les riffs de Zach Dear. Taillés dans l'acier pur, concentrés, affûtés, au coup de médiator près. Puis les vocaux de Josh Kelting, hurlés à pleins poumons, aux propos revendicatifs et ressassés. Le tout sur une section basse/batterie à qui on ne la fait pas, qui elle aussi sait rester solide sans cracher sur un brin d'innovation, discrète.
Je l'ai dit en préambule, j'ai utilisé des garde-fous. Mais je le répète. Ce deuxième album des américains d'EXPIRE est la rencontre intemporelle entre les quatre grands anciens que j'ai cité précédemment. Et contrairement à son titre, Pretty Low va vous emmener très haut, sur les sommets de la rage. Et si celle-ci devait se trouver un parangon jusqu'à lors, c'est chose faite.
Oui, la perfection existe, même dans la furie. Et c'est effrayant.
Ajouté : Lundi 23 Février 2015 Chroniqueur : Mortne2001 Score : Lien en relation: Expire Website Hits: 5546
|