#
# 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
}
TURTLE RAGE (de) - Chambers Of Peace (2015)
Label : Auto-Production
Sortie du Scud : 30 mars 2015
Pays : Allemagne
Genre : Fastcore
Type : EP
Playtime : 10 Titres - 7 Mins
Bon, le Bayern s'est fait éliminer, c'est clair, mais le Real aussi. Alors finalement, vous n'êtes pas si mal lotis que ça les gars.
Et puis, tiens, pour sécher vos larmes, dites vous que vous vous êtes bien battus. Et puis si ça ne suffit pas, j'ai une petite blague du cru pour vous, qui n'en est pas vraiment une en plus. Et vous savez à quel point j'aime votre humour chers amis allemands. Et cette façon que vous avez de vénérer le Heavy de tradition alors que tout le monde est passé à autre chose depuis des siècles.
Mais bon, c'est aussi pour cette fidélité indéfectible qu'on vous admire. Ca, et les tailleurs d'Angela, mettant si bien en valeur sa... politique austère. Non, la blague n'est pas là, elle arrive, juste en dessous.
Alors, c'est l'histoire de trois copains, Fabs, Piti et Tobi, qui s'emmerdent ferme dans leur garage. Les trois gus ont des passions communes. D'abord, le Punk, le Hardcore, la vitesse et la musique qui mord. Mais ils adorent aussi les tortues, et les pizzas. Et du coup, ils se sentent pousser des ailes lorsqu'ils réalisent qu'ils pourraient confondre dans un même hobby leur vénération pour les Tortues Ninja et le Fastcore. Jouer vite, utiliser leurs supers pouvoirs pour aller plus vite que les autres et faire encore plus de boucans les rendit soudain très joyeux. Alors ils commencèrent à graver quelques trucs à la hâte, depuis 2014. Des petits machins sans prétention, juste pour le fun.
Et ils ont continué, jusqu'à nous balancer il y a quelques temps ce truc hyper court, qu'ils n'oseront pas j'espère appeler LP, mais qui durant un peu moins de sept minutes m'a bien fait marrer, tout en me faisant voyager dans le passé.
Le fastcore violent et teigneux, c'est bien. Mais c'est encore mieux quand on y injecte une bonne dose d'humour bien senti, et qu'en plus, on sait jouer. Ce qui est le cas de nos trois hirsutes, du moins selon les standards du style pratiqué.
Fabs, Piti et Tobi ont vite pigé le truc. Ils ont compris la recette, pas de souci. Pour la pizza, pâte fine, olives et anchois, et cuisson à la seconde près.
Pour la musique, c'est la même chose. Structure fine, petite olive et un choix. Celui de privilégier le format court et de ne jamais dépasser la minute. C'est chose faite, puisque le morceau le plus long surnage à peine à cinquante seconde et se planque à la fin du EP.
Musicalement, le bilan est simple. Vocaux criards d'un côté, rauques de l'autre, rythmique volontiers paillarde et ultra rapide, riffs simples et accrocheurs, le tout en respectant la tradition Punk que le Fastcore a adopté depuis ses débuts. On pense souvent à ANAL CUNT dans les moments les plus délurés ("Taste Of Freedom - Places I Know"), et même aux origines du Speedcore des années 80 pour cette façon analogique et amateur de survoler les débats ("Living The Good Life"). A la différence près que TURTLE RAGE joue précis, ne tombe jamais à côté de la flaque (de sauce tomate), et sait trouver des angles d'approche pour que leurs motifs s'incrustent dans nos mémoires.
Alors oui, c'est délibérément rigolard, mais avec en guise de credo une idolâtrie envers des tortues combatives accros à la spécialité italienne, il ne pouvait pas en être autrement. C'est du Fastcore certes, j'en conviens, mais du bon, du simple et qui tourne rond.
Les trois associés ne cherchent pas midi à quatorze heures, surtout qu'à quatorze heures, il est trop tard pour bouffer. Et la pizza c'est sacré. Comme l'humour d'ailleurs ("Modern Stalking", encore un fleuron national au brushing qui fait rire trente ans après sa découverte), la folie soudaine ("Skate That Fucking Shit!" ou comment se réveiller à seize heure et constater qu'on a plus rien à bouffer ni à boire), ou les courses poursuites devant des passants hagards ("Disrespected Boarders", qui bouffe à tous les tempi).
Bon là, je peux y aller, vous avez pigé. TURTLE RAGE, c'est du second degré, efficace, drôle et tenace. Ca va vite, ça ne dure pas longtemps, et pas besoin de beaucoup d'efforts pour apprécier le menu.
Alors vous voyez, pas grave si le Bayern à paumé.
Il vous reste encore plein de gaillards prêts à se battre pour la cause. Et pour vous faire marrer, chers amis allemands.
Parce que la choucroute d'accord, mais la pizza d'abord !
Ajouté : Jeudi 10 Septembre 2015
Chroniqueur : Mortne2001
Score : 
Lien en relation: Turtle Rage Website
Hits: 5520
|
| © Metal-Impact Since 2001 | Webmaster et Rédacteur en chef : Blasphy De Blasphèmar
Rechercher sur M-I
