#
# 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
}
THE AGONIST (ca) - Prisoners (2012)
Label : Century Media Records
Sortie du Scud : 4 juin 2012
Pays : Canada
Genre : Metalcore
Type : Album
Playtime : 11 Titres - 56 Mins
Vous savez, cette histoire de virage mortel du troisième album, je n'y crois pas vraiment. Mais avec THE AGONIST, je commence à me poser des questions et... en fait non. Le combo canadien formé en 2004 avait entamé les hostilités avec Once Only Imagined en 2007. Puis vint à son tour Lullabies For The Dormant Mind deux ans plus tard. Et c'est donc en 2012 que ce Prisoners voit le jour et risque de vite apporter quelques clés à nos serrures. Encore une fois, la cover ne laisse pas vraiment présager de changement, étant en cohérence avec les visuels farfelus déjà présents sur leurs anciennes productions.
Pour la musique, c'est la même ! Aucun changement à noter depuis tout ce temps si ce n'est une légère montée en puissance, que ce soit au niveau des instruments où du chant d'Alissa, tantôt crié, tantôt clair, et qui manque (encore et toujours) d'intensité, la faute à une totale absence de conviction malgré qu'il soit impeccable et tout bonnement agréable à écouter. La production quant à elle est beaucoup plus touffue, ce qui rend le contenu un tantinet plus massif et moins ennuyant à l'écoute. Mais alors où est le problème ? Eh bien nos Canadiens jouent du Metalcore, coupé par moment d'un Death Metal mélodique. Et... c'est tout. Soit, je n'aime pas chipoter sous prétexte "qu'ils n'innovent pas" car j'estime que c'est quelque chose d'assez récurent et finalement un détail parmi tant d'autres. Mais lorsqu'une formation de cette trempe arrive à avoir un tel succès, je suis tout de même en droit de réclamer autre chose que du réchauffé pendant presque une heure ! Je ne réclame pas l'accordéon pour autant, mais au moins autre chose que des blast-beats à ne plus savoir quoi en faire. Alors certes, c'est entraînant, c'est puissant, c'est tout ce qu'on veut. D'ailleurs les titres sympas ne manquent pas. Prenez « Anxious Darwinians ». Une piste aux relents plus cisaillés que le reste et qui se veut, sans grimper bien haut, agréable à écouter. Agréable, c'est l'adjectif que je pourrais donner à Prisoners, mais uniquement dans la mesure où l'on peut l’apprécier sans se prendre la tête. Cependant, les Canadiens font toujours preuve d'un professionnalisme qui ne peut être que salué, ainsi que d'une maîtrise total de ce qui se fait de mieux en matière de Metalcore bétonné.
En outre, THE AGONIST fait du THE AGONIST. Peut-on leur en vouloir pour ça ? A vous d'en juger. Pour ma part, la question n'est pas de savoir si Prisoners est un bon ou un mauvais album, mais plutôt s'il va plaire aux fans. Et la réponse serait plutôt positive dans le sens où ce CD contient une musique solide, consistante et qui va droit à l'essentiel sans manquer de nous satisfaire, même en assurant le minimum syndical. Cependant, je me demande toujours si après trois albums, nos Canadiens vont enfin se décider à nous surprendre un jour. Mais ça, c'est une autre histoire…
Ajouté : Dimanche 15 Septembre 2013
Chroniqueur : Nash
Score : 
Lien en relation: The Agonist Website
Hits: 4048
|
Rechercher sur M-I
