Return to rpl.h CVS log

Up to [local] / rpl / src

Correction d'un bug concernant le champ format des objets FCH et SCK.
La valeur nombre_occurrences n'était pas mise à jour correctement par
les copies et libérations d'objets.

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