Annotation of rpl/src/rpl.h, revision 1.36

1.1       bertrand    1: /*
                      2: ================================================================================
1.24      bertrand    3:   RPL/2 (R) version 4.0.15
1.1       bertrand    4:   Copyright (C) 1989-2010 Dr. BERTRAND Joël
                      5: 
                      6:   This file is part of RPL/2.
                      7: 
                      8:   RPL/2 is free software; you can redistribute it and/or modify it
                      9:   under the terms of the CeCILL V2 License as published by the french
                     10:   CEA, CNRS and INRIA.
                     11:  
                     12:   RPL/2 is distributed in the hope that it will be useful, but WITHOUT
                     13:   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
                     14:   FITNESS FOR A PARTICULAR PURPOSE.  See the CeCILL V2 License
                     15:   for more details.
                     16:  
                     17:   You should have received a copy of the CeCILL License
                     18:   along with RPL/2. If not, write to info@cecill.info.
                     19: ================================================================================
                     20: */
                     21: 
                     22: 
                     23: #ifndef INCLUSION_RPL
                     24: #define INCLUSION_RPL
1.10      bertrand   25: 
1.1       bertrand   26: #define _GNU_SOURCE
1.32      bertrand   27: #define _POSIX_C_SOURCE        200112L
1.10      bertrand   28: #define _REENTRANT
                     29: 
1.32      bertrand   30: #ifdef Darwin
1.36    ! bertrand   31: #  define SIGPOLL          SIGINFO
1.32      bertrand   32: #  define _DARWIN_C_SOURCE
                     33: #endif
                     34: 
1.1       bertrand   35: /*
                     36: ================================================================================
                     37:   INCLUSIONS
                     38: ================================================================================
                     39: */
                     40: 
                     41: #include <stdio.h>
                     42: #include <stdlib.h>
                     43: #include <math.h>
                     44: #include <string.h>
                     45: #include <strings.h>
                     46: #include <syslog.h>
                     47: #include <errno.h>
1.18      bertrand   48: #include <stdarg.h>
1.1       bertrand   49: 
                     50: #ifndef RPLARGS
1.32      bertrand   51: #  include <sys/mman.h>
1.1       bertrand   52: #  include <sys/resource.h>
                     53: #  include <sys/select.h>
                     54: #  include <sys/socket.h>
                     55: #  include <sys/stat.h>
                     56: #  include <sys/time.h>
                     57: #  include <sys/timeb.h>
                     58: #  include <sys/types.h>
                     59: #  include <sys/un.h>
                     60: #  include <sys/wait.h>
                     61: 
                     62: #  include <arpa/inet.h>
                     63: #  include <netinet/in.h>
                     64: #  include <netdb.h>
                     65: 
                     66: #  include <dlfcn.h>
                     67: #  include <fcntl.h>
                     68: #  include <pthread.h>
                     69: #  include <pwd.h>
                     70: #  include <semaphore.h>
                     71: #  include <setjmp.h>
                     72: #  include <signal.h>
                     73: #  include <termios.h>
                     74: #  include <time.h>
                     75: #  include <unistd.h>
                     76: #  include <locale.h>
                     77: 
                     78: #  include "history.h"
                     79: #  include "readline.h"
                     80: #  include "termcap.h"
                     81: #  include "iconv.h"
                     82: 
1.13      bertrand   83: #  include "openssl/evp.h"
1.15      bertrand   84: #  include "sqlite3.h"
1.13      bertrand   85: 
1.1       bertrand   86: #  define HAVE_INLINE
                     87: #  define GSL_RANGE_CHECK_OFF
                     88: #  include "gsl/gsl_cdf.h"
                     89: #  include "gsl/gsl_cblas.h"
                     90: #  include "gsl/gsl_errno.h"
                     91: #  include "gsl/gsl_fft_complex.h"
                     92: #  include "gsl/gsl_permutation.h"
                     93: #  include "gsl/gsl_randist.h"
                     94: #  include "gsl/gsl_rng.h"
                     95: #  include "gsl/gsl_sf.h"
                     96: #endif
                     97: 
                     98: #ifdef SunOS
                     99: #  include <ieeefp.h>
                    100: #endif
                    101: 
1.23      bertrand  102: // Définition spécifique à Hurd
                    103: #ifndef PIPE_BUF
                    104: #  define fpathconf (".", _PC_PIPE_BUF)
                    105: #endif
                    106: 
1.1       bertrand  107: #ifdef MYSQL_SUPPORT
                    108: #   include <mysql.h>
                    109: #   define mysqlclose(arg)     mysql_close(arg.mysql)
                    110: #else
                    111: #   define mysqlclose(arg)
                    112: #endif
                    113: 
                    114: #ifdef POSTGRESQL_SUPPORT
                    115: #   include <libpq-fe.h>
                    116: #  define postgresqlclose(arg) PQfinish(arg.postgresql)
                    117: #else
                    118: #   define postgresqlclose(arg)
                    119: #endif
                    120: 
1.25      bertrand  121: #include "librplprototypes.h"
1.1       bertrand  122: 
                    123: /*
                    124: ================================================================================
                    125:   SIGNAUX
                    126: ================================================================================
                    127: */
                    128: 
                    129: #ifndef RPLARGS
1.27      bertrand  130: // Arrêt par STOP
1.1       bertrand  131: #  define SIGFSTOP                 SIGUSR1
1.27      bertrand  132: // Démarrage d'un processus fils
1.1       bertrand  133: #  define SIGSTART                 SIGUSR2
1.27      bertrand  134: // Injection de données
1.1       bertrand  135: #  define SIGINJECT                SIGQUIT
1.27      bertrand  136: // Arrêt général
1.1       bertrand  137: #  define SIGABORT                 SIGPROF
1.27      bertrand  138: // Arrêt d'un processus fils depuis autre chose que STOP
                    139: #  define SIGFABORT                SIGPOLL
1.1       bertrand  140: #  define d_NOMBRE_INTERRUPTIONS   64
                    141: #endif
                    142: 
                    143: /*
                    144: ================================================================================
                    145:   Granularité temporelle
                    146: ================================================================================
                    147: */
                    148: 
                    149: #ifndef RPLARGS
                    150: #  define GRANULARITE_us           10
                    151: #  define GRANULARITE_us_max       100000
                    152: #  define INCR_GRANULARITE(g) \
                    153:    do  g = 1000 * ((g >= (GRANULARITE_us_max * 1000)) \
                    154:            ? GRANULARITE_us_max : ((g / 1000) + GRANULARITE_us)); while(0)
                    155: #endif
                    156: 
                    157: /*
                    158: ================================================================================
                    159:   Options de debug
                    160: ================================================================================
                    161: */
                    162: 
                    163: #ifndef RPLARGS
                    164: #  define d_debug_pile_utilisateur         ((integer8) 0x1)
                    165: #  define d_debug_pile_systeme             ((integer8) 0x2)
                    166: #  define d_debug_appels_fonctions         ((integer8) 0x4)
                    167: #  define d_debug_processus                ((integer8) 0x8)
                    168: #  define d_debug_analyse                  ((integer8) 0x10)
                    169: #  define d_debug_fusible                  ((integer8) 0x20)
                    170: #  define d_debug_variables                ((integer8) 0x40)
                    171: #  define d_debug_fonctions_intrinseques   ((integer8) 0x80)
                    172: #  define d_debug_niveaux                  ((integer8) 0x100)
                    173: #  define d_conversion_RPN                 ((integer8) 0x200)
                    174: #  define d_traitement_interruption        ((integer8) 0x400)
                    175: #  define d_debug_signaux                  ((integer8) 0x800)
                    176: #endif
                    177: 
                    178: /*
                    179: ================================================================================
                    180:   TYPES
                    181: ================================================================================
                    182: */
                    183: 
                    184: typedef FILE                   file;
                    185: typedef unsigned char          t_8_bits;
                    186: 
                    187: #ifndef RPLARGS
                    188: #  include "rpltypes.conv.h"
                    189: #else
                    190: #  include "rpltypes.h"
                    191: #endif
                    192: 
                    193: /*
                    194: ================================================================================
                    195:   Variables globales
                    196: ================================================================================
                    197: */
                    198: 
                    199: #ifndef RPLARGS
1.22      bertrand  200: #  ifdef SEMAPHORES_NOMMES
                    201: #      define LONGUEUR_NOM_SEMAPHORE   64
                    202: #  endif
1.1       bertrand  203: #  ifndef MAIN_RPL
1.22      bertrand  204:        extern jmp_buf              contexte;
                    205:        extern jmp_buf              contexte_initial;
                    206: 
                    207: #      ifdef SEMAPHORES_NOMMES
                    208:        extern pthread_mutex_t      mutex_sem;
                    209: #      endif
1.1       bertrand  210: 
1.22      bertrand  211:        extern pthread_key_t        semaphore_fork_processus_courant;
1.1       bertrand  212: 
1.22      bertrand  213:        extern sem_t
                    214: #      ifdef SEMAPHORES_NOMMES
                    215:        *
                    216: #      endif
                    217:                                    semaphore_liste_threads;
                    218: 
                    219:        extern sem_t
                    220: #      ifdef SEMAPHORES_NOMMES
                    221:        *
                    222: #      endif
                    223:                                    semaphore_gestionnaires_signaux;
                    224: 
                    225:        extern sem_t
                    226: #      ifdef SEMAPHORES_NOMMES
                    227:        *
                    228: #      endif
                    229:                                    semaphore_gestionnaires_signaux_atomique;
                    230: 
                    231: #      ifdef SEMAPHORES_NOMMES
                    232:        // 0 -> liste_threads
                    233:        // 1 -> gestionnaire_signaux
                    234:        // 2 -> gestionnaire_signaux_atomique
                    235:        // 3 -> &((*s_etat_processus).semaphore_fork)
                    236:            extern unsigned char    noms_semaphores[4][LONGUEUR_NOM_SEMAPHORE];
                    237:            extern sem_t            *semaphores_nommes[4];
                    238: #      endif
1.1       bertrand  239: #  else
1.22      bertrand  240:        jmp_buf                     contexte;
                    241:        jmp_buf                     contexte_initial;
                    242: 
                    243: #      ifdef SEMAPHORES_NOMMES
                    244:        pthread_mutex_t             mutex_sem = PTHREAD_MUTEX_INITIALIZER;
                    245: #      endif
                    246: 
                    247:        pthread_key_t               semaphore_fork_processus_courant;
                    248: 
                    249:        sem_t
                    250: #      ifdef SEMAPHORES_NOMMES
                    251:        *
                    252: #      endif
                    253:                                    semaphore_liste_threads;
1.1       bertrand  254: 
1.22      bertrand  255:        sem_t
                    256: #      ifdef SEMAPHORES_NOMMES
                    257:        *
                    258: #      endif
                    259:                                    semaphore_gestionnaires_signaux;
1.1       bertrand  260: 
1.22      bertrand  261:        sem_t
                    262: #      ifdef SEMAPHORES_NOMMES
                    263:        *
                    264: #      endif
                    265:                                    semaphore_gestionnaires_signaux_atomique;
                    266: 
                    267: #      ifdef SEMAPHORES_NOMMES
                    268:            unsigned char           noms_semaphores[4][LONGUEUR_NOM_SEMAPHORE];
                    269:            sem_t                   *semaphores_nommes[4];
                    270: #      endif
1.1       bertrand  271: #  endif
                    272: #endif
                    273: 
1.22      bertrand  274: #ifdef SEMAPHORES_NOMMES
                    275: enum t_semaphore   { sem_liste_threads = 0,
                    276:        sem_gestionnaires_signaux = 1,
                    277:        sem_gestionnaires_signaux_atomique = 2,
                    278:        sem_fork = 3 };
                    279: 
                    280: sem_t *sem_init2(unsigned int valeur, enum t_semaphore semaphore);
                    281: int sem_destroy2(sem_t *semaphore_p, enum t_semaphore semaphore);
                    282: int sem_getvalue2(sem_t *semaphore, int *valeur);
                    283: 
                    284: #define sem_getvalue(semaphore, value) sem_getvalue2(semaphore, value)
                    285: #define sem_post(semaphore) \
                    286:        ({ int r; pthread_mutex_lock(&mutex_sem); \
                    287:        r = sem_post(semaphore), pthread_mutex_unlock(&mutex_sem); r; })
                    288: #define sem_wait(semaphore) \
                    289:        ({ int r; pthread_mutex_lock(&mutex_sem); \
                    290:        r = sem_wait(semaphore), pthread_mutex_unlock(&mutex_sem); r; })
                    291: #define sem_trywait(semaphore) \
                    292:        ({ int r; pthread_mutex_lock(&mutex_sem); \
                    293:        r = sem_trywait(semaphore), pthread_mutex_unlock(&mutex_sem); r; })
                    294: #endif
                    295: 
1.1       bertrand  296: /*
                    297: ================================================================================
                    298:   Macros
                    299: ================================================================================
                    300: */
                    301: 
                    302: // Par défaut, tout est redirigé vers stderr sauf indication explicite de
                    303: // stdout.
                    304: 
                    305: #define printf(...) transliterated_fprintf(s_etat_processus, \
                    306:            stderr, __VA_ARGS__)
                    307: #define fprintf(flux, ...) transliterated_fprintf(s_etat_processus, \
                    308:            flux, __VA_ARGS__)
                    309: #define uprintf(...) transliterated_fprintf(NULL, \
                    310:            stderr, __VA_ARGS__)
                    311: #define ufprintf(flux, ...) transliterated_fprintf(NULL, \
                    312:            flux, __VA_ARGS__)
                    313: 
                    314: // Tous les messages pour DISP, INPUT et les E/S par readline sont sur stderr.
                    315: // Cela évite aux messages envoyés par les gestionnaires de signaux d'être
                    316: // indéfiniment bloqués.
                    317: 
                    318: #ifdef SunOS
                    319: #  define fopen(...) ({ FILE *desc; \
                    320:            while((desc = fopen(__VA_ARGS__)) == NULL) \
                    321:            { if ((errno != EINTR) && (errno != 0)) break; } desc; })
                    322: #  define fclose(...) ({ int ios; \
                    323:            while((ios = fclose(__VA_ARGS__)) != 0) \
                    324:            { if ((errno != EINTR) && (errno != 0)) break; } ios; })
                    325: #  define fread(...) ({ int ios; \
                    326:            while((ios = fread(__VA_ARGS__)) < 0) \
                    327:            { if ((errno != EINTR) && (errno != 0)) break; } ios; })
                    328: #  define fflush(flux) ({ int ios; \
                    329:            while((ios = fflush((flux == stdout) ? stderr : flux)) != 0) \
                    330:            { if ((errno != EINTR) && (errno != 0)) break; } ios; })
                    331: #  define sem_open(...) ({ sem_t *semaphore; \
                    332:            while((semaphore = sem_open(__VA_ARGS__)) == SEM_FAILED) \
                    333:            { if (errno != EINTR) break; }  semaphore; })
                    334: #else // !SunOS
                    335: #  define fflush(flux) fflush((flux == stdout) ? stderr : flux)
                    336: #endif
                    337: 
                    338: // Ajout d'un timeout sur les fonctions pipe() pour éviter une erreur
                    339: // système dans le cas où l'on a atteint le nombre maximale de fichiers
                    340: // ouverts.
                    341: 
                    342: #define pipe(descripteurs) \
                    343:    ({ \
                    344:        struct timespec temporisation; \
                    345:        int erreur, nombre_echecs; \
                    346:        nombre_echecs = 0; \
                    347:        do \
                    348:        { \
                    349:            if ((erreur = pipe(descripteurs)) == 0) break; \
                    350:            nombre_echecs++; \
                    351:            temporisation.tv_sec = 0; \
                    352:            temporisation.tv_nsec = ((long) 1000000000) * rand(); \
                    353:            nanosleep(&temporisation, NULL); \
                    354:        } while(nombre_echecs < 100); \
                    355:        erreur; \
                    356:     })
                    357: 
                    358: // Redéfinition de abs pour un fonctionnement en entier de type long long int
                    359: 
                    360: #if 1
                    361: #  define abs(i) ({ typeof(i) _i; _i = (i); (_i >= 0) ? _i : -_i; })
                    362: // typeof() est une extension de gcc, mais est présent sur d'autres compilateurs
                    363: // comme Sun Studio. Dans le cas où typeof() n'existe pas, il est possible
                    364: // d'utiliser la macro suivante, mais elle possède un effet de bord dû à
                    365: // l'évaluation multiple de l'argument.
                    366: #else
                    367: #  define abs(i) (((i) >= 0) ? (i) : (-i))
                    368: #endif
                    369: 
1.9       bertrand  370: #define NOTICE(m) \
                    371:    do \
                    372:    { \
                    373:        ufprintf(stderr, "[%d-%llu] %s() from %s at line %d: %s\n", \
                    374:                getpid(), (unsigned long long) pthread_self(), \
                    375:                __FUNCTION__, __FILE__, __LINE__, m); \
                    376:        fflush(stderr); \
                    377:    } while(0)
                    378: 
                    379: #ifdef __GLIBC__
                    380: #include <execinfo.h>
1.34      bertrand  381: #define __BACKTRACE
1.1       bertrand  382: #define BACKTRACE(n) \
                    383:    do \
                    384:    { \
                    385:        void            *buffer[n]; \
                    386:        int             nb, i; \
                    387:        char            **appels; \
                    388:        pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; \
                    389:        nb = backtrace(buffer, n); \
                    390:        appels = backtrace_symbols(buffer, nb); \
                    391:        pthread_mutex_lock(&mutex); \
                    392:        uprintf("[%d-%llu] BACKTRACE <%s()> at line #%d\n", \
                    393:                getpid(), pthread_self(), __FUNCTION__, __LINE__); \
                    394:        if (appels != NULL) \
                    395:        { \
                    396:            for(i = 0; i < nb; i++) \
1.23      bertrand  397:                uprintf("    %s\n", appels[i]); \
1.1       bertrand  398:            free(appels); \
                    399:        } \
                    400:        else \
                    401:            uprintf("Nullified backtrace\n"); \
                    402:        uprintf("[%d-%llu] END OF BACKTRACE\n", getpid(), pthread_self()); \
                    403:        fflush(stdout); \
                    404:        pthread_mutex_unlock(&mutex); \
                    405:    } while(0)
1.9       bertrand  406: #else
                    407: #define BACKTRACE(n) NOTICE("BACKTRACE only defined in glibc")
                    408: #endif
1.1       bertrand  409: 
1.35      bertrand  410: #ifdef __BACKTRACE
                    411: #  define BUG(b, ...) \
                    412:            do { if (b) { uprintf("[%d] BUG! <%s()> at line #%d of %s\n", \
                    413:            (int) getpid(), __FUNCTION__, __LINE__, __FILE__); \
                    414:            __VA_ARGS__; fflush(stdout); \
                    415:            BACKTRACE(64); \
                    416:            pthread_kill(pthread_self(), SIGBUS); }} while(0)
                    417: #else
                    418: #  define BUG(b, ...) \
                    419:            do { if (b) { uprintf("[%d] BUG! <%s()> at line #%d of %s\n", \
                    420:            (int) getpid(), __FUNCTION__, __LINE__, __FILE__); \
                    421:            __VA_ARGS__; fflush(stdout); \
                    422:            pthread_kill(pthread_self(), SIGBUS); }} while(0)
                    423: #endif
                    424: 
1.1       bertrand  425: 
                    426: /*
                    427: ================================================================================
                    428:   Affichage des points de retour des fonctions
                    429: ================================================================================
                    430: */
                    431: 
1.9       bertrand  432: #ifdef DEBUG_MEMOIRE
1.35      bertrand  433: void analyse_post_mortem();
1.9       bertrand  434: void *debug_memoire_ajout(size_t taille, const unsigned char *fonction,
                    435:        unsigned long ligne, const unsigned char *argument);
                    436: void *debug_memoire_modification(void *pointeur, size_t taille,
                    437:        const unsigned char *fonction, unsigned long ligne,
                    438:        const unsigned char *argument);
1.36    ! bertrand  439: void debug_memoire_reinitialisation();
1.9       bertrand  440: void debug_memoire_retrait(void *ptr);
1.35      bertrand  441: void debug_memoire_verification();
1.9       bertrand  442: 
                    443: #define malloc(s) debug_memoire_ajout(s, __FUNCTION__, __LINE__, #s)
                    444: #define free(s) debug_memoire_retrait(s)
                    445: #define realloc(s, t) debug_memoire_modification(s, t, \
                    446:            __FUNCTION__, __LINE__, #t)
                    447: #endif
                    448: 
