![]() ![]() | ![]() |
Passage de la branche 4.1 en branche stable.
1: /* 2: ================================================================================ 3: RPL/2 (R) version 4.1.0 4: Copyright (C) 1989-2011 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: #include "rpl-conv.h" 24: 25: 26: /* 27: ================================================================================ 28: Fonction 'spawn' 29: ================================================================================ 30: Entrées : 31: -------------------------------------------------------------------------------- 32: Sorties : 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: void 39: instruction_spawn(struct_processus *s_etat_processus) 40: { 41: logical1 drapeau; 42: logical1 variable_partagee; 43: 44: pthread_attr_t attributs; 45: 46: pthread_mutexattr_t attributs_mutex; 47: 48: pthread_t thread_id; 49: pthread_t thread_surveillance; 50: 51: sigset_t oldset; 52: sigset_t set; 53: 54: struct_descripteur_thread *s_argument_thread; 55: 56: struct_liste_chainee *l_element_courant; 57: 58: struct_objet *s_copie; 59: struct_objet *s_objet; 60: struct_objet *s_objet_resultat; 61: struct_objet *s_objet_systeme; 62: 63: struct_processus *s_nouvel_etat_processus; 64: 65: struct timespec attente; 66: 67: (*s_etat_processus).erreur_execution = d_ex; 68: 69: if ((*s_etat_processus).affichage_arguments == 'Y') 70: { 71: printf("\n SPAWN "); 72: 73: if ((*s_etat_processus).langue == 'F') 74: { 75: printf("(lancement d'un thread)\n\n"); 76: } 77: else 78: { 79: printf("(create thread)\n\n"); 80: } 81: 82: printf(" 1: %s, %s\n", d_NOM, d_RPN); 83: printf("-> 1: %s\n", d_PRC); 84: 85: return; 86: } 87: else if ((*s_etat_processus).test_instruction == 'Y') 88: { 89: (*s_etat_processus).nombre_arguments = -1; 90: return; 91: } 92: 93: if (test_cfsf(s_etat_processus, 31) == d_vrai) 94: { 95: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 96: { 97: return; 98: } 99: } 100: 101: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 102: &s_objet) == d_erreur) 103: { 104: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 105: return; 106: } 107: 108: /* 109: * Une routine fille doit pouvoir renvoyer des objets au processus 110: * père au travers de la fonction SEND. Il ne peut donc s'agir que 111: * d'une fonction ou d'une expression RPN. 112: */ 113: 114: if (((*s_objet).type != NOM) && ((*s_objet).type != RPN)) 115: { 116: liberation(s_etat_processus, s_objet); 117: 118: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 119: return; 120: } 121: 122: /* 123: * Si l'argument est de type NOM, il faut que la variable correspondante 124: * soit une variable de type RPN. 125: */ 126: 127: variable_partagee = d_faux; 128: s_copie = NULL; 129: 130: if ((*s_objet).type == NOM) 131: { 132: if (recherche_variable(s_etat_processus, (*((struct_nom *) 133: (*s_objet).objet)).nom) == d_vrai) 134: { 135: if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL) 136: { 137: if (pthread_mutex_lock(&((*(*s_etat_processus) 138: .s_liste_variables_partagees).mutex)) != 0) 139: { 140: (*s_etat_processus).erreur_systeme = d_es_processus; 141: return; 142: } 143: 144: if (recherche_variable_partagee(s_etat_processus, 145: (*(*s_etat_processus).pointeur_variable_courante).nom, 146: (*(*s_etat_processus).pointeur_variable_courante) 147: .variable_partagee, (*(*s_etat_processus) 148: .pointeur_variable_courante).origine) == d_faux) 149: { 150: if (pthread_mutex_unlock(&((*(*s_etat_processus) 151: .s_liste_variables_partagees).mutex)) != 0) 152: { 153: (*s_etat_processus).erreur_systeme = d_es_processus; 154: return; 155: } 156: 157: liberation(s_etat_processus, s_objet); 158: 159: (*s_etat_processus).erreur_systeme = d_es; 160: (*s_etat_processus).erreur_execution = 161: d_ex_argument_invalide; 162: return; 163: } 164: 165: if (((*(*(*s_etat_processus).s_liste_variables_partagees) 166: .table[(*(*s_etat_processus) 167: .s_liste_variables_partagees).position_variable].objet) 168: .type != RPN) && ((*(*(*s_etat_processus) 169: .s_liste_variables_partagees).table 170: [(*(*s_etat_processus).s_liste_variables_partagees) 171: .position_variable].objet).type != ADR)) 172: { 173: if (pthread_mutex_unlock(&((*(*s_etat_processus) 174: .s_liste_variables_partagees).mutex)) != 0) 175: { 176: (*s_etat_processus).erreur_systeme = d_es_processus; 177: return; 178: } 179: 180: liberation(s_etat_processus, s_objet); 181: 182: (*s_etat_processus).erreur_execution = 183: d_ex_argument_invalide; 184: return; 185: } 186: 187: if ((s_copie = copie_objet(s_etat_processus, 188: (*(*s_etat_processus) 189: .s_liste_variables_partagees).table 190: [(*(*s_etat_processus).s_liste_variables_partagees) 191: .position_variable].objet, 'P')) == NULL) 192: { 193: if (pthread_mutex_unlock(&((*(*s_etat_processus) 194: .s_liste_variables_partagees).mutex)) != 0) 195: { 196: (*s_etat_processus).erreur_systeme = d_es_processus; 197: return; 198: } 199: 200: (*s_etat_processus).erreur_systeme = 201: d_es_allocation_memoire; 202: 203: return; 204: } 205: 206: variable_partagee = d_vrai; 207: 208: if (pthread_mutex_unlock(&((*(*s_etat_processus) 209: .s_liste_variables_partagees).mutex)) != 0) 210: { 211: (*s_etat_processus).erreur_systeme = d_es_processus; 212: return; 213: } 214: } 215: else 216: { 217: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet) 218: .type != RPN) && ((*(*(*s_etat_processus) 219: .pointeur_variable_courante).objet).type != ADR)) 220: { 221: liberation(s_etat_processus, s_objet); 222: 223: (*s_etat_processus).erreur_execution = 224: d_ex_argument_invalide; 225: return; 226: } 227: } 228: } 229: else // Variable inexistante 230: { 231: liberation(s_etat_processus, s_objet); 232: 233: (*s_etat_processus).erreur_systeme = d_es; 234: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 235: return; 236: } 237: } 238: 239: if (sigemptyset(&set) != 0) 240: { 241: (*s_etat_processus).erreur_systeme = d_es_processus; 242: return; 243: } 244: 245: if (sigaddset(&set, SIGSTART) != 0) 246: { 247: (*s_etat_processus).erreur_systeme = d_es_processus; 248: return; 249: } 250: 251: /* 252: * Le signal SIGFSTOP doit être traité ! 253: */ 254: 255: if (sigaddset(&set, SIGFSTOP) != 0) 256: { 257: (*s_etat_processus).erreur_systeme = d_es_processus; 258: return; 259: } 260: 261: if (sigaddset(&set, SIGFABORT) != 0) 262: { 263: (*s_etat_processus).erreur_systeme = d_es_processus; 264: return; 265: } 266: 267: if (sigaddset(&set, SIGURG) != 0) 268: { 269: (*s_etat_processus).erreur_systeme = d_es_processus; 270: return; 271: } 272: 273: if (pthread_sigmask(SIG_BLOCK, &set, &oldset) != 0) 274: { 275: (*s_etat_processus).erreur_systeme = d_es_processus; 276: return; 277: } 278: 279: if ((s_argument_thread = malloc(sizeof(struct_descripteur_thread))) == NULL) 280: { 281: (*s_etat_processus).erreur_systeme = d_es_processus; 282: return; 283: } 284: 285: if (pipe((*s_argument_thread).pipe_erreurs) != 0) 286: { 287: (*s_etat_processus).erreur_systeme = d_es_processus; 288: return; 289: } 290: 291: if (pipe((*s_argument_thread).pipe_interruptions) != 0) 292: { 293: (*s_etat_processus).erreur_systeme = d_es_processus; 294: return; 295: } 296: 297: if (pipe((*s_argument_thread).pipe_nombre_interruptions_attente) != 0) 298: { 299: (*s_etat_processus).erreur_systeme = d_es_processus; 300: return; 301: } 302: 303: if (pipe((*s_argument_thread).pipe_objets) != 0) 304: { 305: (*s_etat_processus).erreur_systeme = d_es_processus; 306: return; 307: } 308: 309: if (pipe((*s_argument_thread).pipe_acquittement) != 0) 310: { 311: (*s_etat_processus).erreur_systeme = d_es_processus; 312: return; 313: } 314: 315: if (pipe((*s_argument_thread).pipe_nombre_objets_attente) != 0) 316: { 317: (*s_etat_processus).erreur_systeme = d_es_processus; 318: return; 319: } 320: 321: if (pipe((*s_argument_thread).pipe_injections) != 0) 322: { 323: (*s_etat_processus).erreur_systeme = d_es_processus; 324: return; 325: } 326: 327: if (pipe((*s_argument_thread).pipe_nombre_injections) != 0) 328: { 329: (*s_etat_processus).erreur_systeme = d_es_processus; 330: return; 331: } 332: 333: if ((s_nouvel_etat_processus = copie_etat_processus(s_etat_processus)) 334: == NULL) 335: { 336: return; 337: } 338: 339: pthread_mutexattr_init(&attributs_mutex); 340: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); 341: pthread_mutex_init(&((*s_argument_thread).mutex), &attributs_mutex); 342: pthread_mutexattr_destroy(&attributs_mutex); 343: 344: pthread_mutexattr_init(&attributs_mutex); 345: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); 346: pthread_mutex_init(&((*s_argument_thread).mutex_nombre_references), 347: &attributs_mutex); 348: pthread_mutexattr_destroy(&attributs_mutex); 349: 350: (*s_argument_thread).processus_detache = d_faux; 351: (*s_argument_thread).thread_actif = d_faux; 352: (*s_argument_thread).thread_pere = pthread_self(); 353: (*s_argument_thread).pid = getpid(); 354: 355: (*s_nouvel_etat_processus).pipe_donnees = 356: (*s_argument_thread).pipe_objets[1]; 357: (*s_nouvel_etat_processus).pipe_nombre_objets_attente = 358: (*s_argument_thread).pipe_nombre_objets_attente[1]; 359: (*s_nouvel_etat_processus).pipe_interruptions = 360: (*s_argument_thread).pipe_interruptions[1]; 361: (*s_nouvel_etat_processus).pipe_nombre_interruptions_attente = 362: (*s_argument_thread).pipe_nombre_interruptions_attente[1]; 363: (*s_nouvel_etat_processus).pipe_injections = 364: (*s_argument_thread).pipe_injections[0]; 365: (*s_nouvel_etat_processus).pipe_nombre_injections = 366: (*s_argument_thread).pipe_nombre_injections[0]; 367: (*s_nouvel_etat_processus).pipe_acquittement = 368: (*s_argument_thread).pipe_acquittement[0]; 369: (*s_nouvel_etat_processus).presence_pipes = d_vrai; 370: 371: (*s_nouvel_etat_processus).niveau_initial = 372: (*s_etat_processus).niveau_courant; 373: (*s_nouvel_etat_processus).debug_programme = d_faux; 374: (*s_nouvel_etat_processus).nombre_objets_injectes = 0; 375: (*s_nouvel_etat_processus).nombre_objets_envoyes_non_lus = 0; 376: (*s_nouvel_etat_processus).temps_maximal_cpu = 0; 377: (*s_nouvel_etat_processus).presence_fusible = d_faux; 378: (*s_nouvel_etat_processus).thread_fusible = 0; 379: 380: (*s_nouvel_etat_processus).pile_profilage = NULL; 381: (*s_nouvel_etat_processus).pile_profilage_fonctions = NULL; 382: 383: /* 384: * Lancement du thread fils et du thread de surveillance 385: */ 386: 387: if (pthread_attr_init(&attributs) != 0) 388: { 389: (*s_etat_processus).erreur_systeme = d_es_processus; 390: return; 391: } 392: 393: if (pthread_attr_setdetachstate(&attributs, PTHREAD_CREATE_JOINABLE) != 0) 394: { 395: (*s_etat_processus).erreur_systeme = d_es_processus; 396: return; 397: } 398: 399: # ifndef OS2 400: # ifndef Cygwin 401: if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 0) 402: { 403: (*s_etat_processus).erreur_systeme = d_es_processus; 404: return; 405: } 406: 407: if (pthread_attr_setinheritsched(&attributs, PTHREAD_EXPLICIT_SCHED) != 0) 408: { 409: (*s_etat_processus).erreur_systeme = d_es_processus; 410: return; 411: } 412: 413: if (pthread_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 0) 414: { 415: (*s_etat_processus).erreur_systeme = d_es_processus; 416: return; 417: } 418: # endif 419: # endif 420: 421: /* 422: * Création de l'objet à retourner 423: */ 424: 425: if ((s_objet_resultat = allocation(s_etat_processus, PRC)) == NULL) 426: { 427: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 428: return; 429: } 430: 431: (*((struct_processus_fils *) (*s_objet_resultat).objet)).thread 432: = s_argument_thread; 433: 434: (*(*((struct_processus_fils *) (*s_objet_resultat).objet)).thread) 435: .nombre_objets_dans_pipe = 0; 436: (*(*((struct_processus_fils *) (*s_objet_resultat).objet)).thread) 437: .nombre_interruptions_dans_pipe = 0; 438: (*(*((struct_processus_fils *) (*s_objet_resultat).objet)).thread) 439: .nombre_references = 1; 440: 441: // Lancement du thread fils 442: 443: if (pthread_mutex_lock(&((*s_nouvel_etat_processus).mutex)) != 0) 444: { 445: (*s_etat_processus).erreur_systeme = d_es_processus; 446: return; 447: } 448: 449: (*s_argument_thread).s_nouvel_etat_processus = s_nouvel_etat_processus; 450: (*s_argument_thread).s_etat_processus = s_etat_processus; 451: 452: if (variable_partagee == d_vrai) 453: { 454: (*s_argument_thread).argument = s_copie; 455: (*s_argument_thread).destruction_objet = d_vrai; 456: } 457: else 458: { 459: (*s_argument_thread).argument = s_objet; 460: (*s_argument_thread).destruction_objet = d_faux; 461: } 462: 463: (*s_argument_thread).set = set; 464: (*s_argument_thread).oldset = oldset; 465: (*s_argument_thread).thread_actif = d_faux; 466: 467: if (pthread_create(&thread_id, &attributs, lancement_thread, 468: s_argument_thread) != 0) 469: { 470: (*s_etat_processus).erreur_systeme = d_es_processus; 471: return; 472: } 473: 474: attente.tv_sec = 0; 475: attente.tv_nsec = GRANULARITE_us * 1000; 476: 477: while((*s_argument_thread).thread_actif == d_faux) 478: { 479: nanosleep(&attente, NULL); 480: INCR_GRANULARITE(attente.tv_nsec); 481: } 482: 483: if (pthread_attr_destroy(&attributs) != 0) 484: { 485: (*s_etat_processus).erreur_systeme = d_es_processus; 486: return; 487: } 488: 489: if (pthread_attr_init(&attributs) != 0) 490: { 491: (*s_etat_processus).erreur_systeme = d_es_processus; 492: return; 493: } 494: 495: if (pthread_attr_setdetachstate(&attributs, 496: PTHREAD_CREATE_DETACHED) != 0) 497: { 498: (*s_etat_processus).erreur_systeme = d_es_processus; 499: return; 500: } 501: 502: # ifndef OS2 503: # ifndef Cygwin 504: if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 0) 505: { 506: (*s_etat_processus).erreur_systeme = d_es_processus; 507: return; 508: } 509: 510: if (pthread_attr_setinheritsched(&attributs, 511: PTHREAD_EXPLICIT_SCHED) != 0) 512: { 513: (*s_etat_processus).erreur_systeme = d_es_processus; 514: return; 515: } 516: 517: if (pthread_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 0) 518: { 519: (*s_etat_processus).erreur_systeme = d_es_processus; 520: return; 521: } 522: # endif 523: # endif 524: 525: // Attente de l'affectation de la grandeur processus.tid par le thread fils. 526: 527: if (pthread_mutex_lock(&((*s_nouvel_etat_processus).mutex)) != 0) 528: { 529: (*s_etat_processus).erreur_systeme = d_es_processus; 530: return; 531: } 532: 533: /* 534: * On copie l'objet plutôt que le pointeur car cet objet peut être 535: * accédé depuis deux threads distincts et aboutir à un blocage lors d'une 536: * copie. 537: */ 538: 539: if ((s_objet_systeme = copie_objet(s_etat_processus, s_objet_resultat, 'O')) 540: == NULL) 541: { 542: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 543: return; 544: } 545: 546: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) 547: { 548: (*s_etat_processus).erreur_systeme = d_es_processus; 549: return; 550: } 551: 552: // Si le tid existe déjà dans la pile des processus, il s'agit forcement 553: // d'un processus moribond. On attend donc qu'il soit effectivement 554: // libéré. 555: 556: do 557: { 558: l_element_courant = (struct_liste_chainee *) 559: (*s_etat_processus).l_base_pile_processus; 560: drapeau = d_faux; 561: 562: attente.tv_sec = 0; 563: attente.tv_nsec = GRANULARITE_us * 1000; 564: 565: while(l_element_courant != NULL) 566: { 567: if (((*(*((struct_processus_fils *) 568: (*(*l_element_courant).donnee).objet)).thread) 569: .processus_detache == d_faux) && 570: ((*s_argument_thread).processus_detache == d_faux)) 571: { 572: if (pthread_equal((*(*((struct_processus_fils *) 573: (*(*l_element_courant).donnee).objet)).thread) 574: .tid, (*s_argument_thread).tid) != 0) 575: { 576: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 577: { 578: (*s_etat_processus).erreur_systeme = d_es_processus; 579: return; 580: } 581: 582: scrutation_injection(s_etat_processus); 583: 584: if ((*s_etat_processus).nombre_interruptions_non_affectees 585: != 0) 586: { 587: affectation_interruptions_logicielles(s_etat_processus); 588: } 589: 590: if ((*s_etat_processus).nombre_interruptions_en_queue != 0) 591: { 592: traitement_interruptions_logicielles(s_etat_processus); 593: } 594: 595: nanosleep(&attente, NULL); 596: INCR_GRANULARITE(attente.tv_nsec); 597: 598: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0) 599: { 600: (*s_etat_processus).erreur_systeme = d_es_processus; 601: return; 602: } 603: 604: drapeau = d_vrai; 605: break; 606: } 607: } 608: 609: l_element_courant = (*l_element_courant).suivant; 610: } 611: } while(drapeau == d_vrai); 612: 613: if (empilement(s_etat_processus, 614: (struct_liste_chainee **) &((*s_etat_processus) 615: .l_base_pile_processus), s_objet_systeme) == d_erreur) 616: { 617: pthread_mutex_unlock(&((*s_etat_processus).mutex)); 618: pthread_mutex_unlock(&((*s_nouvel_etat_processus).mutex)); 619: return; 620: } 621: 622: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0) 623: { 624: (*s_etat_processus).erreur_systeme = d_es_processus; 625: return; 626: } 627: 628: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 629: s_objet_resultat) == d_erreur) 630: { 631: pthread_mutex_unlock(&((*s_nouvel_etat_processus).mutex)); 632: return; 633: } 634: 635: if (pthread_mutex_lock(&(*s_argument_thread).mutex) != 0) 636: { 637: pthread_mutex_unlock(&((*s_nouvel_etat_processus).mutex)); 638: (*s_etat_processus).erreur_systeme = d_es_processus; 639: return; 640: } 641: 642: if ((*s_argument_thread).thread_actif == d_faux) 643: { 644: // Le thread n'existe plus. 645: 646: pthread_join((*s_argument_thread).tid, NULL); 647: pthread_mutex_unlock(&((*s_nouvel_etat_processus).mutex)); 648: pthread_mutex_unlock(&(*s_argument_thread).mutex); 649: (*s_etat_processus).erreur_systeme = d_es_processus; 650: return; 651: } 652: 653: if (pthread_mutex_unlock(&(*s_argument_thread).mutex) != 0) 654: { 655: pthread_mutex_unlock(&((*s_nouvel_etat_processus).mutex)); 656: (*s_etat_processus).erreur_systeme = d_es_processus; 657: return; 658: } 659: 660: if (pthread_mutex_unlock(&((*s_nouvel_etat_processus).mutex)) != 0) 661: { 662: (*s_etat_processus).erreur_systeme = d_es_processus; 663: return; 664: } 665: 666: // Lancement du thread de surveillance 667: 668: if (pthread_create(&thread_surveillance, &attributs, 669: surveillance_processus, s_argument_thread) != 0) 670: { 671: (*s_etat_processus).erreur_systeme = d_es_processus; 672: return; 673: } 674: 675: if (pthread_attr_destroy(&attributs) != 0) 676: { 677: (*s_etat_processus).erreur_systeme = d_es_processus; 678: return; 679: } 680: 681: // Le fils peut être présent sans être en attente du signal de départ. 682: 683: if (pthread_kill((*s_argument_thread).tid, SIGSTART) != 0) 684: { 685: (*s_etat_processus).erreur_systeme = d_es_processus; 686: return; 687: } 688: 689: if (pthread_sigmask(SIG_SETMASK, &oldset, NULL) != 0) 690: { 691: (*s_etat_processus).erreur_systeme = d_es_processus; 692: return; 693: } 694: 695: sigpending(&set); 696: 697: return; 698: } 699: 700: 701: /* 702: ================================================================================ 703: Fonction 'sqlconnect' 704: ================================================================================ 705: Entrées : 706: -------------------------------------------------------------------------------- 707: Sorties : 708: -------------------------------------------------------------------------------- 709: Effets de bord : néant 710: ================================================================================ 711: */ 712: 713: void 714: instruction_sqlconnect(struct_processus *s_etat_processus) 715: { 716: struct_objet *s_objet_argument; 717: struct_objet *s_objet_resultat; 718: struct_objet *s_objet_systeme; 719: 720: (*s_etat_processus).erreur_execution = d_ex; 721: 722: if ((*s_etat_processus).affichage_arguments == 'Y') 723: { 724: printf("\n SQLCONNECT "); 725: 726: if ((*s_etat_processus).langue == 'F') 727: { 728: printf("(connexion à une base de données SQL)\n\n"); 729: } 730: else 731: { 732: printf("(connect to SQL database)\n\n"); 733: } 734: 735: printf(" 1: %s\n", d_LST); 736: printf("-> 1: %s\n\n", d_SQL); 737: 738: if ((*s_etat_processus).langue == 'F') 739: { 740: printf(" Utilisation :\n\n"); 741: } 742: else 743: { 744: printf(" Usage:\n\n"); 745: } 746: 747: printf(" { \"mysql\" \"server\" \"database\" " 748: "\"user\" \"password\" } SQLCONNECT\n"); 749: printf(" { \"postgresql:iso-8859-1\" \"server\" " 750: "\"database\" \"user\" \"password\" port }\n"); 751: printf(" SQLCONNECT\n"); 752: 753: return; 754: } 755: else if ((*s_etat_processus).test_instruction == 'Y') 756: { 757: (*s_etat_processus).nombre_arguments = -1; 758: return; 759: } 760: 761: if (test_cfsf(s_etat_processus, 31) == d_vrai) 762: { 763: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 764: { 765: return; 766: } 767: } 768: 769: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 770: &s_objet_argument) == d_erreur) 771: { 772: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 773: return; 774: } 775: 776: if ((*s_objet_argument).type == LST) 777: { 778: if ((s_objet_resultat = parametres_sql(s_etat_processus, 779: s_objet_argument)) == NULL) 780: { 781: liberation(s_etat_processus, s_objet_argument); 782: return; 783: } 784: 785: if ((s_objet_systeme = copie_objet(s_etat_processus, s_objet_resultat, 786: 'O')) == NULL) 787: { 788: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 789: return; 790: } 791: 792: if (empilement(s_etat_processus, 793: (struct_liste_chainee **) &((*s_etat_processus) 794: .s_connecteurs_sql), s_objet_systeme) == d_erreur) 795: { 796: return; 797: } 798: 799: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 800: s_objet_resultat) == d_erreur) 801: { 802: return; 803: } 804: } 805: else 806: { 807: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 808: 809: liberation(s_etat_processus, s_objet_argument); 810: return; 811: } 812: 813: liberation(s_etat_processus, s_objet_argument); 814: return; 815: } 816: 817: 818: /* 819: ================================================================================ 820: Fonction 'sqldisconnect' 821: ================================================================================ 822: Entrées : 823: -------------------------------------------------------------------------------- 824: Sorties : 825: -------------------------------------------------------------------------------- 826: Effets de bord : néant 827: ================================================================================ 828: */ 829: 830: void 831: instruction_sqldisconnect(struct_processus *s_etat_processus) 832: { 833: logical1 drapeau; 834: 835: struct_liste_chainee *l_element_courant; 836: struct_liste_chainee *l_element_precedent; 837: 838: struct_objet *s_objet; 839: 840: (*s_etat_processus).erreur_execution = d_ex; 841: 842: if ((*s_etat_processus).affichage_arguments == 'Y') 843: { 844: printf("\n SQLDISCONNECT "); 845: 846: if ((*s_etat_processus).langue == 'F') 847: { 848: printf("(déconnexion d'une base de donnée SQL)\n\n"); 849: } 850: else 851: { 852: printf("(disconnection from SQL database)\n\n"); 853: } 854: 855: printf(" 1: %s\n", d_SQL); 856: return; 857: } 858: else if ((*s_etat_processus).test_instruction == 'Y') 859: { 860: (*s_etat_processus).nombre_arguments = -1; 861: return; 862: } 863: 864: if (test_cfsf(s_etat_processus, 31) == d_vrai) 865: { 866: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 867: { 868: return; 869: } 870: } 871: 872: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 873: &s_objet) == d_erreur) 874: { 875: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 876: return; 877: } 878: 879: if ((*s_objet).type == SQL) 880: { 881: if (((*((struct_connecteur_sql *) (*s_objet).objet)).pid != 882: getpid()) || (pthread_equal((*((struct_connecteur_sql *) 883: (*s_objet).objet)).tid, pthread_self()) == 0)) 884: { 885: (*s_etat_processus).erreur_execution = d_ex_fichier_hors_contexte; 886: 887: liberation(s_etat_processus, s_objet); 888: return; 889: } 890: 891: l_element_courant = (*s_etat_processus).s_connecteurs_sql; 892: l_element_precedent = NULL; 893: 894: while(l_element_courant != NULL) 895: { 896: if (((*((struct_connecteur_sql *) (*(*l_element_courant).donnee) 897: .objet)).pid == getpid()) && (pthread_equal( 898: (*((struct_connecteur_sql *) (*(*l_element_courant).donnee) 899: .objet)).tid, pthread_self()) != 0) && 900: (strcmp((*((struct_connecteur_sql *) (*(*l_element_courant) 901: .donnee).objet)).type, (*((struct_connecteur_sql *) 902: (*s_objet).objet)).type) == 0)) 903: { 904: if (strcmp((*((struct_connecteur_sql *) (*s_objet).objet)).type, 905: "MYSQL") == 0) 906: { 907: # ifdef MYSQL_SUPPORT 908: 909: if ((*((struct_connecteur_sql *) (*(*l_element_courant) 910: .donnee).objet)).descripteur.mysql == 911: (*((struct_connecteur_sql *) (*s_objet).objet)) 912: .descripteur.mysql) 913: { 914: drapeau = d_vrai; 915: } 916: else 917: { 918: drapeau = d_faux; 919: } 920: 921: # else 922: 923: if ((*s_etat_processus).langue == 'F') 924: { 925: printf("+++Attention : Support de MySQL " 926: "non compilé !\n"); 927: } 928: else 929: { 930: printf("+++Warning : MySQL support not available !\n"); 931: } 932: 933: fflush(stdout); 934: 935: drapeau = d_faux; 936: # endif 937: } 938: else if (strcmp((*((struct_connecteur_sql *) (*s_objet).objet)) 939: .type, "POSTGRESQL") == 0) 940: { 941: # ifdef POSTGRESQL_SUPPORT 942: 943: if ((*((struct_connecteur_sql *) (*(*l_element_courant) 944: .donnee).objet)).descripteur.postgresql == 945: (*((struct_connecteur_sql *) (*s_objet).objet)) 946: .descripteur.postgresql) 947: { 948: drapeau = d_vrai; 949: } 950: else 951: { 952: drapeau = d_faux; 953: } 954: 955: # else 956: 957: if ((*s_etat_processus).langue == 'F') 958: { 959: printf("+++Attention : Support de PostgreSQL " 960: "non compilé !\n"); 961: } 962: else 963: { 964: printf("+++Warning : PostgreSQL support " 965: "not available !\n"); 966: } 967: 968: fflush(stdout); 969: 970: drapeau = d_faux; 971: # endif 972: } 973: else 974: { 975: BUG(1, printf("SQL type '%s' not allowed!", 976: (*((struct_connecteur_sql *) (*s_objet).objet)) 977: .type)); 978: return; 979: } 980: 981: if (drapeau == d_vrai) 982: { 983: if (l_element_precedent == NULL) 984: { 985: (*s_etat_processus).s_connecteurs_sql = 986: (*l_element_courant).suivant; 987: } 988: else if ((*l_element_courant).suivant == NULL) 989: { 990: (*l_element_precedent).suivant = NULL; 991: } 992: else 993: { 994: (*l_element_precedent).suivant = 995: (*l_element_courant).suivant; 996: } 997: 998: liberation(s_etat_processus, (*l_element_courant).donnee); 999: free(l_element_courant); 1000: 1001: break; 1002: } 1003: } 1004: 1005: l_element_precedent = l_element_courant; 1006: l_element_courant = (*l_element_courant).suivant; 1007: } 1008: 1009: sqlclose(s_objet); 1010: } 1011: else 1012: { 1013: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1014: 1015: liberation(s_etat_processus, s_objet); 1016: return; 1017: } 1018: 1019: liberation(s_etat_processus, s_objet); 1020: return; 1021: } 1022: 1023: 1024: /* 1025: ================================================================================ 1026: Fonction 'smphrincr' 1027: ================================================================================ 1028: Entrées : 1029: -------------------------------------------------------------------------------- 1030: Sorties : 1031: -------------------------------------------------------------------------------- 1032: Effets de bord : néant 1033: ================================================================================ 1034: */ 1035: 1036: void 1037: instruction_smphrincr(struct_processus *s_etat_processus) 1038: { 1039: struct_objet *s_objet_argument; 1040: 1041: (*s_etat_processus).erreur_execution = d_ex; 1042: 1043: if ((*s_etat_processus).affichage_arguments == 'Y') 1044: { 1045: printf("\n SMPHRINCR "); 1046: 1047: if ((*s_etat_processus).langue == 'F') 1048: { 1049: printf("(incrémentation du sémaphore)\n\n"); 1050: } 1051: else 1052: { 1053: printf("(semaphore incrementation)\n\n"); 1054: } 1055: 1056: printf(" 1: %s\n", d_SPH); 1057: return; 1058: } 1059: else if ((*s_etat_processus).test_instruction == 'Y') 1060: { 1061: (*s_etat_processus).nombre_arguments = -1; 1062: return; 1063: } 1064: 1065: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1066: { 1067: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 1068: { 1069: return; 1070: } 1071: } 1072: 1073: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1074: &s_objet_argument) == d_erreur) 1075: { 1076: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1077: return; 1078: } 1079: 1080: if ((*s_objet_argument).type == SPH) 1081: { 1082: if (sem_post((*((struct_semaphore *) (*s_objet_argument).objet)) 1083: .semaphore) != 0) 1084: { 1085: (*s_etat_processus).erreur_execution = d_ex_semaphore; 1086: 1087: liberation(s_etat_processus, s_objet_argument); 1088: return; 1089: } 1090: 1091: liberation(s_etat_processus, s_objet_argument); 1092: } 1093: else 1094: { 1095: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1096: 1097: liberation(s_etat_processus, s_objet_argument); 1098: return; 1099: } 1100: 1101: return; 1102: } 1103: 1104: 1105: /* 1106: ================================================================================ 1107: Fonction 'smphrdecr' 1108: ================================================================================ 1109: Entrées : 1110: -------------------------------------------------------------------------------- 1111: Sorties : 1112: -------------------------------------------------------------------------------- 1113: Effets de bord : néant 1114: ================================================================================ 1115: */ 1116: 1117: void 1118: instruction_smphrdecr(struct_processus *s_etat_processus) 1119: { 1120: struct_objet *s_objet_argument; 1121: 1122: unsigned char *tampon; 1123: 1124: (*s_etat_processus).erreur_execution = d_ex; 1125: 1126: if ((*s_etat_processus).affichage_arguments == 'Y') 1127: { 1128: printf("\n SMPHRDECR "); 1129: 1130: if ((*s_etat_processus).langue == 'F') 1131: { 1132: printf("(decrémentation du sémaphore)\n\n"); 1133: } 1134: else 1135: { 1136: printf("(semaphore decrementation)\n\n"); 1137: } 1138: 1139: printf(" 1: %s\n", d_SPH); 1140: return; 1141: } 1142: else if ((*s_etat_processus).test_instruction == 'Y') 1143: { 1144: (*s_etat_processus).nombre_arguments = -1; 1145: return; 1146: } 1147: 1148: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1149: { 1150: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 1151: { 1152: return; 1153: } 1154: } 1155: 1156: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1157: &s_objet_argument) == d_erreur) 1158: { 1159: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1160: return; 1161: } 1162: 1163: if ((*s_objet_argument).type == SPH) 1164: { 1165: if ((*s_etat_processus).profilage == d_vrai) 1166: { 1167: if ((tampon = formateur(s_etat_processus, 0, s_objet_argument)) 1168: == NULL) 1169: { 1170: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1171: return; 1172: } 1173: 1174: profilage(s_etat_processus, tampon); 1175: free(tampon); 1176: 1177: if ((*s_etat_processus).erreur_systeme != d_es) 1178: { 1179: return; 1180: } 1181: } 1182: 1183: # ifndef SEMAPHORES_NOMMES 1184: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 1185: { 1186: (*s_etat_processus).erreur_systeme = d_es_processus; 1187: return; 1188: } 1189: # else 1190: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 1191: { 1192: (*s_etat_processus).erreur_systeme = d_es_processus; 1193: return; 1194: } 1195: # endif 1196: 1197: while(sem_wait((*((struct_semaphore *) (*s_objet_argument).objet)) 1198: .semaphore) == -1) 1199: { 1200: if (errno != EINTR) 1201: { 1202: (*s_etat_processus).erreur_execution = d_ex_semaphore; 1203: 1204: if ((*s_etat_processus).profilage == d_vrai) 1205: { 1206: profilage(s_etat_processus, NULL); 1207: } 1208: 1209: liberation(s_etat_processus, s_objet_argument); 1210: return; 1211: } 1212: } 1213: 1214: # ifndef SEMAPHORES_NOMMES 1215: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 1216: # else 1217: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 1218: # endif 1219: { 1220: if (errno != EINTR) 1221: { 1222: if ((*s_etat_processus).profilage == d_vrai) 1223: { 1224: profilage(s_etat_processus, NULL); 1225: } 1226: 1227: (*s_etat_processus).erreur_systeme = d_es_processus; 1228: return; 1229: } 1230: } 1231: 1232: if ((*s_etat_processus).profilage == d_vrai) 1233: { 1234: profilage(s_etat_processus, NULL); 1235: } 1236: 1237: liberation(s_etat_processus, s_objet_argument); 1238: } 1239: else 1240: { 1241: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1242: 1243: liberation(s_etat_processus, s_objet_argument); 1244: return; 1245: } 1246: 1247: return; 1248: } 1249: 1250: 1251: /* 1252: ================================================================================ 1253: Fonction 'smphrtrydecr' 1254: ================================================================================ 1255: Entrées : 1256: -------------------------------------------------------------------------------- 1257: Sorties : 1258: -------------------------------------------------------------------------------- 1259: Effets de bord : néant 1260: ================================================================================ 1261: */ 1262: 1263: void 1264: instruction_smphrtrydecr(struct_processus *s_etat_processus) 1265: { 1266: struct_objet *s_objet_argument; 1267: struct_objet *s_objet_resultat; 1268: 1269: unsigned char *tampon; 1270: 1271: (*s_etat_processus).erreur_execution = d_ex; 1272: 1273: if ((*s_etat_processus).affichage_arguments == 'Y') 1274: { 1275: printf("\n SMPHRTRYDECR "); 1276: 1277: if ((*s_etat_processus).langue == 'F') 1278: { 1279: printf("(essai de decrémentation du sémaphore)\n\n"); 1280: } 1281: else 1282: { 1283: printf("(try to decremente semaphore)\n\n"); 1284: } 1285: 1286: printf(" 1: %s\n", d_SPH); 1287: printf("-> 1: %s\n", d_INT); 1288: return; 1289: } 1290: else if ((*s_etat_processus).test_instruction == 'Y') 1291: { 1292: (*s_etat_processus).nombre_arguments = -1; 1293: return; 1294: } 1295: 1296: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1297: { 1298: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 1299: { 1300: return; 1301: } 1302: } 1303: 1304: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1305: &s_objet_argument) == d_erreur) 1306: { 1307: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1308: return; 1309: } 1310: 1311: if ((*s_objet_argument).type == SPH) 1312: { 1313: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) 1314: { 1315: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1316: return; 1317: } 1318: 1319: if ((*s_etat_processus).profilage == d_vrai) 1320: { 1321: if ((tampon = formateur(s_etat_processus, 0, s_objet_argument)) 1322: == NULL) 1323: { 1324: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1325: return; 1326: } 1327: 1328: profilage(s_etat_processus, tampon); 1329: free(tampon); 1330: 1331: if ((*s_etat_processus).erreur_systeme != d_es) 1332: { 1333: return; 1334: } 1335: } 1336: 1337: # ifndef SEMAPHORES_NOMMES 1338: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) 1339: { 1340: (*s_etat_processus).erreur_systeme = d_es_processus; 1341: return; 1342: } 1343: # else 1344: if (sem_post((*s_etat_processus).semaphore_fork) != 0) 1345: { 1346: (*s_etat_processus).erreur_systeme = d_es_processus; 1347: return; 1348: } 1349: # endif 1350: 1351: (*((integer8 *) (*s_objet_resultat).objet)) = 0; 1352: 1353: while(sem_trywait((*((struct_semaphore *) (*s_objet_argument).objet)) 1354: .semaphore) == -1) 1355: { 1356: switch(errno) 1357: { 1358: case EINTR : 1359: { 1360: break; 1361: } 1362: 1363: case EINVAL : 1364: { 1365: (*s_etat_processus).erreur_execution = d_ex_semaphore; 1366: 1367: if ((*s_etat_processus).profilage == d_vrai) 1368: { 1369: profilage(s_etat_processus, NULL); 1370: } 1371: 1372: liberation(s_etat_processus, s_objet_argument); 1373: return; 1374: } 1375: 1376: case EAGAIN : 1377: { 1378: (*((integer8 *) (*s_objet_resultat).objet)) = -1; 1379: break; 1380: } 1381: } 1382: 1383: if ((*((integer8 *) (*s_objet_resultat).objet)) != 0) 1384: { 1385: break; 1386: } 1387: } 1388: 1389: # ifndef SEMAPHORES_NOMMES 1390: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) 1391: # else 1392: while(sem_wait((*s_etat_processus).semaphore_fork) == -1) 1393: # endif 1394: { 1395: if (errno != EINTR) 1396: { 1397: if ((*s_etat_processus).profilage == d_vrai) 1398: { 1399: profilage(s_etat_processus, NULL); 1400: } 1401: 1402: (*s_etat_processus).erreur_systeme = d_es_processus; 1403: return; 1404: } 1405: } 1406: 1407: if ((*s_etat_processus).profilage == d_vrai) 1408: { 1409: profilage(s_etat_processus, NULL); 1410: } 1411: 1412: liberation(s_etat_processus, s_objet_argument); 1413: } 1414: else 1415: { 1416: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1417: 1418: liberation(s_etat_processus, s_objet_argument); 1419: return; 1420: } 1421: 1422: return; 1423: } 1424: 1425: 1426: /* 1427: ================================================================================ 1428: Fonction 'smphrgetv' 1429: ================================================================================ 1430: Entrées : 1431: -------------------------------------------------------------------------------- 1432: Sorties : 1433: -------------------------------------------------------------------------------- 1434: Effets de bord : néant 1435: ================================================================================ 1436: */ 1437: 1438: void 1439: instruction_smphrgetv(struct_processus *s_etat_processus) 1440: { 1441: int valeur; 1442: 1443: struct_objet *s_objet_argument; 1444: struct_objet *s_objet_resultat; 1445: 1446: (*s_etat_processus).erreur_execution = d_ex; 1447: 1448: if ((*s_etat_processus).affichage_arguments == 'Y') 1449: { 1450: printf("\n SMPHRGETV "); 1451: 1452: if ((*s_etat_processus).langue == 'F') 1453: { 1454: printf("(valeur du sémaphore)\n\n"); 1455: } 1456: else 1457: { 1458: printf("(semaphore value)\n\n"); 1459: } 1460: 1461: printf(" 1: %s\n", d_SPH); 1462: return; 1463: } 1464: else if ((*s_etat_processus).test_instruction == 'Y') 1465: { 1466: (*s_etat_processus).nombre_arguments = -1; 1467: return; 1468: } 1469: 1470: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1471: { 1472: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 1473: { 1474: return; 1475: } 1476: } 1477: 1478: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1479: &s_objet_argument) == d_erreur) 1480: { 1481: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1482: return; 1483: } 1484: 1485: if ((*s_objet_argument).type == SPH) 1486: { 1487: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) 1488: { 1489: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1490: 1491: liberation(s_etat_processus, s_objet_argument); 1492: return; 1493: } 1494: 1495: if (sem_getvalue((*((struct_semaphore *) (*s_objet_argument).objet)) 1496: .semaphore, &valeur) != 0) 1497: { 1498: (*s_etat_processus).erreur_execution = d_ex_semaphore; 1499: 1500: liberation(s_etat_processus, s_objet_argument); 1501: return; 1502: } 1503: 1504: (*((integer8 *) (*s_objet_resultat).objet)) = valeur; 1505: 1506: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1507: s_objet_resultat) == d_erreur) 1508: { 1509: return; 1510: } 1511: 1512: liberation(s_etat_processus, s_objet_argument); 1513: } 1514: else 1515: { 1516: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1517: 1518: liberation(s_etat_processus, s_objet_argument); 1519: return; 1520: } 1521: 1522: return; 1523: } 1524: 1525: 1526: /* 1527: ================================================================================ 1528: Fonction 'svl' 1529: ================================================================================ 1530: Entrées : 1531: -------------------------------------------------------------------------------- 1532: Sorties : 1533: -------------------------------------------------------------------------------- 1534: Effets de bord : néant 1535: ================================================================================ 1536: */ 1537: 1538: void 1539: instruction_svl(struct_processus *s_etat_processus) 1540: { 1541: struct_objet *s_objet_argument; 1542: struct_objet *s_objet_resultat; 1543: 1544: (*s_etat_processus).erreur_execution = d_ex; 1545: 1546: if ((*s_etat_processus).affichage_arguments == 'Y') 1547: { 1548: printf("\n SVL "); 1549: 1550: if ((*s_etat_processus).langue == 'F') 1551: { 1552: printf("(valeurs singulières)\n\n"); 1553: } 1554: else 1555: { 1556: printf("(singular values)\n\n"); 1557: } 1558: 1559: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX); 1560: printf("-> 1: %s\n", d_VRL); 1561: return; 1562: } 1563: else if ((*s_etat_processus).test_instruction == 'Y') 1564: { 1565: (*s_etat_processus).nombre_arguments = -1; 1566: return; 1567: } 1568: 1569: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1570: { 1571: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 1572: { 1573: return; 1574: } 1575: } 1576: 1577: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1578: &s_objet_argument) == d_erreur) 1579: { 1580: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1581: return; 1582: } 1583: 1584: if (((*s_objet_argument).type == MIN) || 1585: ((*s_objet_argument).type == MRL) || 1586: ((*s_objet_argument).type == MCX)) 1587: { 1588: if ((s_objet_resultat = allocation(s_etat_processus, VRL)) == NULL) 1589: { 1590: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1591: return; 1592: } 1593: 1594: valeurs_singulieres(s_etat_processus, (*s_objet_argument).objet, 1595: NULL, (*s_objet_resultat).objet, NULL); 1596: 1597: if ((*s_etat_processus).erreur_systeme != d_es) 1598: { 1599: return; 1600: } 1601: 1602: if (((*s_etat_processus).erreur_execution != d_ex) || 1603: ((*s_etat_processus).exception != d_ep)) 1604: { 1605: liberation(s_etat_processus, s_objet_resultat); 1606: liberation(s_etat_processus, s_objet_argument); 1607: return; 1608: } 1609: 1610: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1611: s_objet_resultat) == d_erreur) 1612: { 1613: return; 1614: } 1615: } 1616: else 1617: { 1618: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1619: 1620: liberation(s_etat_processus, s_objet_argument); 1621: return; 1622: } 1623: 1624: liberation(s_etat_processus, s_objet_argument); 1625: 1626: return; 1627: } 1628: 1629: 1630: /* 1631: ================================================================================ 1632: Fonction 'svd' 1633: ================================================================================ 1634: Entrées : 1635: -------------------------------------------------------------------------------- 1636: Sorties : 1637: -------------------------------------------------------------------------------- 1638: Effets de bord : néant 1639: ================================================================================ 1640: */ 1641: 1642: void 1643: instruction_svd(struct_processus *s_etat_processus) 1644: { 1645: struct_objet *s_objet_argument; 1646: struct_objet *s_objet_resultat_1; 1647: struct_objet *s_objet_resultat_2; 1648: struct_objet *s_objet_resultat_3; 1649: 1650: struct_vecteur s_vecteur; 1651: 1652: unsigned long i; 1653: unsigned long j; 1654: 1655: (*s_etat_processus).erreur_execution = d_ex; 1656: 1657: if ((*s_etat_processus).affichage_arguments == 'Y') 1658: { 1659: printf("\n SVD "); 1660: 1661: if ((*s_etat_processus).langue == 'F') 1662: { 1663: printf("(décomposition en valeurs singulières)\n\n"); 1664: } 1665: else 1666: { 1667: printf("(singular value decomposition)\n\n"); 1668: } 1669: 1670: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX); 1671: printf("-> 3: %s, %s\n", d_MRL, d_MCX); 1672: printf(" 2: %s, %s\n", d_MRL, d_MCX); 1673: printf(" 1: %s\n", d_VRL); 1674: return; 1675: } 1676: else if ((*s_etat_processus).test_instruction == 'Y') 1677: { 1678: (*s_etat_processus).nombre_arguments = -1; 1679: return; 1680: } 1681: 1682: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1683: { 1684: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 1685: { 1686: return; 1687: } 1688: } 1689: 1690: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1691: &s_objet_argument) == d_erreur) 1692: { 1693: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1694: return; 1695: } 1696: 1697: if (((*s_objet_argument).type == MIN) || 1698: ((*s_objet_argument).type == MRL)) 1699: { 1700: if ((s_objet_resultat_1 = allocation(s_etat_processus, MRL)) == NULL) 1701: { 1702: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1703: return; 1704: } 1705: 1706: if ((s_objet_resultat_2 = allocation(s_etat_processus, MRL)) == NULL) 1707: { 1708: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1709: return; 1710: } 1711: 1712: if ((s_objet_resultat_3 = allocation(s_etat_processus, MRL)) == NULL) 1713: { 1714: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1715: return; 1716: } 1717: 1718: valeurs_singulieres(s_etat_processus, (*s_objet_argument).objet, 1719: (*s_objet_resultat_3).objet, &s_vecteur, 1720: (*s_objet_resultat_1).objet); 1721: 1722: if ((*s_etat_processus).erreur_systeme != d_es) 1723: { 1724: return; 1725: } 1726: 1727: if (((*s_etat_processus).erreur_execution != d_ex) || 1728: ((*s_etat_processus).exception != d_ep)) 1729: { 1730: liberation(s_etat_processus, s_objet_resultat_1); 1731: liberation(s_etat_processus, s_objet_resultat_2); 1732: liberation(s_etat_processus, s_objet_resultat_3); 1733: liberation(s_etat_processus, s_objet_argument); 1734: return; 1735: } 1736: 1737: (*((struct_matrice *) (*s_objet_resultat_2).objet)).nombre_colonnes = 1738: (*((struct_matrice *) (*s_objet_argument).objet)) 1739: .nombre_colonnes; 1740: (*((struct_matrice *) (*s_objet_resultat_2).objet)).nombre_lignes = 1741: (*((struct_matrice *) (*s_objet_argument).objet)) 1742: .nombre_lignes; 1743: 1744: if (((*((struct_matrice *) (*s_objet_resultat_2).objet)).tableau = 1745: malloc((*((struct_matrice *) (*s_objet_resultat_2).objet)) 1746: .nombre_lignes * sizeof(real8 *))) == NULL) 1747: { 1748: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1749: return; 1750: } 1751: 1752: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat_2).objet)) 1753: .nombre_lignes; i++) 1754: { 1755: if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat_2) 1756: .objet)).tableau)[i] = malloc((*((struct_matrice *) 1757: (*s_objet_resultat_2).objet)).nombre_colonnes * 1758: sizeof(real8 *))) == NULL) 1759: { 1760: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1761: return; 1762: } 1763: 1764: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat_2).objet)) 1765: .nombre_colonnes; j++) 1766: { 1767: ((real8 **) (*((struct_matrice *) (*s_objet_resultat_2) 1768: .objet)).tableau)[i][j] = 0; 1769: } 1770: } 1771: 1772: for(i = 0; i < s_vecteur.taille; i++) 1773: { 1774: ((real8 **) (*((struct_matrice *) (*s_objet_resultat_2).objet)) 1775: .tableau)[i][i] = ((real8 *) (s_vecteur.tableau))[i]; 1776: } 1777: 1778: free(s_vecteur.tableau); 1779: 1780: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1781: s_objet_resultat_3) == d_erreur) 1782: { 1783: return; 1784: } 1785: 1786: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1787: s_objet_resultat_2) == d_erreur) 1788: { 1789: return; 1790: } 1791: 1792: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1793: s_objet_resultat_1) == d_erreur) 1794: { 1795: return; 1796: } 1797: } 1798: else if ((*s_objet_argument).type == MCX) 1799: { 1800: if ((s_objet_resultat_1 = allocation(s_etat_processus, MCX)) == NULL) 1801: { 1802: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1803: return; 1804: } 1805: 1806: if ((s_objet_resultat_2 = allocation(s_etat_processus, MRL)) == NULL) 1807: { 1808: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1809: return; 1810: } 1811: 1812: if ((s_objet_resultat_3 = allocation(s_etat_processus, MCX)) == NULL) 1813: { 1814: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1815: return; 1816: } 1817: 1818: valeurs_singulieres(s_etat_processus, (*s_objet_argument).objet, 1819: (*s_objet_resultat_3).objet, &s_vecteur, 1820: (*s_objet_resultat_1).objet); 1821: 1822: if ((*s_etat_processus).erreur_systeme != d_es) 1823: { 1824: return; 1825: } 1826: 1827: if (((*s_etat_processus).erreur_execution != d_ex) || 1828: ((*s_etat_processus).exception != d_ep)) 1829: { 1830: liberation(s_etat_processus, s_objet_resultat_1); 1831: liberation(s_etat_processus, s_objet_resultat_2); 1832: liberation(s_etat_processus, s_objet_resultat_3); 1833: liberation(s_etat_processus, s_objet_argument); 1834: return; 1835: } 1836: 1837: (*((struct_matrice *) (*s_objet_resultat_2).objet)).nombre_colonnes = 1838: (*((struct_matrice *) (*s_objet_argument).objet)) 1839: .nombre_colonnes; 1840: (*((struct_matrice *) (*s_objet_resultat_2).objet)).nombre_lignes = 1841: (*((struct_matrice *) (*s_objet_argument).objet)) 1842: .nombre_lignes; 1843: 1844: if (((*((struct_matrice *) (*s_objet_resultat_2).objet)).tableau = 1845: malloc((*((struct_matrice *) (*s_objet_resultat_2).objet)) 1846: .nombre_lignes * sizeof(real8 *))) == NULL) 1847: { 1848: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1849: return; 1850: } 1851: 1852: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat_2).objet)) 1853: .nombre_lignes; i++) 1854: { 1855: if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat_2) 1856: .objet)).tableau)[i] = malloc((*((struct_matrice *) 1857: (*s_objet_resultat_2).objet)).nombre_colonnes * 1858: sizeof(real8 *))) == NULL) 1859: { 1860: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1861: return; 1862: } 1863: 1864: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat_2).objet)) 1865: .nombre_colonnes; j++) 1866: { 1867: ((real8 **) (*((struct_matrice *) (*s_objet_resultat_2) 1868: .objet)).tableau)[i][j] = 0; 1869: } 1870: } 1871: 1872: for(i = 0; i < s_vecteur.taille; i++) 1873: { 1874: ((real8 **) (*((struct_matrice *) (*s_objet_resultat_2).objet)) 1875: .tableau)[i][i] = ((real8 *) (s_vecteur.tableau))[i]; 1876: } 1877: 1878: free(s_vecteur.tableau); 1879: 1880: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1881: s_objet_resultat_3) == d_erreur) 1882: { 1883: return; 1884: } 1885: 1886: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1887: s_objet_resultat_2) == d_erreur) 1888: { 1889: return; 1890: } 1891: 1892: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1893: s_objet_resultat_1) == d_erreur) 1894: { 1895: return; 1896: } 1897: } 1898: else 1899: { 1900: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1901: 1902: liberation(s_etat_processus, s_objet_argument); 1903: return; 1904: } 1905: 1906: liberation(s_etat_processus, s_objet_argument); 1907: return; 1908: } 1909: 1910: 1911: /* 1912: ================================================================================ 1913: Fonction 'swapcntxt' 1914: ================================================================================ 1915: Entrées : 1916: -------------------------------------------------------------------------------- 1917: Sorties : 1918: -------------------------------------------------------------------------------- 1919: Effets de bord : néant 1920: ================================================================================ 1921: */ 1922: 1923: void 1924: instruction_swapcntxt(struct_processus *s_etat_processus) 1925: { 1926: integer8 i; 1927: integer8 registre_taille; 1928: 1929: struct_liste_chainee *l_element_courant; 1930: struct_liste_chainee *l_element_courant_taille; 1931: struct_liste_chainee *registre; 1932: 1933: struct_objet *s_objet_argument; 1934: 1935: (*s_etat_processus).erreur_execution = d_ex; 1936: 1937: if ((*s_etat_processus).affichage_arguments == 'Y') 1938: { 1939: printf("\n SWAPCNTXT "); 1940: 1941: if ((*s_etat_processus).langue == 'F') 1942: { 1943: printf("(échange de contextes)\n\n"); 1944: } 1945: else 1946: { 1947: printf("(swap contexts)\n\n"); 1948: } 1949: 1950: printf(" 1: %s\n", d_INT); 1951: return; 1952: } 1953: else if ((*s_etat_processus).test_instruction == 'Y') 1954: { 1955: (*s_etat_processus).nombre_arguments = -1; 1956: return; 1957: } 1958: 1959: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1960: { 1961: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 1962: { 1963: return; 1964: } 1965: } 1966: 1967: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1968: &s_objet_argument) == d_erreur) 1969: { 1970: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1971: return; 1972: } 1973: 1974: if ((*s_objet_argument).type == INT) 1975: { 1976: l_element_courant = (*s_etat_processus).l_base_pile_contextes; 1977: l_element_courant_taille = (*s_etat_processus) 1978: .l_base_pile_taille_contextes; 1979: 1980: i = (*((integer8 *) (*s_objet_argument).objet)); 1981: 1982: while((l_element_courant != NULL) && (l_element_courant_taille != NULL)) 1983: { 1984: i--; 1985: 1986: if (i == 0) 1987: { 1988: break; 1989: } 1990: 1991: l_element_courant = (*l_element_courant).suivant; 1992: l_element_courant_taille = (*l_element_courant_taille).suivant; 1993: } 1994: 1995: if ((l_element_courant == NULL) || (l_element_courant_taille == NULL)) 1996: { 1997: liberation(s_etat_processus, s_objet_argument); 1998: 1999: (*s_etat_processus).erreur_execution = d_ex_contexte; 2000: return; 2001: } 2002: 2003: if ((*(*l_element_courant).donnee).type != LST) 2004: { 2005: (*s_etat_processus).erreur_systeme = d_es_contexte; 2006: return; 2007: } 2008: 2009: if ((*(*l_element_courant_taille).donnee).type != INT) 2010: { 2011: (*s_etat_processus).erreur_systeme = d_es_contexte; 2012: return; 2013: } 2014: 2015: registre = (*s_etat_processus).l_base_pile; 2016: registre_taille = (*s_etat_processus).hauteur_pile_operationnelle; 2017: 2018: (*s_etat_processus).l_base_pile = (*(*l_element_courant).donnee).objet; 2019: (*s_etat_processus).hauteur_pile_operationnelle = 2020: (*((integer8 *) (*(*l_element_courant_taille).donnee).objet)); 2021: 2022: (*(*l_element_courant).donnee).objet = registre; 2023: (*((integer8 *) (*(*l_element_courant_taille).donnee).objet)) = 2024: registre_taille; 2025: } 2026: else 2027: { 2028: liberation(s_etat_processus, s_objet_argument); 2029: 2030: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 2031: return; 2032: } 2033: 2034: liberation(s_etat_processus, s_objet_argument); 2035: } 2036: 2037: // vim: ts=4