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