1.1       bertrand  449: #ifdef DEBUG_RETURN
                    450: #define return uprintf("[%d] Return from <%s()> at line #%d " \
                    451:        "(%s [%d])\n", (int) getpid(), __FUNCTION__, \
1.9       bertrand  452:        __LINE__, strerror(errno), errno); fflush(stdout); errno = 0; return
1.1       bertrand  453: #endif
                    454: 
                    455: #ifdef DEBUG_MUTEX
                    456: #define pthread_mutex_lock(mutex) uprintf("[%d-%llu] Mutex %s (%p) " \
                    457:        "locking at %s() " \
                    458:        "line #%d\n", (int) getpid(), (unsigned long long) pthread_self(), \
                    459:        #mutex, mutex, __FUNCTION__, __LINE__), fflush(stdout), \
                    460:        pthread_mutex_lock(mutex)
                    461: #define pthread_mutex_unlock(mutex) uprintf("[%d-%llu] Mutex %s (%p) " \
                    462:        "unlocking at " \
                    463:        "%s() line #%d\n", (int) getpid(), (unsigned long long) \
                    464:        pthread_self(), #mutex, mutex, __FUNCTION__, __LINE__), \
                    465:        fflush(stdout), \
                    466:        pthread_mutex_unlock(mutex)
                    467: #endif
                    468: 
                    469: #ifdef DEBUG_SEMAPHORES
                    470: #define sem_wait(a) ({ int value; sem_getvalue(a, &value); \
                    471:        uprintf("[%d-%llu] Semaphore %s (%p) "\
                    472:        "waiting at %s() " \
                    473:        "line #%d\n", (int) getpid(), (unsigned long long) pthread_self(), \
                    474:        #a, a, __FUNCTION__, __LINE__), fflush(stdout); \
                    475:        if (value > 1) BUG(1, uprintf("Value %d\n", value)); sem_wait(a); })
                    476: #define sem_post(a) ({ int value; sem_getvalue(a, &value); \
                    477:        uprintf("[%d-%llu] Semaphore %s (%p) "\
                    478:        "posting at %s() " \
                    479:        "line #%d\n", (int) getpid(), (unsigned long long) pthread_self(), \
                    480:        #a, a, __FUNCTION__, __LINE__), fflush(stdout); \
                    481:        if (value > 0) BUG(1, uprintf("Value %d\n", value)); sem_post(a); })
                    482: #define sem_destroy(a) ({ int value; sem_getvalue(a, &value); \
                    483:        if (value == 0) BUG(1, uprintf("Value %d\n", value)); sem_destroy(a); })
                    484: #endif
                    485: 
                    486: #ifdef DEBUG_MALLOC
                    487: #define malloc(taille) ({ size_t s = taille; void *p; \
                    488:        p = malloc(taille); if (p != NULL) memset(p, 0, s); \
                    489:        /*uprintf("[%d-%llu] Allocating %p (%d bytes) at %s() line #%d\n", \
                    490:        (int) getpid(), (unsigned long long) pthread_self(), p, \
                    491:        (int) s, __FUNCTION__, __LINE__); fflush(stdout); */ p; })
                    492: #endif
                    493: 
                    494: #ifdef DEBUG_FREE
                    495: #define free(ptr) ({ void *p = ptr; \
                    496:        /*uprintf("[%d-%llu] Freeing %p (%d bytes) at %s() line #%d\n", \
                    497:        (int) getpid(), (unsigned long long) pthread_self(), p, \
                    498:        (int) sizeof(p), __FUNCTION__, __LINE__); fflush(stdout); */ \
                    499:        if (p != NULL) memset(p, 0, sizeof(p)); free(p); })
                    500: #endif
                    501: 
                    502: /*
                    503: ================================================================================
                    504:   DEFINIONS
                    505: ================================================================================
                    506: */
                    507: 
                    508: /*
                    509: --------------------------------------------------------------------------------
                    510:   Valeurs
                    511: --------------------------------------------------------------------------------
                    512: */
                    513: 
                    514: #define d_faux                 ((logical1) 0L)
                    515: #define d_vrai                 ((logical1) -1L)
                    516: 
                    517: #define d_absence_erreur       ((logical1) d_faux)
                    518: #define d_erreur               ((logical1) d_vrai)
                    519: 
1.31      bertrand  520: #define d_code_fin_chaine                  '\0'
                    521: #define d_code_espace                      ' '
                    522: #define d_code_retour_chariot              '\n'
                    523: #define d_code_tabulation                  '\t'
                    524: #define d_longueur_maximale_instruction        16
1.1       bertrand  525: 
                    526: #define d_INT                  "integer"
                    527: #define    d_REL                   "real"
                    528: #define d_CPL                  "complex"
                    529: #define d_VIN                  "[ integer ]"
                    530: #define d_VRL                  "[ real ]"
                    531: #define d_VCX                  "[ complex ]"
                    532: #define d_MIN                  "[[ integer ]]"
                    533: #define d_MRL                  "[[ real ]]"
                    534: #define d_MCX                  "[[ complex ]]"
                    535: #define d_BIN                  "# binary[bodh]"
                    536: #define d_NOM                  "'name'"
                    537: #define d_CHN                  "\"string\""
                    538: #define d_LST                  "{ list }"
                    539: #define d_ALG                  "'algebraic'"
                    540: #define d_RPN                  "<< RPN >>"
                    541: #define d_FCH                  "File $n { format }"
                    542: #define d_SLB                  "Library $n"
                    543: #define d_SQL                  "Sql $n (type)"
                    544: #define d_PRC                  "Process $n"
                    545: #define d_SCK                  "Socket $n { format }"
                    546: #define d_SPH                  "Semaphore $n 'name'"
                    547: #define d_TAB                  "<[ table ]>"
                    548: #define d_MTX                  "Mutex $n"
                    549: 
                    550: /*
                    551: --------------------------------------------------------------------------------
                    552:   Paramètres du système
                    553: --------------------------------------------------------------------------------
                    554: */
                    555: 
                    556: #ifndef RPLARGS
                    557: #  define ds_beep                              ""
                    558: #  define ds_fichier_historique                ".RPL2_history"
                    559: #  define ds_imposition_separateur_decimal     d_vrai
                    560: #  define ds_longueur_historique               256
                    561: #  define ds_nombre_maximum_fichiers_ouverts   65536
                    562: #  define ds_preprocesseur                     "rplpp " \
                    563:                                                    "--nostdinc -C 2> /dev/null"
                    564: #  define ds_rplcore                           "rpl-core"
                    565: #  define ds_rplprofile                        "rpl-profile"
                    566: #  define ds_sdat                              "SDAT"
                    567: #endif
                    568: 
                    569: /*
                    570: --------------------------------------------------------------------------------
                    571:   Erreurs système
                    572: --------------------------------------------------------------------------------
                    573: */
                    574: 
1.36    ! bertrand  575: #ifdef DEBUG_ERREURS
        !           576: #  ifdef MESSAGES
        !           577: #      define __erreur(i)  i
        !           578: #  else
        !           579: #      define __erreur(i)  ({ if (strstr(__FUNCTION__, "recherche_variable") \
        !           580:                == NULL) fprintf(stderr, "ERROR %d AT %s() LINE %d\n", \
        !           581:                i, __FUNCTION__, __LINE__); i; })
        !           582: #  endif
        !           583: #else
        !           584: #  define __erreur(i)  i
        !           585: #endif
        !           586: 
1.1       bertrand  587: 
                    588: // -1 : erreur provoquée par une bibliothèque externe
                    589: #ifndef RPLARGS
                    590: #  define d_es                                 2000
1.36    ! bertrand  591: #  define d_es_allocation_memoire              __erreur(2001)
        !           592: #  define d_es_variable_introuvable            __erreur(2002)
        !           593: #  define d_es_pile_vide                       __erreur(2003)
        !           594: #  define d_es_end_incoherent                  __erreur(2004)
        !           595: #  define d_es_peripherique_stdin              __erreur(2005)
        !           596: #  define d_es_erreur_fichier                  __erreur(2006)
        !           597: #  define d_es_execution_bibliotheque          __erreur(2007)
        !           598: #  define d_es_signal                          __erreur(2008)
        !           599: #  define d_es_processus                       __erreur(2009)
        !           600: #  define d_es_pile_operationnelle_vide        __erreur(2010)
        !           601: #  define d_es_nombre_max_descripteurs         __erreur(2011)
        !           602: #  define d_es_interruption_invalide           __erreur(2012)
        !           603: #  define d_es_contexte                        __erreur(2013)
        !           604: #  define d_es_somme_controle                  __erreur(2014)
1.1       bertrand  605: #endif
                    606: 
                    607: /*
                    608: --------------------------------------------------------------------------------
                    609:   Exceptions
                    610: --------------------------------------------------------------------------------
                    611: */
                    612: 
                    613: #ifndef RPLARGS
                    614: #  define d_ep                                 1000
1.36    ! bertrand  615: #  define d_ep_division_par_zero               __erreur(1001)
        !           616: #  define d_ep_matrice_non_inversible          __erreur(1002)
        !           617: #  define d_ep_resultat_indefini               __erreur(1003)
        !           618: #  define d_ep_underflow                       __erreur(1004)
        !           619: #  define d_ep_overflow                        __erreur(1005)
        !           620: #  define d_ep_domaine_definition              __erreur(1006)
        !           621: #  define d_ep_perte_precision                 __erreur(1007)
        !           622: #  define d_ep_decomposition_QR                __erreur(1008)
        !           623: #  define d_ep_matrice_non_definie_positive    __erreur(1009)
        !           624: #  define d_ep_decomposition_QZ                __erreur(1010)
        !           625: #  define d_ep_decomposition_SVD               __erreur(1011)
1.1       bertrand  626: #endif
                    627: 
                    628: /*
                    629: --------------------------------------------------------------------------------
                    630:   Erreurs de compilation
                    631: --------------------------------------------------------------------------------
                    632: */
                    633: 
                    634: #ifndef RPLARGS
                    635: #  define d_ec                                 3000
1.36    ! bertrand  636: #  define d_ec_niveau_definition_negatif       __erreur(3001)
        !           637: #  define d_ec_nom_definition_invalide         __erreur(3002)
        !           638: #  define d_ec_erreur_boucle_definie           __erreur(3003)
        !           639: #  define d_ec_erreur_instruction_end          __erreur(3004)
        !           640: #  define d_ec_erreur_instruction_until        __erreur(3005)
        !           641: #  define d_ec_source_incoherent               __erreur(3006)
        !           642: #  define d_ec_erreur_instruction_while        __erreur(3007)
        !           643: #  define d_ec_erreur_instruction_then         __erreur(3008)
        !           644: #  define d_ec_erreur_instruction_else         __erreur(3009)
        !           645: #  define d_ec_erreur_instruction_elseif       __erreur(3010)
        !           646: #  define d_ec_erreur_instruction_select       __erreur(3011)
        !           647: #  define d_ec_erreur_instruction_case         __erreur(3012)
1.1       bertrand  648: #endif
                    649: 
                    650: /*
                    651: --------------------------------------------------------------------------------
                    652:   Erreurs à l'exécution
                    653: --------------------------------------------------------------------------------
                    654: */
                    655: 
                    656: // -1 : erreur provoquée par une bibliothèque externe
                    657: #ifndef RPLARGS
                    658: #  define d_ex                                 0
1.36    ! bertrand  659: #  define d_ex_pile_vide                       __erreur(1)
        !           660: #  define d_ex_manque_argument                 __erreur(2)
        !           661: #  define d_ex_argument_invalide               __erreur(3)
        !           662: #  define d_ex_erreur_type_argument            __erreur(4)
        !           663: #  define d_ex_nom_reserve                     __erreur(5)
        !           664: #  define d_ex_nombre_arguments                __erreur(6)
        !           665: #  define d_ex_dimensions_invalides            __erreur(7)
        !           666: #  define d_ex_expression_invalide             __erreur(8)
        !           667: #  define d_ex_absence_graphique_courant       __erreur(9)
        !           668: #  define d_ex_erreur_traitement_condition     __erreur(10)
        !           669: #  define d_ex_erreur_traitement_boucle        __erreur(11)
        !           670: #  define d_ex_variable_non_definie            __erreur(12)
        !           671: #  define d_ex_drapeau_inexistant              __erreur(13)
        !           672: #  define d_ex_nom_invalide                    __erreur(14)
        !           673: #  define d_ex_element_inexistant              __erreur(15)
        !           674: #  define d_ex_absence_variable                __erreur(16)
        !           675: #  define d_ex_erreur_evaluation               __erreur(17)
        !           676: #  define d_ex_semaphore                       __erreur(18)
        !           677: #  define d_ex_longueur_fft                    __erreur(19)
        !           678: #  define d_ex_queue_impression                __erreur(20)
        !           679: #  define d_ex_type_trace_invalide             __erreur(21)
        !           680: #  define d_ex_erreur_fichier                  __erreur(22)
        !           681: #  define d_ex_absence_equation                __erreur(23)
        !           682: #  define d_ex_erreur_bibliotheque             __erreur(24)
        !           683: #  define d_ex_execution_bibliotheque          __erreur(25)
        !           684: #  define d_ex_stop                            __erreur(26)
        !           685: #  define d_ex_matrice_statistique_invalide    __erreur(27)
        !           686: #  define d_ex_dimensions_matrice_statistique  __erreur(28)
        !           687: #  define d_ex_absence_observations            __erreur(29)
        !           688: #  define d_ex_statistiques_echantillon        __erreur(30)
        !           689: #  define d_ex_observations_inexistantes       __erreur(31)
        !           690: #  define d_ex_syntaxe                         __erreur(32)
        !           691: #  define d_ex_cycle_hors_boucle               __erreur(33)
        !           692: #  define d_ex_conversion_unite                __erreur(34)
        !           693: #  define d_ex_erreur_parametre_fichier        __erreur(35)
        !           694: #  define d_ex_erreur_acces_fichier            __erreur(36)
        !           695: #  define d_ex_erreur_requete_fichier          __erreur(37)
        !           696: #  define d_ex_erreur_format_fichier           __erreur(38)
        !           697: #  define d_ex_fichier_verrouille              __erreur(39)
        !           698: #  define d_ex_verrou_indefini                 __erreur(40)
        !           699: #  define d_ex_fin_de_fichier_atteinte         __erreur(41)
        !           700: #  define d_ex_debut_de_fichier_atteint        __erreur(42)
        !           701: #  define d_ex_erreur_type_fichier             __erreur(43)
        !           702: #  define d_ex_fichier_vide                    __erreur(44)
        !           703: #  define d_ex_dimensions_differentes          __erreur(45)
        !           704: #  define d_ex_routines_mathematiques          __erreur(46)
        !           705: #  define d_ex_exit_hors_boucle                __erreur(47)
        !           706: #  define d_ex_longueur_dft                    __erreur(48)
        !           707: #  define d_ex_contexte                        __erreur(49)
        !           708: #  define d_ex_processus                       __erreur(50)
        !           709: #  define d_ex_image_processus                 __erreur(51)
        !           710: #  define d_ex_erreur_sql                      __erreur(52)
        !           711: #  define d_ex_variable_verrouillee            __erreur(53)
        !           712: #  define d_ex_variable_volatile               __erreur(54)
        !           713: #  define d_ex_erreur_processus                __erreur(55)
        !           714: #  define d_ex_erreur_impression               __erreur(56)
        !           715: #  define d_ex_nombre_arguments_fonction       __erreur(57)
        !           716: #  define d_ex_fonction_indisponible           __erreur(58)
        !           717: #  define d_ex_bibliotheque_chargee            __erreur(59)
        !           718: #  define d_ex_aucun_symbole                   __erreur(60)
        !           719: #  define d_ex_definition_ambigue              __erreur(61)
        !           720: #  define d_ex_fichier_hors_contexte           __erreur(62)
        !           721: #  define d_ex_socket_en_ecoute                __erreur(63)
        !           722: #  define d_ex_interruption_invalide           __erreur(64)
        !           723: #  define d_ex_erreur_transcodage              __erreur(65)
        !           724: #  define d_ex_absence_processus_pere          __erreur(66)
        !           725: #  define d_ex_creation_variable               __erreur(67)
        !           726: #  define d_ex_fusible                         __erreur(68)
        !           727: #  define d_ex_iswi_hors_interruption          __erreur(69)
        !           728: #  define d_ex_daemon                          __erreur(70)
        !           729: #  define d_ex_mutex                           __erreur(71)
        !           730: #  define d_ex_variable_statique_partagee      __erreur(72)
        !           731: #  define d_ex_variable_partagee               __erreur(73)
        !           732: #  define d_ex_graphique_memorise              __erreur(74)
        !           733: #  define d_ex_matrice_non_diagonale           __erreur(75)
        !           734: #  define d_ex_locales                         __erreur(76)
        !           735: #  define d_ex_representation                  __erreur(77)
        !           736: #  define d_ex_erreur_profilage                __erreur(78)
        !           737: #  define d_ex_enregistrement_inexistant       __erreur(79)
        !           738: #  define d_ex_clef_inexistante                __erreur(80)
        !           739: #  define d_ex_nom_implicite                   __erreur(81)
