#
# 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
}
ABIGAIL WILLIAMS (usa) - In The Shadow Of A Thousand Suns (2008)
Label : Candlelight Records / Season of Mist
Sortie du Scud : 20 octobre 2008
Pays : Etats-Unis
Genre : Sympho Black Metal aux arrangements subtils
Type : Album
Playtime : 10 Titres - 47 Mins
Loin est le temps où le Black Metal ne provenait que des pays scandinaves, où la rigueur du climat influait sur une musique glacée et pourtant si impétueuse…Aujourd’hui, le Metal noir surgit des quatre coins du globe, et peut importe l’horizon, les mélodies se fardent de ténèbres et essaient tant bien que mal de reproduire les cauchemars sonores de leurs aînés…
Prenez ABIGAIL WILLIAMS par exemple. Venant de l’Ohio, les armes nécessaires à la construction de structures chaotiques et menaçantes n’étaient pas forcément présentes dès le départ, il n’en reste pas moins qu’ils ont presque réussi à nous faire croire que leur terre natale se situait près de la Suède….
Il faut dire que les atouts sont nombreux dans la manche de leurs grands manteaux de pluie, avec James Murphy à la production et Trym (ex EMPEROR et ZYKLON) au drum-kit, pas de doutes, le résultat à de quoi convaincre.
Au niveau de la production, c’est du massif justement. Un son opaque, lourd qui s’accorde bien avec les tendances symphoniques du combo. On pourrait reprocher dans un élan tatillon un son de clavier un peu light parfois, mais c’est un symptôme qu’on retrouve très souvent sur les albums de cette catégorie.
Et pour une fois justement que les arrangements travaillés sonnent juste, il serait dommage se s’arrêter à de telles considérations.
Car a contrario d’un CRADLE qui confond souvent arrangements et gimmicks insupportables, ABIGAIL WILLIAMS sait mâtiner son discours de lignes de synthé volubiles et captivantes, et de guitares acoustiques bien senties. Ainsi, un titre comme « The Departure » illustre à merveille ce propos, et passe par toutes les ambiances possibles, évoquant même parfois un SAVATAGE de la grande époque.
Mais le ton général, et cela n’étonnera personne, reste dans la plus droite lignée d’un EMPEROR, celui de Anthems To The Welkin At Dusk, un cran en dessous au niveau de l’inspiration et de la grandiloquence bien sur.
Les vocaux écorchés restent très monocordes, et le tempo ne varie guère…Nous restons sur le terrain des blast-beats à outrance, agrémentés de riffs solides, quoiqu’un poil roboratifs, mais ne soyons pas totalement négatifs, car si In The Shadow Of A Thousand Suns n’a pas la dimension de Storm Of The Lights Bane, il reste quand même à des lieues de la majorité des pompeurs internationaux se contentant de refiler la même recette album après album, sans aucune volonté d’innovation.
Des morceaux comme « Empyrean Into The Cold Wastes », ou encore « Floods » sauront vous convaincre de l’utilité de l’entreprise, et l’intermède « A Semblance Of Life » et son petit coté NINE INCH NAILS vs HECATE ENTHRONED se chargera de mettre l’ambiance lors de vos messes noires du Sabbat.
Rien de bien neuf chez les petits cousins américains du Malin, mais un album bien ficelé qui s’écoute sans déplaisir. Ce qui, dans les rangs serrés du Black Metal est déjà une belle réussite.
LUCIFER n’a pas à s’en faire, ses enfants ont encore une santé de fer !
Ajouté : Jeudi 16 Avril 2009
Chroniqueur : Mortne2001
Score :  
Lien en relation: Abigail Williams Website
Hits: 9513
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
