[BACK]Return to rpl.h CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/rpl.h between versions 1.252 and 1.286

version 1.252, 2014/10/13 07:12:54 version 1.286, 2016/03/15 16:31:15
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.19    RPL/2 (R) version 4.1.25
   Copyright (C) 1989-2014 Dr. BERTRAND Joël    Copyright (C) 1989-2016 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 38 Line 38
 #   ifdef OpenBSD  #   ifdef OpenBSD
 #       define _BSD_SOURCE  #       define _BSD_SOURCE
 #   endif  #   endif
   
   #   ifdef FreeBSD
   #       define __BSD_VISIBLE    1
   #   endif
 #endif  #endif
   
 #ifdef OS2  #ifdef OS2
Line 60 Line 64
 #   define SA_ONSTACK   0  #   define SA_ONSTACK   0
 #endif  #endif
   
   #define DEBUG_TRACE     uprintf("[%d/%X] %s(%d)\n", \
           getpid(), pthread_self(), __FILE__, __LINE__);
   
 /*  /*
 ================================================================================  ================================================================================
Line 212 Line 218
 #       undef HAVE_STACK_OVERFLOW_RECOVERY  #       undef HAVE_STACK_OVERFLOW_RECOVERY
 #   endif  #   endif
   
 #   define HAVE_INLINE  
 #   define GSL_RANGE_CHECK_OFF  #   define GSL_RANGE_CHECK_OFF
 #   include "gsl/gsl_cdf.h"  #   include "gsl/gsl_cdf.h"
 #   include "gsl/gsl_cblas.h"  #   include "gsl/gsl_cblas.h"
Line 323  typedef struct queue_signaux Line 328  typedef struct queue_signaux
     volatile logical1           requete_arret;      volatile logical1           requete_arret;
   
     pthread_t                   thread_signaux;      pthread_t                   thread_signaux;
       pid_t                       controle;
   
     volatile struct      volatile struct
     {      {
Line 347  __EXTERN__ int     f_queue_signaux; Line 353  __EXTERN__ int     f_queue_signaux;
 #   endif  #   endif
 #endif  #endif
   
 #ifdef OS2  
 #   define readline(s) readline_wrapper(s)  
     unsigned char *readline_wrapper(unsigned char *s);  
 #endif  
   
 #if ! defined(UNION_SEMUN) && defined(IPCS_SYSV)  #if ! defined(UNION_SEMUN) && defined(IPCS_SYSV)
 union semun  union semun
 {  {
Line 370  union semun Line 371  union semun
 #   define SIGSTKSZ         65536  #   define SIGSTKSZ         65536
 #endif  #endif
   
   
 /*  /*
 ================================================================================  ================================================================================
   SÉMAPHORES    SÉMAPHORES
Line 515  union semun Line 517  union semun
   
     __EXTERN__ pid_t                pid_processus_pere;      __EXTERN__ pid_t                pid_processus_pere;
   
     __EXTERN__ pthread_mutex_t      mutex_liste_threads      __EXTERN__ pthread_mutex_t      mutex_liste_threads;
                                             __STATIC_MUTEX_INITIALIZATION__;  
     __EXTERN__ pthread_mutex_t      mutex_creation_variable_partagee      __EXTERN__ pthread_mutex_t      mutex_creation_variable_partagee
                                             __STATIC_MUTEX_INITIALIZATION__;                                              __STATIC_MUTEX_INITIALIZATION__;
     __EXTERN__ pthread_mutex_t      mutex_sections_critiques;      __EXTERN__ pthread_mutex_t      mutex_sections_critiques;
Line 525  union semun Line 526  union semun
   
     __EXTERN__ volatile int         routine_recursive;      __EXTERN__ volatile int         routine_recursive;
   
 #   define SEM_FORK             0  #   define SEM_FORK                 0
 #   define SEM_QUEUE                1  #   define SEM_QUEUE                1
 #   define SEM_SIGNALISATION        2  #   define SEM_SIGNALISATION        2
 #   define SEM_ARRET_SIGNALISATION  3  #   define SEM_ARRET_SIGNALISATION  3
Line 568  union semun Line 569  union semun
             stderr, __VA_ARGS__)              stderr, __VA_ARGS__)
 #define fprintf(flux, ...) transliterated_fprintf(s_etat_processus, \  #define fprintf(flux, ...) transliterated_fprintf(s_etat_processus, \
             flux, __VA_ARGS__)              flux, __VA_ARGS__)
 #define uprintf(...) transliterated_fprintf(NULL, \  #define uprintf(...) std_fprintf(stderr, __VA_ARGS__)
             stderr, __VA_ARGS__)  #define ufprintf(flux, ...) std_fprintf(flux, __VA_ARGS__)
 #define ufprintf(flux, ...) transliterated_fprintf(NULL, \  
             flux, __VA_ARGS__)  
   
 #ifdef SunOS  #ifdef SunOS
 #   define fopen(...) ({ FILE *desc; \  #   define fopen(...) ({ FILE *desc; \
Line 653  union semun Line 652  union semun
         { \          { \
             for(i = 0; i < nb; i++) \              for(i = 0; i < nb; i++) \
                 uprintf("    %s\n", appels[i]); \                  uprintf("    %s\n", appels[i]); \
             free(appels); \              sys_free(appels); \
         } \          } \
         else \          else \
             uprintf("Nullified backtrace\n"); \              uprintf("Nullified backtrace\n"); \
Line 775  pid_t debug_fork(); Line 774  pid_t debug_fork();
 #define d_SPH                   "Semaphore $n 'name'"  #define d_SPH                   "Semaphore $n 'name'"
 #define d_TAB                   "<[ table ]>"  #define d_TAB                   "<[ table ]>"
 #define d_MTX                   "Mutex $n"  #define d_MTX                   "Mutex $n"
   #define d_REC                   "Record /'name_1', ..., 'name_n'/"
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 1027  pid_t debug_fork(); Line 1027  pid_t debug_fork();
 #define NOM __RPL_NOM  #define NOM __RPL_NOM
 #define NON __RPL_NON  #define NON __RPL_NON
 #define PRC __RPL_PRC  #define PRC __RPL_PRC
   #define REC __RPL_REC
 #define REL __RPL_REL  #define REL __RPL_REL
 #define RPN __RPL_RPN  #define RPN __RPL_RPN
 #define SCK __RPL_SCK  #define SCK __RPL_SCK
Line 1041  pid_t debug_fork(); Line 1042  pid_t debug_fork();
 enum t_rplcas_commandes     { RPLCAS_INTEGRATION = 0, RPLCAS_LIMITE };  enum t_rplcas_commandes     { RPLCAS_INTEGRATION = 0, RPLCAS_LIMITE };
   
 enum t_type     { ADR = 0, ALG, BIN, CHN, CPL, FCH, FCT, INT, LST,  enum t_type     { ADR = 0, ALG, BIN, CHN, CPL, FCH, FCT, INT, LST,
                 MCX, MIN, MRL, MTX, NOM, NON, PRC, REL, RPN, SCK,                  MCX, MIN, MRL, MTX, NOM, NON, PRC, REC, REL, RPN, SCK,
                 SLB, SPH, SQL, TBL, VCX, VIN, VRL };                  SLB, SPH, SQL, TBL, VCX, VIN, VRL };
   
     /*      /*
Line 1057  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1058  enum t_type  { ADR = 0, ALG, BIN, CHN, C
             Sans objet.              Sans objet.
             Type C/Fortran : unsigned integer8              Type C/Fortran : unsigned integer8
   
     CHN : chaine de caracteres (character*(*), unsigned char *)      CHN : chaine de caracteres (unsigned char *)
             Sans objet.              Sans objet.
   
     CPL : complexe sur 2*64 bits (complex*16, struct_complexe16 *)      CPL : complexe sur 2*64 bits (complex*16, struct_complexe16 *)
Line 1315  typedef struct connecteur_sql Line 1316  typedef struct connecteur_sql
 */  */
   
 #ifndef RPLARGS  #ifndef RPLARGS
   
   #   define                      d_BIND_TO_DEVICE        0
   #   define                      d_BROADCAST             1
   #   define                      d_DONT_ROUTE            2
   #   define                      d_KEEP_ALIVE            3
   #   define                      d_PRIORITY              4
   #   define                      d_RECEIVE_BUFFER        5
   #   define                      d_FORCE_RECEIVE_BUFFER  6
   #   define                      d_SEND_BUFFER           7
   #   define                      d_FORCE_SEND_BUFFER     8
   #   define                      d_RECEIVING_TIMEOUT     9
   #   define                      d_SENDING_TIMEOUT       10
   #   define                      d_REUSE_ADDRESS         11
   
 typedef struct socket  typedef struct socket
 {  {
     int                         domaine;      int                         domaine;
Line 1333  typedef struct socket Line 1348  typedef struct socket
     unsigned char               protection;      unsigned char               protection;
     unsigned char               type[19 + 1];      unsigned char               type[19 + 1];
   
       integer8                    options;
       int                         priorite;
       int                         buffer_reception;
       int                         buffer_emission;
       int                         timeout_emission;
       int                         timeout_reception;
   
     struct_objet                *format;      struct_objet                *format;
 } struct_socket;  } struct_socket;
 #endif  #endif