1.1       bertrand  740: #endif
                    741: 
                    742: 
                    743: /*
                    744: ================================================================================
                    745:   STRUCTURES
                    746: ================================================================================
                    747: */
                    748: 
                    749: /*
                    750: --------------------------------------------------------------------------------
                    751:   Structure objet
                    752: --------------------------------------------------------------------------------
                    753: */
                    754: 
                    755: enum t_type        { ADR = 0, ALG, BIN, CHN, CPL, FCH, FCT, INT, LST,
                    756:                MCX, MIN, MRL, MTX, NOM, NON, PRC, REL, RPN, SCK,
                    757:                SLB, SPH, SQL, TBL, VCX, VIN, VRL };
                    758: 
                    759:    /*
                    760:    ADR : adresse sur 32 bits (au moins) non signés (unsigned long)
                    761:            Adresse d'une définition à interpréter.
                    762: 
                    763:    ALG : expression algébrique (struct_liste_chainee *)
                    764:            La liste chaînée contient la définition convertie en notation
                    765:            polonaise inversée. Ce type diffère du type 'RPN' au niveau
                    766:            du format de sortie (notation algébrique).
                    767: 
                    768:    BIN : entier binaire sur 64 bits (unsigned integer8 *)
                    769:            Sans objet.
                    770:            Type C/Fortran : unsigned integer8
                    771: 
                    772:    CHN : chaine de caracteres (character*(*), unsigned char *)
                    773:            Sans objet.
                    774: 
                    775:    CPL : complexe sur 2*64 bits (complex*16, struct_complexe16 *)
                    776:            Sans objet.
                    777:            Type C/Fortran : complex16
                    778: 
                    779:    FCH : descripteur de fichier (struct_fichier *).
                    780: 
                    781:    FCT : déclaration d'une fonction et de son nombre d'arguments
                    782:            (struct_fonction *). Ce type n'est nécessaire que dans le
                    783:            traitement des types 'ALG' et 'RPN'.
                    784: 
                    785:    INT : entier sur 64 bits (integer*8, integer8 *)
                    786:            Sans objet.
                    787:            Type C/Fortran : integer8
                    788: 
                    789:    LST : liste (struct_liste_chainee *)
                    790:            Les objets sont enregistrés sous forme de liste chaînée récursive.
                    791:            Cela permet de traiter des tableaux de données hétérogènes de
                    792:            grandes dimensions. Le nombre de dimensions maximal est fixé par
                    793:            la mémoire de la station.
                    794: 
                    795:    MCX : matrice de complexes (struct_matrice *)
                    796:            Sans objet.
                    797: 
                    798:    MIN : matrice d'entiers (struct_matrice *)
                    799:            Sans objet.
                    800: 
                    801:    MRL : matrice de reels (struct_matrice *)
                    802:            Sans objet.
                    803: 
                    804:    MTX : mutex (struct_mutex *)
                    805:            Sans objet.
                    806: 
                    807:    NOM : nom de variable (struct_nom *)
                    808:            Sans objet.
                    809: 
                    810:    PRC : processus (struct_processus_fils *)
                    811:            Sans objet.
                    812: 
                    813:    REL : reel sur 64 bits (real*8, real8 *)
                    814:            Sans objet.
                    815: 
                    816:    RPN : definition (struct_liste_chainee *)
                    817:            Ce type diffère du type 'ALG' au niveau du format de sortie
                    818:            (notation polonaise inversée).
                    819: 
                    820:    SCK : socket (struct_socket *)
                    821: 
                    822:    SLB : bibliothèque dynamique partagée (struct_bibliotheque *) 
                    823:            Sans objet.
                    824: 
                    825:    SPH : sémaphore nommé (struct_semaphore *)
                    826: 
                    827:    SQL : connecteur sur une base de données SQL (struct_connecteur_sql *)
                    828: 
                    829:    TBL : tableau multidimensionnel d'objets (struct_tableau *).
                    830: 
                    831:    VCX : vecteur de complexes (struct_vecteur *)
                    832:            Sans objet.
                    833: 
                    834:    VIN : vecteur d'entiers (struct_vecteur *)
                    835:            Sans objet.
                    836: 
                    837:    VRL : vecteur de reels (struct_vecteur *)
                    838:            Sans objet.
                    839:    */
                    840: 
                    841: typedef struct objet
                    842: {
                    843:    enum t_type         type;
                    844: 
                    845:    volatile long       nombre_occurrences;
                    846: 
                    847:    pthread_mutex_t     mutex;
                    848: 
                    849:    void                *objet;
                    850: } struct_objet;
                    851: 
                    852: 
                    853: /*
                    854: --------------------------------------------------------------------------------
                    855:   Structure fichier
                    856: --------------------------------------------------------------------------------
                    857: */
                    858: 
                    859: #ifndef RPLARGS
                    860: typedef struct fichier
                    861: {
                    862:    unsigned long               descripteur;
                    863: 
                    864:    unsigned char               acces;          /* S/D/I */
                    865:    unsigned char               binaire;        /* Y/N/F */
                    866:    unsigned char               ouverture;
                    867:    unsigned char               protection;
                    868:    unsigned char               *nom;
                    869: 
                    870:    struct_objet                *format;
                    871: 
                    872:    pid_t                       pid;
                    873:    pthread_t                   tid;
                    874: 
                    875:    integer8                    position_clef;
                    876: } struct_fichier;
                    877: #endif
                    878: 
                    879: 
                    880: /*
                    881: --------------------------------------------------------------------------------
                    882:   Structure mutex
                    883: --------------------------------------------------------------------------------
                    884: */
                    885: 
                    886: #ifndef RPLARGS
                    887: typedef struct rpl_mutex
                    888: {
                    889:    pthread_mutex_t     mutex;
                    890: } struct_mutex;
                    891: #endif
                    892: 
                    893: 
                    894: /*
                    895: --------------------------------------------------------------------------------
                    896:   Structure sémaphore
                    897: --------------------------------------------------------------------------------
                    898: */
                    899: 
                    900: #ifndef RPLARGS
                    901: typedef struct semaphore
                    902: {
                    903:    unsigned char   *nom;
                    904:    sem_t           *semaphore;
                    905: } struct_semaphore;
                    906: #endif
                    907: 
                    908: 
                    909: /*
                    910: --------------------------------------------------------------------------------
                    911:   Structure marque
                    912: --------------------------------------------------------------------------------
                    913: */
                    914: 
                    915: #ifndef RPLARGS
                    916: typedef struct marque
                    917: {
                    918:    unsigned char       *label;
                    919:    unsigned char       *position;
                    920: 
                    921:    struct marque       *suivant;
                    922: } struct_marque;
                    923: #endif
                    924: 
                    925: 
                    926: /*
                    927: --------------------------------------------------------------------------------
                    928:   Structure bibliothèque
                    929: --------------------------------------------------------------------------------
                    930: */
                    931: 
                    932: #ifndef RPLARGS
                    933: typedef struct bibliotheque
                    934: {
                    935:    void                        *descripteur;
                    936: 
                    937:    pid_t                       pid;
                    938:    pthread_t                   tid;
                    939: 
                    940:    unsigned char               *nom;
                    941: } struct_bibliotheque;
                    942: #endif
                    943: 
                    944: 
                    945: /*
                    946: --------------------------------------------------------------------------------
                    947:   Structure descripteur fichier
                    948: --------------------------------------------------------------------------------
                    949: */
                    950: 
                    951: #ifndef RPLARGS
                    952: typedef struct descripteur_fichier
                    953: {
                    954:    unsigned long               identifiant;
                    955: 
                    956:    unsigned char               effacement;
1.15      bertrand  957:    unsigned char               type; // C (file *) ou S (sqlite *)
1.1       bertrand  958:    unsigned char               *nom;
                    959: 
                    960:    pid_t                       pid;
                    961:    pthread_t                   tid;
                    962: 
1.15      bertrand  963:    file                        *descripteur_c;
                    964:    sqlite3                     *descripteur_sqlite;
1.1       bertrand  965: } struct_descripteur_fichier;
                    966: #endif
                    967: 
                    968: 
                    969: /*
                    970: --------------------------------------------------------------------------------
                    971:   Structure connecteur SQL
                    972: --------------------------------------------------------------------------------
                    973: */
                    974: 
                    975: #ifndef RPLARGS
                    976: typedef struct connecteur_sql
                    977: {
                    978:    pid_t                       pid;
                    979:    pthread_t                   tid;
                    980: 
                    981:    /*
                    982:     * "MYSQL"
                    983:     * "POSTGRESQL"
                    984:     */
                    985: 
                    986:    unsigned char               *type;
                    987:    unsigned char               *locale;
                    988: 
                    989:    union
                    990:    {
                    991: #      ifdef MYSQL_SUPPORT
                    992:            MYSQL               *mysql;
                    993: #      endif
                    994: #      ifdef POSTGRESQL_SUPPORT
                    995:            PGconn              *postgresql;
                    996: #      endif
                    997:    } descripteur;
                    998: } struct_connecteur_sql;
                    999: #endif
                   1000: 
                   1001: #define sqlclose(s_objet) \
                   1002:    if (strcmp((*((struct_connecteur_sql *) (*s_objet).objet)).type, "MYSQL") \
                   1003:            == 0) \
                   1004:        mysqlclose((*((struct_connecteur_sql *) (*s_objet).objet)) \
                   1005:                .descripteur); \
                   1006:    else if (strcmp((*((struct_connecteur_sql *) (*s_objet).objet)).type, \
                   1007:            "POSTGRESQL") == 0) \
                   1008:        postgresqlclose((*((struct_connecteur_sql *) (*s_objet).objet)) \
                   1009:                .descripteur); \
                   1010:    else \
                   1011:        BUG(1, uprintf("SQL type '%s' not allowed!", \
                   1012:                (*((struct_connecteur_sql *) (*s_objet).objet)).type));
                   1013: 
                   1014: /*
                   1015: --------------------------------------------------------------------------------
                   1016:   Structure socket
                   1017: --------------------------------------------------------------------------------
                   1018: */
                   1019: 
                   1020: #ifndef RPLARGS
                   1021: typedef struct socket
                   1022: {
                   1023:    int                         domaine;
                   1024:    int                         socket;
                   1025: 
                   1026:    pid_t                       pid;
                   1027:    pthread_t                   tid;
                   1028: 
                   1029:    unsigned char               *adresse;
                   1030:    unsigned char               *adresse_distante;
                   1031:    unsigned char               binaire;
                   1032:    unsigned char               socket_en_ecoute;
                   1033:    logical1                    socket_connectee;
                   1034:    unsigned char               effacement;
                   1035:    unsigned char               localisation;
                   1036:    unsigned char               protection;
                   1037:    unsigned char               type[19 + 1];
                   1038: 
                   1039:    struct_objet                *format;
                   1040: } struct_socket;
                   1041: #endif
                   1042: 
                   1043: /*
                   1044: --------------------------------------------------------------------------------
                   1045:   Structure liste chaînee
                   1046: --------------------------------------------------------------------------------
                   1047: */
                   1048: 
                   1049: typedef struct liste_chainee
                   1050: {
                   1051:    struct liste_chainee        *suivant;
                   1052: 
                   1053:    struct_objet                *donnee;
                   1054: } struct_liste_chainee; 
                   1055: 
                   1056: 
                   1057: /*
                   1058: --------------------------------------------------------------------------------
                   1059:   Structure liste profilage
                   1060: --------------------------------------------------------------------------------
                   1061: */
                   1062: 
                   1063: typedef struct liste_profilage
                   1064: {
                   1065:    struct liste_profilage      *suivant;
                   1066: 
                   1067:    unsigned char               *fonction;
                   1068: 
                   1069:    struct timeval              dernier_appel;
                   1070:    struct timeval              cumul;
                   1071: 
                   1072:    integer8                    nombre_appels;
                   1073: } struct_liste_profilage; 
                   1074: 
                   1075: typedef struct liste_profilage2
                   1076: {
                   1077:    struct liste_profilage2     *suivant;
                   1078: 
                   1079:    unsigned char               *fonction;
                   1080: } struct_liste_profilage2; 
                   1081: 
                   1082: /*
                   1083: --------------------------------------------------------------------------------
                   1084:   Structure contenant les fichiers graphiques (liste chaînée)
                   1085: --------------------------------------------------------------------------------
                   1086: */
                   1087: 
                   1088: #ifndef RPLARLS
                   1089: typedef struct fichier_graphique
                   1090: {
                   1091:    struct fichier_graphique    *suivant;
                   1092: 
                   1093:    logical1                    presence_axes;
                   1094: 
                   1095:    unsigned char               *nom;
                   1096:    unsigned char               type[21];
                   1097: 
                   1098:    unsigned char               *legende;
                   1099: 
                   1100:    int                         dimensions;
                   1101: 
                   1102:    integer8                    systeme_axes;
                   1103: } struct_fichier_graphique;
                   1104: #endif
                   1105: 
                   1106: /*
                   1107: --------------------------------------------------------------------------------
                   1108:   Structure nom
                   1109: --------------------------------------------------------------------------------
                   1110: */
                   1111: 
                   1112: typedef struct nom
                   1113: {
                   1114:    unsigned char               *nom;
                   1115:    logical1                    symbole;    /* d_vrai/d_faux */
                   1116:    // symbole == d_vrai signifie que le nom a été introduit dans un
                   1117:    // calcul sans les apostrophes.
                   1118: } struct_nom;
                   1119: 
                   1120: 
                   1121: /*
                   1122: --------------------------------------------------------------------------------
                   1123:   Structure processus fils
                   1124: --------------------------------------------------------------------------------
                   1125: */
                   1126: 
                   1127: #ifndef RPLARGS
                   1128: typedef struct descripteur_thread
                   1129: {
                   1130:    struct processus            *s_etat_processus;
                   1131:    struct processus            *s_nouvel_etat_processus;
                   1132: 
                   1133:    struct_objet                *argument;
                   1134: 
1.13      bertrand 1135:    pid_t                       pid;
                   1136:    volatile pthread_t          tid;
1.1       bertrand 1137: 
                   1138:    pthread_t                   thread_pere;
                   1139: 
                   1140:    pthread_mutex_t             mutex;
                   1141:    volatile logical1           thread_actif;
                   1142: 
                   1143:    int                         pipe_erreurs[2];
                   1144:    int                         pipe_objets[2];
                   1145:    int                         pipe_injections[2];
                   1146:    int                         pipe_nombre_injections[2];
                   1147:    int                         pipe_interruptions[2];
                   1148:    int                         pipe_nombre_objets_attente[2];
                   1149:    int                         pipe_nombre_interruptions_attente[2];
                   1150:    int                         pipe_acquittement[2];
                   1151: 
                   1152:    volatile integer8           nombre_objets_dans_pipe;
                   1153:    volatile integer8           nombre_interruptions_dans_pipe;
                   1154: 
                   1155:    logical1                    processus_detache;
                   1156:    logical1                    destruction_objet;
                   1157: 
                   1158:    sigset_t                    oldset;
                   1159:    sigset_t                    set;
                   1160: 
                   1161:    volatile signed long        nombre_references;
                   1162: } struct_descripteur_thread;
                   1163: 
                   1164: typedef struct processus_fils
                   1165: {
                   1166:    struct_descripteur_thread       *thread;
                   1167: } struct_processus_fils;
                   1168: #endif
                   1169: 
                   1170: 
                   1171: /*
                   1172: --------------------------------------------------------------------------------
                   1173:   Structure liste pile systeme
                   1174: --------------------------------------------------------------------------------
                   1175: */
                   1176: 
                   1177: #ifndef RPLARGS
                   1178: typedef struct liste_pile_systeme
                   1179: {
                   1180:    struct liste_pile_systeme   *suivant;
                   1181: 
                   1182:    struct_liste_chainee        *pointeur_objet_retour;
                   1183: 
                   1184:    struct_objet                *indice_boucle;
                   1185:    struct_objet                *limite_indice_boucle;
                   1186:    struct_objet                *objet_de_test;
                   1187: 
                   1188:    logical1                    arret_si_exception;
                   1189:    logical1                    creation_variables_statiques;
                   1190:    logical1                    creation_variables_partagees;
                   1191:    logical1                    evaluation_expression;
                   1192: 
                   1193:    unsigned char               clause;
                   1194: 
                   1195:    /*
                   1196:    clause :
                   1197:    I : IF
                   1198:    R : IFERR
                   1199:    X : IFERR indiquant la présence d'une erreur.
                   1200:    T : THEN
                   1201:    E : ELSE
                   1202:    Z : traitement en cours de ELSE
                   1203:    D : DO
                   1204:    U : UNTIL
                   1205:    W : WHILE
                   1206:    M : WHILE avec une clause fausse.
                   1207:    S : SELECT
                   1208:    K : aucun cas CASE n'a encore été traité.
                   1209:    C : au moins un cas de SELECT...CASE a été traité.
                   1210:    Q : traitement en cours d'un cas CASE.
                   1211:    F : traitement du cas DEFAULT
                   1212:    */
                   1213: 
                   1214:    unsigned char               retour_definition;
                   1215:    unsigned char               *nom_variable;
                   1216:    unsigned char               origine_routine_evaluation;
                   1217:    unsigned char               type_cloture;
                   1218: 
                   1219:    /*
                   1220:    type clôture :
                   1221:    C     CASE  : END termine un test SELECT/CASE/THEN/END/DEFAULT/END.
                   1222:    D     DO    : END termine une boucle DO/UNTIL/END.
                   1223:    I     IF    : END termine un test IF/THEN (ELSE)/END.
                   1224:    J     IFERR : END termine un test IFERR/THEN (ELSE)/END.
                   1225:    W     WHILE : END termine une boucle WHILE/REPEAT/END.
                   1226: 
                   1227:    F     FOR   : NEXT ou STEP termine une boucle avec compteur.
                   1228:    S     START : NEXT ou STEP termine une boucle sans compteur.
                   1229:    L     LOOP  : boucle utilisé dans le traitement de l'instruction RETURN.
                   1230:            Elle correspond à une boucle FOR ou START mais sans son
                   1231:            initialisation.
                   1232:    */
                   1233: 
                   1234:    unsigned long               adresse_retour;
                   1235:    unsigned long               niveau_courant;
                   1236: } struct_liste_pile_systeme;
                   1237: #endif
                   1238: 
                   1239: 
                   1240: /*
                   1241: --------------------------------------------------------------------------------
                   1242:   Structure variable
                   1243: --------------------------------------------------------------------------------
                   1244: */
                   1245: 
                   1246: #ifndef RPLARGS
                   1247: typedef union position_variable
                   1248: {
                   1249:    unsigned long       adresse;
                   1250:    struct_objet        *pointeur;
                   1251: } union_position_variable;
                   1252: 
                   1253: typedef struct variable
                   1254: {
                   1255:    unsigned char           *nom;
                   1256:    unsigned char           origine;
                   1257: 
                   1258:    unsigned long           niveau;
                   1259: 
                   1260:    union_position_variable variable_statique;
                   1261:    union_position_variable variable_partagee;
                   1262: 
                   1263:    struct_objet            *objet;
                   1264: 
                   1265:    logical1                variable_verrouillee;
                   1266: } struct_variable;
                   1267: 
                   1268: #endif
                   1269: 
                   1270: /*
                   1271: --------------------------------------------------------------------------------
                   1272:   Structure variable partagée
                   1273: --------------------------------------------------------------------------------
                   1274: */
                   1275: 
                   1276: #ifndef RPLARGS
                   1277: 
                   1278: typedef struct variable_partage
                   1279: {
                   1280:    unsigned char               *nom;
                   1281:    unsigned char               origine;
                   1282: 
                   1283:    unsigned long               niveau;
                   1284: 
                   1285:    union_position_variable     variable_partagee;
                   1286: 
                   1287:    struct_objet                *objet;
                   1288: } struct_variable_partagee;
                   1289: 
                   1290: typedef struct table_variables_partagees
                   1291: {
                   1292:    pthread_mutex_t                     mutex;
                   1293: 
                   1294:    volatile struct_variable_partagee   *table;
                   1295: 
                   1296:    volatile unsigned long              nombre_variables;
                   1297:    volatile unsigned long              nombre_variables_allouees;
                   1298: 
                   1299:    unsigned long                       position_variable;
                   1300: } struct_table_variables_partagees;
                   1301: 
                   1302: #endif
                   1303: 
                   1304: 
                   1305: /*
                   1306: --------------------------------------------------------------------------------
                   1307:   Structure variable statique
                   1308: --------------------------------------------------------------------------------
                   1309: */
                   1310: 
                   1311: #ifndef RPLARGS
                   1312: typedef struct variable_statique
                   1313: {
                   1314:    unsigned char           *nom;
                   1315:    unsigned char           origine;
                   1316: 
                   1317:    // Position de création de la variable statique dans le programme ou dans
                   1318:    // l'expression. 'origine' vaut 'P' pour programme ou 'E' pour expression.
                   1319: 
                   1320:    unsigned long           niveau;
                   1321: 
                   1322:    union_position_variable variable_statique;
                   1323: 
                   1324:    struct_objet            *objet;
                   1325: } struct_variable_statique;
                   1326: #endif
                   1327: 
                   1328: 
                   1329: /*
                   1330: --------------------------------------------------------------------------------
                   1331:   Structure vecteur
                   1332: --------------------------------------------------------------------------------
                   1333: */
                   1334: 
                   1335: typedef struct vecteur
                   1336: {
                   1337:    unsigned long       taille;
                   1338: 
                   1339:    unsigned char       type; /* C (complex*16), R (real*8), I (integer*8) */
                   1340: 
                   1341:    void                *tableau;
                   1342: } struct_vecteur;
                   1343: 
                   1344: 
                   1345: /*
                   1346: --------------------------------------------------------------------------------
                   1347:   Structure matrice
                   1348: --------------------------------------------------------------------------------
                   1349: */
                   1350: 
                   1351: typedef struct matrice
                   1352: {
                   1353:    unsigned long       nombre_lignes;
                   1354:    unsigned long       nombre_colonnes;
                   1355: 
                   1356:    unsigned char       type; /* C (complex*16), R (real*8), I (integer*8) */
                   1357: 
                   1358:    void                **tableau;
                   1359: } struct_matrice;
                   1360: 
                   1361: 
                   1362: /*
                   1363: --------------------------------------------------------------------------------
                   1364:   Structure tableau
                   1365: --------------------------------------------------------------------------------
                   1366: */
                   1367: 
                   1368: typedef struct tableau
                   1369: {
                   1370:    unsigned long       nombre_elements;
                   1371: 
                   1372:    struct_objet        **elements;
                   1373: } struct_tableau;
                   1374: 
                   1375: 
                   1376: /*
                   1377: --------------------------------------------------------------------------------
                   1378:   Structure arbre
                   1379: --------------------------------------------------------------------------------
                   1380: */
                   1381: 
                   1382: typedef struct arbre
                   1383: {
                   1384:    struct_objet        *objet;
                   1385: 
                   1386:    unsigned long       nombre_feuilles;
                   1387:    struct arbre        **feuilles;
                   1388: } struct_arbre;
                   1389: 
                   1390: 
                   1391: /*
                   1392: --------------------------------------------------------------------------------
                   1393:   Structures de gestion des instructions externes
                   1394: --------------------------------------------------------------------------------
                   1395: */
                   1396: 
                   1397: typedef struct instruction_externe
                   1398: {
                   1399:    unsigned char       *nom;
                   1400:    unsigned char       *nom_bibliotheque;
                   1401:    void                *descripteur_bibliotheque;
                   1402: } struct_instruction_externe;
                   1403: 
                   1404: 
                   1405: /*
                   1406: --------------------------------------------------------------------------------
                   1407:   Structure argument (pour les fonctions dynamiques)
                   1408: --------------------------------------------------------------------------------
                   1409: */
                   1410: 
                   1411: typedef struct rpl_arguments
                   1412: {
                   1413: /* Piles operationnelles                               */
                   1414: 
                   1415:    struct_liste_chainee        *l_base_pile;
                   1416:    struct_liste_chainee        *l_base_pile_last;
                   1417: 
                   1418: /* Etat du calculateur                                 */
                   1419: 
                   1420:    t_8_bits                    drapeaux_etat[8];
                   1421: 
                   1422: /* Traitement des erreurs                              */
                   1423: 
                   1424:    unsigned char               *message_erreur;
                   1425:    unsigned char               type_erreur;            /* S = système
                   1426:                                                           E = exécution */
                   1427:    integer8                    erreur;
                   1428: 
                   1429: /* Traitement des messages d'aide                      */
                   1430: 
                   1431:    logical1                    aide;                   /* Affichage d'un
                   1432:                                                           message d'aide
                   1433:                                                           par la routine */
                   1434: 
                   1435: /* Nombre d'arguments                                  */
                   1436: 
                   1437:    unsigned char               affichage_arguments;
                   1438:    unsigned char               constante_symbolique;
                   1439:    unsigned char               instruction_valide;
                   1440:    unsigned char               test_instruction;
                   1441: 
                   1442:    integer8                    nombre_arguments;
                   1443:    // Nombre d'arguments de la fonction, positif ou nul.
                   1444: 
                   1445:    void                        *s_etat_processus;
                   1446: } struct_rpl_arguments;
                   1447: 
                   1448: 
                   1449: /*
                   1450: --------------------------------------------------------------------------------
                   1451:   Structure processus
                   1452: --------------------------------------------------------------------------------
                   1453: */
                   1454: 
                   1455: #ifndef RPLARGS
                   1456: typedef struct processus
                   1457: {
                   1458: /* Pointeurs sur le programme                          */
                   1459: 
                   1460:    unsigned char               *definitions_chainees;
                   1461:    struct_liste_chainee        *expression_courante;
                   1462: 
                   1463:    unsigned char               *instruction_courante;
                   1464:    struct_objet                *objet_courant;
                   1465:    unsigned char               evaluation_expression_compilee;     /*Y/N*/
                   1466: 
                   1467:    unsigned char               *nom_fichier_source;
                   1468:    unsigned char               *nom_fichier_historique;
                   1469: 
1.7       bertrand 1470:    unsigned char               autorisation_conversion_chaine;     /*Y/N*/
1.1       bertrand 1471:    unsigned char               autorisation_empilement_programme;  /*Y/N*/
                   1472:    unsigned char               autorisation_evaluation_nom;        /*Y/N*/
1.20      bertrand 1473:    unsigned char               autorisation_nom_implicite;         /*Y/N*/
1.5       bertrand 1474:    unsigned char               evaluation_forcee;                  /*Y/N*/
1.1       bertrand 1475:    unsigned char               instruction_valide;                 /*Y/N*/
                   1476:    unsigned char               instruction_intrinseque;            /*Y/I/N*/
                   1477:    unsigned char               test_instruction;                   /*Y/N*/
                   1478:    unsigned char               affichage_arguments;                /*Y/N*/
                   1479:    unsigned char               constante_symbolique;               /*Y/N*/
                   1480:    unsigned char               traitement_symbolique;              /*Y/N*/
                   1481:    unsigned char               mode_execution_programme;           /*Y/I/N*/
                   1482:    unsigned char               mode_interactif;                    /*Y/N*/
                   1483:    unsigned char               mode_evaluation_expression;         /*Y/N*/
                   1484:    unsigned char               traitement_cycle_exit;              /*N/E/C*/
                   1485: 
                   1486:    unsigned long               position_courante;
                   1487:    unsigned long               longueur_definitions_chainees;
                   1488: 
                   1489: /* Pointeurs sur les instructions                      */
                   1490: 
                   1491:    int                         *pointeurs_caracteres;
                   1492:    int                         nombre_caracteres;
                   1493:    struct instruction          *arbre_instructions;
                   1494: 
                   1495: /* Requetes                                                */
                   1496: 
                   1497:    unsigned char               requete_arret;                      /*Y/N*/
                   1498: 
                   1499: /* Piles operationnelles                               */
                   1500: 
                   1501:    struct_liste_chainee        *l_base_pile;
                   1502:    struct_liste_chainee        *l_base_pile_last;
                   1503: 
                   1504:    unsigned long               hauteur_pile_operationnelle;
                   1505: 
                   1506: /* Piles systemes                                      */
                   1507: 
                   1508:    struct_liste_pile_systeme   *l_base_pile_systeme;
                   1509: 
                   1510:    unsigned long               hauteur_pile_systeme;
                   1511: 
                   1512: /* Gestion des processus                                */
                   1513: 
                   1514:    volatile
                   1515:    struct_liste_chainee        *l_base_pile_processus;
                   1516: 
                   1517:    logical1                    presence_pipes;
                   1518: 
                   1519:    int                         pipe_acquittement;
                   1520:    int                         pipe_donnees;
                   1521:    int                         pipe_injections;
                   1522:    int                         pipe_nombre_injections;
                   1523:    int                         pipe_interruptions;
                   1524:    int                         pipe_nombre_objets_attente;
                   1525:    int                         pipe_nombre_interruptions_attente;
                   1526:    int                         nombre_objets_envoyes_non_lus;
                   1527:    int                         nombre_objets_injectes;
                   1528: 
                   1529:    real8                       pourcentage_maximal_cpu;
                   1530:    real8                       temps_maximal_cpu;
                   1531: 
                   1532:    logical1                    presence_fusible;
                   1533:    pthread_t                   thread_fusible;
                   1534:    pthread_t                   thread_surveille_par_fusible;
                   1535: 
1.11      bertrand 1536: #  ifndef Cygwin
1.1       bertrand 1537:    stack_t                     pile_signal;
1.11      bertrand 1538: #  else
                   1539: #  define SA_ONSTACK           0
                   1540: #  define RTLD_LOCAL           0
                   1541: #  endif
1.1       bertrand 1542: 
                   1543: /* Contextes                                           */
                   1544: 
                   1545:    struct_liste_chainee        *l_base_pile_contextes;
                   1546:    struct_liste_chainee        *l_base_pile_taille_contextes;
                   1547: 
                   1548: /* Variables                                           */
                   1549: 
                   1550:    struct_variable             *s_liste_variables;
                   1551:    unsigned long               nombre_variables;
                   1552:    unsigned long               nombre_variables_allouees;
                   1553: 
                   1554:    struct_variable_statique    *s_liste_variables_statiques;
                   1555:    unsigned long               nombre_variables_statiques;
                   1556:    unsigned long               nombre_variables_statiques_allouees;
                   1557: 
                   1558:    struct_table_variables_partagees
                   1559:                                *s_liste_variables_partagees;
                   1560: 
                   1561:    unsigned long               niveau_courant;
                   1562:    unsigned long               niveau_initial;
                   1563:    unsigned long               position_variable_courante;
                   1564:    unsigned long               position_variable_statique_courante;
                   1565: 
                   1566:    logical1                    creation_variables_statiques;
                   1567:    logical1                    creation_variables_partagees;
                   1568:    logical1                    gel_liste_variables;
                   1569: 
                   1570: /* Fichiers                                                */
                   1571: 
                   1572:    struct_liste_chainee        *s_fichiers;
                   1573: 
                   1574: /* Sockets                                             */
                   1575: 
                   1576:    struct_liste_chainee        *s_sockets;
                   1577: 
                   1578: /* Connecteurs aux bases de données                    */
                   1579: 
                   1580:    struct_liste_chainee        *s_connecteurs_sql;
                   1581: 
                   1582: /* Bibliothèques dynamiques                                */
                   1583: 
                   1584:    struct_liste_chainee        *s_bibliotheques;
                   1585:    struct_instruction_externe  *s_instructions_externes;
                   1586:    unsigned long               nombre_instructions_externes;
                   1587: 
                   1588: /* Fichier d'impression                                    */
                   1589: 
                   1590:    unsigned char               *nom_fichier_impression;
                   1591:    unsigned char               format_papier[16];
                   1592: 
                   1593: /* Parametres graphiques                               */
                   1594: 
                   1595:    struct_fichier_graphique    *fichiers_graphiques;    /* NULL */
                   1596: 
                   1597:    unsigned char               type_trace_eq[21];
                   1598: 
                   1599:                                /*
                   1600:                                 * 2D :
                   1601:                                 * FONCTION
                   1602:                                 * PARAMETRIQUE
                   1603:                                 * POLAIRE
                   1604:                                 * COURBES DE NIVEAU
                   1605:                                 *
                   1606:                                 * 3D :
                   1607:                                 * GRILLE 3D
                   1608:                                 * COURBE PARAMETRIQUE // A FAIRE
                   1609:                                 * SURFACE PARAMETRIQUE // A FAIRE
                   1610:                                 * CYNLINDRIQUE // A FAIRE
                   1611:                                 * SPHERIQUE // A FAIRE
                   1612:                                 */
                   1613: 
                   1614:    unsigned char               type_trace_sigma[21];
                   1615: 
                   1616:                                /*
                   1617:                                 * POINTS
                   1618:                                 * HISTOGRAMME
                   1619:                                 * TABLE TRACANTE
                   1620:                                 */
                   1621: 
                   1622:                                /*
                   1623:                                 * ECHELLES
                   1624:                                 */
                   1625: 
                   1626:    integer8                    systeme_axes;
                   1627: 
                   1628:    real8                       x_min;
                   1629:    real8                       x_max;
                   1630:    real8                       y_min;
                   1631:    real8                       y_max;
                   1632:    real8                       z_min;
                   1633:    real8                       z_max;
                   1634: 
                   1635:    real8                       x_tics;
                   1636:    real8                       y_tics;
                   1637:    real8                       z_tics;
                   1638:    
                   1639:    integer8                    mx_tics;
                   1640:    integer8                    my_tics;
                   1641:    integer8                    mz_tics;
                   1642: 
                   1643:    logical1                    x_lines;
                   1644:    logical1                    y_lines;
                   1645:    logical1                    z_lines;
                   1646: 
                   1647:    logical1                    mx_lines;
                   1648:    logical1                    my_lines;
                   1649:    logical1                    mz_lines;
                   1650: 
                   1651:                                /*
                   1652:                                 * -1 : absent du graphique
                   1653:                                 *  0 : graduations automatiques
                   1654:                                 * >0 : valeur manuelle
                   1655:                                 */
                   1656: 
                   1657:    real8                       x2_min;
                   1658:    real8                       x2_max;
                   1659:    real8                       y2_min;
                   1660:    real8                       y2_max;
                   1661:    real8                       z2_min;
                   1662:    real8                       z2_max;
                   1663: 
                   1664:    real8                       x2_tics;
                   1665:    real8                       y2_tics;
                   1666:    real8                       z2_tics;
                   1667: 
                   1668:    integer8                    mx2_tics;
                   1669:    integer8                    my2_tics;
                   1670:    integer8                    mz2_tics;
                   1671: 
                   1672:    logical1                    x2_lines;
                   1673:    logical1                    y2_lines;
                   1674:    logical1                    z2_lines;
                   1675: 
                   1676:    logical1                    mx2_lines;
                   1677:    logical1                    my2_lines;
                   1678:    logical1                    mz2_lines;
                   1679: 
                   1680:    real8                       resolution;
                   1681: 
                   1682:    logical1                    souris_active;
                   1683: 
                   1684:    logical1                    echelle_automatique_x;
                   1685:    logical1                    echelle_automatique_y;
                   1686:    logical1                    echelle_automatique_z;
                   1687: 
                   1688:    logical1                    echelle_automatique_x2;
                   1689:    logical1                    echelle_automatique_y2;
                   1690:    logical1                    echelle_automatique_z2;
                   1691: 
                   1692:    logical1                    echelle_log_x;
                   1693:    logical1                    echelle_log_y;
                   1694:    logical1                    echelle_log_z;
                   1695: 
                   1696:    logical1                    echelle_log_x2;
                   1697:    logical1                    echelle_log_y2;
                   1698:    logical1                    echelle_log_z2;
                   1699: 
                   1700:    real8                       point_de_vue_theta;
                   1701:    real8                       point_de_vue_phi;
                   1702:    real8                       echelle_3D;
                   1703: 
                   1704:    unsigned char               *label_x;
                   1705:    unsigned char               *label_y;
                   1706:    unsigned char               *label_z;
                   1707:    unsigned char               *titre;
                   1708:    unsigned char               *legende;
                   1709: 
                   1710:    unsigned char               *nom_fichier_gnuplot;
                   1711:    unsigned char               *type_fichier_gnuplot;
                   1712: 
                   1713:    struct_objet                *indep;
                   1714:    struct_objet                *depend;
                   1715:    struct_objet                *parametres_courbes_de_niveau;
                   1716: 
                   1717:    struct_marque               *s_marques;
                   1718: 
                   1719:    file                        *entree_standard;
                   1720: 
                   1721:    logical1                    requete_nouveau_plan;
                   1722:    logical1                    mise_a_jour_trace_requise;
                   1723: 
                   1724: /* Parametres statistiques                             */
                   1725: 
                   1726:    integer8                    colonne_statistique_1;
                   1727:    integer8                    colonne_statistique_2;
                   1728: 
                   1729: /* Etat du calculateur                                 */
                   1730: 
                   1731:    t_8_bits                    drapeaux_etat[8];
                   1732: 
                   1733: /* Traitement des exceptions                           */
                   1734: 
                   1735:    logical1                    arret_si_exception;
                   1736:    unsigned int                exception;
                   1737:    unsigned int                derniere_exception;
                   1738:    unsigned int                exception_processus_fils;
                   1739: 
                   1740: /* Traitement des erreurs                              */
                   1741: 
                   1742:    unsigned int                erreur_compilation;
                   1743:    unsigned int                erreur_execution;
                   1744:    unsigned int                erreur_systeme;
                   1745: 
                   1746:    struct_objet                *s_objet_errone;
                   1747:    struct_objet                *s_objet_erreur;
                   1748: 
                   1749:    logical1                    erreur_scrutation;
                   1750: 
                   1751:    volatile unsigned int       erreur_systeme_processus_fils;
                   1752:    unsigned int                erreur_execution_processus_fils;
                   1753: 
                   1754:    pid_t                       pid_erreur_processus_fils;
                   1755: 
                   1756:    logical1                    erreur_processus_fils;
                   1757: 
                   1758:    integer8                    derniere_erreur_fonction_externe;
                   1759: 
                   1760:    unsigned int                derniere_erreur_systeme;
                   1761:    unsigned int                derniere_erreur_execution;
                   1762:    unsigned int                derniere_erreur_evaluation;
                   1763: 
                   1764:    unsigned char               *instruction_derniere_erreur;
                   1765: 
                   1766:    unsigned long               niveau_derniere_erreur;
                   1767: 
                   1768:    logical1                    core;
                   1769:    logical1                    invalidation_message_erreur;
                   1770: 
                   1771: /* Debug                                               */
                   1772: 
                   1773:    logical1                    debug;
                   1774:    integer8                    type_debug;
                   1775:    logical1                    debug_programme;
                   1776:    logical1                    execution_pas_suivant;
                   1777:    logical1                    traitement_instruction_halt;
                   1778: 
                   1779: /* Interruptions logicielles                           */
                   1780: 
                   1781:    unsigned char               masque_interruptions[d_NOMBRE_INTERRUPTIONS];
                   1782: 
                   1783:    /*
                   1784:     * 'I' : interruption ignorée
                   1785:     * 'Q' : interruption mise en queue pour un traitement ultérieur
                   1786:     * 'N' : traitement normal de l'interruption
                   1787:     */
                   1788: 
                   1789:    integer8                    queue_interruptions[d_NOMBRE_INTERRUPTIONS];
                   1790:    integer8                    nombre_interruptions_en_queue;
                   1791:    struct_liste_chainee        *pile_origine_interruptions
                   1792:                                        [d_NOMBRE_INTERRUPTIONS];
                   1793:    volatile integer8           nombre_interruptions_non_affectees;
                   1794: 
                   1795:    struct_objet                *corps_interruptions[d_NOMBRE_INTERRUPTIONS];
                   1796: 
                   1797:    unsigned char               traitement_interruption;  /* Y/N */
                   1798:    unsigned char               traitement_interruptible; /* Y/N */
                   1799: 
1.26      bertrand 1800:    struct_objet                *at_exit;
1.25      bertrand 1801: 
1.1       bertrand 1802: /* Variables volatiles                                 */
                   1803: 
                   1804:    volatile sig_atomic_t       var_volatile_alarme;
                   1805:    // Traitement de ctrl+C et des arrêts brutaux
                   1806:    volatile sig_atomic_t       var_volatile_requete_arret;
                   1807:    // Traitement de ctrl+Z
                   1808:    volatile sig_atomic_t       var_volatile_requete_arret2;
                   1809:    volatile sig_atomic_t       var_volatile_traitement_retarde_stop;
                   1810:    volatile sig_atomic_t       var_volatile_traitement_sigint;
                   1811: 
                   1812:    volatile sig_atomic_t       var_volatile_processus_pere;
                   1813:    volatile sig_atomic_t       var_volatile_recursivite;
                   1814: 
1.27      bertrand 1815:    volatile sig_atomic_t       arret_depuis_abort;
                   1816: 
1.1       bertrand 1817:    volatile int                var_volatile_exception_gsl;
                   1818: 
                   1819: /* Autres                                              */
                   1820: 
1.13      bertrand 1821:    char                        *rpl_home;
                   1822: 
1.1       bertrand 1823:    gsl_rng                     *generateur_aleatoire;
                   1824:    const gsl_rng_type          *type_generateur_aleatoire;
                   1825: 
                   1826:    integer8                    nombre_arguments;
                   1827: 
                   1828:    /*
                   1829:     * Il s'agit du nombre d'arguments utilisé pour l'évaluation
                   1830:     * des expressions algébriques.
                   1831:     * -1 : la fonction ne peut être dans un objet de type ALG.
                   1832:     * -2 : nombre d'arguments inconnu
                   1833:     *  0 : la fonction doit apparaître en notation infixe
                   1834:     * >0 : la fonction apparaît comme une fonction normale
                   1835:     */
                   1836: 
                   1837:    logical1                    lancement_interactif;
                   1838: 
                   1839:    unsigned char               *chemin_fichiers_temporaires;
                   1840:    unsigned char               langue;
                   1841:    unsigned char               retour_routine_evaluation;
                   1842:    unsigned char               *localisation;
                   1843: 
                   1844:    unsigned long               niveau_recursivite;
                   1845: 
                   1846:    pid_t                       pid_processus_pere;
                   1847:    pthread_t                   tid_processus_pere;
                   1848: 
                   1849:    logical1                    processus_detache;
                   1850: 
                   1851: /* Profilage                                           */
                   1852: 
                   1853:    logical1                    profilage;
                   1854:    int                         niveau_profilage;
                   1855:    struct_liste_profilage      *pile_profilage;
                   1856:    struct_liste_profilage2     *pile_profilage_fonctions;
                   1857:    struct timeval              horodatage_profilage;
                   1858: 
                   1859:    // Mutex spécifique au processus et donnant accès à la pile des processus
                   1860:    pthread_mutex_t             mutex;
                   1861: 
                   1862:    // Sémaphore autorisant les fork()
1.22      bertrand 1863:    sem_t
                   1864: #  ifdef SEMAPHORES_NOMMES
                   1865:    *
                   1866: #  endif
                   1867:                                semaphore_fork;
1.1       bertrand 1868: 
                   1869: /* Mutexes                                         */
                   1870: 
                   1871:    struct_liste_chainee        *liste_mutexes;
                   1872:    pthread_mutex_t             protection_liste_mutexes;
                   1873: 
                   1874: /* Gestion optimisée de la mémoire                 */
                   1875: 
                   1876:    double                      estimation_taille_pile_tampon;
                   1877:    unsigned long               taille_pile_tampon;
                   1878:    struct_liste_chainee        *pile_tampon;
                   1879: 
                   1880:    double                      estimation_taille_pile_systeme_tampon;
                   1881:    unsigned long               taille_pile_systeme_tampon;
                   1882:    struct_liste_pile_systeme   *pile_systeme_tampon;
                   1883: 
                   1884:    unsigned long               taille_pile_objets;
                   1885:    struct_objet                *pile_objets;
                   1886: 
1.36    ! bertrand 1887: #  ifndef DEBUG_MALLOC
        !          1888: #      define TAILLE_CACHE 16384
        !          1889: #  else
        !          1890: #      define TAILLE_CACHE 4
        !          1891: #  endif
1.1       bertrand 1892: 
                   1893:    unsigned long               *objets_adr[TAILLE_CACHE];
                   1894:    int                         pointeur_adr;
                   1895: 
                   1896:    logical8                    *objets_bin[TAILLE_CACHE];
                   1897:    int                         pointeur_bin;
                   1898: 
                   1899:    complex16                   *objets_cpl[TAILLE_CACHE];
                   1900:    int                         pointeur_cpl;
                   1901: 
                   1902:    struct fonction             *objets_fct[TAILLE_CACHE];
                   1903:    int                         pointeur_fct;
                   1904: 
                   1905:    integer8                    *objets_int[TAILLE_CACHE];
                   1906:    int                         pointeur_int;
                   1907: 
                   1908:    struct_matrice              *objets_mat[TAILLE_CACHE];
                   1909:    int                         pointeur_mat;
                   1910: 
                   1911:    struct_nom                  *objets_nom[TAILLE_CACHE];
                   1912:    int                         pointeur_nom;
                   1913: 
                   1914:    real8                       *objets_rel[TAILLE_CACHE];
                   1915:    int                         pointeur_rel;
                   1916: 
                   1917:    struct_tableau              *objets_tab[TAILLE_CACHE];
                   1918:    int                         pointeur_tab;
                   1919: 
                   1920:    struct_vecteur              *objets_vec[TAILLE_CACHE];
                   1921:    int                         pointeur_vec;
                   1922: 
                   1923:    struct_liste_chainee        *maillons[TAILLE_CACHE];
                   1924:    int                         pointeur_maillons;
                   1925: } struct_processus;
                   1926: #endif
                   1927: 
                   1928: /*
                   1929: --------------------------------------------------------------------------------
1.36    ! bertrand 1930:   Structures instruction intrinsèque
1.1       bertrand 1931: --------------------------------------------------------------------------------
                   1932: */
                   1933: 
                   1934: #ifndef RPLARGS
                   1935: typedef struct instruction
                   1936: {
                   1937:    struct instruction      **noeud;
                   1938:    void                    (*feuille)(struct_processus *);
                   1939: } struct_instruction;
                   1940: #endif
                   1941: 
                   1942: 
                   1943: /*
                   1944: --------------------------------------------------------------------------------
                   1945:   Structure fonction
                   1946: --------------------------------------------------------------------------------
                   1947: */
                   1948: 
                   1949: #ifndef RPLARGS
                   1950: typedef struct fonction
                   1951: {
                   1952:    unsigned char                       *nom_fonction;
                   1953:    unsigned long                       nombre_arguments;
                   1954: 
                   1955:    void                                (*fonction)(struct_processus *);
                   1956: 
                   1957:    volatile struct_liste_chainee       *prediction_saut;
                   1958:    volatile logical1                   prediction_execution;
                   1959: } struct_fonction;
                   1960: #endif
                   1961: 
                   1962: 
                   1963: /*
                   1964: ================================================================================
                   1965:   PROTOTYPES
                   1966: ================================================================================
                   1967: */
                   1968: 
                   1969: /*
                   1970: --------------------------------------------------------------------------------
                   1971:   Procédures d'exécution des mots-clef du langage RPL/2
                   1972: --------------------------------------------------------------------------------
                   1973: */
                   1974: 
                   1975: // BEGIN C PROTOTYPES
                   1976: void instruction_sensible_e(struct_processus *s_etat_processus);
                   1977: void instruction_sensible_i(struct_processus *s_etat_processus);
                   1978: 
                   1979: void instruction_abort(struct_processus *s_etat_processus);
                   1980: void instruction_abs(struct_processus *s_etat_processus);
                   1981: void instruction_acos(struct_processus *s_etat_processus);
                   1982: void instruction_acosh(struct_processus *s_etat_processus);
                   1983: void instruction_alarm(struct_processus *s_etat_processus);
                   1984: void instruction_alog(struct_processus *s_etat_processus);
                   1985: void instruction_and(struct_processus *s_etat_processus);
                   1986: void instruction_append(struct_processus *s_etat_processus);
                   1987: void instruction_array_fleche(struct_processus *s_etat_processus);
                   1988: void instruction_arg(struct_processus *s_etat_processus);
                   1989: void instruction_asin(struct_processus *s_etat_processus);
                   1990: void instruction_asinh(struct_processus *s_etat_processus);
                   1991: void instruction_asl(struct_processus *s_etat_processus);
                   1992: void instruction_asr(struct_processus *s_etat_processus);
                   1993: void instruction_atan(struct_processus *s_etat_processus);
                   1994: void instruction_atanh(struct_processus *s_etat_processus);
