rpl/src/rpl.h - view

File: [local] / rpl / src / rpl.h
Revision 1.14: download - view: text, annotated - select for diffs - revision graph
Fri Mar 5 11:20:09 2010 UTC (14 years, 1 month ago) by bertrand
Branches: MAIN
CVS tags: HEAD

VÃ©rification des sommes de contrÃ´le des utilitaires.

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