rpl/src/rpl.h - view

File: [local] / rpl / src / rpl.h
Revision 1.19: download - view: text, annotated - select for diffs - revision graph
Thu Mar 18 21:42:41 2010 UTC (14 years, 1 month ago) by bertrand
Branches: MAIN
CVS tags: HEAD

Correction de problÃ¨mes de compilation sur des systÃ¨mes non GNU (scripts
awk en particulier).

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