Return to rpl.h CVS log

Up to [local] / rpl / src

Ajout d'un mutex dans la structure de description du processus pour protéger
les allocateurs partagés entre le processus principal et les threads de
surveillance des processus fils.

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