X-Git-Url: http://git.cyclocoop.org/?p=velocampus%2Fweb%2Fwww.git;a=blobdiff_plain;f=www%2Fecrire%2Fpublic%2Fphraser_html.php;fp=www%2Fecrire%2Fpublic%2Fphraser_html.php;h=80b1c2eb81c8cdb54829d23fca31d536e48451dd;hp=0000000000000000000000000000000000000000;hb=80b4d3e85f78d402ed2e73f8f5d1bf4c19962eed;hpb=aaf970bf4cdaf76689ecc10609048e18d073820c diff --git a/www/ecrire/public/phraser_html.php b/www/ecrire/public/phraser_html.php new file mode 100644 index 0000000..80b1c2e --- /dev/null +++ b/www/ecrire/public/phraser_html.php @@ -0,0 +1,761 @@ +(.*),Uims'); +define('BALISE_IDIOMES',',<:(([a-z0-9_]+):)?([a-z0-9_]+)({([^\|=>]*=[^\|>]*)})?((\|[^>]*)?:>),iS'); + +define('SQL_ARGS', '(\([^)]*\))'); +define('CHAMP_SQL_PLUS_FONC', '`?([A-Z_][A-Z_0-9.]*)' . SQL_ARGS . '?`?'); + +// http://doc.spip.org/@phraser_inclure +function phraser_inclure($texte, $ligne, $result) { + + while (preg_match(BALISE_INCLURE, $texte, $match)) { + $p = strpos($texte,$match[0]); + $debut = substr($texte, 0, $p); + if ($p) $result = phraser_idiomes($debut, $ligne, $result); + $ligne += substr_count($debut, "\n"); + $champ = new Inclure; + $champ->ligne = $ligne; + $ligne += substr_count($match[0], "\n"); + $fichier = @$match[2]; + # assurer ici la migration .php3 => .php + # et de l'ancienne syntaxe INCLURE(page.php3) devenue surperflue + if (preg_match(',^(.*[.]php)3$,', $fichier, $r)) { + $fichier = $r[1]; + } + $champ->texte = ($fichier !== 'page.php') ? $fichier : ''; + $texte = substr($texte, $p+strlen($match[0])); + // on assimile {var=val} a une liste de un argument sans fonction + phraser_args($texte,"/>","",$result,$champ); + if (!$champ->texte OR count($champ->param) > 1) { + include_spip('public/normaliser'); + normaliser_inclure($champ); + } + $texte = substr($champ->apres, strpos($champ->apres, '>')+1); + $champ->apres = ""; + $texte = preg_replace(',^,', '', $texte); + $result[] = $champ; + } + return (($texte==="") ? $result : phraser_idiomes($texte, $ligne, $result)); +} + +// http://doc.spip.org/@phraser_polyglotte +function phraser_polyglotte($texte,$ligne, $result) { + + if (preg_match_all(BALISE_POLYGLOTTE, $texte, $m, PREG_SET_ORDER)) + foreach ($m as $match) { + $p = strpos($texte, $match[0]); + $debut = substr($texte, 0, $p); + if ($p) { + $champ = new Texte; + $champ->texte = $debut; + $champ->ligne = $ligne; + $result[] = $champ; + $ligne += substr_count($champ->texte, "\n"); + } + + $champ = new Polyglotte; + $champ->ligne = $ligne; + $ligne += substr_count($match[0], "\n"); + $lang = ''; + $bloc = $match[1]; + $texte = substr($texte,$p+strlen($match[0])); + while (preg_match("/^[[:space:]]*([^[{]*)[[:space:]]*[[{]([a-z_]+)[]}](.*)$/si", $bloc, $regs)) { + $trad = $regs[1]; + if ($trad OR $lang) + $champ->traductions[$lang] = $trad; + $lang = $regs[2]; + $bloc = $regs[3]; + } + $champ->traductions[$lang] = $bloc; + $result[] = $champ; + } + if ($texte!=="") { + $champ = new Texte; + $champ->texte = $texte; + $champ->ligne = $ligne; + $result[] = $champ; + } + return $result; +} + + +// http://doc.spip.org/@phraser_idiomes +function phraser_idiomes($texte,$ligne,$result) { + + // Reperer les balises de traduction <:module:chaine{argument1=texte,argument2=#BALISE}|filtre1{texte,#BALISE}|filtre2:> + while (preg_match(BALISE_IDIOMES, $texte, $match)) { + $p = strpos($texte, $match[0]); + $debut = substr($texte, 0, $p); + if ($p) $result = phraser_champs($debut, $ligne, $result); + $champ = new Idiome; + $ligne += substr_count($debut, "\n"); + $champ->ligne = $ligne; + $ligne += substr_count($match[0], "\n"); + $texte = substr($texte,$p+strlen($match[0])); + // Stocker les arguments de la balise de traduction + $args=array(); + $vals=preg_split('/,\s*/',$match[5]); + foreach ($vals as $val) { + $arg=preg_split('/\s*=/',$val); + if ($arg[0]) + $args[$arg[0]]=phraser_champs($arg[1], 0, array()); + } + $champ->arg=$args; + $champ->nom_champ = strtolower($match[3]); + $champ->module = $match[2] ? $match[2] : MODULES_IDIOMES; + // pas d'imbrication pour les filtres sur langue + phraser_args(@$match[7], ":", '', array(), $champ); + $result[] = $champ; + } + if ($texte!=="") $result = phraser_champs($texte,$ligne,$result); + return $result; +} + +// http://doc.spip.org/@phraser_champs +function phraser_champs($texte,$ligne,$result) { + while (preg_match("/".NOM_DE_CHAMP."/S", $texte, $match)) { + $p = strpos($texte, $match[0]); + $suite = substr($texte,$p+strlen($match[0])); + if ($match[5] || (strpos($suite[0], "[0-9]") === false)) { + $debut = substr($texte, 0, $p); + if ($p) $result = phraser_polyglotte($debut, $ligne, $result); + $ligne += substr_count($debut, "\n"); + $champ = new Champ; + $champ->ligne = $ligne; + $ligne += substr_count($match[0], "\n"); + $champ->nom_boucle = $match[2]; + $champ->nom_champ = $match[3]; + $champ->etoile = $match[5]; + + if ($suite[0] == '{') { + phraser_arg($suite, '', array(), $champ); + // ce ltrim est une ereur de conception + // mais on le conserve par souci de compatibilite + $texte = ltrim($suite); + // Il faudrait le normaliser dans l'arbre de syntaxe abstraite + // pour faire sauter ce cas particulier a la decompilation. + /* Ce qui suit est malheureusement incomplet pour cela: + if ($n = (strlen($suite) - strlen($texte))) { + $champ->apres = array(new Texte); + $champ->apres[0]->texte = substr($suite,0,$n); + } + */ + } else $texte = $suite; + phraser_vieux($champ); + $result[] = $champ; + } else { + // faux champ + $result = phraser_polyglotte (substr($texte, 0, $p+1), $ligne, $result); + $texte = (substr($texte, $p+1)); + } + } + if ($texte!=="") $result = phraser_polyglotte($texte, $ligne, $result); + return $result; +} + +// Gestion des imbrications: +// on cherche les [..] les plus internes et on les remplace par une chaine +// %###N@ ou N indexe un tableau comportant le resultat de leur analyse +// on recommence tant qu'il y a des [...] en substituant a l'appel suivant + +// http://doc.spip.org/@phraser_champs_etendus +function phraser_champs_etendus($texte, $ligne,$result) { + if ($texte==="") return $result; + $sep = '##'; + while (strpos($texte,$sep)!== false) + $sep .= '#'; + return array_merge($result, phraser_champs_interieurs($texte, $ligne, $sep, array())); +} + +// Analyse les filtres d'un champ etendu et affecte le resultat +// renvoie la liste des lexemes d'origine augmentee +// de ceux trouves dans les arguments des filtres (rare) +// sert aussi aux arguments des includes et aux criteres de boucles +// Tres chevelu + +// http://doc.spip.org/@phraser_args +function phraser_args($texte, $fin, $sep, $result, &$pointeur_champ) { + $texte = ltrim($texte); + while (($texte!=="") && strpos($fin, $texte[0]) === false) { + $result = phraser_arg($texte, $sep, $result, $pointeur_champ); + $texte = ltrim($texte); + } +# mettre ici la suite du texte, +# notamment pour que l'appelant vire le caractere fermant si besoin + $pointeur_champ->apres = $texte; + return $result; +} + +// http://doc.spip.org/@phraser_arg +function phraser_arg(&$texte, $sep, $result, &$pointeur_champ) { + preg_match(",^(\|?[^}{)|]*)(.*)$,ms", $texte, $match); + $suite = ltrim($match[2]); + $fonc = trim($match[1]); + if ($fonc && $fonc[0] == "|") $fonc = ltrim(substr($fonc,1)); + $res = array($fonc); + $err_f = ''; + // cas du filtre sans argument ou du critere / + if (($suite && ($suite[0] != '{')) || ($fonc && $fonc[0] == '/')) { + // si pas d'argument, alors il faut une fonction ou un double | + if (!$match[1]) { + $err_f = array('zbug_erreur_filtre', array('filtre' => $texte)); + erreur_squelette($err_f, $pointeur_champ); + $texte = ''; + } else $texte = $suite; + if ($err_f) $pointeur_champ->param = false; + elseif ($fonc!=='') $pointeur_champ->param[] = $res; + // pour les balises avec faux filtres qui boudent ce dur larbeur + $pointeur_champ->fonctions[] = array($fonc, ''); + return $result; + } + $args = ltrim(substr($suite,1)); // virer le '(' initial + $collecte = array(); + while ($args && $args[0] != '}') { + if ($args[0] == '"') + preg_match ('/^(")([^"]*)(")(.*)$/ms', $args, $regs); + else if ($args[0] == "'") + preg_match ("/^(')([^']*)(')(.*)$/ms", $args, $regs); + else { + preg_match("/^([[:space:]]*)([^,([{}]*([(\[{][^])}]*[])}])?[^,}]*)([,}].*)$/ms", $args, $regs); + if (!strlen($regs[2])) + { + $err_f = array('zbug_erreur_filtre', array('filtre' => $args)); + erreur_squelette($err_f, $pointeur_champ); + $champ->apres = $champ->avant = $args = ""; + break; + } + } + $arg = $regs[2]; + if (trim($regs[1])) { + $champ = new Texte; + $champ->texte = $arg; + $champ->apres = $champ->avant = $regs[1]; + $result[] = $champ; + $collecte[] = $champ; + $args = ltrim($regs[count($regs)-1]); + } else { + if (!preg_match("/".NOM_DE_CHAMP ."([{|])/", $arg, $r)) { + // 0 est un aveu d'impuissance. A completer + $arg = phraser_champs_exterieurs($arg, 0, $sep, $result); + + $args = ltrim($regs[count($regs)-1]); + $collecte = array_merge($collecte, $arg); + $result = array_merge($result, $arg); + } + else { + $n = strpos($args,$r[0]); + $pred = substr($args, 0, $n); + $par = ',}'; + if (preg_match('/^(.*)\($/', $pred, $m)) + {$pred = $m[1]; $par =')';} + if ($pred) { + $champ = new Texte; + $champ->texte = $pred; + $champ->apres = $champ->avant = ""; + $result[] = $champ; + $collecte[] = $champ; + } + $rec = substr($args, $n + strlen($r[0]) -1); + $champ = new Champ; + $champ->nom_boucle = $r[2]; + $champ->nom_champ = $r[3]; + $champ->etoile = $r[5]; + $next = $r[6]; + while ($next=='{') { + phraser_arg($rec, $sep, array(), $champ); + $args = ltrim($rec) ; + $next = $args[0]; + } + while ($next=='|') { + phraser_args($rec, $par, $sep, array(), $champ); + $args = $champ->apres ; + $champ->apres = ''; + $next = $args[0]; + } + // Si erreur de syntaxe dans un sous-argument, propager. + if ($champ->param === false) + $err_f = true; + else phraser_vieux($champ); + if ($par==')') $args = substr($args,1); + $collecte[] = $champ; + $result[] = $champ; + } + } + if ($args[0] == ',') { + $args = ltrim(substr($args,1)); + if ($collecte) {$res[] = $collecte; $collecte = array();} + } + } + if ($collecte) {$res[] = $collecte; $collecte = array();} + $texte = substr($args,1); + $source = substr($suite, 0, strlen($suite) - strlen($texte)); + // propager les erreurs, et ignorer les param vides + if ($pointeur_champ->param !== false) { + if ($err_f) + $pointeur_champ->param = false; + elseif ($fonc!=='' || count($res) > 1) + $pointeur_champ->param[] = $res; + } + // pour les balises avec faux filtres qui boudent ce dur larbeur + $pointeur_champ->fonctions[] = array($fonc, $source); + return $result; +} + + +// http://doc.spip.org/@phraser_champs_exterieurs +function phraser_champs_exterieurs($texte, $ligne, $sep, $nested) { + $res = array(); + while (($p=strpos($texte, "%$sep"))!==false) { + if (!preg_match(',^%'.preg_quote($sep).'([0-9]+)@,', substr($texte,$p), $m)) + break; + $debut = substr($texte,0,$p); + $texte = substr($texte, $p+strlen($m[0])); + if ($p) + $res = phraser_inclure($debut, $ligne, $res); + $ligne += substr_count($debut, "\n"); + $res[]= $nested[$m[1]]; + } + return (($texte==='') ? $res : phraser_inclure($texte, $ligne, $res)); +} + +// http://doc.spip.org/@phraser_champs_interieurs +function phraser_champs_interieurs($texte, $ligne, $sep, $result) { + $i = 0; // en fait count($result) + $x = ""; + + while (true) { + $j=$i; + $n = $ligne; + while (preg_match(CHAMP_ETENDU, $texte, $match)) { + $p = strpos($texte, $match[0]); + $debut = substr($texte, 0, $p); + if ($p) { + $result[$i] = $debut; + $i++; + } + $nom = $match[4]; + $champ = new Champ; + // ca ne marche pas encore en cas de champ imbrique + $champ->ligne = $x ? 0 :($n+substr_count($debut, "\n")); + $champ->nom_boucle = $match[3]; + $champ->nom_champ = $nom; + $champ->etoile = $match[6]; + // phraser_args indiquera ou commence apres + $result = phraser_args($match[7], ")", $sep, $result, $champ); + phraser_vieux($champ); + $champ->avant = + phraser_champs_exterieurs($match[1],$n,$sep,$result); + $debut = substr($champ->apres,1); + $n += substr_count(substr($texte, 0, strpos($texte, $debut)), "\n"); + $champ->apres = phraser_champs_exterieurs($debut,$n,$sep,$result); + + $result[$i] = $champ; + $i++; + $texte = substr($texte,$p+strlen($match[0])); + } + if ($texte!=="") {$result[$i] = $texte; $i++;} + $x =''; + + while($j < $i) { + $z= $result[$j]; + // j'aurais besoin de connaitre le nombre de lignes... + if (is_object($z)) + $x .= "%$sep$j@"; + else + $x.=$z; + $j++; + } + if (preg_match(CHAMP_ETENDU, $x)) + $texte = $x; + else + return phraser_champs_exterieurs($x, $ligne, $sep, $result); + } +} + +function phraser_vieux(&$champ) +{ + $nom = $champ->nom_champ; + if ($nom == 'EMBED_DOCUMENT') { + include_spip('public/normaliser'); + phraser_vieux_emb($champ); + } elseif ($nom == 'EXPOSER') { + include_spip('public/normaliser'); + phraser_vieux_exposer($champ); + } elseif ($champ->param) { + if ($nom == 'FORMULAIRE_RECHERCHE') { + include_spip('public/normaliser'); + phraser_vieux_recherche($champ); + } elseif (preg_match(",^LOGO_[A-Z]+,", $nom)) { + include_spip('public/normaliser'); + phraser_vieux_logos($champ); + } elseif ($nom == 'MODELE') { + include_spip('public/normaliser'); + phraser_vieux_modele($champ); + } elseif ($nom == 'INCLURE' OR $nom == 'INCLUDE') { + include_spip('public/normaliser'); + phraser_vieux_inclu($champ); + } + } +} + +// analyse des criteres de boucle, + +// http://doc.spip.org/@phraser_criteres +function phraser_criteres($params, &$result) { + + $err_ci = ''; // indiquera s'il y a eu une erreur + $args = array(); + $type = $result->type_requete; + $doublons = array(); + foreach($params as $v) { + $var = $v[1][0]; + $param = ($var->type != 'texte') ? "" : $var->texte; + if ((count($v) > 2) && (!preg_match(",[^A-Za-z]IN[^A-Za-z],i",$param))) + { +// plus d'un argument et pas le critere IN: +// detecter comme on peut si c'est le critere implicite LIMIT debut, fin + + if (($var->type != 'texte') || + (strpos("0123456789-", $param[strlen($param)-1]) + !== false)) { + $op = ','; + $not = ""; + } else { + // Le debut du premier argument est l'operateur + preg_match("/^([!]?)([a-zA-Z][a-zA-Z0-9]*)[[:space:]]*(.*)$/ms", $param, $m); + $op = $m[2]; + $not = $m[1]; + // virer le premier argument, + // et mettre son reliquat eventuel + // Recopier pour ne pas alterer le texte source + // utile au debusqueur + + if ($m[3]) { + $texte = new Texte; + $texte->texte = $m[3]; + $v[1][0]= $texte; + } else array_shift($v[1]); + } + array_shift($v); // $v[O] est vide + $crit = new Critere; + $crit->op = $op; + $crit->not = $not; + $crit->exclus =""; + $crit->param = $v; + $args[] = $crit; + } else { + if ($var->type != 'texte') { + // cas 1 seul arg ne commencant pas par du texte brut: + // erreur ou critere infixe "/" + if (($v[1][1]->type != 'texte') || (trim($v[1][1]->texte) !='/')) { + $err_ci = array('zbug_critere_inconnu', + array('critere' => $var->nom_champ)); + erreur_squelette($err_ci, $result); + } else { + $crit = new Critere; + $crit->op = '/'; + $crit->not = ""; + $crit->exclus =""; + $crit->param = array(array($v[1][0]),array($v[1][2])); + $args[] = $crit; + } + } else { + // traiter qq lexemes particuliers pour faciliter la suite + // les separateurs + if ($var->apres) + $result->separateur[] = $param; + elseif (($param == 'tout') OR ($param == 'tous')) + $result->modificateur['tout'] = true; + elseif ($param == 'plat') + $result->modificateur['plat'] = true; + + // Boucle hierarchie, analyser le critere id_article - id_rubrique + // - id_syndic, afin, dans les cas autres que {id_rubrique}, de + // forcer {tout} pour avoir la rubrique mere... + + elseif (!strcasecmp($type, 'hierarchie') AND + ($param == 'id_article' OR $param == 'id_syndic')) + $result->modificateur['tout'] = true; + elseif (!strcasecmp($type, 'hierarchie') AND ($param == 'id_rubrique')) + {;} + else { + // pas d'emplacement statique, faut un dynamique + /// mais il y a 2 cas qui ont les 2 ! + if (($param == 'unique') || (preg_match(',^!?doublons *,', $param))) + { + // cette variable sera inseree dans le code + // et son nom sert d'indicateur des maintenant + $result->doublons = '$doublons_index'; + if ($param == 'unique') $param = 'doublons'; + } + elseif ($param == 'recherche') + // meme chose (a cause de #nom_de_boucle:URL_*) + $result->hash = ' '; + if (preg_match(',^ *([0-9-]+) *(/) *(.+) *$,', $param, $m)) { + $crit = phraser_critere_infixe($m[1], $m[3],$v, '/', '', ''); + } elseif (preg_match(',^([!]?)(' . CHAMP_SQL_PLUS_FONC . + ')[[:space:]]*(\??)(!?)(<=?|>=?|==?|\b(?:IN|LIKE)\b)(.*)$,is', $param, $m)) { + $a2 = trim($m[8]); + if ($a2 AND ($a2[0]=="'" OR $a2[0]=='"') AND ($a2[0]==substr($a2,-1))) + $a2 = substr($a2,1,-1); + $crit = phraser_critere_infixe($m[2], $a2, $v, + (($m[2] == 'lang_select') ? $m[2] : $m[7]), + $m[6], $m[5]); + $crit->exclus = $m[1]; + } elseif (preg_match("/^([!]?)\s*(" . + CHAMP_SQL_PLUS_FONC . + ")\s*(\??)(.*)$/is", $param, $m)) { + // contient aussi les comparaisons implicites ! + // Comme ci-dessus: + // le premier arg contient l'operateur + array_shift($v); + if ($m[6]) { + $v[0][0] = new Texte; + $v[0][0]->texte = $m[6]; + } else { + array_shift($v[0]); + if (!$v[0]) array_shift($v); + } + $crit = new Critere; + $crit->op = $m[2]; + $crit->param = $v; + $crit->not = $m[1]; + $crit->cond = $m[5]; + } + else { + $err_ci = array('zbug_critere_inconnu', + array('critere' => $param)); + erreur_squelette($err_ci, $result); + } + if ((!preg_match(',^!?doublons *,', $param)) || $crit->not) + $args[] = $crit; + else + $doublons[] = $crit; + } + } + } + } + // les doublons non nies doivent etre le dernier critere + // pour que la variable $doublon_index ait la bonne valeur + // cf critere_doublon + if ($doublons) $args= array_merge($args, $doublons); + // Si erreur, laisser la chaine dans ce champ pour le HTTP 503 + if (!$err_ci) $result->criteres = $args; +} + +// http://doc.spip.org/@phraser_critere_infixe +function phraser_critere_infixe($arg1, $arg2, $args, $op, $not, $cond) +{ + $args[0] = new Texte; + $args[0]->texte = $arg1; + $args[0] = array($args[0]); + $args[1][0] = new Texte; + $args[1][0]->texte = $arg2; + $crit = new Critere; + $crit->op = $op; + $crit->not = $not; + $crit->cond = $cond; + $crit->param = $args; + return $crit; +} + +function public_phraser_html_dist($texte, $id_parent, &$boucles, $descr, $ligne=1) { + + $all_res = array(); + + while (($pos_boucle = strpos($texte, BALISE_BOUCLE)) !== false) { + + $err_b = ''; // indiquera s'il y a eu une erreur + $result = new Boucle; + $result->id_parent = $id_parent; + $result->descr = $descr; +# attention: reperer la premiere des 2 balises: pre_boucle ou boucle + + if (!preg_match(",".BALISE_PRE_BOUCLE . '[0-9_],', $texte, $r) + OR ($n = strpos($texte, $r[0]))===false + OR ($n > $pos_boucle) ) { + $debut = substr($texte, 0, $pos_boucle); + $milieu = substr($texte, $pos_boucle); + $k = strpos($milieu, '('); + $id_boucle = trim(substr($milieu, + strlen(BALISE_BOUCLE), + $k - strlen(BALISE_BOUCLE))); + $milieu = substr($milieu, $k); + + } else { + $debut = substr($texte, 0, $n); + $milieu = substr($texte, $n); + $k = strpos($milieu, '>'); + $id_boucle = substr($milieu, + strlen(BALISE_PRE_BOUCLE), + $k - strlen(BALISE_PRE_BOUCLE)); + + if (!preg_match(",".BALISE_BOUCLE . $id_boucle . "[[:space:]]*\(,", $milieu, $r)) { + $err_b = array('zbug_erreur_boucle_syntaxe', array('id' => $id_boucle)); + erreur_squelette($err_b, $result); + } + $pos_boucle = $n; + $n = strpos($milieu, $r[0]); + $result->avant = substr($milieu, $k+1, $n-$k-1); + $milieu = substr($milieu, $n+strlen($id_boucle)+strlen(BALISE_BOUCLE)); + } + $result->id_boucle = $id_boucle; + + preg_match(SPEC_BOUCLE, $milieu, $match); + $result->type_requete = $match[0]; + $milieu = substr($milieu, strlen($match[0])); + $type = $match[1]; + $jointures = trim($match[2]); + $table_optionnelle = ($match[3]); + if ($jointures) { + // on affecte pas ici les jointures explicites, mais dans la compilation + // ou elles seront completees des jointures declarees + $result->jointures_explicites = $jointures; + } + + if ($table_optionnelle){ + $result->table_optionnelle = $type; + } + + // 1ere passe sur les criteres, vu comme des arguments sans fct + // Resultat mis dans result->param + phraser_args($milieu,"/>","",$all_res,$result); + + // En 2e passe result->criteres contiendra un tableau + // pour l'instant on met le source (chaine) : + // si elle reste ici au final, c'est qu'elle contient une erreur + $result->criteres = substr($milieu,0,@strpos($milieu,$result->apres)); + $milieu = $result->apres; + $result->apres = ""; + + // + // Recuperer la fin : + // + if ($milieu[0] === '/') { + $suite = substr($milieu,2); + $milieu = ''; + } else { + $milieu = substr($milieu,1); + $s = BALISE_FIN_BOUCLE . $id_boucle . ">"; + $p = strpos($milieu, $s); + if ($p === false) { + $err_b = array('zbug_erreur_boucle_fermant', + array('id' => $id_boucle)); + erreur_squelette($err_b, $result); + } + + $suite = substr($milieu, $p + strlen($s)); + $milieu = substr($milieu, 0, $p); + } + + $result->milieu = $milieu; + + // + // 1. Recuperer la partie conditionnelle apres + // + $s = BALISE_POST_BOUCLE . $id_boucle . ">"; + $p = strpos($suite, $s); + if ($p !== false) { + $result->apres = substr($suite, 0, $p); + $suite = substr($suite, $p + strlen($s)); + } + + // + // 2. Recuperer la partie alternative + // + $s = BALISE_ALT_BOUCLE . $id_boucle . ">"; + $p = strpos($suite, $s); + if ($p !== false) { + $result->altern = substr($suite, 0, $p); + $suite = substr($suite, $p + strlen($s)); + } + $result->ligne = $ligne + substr_count($debut, "\n"); + $m = substr_count($milieu, "\n"); + $b = substr_count($result->avant, "\n"); + $a = substr_count($result->apres, "\n"); + + if ($p = strpos($type, ':')) { + $result->sql_serveur = substr($type,0,$p); + $type = substr($type,$p+1); + } + $soustype = strtolower($type); + if ($soustype == 'sites') $soustype = 'syndication' ; # alias + + if (!isset($GLOBALS["table_des_tables"][$soustype])) + $soustype = $type; + + $result->type_requete = $soustype; + // Lancer la 2e passe sur les criteres si la 1ere etait bonne + if (!is_array($result->param)) + $err_b = true; + else { + phraser_criteres($result->param, $result); + if (strncasecmp($soustype, TYPE_RECURSIF, strlen(TYPE_RECURSIF)) == 0) { + $result->type_requete = TYPE_RECURSIF; + $args = $result->param; + array_unshift($args, + substr($type, strlen(TYPE_RECURSIF))); + $result->param = $args; + } + } + + $result->avant = public_phraser_html_dist($result->avant, $id_parent,$boucles, $descr, $result->ligne); + $result->apres = public_phraser_html_dist($result->apres, $id_parent,$boucles, $descr, $result->ligne+$b+$m); + $result->altern = public_phraser_html_dist($result->altern,$id_parent,$boucles, $descr, $result->ligne+$a+$m+$b); + $result->milieu = public_phraser_html_dist($milieu, $id_boucle,$boucles, $descr, $result->ligne+$b); + + // Prevenir le generateur de code que le squelette est faux + if ($err_b) $result->type_requete = false; + + // Verifier qu'il n'y a pas double definition + // apres analyse des sous-parties (pas avant). + + if (isset($boucles[$id_boucle])) { + $err_b_d = array('zbug_erreur_boucle_double', + array('id'=>$id_boucle)); + erreur_squelette($err_b_d, $result); + // Prevenir le generateur de code que le squelette est faux + $boucles[$id_boucle]->type_requete = false; + } else + $boucles[$id_boucle] = $result; + $all_res = phraser_champs_etendus($debut, $ligne, $all_res); + $all_res[] = &$boucles[$id_boucle]; + $ligne += substr_count(substr($texte, 0, strpos($texte, $suite)), "\n"); + $texte = $suite; + } + + return phraser_champs_etendus($texte, $ligne, $all_res); +} +?>