1.26      bertrand 1995: void instruction_atexit(struct_processus *s_etat_processus);
1.1       bertrand 1996: void instruction_autoscale(struct_processus *s_etat_processus);
                   1997: void instruction_axes(struct_processus *s_etat_processus);
                   1998: 
                   1999: void instruction_b_vers_r(struct_processus *s_etat_processus);
                   2000: void instruction_backspace(struct_processus *s_etat_processus);
                   2001: void instruction_beep(struct_processus *s_etat_processus);
                   2002: void instruction_bessel(struct_processus *s_etat_processus);
                   2003: void instruction_bin(struct_processus *s_etat_processus);
                   2004: 
                   2005: void instruction_c_vers_r(struct_processus *s_etat_processus);
                   2006: void instruction_case(struct_processus *s_etat_processus);
                   2007: void instruction_ceil(struct_processus *s_etat_processus);
                   2008: void instruction_centr(struct_processus *s_etat_processus);
                   2009: void instruction_cf(struct_processus *s_etat_processus);
                   2010: void instruction_chr(struct_processus *s_etat_processus);
                   2011: void instruction_clear(struct_processus *s_etat_processus);
                   2012: void instruction_cllcd(struct_processus *s_etat_processus);
                   2013: void instruction_clmf(struct_processus *s_etat_processus);
                   2014: void instruction_close(struct_processus *s_etat_processus);
