www/ecrire/public/interfaces.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2017                                                *
   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         // obsoletes, conserves provisoirement pour compatibilite
 547         public $tout = false;
 548         public $plat = false;
 549         public $lien = false;
 550 }
 551
 552 /**
 553  * Description d'un critère de boucle
 554  *
 555  * Sous-noeud de Boucle
 556  *
 557  * @package SPIP\Core\Compilateur\AST
 558  **/
 559 class Critere {
 560         /**
 561          * Type de noeud
 562          *
 563          * @var string
 564          */
 565         public $type = 'critere';
 566
 567         /**
 568          * Opérateur (>, <, >=, IN, ...)
 569          *
 570          * @var null|string
 571          */
 572         public $op;
 573
 574         /**
 575          * Présence d'une négation (truc !op valeur)
 576          *
 577          * @var null|string
 578          */
 579         public $not;
 580
 581         /**
 582          * Présence d'une exclusion (!truc op valeur)
 583          *
 584          * @var null|string
 585          */
 586         public $exclus;
 587
 588         /**
 589          * Présence d'une condition dans le critère (truc ?)
 590          *
 591          * @var bool
 592          */
 593         public $cond = false;
 594
 595         /**
 596          * Paramètres du critère
 597          * - $param[0] : élément avant l'opérateur
 598          * - $param[1..n] : éléments après l'opérateur
 599          *
 600          * @var array
 601          */
 602         public $param = array();
 603
 604         /**
 605          * Numéro de ligne dans le code source du squelette
 606          *
 607          * @var int
 608          */
 609         public $ligne = 0;
 610 }
 611
 612 /**
 613  * Description d'un champ (balise SPIP)
 614  *
 615  * @package SPIP\Core\Compilateur\AST
 616  **/
 617 class Champ {
 618         /**
 619          * Type de noeud
 620          *
 621          * @var string
 622          */
 623         public $type = 'champ';
 624
 625         /**
 626          * Nom du champ demandé. Exemple 'ID_ARTICLE'
 627          *
 628          * @var string|null
 629          */
 630         public $nom_champ;
 631
 632         /**
 633          * Identifiant de la boucle parente si explicité
 634          *
 635          * @var string|null
 636          */
 637         public $nom_boucle = '';
 638
 639         /**
 640          * Partie optionnelle avant
 641          *
 642          * @var null|string|array
 643          */
 644         public $avant;
 645
 646         /**
 647          * Partie optionnelle après
 648          *
 649          * @var null|string|array
 650          */
 651         public $apres;
 652
 653         /**
 654          * Étoiles : annuler des automatismes
 655          *
 656          * - '*' annule les filtres automatiques
 657          * - '**' annule en plus les protections de scripts
 658          *
 659          * @var null|string
 660          */
 661         public $etoile;
 662
 663         /**
 664          * Arguments et filtres explicites sur la balise
 665          *
 666          * - $param[0] contient les arguments de la balise
 667          * - $param[1..n] contient les filtres à appliquer à la balise
 668          *
 669          * @var array
 670          */
 671         public $param = array();
 672
 673         /**
 674          * Source des filtres  (compatibilité) (?)
 675          *
 676          * @var array|null
 677          */
 678         public $fonctions = array();
 679
 680         /**
 681          * Identifiant de la boucle
 682          *
 683          * @var string
 684          */
 685         public $id_boucle = '';
 686
 687         /**
 688          * AST du squelette, liste de toutes les boucles
 689          *
 690          * @var Boucles[]
 691          */
 692         public $boucles;
 693
 694         /**
 695          * Alias de table d'application de la requête ou nom complet de la table SQL
 696          *
 697          * @var string|null
 698          */
 699         public $type_requete;
 700
 701         /**
 702          * Résultat de la compilation: toujours une expression PHP
 703          *
 704          * @var string
 705          */
 706         public $code = '';
 707
 708         /**
 709          * Interdire les scripts
 710          *
 711          * false si on est sûr de cette balise
 712          *
 713          * @see interdire_scripts()
 714          * @var bool
 715          */
 716         public $interdire_scripts = true;
 717
 718         /**
 719          * Description du squelette
 720          *
 721          * Sert pour la gestion d'erreur et la production de code dependant du contexte
 722          *
 723          * Peut contenir les index :
 724          *
 725          * - nom : Nom du fichier de cache
 726          * - gram : Nom de la grammaire du squelette (détermine le phraseur à utiliser)
 727          * - sourcefile : Chemin du squelette
 728          * - squelette : Code du squelette
 729          * - id_mere : Identifiant de la boucle parente
 730          * - documents : Pour embed et img dans les textes
 731          * - session : Pour un cache sessionné par auteur
 732          * - niv : Niveau de tabulation
 733          *
 734          * @var array
 735          */
 736         public $descr = array();
 737
 738         /**
 739          * Numéro de ligne dans le code source du squelette
 740          *
 741          * @var int
 742          */
 743         public $ligne = 0;
 744
 745         /**
 746          * Drapeau pour reperer les balises calculées par une fonction explicite
 747          *
 748          * @var bool
 749          */
 750         public $balise_calculee = false;
 751 }
 752
 753
 754 /**
 755  * Description d'une chaîne de langue
 756  **/
 757 class Idiome {
 758         /**
 759          * Type de noeud
 760          *
 761          * @var string
 762          */
 763         public $type = 'idiome';
 764
 765         /**
 766          * Clé de traduction demandée. Exemple 'item_oui'
 767          *
 768          * @var string
 769          */
 770         public $nom_champ = "";
 771
 772         /**
 773          * Module de langue où chercher la clé de traduction. Exemple 'medias'
 774          *
 775          * @var string
 776          */
 777         public $module = "";
 778
 779         /**
 780          * Arguments à passer à la chaîne
 781          *
 782          * @var array
 783          */
 784         public $arg = array();
 785
 786         /**
 787          * Filtres à appliquer au résultat
 788          *
 789          * @var array
 790          */
 791         public $param = array();
 792
 793         /**
 794          * Source des filtres  (compatibilité) (?)
 795          *
 796          * @var array|null
 797          */
 798         public $fonctions = array();
 799
 800         /**
 801          * Inutilisé, propriété générique de l'AST
 802          *
 803          * @var string|array
 804          */
 805         public $avant = '';
 806
 807         /**
 808          * Inutilisé, propriété générique de l'AST
 809          *
 810          * @var string|array
 811          */
 812         public $apres = '';
 813
 814         /**
 815          * Identifiant de la boucle
 816          *
 817          * @var string
 818          */
 819         public $id_boucle = '';
 820
 821         /**
 822          * AST du squelette, liste de toutes les boucles
 823          *
 824          * @var Boucles[]
 825          */
 826         public $boucles;
 827
 828         /**
 829          * Alias de table d'application de la requête ou nom complet de la table SQL
 830          *
 831          * @var string|null
 832          */
 833         public $type_requete;
 834
 835         /**
 836          * Résultat de la compilation: toujours une expression PHP
 837          *
 838          * @var string
 839          */
 840         public $code = '';
 841
 842         /**
 843          * Interdire les scripts
 844          *
 845          * @see interdire_scripts()
 846          * @var bool
 847          */
 848         public $interdire_scripts = false;
 849
 850         /**
 851          * Description du squelette
 852          *
 853          * Sert pour la gestion d'erreur et la production de code dependant du contexte
 854          *
 855          * Peut contenir les index :
 856          * - nom : Nom du fichier de cache
 857          * - gram : Nom de la grammaire du squelette (détermine le phraseur à utiliser)
 858          * - sourcefile : Chemin du squelette
 859          * - squelette : Code du squelette
 860          * - id_mere : Identifiant de la boucle parente
 861          * - documents : Pour embed et img dans les textes
 862          * - session : Pour un cache sessionné par auteur
 863          * - niv : Niveau de tabulation
 864          *
 865          * @var array
 866          */
 867         public $descr = array();
 868
 869         /**
 870          * Numéro de ligne dans le code source du squelette
 871          *
 872          * @var int
 873          */
 874         public $ligne = 0;
 875 }
 876
 877 /**
 878  * Description d'un texte polyglotte (<multi>)
 879  *
 880  * @package SPIP\Core\Compilateur\AST
 881  **/
 882 class Polyglotte {
 883         /**
 884          * Type de noeud
 885          *
 886          * @var string
 887          */
 888         public $type = 'polyglotte';
 889
 890         /**
 891          * Tableau des traductions possibles classées par langue
 892          *
 893          * Tableau code de langue => texte
 894          *
 895          * @var array
 896          */
 897         public $traductions = array();
 898
 899         /**
 900          * Numéro de ligne dans le code source du squelette
 901          *
 902          * @var int
 903          */
 904         public $ligne = 0;
 905 }
 906
 907
 908 global $table_criteres_infixes;
 909 $table_criteres_infixes = array('<', '>', '<=', '>=', '==', '===', '!=', '!==', '<>', '?');
 910
 911 global $exception_des_connect;
 912 $exception_des_connect[] = ''; // ne pas transmettre le connect='' par les inclure
 913
 914
 915 /**
 916  * Déclarer les interfaces de la base pour le compilateur
 917  *
 918  * On utilise une fonction qui initialise les valeurs,
 919  * sans écraser d'eventuelles prédéfinition dans mes_options
 920  * et les envoie dans un pipeline
 921  * pour les plugins
 922  *
 923  * @link http://code.spip.net/@declarer_interfaces
 924  *
 925  * @return void
 926  */
 927 function declarer_interfaces() {
 928
 929         $GLOBALS['table_des_tables']['articles'] = 'articles';
 930         $GLOBALS['table_des_tables']['auteurs'] = 'auteurs';
 931         $GLOBALS['table_des_tables']['rubriques'] = 'rubriques';
 932         $GLOBALS['table_des_tables']['hierarchie'] = 'rubriques';
 933
 934         // definition des statuts de publication
 935         $GLOBALS['table_statut'] = array();
 936
 937         //
 938         // tableau des tables de jointures
 939         // Ex: gestion du critere {id_mot} dans la boucle(ARTICLES)
 940         $GLOBALS['tables_jointures'] = array();
 941         $GLOBALS['tables_jointures']['spip_jobs'][] = 'jobs_liens';
 942
 943         // $GLOBALS['exceptions_des_jointures']['titre_mot'] = array('spip_mots', 'titre'); // pour exemple
 944         $GLOBALS['exceptions_des_jointures']['profondeur'] = array('spip_rubriques', 'profondeur');
 945
 946         define('_TRAITEMENT_TYPO', 'typo(%s, "TYPO", $connect, $Pile[0])');
 947         define('_TRAITEMENT_RACCOURCIS', 'propre(%s, $connect, $Pile[0])');
 948         define('_TRAITEMENT_TYPO_SANS_NUMERO', 'supprimer_numero(typo(%s), "TYPO", $connect, $Pile[0])');
 949
 950         $GLOBALS['table_des_traitements']['BIO'][] = _TRAITEMENT_RACCOURCIS;
 951         $GLOBALS['table_des_traitements']['CHAPO'][] = _TRAITEMENT_RACCOURCIS;
 952         $GLOBALS['table_des_traitements']['DATE'][] = 'normaliser_date(%s)';
 953         $GLOBALS['table_des_traitements']['DATE_REDAC'][] = 'normaliser_date(%s)';
 954         $GLOBALS['table_des_traitements']['DATE_MODIF'][] = 'normaliser_date(%s)';
 955         $GLOBALS['table_des_traitements']['DATE_NOUVEAUTES'][] = 'normaliser_date(%s)';
 956         $GLOBALS['table_des_traitements']['DESCRIPTIF'][] = _TRAITEMENT_RACCOURCIS;
 957         $GLOBALS['table_des_traitements']['INTRODUCTION'][] = _TRAITEMENT_RACCOURCIS;
 958         $GLOBALS['table_des_traitements']['NOM_SITE_SPIP'][] = _TRAITEMENT_TYPO;
 959         $GLOBALS['table_des_traitements']['NOM'][] = _TRAITEMENT_TYPO_SANS_NUMERO;
 960         $GLOBALS['table_des_traitements']['AUTEUR'][] = _TRAITEMENT_TYPO;
 961         $GLOBALS['table_des_traitements']['PS'][] = _TRAITEMENT_RACCOURCIS;
 962         $GLOBALS['table_des_traitements']['SOURCE'][] = _TRAITEMENT_TYPO;
 963         $GLOBALS['table_des_traitements']['SOUSTITRE'][] = _TRAITEMENT_TYPO;
 964         $GLOBALS['table_des_traitements']['SURTITRE'][] = _TRAITEMENT_TYPO;
 965         $GLOBALS['table_des_traitements']['TAGS'][] = '%s';
 966         $GLOBALS['table_des_traitements']['TEXTE'][] = _TRAITEMENT_RACCOURCIS;
 967         $GLOBALS['table_des_traitements']['TITRE'][] = _TRAITEMENT_TYPO_SANS_NUMERO;
 968         $GLOBALS['table_des_traitements']['TYPE'][] = _TRAITEMENT_TYPO;
 969         $GLOBALS['table_des_traitements']['DESCRIPTIF_SITE_SPIP'][] = _TRAITEMENT_RACCOURCIS;
 970         $GLOBALS['table_des_traitements']['SLOGAN_SITE_SPIP'][] = _TRAITEMENT_TYPO;
 971         $GLOBALS['table_des_traitements']['ENV'][] = 'entites_html(%s,true)';
 972
 973         // valeur par defaut pour les balises non listees ci-dessus
 974         $GLOBALS['table_des_traitements']['*'][] = false; // pas de traitement, mais permet au compilo de trouver la declaration suivante
 975         // toujours securiser les DATA
 976         $GLOBALS['table_des_traitements']['*']['DATA'] = 'safehtml(%s)';
 977         // expliciter pour VALEUR qui est un champ calcule et ne sera pas protege par le catch-all *
 978         $GLOBALS['table_des_traitements']['VALEUR']['DATA'] = 'safehtml(%s)';
 979
 980
 981         // gerer l'affectation en 2 temps car si le pipe n'est pas encore declare, on ecrase les globales
 982         $interfaces = pipeline('declarer_tables_interfaces',
 983                 array(
 984                         'table_des_tables' => $GLOBALS['table_des_tables'],
 985                         'exceptions_des_tables' => $GLOBALS['exceptions_des_tables'],
 986                         'table_date' => $GLOBALS['table_date'],
 987                         'table_titre' => $GLOBALS['table_titre'],
 988                         'tables_jointures' => $GLOBALS['tables_jointures'],
 989                         'exceptions_des_jointures' => $GLOBALS['exceptions_des_jointures'],
 990                         'table_des_traitements' => $GLOBALS['table_des_traitements'],
 991                         'table_statut' => $GLOBALS['table_statut'],
 992                 ));
 993         if ($interfaces) {
 994                 $GLOBALS['table_des_tables'] = $interfaces['table_des_tables'];
 995                 $GLOBALS['exceptions_des_tables'] = $interfaces['exceptions_des_tables'];
 996                 $GLOBALS['table_date'] = $interfaces['table_date'];
 997                 $GLOBALS['table_titre'] = $interfaces['table_titre'];
 998                 $GLOBALS['tables_jointures'] = $interfaces['tables_jointures'];
 999                 $GLOBALS['exceptions_des_jointures'] = $interfaces['exceptions_des_jointures'];
1000                 $GLOBALS['table_des_traitements'] = $interfaces['table_des_traitements'];
1001                 $GLOBALS['table_statut'] = $interfaces['table_statut'];
1002         }
1003 }
1004
1005 declarer_interfaces();