www/ecrire/public/interfaces.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2019                                                *
   7  *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
   8  *                                                                         *
   9  *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
  10  *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
  11 \***************************************************************************/
  12
  13 /**
  14  * Définition des noeuds de l'arbre de syntaxe abstraite
  15  *
  16  * @package SPIP\Core\Compilateur\AST
  17  **/
  18
  19 if (!defined('_ECRIRE_INC_VERSION')) {
  20         return;
  21 }
  22
  23
  24 /**
  25  * Description d'un contexte de compilation
  26  *
  27  * Objet simple pour stocker le nom du fichier, la ligne, la boucle
  28  * permettant entre autre de localiser le lieu d'une erreur de compilation.
  29  * Cette structure est nécessaire au traitement d'erreur à l'exécution.
  30  *
  31  * Le champ code est inutilisé dans cette classe seule, mais harmonise
  32  * le traitement d'erreurs.
  33  *
  34  * @package SPIP\Core\Compilateur\AST
  35  */
  36 class Contexte {
  37         /**
  38          * Description du squelette
  39          *
  40          * Sert pour la gestion d'erreur et la production de code dependant du contexte
  41          *
  42          * Peut contenir les index :
  43          *
  44          * - nom : Nom du fichier de cache
  45          * - gram : Nom de la grammaire du squelette (détermine le phraseur à utiliser)
  46          * - sourcefile : Chemin du squelette
  47          * - squelette : Code du squelette
  48          * - id_mere : Identifiant de la boucle parente
  49          * - documents : Pour embed et img dans les textes
  50          * - session : Pour un cache sessionné par auteur
  51          * - niv : Niveau de tabulation
  52          *
  53          * @var array
  54          */
  55         public $descr = array();
  56
  57         /**
  58          * Identifiant de la boucle
  59          *
  60          * @var string
  61          */
  62         public $id_boucle = '';
  63
  64         /**
  65          * Numéro de ligne dans le code source du squelette
  66          *
  67          * @var int
  68          */
  69         public $ligne = 0;
  70
  71         /**
  72          * Langue d'exécution
  73          *
  74          * @var string
  75          */
  76         public $lang = '';
  77
  78         /**
  79          * Résultat de la compilation: toujours une expression PHP
  80          *
  81          * @var string
  82          */
  83         public $code = '';
  84 }
  85
  86
  87 /**
  88  * Description d'un texte
  89  *
  90  * @package SPIP\Core\Compilateur\AST
  91  **/
  92 class Texte {
  93         /**
  94          * Type de noeud
  95          *
  96          * @var string
  97          */
  98         public $type = 'texte';
  99
 100         /**
 101          * Le texte
 102          *
 103          * @var string
 104          */
 105         public $texte;
 106
 107         /**
 108          * Contenu avant le texte.
 109          *
 110          * Vide ou apostrophe simple ou double si le texte en était entouré
 111          *
 112          * @var string|array
 113          */
 114         public $avant = "";
 115
 116         /**
 117          * Contenu après le texte.
 118          *
 119          * Vide ou apostrophe simple ou double si le texte en était entouré
 120          *
 121          * @var string|array
 122          */
 123         public $apres = "";
 124
 125         /**
 126          * Numéro de ligne dans le code source du squelette
 127          *
 128          * @var int
 129          */
 130         public $ligne = 0;
 131 }
 132
 133 /**
 134  * Description d'une inclusion de squelette
 135  *
 136  * @package SPIP\Core\Compilateur\AST
 137  **/
 138 class Inclure {
 139         /**
 140          * Type de noeud
 141          *
 142          * @var string
 143          */
 144         public $type = 'include';
 145
 146         /**
 147          * Nom d'un fichier inclu
 148          *
 149          * - Objet Texte si inclusion d'un autre squelette
 150          * - chaîne si inclusion d'un fichier PHP directement
 151          *
 152          * @var string|Texte
 153          */
 154         public $texte;
 155
 156         /**
 157          * Inutilisé, propriété générique de l'AST
 158          *
 159          * @var string|array
 160          */
 161         public $avant = '';
 162
 163         /**
 164          * Inutilisé, propriété générique de l'AST
 165          *
 166          * @var string|array
 167          */
 168         public $apres = '';
 169
 170         /**
 171          * Numéro de ligne dans le code source du squelette
 172          *
 173          * @var int
 174          */
 175         public $ligne = 0;
 176
 177         /**
 178          * Valeurs des paramètres
 179          *
 180          * @var array
 181          */
 182         public $param = array();
 183 }
 184
 185
 186 /**
 187  * Description d'une boucle
 188  *
 189  * @package SPIP\Core\Compilateur\AST
 190  **/
 191 class Boucle {
 192         /**
 193          * Type de noeud
 194          *
 195          * @var string
 196          */
 197         public $type = 'boucle';
 198
 199         /**
 200          * Identifiant de la boucle
 201          *
 202          * @var string
 203          */
 204         public $id_boucle;
 205
 206         /**
 207          * Identifiant de la boucle parente
 208          *
 209          * @var string
 210          */
 211         public $id_parent = '';
 212
 213         /**
 214          * Partie optionnelle avant
 215          *
 216          * @var string|array
 217          */
 218         public $avant = '';
 219
 220         /**
 221          * Pour chaque élément
 222          *
 223          * @var string|array
 224          */
 225         public $milieu = '';
 226
 227         /**
 228          * Partie optionnelle après
 229          *
 230          * @var string|array
 231          */
 232         public $apres = '';
 233
 234         /**
 235          * Partie alternative, si pas de résultat dans la boucle
 236          *
 237          * @var string|array
 238          */
 239         public $altern = '';
 240
 241         /**
 242          * La boucle doit-elle sélectionner la langue ?
 243          *
 244          * @var string|null
 245          */
 246         public $lang_select;
 247
 248         /**
 249          * Alias de table d'application de la requête ou nom complet de la table SQL
 250          *
 251          * @var string|null
 252          */
 253         public $type_requete;
 254
 255         /**
 256          * La table est elle optionnelle ?
 257          *
 258          * Si oui, aucune erreur ne sera générée si la table demandée n'est pas présente
 259          *
 260          * @var bool
 261          */
 262         public $table_optionnelle = false;
 263
 264         /**
 265          * Nom du fichier de connexion
 266          *
 267          * @var string
 268          */
 269         public $sql_serveur = '';
 270
 271         /**
 272          * Paramètres de la boucle
 273          *
 274          * Description des paramètres passés à la boucle, qui servent ensuite
 275          * au calcul des critères
 276          *
 277          * @var array
 278          */
 279         public $param = array();
 280
 281         /**
 282          * Critères de la boucle
 283          *
 284          * @var Critere[]
 285          */
 286         public $criteres = array();
 287
 288         /**
 289          * Textes insérés entre 2 éléments de boucle (critère inter)
 290          *
 291          * @var string[]
 292          */
 293         public $separateur = array();
 294
 295         /**
 296          * Liste des jointures possibles avec cette table
 297          *
 298          * Les jointures par défaut de la table sont complétées en priorité
 299          * des jointures déclarées explicitement sur la boucle
 300          *
 301          * @see base_trouver_table_dist()
 302          * @var array
 303          */
 304         public $jointures = array();
 305
 306         /**
 307          * Jointures explicites avec cette table
 308          *
 309          * Ces jointures sont utilisées en priorité par rapport aux jointures
 310          * normales possibles pour retrouver les colonnes demandées extérieures
 311          * à la boucle.
 312          *
 313          * @var string|bool
 314          */
 315         public $jointures_explicites = false;
 316
 317         /**
 318          * Nom de la variable PHP stockant le noms de doublons utilisés "$doublons_index"
 319          *
 320          * @var string|null
 321          */
 322         public $doublons;
 323
 324         /**
 325          * Code PHP ajouté au début de chaque itération de boucle.
 326          *
 327          * Utilisé entre autre par les critères {pagination}, {n-a,b}, {a/b}...
 328          *
 329          * @var string
 330          */
 331         public $partie = "";
 332
 333         /**
 334          * Nombre de divisions de la boucle, d'éléments à afficher,
 335          * ou de soustractions d'éléments à faire
 336          *
 337          * Dans les critères limitant le nombre d'éléments affichés
 338          * {a,b}, {a,n-b}, {a/b}, {pagination b}, b est affecté à total_parties.
 339          *
 340          * @var string
 341          */
 342         public $total_parties = "";
 343
 344         /**
 345          * Code PHP ajouté avant l'itération de boucle.
 346          *
 347          * Utilisé entre autre par les critères {pagination}, {a,b}, {a/b}
 348          * pour initialiser les variables de début et de fin d'itération.
 349          *
 350          * @var string
 351          */
 352         public $mode_partie = '';
 353
 354         /**
 355          * Identifiant d'une boucle qui appelle celle-ci de manière récursive
 356          *
 357          * Si une boucle est appelée de manière récursive quelque part par
 358          * une autre boucle comme <BOUCLE_rec(boucle_identifiant) />, cette
 359          * boucle (identifiant) reçoit dans cette propriété l'identifiant
 360          * de l'appelant (rec)
 361          *
 362          * @var string
 363          */
 364         public $externe = '';
 365
 366         // champs pour la construction de la requete SQL
 367
 368         /**
 369          * Liste des champs à récupérer par la boucle
 370          *
 371          * Expression 'table.nom_champ' ou calculée 'nom_champ AS x'
 372          *
 373          * @var string[]
 374          */
 375         public $select = array();
 376
 377         /**
 378          * Liste des alias / tables SQL utilisées dans la boucle
 379          *
 380          * L'index est un identifiant (xx dans spip_xx assez souvent) qui servira
 381          * d'alias au nom de la table ; la valeur est le nom de la table SQL désirée.
 382          *
 383          * L'index 0 peut définir le type de sources de données de l'itérateur DATA
 384          *
 385          * @var string[]
 386          */
 387         public $from = array();
 388
 389         /**
 390          * Liste des alias / type de jointures utilisées dans la boucle
 391          *
 392          * L'index est le nom d'alias (comme pour la propriété $from), et la valeur
 393          * un type de jointure parmi 'INNER', 'LEFT', 'RIGHT', 'OUTER'.
 394          *
 395          * Lorsque le type n'est pas déclaré pour un alias, c'est 'INNER'
 396          * qui sera utilisé par défaut (créant donc un INNER JOIN).
 397          *
 398          * @var string[]
 399          */
 400         public $from_type = array();
 401
 402         /**
 403          * Liste des conditions WHERE de la boucle
 404          *
 405          * Permet de restreindre les éléments retournés par une boucle
 406          * en fonctions des conditions transmises dans ce tableau.
 407          *
 408          * Ce tableau peut avoir plusieurs niveaux de profondeur.
 409          *
 410          * Les éléments du premier niveau sont reliés par des AND, donc
 411          * chaque élément ajouté directement au where par
 412          * $boucle->where[] = array(...) ou $boucle->where[] = "'expression'"
 413          * est une condition AND en plus.
 414          *
 415          * Par contre, lorsqu'on indique un tableau, il peut décrire des relations
 416          * internes différentes. Soit $expr un tableau d'expressions quelconques de 3 valeurs :
 417          * $expr = array(operateur, val1, val2)
 418          *
 419          * Ces 3 valeurs sont des expressions PHP. L'index 0 désigne l'opérateur
 420          * à réaliser tel que :
 421          *
 422          * - "'='" , "'>='", "'<'", "'IN'", "'REGEXP'", "'LIKE'", ... :
 423          *    val1 et val2 sont des champs et valeurs à utiliser dans la comparaison
 424          *    suivant cet ordre : "val1 operateur val2".
 425          *    Exemple : $boucle->where[] = array("'='", "'articles.statut'", "'\"publie\"'");
 426          * - "'AND'", "'OR'", "'NOT'" :
 427          *    dans ce cas val1 et val2 sont également des expressions
 428          *    de comparaison complètes, et peuvent être eux-même des tableaux comme $expr
 429          *    Exemples :
 430          *    $boucle->where[] = array("'OR'", $expr1, $expr2);
 431          *    $boucle->where[] = array("'NOT'", $expr); // val2 n'existe pas avec NOT
 432          *
 433          * D'autres noms sont possibles pour l'opérateur (le nombre de valeurs diffère) :
 434          * - "'SELF'", "'SUBSELECT'" : indiquent des sous requêtes
 435          * - "'?'" : indique une condition à faire évaluer (val1 ? val2 : val3)
 436          *
 437          * @var array
 438          */
 439         public $where = array();
 440
 441         public $join = array();
 442         public $having = array();
 443         public $limit;
 444         public $group = array();
 445         public $order = array();
 446         public $default_order = array();
 447         public $date = 'date';
 448         public $hash = "";
 449         public $in = "";
 450         public $sous_requete = false;
 451
 452         /**
 453          * Code PHP qui sera ajouté en tout début de la fonction de boucle
 454          *
 455          * Il sert à insérer le code calculant une hierarchie
 456          *
 457          * @var string
 458          */
 459         public $hierarchie = '';
 460
 461         /**
 462          * Indique la présence d'un critère sur le statut
 463          *
 464          * @deprecated Remplacé par $boucle->modificateur['criteres']['statut']
 465          * @var bool
 466          */
 467         public $statut = false;
 468
 469         // champs pour la construction du corps PHP
 470
 471         /**
 472          * Description des sources de données de la boucle
 473          *
 474          * Description des données de la boucle issu de trouver_table
 475          * dans le cadre de l'itérateur SQL et contenant au moins l'index 'field'.
 476          *
 477          * @see base_trouver_table_dist()
 478          * @var array
 479          */
 480         public $show = array();
 481
 482         /**
 483          * Nom de la table SQL principale de la boucle, sans son préfixe
 484          *
 485          * @var string
 486          */
 487         public $id_table;
 488
 489         /**
 490          * Nom de la clé primaire de la table SQL principale de la boucle
 491          *
 492          * @var string
 493          */
 494         public $primary;
 495
 496         /**
 497          * Code PHP compilé de la boucle
 498          *
 499          * @var string
 500          */
 501         public $return;
 502
 503         public $numrows = false;
 504         public $cptrows = false;
 505
 506         /**
 507          * Description du squelette
 508          *
 509          * Sert pour la gestion d'erreur et la production de code dependant du contexte
 510          *
 511          * Peut contenir les index :
 512          *
 513          * - nom : Nom du fichier de cache
 514          * - gram : Nom de la grammaire du squelette (détermine le phraseur à utiliser)
 515          * - sourcefile : Chemin du squelette
 516          * - squelette : Code du squelette
 517          * - id_mere : Identifiant de la boucle parente
 518          * - documents : Pour embed et img dans les textes
 519          * - session : Pour un cache sessionné par auteur
 520          * - niv : Niveau de tabulation
 521          *
 522          * @var array
 523          */
 524         public $descr = array();
 525
 526         /**
 527          * Numéro de ligne dans le code source du squelette
 528          *
 529          * @var int
 530          */
 531         public $ligne = 0;
 532
 533
 534         public $modificateur = array(); // table pour stocker les modificateurs de boucle tels que tout, plat ..., utilisable par les plugins egalement
 535
 536         /**
 537          * Type d'itérateur utilisé pour cette boucle
 538          *
 539          * - 'SQL' dans le cadre d'une boucle sur une table SQL
 540          * - 'DATA' pour l'itérateur DATA, ...
 541          *
 542          * @var string
 543          */
 544         public $iterateur = ''; // type d'iterateur
 545
 546         /**
 547          * Index de la boucle dont le champ présent dans cette boucle est originaire,
 548          * notamment si le champ a été trouve dans une boucle parente
 549          *
 550          * Tableau nom du champ => index de boucle
 551          *
 552          * @var array $index_champ
 553         */
 554         public $index_champ = [];
 555
 556         // obsoletes, conserves provisoirement pour compatibilite
 557         public $tout = false;
 558         public $plat = false;
 559         public $lien = false;
 560 }
 561
 562 /**
 563  * Description d'un critère de boucle
 564  *
 565  * Sous-noeud de Boucle
 566  *
 567  * @package SPIP\Core\Compilateur\AST
 568  **/
 569 class Critere {
 570         /**
 571          * Type de noeud
 572          *
 573          * @var string
 574          */
 575         public $type = 'critere';
 576
 577         /**
 578          * Opérateur (>, <, >=, IN, ...)
 579          *
 580          * @var null|string
 581          */
 582         public $op;
 583
 584         /**
 585          * Présence d'une négation (truc !op valeur)
 586          *
 587          * @var null|string
 588          */
 589         public $not;
 590
 591         /**
 592          * Présence d'une exclusion (!truc op valeur)
 593          *
 594          * @var null|string
 595          */
 596         public $exclus;
 597
 598         /**
 599          * Présence d'une condition dans le critère (truc ?)
 600          *
 601          * @var bool
 602          */
 603         public $cond = false;
 604
 605         /**
 606          * Paramètres du critère
 607          * - $param[0] : élément avant l'opérateur
 608          * - $param[1..n] : éléments après l'opérateur
 609          *
 610          * @var array
 611          */
 612         public $param = array();
 613
 614         /**
 615          * Numéro de ligne dans le code source du squelette
 616          *
 617          * @var int
 618          */
 619         public $ligne = 0;
 620 }
 621
 622 /**
 623  * Description d'un champ (balise SPIP)
 624  *
 625  * @package SPIP\Core\Compilateur\AST
 626  **/
 627 class Champ {
 628         /**
 629          * Type de noeud
 630          *
 631          * @var string
 632          */
 633         public $type = 'champ';
 634
 635         /**
 636          * Nom du champ demandé. Exemple 'ID_ARTICLE'
 637          *
 638          * @var string|null
 639          */
 640         public $nom_champ;
 641
 642         /**
 643          * Identifiant de la boucle parente si explicité
 644          *
 645          * @var string|null
 646          */
 647         public $nom_boucle = '';
 648
 649         /**
 650          * Partie optionnelle avant
 651          *
 652          * @var null|string|array
 653          */
 654         public $avant;
 655
 656         /**
 657          * Partie optionnelle après
 658          *
 659          * @var null|string|array
 660          */
 661         public $apres;
 662
 663         /**
 664          * Étoiles : annuler des automatismes
 665          *
 666          * - '*' annule les filtres automatiques
 667          * - '**' annule en plus les protections de scripts
 668          *
 669          * @var null|string
 670          */
 671         public $etoile;
 672
 673         /**
 674          * Arguments et filtres explicites sur la balise
 675          *
 676          * - $param[0] contient les arguments de la balise
 677          * - $param[1..n] contient les filtres à appliquer à la balise
 678          *
 679          * @var array
 680          */
 681         public $param = array();
 682
 683         /**
 684          * Source des filtres  (compatibilité) (?)
 685          *
 686          * @var array|null
 687          */
 688         public $fonctions = array();
 689
 690         /**
 691          * Identifiant de la boucle
 692          *
 693          * @var string
 694          */
 695         public $id_boucle = '';
 696
 697         /**
 698          * AST du squelette, liste de toutes les boucles
 699          *
 700          * @var Boucles[]
 701          */
 702         public $boucles;
 703
 704         /**
 705          * Alias de table d'application de la requête ou nom complet de la table SQL
 706          *
 707          * @var string|null
 708          */
 709         public $type_requete;
 710
 711         /**
 712          * Résultat de la compilation: toujours une expression PHP
 713          *
 714          * @var string
 715          */
 716         public $code = '';
 717
 718         /**
 719          * Interdire les scripts
 720          *
 721          * false si on est sûr de cette balise
 722          *
 723          * @see interdire_scripts()
 724          * @var bool
 725          */
 726         public $interdire_scripts = true;
 727
 728         /**
 729          * Description du squelette
 730          *
 731          * Sert pour la gestion d'erreur et la production de code dependant du contexte
 732          *
 733          * Peut contenir les index :
 734          *
 735          * - nom : Nom du fichier de cache
 736          * - gram : Nom de la grammaire du squelette (détermine le phraseur à utiliser)
 737          * - sourcefile : Chemin du squelette
 738          * - squelette : Code du squelette
 739          * - id_mere : Identifiant de la boucle parente
 740          * - documents : Pour embed et img dans les textes
 741          * - session : Pour un cache sessionné par auteur
 742          * - niv : Niveau de tabulation
 743          *
 744          * @var array
 745          */
 746         public $descr = array();
 747
 748         /**
 749          * Numéro de ligne dans le code source du squelette
 750          *
 751          * @var int
 752          */
 753         public $ligne = 0;
 754
 755         /**
 756          * Drapeau pour reperer les balises calculées par une fonction explicite
 757          *
 758          * @var bool
 759          */
 760         public $balise_calculee = false;
 761 }
 762
 763
 764 /**
 765  * Description d'une chaîne de langue
 766  **/
 767 class Idiome {
 768         /**
 769          * Type de noeud
 770          *
 771          * @var string
 772          */
 773         public $type = 'idiome';
 774
 775         /**
 776          * Clé de traduction demandée. Exemple 'item_oui'
 777          *
 778          * @var string
 779          */
 780         public $nom_champ = "";
 781
 782         /**
 783          * Module de langue où chercher la clé de traduction. Exemple 'medias'
 784          *
 785          * @var string
 786          */
 787         public $module = "";
 788
 789         /**
 790          * Arguments à passer à la chaîne
 791          *
 792          * @var array
 793          */
 794         public $arg = array();
 795
 796         /**
 797          * Filtres à appliquer au résultat
 798          *
 799          * @var array
 800          */
 801         public $param = array();
 802
 803         /**
 804          * Source des filtres  (compatibilité) (?)
 805          *
 806          * @var array|null
 807          */
 808         public $fonctions = array();
 809
 810         /**
 811          * Inutilisé, propriété générique de l'AST
 812          *
 813          * @var string|array
 814          */
 815         public $avant = '';
 816
 817         /**
 818          * Inutilisé, propriété générique de l'AST
 819          *
 820          * @var string|array
 821          */
 822         public $apres = '';
 823
 824         /**
 825          * Identifiant de la boucle
 826          *
 827          * @var string
 828          */
 829         public $id_boucle = '';
 830
 831         /**
 832          * AST du squelette, liste de toutes les boucles
 833          *
 834          * @var Boucles[]
 835          */
 836         public $boucles;
 837
 838         /**
 839          * Alias de table d'application de la requête ou nom complet de la table SQL
 840          *
 841          * @var string|null
 842          */
 843         public $type_requete;
 844
 845         /**
 846          * Résultat de la compilation: toujours une expression PHP
 847          *
 848          * @var string
 849          */
 850         public $code = '';
 851
 852         /**
 853          * Interdire les scripts
 854          *
 855          * @see interdire_scripts()
 856          * @var bool
 857          */
 858         public $interdire_scripts = false;
 859
 860         /**
 861          * Description du squelette
 862          *
 863          * Sert pour la gestion d'erreur et la production de code dependant du contexte
 864          *
 865          * Peut contenir les index :
 866          * - nom : Nom du fichier de cache
 867          * - gram : Nom de la grammaire du squelette (détermine le phraseur à utiliser)
 868          * - sourcefile : Chemin du squelette
 869          * - squelette : Code du squelette
 870          * - id_mere : Identifiant de la boucle parente
 871          * - documents : Pour embed et img dans les textes
 872          * - session : Pour un cache sessionné par auteur
 873          * - niv : Niveau de tabulation
 874          *
 875          * @var array
 876          */
 877         public $descr = array();
 878
 879         /**
 880          * Numéro de ligne dans le code source du squelette
 881          *
 882          * @var int
 883          */
 884         public $ligne = 0;
 885 }
 886
 887 /**
 888  * Description d'un texte polyglotte (<multi>)
 889  *
 890  * @package SPIP\Core\Compilateur\AST
 891  **/
 892 class Polyglotte {
 893         /**
 894          * Type de noeud
 895          *
 896          * @var string
 897          */
 898         public $type = 'polyglotte';
 899
 900         /**
 901          * Tableau des traductions possibles classées par langue
 902          *
 903          * Tableau code de langue => texte
 904          *
 905          * @var array
 906          */
 907         public $traductions = array();
 908
 909         /**
 910          * Numéro de ligne dans le code source du squelette
 911          *
 912          * @var int
 913          */
 914         public $ligne = 0;
 915 }
 916
 917
 918 global $table_criteres_infixes;
 919 $table_criteres_infixes = array('<', '>', '<=', '>=', '==', '===', '!=', '!==', '<>', '?');
 920
 921 global $exception_des_connect;
 922 $exception_des_connect[] = ''; // ne pas transmettre le connect='' par les inclure
 923
 924
 925 /**
 926  * Déclarer les interfaces de la base pour le compilateur
 927  *
 928  * On utilise une fonction qui initialise les valeurs,
 929  * sans écraser d'eventuelles prédéfinition dans mes_options
 930  * et les envoie dans un pipeline
 931  * pour les plugins
 932  *
 933  * @link http://code.spip.net/@declarer_interfaces
 934  *
 935  * @return void
 936  */
 937 function declarer_interfaces() {
 938
 939         $GLOBALS['table_des_tables']['articles'] = 'articles';
 940         $GLOBALS['table_des_tables']['auteurs'] = 'auteurs';
 941         $GLOBALS['table_des_tables']['rubriques'] = 'rubriques';
 942         $GLOBALS['table_des_tables']['hierarchie'] = 'rubriques';
 943
 944         // definition des statuts de publication
 945         $GLOBALS['table_statut'] = array();
 946
 947         //
 948         // tableau des tables de jointures
 949         // Ex: gestion du critere {id_mot} dans la boucle(ARTICLES)
 950         $GLOBALS['tables_jointures'] = array();
 951         $GLOBALS['tables_jointures']['spip_jobs'][] = 'jobs_liens';
 952
 953         // $GLOBALS['exceptions_des_jointures']['titre_mot'] = array('spip_mots', 'titre'); // pour exemple
 954         $GLOBALS['exceptions_des_jointures']['profondeur'] = array('spip_rubriques', 'profondeur');
 955
 956
 957         if (!defined('_TRAITEMENT_TYPO')) {
 958                 define('_TRAITEMENT_TYPO', 'typo(%s, "TYPO", $connect, $Pile[0])');
 959         }
 960         if (!defined('_TRAITEMENT_RACCOURCIS')) {
 961                 define('_TRAITEMENT_RACCOURCIS', 'propre(%s, $connect, $Pile[0])');
 962         }
 963         if (!defined('_TRAITEMENT_TYPO_SANS_NUMERO')) {
 964                 define('_TRAITEMENT_TYPO_SANS_NUMERO', 'supprimer_numero(typo(%s, "TYPO", $connect, $Pile[0]))');
 965         }
 966         $GLOBALS['table_des_traitements']['BIO'][] = 'safehtml('._TRAITEMENT_RACCOURCIS.')';
 967         $GLOBALS['table_des_traitements']['NOM_SITE']['spip_auteurs'] = 'entites_html(%s)';
 968         $GLOBALS['table_des_traitements']['NOM']['spip_auteurs'] = 'safehtml(%s)';
 969         $GLOBALS['table_des_traitements']['CHAPO'][] = _TRAITEMENT_RACCOURCIS;
 970         $GLOBALS['table_des_traitements']['DATE'][] = 'normaliser_date(%s)';
 971         $GLOBALS['table_des_traitements']['DATE_REDAC'][] = 'normaliser_date(%s)';
 972         $GLOBALS['table_des_traitements']['DATE_MODIF'][] = 'normaliser_date(%s)';
 973         $GLOBALS['table_des_traitements']['DATE_NOUVEAUTES'][] = 'normaliser_date(%s)';
 974         $GLOBALS['table_des_traitements']['DESCRIPTIF'][] = _TRAITEMENT_RACCOURCIS;
 975         $GLOBALS['table_des_traitements']['INTRODUCTION'][] = _TRAITEMENT_RACCOURCIS;
 976         $GLOBALS['table_des_traitements']['NOM_SITE_SPIP'][] = _TRAITEMENT_TYPO;
 977         $GLOBALS['table_des_traitements']['NOM'][] = _TRAITEMENT_TYPO_SANS_NUMERO;
 978         $GLOBALS['table_des_traitements']['AUTEUR'][] = _TRAITEMENT_TYPO;
 979         $GLOBALS['table_des_traitements']['PS'][] = _TRAITEMENT_RACCOURCIS;
 980         $GLOBALS['table_des_traitements']['SOURCE'][] = _TRAITEMENT_TYPO;
 981         $GLOBALS['table_des_traitements']['SOUSTITRE'][] = _TRAITEMENT_TYPO;
 982         $GLOBALS['table_des_traitements']['SURTITRE'][] = _TRAITEMENT_TYPO;
 983         $GLOBALS['table_des_traitements']['TAGS'][] = '%s';
 984         $GLOBALS['table_des_traitements']['TEXTE'][] = _TRAITEMENT_RACCOURCIS;
 985         $GLOBALS['table_des_traitements']['TITRE'][] = _TRAITEMENT_TYPO_SANS_NUMERO;
 986         $GLOBALS['table_des_traitements']['TYPE'][] = _TRAITEMENT_TYPO;
 987         $GLOBALS['table_des_traitements']['DESCRIPTIF_SITE_SPIP'][] = _TRAITEMENT_RACCOURCIS;
 988         $GLOBALS['table_des_traitements']['SLOGAN_SITE_SPIP'][] = _TRAITEMENT_TYPO;
 989         $GLOBALS['table_des_traitements']['ENV'][] = 'entites_html(%s,true)';
 990
 991         // valeur par defaut pour les balises non listees ci-dessus
 992         $GLOBALS['table_des_traitements']['*'][] = false; // pas de traitement, mais permet au compilo de trouver la declaration suivante
 993         // toujours securiser les DATA
 994         $GLOBALS['table_des_traitements']['*']['DATA'] = 'safehtml(%s)';
 995         // expliciter pour VALEUR qui est un champ calcule et ne sera pas protege par le catch-all *
 996         $GLOBALS['table_des_traitements']['VALEUR']['DATA'] = 'safehtml(%s)';
 997
 998
 999         // gerer l'affectation en 2 temps car si le pipe n'est pas encore declare, on ecrase les globales
1000         $interfaces = pipeline('declarer_tables_interfaces',
1001                 array(
1002                         'table_des_tables' => $GLOBALS['table_des_tables'],
1003                         'exceptions_des_tables' => $GLOBALS['exceptions_des_tables'],
1004                         'table_date' => $GLOBALS['table_date'],
1005                         'table_titre' => $GLOBALS['table_titre'],
1006                         'tables_jointures' => $GLOBALS['tables_jointures'],
1007                         'exceptions_des_jointures' => $GLOBALS['exceptions_des_jointures'],
1008                         'table_des_traitements' => $GLOBALS['table_des_traitements'],
1009                         'table_statut' => $GLOBALS['table_statut'],
1010                 ));
1011         if ($interfaces) {
1012                 $GLOBALS['table_des_tables'] = $interfaces['table_des_tables'];
1013                 $GLOBALS['exceptions_des_tables'] = $interfaces['exceptions_des_tables'];
1014                 $GLOBALS['table_date'] = $interfaces['table_date'];
1015                 $GLOBALS['table_titre'] = $interfaces['table_titre'];
1016                 $GLOBALS['tables_jointures'] = $interfaces['tables_jointures'];
1017                 $GLOBALS['exceptions_des_jointures'] = $interfaces['exceptions_des_jointures'];
1018                 $GLOBALS['table_des_traitements'] = $interfaces['table_des_traitements'];
1019                 $GLOBALS['table_statut'] = $interfaces['table_statut'];
1020         }
1021 }
1022
1023 declarer_interfaces();