Line 1706  typedef struct tableau Line 1728  typedef struct tableau
   
 typedef struct arbre  typedef struct arbre
 {  {
     struct_objet        *feuille;      struct_liste_chainee        *feuille;
     logical1            inversion;  
   
     integer8            nombre_branches;      integer8                    nombre_branches;
     struct arbre        **branches;      struct arbre                **branches;
 } struct_arbre;  } struct_arbre;
   
   
Line 1891  typedef struct liste_variables_partagees Line 1912  typedef struct liste_variables_partagees
 } struct_liste_variables_partagees;  } struct_liste_variables_partagees;
 #endif  #endif
   
   
   /*
   --------------------------------------------------------------------------------
     Structure fonction
   --------------------------------------------------------------------------------
   */
   
   #ifndef RPLARGS
   typedef struct fonction
   {
       unsigned char                       *nom_fonction;
       integer8                            nombre_arguments;
   
       void                                (*fonction)(struct processus *);
   
       volatile struct_liste_chainee       *prediction_saut;
       volatile logical1                   prediction_execution;
   } struct_fonction;
   #endif
   
   
   /*
   --------------------------------------------------------------------------------
     Structure buffer
   --------------------------------------------------------------------------------
   */
   
   typedef struct buffer
   {
       unsigned char                       *buffer;
   
       size_t                              longueur_requise;
       int                                 classe;
   } struct_buffer;
   
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure processus    Structure processus
Line 1919  typedef struct processus Line 1976  typedef struct processus
     unsigned char               evaluation_forcee;                  /*Y/N*/      unsigned char               evaluation_forcee;                  /*Y/N*/
     unsigned char               instruction_valide;                 /*Y/N*/      unsigned char               instruction_valide;                 /*Y/N*/
     unsigned char               instruction_intrinseque;            /*Y/I/N*/      unsigned char               instruction_intrinseque;            /*Y/I/N*/
       unsigned char               instruction_sensible;               /*Y/N*/
     unsigned char               test_instruction;                   /*Y/N*/      unsigned char               test_instruction;                   /*Y/N*/
     unsigned char               affichage_arguments;                /*Y/N*/      unsigned char               affichage_arguments;                /*Y/N*/
     unsigned char               constante_symbolique;               /*Y/N*/      unsigned char               constante_symbolique;               /*Y/N*/
