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