#
# 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
}
DREAM THEATER (usa) - Images And Words (1992)
Label : Amphetamine Reptile
Sortie du Scud : 1992
Pays : Etats-Unis
Genre : Metal Progressif
Type : Album
Playtime : 8 Titres - 57 Mins
Quand on me parle de DREAM THEATER, le premier album qui me vient à l’esprit est Images And Words. Il est pour moi le meilleur album du groupe. Rien que ça. Et pourtant, ils en ont fait des excellents, mais celui-ci surpasse tous les autres. Et ce grâce à quelques titres tout simplement hallucinants. Mais reprenons depuis le début. DREAM THEATER n’a en rien inventé le Metal Progressif (ceux qui le pensent devrait se rappeler que le monde a tourné avant leur naissance et qu’il y a eu, entre autre, les années 70). Par contre, Images And Words a clairement redéfini les bases de ce que serait le Metal Progressif des années 90 et suivantes. Ça, c’est indéniable. Il faut dire que le groupe a de quoi faire valoir ses arguments. Cinq musiciens qui maîtrisent parfaitement leurs instruments et dotés d’un talent de composition qu’on ne retrouve pas chez tous les musiciens techniquement bons. Une envie de faire une musique à la fois ultra technique dans laquelle les virtuoses se retrouvent et à la fois accessible à ceux qui ne sont pas de grands techniciens ou qui veulent juste prendre du plaisir à l’écoute des morceaux. Et allier les deux n’est en rien évident. Ils sont pléthore les groupes progressifs qui savent jouer mais qui offrent une musique hermétique au plus grand monde. Avec Images And Words, DREAM THEATER a démontré que faire un album technique et dont on ne décroche pas est possible. Bon, il a bien fallu se séparer de l’insupportable chanteur Charlie Dominici, qui a gâché leur premier album. C’est don James LaBrie qui reprend la place. Et tout de suite on sent qu’on ne joue pas dans la même catégorie. On peut donc passer aux choses sérieuses.
Commençons par parler des morceaux qui fâchent généralement : « Another Day » et « Surrounded ». Personnellement, je trouve que ces morceaux s’intègrent parfaitement dans l’album. Ils sont quand même très techniques, faut pas se leurrer et offrent de petites pauses bienfaisantes dans une écoute qui aurait pu sinon être un rien trop riche en calories. Et puis, ils possèdent comme tous les morceaux ce côté romantique. Parce que tout l’album est teinté de romantisme. Pas un truc gnangnan, mais un vrai romantisme dans la composition et l’approche des thèmes.
Ensuite, on peut parler des morceaux comme « Pull Me Under » ou « Under A Glass Moon », qui sont de bons morceaux progressifs dans lesquels le groupe prend plaisir. Ils permettent de mettre l’auditeur dans les conditions nécessaires pour accéder au niveau supérieur et rencontrer le boss de fin de niveau. Celui-ci est représenté par « Learning To Live » et « Metropolis - Part I ». Ces deux morceaux sont les piliers de l’album. Le premier est une pure jouissance, qui se permet même de reprendre la mélodie de « Wait For Sleep » et de varier tout autour, sur une deuxième moitié de morceau. Le deuxième, « Metropolis - Part I », est tout bonnement à mes yeux le meilleur morceau que le groupe composa et composera (oui, je sais, mais j’assume mon propos). C’est à la fois sensible, émouvant, technique, alambiqué et terriblement accessible. On n’est pas obligé d’écouter le morceau cinquante fois pour rentrer dedans, même s’il faut le faire pour en retirer toutes les subtilités. Un véritable moment de musique divine.
Au niveau des musiciens, ce sont tous de très bons techniciens et de bons compositeurs. Quoi qu’on en dise, John Myung est impressionnant à voir jouer. Et il tient la dragée haute à John Petrucci alors qu’il joue de la basse sans médiator. Petrucci et Kevin Moore s’amusent dans des questions/réponses à la guitare et au clavier, ou même se suivent dans des déchainements de notes d’une grande virtuosité. Et bien sûr, on a Mike Portnoy derrière ses fûts qui assure comme un dieu. Le seul problème dans son jeu est la monotonie de sa double grosse caisse.
Pour toutes ces raisons, Images And Words est un album qui, malgré le temps qui passe, demeure excellent. Bien sûr, on peut lui reprocher un trop plein de romantisme ce qui se traduit par un son pas forcément très agressif à la guitare, mais c’est justement pour cela que j’aime encore l’écouter. Si je veux un son de guitare qui arrache plus, je me tourne vers SYMPHONY X. En tous cas, cet album est vraiment un incontournable de la scène Metal Progressif. Encore aujourd’hui et sûrement encore demain.
Ajouté : Mercredi 16 Juillet 2008
Chroniqueur : Wong Li
Score :  
Lien en relation: Dream Theater Website
Hits: 13021
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
