rpl/src/rpl.h - view

File: [local] / rpl / src / rpl.h
Revision 1.49: download - view: text, annotated - select for diffs - revision graph
Wed Jul 14 14:19:40 2010 UTC (13 years, 9 months ago) by bertrand
Branches: MAIN
CVS tags: HEAD

En route vers la 4.0.18 !

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