#
# 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
}
ALEA JACTA EST (FRA) - Dies Irae (2016)
Label : Useless Pride Records
Sortie du Scud : 8 septembre 2016
Pays : Etats-Unis
Genre : Hardcore
Type : Album
Playtime : 11 Titres - 28 Mins
Dix ans, voilà dix ans que les toulousains de ALEA JACTA EST occupent une partie de l'espace sonore avec leur cocktail signature. Cette signature, c'est un assemblage vitaminé de Hardcore énervé en mode gros son enluminé par des samples tirés des films d'action culte comme Gladiator, Dirty Harry, Rocky, le Maître de guerre, etc. Des icônes du cinéma testostéroné made in USA. La recette fonctionne bien et ces illustrations extérieures donnent aux albums du quintet toulousain une petite touche d'originalité car il faut bien reconnaître que toute sympathiques que soit la musique d'ALEA JACTA EST, le combo n'a pas révolutionné le genre.
Dix ans et un troisième projet, Dies Irae, sorti ce mois-ci qui s'ouvre justement sur un "Decem", un hymne fêtant cette première décennie avec des accents de "Happy Birthday to you" pour coreux bourrés. En deux minutes et vingt secondes, la messe est dite. ALEA JACTA EST n'est pas le genre à vous entraîner dans des ambiances planantes ou des numéros de solistes. Ici le son est collectif, le chant est gueulé, la rythmique est énorme et les refrains sont repris en choeur. "Decem" introduit dix chansons qui se ressemblent peut-être un petit peu trop, si l'on enlève les samples parsemés ici et là. Onze titres courts et incisifs, une tracklist pliée en trente minutes. C'est comme un shot de vodka. Une dose brutale et rapide qui fait du bien par où ça passe. Vite bu, vite passé dans le sang et vite assimilé. Mais bien vite oublié également.
Pourquoi ? Tout simplement parce que la discographie des toulousains est trop linéaires et qu'il est difficile de trouver des qualités qui distinguent Dies Irae de Gloria Victis et Vae Victis. Dix ans de scène, dix ans de répétition, de cloques, de sang et de larmes ont indéniablement permis à la formation de progresser, mais on peine à trouver des différences saillantes entre les morceaux du disque et, plus embêtant, entre cet opus et les précédents.
La production, quant à elle, est bien dans l'air du temps. Massive et linéaire. On joue fort mais on dirait que tous les instruments sont sur une même ligne, arrivant tous en même temps dans l'enceinte. C'est la brique en béton dans la tête, sans chichis.
En synthèse, Dies Irae ne jure pas dans la discographie de ALEA JACTA EST. Cet album est bien dans la continuité des parpaings précédents. C'est sa qualité, c'est aussi son talon d'Achille. On regrette que l'anniversaire d'une décennie d'activité n'ait pas donné au groupe l'envie de prendre plus de de risque en sortant de sa zone de confort pour proposer quelque chose d'un peu neuf. Dies Irae est tout le contraire, c'est un produit un peu trop standardisé qui manque clairement d'audace. Ecouté isolément, il fait le job, mais replacé dans la discographie d'ALEA JACTA EST, on cherche désespérément des raisons de le préférer aux précédents disques.
Ajouté : Jeudi 22 Septembre 2016
Chroniqueur : Rivax
Score : 
Lien en relation: Alea Jacta Est Website
Hits: 4534
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
