Return to rpl.h CVS log

Up to [local] / rpl / src

Ajout d'une fonction de conversion de chaîne statique
conversion_majuscule_limitee() pour éviter l'allocation de mémoire
inhérente à conversion_majuscule() problèmatique sous Solaris malgré
l'utilisation de ptmalloc3.

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