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

Diff for /rpl/src/rpl.h between versions 1.37 and 1.52

version 1.37, 2010/05/22 21:45:50 version 1.52, 2010/08/06 15:33:04
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.15    RPL/2 (R) version 4.0.18
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2010 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
Line 31 Line 31
 #   define  _DARWIN_C_SOURCE  #   define  _DARWIN_C_SOURCE
 #endif  #endif
   
   #ifdef OS2
   #   define _BSD_SOURCE
   #   define _XOPEN_SOURCE    600
   
   #   include <types.h>
       enum { SHUT_RD = 0, SHUT_WR, SHUT_RDWR };
   #   define SHUT_RD      SHUT_RD
   #   define SHUT_WR      SHUT_WR
   #   define SHUT_RDWR    SHUT_RDWR
   #   define SEM_FAILED   NULL
   #   undef IPV6
   
   #   include "getaddrinfo-conv.h"
   #else
   #   define IPV6
   #endif
   
   
 /*  /*
 ================================================================================  ================================================================================
Line 66 Line 83
 #   include <dlfcn.h>  #   include <dlfcn.h>
 #   include <fcntl.h>  #   include <fcntl.h>
 #   include <pthread.h>  #   include <pthread.h>
   
   #   ifdef OS2
   #       undef pthread_mutexattr_settype
   #       define pthread_mutexattr_settype(a, b)
   #   endif
   
 #   include <pwd.h>  #   include <pwd.h>
 #   include <semaphore.h>  
   #   ifndef OS2
   #       include <semaphore.h>
   #   else
   #       include <sys/sem.h>
           typedef int sem_t;
   
           sem_t *sem_open(const char *nom, int oflag, ...);
           int sem_init(sem_t *sem, int shared, unsigned int value);
           int sem_close(sem_t *sem);
           int sem_wait(sem_t *sem);
           int sem_trywait(sem_t *sem);
           int sem_post(sem_t *sem);
           int sem_getvalue(sem_t *sem, int *value);
           int sem_unlink(const char *nom);
           int sem_destroy(sem_t *sem);
   #   endif
   
 #   include <setjmp.h>  #   include <setjmp.h>
 #   include <signal.h>  #   include <signal.h>
 #   include <termios.h>  #   include <termios.h>
Line 127 Line 167
 */  */
   
 #ifndef RPLARGS  #ifndef RPLARGS
 #   ifdef Darwin  #   if defined(Darwin)
 #       define SIGPOLL              SIGINFO  #       define SIGPOLL              SIGINFO
 #   endif  #   endif
   
Line 190  typedef FILE     file; Line 230  typedef FILE     file;
 typedef unsigned char           t_8_bits;  typedef unsigned char           t_8_bits;
   
 #ifndef RPLARGS  #ifndef RPLARGS
 #   include "rpltypes.conv.h"  #   include "rpltypes-conv.h"
 #else  #else
 #   include "rpltypes.h"  #   include "rpltypes.h"
 #endif  #endif
