rpl/src/rpl.h - view

File: [local] / rpl / src / rpl.h
Revision 1.9: download - view: text, annotated - select for diffs - revision graph
Sun Feb 28 14:47:14 2010 UTC (14 years, 2 months ago) by bertrand
Branches: MAIN
CVS tags: HEAD

Ajout de fonctions de dÃ©bogage des allocations et libÃ©rations de mÃ©moire.
Correction de deux fuites de mÃ©moire dans l'analyse des expressions
algÃ©briques (touchent les fonctions).

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