1.28      bertrand 2015: void instruction_clratexit(struct_processus *s_etat_processus);
1.1       bertrand 2016: void instruction_clrcntxt(struct_processus *s_etat_processus);
                   2017: void instruction_clrerr(struct_processus *s_etat_processus);
                   2018: void instruction_clrfuse(struct_processus *s_etat_processus);
                   2019: void instruction_clrmtx(struct_processus *s_etat_processus);
                   2020: void instruction_clrsmphr(struct_processus *s_etat_processus);
                   2021: void instruction_clrswi(struct_processus *s_etat_processus);
                   2022: void instruction_cls(struct_processus *s_etat_processus);
                   2023: void instruction_clusr(struct_processus *s_etat_processus);
                   2024: void instruction_cnrm(struct_processus *s_etat_processus);
                   2025: void instruction_cols(struct_processus *s_etat_processus);
                   2026: void instruction_col_fleche(struct_processus *s_etat_processus);
                   2027: void instruction_col_moins(struct_processus *s_etat_processus);
                   2028: void instruction_col_plus(struct_processus *s_etat_processus);
                   2029: void instruction_comb(struct_processus *s_etat_processus);
                   2030: void instruction_con(struct_processus *s_etat_processus);
                   2031: void instruction_cond(struct_processus *s_etat_processus);
                   2032: void instruction_cont(struct_processus *s_etat_processus);
                   2033: void instruction_continue(struct_processus *s_etat_processus);
                   2034: void instruction_conj(struct_processus *s_etat_processus);
                   2035: void instruction_convert(struct_processus *s_etat_processus);
                   2036: void instruction_copy(struct_processus *s_etat_processus);
                   2037: void instruction_copyright(struct_processus *s_etat_processus);
                   2038: void instruction_corr(struct_processus *s_etat_processus);
                   2039: void instruction_cos(struct_processus *s_etat_processus);
                   2040: void instruction_cosh(struct_processus *s_etat_processus);
                   2041: void instruction_cov(struct_processus *s_etat_processus);
                   2042: void instruction_cr(struct_processus *s_etat_processus);
                   2043: void instruction_create(struct_processus *s_etat_processus);
                   2044: void instruction_crmtx(struct_processus *s_etat_processus);
                   2045: void instruction_cross(struct_processus *s_etat_processus);
                   2046: void instruction_crsmphr(struct_processus *s_etat_processus);
                   2047: void instruction_crtab(struct_processus *s_etat_processus);
                   2048: void instruction_cstop(struct_processus *s_etat_processus);
                   2049: void instruction_cswp(struct_processus *s_etat_processus);
                   2050: void instruction_currenc(struct_processus *s_etat_processus);
                   2051: void instruction_cycle(struct_processus *s_etat_processus);
                   2052: 
                   2053: void instruction_d_vers_r(struct_processus *s_etat_processus);
                   2054: void instruction_daemonize(struct_processus *s_etat_processus);
                   2055: void instruction_date(struct_processus *s_etat_processus);
                   2056: void instruction_dec(struct_processus *s_etat_processus);
                   2057: void instruction_decr(struct_processus *s_etat_processus);
                   2058: void instruction_default(struct_processus *s_etat_processus);
                   2059: void instruction_deg(struct_processus *s_etat_processus);
                   2060: void instruction_delete(struct_processus *s_etat_processus);
                   2061: void instruction_depnd(struct_processus *s_etat_processus);
                   2062: void instruction_depth(struct_processus *s_etat_processus);
                   2063: void instruction_der(struct_processus *s_etat_processus);
                   2064: void instruction_det(struct_processus *s_etat_processus);
                   2065: void instruction_detach(struct_processus *s_etat_processus);
                   2066: void instruction_dft(struct_processus *s_etat_processus);
                   2067: void instruction_dgtiz(struct_processus *s_etat_processus);
                   2068: void instruction_diag_fleche(struct_processus *s_etat_processus);
                   2069: void instruction_disp(struct_processus *s_etat_processus);
                   2070: void instruction_division(struct_processus *s_etat_processus);
                   2071: void instruction_do(struct_processus *s_etat_processus);
                   2072: void instruction_dot(struct_processus *s_etat_processus);
                   2073: void instruction_draw(struct_processus *s_etat_processus);
                   2074: void instruction_drax(struct_processus *s_etat_processus);
                   2075: void instruction_drop(struct_processus *s_etat_processus);
                   2076: void instruction_drop2(struct_processus *s_etat_processus);
                   2077: void instruction_dropcntxt(struct_processus *s_etat_processus);
                   2078: void instruction_dropn(struct_processus *s_etat_processus);
                   2079: void instruction_drws(struct_processus *s_etat_processus);
                   2080: void instruction_dup(struct_processus *s_etat_processus);
                   2081: void instruction_dup2(struct_processus *s_etat_processus);
                   2082: void instruction_dupcntxt(struct_processus *s_etat_processus);
                   2083: void instruction_dupn(struct_processus *s_etat_processus);
                   2084: 
                   2085: void instruction_e(struct_processus *s_etat_processus);
                   2086: void instruction_edit(struct_processus *s_etat_processus);
                   2087: void instruction_egalite(struct_processus *s_etat_processus);
                   2088: void instruction_egv(struct_processus *s_etat_processus);
                   2089: void instruction_egvl(struct_processus *s_etat_processus);
                   2090: void instruction_else(struct_processus *s_etat_processus);
                   2091: void instruction_elseif(struct_processus *s_etat_processus);
                   2092: void instruction_end(struct_processus *s_etat_processus);
                   2093: void instruction_eng(struct_processus *s_etat_processus);
                   2094: void instruction_epsilon(struct_processus *s_etat_processus);
                   2095: void instruction_erase(struct_processus *s_etat_processus);
                   2096: void instruction_errm(struct_processus *s_etat_processus);
                   2097: void instruction_errn(struct_processus *s_etat_processus);
                   2098: void instruction_eval(struct_processus *s_etat_processus);
                   2099: void instruction_exget(struct_processus *s_etat_processus);
                   2100: void instruction_exit(struct_processus *s_etat_processus);
                   2101: void instruction_exp(struct_processus *s_etat_processus);
                   2102: void instruction_expm(struct_processus *s_etat_processus);
                   2103: void instruction_exsub(struct_processus *s_etat_processus);
                   2104: void instruction_externals(struct_processus *s_etat_processus);
                   2105: void instruction_eyept(struct_processus *s_etat_processus);
                   2106: 
                   2107: void instruction_fact(struct_processus *s_etat_processus);
                   2108: void instruction_false(struct_processus *s_etat_processus);
                   2109: void instruction_fc_test(struct_processus *s_etat_processus);
                   2110: void instruction_fc_test_c(struct_processus *s_etat_processus);
                   2111: void instruction_fc_test_s(struct_processus *s_etat_processus);
                   2112: void instruction_fft(struct_processus *s_etat_processus);
                   2113: void instruction_fix(struct_processus *s_etat_processus);
                   2114: void instruction_fleche(struct_processus *s_etat_processus);
                   2115: void instruction_fleche_array(struct_processus *s_etat_processus);
                   2116: void instruction_fleche_col(struct_processus *s_etat_processus);
                   2117: void instruction_fleche_diag(struct_processus *s_etat_processus);
                   2118: void instruction_fleche_hms(struct_processus *s_etat_processus);
                   2119: void instruction_fleche_lcd(struct_processus *s_etat_processus);
                   2120: void instruction_fleche_list(struct_processus *s_etat_processus);
                   2121: void instruction_fleche_num(struct_processus *s_etat_processus);
                   2122: void instruction_fleche_q(struct_processus *s_etat_processus);
                   2123: void instruction_fleche_row(struct_processus *s_etat_processus);
                   2124: void instruction_fleche_str(struct_processus *s_etat_processus);
                   2125: void instruction_fleche_table(struct_processus *s_etat_processus);
                   2126: void instruction_floor(struct_processus *s_etat_processus);
                   2127: void instruction_for(struct_processus *s_etat_processus);
                   2128: void instruction_format(struct_processus *s_etat_processus);
                   2129: void instruction_fp(struct_processus *s_etat_processus);
                   2130: void instruction_fs_test(struct_processus *s_etat_processus);
                   2131: void instruction_fs_test_c(struct_processus *s_etat_processus);
                   2132: void instruction_fs_test_s(struct_processus *s_etat_processus);
                   2133: void instruction_function(struct_processus *s_etat_processus);
                   2134: void instruction_fuse(struct_processus *s_etat_processus);
                   2135: 
                   2136: void instruction_gamma(struct_processus *s_etat_processus);
                   2137: void instruction_ge(struct_processus *s_etat_processus);
                   2138: void instruction_gegv(struct_processus *s_etat_processus);
                   2139: void instruction_gegvl(struct_processus *s_etat_processus);
                   2140: void instruction_get(struct_processus *s_etat_processus);
                   2141: void instruction_getc(struct_processus *s_etat_processus);
                   2142: void instruction_geti(struct_processus *s_etat_processus);
                   2143: void instruction_getr(struct_processus *s_etat_processus);
                   2144: void instruction_glegv(struct_processus *s_etat_processus);
                   2145: void instruction_gregv(struct_processus *s_etat_processus);
                   2146: void instruction_gt(struct_processus *s_etat_processus);
                   2147: 
                   2148: void instruction_halt(struct_processus *s_etat_processus);
                   2149: void instruction_head(struct_processus *s_etat_processus);
                   2150: void instruction_help(struct_processus *s_etat_processus);
                   2151: void instruction_hex(struct_processus *s_etat_processus);
                   2152: void instruction_histogram(struct_processus *s_etat_processus);
                   2153: void instruction_hms_fleche(struct_processus *s_etat_processus);
                   2154: void instruction_hms_moins(struct_processus *s_etat_processus);
                   2155: void instruction_hms_plus(struct_processus *s_etat_processus);
                   2156: 
                   2157: void instruction_i(struct_processus *s_etat_processus);
                   2158: void instruction_idft(struct_processus *s_etat_processus);
                   2159: void instruction_idn(struct_processus *s_etat_processus);
                   2160: void instruction_if(struct_processus *s_etat_processus);
                   2161: void instruction_iferr(struct_processus *s_etat_processus);
                   2162: void instruction_ifft(struct_processus *s_etat_processus);
                   2163: void instruction_ift(struct_processus *s_etat_processus);
                   2164: void instruction_ifte(struct_processus *s_etat_processus);
                   2165: void instruction_im(struct_processus *s_etat_processus);
1.20      bertrand 2166: void instruction_implicit(struct_processus *s_etat_processus);
1.1       bertrand 2167: void instruction_in(struct_processus *s_etat_processus);
                   2168: void instruction_incr(struct_processus *s_etat_processus);
                   2169: void instruction_indep(struct_processus *s_etat_processus);
                   2170: void instruction_input(struct_processus *s_etat_processus);
                   2171: void instruction_inquire(struct_processus *s_etat_processus);
                   2172: void instruction_int(struct_processus *s_etat_processus);
                   2173: void instruction_interrupt(struct_processus *s_etat_processus);
                   2174: void instruction_inv(struct_processus *s_etat_processus);
                   2175: void instruction_ip(struct_processus *s_etat_processus);
                   2176: void instruction_iswi(struct_processus *s_etat_processus);
                   2177: void instruction_itrace(struct_processus *s_etat_processus);
                   2178: 
                   2179: void instruction_jdate(struct_processus *s_etat_processus);
                   2180: 
                   2181: void instruction_key(struct_processus *s_etat_processus);
                   2182: void instruction_keylabel(struct_processus *s_etat_processus);
                   2183: void instruction_keytitle(struct_processus *s_etat_processus);
                   2184: void instruction_kill(struct_processus *s_etat_processus);
                   2185: void instruction_kind(struct_processus *s_etat_processus);
                   2186: 
                   2187: void instruction_label(struct_processus *s_etat_processus);
                   2188: void instruction_last(struct_processus *s_etat_processus);
                   2189: void instruction_lcase(struct_processus *s_etat_processus);
                   2190: void instruction_lcd_fleche(struct_processus *s_etat_processus);
                   2191: void instruction_lchol(struct_processus *s_etat_processus);
                   2192: void instruction_le(struct_processus *s_etat_processus);
                   2193: void instruction_legv(struct_processus *s_etat_processus);
                   2194: void instruction_line(struct_processus *s_etat_processus);
                   2195: void instruction_list_fleche(struct_processus *s_etat_processus);
                   2196: void instruction_ln(struct_processus *s_etat_processus);
                   2197: void instruction_lnp1(struct_processus *s_etat_processus);
                   2198: void instruction_localization(struct_processus *s_etat_processus);
                   2199: void instruction_lock(struct_processus *s_etat_processus);
                   2200: void instruction_log(struct_processus *s_etat_processus);
                   2201: void instruction_logger(struct_processus *s_etat_processus);
                   2202: void instruction_logscale(struct_processus *s_etat_processus);
                   2203: void instruction_lq(struct_processus *s_etat_processus);
                   2204: void instruction_lsq(struct_processus *s_etat_processus);
                   2205: void instruction_lt(struct_processus *s_etat_processus);
                   2206: void instruction_lu(struct_processus *s_etat_processus);
                   2207: 
                   2208: void instruction_mant(struct_processus *s_etat_processus);
                   2209: void instruction_mark(struct_processus *s_etat_processus);
                   2210: void instruction_max(struct_processus *s_etat_processus);
                   2211: void instruction_maxs(struct_processus *s_etat_processus);
                   2212: void instruction_mclrin(struct_processus *s_etat_processus);
                   2213: void instruction_mean(struct_processus *s_etat_processus);
                   2214: void instruction_mem(struct_processus *s_etat_processus);
1.32      bertrand 2215: void instruction_memlock(struct_processus *s_etat_processus);
                   2216: void instruction_memunlock(struct_processus *s_etat_processus);