Line 362  int sem_getvalue2(sem_t *semaphore, int Line 402  int sem_getvalue2(sem_t *semaphore, int
   
 // Redéfinition de abs pour un fonctionnement en entier de type long long int  // Redéfinition de abs pour un fonctionnement en entier de type long long int
   
 #if 1  #ifdef __GNUC__
 #   define abs(i) ({ typeof(i) _i; _i = (i); (_i >= 0) ? _i : -_i; })  #   define abs(i) ({ typeof(i) _i; _i = (i); (_i >= 0) ? _i : -_i; })
 // typeof() est une extension de gcc, mais est présent sur d'autres compilateurs  // typeof() est une extension de gcc, mais est présent sur d'autres compilateurs
 // comme Sun Studio. Dans le cas où typeof() n'existe pas, il est possible  // comme Sun Studio. Dans le cas où typeof() n'existe pas, il est possible
Line 438  int sem_getvalue2(sem_t *semaphore, int Line 478  int sem_getvalue2(sem_t *semaphore, int
 void analyse_post_mortem();  void analyse_post_mortem();
 void *debug_memoire_ajout(size_t taille, const unsigned char *fonction,  void *debug_memoire_ajout(size_t taille, const unsigned char *fonction,
         unsigned long ligne, const unsigned char *argument);          unsigned long ligne, const unsigned char *argument);
   void debug_memoire_initialisation();
 void *debug_memoire_modification(void *pointeur, size_t taille,  void *debug_memoire_modification(void *pointeur, size_t taille,
         const unsigned char *fonction, unsigned long ligne,          const unsigned char *fonction, unsigned long ligne,
         const unsigned char *argument);          const unsigned char *argument);
 void debug_memoire_reinitialisation();  
 void debug_memoire_retrait(void *ptr);  void debug_memoire_retrait(void *ptr);
 void debug_memoire_verification();  void debug_memoire_verification();
   
   pid_t debug_fork();
   
 #define malloc(s) debug_memoire_ajout(s, __FUNCTION__, __LINE__, #s)  #define malloc(s) debug_memoire_ajout(s, __FUNCTION__, __LINE__, #s)
 #define free(s) debug_memoire_retrait(s)  #define free(s) debug_memoire_retrait(s)
 #define realloc(s, t) debug_memoire_modification(s, t, \  #define realloc(s, t) debug_memoire_modification(s, t, \
             __FUNCTION__, __LINE__, #t)              __FUNCTION__, __LINE__, #t)
   #define fork() debug_fork()
 #endif  #endif
   
 #ifdef DEBUG_RETURN  #ifdef DEBUG_RETURN
Line 488  void debug_memoire_verification(); Line 531  void debug_memoire_verification();
         if (value == 0) BUG(1, uprintf("Value %d\n", value)); sem_destroy(a); })          if (value == 0) BUG(1, uprintf("Value %d\n", value)); sem_destroy(a); })
 #endif  #endif
   
 #ifdef DEBUG_MALLOC  
 #define malloc(taille) ({ size_t s = taille; void *p; \  
         p = malloc(taille); if (p != NULL) memset(p, 0, s); \  
         /*uprintf("[%d-%llu] Allocating %p (%d bytes) at %s() line #%d\n", \  
         (int) getpid(), (unsigned long long) pthread_self(), p, \  
         (int) s, __FUNCTION__, __LINE__); fflush(stdout); */ p; })  
 #endif  
   
 #ifdef DEBUG_FREE  
 #define free(ptr) ({ void *p = ptr; \  
         /*uprintf("[%d-%llu] Freeing %p (%d bytes) at %s() line #%d\n", \  
         (int) getpid(), (unsigned long long) pthread_self(), p, \  
         (int) sizeof(p), __FUNCTION__, __LINE__); fflush(stdout); */ \  
         if (p != NULL) memset(p, 0, sizeof(p)); free(p); })  
 #endif  
   
 /*  /*
 ================================================================================  ================================================================================
Line 742  void debug_memoire_verification(); Line 770  void debug_memoire_verification();
 #   define d_ex_enregistrement_inexistant       __erreur(79)  #   define d_ex_enregistrement_inexistant       __erreur(79)
 #   define d_ex_clef_inexistante                __erreur(80)  #   define d_ex_clef_inexistante                __erreur(80)
 #   define d_ex_nom_implicite                   __erreur(81)  #   define d_ex_nom_implicite                   __erreur(81)
   #   define d_ex_version_bibliotheque            __erreur(82)
 #endif  #endif
   
   
Line 1143  typedef struct descripteur_thread Line 1172  typedef struct descripteur_thread
     pthread_t                   thread_pere;      pthread_t                   thread_pere;
   
     pthread_mutex_t             mutex;      pthread_mutex_t             mutex;
   
     volatile logical1           thread_actif;      volatile logical1           thread_actif;
   
     int                         pipe_erreurs[2];      int                         pipe_erreurs[2];
Line 1223  typedef struct liste_pile_systeme Line 1253  typedef struct liste_pile_systeme
   
     /*      /*
     type clôture :      type clôture :
     C     CASE  : END termine un test SELECT/CASE/THEN/END/DEFAULT/END.      C     SELECT  : END termine un test SELECT/DEFAULT/END.
     D     DO    : END termine une boucle DO/UNTIL/END.      D     DO      : END termine une boucle DO/UNTIL/END.
     I     IF    : END termine un test IF/THEN (ELSE)/END.      I     IF      : END termine un test IF/THEN (ELSE)/END.
     J     IFERR : END termine un test IFERR/THEN (ELSE)/END.      J     IFERR   : END termine un test IFERR/THEN (ELSE)/END.
     W     WHILE : END termine une boucle WHILE/REPEAT/END.      K     CASE    : END termine un test CASE/THEN/END
       W     WHILE   : END termine une boucle WHILE/REPEAT/END.
     F     FOR   : NEXT ou STEP termine une boucle avec compteur.  
     S     START : NEXT ou STEP termine une boucle sans compteur.      F     FOR     : NEXT ou STEP termine une boucle avec compteur.
     L     LOOP  : boucle utilisé dans le traitement de l'instruction RETURN.      S     START   : NEXT ou STEP termine une boucle sans compteur.
       L     LOOP    : boucle utilisé dans le traitement de l'instruction RETURN.
             Elle correspond à une boucle FOR ou START mais sans son              Elle correspond à une boucle FOR ou START mais sans son
             initialisation.              initialisation.
     */      */
   
     unsigned long               adresse_retour;      unsigned long               adresse_retour;
     unsigned long               niveau_courant;      unsigned long               niveau_courant;
       struct_objet                *pointeur_adresse_retour;
 } struct_liste_pile_systeme;  } struct_liste_pile_systeme;
 #endif  #endif
   
