#
# 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
}
JUDAS PRIEST (uk) - Jugulator (1997)
Label : SPV
Sortie du Scud : 28 octobre 1997
Pays : Angleterre
Genre : Heavy Thrash Metal
Type : Album
Playtime : 10 Titres - 58 Mins
Il y a une vie après Rob Halford … même si elle paraît bien difficile. Si Glenn Tipton s’est fendu d’un Baptism Of Fire en guise d’album solo, on ne peut pas dire que les membres de JUDAS PRIEST croulent sous le boulot depuis le départ du Metal God, qui lui multiplie les projets (FIGHT puis TWO). A la limite, le monumental Painkiller semble déjà bien loin et le public Metal ne compte plus trop sur le PRIEST …
La rumeur prétend pourtant que Tipton, Downing, Hill et Travis procèdent à des auditions pour débaucher la perle rare. On annonce même pendant un temps le nom de Ralf Scheepers (ex-GAMMA RAY). Mais le massif chanteur allemand n’est pas retenu et part fonder PRIMAL FEAR, son JUDAS PRIEST à lui en quelque sorte. Comparaison inévitable : il est amusant de constater que pour une fois, c’est IRON MAIDEN qui aime prendre des risques puisque la Vierge de Fer a confié le poste de frontman à Blaze Bayley pour remplacer le démissionnaire Bruce Dickinson. Alors que MAIDEN prend une tournure plus sombre (The X-Factor) avec un Blaze à la voix plus grave, JUDAS PRIEST cherche plutôt un chanteur évoluant dans le même registre qu’Halford.
Ce successeur tant attendu débarque en 1997. Il est Américain (né le 13 Septembre 1967), s’appelle Tim Owens et porte le sobriquet de « Ripper ». Il chante dans WINTER’S BANE mais surtout dans un tribute-band à JUDAS PRIEST nommé BRITISH STEEL. Impressionnés par les bandes qu’ils ont reçues, Tipton et consorts n’hésitent pas une seconde. C’est bien Tim « Ripper » Owens qui se charge des parties vocales du nouvel album de JUDAS PRIEST. Sa participation est toutefois minime en termes d’écriture, tous les morceaux sont déjà prêts, mais il réalise alors « un rêve de gosse en jouant avec ses héros ».
Produit par Glenn Tipton, K.K. Downing et Sean Lynch, Jugulator succède à Painkiller au bout de 7 ans et le moins que l’on puisse dire, c’est que la surprise est de taille. Non pas à cause de la prestation de Tim Owens, quasiment parfait de bout en bout alors que la pression reposant sur ses épaules ne doit pas être négligeable, mais plutôt en ce qui concerne l’orientation prise par Tipton et Downing. Le duo a tout composé en repoussant encore plus loin les limites de Painkiller : plus violent, plus écrasant, plus extrême, empruntant aux vieilles (PANTERA) ou nouvelles pointures (MACHINE HEAD) du Thrash Metal. Au moins les titres des chansons (« Dead Meat », « Decapitate », « Death Row », « Brain Dead ») doivent mettre la puce à l’oreille sur ce déluge de férocité ...
Parfois lourd comme les Cowboys de l’Enfer (« Blood Stained », « Death Row »), maléfique à souhait (« Burn In Hell »), nostalgique de Painkiller (« Jugulator »), le PRIEST nouveau intègre des arpèges régulièrement pour donner dans le climat malsain, et profite toujours autant des guitares acérées de son duo légendaire. A la batterie, Scott Travis se lâche encore plus que sur Painkiller, utilise sa double pédale sans aucun complexe et se montre aussi à l’aise sur les tempos les moins rapides. Synthèse ultime de ce JUDAS PRIEST au logo tout neuf, « Bullet Train » arrache tout sur son passage et séduit les plus sceptiques …
Et « Ripper » dans tout ça ? Le bonhomme chante bien, très bien même, adoptant par instants un style plus menaçant et presque Death, au détour de cris suraigus comme sait si bien le faire Rob Halford. Il faut reconnaître que Tim atteint sans aucun mal les notes les plus vicieuses. Il se montre capable de bien des subtilités, voire d’une sensibilité communicative sur « Cathedral Spires », final épique de 9 minutes, alternant mélodie et virulence, considéré comme un futur classique de JUDAS PRIEST.
Jugulator a le mérite, en 1997, de remettre JUDAS PRIEST sur les rails. L’apparition dans les bacs d’un nouveau CD du PRIEST dissipe toute interrogation objective autour du réel niveau de ce disque. Avec le recul, on pourrait le qualifier d’opportuniste car trop axé sur le succès des combos majeurs d’alors. Et puis, on ne saura jamais ce qu’aurait donné Jugulator avec Halford au micro...
Discographie Complète de JUDAS PRIEST :
Rocka Rolla (Album - 1974),
Sad Wings Of Destiny (Album - 1976),
Sin After Sin (Album - 1977),
Stained Class (Album - 1978),
Hell Bent For Leather (Killing Machine) (Album - 1979),
Unleashed In The East (Live - 1979),
British Steel (Album - 1980),
Point Of Entry (Album - 1981),
Screaming For Vengeance (Album - 1982),
Defenders Of The Faith (Album - 1984),
Turbo (Album - 1986),
Priest ... Live! (Live - 1987),
Ram It Down (Album - 1988),
Painkiller (Album - 1990),
Metal Works '73-'93 (Best-Of - 1993),
Jugulator (Album - 1997),
Meltdown (Live - 1998),
Demolition (Album - 2001),
British Steel (DVD - 2001),
Live In London (DVD - 2002),
Live In London (Live - 2003),
Electric Eye (DVD - 2003),
Angel Of Retribution (Album - 2005),
Rising In The East (DVD - 2005),
Nostradamus (Album - 2008),
A Touch Of Evil: Live (Live - 2009),
British Steel - 30th Anniversary Deluxe Edition (Album - 2012),
Redeemer Of Souls (Album - 2014),
Battle Cry (Live - 2016)
Ajouté : Mercredi 09 Septembre 2009
Chroniqueur : NicoTheSpur
Score :  
Lien en relation: Judas Priest Website
Hits: 14633
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
