#
# 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
}
MARILLION (uk) - Less Is More (2009)
Label : Racket Records (Online sale)
Sortie du Scud : 2 octobre 2009
Pays : Angleterre
Genre : Acoustique Riche et Précieux
Type : Album
Playtime : 12 Titres - 57 Mins
Voila pour les plus ouverts d’entre vous, les fans, ou les amateurs de musique douce, mais néanmoins puissante de quoi vous faire les dents.
Après un Happiness Is The Road, riche, rempli de musique luxuriante et d’arrangements épais, MARILLION nous revient avec son exact contraire. Un album d’une simplicité et d’une sobriété le confinant à l’ascétisme, à l’image de sa pochette, magnifique et pure. Less Is More pourrait se concevoir comme l’exact croisement entre le Double Blanc des BEATLES et le No Quarter de Page & Plant. Un mélange entre le regard en arrière mélancolique et la pause salvatrice. La créativité au maximum, comme toujours, mais un certain besoin de recharger les batteries.
MARILLION n’a jamais donné dans la simplicité depuis l’arrivée dans le groupe de Steve HOGARTH. Ils se sont battus contre les fans de FISH, contre une presse toujours plus exigeante, contre le temps, contre les méandres d’un business qu’ils refusent, qu’ils abhorrent. Steve me confiait dans le tour bus que la musique doit rester la propriété d’un artiste, ce en quoi je suis totalement d’accord.
Ecoutez Less Is More pour en être persuadés. MARILLION n’est pas un marchand de vin, ni une superette de quartier. Ils ne vendent pas leurs chansons comme on vend du pâté ou un salon de jardin. Pardonnez-les d’être des esthètes, car vous en êtes les premiers bénéficiaires.
Sur cet album, vous retrouverez un passage en revue de la carrière du gang depuis Season’s End. L’utilité ? Retrouver des pépites à la sauce 2009, paisiblement, tranquillement. Pour cela, les instruments rares ont été sortis du placard, de la même façon que John et Paul recherchaient pour Sergent Pepper tout ce qui pouvait leur tomber sous la main pour enrichir les morceaux.
Et comme à la base, ces dits morceaux sont déjà des trésors d’harmonie, le résultat est tout simplement magnifique.
Cet album n’a rien d’un Unplugged, le groupe s’est livré à un vrai travail de recherche, de combinaisons. Les titres revisités ont été triturés, reformatés, les tonalités parfois changées, réarrangées. Il en ressort une impression de nouveauté, de fraîcheur indéniable. On écoute cet album l’âme en paix, ouverte à tout ce que peut nous offrir le ciel.
Alors oui, il faut être honnête et ne pas raconter n’importe quoi. Less Is More n’a rien à voir avec le MARILLION de Script For A Jester’s Tear, Clutching At Straws ou même de Brave. MARILLION peut difficilement avec cet album avoir une tribune sur un site comme le notre. Et pourtant c’est le cas. Et je ne saurais vous dire pourquoi.
Mais lorsque la voix de Steve H. vous parvient aux oreilles, on oublie les notions de Hard-Rock, de Heavy Metal, et autres sous genres bâtards qui n’intéressent plus guère que les abrutis qui ont besoin d’étiquettes pour ne pas se perdre sur le chemin de la facilité.
Nous parlons de musique ici, pas de style, de catégories ou autres carcans stylistiques qui en ont perdu tant. MARILLION joue et chante pour ceux qui ont envie de les écouter.
Je ne dévoilerai pas l’album dans ces lignes, car cela reviendrait à raconter la fin d’un film à celui qui ne l’a pas vu.
Sachez juste que vous retrouverez deux titres de Marillion.com, trois de Anoraknophobia, et un morceau des albums Season’s End, Brave, Happiness Is The Road, Afraid Of Sunlight, et This Strange Engine. Plus un morceau caché.
Sachez aussi que la guitare de Steve Rothery sonne parfois comme celle d’un certain David Gilmour. Que la batterie de Ian Mosley prend des accents cubains. Que les claviers de Mark Kelly sonnent plus analogiques que la guitare de Muddy Waters. Que la basse de Pete Trewavas est aussi importante que celle de Paul McCartney. Et que le chant de Steve Hogarth est tout simplement divin.
Less Is More se vit.
Qui peut le plus, peut le moins? MARILLION peut plus que ça. Il peut tout.
Ajouté : Mardi 27 Octobre 2009
Chroniqueur : Mortne2001
Score :  
Lien en relation: Marillion Website
Hits: 13401
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
