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