1.1       bertrand 2217: void instruction_min(struct_processus *s_etat_processus);
                   2218: void instruction_mins(struct_processus *s_etat_processus);
                   2219: void instruction_mod(struct_processus *s_etat_processus);
                   2220: void instruction_moins(struct_processus *s_etat_processus);
                   2221: void instruction_mtxlock(struct_processus *s_etat_processus);
                   2222: void instruction_mtxstatus(struct_processus *s_etat_processus);
                   2223: void instruction_mtxtrylock(struct_processus *s_etat_processus);
                   2224: void instruction_mtxunlock(struct_processus *s_etat_processus);
                   2225: void instruction_multiplication(struct_processus *s_etat_processus);
                   2226: 
                   2227: void instruction_ne(struct_processus *s_etat_processus);
                   2228: void instruction_neg(struct_processus *s_etat_processus);
                   2229: void instruction_next(struct_processus *s_etat_processus);
                   2230: void instruction_newplane(struct_processus *s_etat_processus);
                   2231: void instruction_not(struct_processus *s_etat_processus);
                   2232: void instruction_nrand(struct_processus *s_etat_processus);
                   2233: void instruction_nrproc(struct_processus *s_etat_processus);
                   2234: void instruction_ns(struct_processus *s_etat_processus);
                   2235: void instruction_num(struct_processus *s_etat_processus);
                   2236: 
                   2237: void instruction_obget(struct_processus *s_etat_processus);
                   2238: void instruction_obsub(struct_processus *s_etat_processus);
                   2239: void instruction_oct(struct_processus *s_etat_processus);
                   2240: void instruction_open(struct_processus *s_etat_processus);
                   2241: void instruction_or(struct_processus *s_etat_processus);
                   2242: void instruction_over(struct_processus *s_etat_processus);
                   2243: 
                   2244: void instruction_p_vers_r(struct_processus *s_etat_processus);
                   2245: void instruction_paper(struct_processus *s_etat_processus);
                   2246: void instruction_parameter(struct_processus *s_etat_processus);
                   2247: void instruction_parametric(struct_processus *s_etat_processus);
                   2248: void instruction_pcov(struct_processus *s_etat_processus);
                   2249: void instruction_peek(struct_processus *s_etat_processus);
                   2250: void instruction_perm(struct_processus *s_etat_processus);
                   2251: void instruction_persist(struct_processus *s_etat_processus);
                   2252: void instruction_pi(struct_processus *s_etat_processus);
                   2253: void instruction_pick(struct_processus *s_etat_processus);
                   2254: void instruction_plot(struct_processus *s_etat_processus);
                   2255: void instruction_plotter(struct_processus *s_etat_processus);
                   2256: void instruction_plus(struct_processus *s_etat_processus);
                   2257: void instruction_pmax(struct_processus *s_etat_processus);
                   2258: void instruction_pmin(struct_processus *s_etat_processus);
                   2259: void instruction_poke(struct_processus *s_etat_processus);
                   2260: void instruction_polar(struct_processus *s_etat_processus);
                   2261: void instruction_pos(struct_processus *s_etat_processus);
                   2262: void instruction_pourcent(struct_processus *s_etat_processus);
                   2263: void instruction_pourcent_ch(struct_processus *s_etat_processus);
                   2264: void instruction_pourcent_t(struct_processus *s_etat_processus);
                   2265: void instruction_ppar(struct_processus *s_etat_processus);
                   2266: void instruction_pr1(struct_processus *s_etat_processus);
                   2267: void instruction_print(struct_processus *s_etat_processus);
                   2268: void instruction_private(struct_processus *s_etat_processus);
                   2269: void instruction_prlcd(struct_processus *s_etat_processus);
                   2270: void instruction_prmd(struct_processus *s_etat_processus);
1.34      bertrand 2271: void instruction_procid(struct_processus *s_etat_processus);
1.1       bertrand 2272: void instruction_prompt(struct_processus *s_etat_processus);
                   2273: void instruction_protect(struct_processus *s_etat_processus);
                   2274: void instruction_prst(struct_processus *s_etat_processus);
                   2275: void instruction_prstc(struct_processus *s_etat_processus);
                   2276: void instruction_prusr(struct_processus *s_etat_processus);
                   2277: void instruction_prvar(struct_processus *s_etat_processus);
                   2278: void instruction_psdev(struct_processus *s_etat_processus);
                   2279: void instruction_puissance(struct_processus *s_etat_processus);
                   2280: void instruction_purge(struct_processus *s_etat_processus);
                   2281: void instruction_pshcntxt(struct_processus *s_etat_processus);
                   2282: void instruction_pshprfl(struct_processus *s_etat_processus);
                   2283: void instruction_pulcntxt(struct_processus *s_etat_processus);
                   2284: void instruction_pulprfl(struct_processus *s_etat_processus);
                   2285: void instruction_put(struct_processus *s_etat_processus);
                   2286: void instruction_putc(struct_processus *s_etat_processus);
                   2287: void instruction_puti(struct_processus *s_etat_processus);
                   2288: void instruction_putr(struct_processus *s_etat_processus);
                   2289: void instruction_pvar(struct_processus *s_etat_processus);
                   2290: 
                   2291: void instruction_qr(struct_processus *s_etat_processus);
                   2292: 
                   2293: void instruction_r_vers_b(struct_processus *s_etat_processus);
                   2294: void instruction_r_vers_c(struct_processus *s_etat_processus);
                   2295: void instruction_r_vers_d(struct_processus *s_etat_processus);
                   2296: void instruction_r_vers_p(struct_processus *s_etat_processus);
                   2297: void instruction_rad(struct_processus *s_etat_processus);
                   2298: void instruction_rand(struct_processus *s_etat_processus);
                   2299: void instruction_rank(struct_processus *s_etat_processus);
                   2300: void instruction_rceq(struct_processus *s_etat_processus);
                   2301: void instruction_rci(struct_processus *s_etat_processus);
                   2302: void instruction_rcij(struct_processus *s_etat_processus);
                   2303: void instruction_rcl(struct_processus *s_etat_processus);
                   2304: void instruction_rclf(struct_processus *s_etat_processus);
                   2305: void instruction_rcls(struct_processus *s_etat_processus);
                   2306: void instruction_rclswi(struct_processus *s_etat_processus);
                   2307: void instruction_rcws(struct_processus *s_etat_processus);
                   2308: void instruction_rdate(struct_processus *s_etat_processus);
                   2309: void instruction_rdm(struct_processus *s_etat_processus);
                   2310: void instruction_rdgn(struct_processus *s_etat_processus);
                   2311: void instruction_rdz(struct_processus *s_etat_processus);
                   2312: void instruction_re(struct_processus *s_etat_processus);
                   2313: void instruction_read(struct_processus *s_etat_processus);
                   2314: void instruction_recode(struct_processus *s_etat_processus);
                   2315: void instruction_recv(struct_processus *s_etat_processus);
                   2316: void instruction_redraw(struct_processus *s_etat_processus);
                   2317: void instruction_relax(struct_processus *s_etat_processus);
                   2318: void instruction_remove(struct_processus *s_etat_processus);
                   2319: void instruction_res(struct_processus *s_etat_processus);
                   2320: void instruction_recall(struct_processus *s_etat_processus);
                   2321: void instruction_regv(struct_processus *s_etat_processus);
                   2322: void instruction_repeat(struct_processus *s_etat_processus);
                   2323: void instruction_repl(struct_processus *s_etat_processus);
                   2324: void instruction_return(struct_processus *s_etat_processus);
                   2325: void instruction_revlist(struct_processus *s_etat_processus);
                   2326: void instruction_rewind(struct_processus *s_etat_processus);
                   2327: void instruction_rfuse(struct_processus *s_etat_processus);
                   2328: void instruction_rl(struct_processus *s_etat_processus);
                   2329: void instruction_rlb(struct_processus *s_etat_processus);
                   2330: void instruction_rnd(struct_processus *s_etat_processus);
                   2331: void instruction_rnrm(struct_processus *s_etat_processus);
                   2332: void instruction_roll(struct_processus *s_etat_processus);
                   2333: void instruction_rolld(struct_processus *s_etat_processus);
                   2334: void instruction_rot(struct_processus *s_etat_processus);
                   2335: void instruction_row_fleche(struct_processus *s_etat_processus);
                   2336: void instruction_row_moins(struct_processus *s_etat_processus);
                   2337: void instruction_row_plus(struct_processus *s_etat_processus);
                   2338: void instruction_rr(struct_processus *s_etat_processus);
                   2339: void instruction_rrb(struct_processus *s_etat_processus);
                   2340: void instruction_rsd(struct_processus *s_etat_processus);
                   2341: void instruction_rstop(struct_processus *s_etat_processus);
                   2342: void instruction_rswp(struct_processus *s_etat_processus);
                   2343: 
                   2344: void instruction_s_moins(struct_processus *s_etat_processus);
                   2345: void instruction_s_plus(struct_processus *s_etat_processus);
                   2346: void instruction_same(struct_processus *s_etat_processus);
                   2347: void instruction_save(struct_processus *s_etat_processus);
                   2348: void instruction_scatter(struct_processus *s_etat_processus);
                   2349: void instruction_scale(struct_processus *s_etat_processus);
                   2350: void instruction_sched(struct_processus *s_etat_processus);
                   2351: void instruction_schur(struct_processus *s_etat_processus);
                   2352: void instruction_sci(struct_processus *s_etat_processus);
                   2353: void instruction_scls(struct_processus *s_etat_processus);
                   2354: void instruction_sconj(struct_processus *s_etat_processus);
                   2355: void instruction_sdev(struct_processus *s_etat_processus);
                   2356: void instruction_select(struct_processus *s_etat_processus);
                   2357: void instruction_send(struct_processus *s_etat_processus);
                   2358: void instruction_sf(struct_processus *s_etat_processus);
                   2359: void instruction_shared(struct_processus *s_etat_processus);
                   2360: void instruction_sign(struct_processus *s_etat_processus);
                   2361: void instruction_sin(struct_processus *s_etat_processus);
                   2362: void instruction_sinh(struct_processus *s_etat_processus);
                   2363: void instruction_sinv(struct_processus *s_etat_processus);
                   2364: void instruction_size(struct_processus *s_etat_processus);
                   2365: void instruction_sl(struct_processus *s_etat_processus);
                   2366: void instruction_slb(struct_processus *s_etat_processus);
                   2367: void instruction_slice(struct_processus *s_etat_processus);
                   2368: void instruction_slicescale(struct_processus *s_etat_processus);
                   2369: void instruction_smphrdecr(struct_processus *s_etat_processus);
                   2370: void instruction_smphrgetv(struct_processus *s_etat_processus);
                   2371: void instruction_smphrincr(struct_processus *s_etat_processus);
                   2372: void instruction_smphrtrydecr(struct_processus *s_etat_processus);
                   2373: void instruction_sneg(struct_processus *s_etat_processus);
                   2374: void instruction_sort(struct_processus *s_etat_processus);
                   2375: void instruction_spar(struct_processus *s_etat_processus);
                   2376: void instruction_spawn(struct_processus *s_etat_processus);
                   2377: void instruction_splash(struct_processus *s_etat_processus);
                   2378: void instruction_sq(struct_processus *s_etat_processus);
                   2379: void instruction_sqlconnect(struct_processus *s_etat_processus);
                   2380: void instruction_sqldisconnect(struct_processus *s_etat_processus);
                   2381: void instruction_sqlquery(struct_processus *s_etat_processus);
                   2382: void instruction_sqrt(struct_processus *s_etat_processus);
                   2383: void instruction_sr(struct_processus *s_etat_processus);
                   2384: void instruction_srb(struct_processus *s_etat_processus);
                   2385: void instruction_sst(struct_processus *s_etat_processus);
                   2386: void instruction_star_d(struct_processus *s_etat_processus);
                   2387: void instruction_star_h(struct_processus *s_etat_processus);
                   2388: void instruction_star_s(struct_processus *s_etat_processus);
                   2389: void instruction_star_w(struct_processus *s_etat_processus);
                   2390: void instruction_start(struct_processus *s_etat_processus);
                   2391: void instruction_static(struct_processus *s_etat_processus);
                   2392: void instruction_std(struct_processus *s_etat_processus);
                   2393: void instruction_step(struct_processus *s_etat_processus);
                   2394: void instruction_steq(struct_processus *s_etat_processus);
                   2395: void instruction_sto(struct_processus *s_etat_processus);
                   2396: void instruction_sto_division(struct_processus *s_etat_processus);
                   2397: void instruction_sto_fois(struct_processus *s_etat_processus);
                   2398: void instruction_sto_moins(struct_processus *s_etat_processus);
                   2399: void instruction_sto_plus(struct_processus *s_etat_processus);
                   2400: void instruction_stof(struct_processus *s_etat_processus);
                   2401: void instruction_stop(struct_processus *s_etat_processus);
                   2402: void instruction_store(struct_processus *s_etat_processus);
                   2403: void instruction_stos(struct_processus *s_etat_processus);
                   2404: void instruction_stoswi(struct_processus *s_etat_processus);
                   2405: void instruction_str_fleche(struct_processus *s_etat_processus);
                   2406: void instruction_stws(struct_processus *s_etat_processus);
                   2407: void instruction_sub(struct_processus *s_etat_processus);
                   2408: void instruction_suspend(struct_processus *s_etat_processus);
                   2409: void instruction_svd(struct_processus *s_etat_processus);
                   2410: void instruction_svl(struct_processus *s_etat_processus);
                   2411: void instruction_swap(struct_processus *s_etat_processus);
                   2412: void instruction_swi(struct_processus *s_etat_processus);
                   2413: void instruction_swilock(struct_processus *s_etat_processus);
                   2414: void instruction_swiqueue(struct_processus *s_etat_processus);
                   2415: void instruction_swistatus(struct_processus *s_etat_processus);
                   2416: void instruction_swiunlock(struct_processus *s_etat_processus);
                   2417: void instruction_swapcntxt(struct_processus *s_etat_processus);
                   2418: void instruction_sx(struct_processus *s_etat_processus);
                   2419: void instruction_sx2(struct_processus *s_etat_processus);
                   2420: void instruction_sxy(struct_processus *s_etat_processus);
                   2421: void instruction_sy(struct_processus *s_etat_processus);
                   2422: void instruction_sy2(struct_processus *s_etat_processus);
                   2423: void instruction_sync(struct_processus *s_etat_processus);
                   2424: void instruction_syseval(struct_processus *s_etat_processus);
                   2425: 
                   2426: void instruction_table_fleche(struct_processus *s_etat_processus);
                   2427: void instruction_tail(struct_processus *s_etat_processus);
                   2428: void instruction_tan(struct_processus *s_etat_processus);
                   2429: void instruction_tanh(struct_processus *s_etat_processus);
                   2430: void instruction_target(struct_processus *s_etat_processus);
                   2431: void instruction_taylr(struct_processus *s_etat_processus);
                   2432: void instruction_then(struct_processus *s_etat_processus);
                   2433: void instruction_time(struct_processus *s_etat_processus);
                   2434: void instruction_title(struct_processus *s_etat_processus);
                   2435: void instruction_tokenize(struct_processus *s_etat_processus);
                   2436: void instruction_tot(struct_processus *s_etat_processus);
                   2437: void instruction_trim(struct_processus *s_etat_processus);
                   2438: void instruction_trn(struct_processus *s_etat_processus);
                   2439: void instruction_trnc(struct_processus *s_etat_processus);
                   2440: void instruction_true(struct_processus *s_etat_processus);
                   2441: void instruction_type(struct_processus *s_etat_processus);
                   2442: 
                   2443: void instruction_ucase(struct_processus *s_etat_processus);
                   2444: void instruction_uchol(struct_processus *s_etat_processus);
                   2445: void instruction_undo(struct_processus *s_etat_processus);
                   2446: void instruction_unlock(struct_processus *s_etat_processus);
                   2447: void instruction_unprotect(struct_processus *s_etat_processus);
                   2448: void instruction_until(struct_processus *s_etat_processus);
                   2449: void instruction_use(struct_processus *s_etat_processus);
                   2450: void instruction_utpc(struct_processus *s_etat_processus);
                   2451: void instruction_utpf(struct_processus *s_etat_processus);
                   2452: void instruction_utpn(struct_processus *s_etat_processus);
                   2453: void instruction_utpt(struct_processus *s_etat_processus);
                   2454: 
                   2455: void instruction_var(struct_processus *s_etat_processus);
                   2456: void instruction_variable(struct_processus *s_etat_processus);
                   2457: void instruction_vars(struct_processus *s_etat_processus);
                   2458: void instruction_verify(struct_processus *s_etat_processus);
                   2459: void instruction_vers_niveau_inferieur(struct_processus *s_etat_processus);
                   2460: void instruction_vers_niveau_superieur(struct_processus *s_etat_processus);
                   2461: void instruction_version(struct_processus *s_etat_processus);
                   2462: void instruction_visit(struct_processus *s_etat_processus);
                   2463: void instruction_volatile(struct_processus *s_etat_processus);
                   2464: 
                   2465: void instruction_wait(struct_processus *s_etat_processus);
                   2466: void instruction_warranty(struct_processus *s_etat_processus);
                   2467: void instruction_wfdata(struct_processus *s_etat_processus);
                   2468: void instruction_wfack(struct_processus *s_etat_processus);
                   2469: void instruction_wflock(struct_processus *s_etat_processus);
                   2470: void instruction_wfpoke(struct_processus *s_etat_processus);
                   2471: void instruction_wfproc(struct_processus *s_etat_processus);
                   2472: void instruction_wfsock(struct_processus *s_etat_processus);
                   2473: void instruction_wfswi(struct_processus *s_etat_processus);
                   2474: void instruction_while(struct_processus *s_etat_processus);
                   2475: void instruction_wireframe(struct_processus *s_etat_processus);
                   2476: void instruction_workdir(struct_processus *s_etat_processus);
                   2477: void instruction_write(struct_processus *s_etat_processus);
                   2478: 
                   2479: void instruction_xcol(struct_processus *s_etat_processus);
                   2480: void instruction_xor(struct_processus *s_etat_processus);
                   2481: void instruction_xpon(struct_processus *s_etat_processus);
                   2482: void instruction_xroot(struct_processus *s_etat_processus);
                   2483: 
                   2484: void instruction_ycol(struct_processus *s_etat_processus);
                   2485: void instruction_yield(struct_processus *s_etat_processus);
                   2486: 
                   2487: /*
                   2488: --------------------------------------------------------------------------------
                   2489:   Procédures
                   2490: --------------------------------------------------------------------------------
                   2491: */
                   2492: 
                   2493: #ifndef RPLARGS
                   2494: void affectation_interruptions_logicielles(struct_processus *s_etat_processus);
                   2495: void affichage_pile(struct_processus *s_etat_processus,
                   2496:        struct_liste_chainee *l_element_courant, unsigned long
                   2497:        niveau_courant);
                   2498: #endif
                   2499: 
                   2500: void *allocation(struct_processus *s_etat_processus, enum t_type type);
                   2501: void *allocation_maillon(struct_processus *s_etat_processus);
                   2502: 
                   2503: #ifndef RPLARGS
                   2504: void analyse(struct_processus *s_etat_processus, void (*fonction)());
1.34      bertrand 2505: void *analyse_instruction(struct_processus *s_etat_processus,
1.1       bertrand 2506:        unsigned char *candidat);
                   2507: void appel_gnuplot(struct_processus *s_etat_processus,
                   2508:        unsigned char persistance);
                   2509: void cf(struct_processus *s_etat_processus, unsigned char indice_drapeau);
                   2510: void cond(struct_processus *s_etat_processus,
                   2511:        struct_matrice *s_matrice, real8 *condition);
                   2512: void conversion_decimal_vers_hms(real8 *angle);
                   2513: void conversion_degres_vers_radians(real8 *angle);
                   2514: void conversion_element_tex(unsigned char **element, unsigned char *fonction);
                   2515: void conversion_format(struct_processus *s_etat_processus,
                   2516:        unsigned char *chaine);
                   2517: void conversion_hms_vers_decimal(real8 *angle);
1.31      bertrand 2518: void conversion_majuscule_limitee(unsigned char *chaine_entree, 
                   2519:        unsigned char *chaine_sortie, unsigned long longueur);
1.1       bertrand 2520: void conversion_radians_vers_degres(real8 *angle);
                   2521: void correction_formateur_tex(struct_processus *s_etat_processus,
                   2522:        unsigned char **ligne);
                   2523: void depilement_pile_systeme(struct_processus *s_etat_processus);
                   2524: void derivation(struct_processus *s_etat_processus,
                   2525:        struct_objet **s_expression);
                   2526: void determinant(struct_processus *s_etat_processus, struct_matrice *s_matrice,
                   2527:        void *valeur);
                   2528: void deverrouillage_threads_concurrents(struct_processus *s_etat_processus);
                   2529: void ecriture_pile(struct_processus *s_etat_processus, file *flux,
                   2530:        struct_liste_chainee *l_element_courant, unsigned long niveau_courant);
                   2531: void ecriture_profil(struct_processus *s_etat_processus);
