# 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
}
LACRIMAS PROFUNDERE (de) - Antiadore (2013)

Label : Napalm Records
Sortie du Scud : 24 mai 2013
Pays : Allemagne
Genre : Gothic Rock
Type : Album
Playtime : 12 Titres - 45 Mins
Sortez les éponges, faites chauffer vos tampons, la cyprine chaude va se répandre au sol telle l'eau croupie d'une canalisation perforée. Les beaux bruns ténébreux de LACRIMAS PROFUNDERE sont en effet de retour, trois ans après leur dernier album, The Grandiose Nowhere qui était, il faut le dire, une agréable réussite après un Songs For The Last View racoleur mais peu bandant. C'est d'ailleurs suffisant pour résumer l'impact musical de ces Allemands. Un départ en mode Doom Metal absolument honorable (Memorandum demeure leur chef d'œuvre absolu), un virage Gothic Rock pour gothopoufs échaudées puis un semblant de rédemption qui devait ouvrir une voie royale à Antiadore, un dixième album forcément attendu au tournant. Toujours emmené par le charismatique Rob Vitacca qui du haut de ses vingt-trois ans, fait pâlir de jalousie ceux qui, comme moi, chantent sous la douche comme un castrat, le groupe teuton semble désormais avoir trouvé son chemin depuis l'outing orchestré sur Filthy Notes For Frozen Hearts en 2006.
Sans réelle surprise, Antiadore n'a donc plus rien à voir avec leur période Doom Metal et ceux qui espéraient de leur part un improbable come-back peuvent retourner faire mumuse avec leurs cordes et leurs lames de rasoir. Ce nouvel album est ouvert, plus ouvert que jamais aux mélodies catchys, aux refrains imparables, aux ersatz d'un "A Pearl" qui était le single putassier absolu de Songs For The Last View. On retrouve ces cadences hypnotiques et légères, ces constructions qui font désormais de LACRIMAS PROFUNDERE un groupe dont les puristes se passeraient bien. Et à côté de ça, aussi saugrenu que ça puisse paraître, les Allemands sont parvenus à injecter le jus nécessaire dans leur musique pour ne pas sombrer définitivement dans le grotesque. Le piano, symbole de la mascarade gothique qui faisait rayonner les précédents efforts d'un halo clownesque, se veut désormais subtil, dosé pour ne pas dire légitime. Antiadore, tout en se la jouant beau-gosse mystérieux, parvient à crever l'abcès en rapprochant le quatuor de son public. Plus simple, plus vrai, plus clean, cet album oublie d'être caricatural et c'est ce qui fait son principal charme. Après, oui, Rob Vitacca est un sacré chanteur et sa présence ne laisse personne indifférent. Sa voix grave et pénétrante instaure toujours un climat romantico-glauque à l'œuvre. Qu'on aime ou pas, il est une marque de fabrique pour le groupe depuis maintenant six ans et c'est toujours mieux d'avoir un personnage comme ça que de ne pas en avoir du tout. D'autant plus que son chant, techniquement parlant, a encore gagné en profondeur et variations, loin du cinéma pas possible qu'il nous faisait sur "And God's Ocean". Et en parlant de balade mièvre, il était improbable de ne pas tomber sur une pépite. Celle qui truffe Antiadore s'appelle "Head Held High" (même si toutes peuvent revendiquer ce titre honorifique) et n'est pas sans rappeler le STONE SOUR du pauvre. On préférera de loin un "Remembrance Song" couillu, un "What I'm Not" vivant ou carrément la conclusion, "A Sigh", une étrange mixture entre leur Gothic Rock actuel et leur Doom Metal de l'époque.
Très sincèrement, la musique de LACRIMAS PROFUNDERE, dans cette forme là, ne me fait plus aucun effet. Je reconnais que depuis The Grandiose Nowhere, il y a eu prise de conscience, amélioration. Mais le Gothic Rock des Allemands souffre terriblement de sa propre superficialité, qui se voit comme le nez au milieu du visage. En optant pour des compositions moins tapageuses et plus lisses, LACRIMAS PROFUNDERE s'est fait tout petit et c'est dans cette discrétion qu'ils sont encore les plus efficaces.
Ajouté : Dimanche 23 Février 2014 Chroniqueur : Stef. Score :    Lien en relation: Lacrimas Profundere Website Hits: 6960
|