rpl/src/rpl.h - view

File: [local] / rpl / src / rpl.h
Revision 1.2: download - view: text, annotated - select for diffs - revision graph
Wed Jan 27 22:22:17 2010 UTC (15 years, 3 months ago) by bertrand
Branches: MAIN
CVS tags: HEAD



Changement de version pour la 4.0.10.
Correction d'un dysfonctionnement dans le retour des erreurs des fonctions
RPL/C lorsque le programme est compilĂŠ (routine evaluation()).

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