#
# 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;
}
}
#
# 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
}
ODIUM (FRA) - The Monolith Of Hate (2013)
Label : Auto-Production
Sortie du Scud : 2013
Pays : France
Genre : Brutal Black Metal
Type : Album
Playtime : 14 Titres - 45 Mins
ODIUM, ça vous dit quelque chose ? Non mais mis à part vous, les deux fanatiques blackeux du fond ? Rassurez-vous, j’étais dans le même cas que vous… Ce groupe niçois, qui commence petit à petit à se faire connaître dans sa région et sur tout le territoire a, grâce à une démo et un album, inventé un genre qui lui est propre : l’Hostile Brutal Black Metal. Autant dire qu’il suffit de jeter un coup d’œil à la délicieuse couverture de leur dernier album, The Monolith Of Hate, pour comprendre que la délicatesse, c’est pas tellement leur truc. ODIUM, ça se résume en trois mots : violence, haine et violence.
Ca peut paraître réducteur, voir insultant (j’en ai conscience…) de présenter The Monolith Of Hate ainsi. Enfin, d’un autre côté, je me dis que c’est peut être ce qu’il y a de mieux, dans la mesure où le groupe lui-même se présente comme ça. Assez surprenante chimère de MARDUK (pour la haine blasphématoire) et de CANNIBAL CORPSE (pour, euuuh… la violence genre rouleau compresseur), ODIUM met la barre très haut dans l’extrême brutalité pendant 45 minutes. Et c’est garanti, les 45 minutes, vous les sentez passer, d’une manière ou d’une autre. Je les sens baver d’avance, les amateurs de sensations fortes et d’aplatissages de cerveau…
Je préfère l’annoncer tout de suite, ce disque m’a vraiment ennuyé (sans doute l’impression d’avoir entendu un seul morceau de 45 minutes…). J’insiste, je ne parle que de mes propres goûts, avec une subjectivité assumée. Du coup, en lui même, The Monolith Of Hate est un produit extrême, dans lequel il peut être très difficile de rentrer… mais qui en ravira un grand nombre et qui est riche en qualités, à savoir une technique et une maîtrise parfaites, un son puissant et massif et un mode de composition très riche qui mène rapidement à la création et au développement d’ambiances qui rappellent les grandes années de ce cher DARK FUNERAL. La cristallisation parfaite de cette haine auditive se fait sur l’excellent « Bipolar Disorder ». Ce chant éraillé, mais qui possède tout de même une chaleur et un débit très particulier, n’y est pas pour rien… Les quelques interludes que sont "Overture", "Legio CXVI Ferrata", "Into The Void" sont vraiment dispensables, car pour peu que l’on arrive à s’accrocher à cette déferlante, la pression retombe d’un seul coup… Dommage.
La cohérence de cet album mérite également d’être soulignée car qu’on adhère ou pas, la puissance hors du commun qu’impose ODIUM ne peut pas laisser indifférent. A aucun moment le groupe n’expérimente, ou essaye de changer sa ligne directrice. Pendant trois quarts d’heure quasi non stop, c’est un mur du son franchi à Mach15 qui sort de vos hauts parleurs. Après, qu’on apprécie ou pas, c’est un autre débat…
Bon en gros, vous avez compris qu’ODIUM était un groupe hyper violent ? Une belle victoire en tout cas pour les Niçois qui font ici plus que s’affirmer…
Ajouté : Mercredi 31 Juillet 2013
Chroniqueur : Hizia
Score : 
Lien en relation: Odium Website
Hits: 9274
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
