#
# 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
}
SIXX:A.M. (usa) - This Is Gonna Hurt (2011)
Label : Eleven Seven Music
Sortie du Scud : 9 mai 2011
Pays : Etats-Unis
Genre : Hard Rock
Type : Album
Playtime : 11 Titres - 48 Mins
Belote et rebelote, je ne sais pas mais en tout cas il y en a un deuxième. Un deuxième quoi ? Eh bien un deuxième album du projet de monsieur Nikki Sixx (basse), SIXX : A.M.
Après une surprise de taille sur le premier opus du quatuor Californien nous étions en droit d’attendre avec une frénésie non feinte ce qu’ils pouvaient bien nous réserver cette fois.
Et pourtant, c’est sans réelle surprise que démarre This Is Gonna Hurt. A l’image de son grand-frère, il déverse déjà tous les arguments d’un bon Hard Rock incisif. Ça gratte nerveusement, ça claque et ça t’en met plein la tronche. Mais est-ce que tout ça tient la route ?
On passera vite sur la piste précédemment résumée, « This Is Gonna Hurt » en soulignant qu’en dehors du fait qu’elle prend la pole position et est l’éponyme de l’album, elle comptera peu d’atouts pour le reste.
C’est alors que nos musiciens nous sortent le grand jeu : « Lies Of The Beautiful People ». Tube radiophonique sans conteste. N’y voyez rien de dépréciatif, car même s’il a l’apanage de s’enregistrer à la première écoute : il a aussi la verve des compositions qui cachent bien leur jeu. Tout sonne de manière triomphale et nous file la banane en un temps record.
On retrouve la rage contenue dans le premier album au fil de piste comme « Live Forever » aux accords stridents et solo à se rouler par terre. Mais celui qui nous rappelle sans le moindre effort la belle originalité de The Heroin Diaries, c’est sans l’ombre d’un doute le somptueux « Goodbye My Friends » où tout est déployé à outrance mais majestueusement, du chant assimilable à celui de Matthew Bellamy (MUSE), jusqu’à la guitare aiguisée qui vient limer la frappe tenace de Joshua Stevens (batterie), le tout bien évidemment sublimé par la basse du maître.
On aura bien du mal à ne pas classer dans le Post-Grunge ou Néo Metal certaines de leurs chansonnettes : « Are You With Me », « Didlihood », etc… Toutefois il faut bien le reconnaître, tout ça semble facile et c’est tristement ce qui le démarquera de son aîné. Où est donc passé le grain de folie d’avant ? Surement dans la pochette complètement hors-sujet à la vue du manque d’agressivité.
En revanche « Oh My God » m’aura donné envie d’une belle ballade au volant d’une Ford Mustang décapotable cheveux au vent (oui, ça va, je sais Monsieur Blasphy, j’ai les cheveux courts et alors ?). Ses accords aériens à la Thelma et Louise m’ont fait voyager.
Même si pour certains, les ballades tombent facilement dans la mièvrerie, SIXX:A.M. n’en a que peu abusé ici, mais c’est à la perfection qu’ils réserveront la plus belle pour clôturer This Is Gonna Hurt. « Skin » offrira son lot de poils dressés sur les bras et de petits cœurs qui tomberont en miettes en raison d’un James Michael (chant) désespéré.
Ne vous attendez pas à une quelconque déception, mais ne voyez pas non plus en This Is Gonna Hurt le clone d’une autobiographie déjà contée dans The Heroin Diaries. Celui-ci a sa propre personnalité maculée de chacune des qualités qui font l’empreinte du groupe et ravira les oreilles des fans de la première heure, et j’en suis !
Ajouté : Mardi 07 Juin 2011
Chroniqueur : Line44
Score : 
Lien en relation: Six:A.M. Website
Hits: 8924
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