Line 2328  typedef struct processus Line 2386  typedef struct processus
     struct timeval              horodatage_profilage;      struct timeval              horodatage_profilage;
   
     pthread_mutex_t             mutex_allocation;      pthread_mutex_t             mutex_allocation;
       pthread_mutex_t             mutex_allocation_buffer;
     pthread_mutex_t             mutex_interruptions;      pthread_mutex_t             mutex_interruptions;
     pthread_mutex_t             mutex_pile_processus;      pthread_mutex_t             mutex_pile_processus;
     pthread_mutex_t             mutex_signaux;      pthread_mutex_t             mutex_signaux;
Line 2362  typedef struct processus Line 2421  typedef struct processus
     integer8                    taille_pile_objets;      integer8                    taille_pile_objets;
     struct_objet                *pile_objets;      struct_objet                *pile_objets;
   
 #   define TAILLE_CACHE 1024  #   define TAILLE_CACHE         1024
   #   define CACHE(type, nom) \
     integer8                    *objets_adr[TAILLE_CACHE];      type                        *objets_##nom[TAILLE_CACHE]; \
     int                         pointeur_adr;      volatile int                pointeur_##nom;
   
     logical8                    *objets_bin[TAILLE_CACHE];  #   define CACHE2(type, nom) \
     int                         pointeur_bin;      type                        *nom[TAILLE_CACHE]; \
       volatile int                pointeur_##nom;
     complex16                   *objets_cpl[TAILLE_CACHE];  
     int                         pointeur_cpl;      CACHE(integer8, adr)
       CACHE(logical8, bin)
     struct fonction             *objets_fct[TAILLE_CACHE];      CACHE(complex16, cpl)
     int                         pointeur_fct;      CACHE(struct_fonction, fct)
       CACHE(integer8, int)
     integer8                    *objets_int[TAILLE_CACHE];      CACHE(struct_matrice, mat)
     int                         pointeur_int;      CACHE(struct_nom, nom)
       CACHE(real8, rel)
     struct_matrice              *objets_mat[TAILLE_CACHE];      CACHE(struct_tableau, tab)
     int                         pointeur_mat;      CACHE(struct_vecteur, vec)
   
     struct_nom                  *objets_nom[TAILLE_CACHE];      CACHE2(struct_liste_chainee, maillons)
     int                         pointeur_nom;      CACHE2(struct_arbre_variables, variables_noeud)
       CACHE2(struct_arbre_variables_partagees, variables_partagees_noeud)
     real8                       *objets_rel[TAILLE_CACHE];      CACHE2(struct_liste_variables, variables_feuille)
     int                         pointeur_rel;      CACHE2(struct_variable, variables_variable)
       CACHE2(struct_arbre_variables *, variables_tableau_noeuds)
     struct_tableau              *objets_tab[TAILLE_CACHE];      CACHE2(struct_arbre_variables_partagees *,
     int                         pointeur_tab;              variables_tableau_noeuds_partages)
   
     struct_vecteur              *objets_vec[TAILLE_CACHE];      CACHE2(struct_buffer, enveloppes_buffers)
     int                         pointeur_vec;      unsigned char       ***cache_buffer;
       int                 *pointeur_cache_buffer;
     struct_liste_chainee        *maillons[TAILLE_CACHE];  
     int                         pointeur_maillons;  
   
     struct_arbre_variables      *variables_noeud[TAILLE_CACHE];  
     int                         pointeur_variables_noeud;  
   
     struct_arbre_variables_partagees  
                                 *variables_partagees_noeud[TAILLE_CACHE];  
     int                         pointeur_variables_partagees_noeud;  
   
     struct_liste_variables      *variables_feuille[TAILLE_CACHE];  
     int                         pointeur_variables_feuille;  
   
     struct_variable             *variables_variable[TAILLE_CACHE];  
     int                         pointeur_variables_variable;  
   
     struct_arbre_variables      **variables_tableau_noeuds[TAILLE_CACHE];  
     int                         pointeur_variables_tableau_noeuds;  
   
     struct_arbre_variables_partagees  
                                 **variables_tableau_noeuds_partages  
                                 [TAILLE_CACHE];  
     int                         pointeur_variables_tableau_noeuds_partages;  
 } struct_processus;  } struct_processus;
 #endif  #endif
   
 /*  
 --------------------------------------------------------------------------------  
   Structure fonction  
 --------------------------------------------------------------------------------  
 */  
   
 #ifndef RPLARGS  /*
 typedef struct fonction  ================================================================================
 {    MISE EN PLACE DE L'ALLOCATEUR SPÉCIFIQUE
     unsigned char                       *nom_fonction;  ================================================================================*/
     integer8                            nombre_arguments;  
   
     void                                (*fonction)(struct_processus *);  #ifndef DEBUG_MEMOIRE
   #   define malloc(a)            rpl_malloc(s_etat_processus, a)
     volatile struct_liste_chainee       *prediction_saut;  #   define realloc(a, b)        rpl_realloc(s_etat_processus, a, b)
     volatile logical1                   prediction_execution;  #   define free(a)              rpl_free(s_etat_processus, a)
 } struct_fonction;  #endif
 #endif  
   void *rpl_malloc(struct_processus *s_etat_processus, size_t s);
   void *rpl_realloc(struct_processus *s_etat_processus, void *ptr, size_t s);
   void rpl_free(struct_processus *s_etat_processus, void *ptr);
   void *sys_malloc(size_t s);
   void *sys_realloc(void *ptr, size_t s);
   void sys_free(void *ptr);
   
   /*
    * Wrapper de readline() pour que la fonction renvoie un pointeur sur un
    * buffer alloué par rpl_malloc().
    */
   
   #define readline(s) readline_wrapper(s_etat_processus, s)
   unsigned char *readline_wrapper(struct_processus *s_etat_processus,
           unsigned char *s);
   
   
 /*  /*
Line 3011  void conversion_chaine(struct_processus Line 3056  void conversion_chaine(struct_processus
         unsigned char *chaine, unsigned char type);          unsigned char *chaine, unsigned char type);
 void conversion_decimal_vers_hms(real8 *angle);  void conversion_decimal_vers_hms(real8 *angle);
 void conversion_degres_vers_radians(real8 *angle);  void conversion_degres_vers_radians(real8 *angle);
 void conversion_element_tex(unsigned char **element, unsigned char *fonction);  void conversion_element_tex(struct_processus *s_etat_processus,
           unsigned char **element, unsigned char *fonction);
 void conversion_format(struct_processus *s_etat_processus,  void conversion_format(struct_processus *s_etat_processus,
         unsigned char *chaine);          unsigned char *chaine);
 void conversion_hms_vers_decimal(real8 *angle);  void conversion_hms_vers_decimal(real8 *angle);
 void conversion_majuscule_limitee(unsigned char *chaine_entree,   void conversion_majuscule_limitee(
         unsigned char *chaine_sortie, integer8 longueur);          unsigned char *chaine_entree, unsigned char *chaine_sortie,
           integer8 longueur);
 void conversion_radians_vers_degres(real8 *angle);  void conversion_radians_vers_degres(real8 *angle);
 void copie_arbre_variables(struct_processus *s_etat_processus,  void copie_arbre_variables(struct_processus *s_etat_processus,
         struct_processus *s_nouvel_etat_processus);          struct_processus *s_nouvel_etat_processus);
Line 3207  real8 correlation_statistique(struct_mat Line 3254  real8 correlation_statistique(struct_mat
 real8 covariance_statistique(struct_matrice *s_matrice,  real8 covariance_statistique(struct_matrice *s_matrice,
         integer8 colonne_1, integer8 colonne_2,          integer8 colonne_1, integer8 colonne_2,
         unsigned char type, logical1 *erreur);          unsigned char type, logical1 *erreur);
 struct_vecteur *ecart_type_statistique(struct_matrice *s_matrice,  struct_vecteur *ecart_type_statistique(struct_processus *s_etat_processus,
         unsigned char type);          struct_matrice *s_matrice, unsigned char type);
 struct_vecteur *moyenne_statistique(struct_matrice *s_matrice);  struct_vecteur *moyenne_statistique(struct_processus *s_etat_processus,
 struct_vecteur *sommation_colonne_statistique(struct_matrice *s_matrice,          struct_matrice *s_matrice);
   struct_vecteur *sommation_colonne_statistique(
           struct_processus *s_etat_processus, struct_matrice *s_matrice,
         integer8 colonne);          integer8 colonne);
 struct_vecteur *sommation_produits_colonnes_statistiques(struct_matrice  struct_vecteur *sommation_produits_colonnes_statistiques(
           struct_processus *s_etat_processus, struct_matrice
         *s_matrice, integer8 colonne_1, integer8 colonne_2);          *s_matrice, integer8 colonne_1, integer8 colonne_2);
 struct_vecteur *sommation_statistique(struct_matrice *s_matrice);  struct_vecteur *sommation_statistique(struct_processus *s_etat_processus,
 struct_vecteur *variance_statistique(struct_matrice *s_matrice,          struct_matrice *s_matrice);
         unsigned char type);  struct_vecteur *variance_statistique(struct_processus *s_etat_processus,
           struct_matrice *s_matrice, unsigned char type);
 #endif  #endif
   
 /*  /*
Line 3252  unsigned char *analyse_algebrique(struct Line 3303  unsigned char *analyse_algebrique(struct
         unsigned char *chaine_algebrique, struct_liste_chainee **l_base_liste);          unsigned char *chaine_algebrique, struct_liste_chainee **l_base_liste);
 unsigned char *analyse_flux(struct_processus *s_etat_processus,  unsigned char *analyse_flux(struct_processus *s_etat_processus,
         unsigned char *flux, integer8 longueur);          unsigned char *flux, integer8 longueur);
 unsigned char *chiffrement(const EVP_CIPHER *type_chiffrement,  unsigned char *chiffrement(struct_processus *s_etat_processus,
           const EVP_CIPHER *type_chiffrement,
         logical1 encodage, unsigned char *message, integer8 longueur_message,          logical1 encodage, unsigned char *message, integer8 longueur_message,
         unsigned char *clef, integer8 longueur_clef,          unsigned char *clef, integer8 longueur_clef,
         unsigned char *vecteur_initialisation,          unsigned char *vecteur_initialisation,
         integer8 *longueur_message_chiffre);          integer8 *longueur_message_chiffre);
 unsigned char *compactage(unsigned char *chaine);  unsigned char *compactage(struct_processus *s_etat_processus,
 unsigned char *conversion_majuscule(unsigned char *chaine);          unsigned char *chaine);
   unsigned char *conversion_majuscule(struct_processus *s_etat_processus,
           unsigned char *chaine);
 unsigned char *creation_nom_fichier(struct_processus *s_etat_processus,  unsigned char *creation_nom_fichier(struct_processus *s_etat_processus,
         unsigned char *chemin);          unsigned char *chemin);
 unsigned char *date_compilation();  unsigned char *date_compilation(struct_processus *s_etat_processus);
 unsigned char *extraction_chaine(unsigned char *chaine, integer8 i, integer8 j);  unsigned char *extraction_chaine(struct_processus *s_etat_processus,
           unsigned char *chaine, integer8 i, integer8 j);
 unsigned char *formateur(struct_processus *s_etat_processus, long offset,  unsigned char *formateur(struct_processus *s_etat_processus, long offset,
         struct_objet *s_objet);          struct_objet *s_objet);
 unsigned char *formateur_fichier(struct_processus *s_etat_processus,  unsigned char *formateur_fichier(struct_processus *s_etat_processus,
Line 3288  unsigned char *formateur_reel(struct_pro Line 3343  unsigned char *formateur_reel(struct_pro
 unsigned char *messages(struct_processus *s_etat_processus);  unsigned char *messages(struct_processus *s_etat_processus);
 unsigned char *pointeur_ieme_caractere(struct_processus *s_etat_processus,  unsigned char *pointeur_ieme_caractere(struct_processus *s_etat_processus,
         unsigned char *chaine, integer8 position);          unsigned char *chaine, integer8 position);
 unsigned char *purification_chaine(unsigned char *chaine);  unsigned char *purification_chaine(struct_processus *s_etat_processus,
           unsigned char *chaine);
 unsigned char *recherche_chemin_fichiers_temporaires(struct_processus  unsigned char *recherche_chemin_fichiers_temporaires(struct_processus
         *s_etat_processus);          *s_etat_processus);
 unsigned char *reencodage(struct_processus *s_etat_processus,  unsigned char *reencodage(struct_processus *s_etat_processus,
Line 3402  ssize_t write_atomic(struct_processus *s Line 3458  ssize_t write_atomic(struct_processus *s
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 int alsprintf(unsigned char **strp, const char *fmt, ...);  int alsprintf(struct_processus *s_etat_processus,
           unsigned char **strp, const char *fmt, ...);
   #ifndef RPLARGS
   int association_etat_processus_readline();
   #endif
 int interruption_violation_access(void *adresse_fautive, int gravite);  int interruption_violation_access(void *adresse_fautive, int gravite);
 #ifndef RPLARGS  #ifndef RPLARGS
   int initialisation_etat_processus_readline();
   int liberation_etat_processus_readline();
 integer8 liste_variables(struct_processus *s_etat_processus,  integer8 liste_variables(struct_processus *s_etat_processus,
         struct_tableau_variables *tableau);          struct_tableau_variables *tableau);
 integer8 nombre_variables(struct_processus *s_etat_processus);  integer8 nombre_variables(struct_processus *s_etat_processus);
 int readline_analyse_syntaxique(int count, int key);  int readline_analyse_syntaxique(int count, int key);
 int readline_effacement(int count, int key);  int readline_effacement(int count, int key);
 #endif  #endif
   int std_fprintf(file *flux, const char *format, ...);
 int tex_fprintf(struct_processus *s_etat_processus,  int tex_fprintf(struct_processus *s_etat_processus,
         file *flux, const char *format, ...);          file *flux, const char *format, ...);
 int transliterated_fprintf(struct_processus *s_etat_processus, file *flux,  int transliterated_fprintf(struct_processus *s_etat_processus, file *flux,
         const char *format, ...);          const char *format, ...);
 int valsprintf(unsigned char **strp, const char *fmt, va_list ap);  int valsprintf(struct_processus *s_etat_processus,
           unsigned char **strp, const char *fmt, va_list ap);
 int wrapper_instruction_intrinseque(void (*fonction)(),  int wrapper_instruction_intrinseque(void (*fonction)(),
         struct_rpl_arguments *rpl_arguments);          struct_rpl_arguments *rpl_arguments);
   
Line 3466  struct_liste_chainee *analyse_rpn(struct Line 3530  struct_liste_chainee *analyse_rpn(struct
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
     Allocateur de buffers à cache
   --------------------------------------------------------------------------------
   */
   
   void initialisation_allocateur_buffer(struct_processus *s_etat_processus);
   void liberation_allocateur_buffer(struct_processus *s_etat_pocessus);
   struct_buffer *allocation_buffer(struct_processus *s_etat_processus,
           size_t longueur);
   void liberation_buffer(struct_processus *s_etat_processus,
           struct_buffer *buffer);
   
   /*
   --------------------------------------------------------------------------------
   Fonctions renvoyant une copie de la structure de description des processus    Fonctions renvoyant une copie de la structure de description des processus
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
Removed from v.1.252  
changed lines
  Added in v.1.286

CVSweb interface <joel.bertrand@systella.fr>