#
# 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
}
EMIA (FRA) - Run To Live (2010)
Label : Auto-Production
Sortie du Scud : 17 mai 2010
Pays : France
Genre : Metal moderne
Type : Album
Playtime : 7 Titres - 33 Mins
Moi j’dis, le racisme c’est moche. On a tous une couleur de peau différente et ça n’empêche pas les peuples de bien s’entendre, ou pas. Tiens, regardez EMIA ! Y a un blanc, un jaune, un vert, un marron et un bleu et tout ça, ça donne un groupe de Metal sacrément original. Je ne sais pas si l’idée du maquillage chatoyant est un hommage à leurs collègues toulousains de PUNISH YOURSELF ou un clin d’œil amusé à la dégustation de glaces dans le film « Le Gendarme à New-York », mais en tout cas, l’accroche visuelle est des plus réussies. Ce qui est réussi également, c’est cet EP, Run To Live, qui succède à un premier effort livré en 2009 sous la forme d’une démo entichée d’un DVD live. Malgré ces deux sorties coup sur coup, on n’a toujours pas eu vent du phénomène EMIA dans le reste de la France. Si la critique le décrit volontiers comme un groupe prometteur et intéressant, il n’en demeure pas moins compliqué de tirer des plans sur la comète quand émerge un nouveau combo de Metal moderne.
Ils ont néanmoins dans leur CV une référence de choix. D’avoir tourné avec HACRIDE ou TREPALIUM ? Non. C’est qu’ils sortent tout droit de Toulouse, un des plus beaux viviers français en activité d’où s’envolent à intervalles réguliers les condors les plus talentueux. EMIA en est-il un membre affirmé ? Oui, clairement, bien que la musique des Midi-Pyrénéens ne soit pas encore clairement affranchie. Combinaison facile mais pas très audacieuse de Thrash, de Hardcore, de Death moderne à la LIVARKAHIL et de Metal easy-listening dérivé de MUDVAYNE, SLIPKNOT, RAUNCHY et EKTOMORF, cet EP bénéficie avant toute chose d’une production sonique et explosive qui met en relief le côté déflagrant des compositions. Ce Metal, bien que finement ciselé dans le granit, n’est pas très technique, pas très complexe. Par contre, il vous pète à la tronche pendant une bonne demi-heure, sans jamais relâcher la bride. On retrouve ici une force de frappe à la fois méthodique et robotique. EMIA appuie là où ça fait mal et se basant sur un duo de guitaristes (Matt et Manu) complémentaires, délivrant à la pelle des riffs tantôt parpaings, tantôt syncopés. A de nombreuses reprises, on assiste à des pauses ou à des ralentissements au cœur des morceaux. Ils rétrogradent pour mieux repartir, à l’image de « Vortex », probablement la création la mieux agencée de ce Run To Live avec ses rythmiques hachées-menu et ses roulements de batterie massifs. L’occasion de souligner tout particulièrement la prestation de haut vol de Joe derrière ses fûts, qui martèle comme un dingue pour aboutir à des cadences dansantes dignes de SEPULTURA (« Child »). Globalement convaincant sans pour autant défrayer la chronique, cet essai nécessite malgré tout plusieurs relectures pour en saisir l’intensité. Une fois captée, c’est du tout cuit.
Voilà donc de quelle substance cancérigène se compose EMIA. Addictif ou lassant selon les humeurs, Run To Live est une sortie qui n’a absolument aucun mal à s’émerveiller et à prendre du galon au fil des écoutes. Pour le reste, ceux qui affichent une préférence pour un genre précis et qui sont réfractaires à l’utilisation du terme « Metal » dans son sens le plus générique ne devraient pas trouver leur bonheur dans cet EP. Le souffle brulant qui s’en dégage rattrapera un peu le flou stylistique dans lequel ces garçons nous font joyeusement patauger.
Ajouté : Mercredi 22 Août 2012
Chroniqueur : Stef.
Score : 
Lien en relation: Emia Website
Hits: 8006
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