Line 1538  typedef struct processus Line 1570  typedef struct processus
     pthread_t                   thread_fusible;      pthread_t                   thread_fusible;
     pthread_t                   thread_surveille_par_fusible;      pthread_t                   thread_surveille_par_fusible;
   
 #   ifndef Cygwin  #   if !defined(Cygwin)
     stack_t                     pile_signal;      stack_t                     pile_signal;
 #   else  #   else
 #   define SA_ONSTACK           0  #   define SA_ONSTACK           0
Line 1801  typedef struct processus Line 1833  typedef struct processus
   
     unsigned char               traitement_interruption;  /* Y/N */      unsigned char               traitement_interruption;  /* Y/N */
     unsigned char               traitement_interruptible; /* Y/N */      unsigned char               traitement_interruptible; /* Y/N */
       unsigned char               traitement_at_poke;       /* Y/N */
   
     struct_objet                *at_exit;      struct_objet                *at_exit;
       struct_objet                *at_poke;
   
 /* Variables volatiles                                  */  /* Variables volatiles                                  */
   
Line 1863  typedef struct processus Line 1897  typedef struct processus
   
     // Mutex spécifique au processus et donnant accès à la pile des processus      // Mutex spécifique au processus et donnant accès à la pile des processus
     pthread_mutex_t             mutex;      pthread_mutex_t             mutex;
       pthread_mutex_t             mutex_allocation;
   
     // Sémaphore autorisant les fork()      // Sémaphore autorisant les fork()
     sem_t      sem_t
Line 1998  void instruction_asr(struct_processus *s Line 2033  void instruction_asr(struct_processus *s
 void instruction_atan(struct_processus *s_etat_processus);  void instruction_atan(struct_processus *s_etat_processus);
 void instruction_atanh(struct_processus *s_etat_processus);  void instruction_atanh(struct_processus *s_etat_processus);
 void instruction_atexit(struct_processus *s_etat_processus);  void instruction_atexit(struct_processus *s_etat_processus);
   void instruction_atpoke(struct_processus *s_etat_processus);
 void instruction_autoscale(struct_processus *s_etat_processus);  void instruction_autoscale(struct_processus *s_etat_processus);
 void instruction_axes(struct_processus *s_etat_processus);  void instruction_axes(struct_processus *s_etat_processus);
   
 void instruction_b_vers_r(struct_processus *s_etat_processus);  void instruction_b_vers_r(struct_processus *s_etat_processus);
 void instruction_backspace(struct_processus *s_etat_processus);  void instruction_backspace(struct_processus *s_etat_processus);
   void instruction_backtrace(struct_processus *s_etat_processus);
 void instruction_beep(struct_processus *s_etat_processus);  void instruction_beep(struct_processus *s_etat_processus);
 void instruction_bessel(struct_processus *s_etat_processus);  void instruction_bessel(struct_processus *s_etat_processus);
 void instruction_bin(struct_processus *s_etat_processus);  void instruction_bin(struct_processus *s_etat_processus);
Line 2018  void instruction_cllcd(struct_processus Line 2055  void instruction_cllcd(struct_processus
 void instruction_clmf(struct_processus *s_etat_processus);  void instruction_clmf(struct_processus *s_etat_processus);
 void instruction_close(struct_processus *s_etat_processus);  void instruction_close(struct_processus *s_etat_processus);
 void instruction_clratexit(struct_processus *s_etat_processus);  void instruction_clratexit(struct_processus *s_etat_processus);
   void instruction_clratpoke(struct_processus *s_etat_processus);
 void instruction_clrcntxt(struct_processus *s_etat_processus);  void instruction_clrcntxt(struct_processus *s_etat_processus);
 void instruction_clrerr(struct_processus *s_etat_processus);  void instruction_clrerr(struct_processus *s_etat_processus);
 void instruction_clrfuse(struct_processus *s_etat_processus);  void instruction_clrfuse(struct_processus *s_etat_processus);
Line 2623  void scrutation_injection(struct_process Line 2661  void scrutation_injection(struct_process
 void sf(struct_processus *s_etat_processus, unsigned char indice_drapeau);  void sf(struct_processus *s_etat_processus, unsigned char indice_drapeau);
 void *surveillance_processus(void *argument);  void *surveillance_processus(void *argument);
 void swap(void *variable_1, void *variable_2, unsigned long taille_octets);  void swap(void *variable_1, void *variable_2, unsigned long taille_octets);
   void trace(struct_processus *s_etat_processus, FILE *flux);
 void traitement_asynchrone_exceptions_gsl(struct_processus *s_etat_processus);  void traitement_asynchrone_exceptions_gsl(struct_processus *s_etat_processus);
 void traitement_exceptions_gsl(const char *reason, const char *file,  void traitement_exceptions_gsl(const char *reason, const char *file,
         int line, int gsl_errno);          int line, int gsl_errno);
Removed from v.1.37  
changed lines
  Added in v.1.52

CVSweb interface <joel.bertrand@systella.fr>