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