1.23      bertrand 2532: void effacement_pile_systeme(struct_processus *s_etat_processus);
1.1       bertrand 2533: void empilement_pile_systeme(struct_processus *s_etat_processus);
                   2534: void encart(struct_processus *s_etat_processus, unsigned long duree);
                   2535: void evaluation_romberg(struct_processus *s_etat_processus,
                   2536:        struct_objet *s_expression, unsigned char *variable, real8 *point,
                   2537:        real8 *valeur, logical1 *validite);
                   2538: void factorisation_cholesky(struct_processus *s_etat_processus,
                   2539:        struct_matrice *s_matrice, unsigned char mode);
                   2540: void factorisation_lq(struct_processus *s_etat_processus,
                   2541:        struct_matrice *s_matrice, void **tau);
                   2542: void factorisation_lu(struct_processus *s_etat_processus,
                   2543:        struct_matrice *s_matrice, struct_matrice **s_permutation);
                   2544: void factorisation_qr(struct_processus *s_etat_processus,
                   2545:        struct_matrice *s_matrice, void **tau);
                   2546: void factorisation_schur(struct_processus *s_etat_processus,
                   2547:        struct_matrice *s_matrice, struct_matrice **s_schur);
                   2548: void *fusible(void *argument);
                   2549: void formateur_tex(struct_processus *s_etat_processus, struct_objet *s_objet,
                   2550:        unsigned char environnement);
                   2551: void formateur_elementaire_tex(struct_processus *s_etat_processus,
                   2552:        file *fichier, struct_objet *s_objet, unsigned char environnement);
                   2553: void impression_pile(struct_processus *s_etat_processus,
                   2554:            struct_liste_chainee *l_element_courant,
                   2555:            unsigned char methode, unsigned long niveau_courant);
                   2556: void impression_tex(struct_processus *s_etat_processus);
                   2557: void informations(struct_processus *s_etat_processus);
                   2558: void initialisation_allocateur(struct_processus *s_etat_processus);
                   2559: void initialisation_completion(void);
                   2560: void initialisation_drapeaux(struct_processus *s_etat_processus);
                   2561: void initialisation_generateur_aleatoire(struct_processus *s_etat_processus,
                   2562:        logical1 initialisation_automatique, unsigned long int racine);
                   2563: void initialisation_instructions(struct_processus *s_etat_processus);
                   2564: #endif
                   2565: 
                   2566: void initialisation_objet(struct_objet *s_objet);
                   2567: 
                   2568: #ifndef RPLARGS
                   2569: void insertion_thread(struct_processus *s_etat_processus,
                   2570:        logical1 thread_principal);
                   2571: void insertion_thread_surveillance(struct_processus *s_etat_processus,
                   2572:        struct_descripteur_thread *s_argument_thread);
                   2573: void integrale_romberg(struct_processus *s_etat_processus,
                   2574:        struct_objet *s_expression, unsigned char *variable,
                   2575:        real8 a, real8 b, real8 precision);
                   2576: void interruption1(int signal, siginfo_t *siginfo, void *context);
                   2577: void interruption2(int signal, siginfo_t *siginfo, void *context);
                   2578: void interruption3(int signal, siginfo_t *siginfo, void *context);
                   2579: void interruption4(int signal, siginfo_t *siginfo, void *context);
                   2580: void interruption5(int signal, siginfo_t *siginfo, void *context);
                   2581: void interruption6(int signal, siginfo_t *siginfo, void *context);
                   2582: void interruption7(int signal, siginfo_t *siginfo, void *context);
                   2583: void interruption8(int signal, siginfo_t *siginfo, void *context);
                   2584: void interruption9(int signal, siginfo_t *siginfo, void *context);
                   2585: void interruption10(int signal, siginfo_t *siginfo, void *context);
1.36    ! bertrand 2586: void interruption11(int signal, siginfo_t *siginfo, void *context);
1.1       bertrand 2587: void inversion_matrice(struct_processus *s_etat_processus,
                   2588:        struct_matrice *s_matrice);
                   2589: void lancement_daemon(struct_processus *s_etat_processus);
                   2590: void *lancement_thread(void *argument);
                   2591: #endif
                   2592: 
                   2593: void liberation(struct_processus *s_etat_processus, struct_objet *s_objet);
                   2594: void liberation_maillon(struct_processus *s_etat_processus,
                   2595:        struct_liste_chainee *maillon);
                   2596: 
                   2597: #ifndef RPLARGS
                   2598: void liberation_allocateur(struct_processus *s_etat_processus);
                   2599: void liberation_arbre_instructions(struct_processus *s_etat_processus,
                   2600:        struct_instruction *arbre);
                   2601: void liberation_generateur_aleatoire(struct_processus *s_etat_processus);
                   2602: void liberation_threads(struct_processus *s_etat_processus);
                   2603: void liberation_profil(struct_processus *s_etat_processus);
                   2604: void localisation_courante(struct_processus *s_etat_processus);
                   2605: void modification_pid_thread_pere(struct_processus *s_etat_processus);
                   2606: void moindres_carres(struct_processus *s_etat_processus,
                   2607:        struct_matrice *s_matrice_a, struct_matrice *s_matrice_b,
                   2608:        struct_matrice *s_matrice_x);
                   2609: void profilage(struct_processus *s_etat_processus, unsigned char *fonction);
                   2610: void rang(struct_processus *s_etat_processus, struct_matrice *s_matrice,
                   2611:        integer8 *valeur);
                   2612: void recherche_type(struct_processus *s_etat_processus);
                   2613: void retrait_thread(struct_processus *s_etat_processus);
                   2614: void retrait_thread_surveillance(struct_processus *s_etat_processus,
                   2615:        struct_descripteur_thread *s_argument_thread);
                   2616: void rplcore(struct_processus *s_etat_processus);
1.34      bertrand 2617: void scrutation_injection(struct_processus *s_etat_processus);
1.1       bertrand 2618: void sf(struct_processus *s_etat_processus, unsigned char indice_drapeau);
                   2619: void *surveillance_processus(void *argument);
                   2620: void swap(void *variable_1, void *variable_2, unsigned long taille_octets);
                   2621: void traitement_asynchrone_exceptions_gsl(struct_processus *s_etat_processus);
                   2622: void traitement_exceptions_gsl(const char *reason, const char *file,
                   2623:        int line, int gsl_errno);
                   2624: void traitement_interruptions_logicielles(struct_processus *s_etat_processus);
                   2625: void tri_base_symboles_externes(struct_processus *s_etat_processus);
                   2626: void tri_vecteur(real8 *vecteur, unsigned long taille);
                   2627: void valeurs_propres(struct_processus *s_etat_processus,
                   2628:        struct_matrice *s_matrice,
                   2629:        struct_vecteur *s_valeurs_propres,
                   2630:        struct_matrice *s_vecteurs_propres_gauches,
                   2631:        struct_matrice *s_vecteur_propres_droits);
                   2632: void valeurs_propres_generalisees(struct_processus *s_etat_processus,
                   2633:        struct_matrice *s_matrice,
                   2634:        struct_matrice *s_metrique,
                   2635:        struct_vecteur *s_valeurs_propres,
                   2636:        struct_matrice *s_vecteurs_propres_gauches,
                   2637:        struct_matrice *s_vecteur_propres_droits);
                   2638: void valeurs_singulieres(struct_processus *s_etat_processus,
                   2639:        struct_matrice *s_matrice,
                   2640:        struct_matrice *u, struct_vecteur *s, struct_matrice *vh);
                   2641: void verrouillage_threads_concurrents(struct_processus *s_etat_processus);
                   2642: #endif
                   2643: 
                   2644: /*
                   2645: --------------------------------------------------------------------------------
                   2646:   Fonctions de sommation de vecteur dans perte de précision
                   2647: --------------------------------------------------------------------------------
                   2648: */
                   2649: 
                   2650: real8 sommation_vecteur_reel(real8 *vecteur, unsigned long *taille,
                   2651:        logical1 *erreur_memoire);
                   2652: complex16 sommation_vecteur_complexe(complex16 *vecteur, unsigned long *taille,
                   2653:        logical1 *erreur_memoire);
                   2654: 
                   2655: /*
                   2656: --------------------------------------------------------------------------------
                   2657:   Routine principale
                   2658: --------------------------------------------------------------------------------
                   2659: */
                   2660: 
                   2661: #ifndef RPLARGS
1.13      bertrand 2662: int rplinit(int argc, char *argv[], unsigned char ***resultats, char *rpl_home);
1.1       bertrand 2663: #endif
                   2664: 
                   2665: /*
                   2666: --------------------------------------------------------------------------------
                   2667:   Routines de statistiques
                   2668: --------------------------------------------------------------------------------
                   2669: */
                   2670: 
                   2671: #ifndef RPLARGS
                   2672: real8 correlation_statistique(struct_matrice *s_matrice,
                   2673:        unsigned long colonne_1, unsigned long colonne_2, logical1 *erreur);
                   2674: real8 covariance_statistique(struct_matrice *s_matrice,
                   2675:        unsigned long colonne_1, unsigned long colonne_2,
                   2676:        unsigned char type, logical1 *erreur);
                   2677: struct_vecteur *ecart_type_statistique(struct_matrice *s_matrice,
                   2678:        unsigned char type);
                   2679: struct_vecteur *moyenne_statistique(struct_matrice *s_matrice);
                   2680: struct_vecteur *sommation_colonne_statistique(struct_matrice *s_matrice,
                   2681:        unsigned long colonne);
                   2682: struct_vecteur *sommation_produits_colonnes_statistiques(struct_matrice
                   2683:        *s_matrice, unsigned long colonne_1, unsigned long colonne_2);
                   2684: struct_vecteur *sommation_statistique(struct_matrice *s_matrice);
                   2685: struct_vecteur *variance_statistique(struct_matrice *s_matrice,
                   2686:        unsigned char type);
                   2687: #endif
                   2688: 
                   2689: /*
                   2690: --------------------------------------------------------------------------------
                   2691:   Gestion des bibliothèques
                   2692: --------------------------------------------------------------------------------
                   2693: */
                   2694: 
                   2695: #ifndef RPLARGS
                   2696: void *chargement_bibliotheque(struct_processus *s_etat_processus,
                   2697:        unsigned char *bibliotheque);
                   2698: logical1 execution_fonction_de_bibliotheque(struct_processus *s_etat_processus,
                   2699:        unsigned char *nom_fonction, unsigned char *bibliothque);
                   2700: logical1 retrait_bibliotheque(struct_processus *s_etat_processus,
                   2701:        struct_bibliotheque *descripteur);
                   2702: #endif
                   2703: 
                   2704: struct_liste_chainee *depilement_pile_operationnelle(struct_rpl_arguments
                   2705:        *s_rpl_arguments, struct_objet **s_objet);
                   2706: struct_liste_chainee *empilement_pile_operationnelle(struct_rpl_arguments
                   2707:        *s_rpl_arguments, struct_objet *s_objet);
                   2708: struct_liste_chainee *sauvegarde_arguments(struct_rpl_arguments
                   2709:        *s_rpl_arguments, unsigned long nombre_arguments);
                   2710: 
                   2711: /*
                   2712: --------------------------------------------------------------------------------
                   2713:   Fonctions retournant un CHARACTER*(*)
                   2714: --------------------------------------------------------------------------------
                   2715: */
                   2716: 
                   2717: #ifndef RPLARGS
                   2718: unsigned char *analyse_algebrique(struct_processus *s_etat_processus,
                   2719:        unsigned char *chaine_algebrique, struct_liste_chainee **l_base_liste);
                   2720: unsigned char *recherche_chemin_fichiers_temporaires(struct_processus
                   2721:        *s_etat_processus);
                   2722: unsigned char *compactage(unsigned char *chaine);
                   2723: unsigned char *conversion_majuscule(unsigned char *chaine);
                   2724: unsigned char *creation_nom_fichier(struct_processus *s_etat_processus,
                   2725:        unsigned char *chemin);
                   2726: unsigned char *extraction_chaine(unsigned char *chaine, unsigned long i,
                   2727:        unsigned long j);
                   2728: unsigned char *formateur(struct_processus *s_etat_processus, long offset,
                   2729:        struct_objet *s_objet);
                   2730: unsigned char *formateur_fichier(struct_processus *s_etat_processus,
                   2731:        struct_objet *s_objet, struct_objet *s_format,
                   2732:        long longueur, long longueur_champ, unsigned char format,
                   2733:        unsigned char type, long *longueur_effective, long *recursivite);
                   2734: unsigned char *formateur_fichier_nombre(struct_processus *s_etat_processus,
                   2735:        void *valeur_numerique, unsigned char type,
                   2736:        long longueur, long longueur_champ, unsigned char format);
                   2737: unsigned char *formateur_fichier_reel(struct_processus *s_etat_processus,
                   2738:        void *valeur_numerique, unsigned char type,
                   2739:        long longueur, long longueur_champ, unsigned char format);
                   2740: unsigned char *formateur_nombre(struct_processus *s_etat_processus,
                   2741:        void *valeur_numerique, unsigned char type);
                   2742: unsigned char *formateur_reel(struct_processus *s_etat_processus,
                   2743:        void *valeur_numerique, unsigned char type);
                   2744: unsigned char *messages(struct_processus *s_etat_processus);
                   2745: unsigned char *purification_chaine(unsigned char *chaine);
                   2746: unsigned char *reencodage(struct_processus *s_etat_processus,
                   2747:        unsigned char *chaine_entree, unsigned char *codage_entree,
                   2748:        unsigned char *codage_sortie);
                   2749: unsigned char *transliteration(struct_processus *s_etat_processus,
                   2750:        unsigned char *chaine_entree, unsigned char *codage_entree,
                   2751:        unsigned char *codage_sortie);
                   2752: #endif
                   2753: 
                   2754: /*
                   2755: --------------------------------------------------------------------------------
                   2756:   Fonctions retournant un INTEGER*1 (drapeau d'erreur)
                   2757: --------------------------------------------------------------------------------
                   2758: */
                   2759: 
                   2760: #ifndef RPLARGS
                   2761: logical1 analyse_syntaxique(struct_processus *s_etat_processus);
                   2762: logical1 caracteristiques_fichier(struct_processus *s_etat_processus,
                   2763:        unsigned char *nom, logical1 *existence, logical1 *ouverture,
                   2764:        unsigned long *unite);
1.13      bertrand 2765: logical1 controle(struct_processus *s_etat_processus, unsigned char *fichier,
                   2766:        unsigned char *type, unsigned char *somme_candidate);
1.1       bertrand 2767: logical1 creation_variable(struct_processus *s_etat_processus,
                   2768:        struct_variable *s_variable,
                   2769:        unsigned char autorisation_creation_variable_statique,
                   2770:        unsigned char autorisation_creation_variable_partagee);
                   2771: logical1 creation_variable_partagee(struct_processus *s_etat_processus,
                   2772:        struct_variable_partagee *s_variable);
                   2773: logical1 creation_variable_statique(struct_processus *s_etat_processus,
                   2774:        struct_variable_statique *s_variable);
                   2775: logical1 chainage(struct_processus *s_etat_processus);
                   2776: logical1 compilation(struct_processus *s_etat_processus);
                   2777: logical1 depilement(struct_processus *s_etat_processus,
                   2778:        struct_liste_chainee **l_base_liste, struct_objet **s_objet);
                   2779: logical1 destruction_fichier(unsigned char *nom_fichier);
                   2780: logical1 empilement(struct_processus *s_etat_processus,
                   2781:        struct_liste_chainee **l_base_liste, struct_objet *s_objet);
                   2782: logical1 empilement_pile_last(struct_processus *s_etat_processus,
                   2783:        unsigned long nombre_arguments);
                   2784: logical1 evaluation(struct_processus *s_etat_processus, struct_objet *s_objet,
                   2785:        unsigned char type_evaluation);
1.15      bertrand 2786: logical1 initialisation_fichier_acces_direct(struct_processus *s_etat_processus,
                   2787:        sqlite3 *sqlite, logical1 binaire);
                   2788: logical1 initialisation_fichier_acces_indexe(struct_processus *s_etat_processus,
1.17      bertrand 2789:        sqlite3 *sqlite, integer8 position_clef, logical1 binaire);
1.1       bertrand 2790: logical1 recherche_instruction_suivante(struct_processus *s_etat_processus);
                   2791: logical1 retrait_variable(struct_processus *s_etat_processus,
                   2792:        unsigned char *nom_variable, unsigned char type);
                   2793: logical1 retrait_variable_par_niveau(struct_processus *s_etat_processus);
                   2794: logical1 retrait_variable_partagee(struct_processus *s_etat_processus,
                   2795:        unsigned char *nom_variable, union_position_variable position);
                   2796: logical1 retrait_variable_statique(struct_processus *s_etat_processus,
                   2797:        unsigned char *nom_variable, union_position_variable position);
                   2798: logical1 sequenceur(struct_processus *s_etat_processus);
                   2799: logical1 sequenceur_optimise(struct_processus *s_etat_processus);
                   2800: #endif
                   2801: 
                   2802: /*
                   2803: --------------------------------------------------------------------------------
                   2804:   Fonctions retournant un INTEGER*1 (drapeau)
                   2805: --------------------------------------------------------------------------------
                   2806: */
                   2807: 
                   2808: logical1 depassement_addition(integer8 *a, integer8 *b, integer8 *resultat);
                   2809: logical1 depassement_multiplication(integer8 *a, integer8 *b,
                   2810:        integer8 *resultat);
                   2811: logical1 depassement_puissance(integer8 *a, integer8 *b, integer8 *resultat);
                   2812: 
                   2813: #ifndef RPLARGS
                   2814: logical1 ecriture_pipe(struct_processus *s_etat_processus, int pipe,
                   2815:        struct_objet *s_objet);
                   2816: logical1 recherche_variable(struct_processus *s_etat_processus,
                   2817:        unsigned char *nom_variable);
                   2818: logical1 recherche_variable_partagee(struct_processus *s_etat_processus,
                   2819:        unsigned char *nom_variable, union_position_variable position,
                   2820:        unsigned char origine);
                   2821: logical1 recherche_variable_statique(struct_processus *s_etat_processus,
                   2822:        unsigned char *nom_variable, union_position_variable position,
                   2823:        unsigned char origine);
                   2824: logical1 test_cfsf(struct_processus *s_etat_processus,
                   2825:        unsigned char indice_drapeau);
                   2826: logical1 test_expression_rpn(unsigned char *chaine);
                   2827: logical1 test_fonction(unsigned char *chaine);
                   2828: #endif
                   2829: 
                   2830: /*
                   2831: --------------------------------------------------------------------------------
                   2832:   Fonctions retournant un ssize_t
                   2833: --------------------------------------------------------------------------------
                   2834: */
                   2835: 
                   2836: #ifndef RPLARGS
1.34      bertrand 2837: ssize_t read_atomic(struct_processus *s_etat_processus,
1.1       bertrand 2838:        int fd, void *buf, size_t count);
1.34      bertrand 2839: ssize_t write_atomic(struct_processus *s_etat_processus,
1.1       bertrand 2840:        int fd, void *buf, size_t count);
                   2841: #endif
                   2842: 
                   2843: /*
                   2844: --------------------------------------------------------------------------------
                   2845:   Fonctions renvoyant un int
                   2846: --------------------------------------------------------------------------------
                   2847: */
                   2848: 
1.4       bertrand 2849: int alsprintf(unsigned char **strp, const char *fmt, ...);
1.9       bertrand 2850: int tex_fprintf(struct_processus *s_etat_processus,
                   2851:        file *flux, const char *format, ...);
1.3       bertrand 2852: int transliterated_fprintf(struct_processus *s_etat_processus, file *flux,
                   2853:        const char *format, ...);
1.4       bertrand 2854: int valsprintf(unsigned char **strp, const char *fmt, va_list ap);
1.1       bertrand 2855: int wrapper_instruction_intrinseque(void (*fonction)(),
                   2856:        struct_rpl_arguments *rpl_arguments);
                   2857: 
                   2858: /*
                   2859: --------------------------------------------------------------------------------
                   2860:   Fonctions renvoyant un INTEGER*1 (longueur d'un entier binaire)
                   2861: --------------------------------------------------------------------------------
                   2862: */
                   2863: 
                   2864: #ifndef RPLARGS
                   2865: unsigned char longueur_entiers_binaires(struct_processus *s_etat_processus);
                   2866: unsigned char recherche_longueur_optimale(integer8 parametre);
                   2867: #endif
                   2868: 
                   2869: /*
                   2870: --------------------------------------------------------------------------------
                   2871:   Fonctions retournant un INTEGER*8 (valeur binaire non signée)
                   2872: --------------------------------------------------------------------------------
                   2873: */
                   2874: 
                   2875: #ifndef RPLARGS
                   2876: logical8 masque_entiers_binaires(struct_processus *s_etat_processus);
                   2877: #endif
                   2878: 
                   2879: /*
                   2880: --------------------------------------------------------------------------------
                   2881:   Fonctions retournant un INTEGER*8 (entier standard RPL/2)
                   2882: --------------------------------------------------------------------------------
                   2883: */
                   2884: 
                   2885: #ifndef RPLARGS
                   2886: integer8 occupation_memoire(struct_objet *s_objet);
                   2887: #endif
                   2888: 
                   2889: /*
                   2890: --------------------------------------------------------------------------------
                   2891:   Fonctions renvoyant une liste chaînée (pointeur sur *struct_liste_chainee)
                   2892: --------------------------------------------------------------------------------
                   2893: */
                   2894: 
                   2895: #ifndef RPLARGS
                   2896: struct_liste_chainee *analyse_rpn(struct_processus *s_etat_processus,
                   2897:        unsigned char *chaine_rpn);
                   2898: #endif
                   2899: 
                   2900: /*
                   2901: --------------------------------------------------------------------------------
                   2902:   Fonctions renvoyant une copie de la structure de description des processus
                   2903: --------------------------------------------------------------------------------
                   2904: */
                   2905: 
                   2906: #ifndef RPLARGS
                   2907: struct_processus *copie_etat_processus(struct_processus *s_etat_processus);
                   2908: #endif
                   2909: 
                   2910: /*
                   2911: --------------------------------------------------------------------------------
1.15      bertrand 2912:   Fonctions renvoyant un pointeur sur un fichier (file *) ou un descripteur
1.1       bertrand 2913: --------------------------------------------------------------------------------
                   2914: */
                   2915: 
                   2916: #ifndef RPLARGS
                   2917: file *creation_fichier_tex(struct_processus *s_etat_processus);
