# 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
}
ENEMY LOGIC (ie) - Bones As Armour (2009)

Label : Auto-Production
Sortie du Scud : 2009
Pays : Irlande
Genre : Metalcore / Death Metal Mélodique
Type : Album
Playtime : 8 Titres - 31 Mins
Ces dernières années ont été plutôt mouvementées pour cette formation irlandaise. Changement de nom, de genre musical, un nouveau départ en quelques sortes. Vous vous souvenez sans doute du groupe de Hard Rock WINDFALL ? Mais si, faites un effort. Cela ne vous dit vraiment rien ? Eh bien, à moi non plus. Et pourtant, ces Irlandais se vantent d’avoir rencontré le succès sous leur ancien patronyme. Puis en 2008, sur un coup de tête, ils se mettent au Metalcore à relents Death Mélodique et proposent, l’année suivante, ce premier album, Bones As Armour, gratuitement sur internet. Une décision louable… pour un contenu qui l’est tout autant ?
Premier constat étonnant, un quartette pour cinq lignes instrumentales et deux vocales. En effet, chacun des membres est à double usage : le bassiste s’occupe du chant, appuyé par le batteur, et le clavier est assuré par un des guitaristes. Un peu brouillon et amateur tout cela. Et la répercussion sur la musique du combo irlandais est évidente. Production étouffée qui relègue le chant derrière les instruments, mixage pas très subtil et linéarité accablante. Un morceau d’introduction au piano s’intensifiant crescendo, soutenu par des nappes de claviers, des compositions familières (« Shattered Ego »), des breaks à répétition, et des riffs réutilisés plusieurs fois dans l’album (« Scatter The Ashes » et « Eternal Guilt ») ; ENEMY LOGIC propose une formule des plus classiques du Metalcore actuel.
Néanmoins, le groupe reste compétent et montre une réelle volonté de se distinguer. Les riffs sont efficaces, et les leads mélodiques et bien amenés accrochent l’oreille. En tant qu’auditeur, on se plaint souvent d’une batterie trop en retrait. Ici, tout le contraire, elle est clairement mise en avant et le batteur se montre énergique et virulent. La basse est également bien audible et la rythmique s’en trouve alors plus agressive. Ainsi, une piste comme « Where You End And I Begin » fait mouche à la première écoute, de part sa puissance et son très bon refrain mélodique intégrant des claviers. Ces derniers, loin d’être appliqués à foison sur tout l’album, permettent au groupe de démarquer quelques morceaux, à l’instar du titre éponyme. En outre, les breaks de guitare acoustique contrastent agréablement avec l’opacité des compositions, et celui de « The Victim Must Be Silenced » est couplé aux cordes du violon, pour un résultat plutôt joli.
Non, le point faible ne vient pas vraiment de l’instrumentation qui se montre correcte, mais plutôt du chant principal. James exécute des vocaux hurlés granuleux, qui ne tardent pas à agacer, et cadencés par la batterie ; ce qui résulte en des lignes vocales hachées. En revanche, les growls profonds apportés par le batteur sont pleinement maîtrisés.
L’album se termine avec « Ring Of Fire », reprise du tube de Johnny Cash. Adapter la Country en Metalcore, c’est osé, et le résultat est satisfaisant. Toutefois, c’est dommage que les leads clairs qui retranscrivent l’essence mélodique du morceau original n’aient été appliqués qu’en début et fin de morceau, laissant la part belle aux riffs agressifs le reste du temps. Mais, le groupe parvient à garder l’esprit premier du titre et l’arranger en une version plus brute et personnelle. Etrangement, le chant est très bon ici.
ENEMY LOGIC nous gratifie donc d’un premier album disposant d’idées intéressantes, mais souffrant également de maladresses non négligeables, ce qui ne risque pas de le démarquer de la scène actuelle. Etonnant que des Irlandais ne pensent pas au Metalcore Celtique pour apporter un peu d’originalité. Bref, Bones As Armour est proposé gratuitement, et je pense que c’est la meilleure idée qu’ils aient eue, à en juger le contenu.
Ajouté : Mercredi 10 Février 2010 Chroniqueur : CyberIF. Score :    Lien en relation: Enemy Logic Website Hits: 12747
|