Return to rpl.h CVS log

Up to [local] / rpl / src

Correction d'un point bloquant dans la gestion des processus
(affectation des interruptions logicielles survenant après l'arrêt du
processus père car le mutex de protection de la routine était déjà positionné
dans la fonction appelante). Ajout de la fonction CLRATEXIT.

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