rpl/src/rpl.h - view

File: [local] / rpl / src / rpl.h
Revision 1.308: download - view: text, annotated - select for diffs - revision graph
Sun Jul 2 22:28:20 2017 UTC (7 years, 10 months ago) by bertrand
Branches: MAIN
CVS tags: HEAD

DerniÃ¨re sÃ©rie de patches pour gÃ©rer les types externes dans les
bibliothÃ¨ques. Voir pour cela modules/sets. Fonctionne.

Attention, ne permet pas encore de compiler un code utilisant des types
externes (la compilation se fait avant l'exÃ©cution de l'instruction USE).

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