rpl/src/rpl.h - view

File: [local] / rpl / src / rpl.h
Revision 1.5: download - view: text, annotated - select for diffs - revision graph
Fri Feb 5 19:02:56 2010 UTC (14 years, 2 months ago) by bertrand
Branches: MAIN
CVS tags: HEAD

Correction d'un problÃ¨me dans sequenceur() pour qu'une Ã©valuation
de type ->num fonctionne de la mÃªme maniÃ¨re que le programme soit compilÃ© ou
non.

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