--- rpl/src/rpl.h 2010/06/28 14:30:33 1.46 +++ rpl/src/rpl.h 2015/02/19 11:01:29 1.265 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.0.17 - Copyright (C) 1989-2010 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.21 + Copyright (C) 1989-2015 Dr. BERTRAND Joël This file is part of RPL/2. @@ -23,12 +23,41 @@ #ifndef INCLUSION_RPL #define INCLUSION_RPL -#define _GNU_SOURCE -#define _POSIX_C_SOURCE 200112L +#ifndef __RPLCAS +# define _GNU_SOURCE +# define _XOPEN_SOURCE 700 +#endif + #define _REENTRANT -#ifdef Darwin -# define _DARWIN_C_SOURCE +#ifndef __RPLCAS +# ifdef Darwin +# define _DARWIN_C_SOURCE +# endif + +# ifdef OpenBSD +# define _BSD_SOURCE +# endif +#endif + +#ifdef OS2 +# ifndef __RPLCAS +# define _BSD_SOURCE +# endif + +# include + enum { SHUT_RD = 0, SHUT_WR, SHUT_RDWR }; +# define SHUT_RD SHUT_RD +# define SHUT_WR SHUT_WR +# define SHUT_RDWR SHUT_RDWR + +# include "getaddrinfo-conv.h" + +# define sched_yield(arg) +#endif + +#ifdef CYGWIN +# define SA_ONSTACK 0 #endif @@ -40,20 +69,23 @@ #include #include +#include #include #include #include #include #include #include +#include +#include #ifndef RPLARGS # include +# include # include # include # include # include -# include # include # include # include @@ -66,10 +98,67 @@ # include # include # include +# include + +# ifdef OS2 +# undef pthread_mutexattr_settype +# define pthread_mutexattr_settype(a, b) +# endif + # include -# include +# ifdef SHARED_MEMORY +# include +# endif + +# ifndef IPCS_SYSV +# include +# else +# include +# include + +# ifdef OS2 +# define INCL_DOSSEMAPHORES +# define INCL_DOSMEMMGR +# define INCL_DOSERRORS +# include + + typedef struct _OS2SEM + { + HMTX hmtx; + HEV hev; + ULONG shared; + ULONG *cnt; + ULONG *nopened; + ULONG allocated; + } sem_t; +# else // IPCS_SYSV + typedef struct + { + int sem; + int alloue; + unsigned char *path; + pid_t pid; + pthread_t tid; + } sem_t; +# endif + +# ifndef SEM_FAILED +# define SEM_FAILED NULL +# endif + + sem_t *sem_open_SysV(const char *nom, int oflag, ...); + int sem_init_SysV(sem_t *sem, int shared, unsigned int value); + int sem_close_SysV(sem_t *sem); + int sem_wait_SysV(sem_t *sem); + int sem_trywait_SysV(sem_t *sem); + int sem_timedwait_SysV(sem_t *sem, struct timespec *ts); + int sem_post_SysV(sem_t *sem); + int sem_getvalue_SysV(sem_t *sem, int *value); + int sem_unlink_SysV(char *nom); + int sem_destroy_SysV(sem_t *sem); +# endif + # include -# include # include # include # include @@ -79,9 +168,49 @@ # include "readline.h" # include "termcap.h" # include "iconv.h" +# include "zlib.h" # include "openssl/evp.h" +# ifndef OPENSSL_NO_MD2 +# include "openssl/md2.h" +# endif +# ifndef OPENSSL_NO_MD4 +# include "openssl/md4.h" +# endif +# ifndef OPENSSL_NO_MD5 +# include "openssl/md5.h" +# endif +# ifndef OPENSSL_NO_MDC2 +# include "openssl/mdc2.h" +# endif +# ifndef OPENSSL_NO_RIPEMD +# include "openssl/ripemd.h" +# endif +# ifndef OPENSSL_NO_SHA +# include "openssl/sha.h" +# endif +# ifndef OPENSSL_NO_WHIRLPOOL +# include "openssl/whrlpool.h" +# endif +# ifndef OPENSSL_NO_AES +# include "openssl/aes.h" +# endif +# ifndef OPENSSL_NO_CAMELLIA +# include "openssl/camellia.h" +# endif +# ifndef OPENSSL_NO_RC2 +# include "openssl/rc2.h" +# endif +# ifndef OPENSSL_NO_IDEA +# include "openssl/idea.h" +# endif + # include "sqlite3.h" +# include "sigsegv.h" +# ifdef OS2 + // Bug de libsigsegv +# undef HAVE_STACK_OVERFLOW_RECOVERY +# endif # define HAVE_INLINE # define GSL_RANGE_CHECK_OFF @@ -120,27 +249,205 @@ #include "librplprototypes.h" +#ifndef RPLARGS +# ifndef UNIX_PATH_MAX + struct sockaddr_un sizecheck; +# define UNIX_PATH_MAX sizeof(sizecheck.sun_path) +# endif +#endif + +#ifdef MAIN_RPL +# define __EXTERN__ +# define __STATIC_MUTEX_INITIALIZATION__ = PTHREAD_MUTEX_INITIALIZER +#else +# define __EXTERN__ extern +# define __STATIC_MUTEX_INITIALIZATION__ +#endif + /* ================================================================================ - SIGNAUX + Bugs spécifiques +================================================================================ +*/ + +// Néant + +/* +================================================================================ + TYPES ================================================================================ */ +typedef FILE file; +typedef unsigned char t_8_bits; + #ifndef RPLARGS -# ifdef Darwin -# define SIGPOLL SIGINFO +# include "rpltypes-conv.h" +#else +# include "rpltypes.h" +#endif + +enum signaux_rpl +{ + rpl_signull = 0, + rpl_sigint, + rpl_sigterm, + rpl_sigstart, // Signal envoyé par un père pour lancer son fils. + rpl_sigcont, // Signal de redémarrage d'un processus arrêté par + // SUSPEND + rpl_sigstop, // Signal d'arrêt envoyé par l'instruction STOP ou + // FUSE. (FSTOP) + rpl_sigabort, // Signal envoyé par l'instruction ABORT (à regrouper + // avec FABORT) + rpl_sigurg, // Signal d'arrêt urgent + rpl_siginject, // Signal indiquant la présence d'une donnée à lire + // envoyée depuis le père + rpl_sigalrm, // Signal d'alarme (erreur système) depuis un fils + rpl_sighup, + rpl_sigtstp, + rpl_sigexcept, + rpl_sigmax +}; + +#define LONGUEUR_QUEUE_SIGNAUX 1024 + +// Une structure s_queue_signaux est créée par processus (et non par thread). +// Elle est projetée dans un segment de mémoire partagée pour qu'elle soit +// accessible à la fois du père et des fils. + +#ifndef RPLARGS +typedef struct queue_signaux +{ + volatile int pointeur_lecture; + volatile int pointeur_ecriture; + volatile logical1 requete_arret; + + pthread_t thread_signaux; + + volatile struct + { + pid_t pid; + enum signaux_rpl signal; + } queue[LONGUEUR_QUEUE_SIGNAUX]; + +# ifdef OS2 + sem_t semaphore; + sem_t signalisation; + sem_t arret_signalisation; +# endif +} struct_queue_signaux; + +__EXTERN__ struct_queue_signaux *s_queue_signaux; +__EXTERN__ int f_queue_signaux; + +# ifndef OS2 + __EXTERN__ sem_t *semaphore_queue_signaux; + __EXTERN__ sem_t *semaphore_signalisation; + __EXTERN__ sem_t *semaphore_arret_signalisation; +# endif +#endif + +#if ! defined(UNION_SEMUN) && defined(IPCS_SYSV) +union semun +{ + int val; + struct semid_ds *buf; + unsigned short *array; + struct seminfo *__buf; +}; +#endif + +#ifndef RTLD_LOCAL +# define RTLD_LOCAL 0 +#endif + +#ifndef SIGSTKSZ +# define SIGSTKSZ 65536 +#endif + + +/* +================================================================================ + SÉMAPHORES +================================================================================ +*/ + +#ifdef IPCS_SYSV +# ifdef DEBUG_SEMAPHORES +# define sem_wait(a) ({ int value; sem_getvalue(a, &value); \ + uprintf("[%d-%llu] Semaphore %s (%p) "\ + "waiting at %s() " \ + "line #%d\n", (int) getpid(), (unsigned long long) i\ + pthread_self(), \ + #a, a, __FUNCTION__, __LINE__), fflush(stdout); \ + if (value > 1) BUG(1, uprintf("Value %d\n", value)); \ + sem_wait_SysV(a); }) +# define sem_post(a) ({ int value; sem_getvalue(a, &value); \ + uprintf("[%d-%llu] Semaphore %s (%p) "\ + "posting at %s() " \ + "line #%d\n", (int) getpid(), (unsigned long long) \ + pthread_self(), \ + #a, a, __FUNCTION__, __LINE__), fflush(stdout); \ + if (value > 0) BUG(1, uprintf("Value %d\n", value)); \ + sem_post_SysV(a); }) +# define sem_destroy(a) ({ int value; sem_getvalue(a, &value); \ + if (value == 0) BUG(1, uprintf("Value %d\n", value)); \ + sem_destroy_SysV(a); }) +# else +# define sem_destroy(a) sem_destroy_SysV(a) +# define sem_wait(a) sem_wait_SysV(a) +# define sem_post(a) sem_post_SysV(a) +# endif + +# define sem_init(a, b, c) sem_init_SysV(a, b, c) +# define sem_trywait(a) sem_trywait_SysV(a) +# define sem_timedwait(a, b) sem_timedwait_SysV(a, b) +# define sem_getvalue(a, b) sem_getvalue_SysV(a, b) +# define sem_open(...) sem_open_SysV(__VA_ARGS__) +# define sem_close(a) sem_close_SysV(a) +# define sem_unlink(a) sem_unlink_SysV(a) +#else +# ifdef DEBUG_SEMAPHORES +# define sem_wait(a) ({ int value; sem_getvalue(a, &value); \ + uprintf("[%d-%llu] Semaphore %s (%p) "\ + "waiting at %s() " \ + "line #%d\n", (int) getpid(), (unsigned long long) \ + pthread_self(), \ + #a, a, __FUNCTION__, __LINE__), fflush(stdout); \ + if (value > 1) BUG(1, uprintf("Value %d\n", value)); sem_wait(a); }) +# define sem_post(a) ({ int value; sem_getvalue(a, &value); \ + uprintf("[%d-%llu] Semaphore %s (%p) "\ + "posting at %s() " \ + "line #%d\n", (int) getpid(), (unsigned long long) \ + pthread_self(), \ + #a, a, __FUNCTION__, __LINE__), fflush(stdout); \ + if (value > 0) BUG(1, uprintf("Value %d\n", value)); sem_post(a); }) +# define sem_destroy(a) ({ int value; sem_getvalue(a, &value); \ + if (value == 0) BUG(1, uprintf("Value %d\n", value)); \ + sem_destroy(a); }) # endif +#endif + + +/* +================================================================================ + SIGNAUX +================================================================================ +*/ + +#ifndef RPLARGS + +// Signaux utilisés par défaut : +// SIGINT +// SIGTSTP +// SIGCONT +// SIGPIPE +// SIGUSR1 et SIGUSR2 sont utilisé par libsigsegv. +// SIGHUP +// SIGALRM + +# define SIGTEST 255 -// Arrêt par STOP -# define SIGFSTOP SIGUSR1 -// Démarrage d'un processus fils -# define SIGSTART SIGUSR2 -// Injection de données -# define SIGINJECT SIGQUIT -// Arrêt général -# define SIGABORT SIGPROF -// Arrêt d'un processus fils depuis autre chose que STOP -# define SIGFABORT SIGPOLL // Nombre d'interruptions disponibles # define d_NOMBRE_INTERRUPTIONS 64 #endif @@ -182,21 +489,6 @@ /* ================================================================================ - TYPES -================================================================================ -*/ - -typedef FILE file; -typedef unsigned char t_8_bits; - -#ifndef RPLARGS -# include "rpltypes.conv.h" -#else -# include "rpltypes.h" -#endif - -/* -================================================================================ Variables globales ================================================================================ */ @@ -204,88 +496,49 @@ typedef unsigned char t_8_bits; #ifndef RPLARGS # ifdef SEMAPHORES_NOMMES # define LONGUEUR_NOM_SEMAPHORE 64 -# endif -# ifndef MAIN_RPL - extern jmp_buf contexte; - extern jmp_buf contexte_initial; - -# ifdef SEMAPHORES_NOMMES - extern pthread_mutex_t mutex_sem; -# endif - - extern pthread_key_t semaphore_fork_processus_courant; - - extern sem_t -# ifdef SEMAPHORES_NOMMES - * -# endif - semaphore_liste_threads; - - extern sem_t -# ifdef SEMAPHORES_NOMMES - * -# endif - semaphore_gestionnaires_signaux; - - extern sem_t -# ifdef SEMAPHORES_NOMMES - * -# endif - semaphore_gestionnaires_signaux_atomique; - -# ifdef SEMAPHORES_NOMMES - // 0 -> liste_threads - // 1 -> gestionnaire_signaux - // 2 -> gestionnaire_signaux_atomique - // 3 -> &((*s_etat_processus).semaphore_fork) - extern unsigned char noms_semaphores[4][LONGUEUR_NOM_SEMAPHORE]; - extern sem_t *semaphores_nommes[4]; -# endif +# define __PTR__ * # else - jmp_buf contexte; - jmp_buf contexte_initial; - -# ifdef SEMAPHORES_NOMMES - pthread_mutex_t mutex_sem = PTHREAD_MUTEX_INITIALIZER; -# endif - - pthread_key_t semaphore_fork_processus_courant; - - sem_t -# ifdef SEMAPHORES_NOMMES - * -# endif - semaphore_liste_threads; - - sem_t -# ifdef SEMAPHORES_NOMMES - * -# endif - semaphore_gestionnaires_signaux; - - sem_t -# ifdef SEMAPHORES_NOMMES - * -# endif - semaphore_gestionnaires_signaux_atomique; - -# ifdef SEMAPHORES_NOMMES - unsigned char noms_semaphores[4][LONGUEUR_NOM_SEMAPHORE]; - sem_t *semaphores_nommes[4]; -# endif +# define __PTR__ # endif -#endif -#ifdef SEMAPHORES_NOMMES -enum t_semaphore { sem_liste_threads = 0, - sem_gestionnaires_signaux = 1, - sem_gestionnaires_signaux_atomique = 2, - sem_fork = 3 }; - -sem_t *sem_init2(unsigned int valeur, enum t_semaphore semaphore); -int sem_destroy2(sem_t *semaphore_p, enum t_semaphore semaphore); -int sem_getvalue2(sem_t *semaphore, int *valeur); + __EXTERN__ jmp_buf contexte_ecriture; + __EXTERN__ jmp_buf contexte_impression; + __EXTERN__ jmp_buf contexte_initial; + __EXTERN__ jmp_buf contexte_processus; + __EXTERN__ jmp_buf contexte_thread; + + __EXTERN__ volatile int signal_test; + + __EXTERN__ pid_t pid_processus_pere; + + __EXTERN__ pthread_mutex_t mutex_liste_threads + __STATIC_MUTEX_INITIALIZATION__; + __EXTERN__ pthread_mutex_t mutex_creation_variable_partagee + __STATIC_MUTEX_INITIALIZATION__; + __EXTERN__ pthread_mutex_t mutex_sections_critiques; + __EXTERN__ pthread_mutex_t mutex_liste_variables_partagees; + __EXTERN__ pthread_mutex_t mutex_sem __STATIC_MUTEX_INITIALIZATION__; + + __EXTERN__ volatile int routine_recursive; + +# define SEM_FORK 0 +# define SEM_QUEUE 1 +# define SEM_SIGNALISATION 2 +# define SEM_ARRET_SIGNALISATION 3 + + sem_t *sem_init2(unsigned int valeur, pid_t pid, int ordre); + sem_t *sem_init3(unsigned int valeur, pid_t pid, pthread_t tid, int ordre); + int sem_destroy2(sem_t *semaphore_p, pid_t pid, int ordre); + int sem_destroy3(sem_t *semaphore_p, pid_t pid, pthread_t tid, int ordre); + int sem_getvalue2(sem_t *semaphore, int *valeur); + sem_t *sem_open2(pid_t pid, int ordre); +#endif + +// Le mutex est là uniquement pour pouvoir émuler le comportement +// de sem_getvalue() sur un système comme MacOS X qui ne possède pas +// cette fonction. +#ifdef Darwin #define sem_getvalue(semaphore, value) sem_getvalue2(semaphore, value) #define sem_post(semaphore) \ ({ int r; pthread_mutex_lock(&mutex_sem); \ @@ -311,25 +564,19 @@ int sem_getvalue2(sem_t *semaphore, int stderr, __VA_ARGS__) #define fprintf(flux, ...) transliterated_fprintf(s_etat_processus, \ flux, __VA_ARGS__) -#define uprintf(...) transliterated_fprintf(NULL, \ - stderr, __VA_ARGS__) -#define ufprintf(flux, ...) transliterated_fprintf(NULL, \ - flux, __VA_ARGS__) - -// Tous les messages pour DISP, INPUT et les E/S par readline sont sur stderr. -// Cela évite aux messages envoyés par les gestionnaires de signaux d'être -// indéfiniment bloqués. +#define uprintf(...) std_fprintf(stderr, __VA_ARGS__) +#define ufprintf(flux, ...) std_fprintf(flux, __VA_ARGS__) #ifdef SunOS # define fopen(...) ({ FILE *desc; \ while((desc = fopen(__VA_ARGS__)) == NULL) \ { if ((errno != EINTR) && (errno != 0)) break; } desc; }) +# define freopen(...) ({ FILE *desc; \ + while((desc = freopen(__VA_ARGS__)) == NULL) \ + { if ((errno != EINTR) && (errno != 0)) break; } desc; }) # define fclose(...) ({ int ios; \ while((ios = fclose(__VA_ARGS__)) != 0) \ { if ((errno != EINTR) && (errno != 0)) break; } ios; }) -# define fread(...) ({ int ios; \ - while((ios = fread(__VA_ARGS__)) < 0) \ - { if ((errno != EINTR) && (errno != 0)) break; } ios; }) # define fflush(flux) ({ int ios; \ while((ios = fflush((flux == stdout) ? stderr : flux)) != 0) \ { if ((errno != EINTR) && (errno != 0)) break; } ios; }) @@ -362,7 +609,7 @@ int sem_getvalue2(sem_t *semaphore, 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; }) // 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 @@ -400,7 +647,7 @@ int sem_getvalue2(sem_t *semaphore, int { \ for(i = 0; i < nb; i++) \ uprintf(" %s\n", appels[i]); \ - free(appels); \ + sys_free(appels); \ } \ else \ uprintf("Nullified backtrace\n"); \ @@ -474,23 +721,6 @@ pid_t debug_fork(); pthread_mutex_unlock(mutex) #endif -#ifdef DEBUG_SEMAPHORES -#define sem_wait(a) ({ int value; sem_getvalue(a, &value); \ - uprintf("[%d-%llu] Semaphore %s (%p) "\ - "waiting at %s() " \ - "line #%d\n", (int) getpid(), (unsigned long long) pthread_self(), \ - #a, a, __FUNCTION__, __LINE__), fflush(stdout); \ - if (value > 1) BUG(1, uprintf("Value %d\n", value)); sem_wait(a); }) -#define sem_post(a) ({ int value; sem_getvalue(a, &value); \ - uprintf("[%d-%llu] Semaphore %s (%p) "\ - "posting at %s() " \ - "line #%d\n", (int) getpid(), (unsigned long long) pthread_self(), \ - #a, a, __FUNCTION__, __LINE__), fflush(stdout); \ - if (value > 0) BUG(1, uprintf("Value %d\n", value)); sem_post(a); }) -#define sem_destroy(a) ({ int value; sem_getvalue(a, &value); \ - if (value == 0) BUG(1, uprintf("Value %d\n", value)); sem_destroy(a); }) -#endif - /* ================================================================================ @@ -568,13 +798,22 @@ pid_t debug_fork(); #ifdef DEBUG_ERREURS # ifdef MESSAGES # define __erreur(i) i +# define __erreur_(i) i # else +# undef _ERREURS_VARIABLES +# ifdef _ERREURS_VARIABLES +# define __erreur_(i) __erreur(i) +# else +# define __erreur_(i) i +# endif # define __erreur(i) ({ if (strstr(__FUNCTION__, "recherche_variable") \ - == NULL) fprintf(stderr, "ERROR %d AT %s() LINE %d\n", \ - i, __FUNCTION__, __LINE__); i; }) + == NULL) ufprintf(stderr, \ + "ERROR %d AT %s() FROM %s LINE %d\n", \ + i, __FUNCTION__, __FILE__, __LINE__); i; }) # endif #else # define __erreur(i) i +# define __erreur_(i) i #endif @@ -582,7 +821,7 @@ pid_t debug_fork(); #ifndef RPLARGS # define d_es 2000 # define d_es_allocation_memoire __erreur(2001) -# define d_es_variable_introuvable __erreur(2002) +# define d_es_variable_introuvable __erreur_(2002) # define d_es_pile_vide __erreur(2003) # define d_es_end_incoherent __erreur(2004) # define d_es_peripherique_stdin __erreur(2005) @@ -595,6 +834,8 @@ pid_t debug_fork(); # define d_es_interruption_invalide __erreur(2012) # define d_es_contexte __erreur(2013) # define d_es_somme_controle __erreur(2014) +# define d_es_semaphore __erreur(2015) +# define d_es_mutex_acquis_autre_thread __erreur(2016) #endif /* @@ -660,7 +901,7 @@ pid_t debug_fork(); # define d_ex_absence_graphique_courant __erreur(9) # define d_ex_erreur_traitement_condition __erreur(10) # define d_ex_erreur_traitement_boucle __erreur(11) -# define d_ex_variable_non_definie __erreur(12) +# define d_ex_variable_non_definie __erreur_(12) # define d_ex_drapeau_inexistant __erreur(13) # define d_ex_nom_invalide __erreur(14) # define d_ex_element_inexistant __erreur(15) @@ -731,6 +972,16 @@ pid_t debug_fork(); # define d_ex_clef_inexistante __erreur(80) # define d_ex_nom_implicite __erreur(81) # define d_ex_version_bibliotheque __erreur(82) +# define d_ex_creation_variable_globale __erreur(83) +# define d_ex_erreur_interne_rplcas __erreur(84) +# define d_ex_fichier_corrompu __erreur(85) +# define d_ex_mutex_acquis_autre_thread __erreur(86) +# define d_ex_expression_reguliere __erreur(87) +# define d_ex_instruction_indisponible __erreur(88) +# define d_ex_chiffrement __erreur(89) +# define d_ex_chiffrement_indisponible __erreur(90) +# define d_ex_longueur_clef_chiffrement __erreur(91) +# define d_ex_taille_message __erreur(92) #endif @@ -746,12 +997,49 @@ pid_t debug_fork(); -------------------------------------------------------------------------------- */ +#ifdef MIN +# undef MIN +#endif + +#ifdef MAX +# undef MAX +#endif + +#define ADR __RPL_ADR +#define ALG __RPL_ALG +#define BIN __RPL_BIN +#define CHN __RPL_CHN +#define CPL __RPL_CPL +#define FCH __RPL_FCH +#define FCT __RPL_FCT +#define INT __RPL_INT +#define LST __RPL_LST +#define MCX __RPL_MCX +#define MIN __RPL_MIN +#define MRL __RPL_MRL +#define MTX __RPL_MTX +#define NOM __RPL_NOM +#define NON __RPL_NON +#define PRC __RPL_PRC +#define REL __RPL_REL +#define RPN __RPL_RPN +#define SCK __RPL_SCK +#define SLB __RPL_SLB +#define SPH __RPL_SPH +#define SQL __RPL_SQL +#define TBL __RPL_TBL +#define VCX __RPL_VCX +#define VIN __RPL_VIN +#define VRL __RPL_VRL + +enum t_rplcas_commandes { RPLCAS_INTEGRATION = 0, RPLCAS_LIMITE }; + enum t_type { ADR = 0, ALG, BIN, CHN, CPL, FCH, FCT, INT, LST, MCX, MIN, MRL, MTX, NOM, NON, PRC, REL, RPN, SCK, SLB, SPH, SQL, TBL, VCX, VIN, VRL }; /* - ADR : adresse sur 32 bits (au moins) non signés (unsigned long) + ADR : adresse sur 64 bits signés. Adresse d'une définition à interpréter. ALG : expression algébrique (struct_liste_chainee *) @@ -763,7 +1051,7 @@ enum t_type { ADR = 0, ALG, BIN, CHN, C Sans objet. Type C/Fortran : unsigned integer8 - CHN : chaine de caracteres (character*(*), unsigned char *) + CHN : chaine de caracteres (unsigned char *) Sans objet. CPL : complexe sur 2*64 bits (complex*16, struct_complexe16 *) @@ -853,7 +1141,7 @@ typedef struct objet #ifndef RPLARGS typedef struct fichier { - unsigned long descripteur; + int descripteur; unsigned char acces; /* S/D/I */ unsigned char binaire; /* Y/N/F */ @@ -881,6 +1169,7 @@ typedef struct fichier typedef struct rpl_mutex { pthread_mutex_t mutex; + pthread_t tid; } struct_mutex; #endif @@ -945,7 +1234,7 @@ typedef struct bibliotheque #ifndef RPLARGS typedef struct descripteur_fichier { - unsigned long identifiant; + int identifiant; unsigned char effacement; unsigned char type; // C (file *) ou S (sqlite *) @@ -954,8 +1243,11 @@ typedef struct descripteur_fichier pid_t pid; pthread_t tid; - file *descripteur_c; - sqlite3 *descripteur_sqlite; + union + { + file *descripteur_c; + sqlite3 *descripteur_sqlite; + }; } struct_descripteur_fichier; #endif @@ -988,6 +1280,7 @@ typedef struct connecteur_sql # ifdef POSTGRESQL_SUPPORT PGconn *postgresql; # endif + sqlite3 *sqlite; } descripteur; } struct_connecteur_sql; #endif @@ -1001,6 +1294,10 @@ typedef struct connecteur_sql "POSTGRESQL") == 0) \ postgresqlclose((*((struct_connecteur_sql *) (*s_objet).objet)) \ .descripteur); \ + else if (strcmp((*((struct_connecteur_sql *) (*s_objet).objet)).type, \ + "SQLITE") == 0) \ + sqlite3_close((*((struct_connecteur_sql *) (*s_objet).objet)) \ + .descripteur.sqlite); \ else \ BUG(1, uprintf("SQL type '%s' not allowed!", \ (*((struct_connecteur_sql *) (*s_objet).objet)).type)); @@ -1050,6 +1347,41 @@ typedef struct liste_chainee /* -------------------------------------------------------------------------------- + Structure de gestion des signaux en provenance de rplsignal +-------------------------------------------------------------------------------- +*/ + +#define d_NOMBRE_SIGNAUX 64 + +typedef struct gestion_signaux +{ + unsigned char masque_signaux[d_NOMBRE_SIGNAUX]; + + /* + * 'I' : signal ignoré + * 'Q' : signal mis en queue pour un traitement ultérieur + * 'N' : traitement normal du signal + */ + + integer8 queue_signaux[d_NOMBRE_SIGNAUX]; + integer8 nombre_signaux_en_queue; + struct_objet *corps_signaux[d_NOMBRE_SIGNAUX]; + + pthread_mutex_t mutex; +} struct_gestion_signaux; + +#ifndef MAIN_RPL +# define __STATIC_GESTION_SIGNAUX__ +#else +# define __STATIC_GESTION_SIGNAUX__ = { .mutex = PTHREAD_MUTEX_INITIALIZER } +#endif + +__EXTERN__ volatile struct_gestion_signaux signaux_externes + __STATIC_GESTION_SIGNAUX__; + + +/* +-------------------------------------------------------------------------------- Structure liste profilage -------------------------------------------------------------------------------- */ @@ -1132,6 +1464,7 @@ typedef struct descripteur_thread pthread_t thread_pere; pthread_mutex_t mutex; + pthread_mutex_t mutex_nombre_references; volatile logical1 thread_actif; @@ -1140,8 +1473,10 @@ typedef struct descripteur_thread int pipe_injections[2]; int pipe_nombre_injections[2]; int pipe_interruptions[2]; - int pipe_nombre_objets_attente[2]; - int pipe_nombre_interruptions_attente[2]; + // pipe_nombre_elements_attente == 0 => initialisation ou terminaison + // pipe_nombre_elements_attente == 1 => objet en attente + // pipe_nombre_elements_attente == 2 => interruption en attente + int pipe_nombre_elements_attente[2]; int pipe_acquittement[2]; volatile integer8 nombre_objets_dans_pipe; @@ -1150,9 +1485,6 @@ typedef struct descripteur_thread logical1 processus_detache; logical1 destruction_objet; - sigset_t oldset; - sigset_t set; - volatile signed long nombre_references; } struct_descripteur_thread; @@ -1174,8 +1506,6 @@ typedef struct liste_pile_systeme { struct liste_pile_systeme *suivant; - struct_liste_chainee *pointeur_objet_retour; - struct_objet *indice_boucle; struct_objet *limite_indice_boucle; struct_objet *objet_de_test; @@ -1213,21 +1543,25 @@ typedef struct liste_pile_systeme /* type clôture : - C CASE : END termine un test SELECT/CASE/THEN/END/DEFAULT/END. - D DO : END termine une boucle DO/UNTIL/END. - I IF : END termine un test IF/THEN (ELSE)/END. - J IFERR : END termine un test IFERR/THEN (ELSE)/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. - L LOOP : boucle utilisé dans le traitement de l'instruction RETURN. + C SELECT : END termine un test SELECT/DEFAULT/END. + D DO : END termine une boucle DO/UNTIL/END. + I IF : END termine un test IF/THEN (ELSE)/END. + J IFERR : END termine un test IFERR/THEN (ELSE)/END. + K CASE : END termine un test CASE/THEN/END + W WHILE : END termine une boucle WHILE/REPEAT/END. + Q CRITICAL : END termine une section critique CRITICAL/END + + F FOR : NEXT ou STEP termine une boucle avec compteur. + 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 initialisation. + A FORALL : NEXT termine une boucle sur un objet. */ - unsigned long adresse_retour; - unsigned long niveau_courant; + integer8 adresse_retour; + integer8 niveau_courant; + struct_liste_chainee *pointeur_objet_retour; } struct_liste_pile_systeme; #endif @@ -1241,16 +1575,16 @@ typedef struct liste_pile_systeme #ifndef RPLARGS typedef union position_variable { - unsigned long adresse; + integer8 adresse; struct_objet *pointeur; } union_position_variable; typedef struct variable { unsigned char *nom; - unsigned char origine; + unsigned char origine; // P(rogramme) ou E(valuation) - unsigned long niveau; + integer8 niveau; union_position_variable variable_statique; union_position_variable variable_partagee; @@ -1275,24 +1609,14 @@ typedef struct variable_partage unsigned char *nom; unsigned char origine; - unsigned long niveau; + integer8 niveau; union_position_variable variable_partagee; struct_objet *objet; -} struct_variable_partagee; - -typedef struct table_variables_partagees -{ - pthread_mutex_t mutex; - - volatile struct_variable_partagee *table; - volatile unsigned long nombre_variables; - volatile unsigned long nombre_variables_allouees; - - unsigned long position_variable; -} struct_table_variables_partagees; + pthread_mutex_t mutex; +} struct_variable_partagee; #endif @@ -1312,7 +1636,7 @@ typedef struct variable_statique // Position de création de la variable statique dans le programme ou dans // l'expression. 'origine' vaut 'P' pour programme ou 'E' pour expression. - unsigned long niveau; + integer8 niveau; union_position_variable variable_statique; @@ -1329,7 +1653,7 @@ typedef struct variable_statique typedef struct vecteur { - unsigned long taille; + integer8 taille; unsigned char type; /* C (complex*16), R (real*8), I (integer*8) */ @@ -1345,8 +1669,8 @@ typedef struct vecteur typedef struct matrice { - unsigned long nombre_lignes; - unsigned long nombre_colonnes; + integer8 nombre_lignes; + integer8 nombre_colonnes; unsigned char type; /* C (complex*16), R (real*8), I (integer*8) */ @@ -1362,7 +1686,7 @@ typedef struct matrice typedef struct tableau { - unsigned long nombre_elements; + integer8 nombre_elements; struct_objet **elements; } struct_tableau; @@ -1376,10 +1700,10 @@ typedef struct tableau typedef struct arbre { - struct_objet *objet; + struct_liste_chainee *feuille; - unsigned long nombre_feuilles; - struct arbre **feuilles; + integer8 nombre_branches; + struct arbre **branches; } struct_arbre; @@ -1440,6 +1764,161 @@ typedef struct rpl_arguments void *s_etat_processus; } struct_rpl_arguments; +/* +-------------------------------------------------------------------------------- + Structure d'arbre des instructions intrinsèques +-------------------------------------------------------------------------------- +*/ + +#ifndef RPLARGS +typedef struct instruction +{ + struct instruction **noeuds; + void (*feuille)(struct processus *); +} struct_instruction; +#endif + +/* +-------------------------------------------------------------------------------- + Structure d'arbre des variables globales et locales +-------------------------------------------------------------------------------- +*/ + +#ifndef RPLARGS +typedef struct arbre_variables +{ + unsigned int noeuds_utilises; + // Nombre de noeuds utilisés dans le + // tableau **noeuds + signed int indice_tableau_pere; + // Position de la structure dans le + // tableau **noeuds du père + + struct arbre_variables *noeud_pere; + struct arbre_variables **noeuds; + + struct liste_variables *feuille; + struct liste_variables_statiques *feuille_statique; +} struct_arbre_variables; + +typedef struct arbre_variables_partagees +{ + unsigned int noeuds_utilises; + // Nombre de noeuds utilisés dans le + // tableau **noeuds + signed int indice_tableau_pere; + // Position de la structure dans le + // tableau **noeuds du père + + struct arbre_variables_partagees *noeud_pere; + struct arbre_variables_partagees **noeuds; + + struct liste_variables_partagees *feuille; + + pthread_mutex_t mutex_feuille; +} struct_arbre_variables_partagees; + +#define INITIALISATION_MUTEX(mutex) \ + do { \ + pthread_mutexattr_t attributs_mutex; \ + pthread_mutexattr_init(&attributs_mutex); \ + pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); \ + pthread_mutex_init(&(mutex), &attributs_mutex); \ + pthread_mutexattr_destroy(&attributs_mutex); \ + } while(0) + +typedef struct tableau_variables +{ + unsigned char origine; + unsigned char *nom; // pointeur sur la struct_variable + // réelle et non copie de la chaîne + integer8 niveau; + + struct_objet *objet; // pointeur sur l'objet et non copie + // de l'objet. + + logical1 variable_verrouillee; + logical1 variable_masquee; + pthread_mutex_t *mutex; + union_position_variable variable_statique; + union_position_variable variable_partagee; +} struct_tableau_variables; + +// La liste des variables est une liste doublement chaînée et circulaire. +typedef struct liste_variables +{ + union + { + // Utilisation dans la gestion des variables + struct_variable *variable; + // Utilisation dans la pile système (variables par niveau) + struct_liste_chainee *liste; + }; + + struct arbre_variables *noeud_pere; + struct arbre_variables *noeud; + struct liste_variables *suivant; + struct liste_variables *precedent; +} struct_liste_variables; + +// La liste des variables statiques et une liste double chaînée et non +// circulaire. +typedef struct liste_variables_statiques +{ + struct liste_variables_statiques *suivant; + struct liste_variables_statiques *precedent; + struct liste_variables_statiques *reference; + struct_arbre_variables *feuille; + struct_variable_statique *variable; +} struct_liste_variables_statiques; + +typedef struct liste_variables_partagees +{ + struct liste_variables_partagees *suivant; + struct liste_variables_partagees *precedent; + struct liste_variables_partagees *reference; + struct_arbre_variables_partagees *feuille; + struct_variable_partagee *variable; + pthread_t tid; + pid_t pid; +} struct_liste_variables_partagees; +#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; + /* -------------------------------------------------------------------------------- @@ -1477,15 +1956,16 @@ typedef struct processus unsigned char mode_interactif; /*Y/N*/ unsigned char mode_evaluation_expression; /*Y/N*/ unsigned char traitement_cycle_exit; /*N/E/C*/ + unsigned char recherche_type; /*Y/N*/ - unsigned long position_courante; - unsigned long longueur_definitions_chainees; + integer8 position_courante; + integer8 longueur_definitions_chainees; /* Pointeurs sur les instructions */ int *pointeurs_caracteres; int nombre_caracteres; - struct instruction *arbre_instructions; + struct_instruction *arbre_instructions; /* Requetes */ @@ -1496,13 +1976,13 @@ typedef struct processus struct_liste_chainee *l_base_pile; struct_liste_chainee *l_base_pile_last; - unsigned long hauteur_pile_operationnelle; + integer8 hauteur_pile_operationnelle; /* Piles systemes */ struct_liste_pile_systeme *l_base_pile_systeme; - unsigned long hauteur_pile_systeme; + integer8 hauteur_pile_systeme; /* Gestion des processus */ @@ -1516,8 +1996,7 @@ typedef struct processus int pipe_injections; int pipe_nombre_injections; int pipe_interruptions; - int pipe_nombre_objets_attente; - int pipe_nombre_interruptions_attente; + int pipe_nombre_elements_attente; int nombre_objets_envoyes_non_lus; int nombre_objets_injectes; @@ -1527,13 +2006,14 @@ typedef struct processus logical1 presence_fusible; pthread_t thread_fusible; pthread_t thread_surveille_par_fusible; + pthread_t thread_signaux; + int pipe_signaux[2]; -# ifndef Cygwin - stack_t pile_signal; -# else -# define SA_ONSTACK 0 -# define RTLD_LOCAL 0 -# endif + volatile int pointeur_signal_ecriture; + volatile int pointeur_signal_lecture; + volatile enum signaux_rpl signaux_en_queue[LONGUEUR_QUEUE_SIGNAUX]; + volatile logical1 demarrage_fils; + volatile logical1 redemarrage_processus; /* Contextes */ @@ -1542,21 +2022,38 @@ typedef struct processus /* Variables */ - struct_variable *s_liste_variables; - unsigned long nombre_variables; - unsigned long nombre_variables_allouees; - - struct_variable_statique *s_liste_variables_statiques; - unsigned long nombre_variables_statiques; - unsigned long nombre_variables_statiques_allouees; - - struct_table_variables_partagees - *s_liste_variables_partagees; - - unsigned long niveau_courant; - unsigned long niveau_initial; - unsigned long position_variable_courante; - unsigned long position_variable_statique_courante; + // La liste des variables par niveau est doublement chaînée. + // À tout moment, elle pointe sur le niveau le plus haut existant et + // l_liste_variable_par_niveau->precedent renvoie la liste des + // définitions. l_liste_variable_par_niveau->precedent->precedent pointe + // sur la liste des variables globales. + // + // À l'initialisation : + // l_liste_variables_par_niveau->suivant == l_liste_variables_par_niveau + // l_liste_variables_par_niveau->precedent == l_liste_variables_par_niveau + + struct_arbre_variables *s_arbre_variables; + struct_liste_variables *l_liste_variables_par_niveau; + struct_liste_variables_statiques + *l_liste_variables_statiques; + + struct_arbre_variables_partagees + **s_arbre_variables_partagees; + struct_liste_variables_partagees + **l_liste_variables_partagees; + + logical1 niveau_supprime; + + struct_variable *pointeur_variable_courante; + struct_liste_variables *pointeur_feuille_courante; + struct_variable_statique *pointeur_variable_statique_courante; + struct_variable_partagee *pointeur_variable_partagee_courante; + + int *pointeurs_caracteres_variables; + int nombre_caracteres_variables; + + integer8 niveau_courant; + integer8 niveau_initial; logical1 creation_variables_statiques; logical1 creation_variables_partagees; @@ -1578,7 +2075,7 @@ typedef struct processus struct_liste_chainee *s_bibliotheques; struct_instruction_externe *s_instructions_externes; - unsigned long nombre_instructions_externes; + integer8 nombre_instructions_externes; /* Fichier d'impression */ @@ -1728,23 +2225,23 @@ typedef struct processus /* Traitement des exceptions */ logical1 arret_si_exception; - unsigned int exception; - unsigned int derniere_exception; - unsigned int exception_processus_fils; + int exception; + int derniere_exception; + int exception_processus_fils; /* Traitement des erreurs */ - unsigned int erreur_compilation; - unsigned int erreur_execution; - unsigned int erreur_systeme; + int erreur_compilation; + volatile int erreur_execution; + volatile int erreur_systeme; struct_objet *s_objet_errone; struct_objet *s_objet_erreur; logical1 erreur_scrutation; - volatile unsigned int erreur_systeme_processus_fils; - unsigned int erreur_execution_processus_fils; + volatile int erreur_systeme_processus_fils; + int erreur_execution_processus_fils; pid_t pid_erreur_processus_fils; @@ -1752,13 +2249,13 @@ typedef struct processus integer8 derniere_erreur_fonction_externe; - unsigned int derniere_erreur_systeme; - unsigned int derniere_erreur_execution; - unsigned int derniere_erreur_evaluation; + int derniere_erreur_systeme; + int derniere_erreur_execution; + int derniere_erreur_evaluation; unsigned char *instruction_derniere_erreur; - unsigned long niveau_derniere_erreur; + integer8 niveau_derniere_erreur; logical1 core; logical1 invalidation_message_erreur; @@ -1766,7 +2263,7 @@ typedef struct processus /* Debug */ logical1 debug; - integer8 type_debug; + logical8 type_debug; logical1 debug_programme; logical1 execution_pas_suivant; logical1 traitement_instruction_halt; @@ -1791,8 +2288,10 @@ typedef struct processus unsigned char traitement_interruption; /* Y/N */ unsigned char traitement_interruptible; /* Y/N */ + unsigned char traitement_at_poke; /* Y/N */ struct_objet *at_exit; + struct_objet *at_poke; /* Variables volatiles */ @@ -1804,6 +2303,7 @@ typedef struct processus volatile sig_atomic_t var_volatile_traitement_retarde_stop; volatile sig_atomic_t var_volatile_traitement_sigint; + volatile sig_atomic_t var_volatile_processus_racine; volatile sig_atomic_t var_volatile_processus_pere; volatile sig_atomic_t var_volatile_recursivite; @@ -1818,6 +2318,8 @@ typedef struct processus gsl_rng *generateur_aleatoire; const gsl_rng_type *type_generateur_aleatoire; + void *contexte_cas; + integer8 nombre_arguments; /* @@ -1836,13 +2338,16 @@ typedef struct processus unsigned char retour_routine_evaluation; unsigned char *localisation; - unsigned long niveau_recursivite; + integer8 niveau_recursivite; pid_t pid_processus_pere; pthread_t tid_processus_pere; + pthread_t tid; logical1 processus_detache; + enum t_type type_en_cours; + /* Profilage */ logical1 profilage; @@ -1851,109 +2356,103 @@ typedef struct processus struct_liste_profilage2 *pile_profilage_fonctions; struct timeval horodatage_profilage; - // Mutex spécifique au processus et donnant accès à la pile des processus - pthread_mutex_t mutex; pthread_mutex_t mutex_allocation; + pthread_mutex_t mutex_allocation_buffer; + pthread_mutex_t mutex_interruptions; + pthread_mutex_t mutex_pile_processus; + pthread_mutex_t mutex_signaux; - // Sémaphore autorisant les fork() - sem_t -# ifdef SEMAPHORES_NOMMES - * -# endif - semaphore_fork; + // Mutex autorisant les fork() + sem_t __PTR__ semaphore_fork; /* Mutexes */ struct_liste_chainee *liste_mutexes; pthread_mutex_t protection_liste_mutexes; + unsigned int sections_critiques; + +/* Variable d'initialisation pour SCHED */ + + logical1 initialisation_scheduler; + +/* Drapeau nécessaire à RESTART */ + + volatile logical1 requete_redemarrage; /* Gestion optimisée de la mémoire */ double estimation_taille_pile_tampon; - unsigned long taille_pile_tampon; + integer8 taille_pile_tampon; struct_liste_chainee *pile_tampon; double estimation_taille_pile_systeme_tampon; - unsigned long taille_pile_systeme_tampon; + integer8 taille_pile_systeme_tampon; struct_liste_pile_systeme *pile_systeme_tampon; - unsigned long taille_pile_objets; + integer8 taille_pile_objets; struct_objet *pile_objets; -# ifndef DEBUG_MALLOC -# define TAILLE_CACHE 16384 -# else -# define TAILLE_CACHE 4 -# endif - - unsigned long *objets_adr[TAILLE_CACHE]; - int pointeur_adr; - - logical8 *objets_bin[TAILLE_CACHE]; - int pointeur_bin; - - complex16 *objets_cpl[TAILLE_CACHE]; - int pointeur_cpl; - - struct fonction *objets_fct[TAILLE_CACHE]; - int pointeur_fct; - - integer8 *objets_int[TAILLE_CACHE]; - int pointeur_int; - - struct_matrice *objets_mat[TAILLE_CACHE]; - int pointeur_mat; - - struct_nom *objets_nom[TAILLE_CACHE]; - int pointeur_nom; - - real8 *objets_rel[TAILLE_CACHE]; - int pointeur_rel; - - struct_tableau *objets_tab[TAILLE_CACHE]; - int pointeur_tab; - - struct_vecteur *objets_vec[TAILLE_CACHE]; - int pointeur_vec; - - struct_liste_chainee *maillons[TAILLE_CACHE]; - int pointeur_maillons; +# define TAILLE_CACHE 1024 +# define CACHE(type, nom) \ + type *objets_##nom[TAILLE_CACHE]; \ + volatile int pointeur_##nom; + +# define CACHE2(type, nom) \ + type *nom[TAILLE_CACHE]; \ + volatile int pointeur_##nom; + + CACHE(integer8, adr) + CACHE(logical8, bin) + CACHE(complex16, cpl) + CACHE(struct_fonction, fct) + CACHE(integer8, int) + CACHE(struct_matrice, mat) + CACHE(struct_nom, nom) + CACHE(real8, rel) + CACHE(struct_tableau, tab) + CACHE(struct_vecteur, vec) + + CACHE2(struct_liste_chainee, maillons) + CACHE2(struct_arbre_variables, variables_noeud) + CACHE2(struct_arbre_variables_partagees, variables_partagees_noeud) + CACHE2(struct_liste_variables, variables_feuille) + CACHE2(struct_variable, variables_variable) + CACHE2(struct_arbre_variables *, variables_tableau_noeuds) + CACHE2(struct_arbre_variables_partagees *, + variables_tableau_noeuds_partages) + + CACHE2(struct_buffer, enveloppes_buffers) + unsigned char ***cache_buffer; + int *pointeur_cache_buffer; } struct_processus; #endif + /* --------------------------------------------------------------------------------- - Structures instruction intrinsèque --------------------------------------------------------------------------------- -*/ +================================================================================ + MISE EN PLACE DE L'ALLOCATEUR SPÉCIFIQUE +================================================================================*/ -#ifndef RPLARGS -typedef struct instruction -{ - struct instruction **noeud; - void (*feuille)(struct_processus *); -} struct_instruction; +#ifndef DEBUG_MEMOIRE +# define malloc(a) rpl_malloc(s_etat_processus, a) +# define realloc(a, b) rpl_realloc(s_etat_processus, a, b) +# define free(a) rpl_free(s_etat_processus, a) #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_free(void *ptr); /* --------------------------------------------------------------------------------- - Structure fonction --------------------------------------------------------------------------------- -*/ + * Wrapper de readline() pour que la fonction renvoie un pointeur sur un + * buffer alloué par rpl_malloc(). + */ -#ifndef RPLARGS -typedef struct fonction -{ - unsigned char *nom_fonction; - unsigned long nombre_arguments; - - void (*fonction)(struct_processus *); - - volatile struct_liste_chainee *prediction_saut; - volatile logical1 prediction_execution; -} struct_fonction; -#endif +#define readline(s) readline_wrapper(s_etat_processus, s) +unsigned char *readline_wrapper(struct_processus *s_etat_processus, + unsigned char *s); /* @@ -1971,6 +2470,7 @@ typedef struct fonction // BEGIN C PROTOTYPES void instruction_sensible_e(struct_processus *s_etat_processus); void instruction_sensible_i(struct_processus *s_etat_processus); +void instruction_sensible_infinity(struct_processus *s_etat_processus); void instruction_abort(struct_processus *s_etat_processus); void instruction_abs(struct_processus *s_etat_processus); @@ -1989,11 +2489,13 @@ void instruction_asr(struct_processus *s void instruction_atan(struct_processus *s_etat_processus); void instruction_atanh(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_axes(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_backtrace(struct_processus *s_etat_processus); void instruction_beep(struct_processus *s_etat_processus); void instruction_bessel(struct_processus *s_etat_processus); void instruction_bin(struct_processus *s_etat_processus); @@ -2004,11 +2506,13 @@ void instruction_ceil(struct_processus * void instruction_centr(struct_processus *s_etat_processus); void instruction_cf(struct_processus *s_etat_processus); void instruction_chr(struct_processus *s_etat_processus); +void instruction_cipher(struct_processus *s_etat_processus); void instruction_clear(struct_processus *s_etat_processus); void instruction_cllcd(struct_processus *s_etat_processus); void instruction_clmf(struct_processus *s_etat_processus); void instruction_close(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_clrerr(struct_processus *s_etat_processus); void instruction_clrfuse(struct_processus *s_etat_processus); @@ -2023,6 +2527,7 @@ void instruction_col_fleche(struct_proce void instruction_col_moins(struct_processus *s_etat_processus); void instruction_col_plus(struct_processus *s_etat_processus); void instruction_comb(struct_processus *s_etat_processus); +void instruction_compress(struct_processus *s_etat_processus); void instruction_con(struct_processus *s_etat_processus); void instruction_cond(struct_processus *s_etat_processus); void instruction_cont(struct_processus *s_etat_processus); @@ -2037,6 +2542,7 @@ void instruction_cosh(struct_processus * void instruction_cov(struct_processus *s_etat_processus); void instruction_cr(struct_processus *s_etat_processus); void instruction_create(struct_processus *s_etat_processus); +void instruction_critical(struct_processus *s_etat_processus); void instruction_crmtx(struct_processus *s_etat_processus); void instruction_cross(struct_processus *s_etat_processus); void instruction_crsmphr(struct_processus *s_etat_processus); @@ -2062,6 +2568,7 @@ void instruction_detach(struct_processus void instruction_dft(struct_processus *s_etat_processus); void instruction_dgtiz(struct_processus *s_etat_processus); void instruction_diag_fleche(struct_processus *s_etat_processus); +void instruction_digest(struct_processus *s_etat_processus); void instruction_disp(struct_processus *s_etat_processus); void instruction_division(struct_processus *s_etat_processus); void instruction_do(struct_processus *s_etat_processus); @@ -2088,6 +2595,7 @@ void instruction_elseif(struct_processus void instruction_end(struct_processus *s_etat_processus); void instruction_eng(struct_processus *s_etat_processus); void instruction_epsilon(struct_processus *s_etat_processus); +void instruction_eqv(struct_processus *s_etat_processus); void instruction_erase(struct_processus *s_etat_processus); void instruction_errm(struct_processus *s_etat_processus); void instruction_errn(struct_processus *s_etat_processus); @@ -2121,6 +2629,7 @@ void instruction_fleche_str(struct_proce void instruction_fleche_table(struct_processus *s_etat_processus); void instruction_floor(struct_processus *s_etat_processus); void instruction_for(struct_processus *s_etat_processus); +void instruction_forall(struct_processus *s_etat_processus); void instruction_format(struct_processus *s_etat_processus); void instruction_fp(struct_processus *s_etat_processus); void instruction_fs_test(struct_processus *s_etat_processus); @@ -2164,6 +2673,7 @@ void instruction_in(struct_processus *s_ void instruction_incr(struct_processus *s_etat_processus); void instruction_indep(struct_processus *s_etat_processus); void instruction_input(struct_processus *s_etat_processus); +void instruction_infinity(struct_processus *s_etat_processus); void instruction_inquire(struct_processus *s_etat_processus); void instruction_int(struct_processus *s_etat_processus); void instruction_interrupt(struct_processus *s_etat_processus); @@ -2187,6 +2697,7 @@ void instruction_lcd_fleche(struct_proce void instruction_lchol(struct_processus *s_etat_processus); void instruction_le(struct_processus *s_etat_processus); void instruction_legv(struct_processus *s_etat_processus); +void instruction_limit(struct_processus *s_etat_processus); void instruction_line(struct_processus *s_etat_processus); void instruction_list_fleche(struct_processus *s_etat_processus); void instruction_ln(struct_processus *s_etat_processus); @@ -2200,6 +2711,7 @@ void instruction_lq(struct_processus *s_ void instruction_lsq(struct_processus *s_etat_processus); void instruction_lt(struct_processus *s_etat_processus); void instruction_lu(struct_processus *s_etat_processus); +void instruction_l_vers_t(struct_processus *s_etat_processus); void instruction_mant(struct_processus *s_etat_processus); void instruction_mark(struct_processus *s_etat_processus); @@ -2254,6 +2766,7 @@ void instruction_pmax(struct_processus * void instruction_pmin(struct_processus *s_etat_processus); void instruction_poke(struct_processus *s_etat_processus); void instruction_polar(struct_processus *s_etat_processus); +void instruction_poll(struct_processus *s_etat_processus); void instruction_pos(struct_processus *s_etat_processus); void instruction_pourcent(struct_processus *s_etat_processus); void instruction_pourcent_ch(struct_processus *s_etat_processus); @@ -2310,9 +2823,11 @@ void instruction_read(struct_processus * void instruction_recode(struct_processus *s_etat_processus); void instruction_recv(struct_processus *s_etat_processus); void instruction_redraw(struct_processus *s_etat_processus); +void instruction_regex(struct_processus *s_etat_processus); void instruction_relax(struct_processus *s_etat_processus); void instruction_remove(struct_processus *s_etat_processus); void instruction_res(struct_processus *s_etat_processus); +void instruction_restart(struct_processus *s_etat_processus); void instruction_recall(struct_processus *s_etat_processus); void instruction_regv(struct_processus *s_etat_processus); void instruction_repeat(struct_processus *s_etat_processus); @@ -2321,6 +2836,8 @@ void instruction_return(struct_processus void instruction_revlist(struct_processus *s_etat_processus); void instruction_rewind(struct_processus *s_etat_processus); void instruction_rfuse(struct_processus *s_etat_processus); +void instruction_rgdl(struct_processus *s_etat_processus); +void instruction_rgdr(struct_processus *s_etat_processus); void instruction_rl(struct_processus *s_etat_processus); void instruction_rlb(struct_processus *s_etat_processus); void instruction_rnd(struct_processus *s_etat_processus); @@ -2378,6 +2895,7 @@ void instruction_sqlquery(struct_process void instruction_sqrt(struct_processus *s_etat_processus); void instruction_sr(struct_processus *s_etat_processus); void instruction_srb(struct_processus *s_etat_processus); +void instruction_srev(struct_processus *s_etat_processus); void instruction_sst(struct_processus *s_etat_processus); void instruction_star_d(struct_processus *s_etat_processus); void instruction_star_h(struct_processus *s_etat_processus); @@ -2435,10 +2953,11 @@ void instruction_trn(struct_processus *s void instruction_trnc(struct_processus *s_etat_processus); void instruction_true(struct_processus *s_etat_processus); void instruction_type(struct_processus *s_etat_processus); +void instruction_t_vers_l(struct_processus *s_etat_processus); void instruction_ucase(struct_processus *s_etat_processus); void instruction_uchol(struct_processus *s_etat_processus); -void instruction_undo(struct_processus *s_etat_processus); +void instruction_uncompress(struct_processus *s_etat_processus); void instruction_unlock(struct_processus *s_etat_processus); void instruction_unprotect(struct_processus *s_etat_processus); void instruction_until(struct_processus *s_etat_processus); @@ -2489,11 +3008,9 @@ void instruction_yield(struct_processus #ifndef RPLARGS void affectation_interruptions_logicielles(struct_processus *s_etat_processus); void affichage_pile(struct_processus *s_etat_processus, - struct_liste_chainee *l_element_courant, unsigned long - niveau_courant); + struct_liste_chainee *l_element_courant, integer8 niveau_courant); #endif -void *allocation(struct_processus *s_etat_processus, enum t_type type); void *allocation_maillon(struct_processus *s_etat_processus); #ifndef RPLARGS @@ -2505,15 +3022,21 @@ void appel_gnuplot(struct_processus *s_e void cf(struct_processus *s_etat_processus, unsigned char indice_drapeau); void cond(struct_processus *s_etat_processus, struct_matrice *s_matrice, real8 *condition); +void conversion_chaine(struct_processus *s_etat_processus, + unsigned char *chaine, unsigned char type); void conversion_decimal_vers_hms(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, unsigned char *chaine); void conversion_hms_vers_decimal(real8 *angle); -void conversion_majuscule_limitee(unsigned char *chaine_entree, - unsigned char *chaine_sortie, unsigned long longueur); +void conversion_majuscule_limitee( + unsigned char *chaine_entree, unsigned char *chaine_sortie, + integer8 longueur); void conversion_radians_vers_degres(real8 *angle); +void copie_arbre_variables(struct_processus *s_etat_processus, + struct_processus *s_nouvel_etat_processus); void correction_formateur_tex(struct_processus *s_etat_processus, unsigned char **ligne); void depilement_pile_systeme(struct_processus *s_etat_processus); @@ -2523,11 +3046,11 @@ void determinant(struct_processus *s_eta void *valeur); void deverrouillage_threads_concurrents(struct_processus *s_etat_processus); void ecriture_pile(struct_processus *s_etat_processus, file *flux, - struct_liste_chainee *l_element_courant, unsigned long niveau_courant); + struct_liste_chainee *l_element_courant, integer8 niveau_courant); void ecriture_profil(struct_processus *s_etat_processus); void effacement_pile_systeme(struct_processus *s_etat_processus); void empilement_pile_systeme(struct_processus *s_etat_processus); -void encart(struct_processus *s_etat_processus, unsigned long duree); +void encart(struct_processus *s_etat_processus, integer8 duree); void evaluation_romberg(struct_processus *s_etat_processus, struct_objet *s_expression, unsigned char *variable, real8 *point, real8 *valeur, logical1 *validite); @@ -2548,15 +3071,17 @@ void formateur_elementaire_tex(struct_pr file *fichier, struct_objet *s_objet, unsigned char environnement); void impression_pile(struct_processus *s_etat_processus, struct_liste_chainee *l_element_courant, - unsigned char methode, unsigned long niveau_courant); + unsigned char methode, integer8 niveau_courant); void impression_tex(struct_processus *s_etat_processus); void informations(struct_processus *s_etat_processus); void initialisation_allocateur(struct_processus *s_etat_processus); void initialisation_completion(void); +void initialisation_contexte_cas(struct_processus *s_etat_processus); void initialisation_drapeaux(struct_processus *s_etat_processus); void initialisation_generateur_aleatoire(struct_processus *s_etat_processus, - logical1 initialisation_automatique, unsigned long int racine); + logical1 initialisation_automatique, integer8 racine); void initialisation_instructions(struct_processus *s_etat_processus); +void initialisation_variables(struct_processus *s_etat_processus); #endif void initialisation_objet(struct_objet *s_objet); @@ -2569,17 +3094,15 @@ void insertion_thread_surveillance(struc void integrale_romberg(struct_processus *s_etat_processus, struct_objet *s_expression, unsigned char *variable, real8 a, real8 b, real8 precision); -void interruption1(int signal, siginfo_t *siginfo, void *context); -void interruption2(int signal, siginfo_t *siginfo, void *context); -void interruption3(int signal, siginfo_t *siginfo, void *context); -void interruption4(int signal, siginfo_t *siginfo, void *context); -void interruption5(int signal, siginfo_t *siginfo, void *context); -void interruption6(int signal, siginfo_t *siginfo, void *context); -void interruption7(int signal, siginfo_t *siginfo, void *context); -void interruption8(int signal, siginfo_t *siginfo, void *context); -void interruption9(int signal, siginfo_t *siginfo, void *context); -void interruption10(int signal, siginfo_t *siginfo, void *context); -void interruption11(int signal, siginfo_t *siginfo, void *context); +void interface_cas(struct_processus *s_etat_processus, + enum t_rplcas_commandes commande); +void interruption1(int signal); +void interruption2(int signal); +void interruption3(int signal); +void interruption4(int signal); +void interruption5(int signal); +void interruption6(int signal); +void interruption_depassement_pile(int urgence, stackoverflow_context_t scp); void inversion_matrice(struct_processus *s_etat_processus, struct_matrice *s_matrice); void lancement_daemon(struct_processus *s_etat_processus); @@ -2594,7 +3117,14 @@ void liberation_maillon(struct_processus void liberation_allocateur(struct_processus *s_etat_processus); void liberation_arbre_instructions(struct_processus *s_etat_processus, struct_instruction *arbre); +void liberation_arbre_variables(struct_processus *s_etat_processus, + struct_arbre_variables *arbre, logical1 definitions); +void liberation_arbre_variables_partagees(struct_processus *s_etat_processus, + struct_arbre_variables_partagees *arbre); +void liberation_contexte_cas(struct_processus *s_etat_processus); void liberation_generateur_aleatoire(struct_processus *s_etat_processus); +void liberation_mutexes_arbre_variables_partagees(struct_processus + *s_etat_processus, struct_arbre_variables_partagees *l_element_courant); void liberation_threads(struct_processus *s_etat_processus); void liberation_profil(struct_processus *s_etat_processus); void localisation_courante(struct_processus *s_etat_processus); @@ -2610,17 +3140,23 @@ void retrait_thread(struct_processus *s_ void retrait_thread_surveillance(struct_processus *s_etat_processus, struct_descripteur_thread *s_argument_thread); void rplcore(struct_processus *s_etat_processus); +#endif + void scrutation_injection(struct_processus *s_etat_processus); + +#ifndef RPLARGS +void scrutation_interruptions(struct_processus *s_etat_processus); void sf(struct_processus *s_etat_processus, unsigned char indice_drapeau); 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, integer8 taille_octets); +void *thread_signaux(void *argument); void trace(struct_processus *s_etat_processus, FILE *flux); void traitement_asynchrone_exceptions_gsl(struct_processus *s_etat_processus); void traitement_exceptions_gsl(const char *reason, const char *file, int line, int gsl_errno); void traitement_interruptions_logicielles(struct_processus *s_etat_processus); void tri_base_symboles_externes(struct_processus *s_etat_processus); -void tri_vecteur(real8 *vecteur, unsigned long taille); +void tri_vecteur(real8 *vecteur, integer8 taille); void valeurs_propres(struct_processus *s_etat_processus, struct_matrice *s_matrice, struct_vecteur *s_valeurs_propres, @@ -2640,13 +3176,29 @@ void verrouillage_threads_concurrents(st /* -------------------------------------------------------------------------------- + Fonctions de gestion des signaux +-------------------------------------------------------------------------------- +*/ + +#ifndef RPLARGS +void creation_queue_signaux(struct_processus *s_etat_processus); +void liberation_queue_signaux(struct_processus *s_etat_processus); +void destruction_queue_signaux(struct_processus *s_etat_processus); +int envoi_signal_contexte(struct_processus *s_etat_processus, + enum signaux_rpl signal); +int envoi_signal_processus(pid_t pid, enum signaux_rpl signal); +int envoi_signal_thread(pthread_t tid, enum signaux_rpl signal); +#endif + +/* +-------------------------------------------------------------------------------- Fonctions de sommation de vecteur dans perte de précision -------------------------------------------------------------------------------- */ -real8 sommation_vecteur_reel(real8 *vecteur, unsigned long *taille, +real8 sommation_vecteur_reel(real8 *vecteur, integer8 *taille, logical1 *erreur_memoire); -complex16 sommation_vecteur_complexe(complex16 *vecteur, unsigned long *taille, +complex16 sommation_vecteur_complexe(complex16 *vecteur, integer8 *taille, logical1 *erreur_memoire); /* @@ -2656,7 +3208,8 @@ complex16 sommation_vecteur_complexe(com */ #ifndef RPLARGS -int rplinit(int argc, char *argv[], unsigned char ***resultats, char *rpl_home); +int rplinit(int argc, char *argv[], char *envp[], + unsigned char ***resultats, char *rpl_home); #endif /* @@ -2667,20 +3220,24 @@ int rplinit(int argc, char *argv[], unsi #ifndef RPLARGS real8 correlation_statistique(struct_matrice *s_matrice, - unsigned long colonne_1, unsigned long colonne_2, logical1 *erreur); + integer8 colonne_1, integer8 colonne_2, logical1 *erreur); real8 covariance_statistique(struct_matrice *s_matrice, - unsigned long colonne_1, unsigned long colonne_2, + integer8 colonne_1, integer8 colonne_2, unsigned char type, logical1 *erreur); -struct_vecteur *ecart_type_statistique(struct_matrice *s_matrice, - unsigned char type); -struct_vecteur *moyenne_statistique(struct_matrice *s_matrice); -struct_vecteur *sommation_colonne_statistique(struct_matrice *s_matrice, - unsigned long colonne); -struct_vecteur *sommation_produits_colonnes_statistiques(struct_matrice - *s_matrice, unsigned long colonne_1, unsigned long colonne_2); -struct_vecteur *sommation_statistique(struct_matrice *s_matrice); -struct_vecteur *variance_statistique(struct_matrice *s_matrice, - unsigned char type); +struct_vecteur *ecart_type_statistique(struct_processus *s_etat_processus, + struct_matrice *s_matrice, unsigned char type); +struct_vecteur *moyenne_statistique(struct_processus *s_etat_processus, + struct_matrice *s_matrice); +struct_vecteur *sommation_colonne_statistique( + struct_processus *s_etat_processus, struct_matrice *s_matrice, + integer8 colonne); +struct_vecteur *sommation_produits_colonnes_statistiques( + struct_processus *s_etat_processus, struct_matrice + *s_matrice, integer8 colonne_1, integer8 colonne_2); +struct_vecteur *sommation_statistique(struct_processus *s_etat_processus, + struct_matrice *s_matrice); +struct_vecteur *variance_statistique(struct_processus *s_etat_processus, + struct_matrice *s_matrice, unsigned char type); #endif /* @@ -2703,7 +3260,7 @@ struct_liste_chainee *depilement_pile_op struct_liste_chainee *empilement_pile_operationnelle(struct_rpl_arguments *s_rpl_arguments, struct_objet *s_objet); struct_liste_chainee *sauvegarde_arguments(struct_rpl_arguments - *s_rpl_arguments, unsigned long nombre_arguments); + *s_rpl_arguments, integer8 nombre_arguments); /* -------------------------------------------------------------------------------- @@ -2714,32 +3271,52 @@ struct_liste_chainee *sauvegarde_argumen #ifndef RPLARGS unsigned char *analyse_algebrique(struct_processus *s_etat_processus, unsigned char *chaine_algebrique, struct_liste_chainee **l_base_liste); -unsigned char *recherche_chemin_fichiers_temporaires(struct_processus - *s_etat_processus); -unsigned char *compactage(unsigned char *chaine); -unsigned char *conversion_majuscule(unsigned char *chaine); +unsigned char *analyse_flux(struct_processus *s_etat_processus, + unsigned char *flux, integer8 longueur); +unsigned char *chiffrement(struct_processus *s_etat_processus, + const EVP_CIPHER *type_chiffrement, + logical1 encodage, unsigned char *message, integer8 longueur_message, + unsigned char *clef, integer8 longueur_clef, + unsigned char *vecteur_initialisation, + integer8 *longueur_message_chiffre); +unsigned char *compactage(struct_processus *s_etat_processus, + 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 *chemin); -unsigned char *extraction_chaine(unsigned char *chaine, unsigned long i, - unsigned long j); +unsigned char *date_compilation(struct_processus *s_etat_processus); +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, struct_objet *s_objet); unsigned char *formateur_fichier(struct_processus *s_etat_processus, struct_objet *s_objet, struct_objet *s_format, - long longueur, long longueur_champ, unsigned char format, - unsigned char type, long *longueur_effective, long *recursivite); + integer8 longueur, integer8 longueur_champ, unsigned char format, + unsigned char type, integer8 *longueur_effective, integer8 *recursivite, + logical1 export_fichier); +unsigned char *formateur_flux(struct_processus *s_etat_processus, + unsigned char *donnees, integer8 *longueur); unsigned char *formateur_fichier_nombre(struct_processus *s_etat_processus, void *valeur_numerique, unsigned char type, - long longueur, long longueur_champ, unsigned char format); + integer8 longueur, integer8 longueur_champ, unsigned char format); +unsigned char *formateur_fichier_binaire_nombre(struct_processus + *s_etat_processus, void *valeur_numerique, unsigned char type_entree, + unsigned char type, integer8 longueur, integer8 *longueur_conversion); unsigned char *formateur_fichier_reel(struct_processus *s_etat_processus, void *valeur_numerique, unsigned char type, - long longueur, long longueur_champ, unsigned char format); + integer8 longueur, integer8 longueur_champ, unsigned char format); unsigned char *formateur_nombre(struct_processus *s_etat_processus, void *valeur_numerique, unsigned char type); unsigned char *formateur_reel(struct_processus *s_etat_processus, void *valeur_numerique, unsigned char type); unsigned char *messages(struct_processus *s_etat_processus); -unsigned char *purification_chaine(unsigned char *chaine); +unsigned char *pointeur_ieme_caractere(struct_processus *s_etat_processus, + unsigned char *chaine, integer8 position); +unsigned char *purification_chaine(struct_processus *s_etat_processus, + unsigned char *chaine); +unsigned char *recherche_chemin_fichiers_temporaires(struct_processus + *s_etat_processus); unsigned char *reencodage(struct_processus *s_etat_processus, unsigned char *chaine_entree, unsigned char *codage_entree, unsigned char *codage_sortie); @@ -2756,11 +3333,14 @@ unsigned char *transliteration(struct_pr #ifndef RPLARGS logical1 analyse_syntaxique(struct_processus *s_etat_processus); +logical1 arret_thread_signaux(struct_processus *s_etat_processus); logical1 caracteristiques_fichier(struct_processus *s_etat_processus, unsigned char *nom, logical1 *existence, logical1 *ouverture, unsigned long *unite); logical1 controle(struct_processus *s_etat_processus, unsigned char *fichier, unsigned char *type, unsigned char *somme_candidate); +logical1 controle_integrite(struct_processus *s_etat_processus, + unsigned char *executable_candidat, unsigned char *executable); logical1 creation_variable(struct_processus *s_etat_processus, struct_variable *s_variable, unsigned char autorisation_creation_variable_statique, @@ -2777,21 +3357,28 @@ logical1 destruction_fichier(unsigned ch logical1 empilement(struct_processus *s_etat_processus, struct_liste_chainee **l_base_liste, struct_objet *s_objet); logical1 empilement_pile_last(struct_processus *s_etat_processus, - unsigned long nombre_arguments); + integer8 nombre_arguments); logical1 evaluation(struct_processus *s_etat_processus, struct_objet *s_objet, unsigned char type_evaluation); logical1 initialisation_fichier_acces_direct(struct_processus *s_etat_processus, sqlite3 *sqlite, logical1 binaire); logical1 initialisation_fichier_acces_indexe(struct_processus *s_etat_processus, sqlite3 *sqlite, integer8 position_clef, logical1 binaire); +logical1 lancement_thread_signaux(struct_processus *s_etat_processus); logical1 recherche_instruction_suivante(struct_processus *s_etat_processus); +logical1 recherche_instruction_suivante_recursive( + struct_processus *s_etat_processus, integer8 recursivite); logical1 retrait_variable(struct_processus *s_etat_processus, unsigned char *nom_variable, unsigned char type); -logical1 retrait_variable_par_niveau(struct_processus *s_etat_processus); +logical1 retrait_variables_par_niveau(struct_processus *s_etat_processus); logical1 retrait_variable_partagee(struct_processus *s_etat_processus, unsigned char *nom_variable, union_position_variable position); +logical1 retrait_variables_partagees_locales( + struct_processus *s_etat_processus); logical1 retrait_variable_statique(struct_processus *s_etat_processus, unsigned char *nom_variable, union_position_variable position); +logical1 retrait_variables_statiques_locales( + struct_processus *s_etat_processus); logical1 sequenceur(struct_processus *s_etat_processus); logical1 sequenceur_optimise(struct_processus *s_etat_processus); #endif @@ -2805,6 +3392,7 @@ logical1 sequenceur_optimise(struct_proc logical1 depassement_addition(integer8 *a, integer8 *b, integer8 *resultat); logical1 depassement_multiplication(integer8 *a, integer8 *b, integer8 *resultat); +logical1 depassement_soustraction(integer8 *a, integer8 *b, integer8 *resultat); logical1 depassement_puissance(integer8 *a, integer8 *b, integer8 *resultat); #ifndef RPLARGS @@ -2812,16 +3400,13 @@ logical1 ecriture_pipe(struct_processus struct_objet *s_objet); logical1 recherche_variable(struct_processus *s_etat_processus, unsigned char *nom_variable); -logical1 recherche_variable_partagee(struct_processus *s_etat_processus, - unsigned char *nom_variable, union_position_variable position, - unsigned char origine); -logical1 recherche_variable_statique(struct_processus *s_etat_processus, - unsigned char *nom_variable, union_position_variable position, - unsigned char origine); +logical1 recherche_variable_globale(struct_processus *s_etat_processus, + unsigned char *nom_variable); logical1 test_cfsf(struct_processus *s_etat_processus, unsigned char indice_drapeau); logical1 test_expression_rpn(unsigned char *chaine); logical1 test_fonction(unsigned char *chaine); +logical1 validation_chaine(unsigned char *chaine); #endif /* @@ -2843,12 +3428,28 @@ 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); +#ifndef RPLARGS +int initialisation_etat_processus_readline(); +int liberation_etat_processus_readline(); +integer8 liste_variables(struct_processus *s_etat_processus, + struct_tableau_variables *tableau); +integer8 nombre_variables(struct_processus *s_etat_processus); +int readline_analyse_syntaxique(int count, int key); +int readline_effacement(int count, int key); +#endif +int std_fprintf(file *flux, const char *format, ...); int tex_fprintf(struct_processus *s_etat_processus, file *flux, const char *format, ...); int transliterated_fprintf(struct_processus *s_etat_processus, file *flux, 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)(), struct_rpl_arguments *rpl_arguments); @@ -2860,7 +3461,6 @@ int wrapper_instruction_intrinseque(void #ifndef RPLARGS unsigned char longueur_entiers_binaires(struct_processus *s_etat_processus); -unsigned char recherche_longueur_optimale(integer8 parametre); #endif /* @@ -2881,6 +3481,10 @@ logical8 masque_entiers_binaires(struct_ #ifndef RPLARGS integer8 occupation_memoire(struct_objet *s_objet); +integer8 longueur_chaine(struct_processus *s_etat_processus, + unsigned char *chaine); +integer8 position_caractere_de_chaine(struct_processus *s_etat_processus, + unsigned char *chaine, unsigned char *position); #endif /* @@ -2896,6 +3500,19 @@ 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 -------------------------------------------------------------------------------- */ @@ -2925,31 +3542,35 @@ struct_descripteur_fichier *descripteur_ struct_objet *copie_objet(struct_processus *s_etat_processus, struct_objet *s_objet, unsigned char type); +struct_objet *allocation(struct_processus *s_etat_processus, enum t_type type); #ifndef RPLARGS struct_objet *formateur_date(struct_processus *s_etat_processus, struct timeval *temps); +struct_objet *lecture_fichier_non_formate(struct_processus *s_etat_processus, + void *argument, integer8 longueur_buffer, logical1 recursivite); struct_objet *lecture_pipe(struct_processus *s_etat_processus, int pipe); struct_objet *parametres_sql(struct_processus *s_etat_processus, struct_objet *s_parametres); struct_objet *simplification(struct_processus *s_etat_processus, struct_objet *s_objet); -#endif + +struct_arbre_variables *allocation_noeud(struct_processus *s_etat_processus); +struct_arbre_variables **allocation_tableau_noeuds( + struct_processus *s_etat_processus); /* -------------------------------------------------------------------------------- - Fonctions gérant les arbres de simplification + Fonctions renvoyant un pointeur sur une *struct_liste_variables_statiques + ou *struct_liste_variables_partagees -------------------------------------------------------------------------------- */ -#ifndef RPLARGS -struct_arbre *creation_arbre(struct_processus *s_etat_processus, - struct_objet **t_objets, unsigned long indice, - unsigned long indice_maximal); -void liberation_arbre(struct_processus *s_etat_processus, - struct_arbre *s_noeud); -void parcours_arbre(struct_processus *s_etat_processus, struct_arbre *s_noeud); -void simplification_arbre(struct_processus *s_etat_processus, - struct_arbre *s_noeud); +struct_liste_variables_statiques *recherche_variable_statique(struct_processus + *s_etat_processus, unsigned char *nom_variable, + union_position_variable position, unsigned char origine); +struct_liste_variables_partagees *recherche_variable_partagee(struct_processus + *s_etat_processus, unsigned char *nom_variable, + union_position_variable position, unsigned char origine); #endif /* @@ -2987,15 +3608,13 @@ void f77multiplicationci_(complex16 *ca, void f77multiplicationcr_(complex16 *ca, real8 *rb, complex16 *resultat); void f77puissancecc_(complex16 *ca, complex16 *cb, complex16 *resultat); -void f77puissanceci_(complex16 *ca, integer8 *ib, complex16 *resultat, - integer4 *troncature); +void f77puissanceci_(complex16 *ca, integer8 *ib, complex16 *resultat); void f77puissancecr_(complex16 *ca, real8 *rb, complex16 *resultat); void f77puissanceic_(integer8 *ia, complex16 *cb, complex16 *resultat); void f77puissanceii_(integer8 *ia, integer8 *ib, integer8 *resultat); void f77puissanceir_(integer8 *ia, real8 *rb, real8 *resultat); void f77puissancerc_(real8 *ra, complex16 *cb, complex16 *resultat); -void f77puissanceri_(real8 *ra, integer8 *ib, real8 *resultat, - integer4 *troncature); +void f77puissanceri_(real8 *ra, integer8 *ib, real8 *resultat); void f77puissancerr_(real8 *ra, real8 *rb, real8 *resultat); void f77racinecarreec_(complex16 *ca, complex16 *resultat);