1.15      bertrand 2918: struct_descripteur_fichier *descripteur_fichier(struct_processus
                   2919:        *s_etat_processus, struct_fichier *s_fichier);
1.1       bertrand 2920: #endif
                   2921: 
                   2922: /*
                   2923: --------------------------------------------------------------------------------
                   2924:   Fonctions renvoyant un pointeur sur une *struct_objet
                   2925: --------------------------------------------------------------------------------
                   2926: */
                   2927: 
                   2928: struct_objet *copie_objet(struct_processus *s_etat_processus,
                   2929:        struct_objet *s_objet, unsigned char type);
                   2930: 
                   2931: #ifndef RPLARGS
                   2932: struct_objet *formateur_date(struct_processus *s_etat_processus,
                   2933:        struct timeval *temps);
                   2934: struct_objet *lecture_pipe(struct_processus *s_etat_processus, int pipe);
                   2935: struct_objet *parametres_sql(struct_processus *s_etat_processus,
                   2936:        struct_objet *s_parametres);
                   2937: struct_objet *simplification(struct_processus *s_etat_processus,
                   2938:        struct_objet *s_objet);
                   2939: #endif
                   2940: 
                   2941: /*
                   2942: --------------------------------------------------------------------------------
                   2943:   Fonctions gérant les arbres de simplification
                   2944: --------------------------------------------------------------------------------
                   2945: */
                   2946: 
                   2947: #ifndef RPLARGS
                   2948: struct_arbre *creation_arbre(struct_processus *s_etat_processus,
                   2949:        struct_objet **t_objets, unsigned long indice,
                   2950:        unsigned long indice_maximal);
                   2951: void liberation_arbre(struct_processus *s_etat_processus,
                   2952:        struct_arbre *s_noeud);
                   2953: void parcours_arbre(struct_processus *s_etat_processus, struct_arbre *s_noeud);
                   2954: void simplification_arbre(struct_processus *s_etat_processus,
                   2955:        struct_arbre *s_noeud);
                   2956: #endif
                   2957: 
                   2958: /*
                   2959: --------------------------------------------------------------------------------
                   2960:   Fonctions gérant la complétion automatique
                   2961: --------------------------------------------------------------------------------
                   2962: */
                   2963: 
                   2964: char **completion_rpl();
                   2965: char *generateur_commandes();
                   2966: char **completion_matches();
                   2967: 
                   2968: // END C PROTOTYPES
                   2969: 
                   2970: /*
                   2971: --------------------------------------------------------------------------------
                   2972:   Arithmétique
                   2973: --------------------------------------------------------------------------------
                   2974: */
                   2975: 
                   2976: void f77absc_(complex16 *c, real8 *resultat);
                   2977: 
                   2978: void f77additioncc_(complex16 *ca, complex16 *cb, complex16 *resultat);
                   2979: void f77additionci_(complex16 *ca, integer8 *ib, complex16 *resultat);
                   2980: void f77additioncr_(complex16 *ca, real8 *rb, complex16 *resultat);
                   2981: 
                   2982: void f77divisioncc_(complex16 *ca, complex16 *rb, complex16 *resultat);
                   2983: void f77divisionci_(complex16 *ca, integer8 *ib, complex16 *resultat);
                   2984: void f77divisioncr_(complex16 *ca, real8 *rb, complex16 *resultat);
                   2985: void f77divisionic_(integer8 *ib, complex16 *cb, complex16 *resultat);
                   2986: void f77divisionrc_(real8 *ra, complex16 *cb, complex16 *resultat);
                   2987: 
                   2988: void f77multiplicationcc_(complex16 *ca, complex16 *cb, complex16 *resultat);
                   2989: void f77multiplicationci_(complex16 *ca, integer8 *ib, complex16 *resultat);
                   2990: void f77multiplicationcr_(complex16 *ca, real8 *rb, complex16 *resultat);
                   2991: 
                   2992: void f77puissancecc_(complex16 *ca, complex16 *cb, complex16 *resultat);
                   2993: void f77puissanceci_(complex16 *ca, integer8 *ib, complex16 *resultat,
                   2994:        integer4 *troncature);
                   2995: void f77puissancecr_(complex16 *ca, real8 *rb, complex16 *resultat);
                   2996: void f77puissanceic_(integer8 *ia, complex16 *cb, complex16 *resultat);
                   2997: void f77puissanceii_(integer8 *ia, integer8 *ib, integer8 *resultat);
                   2998: void f77puissanceir_(integer8 *ia, real8 *rb, real8 *resultat);
                   2999: void f77puissancerc_(real8 *ra, complex16 *cb, complex16 *resultat);
                   3000: void f77puissanceri_(real8 *ra, integer8 *ib, real8 *resultat,
                   3001:        integer4 *troncature);
                   3002: void f77puissancerr_(real8 *ra, real8 *rb, real8 *resultat);
                   3003: 
                   3004: void f77racinecarreec_(complex16 *ca, complex16 *resultat);
                   3005: void f77racinecarreein_(integer8 *ia, complex16 *resultat);
                   3006: void f77racinecarreeip_(integer8 *ia, real8 *resultat);
                   3007: void f77racinecarreern_(real8 *ia, complex16 *resultat);
                   3008: void f77racinecarreerp_(real8 *ia, real8 *resultat);
                   3009: 
                   3010: void f77soustractioncc_(complex16 *ca, complex16 *cb, complex16 *resultat);
                   3011: void f77soustractionci_(complex16 *ca, integer8 *ib, complex16 *resultat);
                   3012: void f77soustractioncr_(complex16 *ca, real8 *rb, complex16 *resultat);
                   3013: void f77soustractionic_(integer8 *ib, complex16 *cb, complex16 *resultat);
                   3014: void f77soustractionrc_(real8 *ra, complex16 *cb, complex16 *resultat);
                   3015: 
                   3016: /*
                   3017: --------------------------------------------------------------------------------
                   3018:   Trigonométrie complexe
                   3019: --------------------------------------------------------------------------------
                   3020: */
                   3021: 
                   3022: void f77acos_(complex16 *argument, complex16 *resultat);
                   3023: void f77asin_(complex16 *argument, complex16 *resultat);
                   3024: void f77atan_(complex16 *argument, complex16 *resultat, integer4 *erreur);
                   3025: void f77cos_(complex16 *argument, complex16 *resultat);
                   3026: void f77sin_(complex16 *argument, complex16 *resultat);
                   3027: void f77tan_(complex16 *argument, complex16 *resultat, integer4 *erreur);
                   3028: 
                   3029: /*
                   3030: --------------------------------------------------------------------------------
                   3031:   Fonctions hyperboliques
                   3032: --------------------------------------------------------------------------------
                   3033: */
                   3034: 
                   3035: void f77acoshc_(complex16 *argument, complex16 *resultat);
                   3036: void f77alogc_(complex16 *argument, complex16 *resultat);
                   3037: void f77asinhc_(complex16 *argument, complex16 *resultat);
                   3038: void f77atanhc_(complex16 *argument, complex16 *resultat);
                   3039: void f77cosh_(complex16 *argument, complex16 *resultat);
                   3040: void f77expc_(complex16 *argument, complex16 *resultat);
                   3041: void f77lnc_(complex16 *argument, complex16 *resultat, integer4 *erreur);
                   3042: void f77lnin_(integer8 *argument, complex16 *resultat, integer4 *erreur);
                   3043: void f77lnrn_(real8 *argument, complex16 *resultat, integer4 *erreur);
                   3044: void f77logc_(complex16 *argument, complex16 *resultat, integer4 *erreur);
                   3045: void f77login_(integer8 *argument, complex16 *resultat, integer4 *erreur);
                   3046: void f77logrn_(real8 *argument, complex16 *resultat, integer4 *erreur);
                   3047: void f77sinh_(complex16 *argument, complex16 *resultat);
                   3048: void f77tanh_(complex16 *argument, complex16 *resultat, integer4 *erreur);
                   3049: void f77acoshi_(integer8 *argument, real8 *resultat);
                   3050: void f77acoshr_(real8 *argument, real8 *resultat);
                   3051: void f77asinhi_(integer8 *argument, real8 *resultat);
                   3052: void f77asinhr_(real8 *argument, real8 *resultat);
                   3053: void f77atanhi_(integer8 *argument, real8 *resultat);
                   3054: void f77atanhr_(real8 *argument, real8 *resultat);
                   3055: void f77lnip_(integer8 *argument, real8 *resultat, integer4 *erreur);
                   3056: void f77lnrp_(real8 *argument, real8 *resultat, integer4 *erreur);
                   3057: void f77logip_(integer8 *argument, real8 *resultat, integer4 *erreur);
                   3058: void f77logrp_(real8 *argument, real8 *resultat, integer4 *erreur);
                   3059: 
                   3060: /*
                   3061: --------------------------------------------------------------------------------
                   3062:   Calculs divers
                   3063: --------------------------------------------------------------------------------
                   3064: */
                   3065: 
                   3066: void f90arrangement(integer8 *n, integer8 *k, real8 *resultat);
                   3067: void f90combinaison(integer8 *n, integer8 *k, real8 *resultat);
                   3068: void f90fcd(real8 *x, integer8 *n1, integer8 *n2, real8 *resultat);
                   3069: void f90gausscd(real8 *x, real8 *moyenne, real8 *variance, real8 *resultat);
                   3070: void f90tcd(real8 *x, integer8 *n, real8 *resultat);
                   3071: void f90x2cd(real8 *x, integer8 *n, real8 *resultat);
                   3072: 
                   3073: // BEGIN C PROTOTYPES
                   3074: void dft(complex16 *dft, integer4 *nombre_lignes, integer4 *nombre_colonnes,
                   3075:        integer4 *inverse, integer4 *erreur);
                   3076: // END C PROTOTYPES
                   3077: 
                   3078: /*
                   3079: --------------------------------------------------------------------------------
                   3080:   Fonctions Lapack
                   3081: --------------------------------------------------------------------------------
                   3082: */
                   3083: 
                   3084:    /*
                   3085:     * Calcul de la longueur d'un espace de travail
                   3086:     */
                   3087: 
                   3088: #ifndef RPLARGS
                   3089: integer4 ilaenv_(integer4 *optimal, char *nom_fonction, char *option,
                   3090:        integer4 *n1, integer4 *n2, integer4 *n3, integer4 *n4,
                   3091:        integer4 longueur_nom_fonction, integer4 longueur_option);
                   3092: 
                   3093:    /*
                   3094:     * Inversion
                   3095:     */
                   3096: 
                   3097: void dgetri_(integer4 *ordre_a, real8 *a, integer4 *lda, integer4 *pivot,
                   3098:        real8 *work, integer4 *dim_work, integer4 *ios);
                   3099: void zgetri_(integer4 *ordre_a, complex16 *a, integer4 *lda, integer4 *pivot,
                   3100:        complex16 *work, integer4 *dim_work, integer4 *ios);
                   3101: 
                   3102:    /*
                   3103:     * Valeurs propres
                   3104:     */
                   3105: 
                   3106: void zgeev_(unsigned char *calcul_vp_gauches, unsigned char *calcul_vp_droits,
                   3107:        integer4 *dim_matrice1, complex16 *matrice_f77,
                   3108:        integer4 *dim_matrice2, complex16 *valeurs_propres,
                   3109:        complex16 *vpg_f77, integer4 *dim_matrice3,
                   3110:        complex16 *vpd_f77, integer4 *dim_matrice4,
                   3111:        complex16 *work, integer4 *lwork, real8 *rwork,
                   3112:        integer4 *erreur, integer4 longueur_1, integer4 longueur_2);
                   3113: 
                   3114:    /*
                   3115:     * Valeurs propres généralisées
                   3116:     */
                   3117: 
                   3118: void zggev_(unsigned char *calcul_vp_gauches, unsigned char *calcul_vp_droits,
                   3119:        integer4 *dim_matrice1, complex16 *matrice_f77,
                   3120:        integer4 *dim_matrice2, complex16 *metrique_f77,
                   3121:        integer4 *dim_matrice3, complex16 *alpha, complex16 *beta,
                   3122:        complex16 *vpg_f77, integer4 *dim_matrice4,
                   3123:        complex16 *vpd_f77, integer4 *dim_matrice5,
                   3124:        complex16 *work, integer4 *lwork, real8 *rwork,
                   3125:        integer4 *erreur, integer4 longueur_1, integer4 longueur_2);
                   3126: 
                   3127:    /*
                   3128:     * Moindres carrés
                   3129:     */
                   3130: 
                   3131: void dgelsd_(integer4 *nombre_lignes_a, integer4 *nombre_colonnes_a,
                   3132:        integer4 *nombre_colonnes_b, real8 *matrice_a, integer4 *lda,
                   3133:        real8 *matrice_b, integer4 *ldb, real8 *valeurs_singulieres,
                   3134:        real8 *rcond, integer4 *rank, real8 *work, integer4 *lwork,
                   3135:        integer4 *iwork, integer4 *info);
                   3136: void zgelsd_(integer4 *nombre_lignes_a, integer4 *nombre_colonnes_a,
                   3137:        integer4 *nombre_colonnes_b, complex16 *matrice_a, integer4 *lda,
                   3138:        complex16 *matrice_b, integer4 *ldb, real8 *valeurs_singulieres,
                   3139:        real8 *rcond, integer4 *rank, complex16 *work, integer4 *lwork,
                   3140:        real8 *rwork, integer4 *iwork, integer4 *info);
                   3141: 
                   3142:    /*
                   3143:     * Moindres carrés généralisé
                   3144:     */
                   3145: 
                   3146:    /*
                   3147:     * Décomposition en valeurs singulières
                   3148:     */
                   3149: 
                   3150: void dgesvd_(unsigned char *jobu, unsigned char *jobvh,
                   3151:        integer4 *m, integer4 *n, real8 *a, integer4 *lda,
                   3152:        real8 *s, real8 *u, integer4 *ldu, real8 *vh, integer4 *ldvh,
                   3153:        real8 *work, integer4 *lwork, integer4 *info, integer4 longueur_jobu,
                   3154:        integer4 longueur_jobvh);
                   3155: void zgesvd_(unsigned char *jobu, unsigned char *jobvh,
                   3156:        integer4 *m, integer4 *n, real8 *a, integer4 *lda,
                   3157:        real8 *s, real8 *u, integer4 *ldu, real8 *vh, integer4 *ldvh,
                   3158:        real8 *work, integer4 *lwork, real8 *rwork, integer4 *info,
                   3159:        integer4 longueur_jobu, integer4 longueur_jobvh);
                   3160: 
                   3161:    /*
                   3162:     * Factorisations diverses
                   3163:     */
                   3164: 
                   3165:        /* LU de Crout */
                   3166: void dgetrf_(integer4 *nb_lignes_a, integer4 *nb_colonnes_a, real8 *a,
                   3167:        integer4 *lda, integer4 *pivot, integer4 *ios);
                   3168: void zgetrf_(integer4 *nb_lignes_a, integer4 *nb_colonnes_a, complex16 *a,
                   3169:        integer4 *lda, integer4 *pivot, integer4 *ios);
                   3170: 
                   3171:        /* LQ */
                   3172: void dgelq2_(integer4 *nb_lignes_a, integer4 *nb_colonnes_a, real8 *a,
                   3173:        integer4 *lda, real8 *tau, real8 *work, integer4 *ios);
                   3174: void zgelq2_(integer4 *nb_lignes_a, integer4 *nb_colonnes_a, complex16 *a,
                   3175:        integer4 *lda, complex16 *tau, complex16 *work, integer4 *ios);
                   3176: 
                   3177:        /* QR */
                   3178: void dgeqp3_(integer4 *nb_lignes_a, integer4 *nb_colonnes_a, real8 *a,
                   3179:        integer4 *lda, integer4 *pivot, real8 *tau, real8 *work,
                   3180:        integer4 *lwork, integer4 *ios);
                   3181: void zgeqp3_(integer4 *nb_lignes_a, integer4 *nb_colonnes_a, complex16 *a,
                   3182:        integer4 *lda, integer4 *pivot, complex16 *tau, complex16 *work,
                   3183:        integer4 *lwork, real8 *rwork, integer4 *ios);
                   3184: 
                   3185:        /* Cholesky */
                   3186: void dpptrf_(unsigned char *mode, integer4 *n, complex16 *triangle,
                   3187:        integer4 *ios, integer4 longueur);
                   3188: void zpptrf_(unsigned char *mode, integer4 *n, complex16 *triangle,
                   3189:        integer4 *ios, integer4 longueur);
                   3190: 
                   3191:        /* Schur */
                   3192: void dgees_(unsigned char *calcul_vecteur, unsigned char *valeurs_triees,
                   3193:        logical4 (*fonction_tri)(), integer4 *n, real8 *a,
                   3194:        integer4 *lda, integer4 *sdim, real8 *wr, real8 *wi,
                   3195:        real8 *vs, integer4 *ldvs, real8 *work, integer4 *lwork,
                   3196:        logical4 *bwork, integer4 *info, integer4 l1, integer4 l2);
                   3197: void zgees_(unsigned char *calcul_vecteur, unsigned char *valeurs_triees,
                   3198:        logical4 (*fonction_tri)(), integer4 *n, complex16 *a,
                   3199:        integer4 *lda, integer4 *sdim, complex16 *w,
                   3200:        complex16 *vs, integer4 *ldvs, complex16 *work, integer4 *lwork,
                   3201:        real8 *rwork, logical4 *bwork, integer4 *info,
                   3202:        integer4 l1, integer4 l2);
                   3203: 
                   3204:        /* Déterminant et rang */
                   3205: void dgecon_(unsigned char *norm, integer4 *n, real8 *a, integer4 *lda,
                   3206:        real8 *anorm, real8 *rcond, real8 *work, integer4 *iwork,
                   3207:        integer4 *info, integer4 l1);
                   3208: void dgelsy_(integer4 *m, integer4 *n, integer4 *nrhs, real8 *a,
                   3209:        integer4 *lda, real8 *b, integer4 *ldb, integer4 *jpvt, real8 *rcond,
                   3210:        integer4 *rank, real8 *work, integer4 *lwork, integer4 *info);
                   3211: real8 dlange_(unsigned char *norme, integer4 *n, integer4 *m, real8 *a,
                   3212:        integer4 *lda, real8 *work, integer4 longueur);
                   3213: real8 zlange_(unsigned char *norme, integer4 *n, integer4 *m, real8 *a,
                   3214:        integer4 *lda, real8 *work, integer4 longueur);
                   3215: void zgecon_(unsigned char *norm, integer4 *n, complex16 *a, integer4 *lda,
                   3216:        real8 *anorm, real8 *rcond, complex16 *work, real8 *rwork,
                   3217:        integer4 *info, integer4 l1);
                   3218: void zgelsy_(integer4 *m, integer4 *n, integer4 *nrhs, complex16 *a,
                   3219:        integer4 *lda, complex16 *b, integer4 *ldb, integer4 *jpvt,
                   3220:        real8 *rcond, integer4 *rank, complex16 *work, integer4 *lwork,
                   3221:        real8 *rwork, integer4 *info);
                   3222: #endif
                   3223: 
                   3224: /*
                   3225:  * Fonction testant la requête d'arrêt (nécessaire pour tester le
                   3226:  * drapeau depuis une bibliothèque).
                   3227:  */
                   3228: 
1.34      bertrand 3229: int test_arret(struct_processus *s_etat_processus);
1.1       bertrand 3230: 
                   3231: #endif
                   3232: 
                   3233: // vim: ts=4

CVSweb interface <joel.bertrand@systella.fr>