Annotation of rpl/src/instructions_s9.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 'sort'
! 29: ================================================================================
! 30: Entrées :
! 31: --------------------------------------------------------------------------------
! 32: Sorties :
! 33: --------------------------------------------------------------------------------
! 34: Effets de bord : néant
! 35: ================================================================================
! 36: */
! 37:
! 38: void
! 39: instruction_sort(struct_processus *s_etat_processus)
! 40: {
! 41: integer8 i;
! 42: integer8 j;
! 43: integer8 nombre_elements;
! 44:
! 45: logical1 condition;
! 46: logical1 inversion;
! 47: logical1 presence_nom;
! 48: logical1 terminaison_boucle_1;
! 49: logical1 terminaison_boucle_2;
! 50: logical1 terminaison_boucle_3;
! 51: logical1 variable_partagee;
! 52:
! 53: struct_liste_chainee *l_element_courant;
! 54: struct_liste_chainee *l_element_precedent;
! 55: struct_liste_chainee *l_element_tampon;
! 56:
! 57: struct_objet *s_objet_copie;
! 58: struct_objet *s_objet_critere;
! 59: struct_objet *s_objet_liste;
! 60: struct_objet *s_objet_test;
! 61:
! 62: signed long indice_i;
! 63: signed long indice_j;
! 64: signed long indice_k;
! 65: signed long indice_l;
! 66:
! 67: unsigned long ecartement;
! 68:
! 69: (*s_etat_processus).erreur_execution = d_ex;
! 70:
! 71: if ((*s_etat_processus).affichage_arguments == 'Y')
! 72: {
! 73: printf("\n SORT ");
! 74:
! 75: if ((*s_etat_processus).langue == 'F')
! 76: {
! 77: printf("(trie une liste selon un critère paramétrable)\n\n");
! 78: }
! 79: else
! 80: {
! 81: printf("(sort a list)\n\n");
! 82: }
! 83:
! 84: printf(" 2: %s\n", d_LST);
! 85: printf(" 1: %s\n", d_RPN);
! 86: printf("-> 1: %s\n\n", d_LST);
! 87:
! 88: printf(" 2: %s\n", d_TAB);
! 89: printf(" 1: %s\n", d_RPN);
! 90: printf("-> 1: %s\n\n", d_LST);
! 91:
! 92: printf(" 2: %s\n", d_NOM);
! 93: printf(" 1: %s\n", d_RPN);
! 94:
! 95: return;
! 96: }
! 97: else if ((*s_etat_processus).test_instruction == 'Y')
! 98: {
! 99: (*s_etat_processus).nombre_arguments = -1;
! 100: return;
! 101: }
! 102:
! 103: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 104: {
! 105: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
! 106: {
! 107: return;
! 108: }
! 109: }
! 110:
! 111: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 112: &s_objet_critere) == d_erreur)
! 113: {
! 114: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 115: return;
! 116: }
! 117:
! 118: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 119: &s_objet_liste) == d_erreur)
! 120: {
! 121: liberation(s_etat_processus, s_objet_critere);
! 122:
! 123: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 124: return;
! 125: }
! 126:
! 127: variable_partagee = d_faux;
! 128:
! 129: if ((*s_objet_liste).type == NOM)
! 130: {
! 131: if (recherche_variable(s_etat_processus, (*((struct_nom *)
! 132: (*s_objet_liste).objet)).nom) == d_faux)
! 133: {
! 134: (*s_etat_processus).erreur_systeme = d_es;
! 135: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
! 136:
! 137: liberation(s_etat_processus, s_objet_critere);
! 138: liberation(s_etat_processus, s_objet_liste);
! 139:
! 140: return;
! 141: }
! 142:
! 143: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
! 144: .position_variable_courante].variable_verrouillee == d_vrai)
! 145: {
! 146: (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
! 147:
! 148: liberation(s_etat_processus, s_objet_critere);
! 149: liberation(s_etat_processus, s_objet_liste);
! 150:
! 151: return;
! 152: }
! 153:
! 154: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
! 155: .position_variable_courante].objet == NULL)
! 156: {
! 157: if (pthread_mutex_lock(&((*(*s_etat_processus)
! 158: .s_liste_variables_partagees).mutex)) != 0)
! 159: {
! 160: (*s_etat_processus).erreur_systeme = d_es_processus;
! 161: return;
! 162: }
! 163:
! 164: if (recherche_variable_partagee(s_etat_processus,
! 165: (*s_etat_processus).s_liste_variables
! 166: [(*s_etat_processus).position_variable_courante].nom,
! 167: (*s_etat_processus).s_liste_variables
! 168: [(*s_etat_processus).position_variable_courante]
! 169: .variable_partagee, (*s_etat_processus).s_liste_variables
! 170: [(*s_etat_processus).position_variable_courante].origine)
! 171: == d_faux)
! 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: (*s_etat_processus).erreur_execution =
! 181: d_ex_erreur_type_argument;
! 182:
! 183: liberation(s_etat_processus, s_objet_critere);
! 184: liberation(s_etat_processus, s_objet_liste);
! 185:
! 186: return;
! 187: }
! 188:
! 189: if ((*(*(*s_etat_processus).s_liste_variables_partagees)
! 190: .table[(*(*s_etat_processus).s_liste_variables_partagees)
! 191: .position_variable].objet).type != LST)
! 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_execution =
! 201: d_ex_erreur_type_argument;
! 202:
! 203: liberation(s_etat_processus, s_objet_critere);
! 204: liberation(s_etat_processus, s_objet_liste);
! 205:
! 206: return;
! 207: }
! 208:
! 209: liberation(s_etat_processus, s_objet_liste);
! 210:
! 211: s_objet_liste = (*(*s_etat_processus).s_liste_variables_partagees)
! 212: .table[(*(*s_etat_processus).s_liste_variables_partagees)
! 213: .position_variable].objet;
! 214:
! 215: if ((s_objet_copie = copie_objet(s_etat_processus, s_objet_liste,
! 216: 'N')) == NULL)
! 217: {
! 218: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 219: .s_liste_variables_partagees).mutex)) != 0)
! 220: {
! 221: (*s_etat_processus).erreur_systeme = d_es_processus;
! 222: return;
! 223: }
! 224:
! 225: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 226: return;
! 227: }
! 228:
! 229: variable_partagee = d_vrai;
! 230: }
! 231: else
! 232: {
! 233: if ((*(*s_etat_processus).s_liste_variables
! 234: [(*s_etat_processus).position_variable_courante].objet)
! 235: .type != LST)
! 236: {
! 237: (*s_etat_processus).erreur_execution =
! 238: d_ex_erreur_type_argument;
! 239:
! 240: liberation(s_etat_processus, s_objet_critere);
! 241: liberation(s_etat_processus, s_objet_liste);
! 242:
! 243: return;
! 244: }
! 245:
! 246: liberation(s_etat_processus, s_objet_liste);
! 247:
! 248: s_objet_liste = (*s_etat_processus).s_liste_variables
! 249: [(*s_etat_processus).position_variable_courante].objet;
! 250:
! 251: if ((s_objet_copie = copie_objet(s_etat_processus, s_objet_liste,
! 252: 'N')) == NULL)
! 253: {
! 254: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 255: return;
! 256: }
! 257: }
! 258:
! 259: liberation(s_etat_processus, s_objet_liste);
! 260: s_objet_liste = s_objet_copie;
! 261:
! 262: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
! 263: .position_variable_courante].objet = s_objet_liste;
! 264:
! 265: presence_nom = d_vrai;
! 266: }
! 267: else
! 268: {
! 269: if ((s_objet_copie = copie_objet(s_etat_processus, s_objet_liste, 'N'))
! 270: == NULL)
! 271: {
! 272: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 273: return;
! 274: }
! 275:
! 276: liberation(s_etat_processus, s_objet_liste);
! 277: s_objet_liste = s_objet_copie;
! 278: presence_nom = d_faux;
! 279: }
! 280:
! 281: if (((*s_objet_liste).type == LST) &&
! 282: ((*s_objet_critere).type == RPN))
! 283: {
! 284: /*
! 285: * Tri bulle de la liste chaînée. On se contente d'un tri bulle
! 286: * car on travaille sur une liste chaînée et non sur un tableau
! 287: * sur lequel on pourrait accéder directement aux données grâce à
! 288: * leur indice.
! 289: */
! 290:
! 291: nombre_elements = 0;
! 292: l_element_courant = (*s_objet_liste).objet;
! 293:
! 294: while(l_element_courant != NULL)
! 295: {
! 296: l_element_courant = (*l_element_courant).suivant;
! 297: nombre_elements++;
! 298: }
! 299:
! 300: // Si la liste est vide, on considère qu'elle est triée.
! 301: // De la même manière, on considère qu'une liste d'un
! 302: // seul élément est toujours triée.
! 303:
! 304: if (nombre_elements > 1)
! 305: {
! 306: j = nombre_elements;
! 307:
! 308: do
! 309: {
! 310: inversion = d_faux;
! 311:
! 312: l_element_courant = (*s_objet_liste).objet;
! 313: l_element_precedent = NULL;
! 314:
! 315: for(i = 0; i < j - 1; i++)
! 316: {
! 317: // Test des éléments adjacents. Pour cela, on
! 318: // empile les deux éléments adjacents dans la pile dans
! 319: // l'ordre [i] [i+1] et on évalue le critère d'ordre.
! 320:
! 321: if ((s_objet_copie = copie_objet(s_etat_processus,
! 322: (*l_element_courant).donnee, 'P')) == NULL)
! 323: {
! 324: (*s_etat_processus).erreur_systeme =
! 325: d_es_allocation_memoire;
! 326: return;
! 327: }
! 328:
! 329: if (empilement(s_etat_processus,
! 330: &((*s_etat_processus).l_base_pile),
! 331: s_objet_copie) == d_erreur)
! 332: {
! 333: return;
! 334: }
! 335:
! 336: if ((s_objet_copie = copie_objet(s_etat_processus,
! 337: (*(*l_element_courant)
! 338: .suivant).donnee, 'P')) == NULL)
! 339: {
! 340: (*s_etat_processus).erreur_systeme =
! 341: d_es_allocation_memoire;
! 342: return;
! 343: }
! 344:
! 345: if (empilement(s_etat_processus,
! 346: &((*s_etat_processus).l_base_pile),
! 347: s_objet_copie) == d_erreur)
! 348: {
! 349: return;
! 350: }
! 351:
! 352: if (evaluation(s_etat_processus, s_objet_critere, 'N')
! 353: == d_erreur)
! 354: {
! 355: liberation(s_etat_processus, s_objet_critere);
! 356: liberation(s_etat_processus, s_objet_liste);
! 357:
! 358: return;
! 359: }
! 360:
! 361: if (depilement(s_etat_processus,
! 362: &((*s_etat_processus).l_base_pile), &s_objet_test)
! 363: == d_erreur)
! 364: {
! 365: liberation(s_etat_processus, s_objet_critere);
! 366: liberation(s_etat_processus, s_objet_liste);
! 367:
! 368: (*s_etat_processus).erreur_execution =
! 369: d_ex_manque_argument;
! 370: return;
! 371: }
! 372:
! 373: if ((*s_objet_test).type == INT)
! 374: {
! 375: condition = ((*((integer8 *) (*s_objet_test).objet))
! 376: == 0) ? d_faux : d_vrai;
! 377: }
! 378: else if ((*s_objet_test).type == REL)
! 379: {
! 380: condition = ((*((real8 *) (*s_objet_test).objet))
! 381: == 0) ? d_faux : d_vrai;
! 382: }
! 383: else
! 384: {
! 385: liberation(s_etat_processus, s_objet_critere);
! 386: liberation(s_etat_processus, s_objet_liste);
! 387: liberation(s_etat_processus, s_objet_test);
! 388:
! 389: (*s_etat_processus).erreur_execution =
! 390: d_ex_erreur_type_argument;
! 391: return;
! 392: }
! 393:
! 394: liberation(s_etat_processus, s_objet_test);
! 395:
! 396: if (condition == d_faux)
! 397: {
! 398: // On échange les deux éléments adjacents
! 399:
! 400: inversion = d_vrai;
! 401:
! 402: if (l_element_precedent == NULL)
! 403: {
! 404: // Échange des deux premiers éléments
! 405: // de la liste.
! 406:
! 407: l_element_tampon = (*(*l_element_courant)
! 408: .suivant).suivant;
! 409: (*s_objet_liste).objet = (*l_element_courant)
! 410: .suivant;
! 411: (*((struct_liste_chainee *) (*s_objet_liste)
! 412: .objet)).suivant = l_element_courant;
! 413: (*l_element_courant).suivant =
! 414: l_element_tampon;
! 415: l_element_courant = (*s_objet_liste).objet;
! 416: }
! 417: else
! 418: {
! 419: // Échange de deux éléments quelconques de la
! 420: // liste.
! 421:
! 422: l_element_tampon = (*l_element_courant).suivant;
! 423: (*l_element_courant).suivant =
! 424: (*(*l_element_courant).suivant).suivant;
! 425: (*l_element_precedent).suivant = l_element_tampon;
! 426: (*l_element_tampon).suivant = l_element_courant;
! 427:
! 428: l_element_courant = l_element_tampon;
! 429: }
! 430: }
! 431:
! 432: l_element_precedent = l_element_courant;
! 433: l_element_courant = (*l_element_courant).suivant;
! 434: }
! 435:
! 436: j--;
! 437: } while(inversion != d_faux);
! 438: }
! 439: }
! 440: else if (((*s_objet_liste).type == TBL) &&
! 441: ((*s_objet_critere).type == RPN))
! 442: {
! 443: /*
! 444: * Tri Shell-Metzner d'une table
! 445: */
! 446:
! 447: ecartement = (*((struct_tableau *) (*s_objet_liste).objet))
! 448: .nombre_elements;
! 449: terminaison_boucle_1 = d_faux;
! 450:
! 451: do
! 452: {
! 453: ecartement = ecartement / 2;
! 454:
! 455: if (ecartement >= 1)
! 456: {
! 457: indice_j = 0;
! 458: indice_k = (*((struct_tableau *) (*s_objet_liste).objet))
! 459: .nombre_elements - ecartement;
! 460:
! 461: terminaison_boucle_2 = d_faux;
! 462:
! 463: do
! 464: {
! 465: indice_i = indice_j;
! 466: terminaison_boucle_3 = d_faux;
! 467:
! 468: do
! 469: {
! 470: indice_l = indice_i + ecartement;
! 471:
! 472: if ((indice_i > 0) && (indice_l > 0))
! 473: {
! 474: if ((s_objet_copie = copie_objet(s_etat_processus,
! 475: (*((struct_tableau *) (*s_objet_liste)
! 476: .objet)).elements[indice_i - 1], 'P'))
! 477: == NULL)
! 478: {
! 479: (*s_etat_processus).erreur_systeme =
! 480: d_es_allocation_memoire;
! 481: return;
! 482: }
! 483:
! 484: if (empilement(s_etat_processus,
! 485: &((*s_etat_processus).l_base_pile),
! 486: s_objet_copie) == d_erreur)
! 487: {
! 488: return;
! 489: }
! 490:
! 491: if ((s_objet_copie = copie_objet(s_etat_processus,
! 492: (*((struct_tableau *) (*s_objet_liste)
! 493: .objet)).elements[indice_l - 1], 'P'))
! 494: == NULL)
! 495: {
! 496: (*s_etat_processus).erreur_systeme =
! 497: d_es_allocation_memoire;
! 498: return;
! 499: }
! 500:
! 501: if (empilement(s_etat_processus,
! 502: &((*s_etat_processus).l_base_pile),
! 503: s_objet_copie) == d_erreur)
! 504: {
! 505: return;
! 506: }
! 507:
! 508: if (evaluation(s_etat_processus, s_objet_critere,
! 509: 'N') == d_erreur)
! 510: {
! 511: liberation(s_etat_processus, s_objet_critere);
! 512: liberation(s_etat_processus, s_objet_liste);
! 513:
! 514: return;
! 515: }
! 516:
! 517: if (depilement(s_etat_processus,
! 518: &((*s_etat_processus).l_base_pile),
! 519: &s_objet_test) == d_erreur)
! 520: {
! 521: liberation(s_etat_processus, s_objet_critere);
! 522: liberation(s_etat_processus, s_objet_liste);
! 523:
! 524: (*s_etat_processus).erreur_execution =
! 525: d_ex_manque_argument;
! 526: return;
! 527: }
! 528:
! 529: if ((*s_objet_test).type == INT)
! 530: {
! 531: condition = ((*((integer8 *) (*s_objet_test)
! 532: .objet)) == 0) ? d_faux : d_vrai;
! 533: }
! 534: else if ((*s_objet_test).type == REL)
! 535: {
! 536: condition = ((*((real8 *) (*s_objet_test)
! 537: .objet)) == 0) ? d_faux : d_vrai;
! 538: }
! 539: else
! 540: {
! 541: liberation(s_etat_processus, s_objet_critere);
! 542: liberation(s_etat_processus, s_objet_liste);
! 543: liberation(s_etat_processus, s_objet_test);
! 544:
! 545: (*s_etat_processus).erreur_execution =
! 546: d_ex_erreur_type_argument;
! 547: return;
! 548: }
! 549:
! 550: liberation(s_etat_processus, s_objet_test);
! 551:
! 552: if (condition == d_faux)
! 553: {
! 554: swap((void *) (*((struct_tableau *)
! 555: (*s_objet_liste).objet)).elements
! 556: [indice_i - 1], (void *)
! 557: (*((struct_tableau *) (*s_objet_liste)
! 558: .objet)).elements[indice_l - 1],
! 559: sizeof(struct_objet));
! 560:
! 561: indice_i -= ecartement;
! 562:
! 563: if (indice_i < 1)
! 564: {
! 565: terminaison_boucle_3 = d_vrai;
! 566: }
! 567: }
! 568: else
! 569: {
! 570: terminaison_boucle_3 = d_vrai;
! 571: }
! 572: }
! 573: else
! 574: {
! 575: terminaison_boucle_3 = d_vrai;
! 576: }
! 577: } while(terminaison_boucle_3 == d_faux);
! 578:
! 579: indice_j++;
! 580:
! 581: if (indice_j > indice_k)
! 582: {
! 583: terminaison_boucle_2 = d_vrai;
! 584: }
! 585: } while(terminaison_boucle_2 == d_faux);
! 586: }
! 587: else
! 588: {
! 589: terminaison_boucle_1 = d_vrai;
! 590: }
! 591: } while(terminaison_boucle_1 == d_faux);
! 592: }
! 593: else
! 594: {
! 595: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 596: .s_liste_variables_partagees).mutex)) != 0)
! 597: {
! 598: (*s_etat_processus).erreur_systeme = d_es_processus;
! 599: return;
! 600: }
! 601:
! 602: liberation(s_etat_processus, s_objet_liste);
! 603: liberation(s_etat_processus, s_objet_critere);
! 604:
! 605: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 606: return;
! 607: }
! 608:
! 609: if (presence_nom == d_faux)
! 610: {
! 611: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 612: s_objet_liste) == d_erreur)
! 613: {
! 614: return;
! 615: }
! 616: }
! 617: else
! 618: {
! 619: if (variable_partagee == d_vrai)
! 620: {
! 621: (*(*s_etat_processus).s_liste_variables_partagees)
! 622: .table[(*(*s_etat_processus).s_liste_variables_partagees)
! 623: .position_variable].objet = s_objet_liste;
! 624:
! 625: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 626: .s_liste_variables_partagees).mutex)) != 0)
! 627: {
! 628: (*s_etat_processus).erreur_systeme = d_es_processus;
! 629: return;
! 630: }
! 631: }
! 632: }
! 633:
! 634: liberation(s_etat_processus, s_objet_critere);
! 635:
! 636: return;
! 637: }
! 638:
! 639:
! 640: /*
! 641: ================================================================================
! 642: Fonction 'save'
! 643: ================================================================================
! 644: Entrées : structure processus
! 645: --------------------------------------------------------------------------------
! 646: Sorties :
! 647: --------------------------------------------------------------------------------
! 648: Effets de bord : néant
! 649: ================================================================================
! 650: */
! 651:
! 652: void
! 653: instruction_save(struct_processus *s_etat_processus)
! 654: {
! 655: logical1 presence_variable;
! 656:
! 657: long i;
! 658:
! 659: struct_objet *s_objet_1;
! 660: struct_objet *s_objet_2;
! 661:
! 662: struct_variable s_variable;
! 663:
! 664: (*s_etat_processus).erreur_execution = d_ex;
! 665:
! 666: if ((*s_etat_processus).affichage_arguments == 'Y')
! 667: {
! 668: printf("\n SAVE ");
! 669:
! 670: if ((*s_etat_processus).langue == 'F')
! 671: {
! 672: printf("(affecte un objet à une variable globale)\n\n");
! 673: }
! 674: else
! 675: {
! 676: printf("(store an object in a global variable)\n\n");
! 677: }
! 678:
! 679: printf(" 2: %s, %s, %s, %s, %s, %s,\n"
! 680: " %s, %s, %s, %s, %s,\n"
! 681: " %s, %s, %s, %s, %s,\n"
! 682: " %s, %s, %s, %s,\n"
! 683: " %s, %s\n",
! 684: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
! 685: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
! 686: d_SQL, d_SLB, d_PRC, d_MTX);
! 687: printf(" 1: %s\n", d_NOM);
! 688:
! 689: return;
! 690: }
! 691: else if ((*s_etat_processus).test_instruction == 'Y')
! 692: {
! 693: (*s_etat_processus).nombre_arguments = -1;
! 694: return;
! 695: }
! 696:
! 697: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 698: {
! 699: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
! 700: {
! 701: return;
! 702: }
! 703: }
! 704:
! 705: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 706: &s_objet_1) == d_erreur)
! 707: {
! 708: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 709: return;
! 710: }
! 711:
! 712: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 713: &s_objet_2) == d_erreur)
! 714: {
! 715: liberation(s_etat_processus, s_objet_1);
! 716:
! 717: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 718: return;
! 719: }
! 720:
! 721: if ((*s_objet_1).type != NOM)
! 722: {
! 723: liberation(s_etat_processus, s_objet_1);
! 724: liberation(s_etat_processus, s_objet_2);
! 725:
! 726: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
! 727: return;
! 728: }
! 729:
! 730: if (recherche_variable(s_etat_processus, (*((struct_nom *)
! 731: (*s_objet_1).objet)).nom) == d_vrai)
! 732: {
! 733: /*
! 734: * Une variable est accessible directement.
! 735: */
! 736:
! 737: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
! 738: .position_variable_courante].niveau == 1)
! 739: {
! 740: // La variable accessible directement est une variable globale.
! 741:
! 742: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
! 743: .position_variable_courante].variable_verrouillee == d_vrai)
! 744: {
! 745: liberation(s_etat_processus, s_objet_1);
! 746: liberation(s_etat_processus, s_objet_2);
! 747:
! 748: (*s_etat_processus).erreur_execution =
! 749: d_ex_variable_verrouillee;
! 750: return;
! 751: }
! 752:
! 753: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
! 754: .position_variable_courante].objet == NULL)
! 755: {
! 756: liberation(s_etat_processus, s_objet_1);
! 757: liberation(s_etat_processus, s_objet_2);
! 758:
! 759: (*s_etat_processus).erreur_execution = d_ex_variable_partagee;
! 760: return;
! 761: }
! 762:
! 763: liberation(s_etat_processus,
! 764: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
! 765: .position_variable_courante].objet);
! 766:
! 767: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
! 768: .position_variable_courante].objet = s_objet_2;
! 769: }
! 770: else
! 771: {
! 772: // On cherche une variable globale de même nom.
! 773:
! 774: i = (*s_etat_processus).position_variable_courante;
! 775: presence_variable = d_faux;
! 776:
! 777: while(i >= 0)
! 778: {
! 779: if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
! 780: (*((struct_nom *) (*s_objet_1).objet)).nom) == 0) &&
! 781: ((*s_etat_processus).s_liste_variables[i].niveau == 1))
! 782: {
! 783: presence_variable = d_vrai;
! 784: break;
! 785: }
! 786:
! 787: i--;
! 788: }
! 789:
! 790: (*s_etat_processus).position_variable_courante = i;
! 791:
! 792: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
! 793: .position_variable_courante].niveau == 1)
! 794: {
! 795: // On a trouvé une variable globale correspondant au nom et
! 796: // que l'on modifie.
! 797:
! 798: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
! 799: .position_variable_courante].variable_verrouillee ==
! 800: d_vrai)
! 801: {
! 802: liberation(s_etat_processus, s_objet_1);
! 803: liberation(s_etat_processus, s_objet_2);
! 804:
! 805: (*s_etat_processus).erreur_execution =
! 806: d_ex_variable_verrouillee;
! 807: return;
! 808: }
! 809:
! 810: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
! 811: .position_variable_courante].objet == NULL)
! 812: {
! 813: liberation(s_etat_processus, s_objet_1);
! 814: liberation(s_etat_processus, s_objet_2);
! 815:
! 816: (*s_etat_processus).erreur_execution =
! 817: d_ex_variable_partagee;
! 818: return;
! 819: }
! 820:
! 821: liberation(s_etat_processus,
! 822: (*s_etat_processus).s_liste_variables
! 823: [(*s_etat_processus).position_variable_courante].objet);
! 824:
! 825: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
! 826: .position_variable_courante].objet = s_objet_2;
! 827: }
! 828: else
! 829: {
! 830: if ((s_variable.nom = malloc((strlen((*((struct_nom *)
! 831: (*s_objet_1).objet)).nom) + 1) * sizeof(unsigned char)))
! 832: == NULL)
! 833: {
! 834: (*s_etat_processus).erreur_systeme =
! 835: d_es_allocation_memoire;
! 836: return;
! 837: }
! 838:
! 839: strcpy(s_variable.nom, (*((struct_nom *)
! 840: (*s_objet_1).objet)).nom);
! 841: s_variable.niveau = 1;
! 842:
! 843: /*
! 844: * Le niveau 0 correspond aux définitions. Les variables
! 845: * commencent à 1 car elles sont toujours incluses dans
! 846: * une définition.
! 847: */
! 848:
! 849: s_variable.objet = s_objet_2;
! 850:
! 851: if (creation_variable(s_etat_processus, &s_variable, 'V', 'P')
! 852: == d_erreur)
! 853: {
! 854: return;
! 855: }
! 856: }
! 857: }
! 858: }
! 859: else
! 860: {
! 861: /*
! 862: * Aucune variable n'est accessible (ni locale, ni globale).
! 863: */
! 864:
! 865: if ((s_variable.nom = malloc((strlen((*((struct_nom *)
! 866: (*s_objet_1).objet)).nom) + 1) * sizeof(unsigned char)))
! 867: == NULL)
! 868: {
! 869: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 870: return;
! 871: }
! 872:
! 873: strcpy(s_variable.nom, (*((struct_nom *) (*s_objet_1).objet)).nom);
! 874: s_variable.niveau = 1;
! 875:
! 876: /*
! 877: * Le niveau 0 correspond aux définitions. Les variables
! 878: * commencent à 1 car elles sont toujours incluses dans
! 879: * une définition.
! 880: */
! 881:
! 882: s_variable.objet = s_objet_2;
! 883:
! 884: if (creation_variable(s_etat_processus, &s_variable, 'V', 'P')
! 885: == d_erreur)
! 886: {
! 887: return;
! 888: }
! 889:
! 890: (*s_etat_processus).erreur_systeme = d_es;
! 891: }
! 892:
! 893: liberation(s_etat_processus, s_objet_1);
! 894:
! 895: return;
! 896: }
! 897:
! 898:
! 899: /*
! 900: ================================================================================
! 901: Fonction 'suspend'
! 902: ================================================================================
! 903: Entrées : structure processus
! 904: --------------------------------------------------------------------------------
! 905: Sorties :
! 906: --------------------------------------------------------------------------------
! 907: Effets de bord : néant
! 908: ================================================================================
! 909: */
! 910:
! 911: void
! 912: instruction_suspend(struct_processus *s_etat_processus)
! 913: {
! 914: sigset_t masque;
! 915:
! 916: (*s_etat_processus).erreur_execution = d_ex;
! 917:
! 918: if ((*s_etat_processus).affichage_arguments == 'Y')
! 919: {
! 920: printf("\n SUSPEND ");
! 921:
! 922: if ((*s_etat_processus).langue == 'F')
! 923: {
! 924: printf("(attend un signal SIGCONT)\n\n");
! 925: printf(" Aucun argument\n");
! 926: }
! 927: else
! 928: {
! 929: printf("(wait for SIGCONT signal)\n\n");
! 930: printf(" No argument\n");
! 931: }
! 932:
! 933: return;
! 934: }
! 935: else if ((*s_etat_processus).test_instruction == 'Y')
! 936: {
! 937: (*s_etat_processus).nombre_arguments = -1;
! 938: return;
! 939: }
! 940:
! 941: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 942: {
! 943: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 944: {
! 945: return;
! 946: }
! 947: }
! 948:
! 949: if (sigfillset(&masque) != 0)
! 950: {
! 951: (*s_etat_processus).erreur_systeme = d_es_processus;
! 952: return;
! 953: }
! 954:
! 955: if (sigdelset(&masque, SIGCONT) != 0)
! 956: {
! 957: (*s_etat_processus).erreur_systeme = d_es_processus;
! 958: return;
! 959: }
! 960:
! 961: if (sigdelset(&masque, SIGFSTOP) != 0)
! 962: {
! 963: (*s_etat_processus).erreur_systeme = d_es_processus;
! 964: return;
! 965: }
! 966:
! 967: if (sigdelset(&masque, SIGURG) != 0)
! 968: {
! 969: (*s_etat_processus).erreur_systeme = d_es_processus;
! 970: return;
! 971: }
! 972:
! 973: if (sigdelset(&masque, SIGALRM) != 0)
! 974: {
! 975: (*s_etat_processus).erreur_systeme = d_es_processus;
! 976: return;
! 977: }
! 978:
! 979: if ((*s_etat_processus).profilage == d_vrai)
! 980: {
! 981: profilage(s_etat_processus, "Suspend");
! 982:
! 983: if ((*s_etat_processus).erreur_systeme != d_es)
! 984: {
! 985: return;
! 986: }
! 987: }
! 988:
! 989: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 990: {
! 991: (*s_etat_processus).erreur_systeme = d_es_processus;
! 992: return;
! 993: }
! 994:
! 995: sigsuspend(&masque);
! 996:
! 997: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 998: {
! 999: if (errno != EINTR)
! 1000: {
! 1001: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1002: return;
! 1003: }
! 1004: }
! 1005:
! 1006: if ((*s_etat_processus).profilage == d_vrai)
! 1007: {
! 1008: profilage(s_etat_processus, NULL);
! 1009: }
! 1010:
! 1011: return;
! 1012: }
! 1013:
! 1014:
! 1015: /*
! 1016: ================================================================================
! 1017: Fonction 'static'
! 1018: ================================================================================
! 1019: Entrées : structure processus
! 1020: --------------------------------------------------------------------------------
! 1021: Sorties :
! 1022: --------------------------------------------------------------------------------
! 1023: Effets de bord : néant
! 1024: ================================================================================
! 1025: */
! 1026:
! 1027: void
! 1028: instruction_static(struct_processus *s_etat_processus)
! 1029: {
! 1030: (*s_etat_processus).erreur_execution = d_ex;
! 1031:
! 1032: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1033: {
! 1034: printf("\n STATIC ");
! 1035:
! 1036: if ((*s_etat_processus).langue == 'F')
! 1037: {
! 1038: printf("(déclaration de variables statiques)\n\n");
! 1039: printf(" Aucun argument\n");
! 1040: }
! 1041: else
! 1042: {
! 1043: printf("(static variables declaration)\n\n");
! 1044: printf(" No argument\n");
! 1045: }
! 1046:
! 1047: return;
! 1048: }
! 1049: else if ((*s_etat_processus).test_instruction == 'Y')
! 1050: {
! 1051: (*s_etat_processus).nombre_arguments = -1;
! 1052: return;
! 1053: }
! 1054:
! 1055: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1056: {
! 1057: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 1058: {
! 1059: return;
! 1060: }
! 1061: }
! 1062:
! 1063: if ((*s_etat_processus).creation_variables_partagees == d_vrai)
! 1064: {
! 1065: (*s_etat_processus).erreur_execution = d_ex_variable_statique_partagee;
! 1066: return;
! 1067: }
! 1068:
! 1069: (*s_etat_processus).creation_variables_statiques = d_vrai;
! 1070:
! 1071: return;
! 1072: }
! 1073:
! 1074:
! 1075: /*
! 1076: ================================================================================
! 1077: Fonction 'shared'
! 1078: ================================================================================
! 1079: Entrées : structure processus
! 1080: --------------------------------------------------------------------------------
! 1081: Sorties :
! 1082: --------------------------------------------------------------------------------
! 1083: Effets de bord : néant
! 1084: ================================================================================
! 1085: */
! 1086:
! 1087: void
! 1088: instruction_shared(struct_processus *s_etat_processus)
! 1089: {
! 1090: (*s_etat_processus).erreur_execution = d_ex;
! 1091:
! 1092: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1093: {
! 1094: printf("\n SHARED ");
! 1095:
! 1096: if ((*s_etat_processus).langue == 'F')
! 1097: {
! 1098: printf("(déclaration de variables partagées)\n\n");
! 1099: printf(" Aucun argument\n");
! 1100: }
! 1101: else
! 1102: {
! 1103: printf("(shared variables declaration)\n\n");
! 1104: printf(" No argument\n");
! 1105: }
! 1106:
! 1107: return;
! 1108: }
! 1109: else if ((*s_etat_processus).test_instruction == 'Y')
! 1110: {
! 1111: (*s_etat_processus).nombre_arguments = -1;
! 1112: return;
! 1113: }
! 1114:
! 1115: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1116: {
! 1117: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 1118: {
! 1119: return;
! 1120: }
! 1121: }
! 1122:
! 1123: if ((*s_etat_processus).creation_variables_partagees == d_vrai)
! 1124: {
! 1125: (*s_etat_processus).erreur_execution = d_ex_variable_statique_partagee;
! 1126: return;
! 1127: }
! 1128:
! 1129: (*s_etat_processus).creation_variables_partagees = d_vrai;
! 1130:
! 1131: return;
! 1132: }
! 1133:
! 1134:
! 1135: /*
! 1136: ================================================================================
! 1137: Fonction 'stoswi'
! 1138: ================================================================================
! 1139: Entrées : structure processus
! 1140: --------------------------------------------------------------------------------
! 1141: Sorties :
! 1142: --------------------------------------------------------------------------------
! 1143: Effets de bord : néant
! 1144: ================================================================================
! 1145: */
! 1146:
! 1147: void
! 1148: instruction_stoswi(struct_processus *s_etat_processus)
! 1149: {
! 1150: integer8 interruption;
! 1151:
! 1152: struct_objet *s_objet_argument_1;
! 1153: struct_objet *s_objet_argument_2;
! 1154:
! 1155: (*s_etat_processus).erreur_execution = d_ex;
! 1156:
! 1157: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1158: {
! 1159: printf("\n STOSWI ");
! 1160:
! 1161: if ((*s_etat_processus).langue == 'F')
! 1162: {
! 1163: printf("(définition d'une interruption logicielle)\n\n");
! 1164: }
! 1165: else
! 1166: {
! 1167: printf("(software interrupt definition)\n\n");
! 1168: }
! 1169:
! 1170: printf(" 2: %s, %s\n", d_NOM, d_RPN);
! 1171: printf(" 1: %s\n", d_INT);
! 1172:
! 1173: return;
! 1174: }
! 1175: else if ((*s_etat_processus).test_instruction == 'Y')
! 1176: {
! 1177: (*s_etat_processus).nombre_arguments = -1;
! 1178: return;
! 1179: }
! 1180:
! 1181: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1182: {
! 1183: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
! 1184: {
! 1185: return;
! 1186: }
! 1187: }
! 1188:
! 1189: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1190: &s_objet_argument_1) == d_erreur)
! 1191: {
! 1192: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1193: return;
! 1194: }
! 1195:
! 1196: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1197: &s_objet_argument_2) == d_erreur)
! 1198: {
! 1199: liberation(s_etat_processus, s_objet_argument_1);
! 1200:
! 1201: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1202: return;
! 1203: }
! 1204:
! 1205: if ((*s_objet_argument_1).type == INT)
! 1206: {
! 1207: interruption = (*((integer8 *) (*s_objet_argument_1).objet));
! 1208:
! 1209: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
! 1210: {
! 1211: liberation(s_etat_processus, s_objet_argument_1);
! 1212: liberation(s_etat_processus, s_objet_argument_2);
! 1213:
! 1214: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide;
! 1215: return;
! 1216: }
! 1217:
! 1218: if ((*s_objet_argument_2).type == NOM)
! 1219: {
! 1220: liberation(s_etat_processus, (*s_etat_processus).corps_interruptions
! 1221: [interruption - 1]);
! 1222: (*s_etat_processus).corps_interruptions[interruption - 1] =
! 1223: s_objet_argument_2;
! 1224: }
! 1225: else if((*s_objet_argument_2).type == RPN)
! 1226: {
! 1227: liberation(s_etat_processus, (*s_etat_processus).corps_interruptions
! 1228: [interruption - 1]);
! 1229: (*s_etat_processus).corps_interruptions[interruption - 1] =
! 1230: s_objet_argument_2;
! 1231: }
! 1232: else
! 1233: {
! 1234: liberation(s_etat_processus, s_objet_argument_1);
! 1235: liberation(s_etat_processus, s_objet_argument_2);
! 1236:
! 1237: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1238: return;
! 1239: }
! 1240: }
! 1241: else
! 1242: {
! 1243: liberation(s_etat_processus, s_objet_argument_1);
! 1244: liberation(s_etat_processus, s_objet_argument_2);
! 1245:
! 1246: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1247: return;
! 1248: }
! 1249:
! 1250: liberation(s_etat_processus, s_objet_argument_1);
! 1251:
! 1252: return;
! 1253: }
! 1254:
! 1255:
! 1256: /*
! 1257: ================================================================================
! 1258: Fonction 'swi'
! 1259: ================================================================================
! 1260: Entrées : structure processus
! 1261: --------------------------------------------------------------------------------
! 1262: Sorties :
! 1263: --------------------------------------------------------------------------------
! 1264: Effets de bord : néant
! 1265: ================================================================================
! 1266: */
! 1267:
! 1268: void
! 1269: instruction_swi(struct_processus *s_etat_processus)
! 1270: {
! 1271: int interruption_reduite;
! 1272:
! 1273: integer8 interruption;
! 1274:
! 1275: pid_t pid;
! 1276:
! 1277: pthread_t tid;
! 1278:
! 1279: sig_atomic_t registre;
! 1280:
! 1281: ssize_t longueur_ecriture;
! 1282:
! 1283: struct_objet *s_objet_argument;
! 1284:
! 1285: struct timespec attente;
! 1286:
! 1287: unsigned char tampon;
! 1288:
! 1289: (*s_etat_processus).erreur_execution = d_ex;
! 1290:
! 1291: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1292: {
! 1293: printf("\n SWI ");
! 1294:
! 1295: if ((*s_etat_processus).langue == 'F')
! 1296: {
! 1297: printf("(interruption logicielle)\n\n");
! 1298: }
! 1299: else
! 1300: {
! 1301: printf("(software interrupt)\n\n");
! 1302: }
! 1303:
! 1304: printf(" 1: %s\n", d_INT);
! 1305:
! 1306: return;
! 1307: }
! 1308: else if ((*s_etat_processus).test_instruction == 'Y')
! 1309: {
! 1310: (*s_etat_processus).nombre_arguments = -1;
! 1311: return;
! 1312: }
! 1313:
! 1314: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1315: {
! 1316: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 1317: {
! 1318: return;
! 1319: }
! 1320: }
! 1321:
! 1322: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1323: &s_objet_argument) == d_erreur)
! 1324: {
! 1325: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1326: return;
! 1327: }
! 1328:
! 1329: if ((*s_objet_argument).type == INT)
! 1330: {
! 1331: interruption = (*((integer8 *) (*s_objet_argument).objet));
! 1332:
! 1333: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
! 1334: {
! 1335: liberation(s_etat_processus, s_objet_argument);
! 1336:
! 1337: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide;
! 1338: return;
! 1339: }
! 1340:
! 1341: if ((*s_etat_processus).presence_pipes == d_faux)
! 1342: {
! 1343: liberation(s_etat_processus, s_objet_argument);
! 1344:
! 1345: (*s_etat_processus).erreur_execution = d_ex_absence_processus_pere;
! 1346: return;
! 1347: }
! 1348:
! 1349: // Envoi d'un PID invalide (-1) pour ne pas bloquer le thread
! 1350: // de surveillance.
! 1351:
! 1352: registre = (*s_etat_processus).var_volatile_traitement_retarde_stop;
! 1353: (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;
! 1354:
! 1355: if ((*s_etat_processus).processus_detache == d_vrai)
! 1356: {
! 1357: pid = -1;
! 1358:
! 1359: attente.tv_sec = 0;
! 1360: attente.tv_nsec = GRANULARITE_us * 1000;
! 1361:
! 1362: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 1363: {
! 1364: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1365: return;
! 1366: }
! 1367:
! 1368: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1369: (*s_etat_processus).pipe_nombre_objets_attente,
! 1370: &pid, sizeof(pid))) != sizeof(pid))
! 1371: {
! 1372: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 1373: {
! 1374: if (errno != EINTR)
! 1375: {
! 1376: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1377: return;
! 1378: }
! 1379: }
! 1380:
! 1381: if (longueur_ecriture == -1)
! 1382: {
! 1383: if (registre == 0)
! 1384: {
! 1385: if ((*s_etat_processus)
! 1386: .var_volatile_traitement_retarde_stop == -1)
! 1387: {
! 1388: (*s_etat_processus).var_volatile_requete_arret = -1;
! 1389: }
! 1390:
! 1391: (*s_etat_processus)
! 1392: .var_volatile_traitement_retarde_stop
! 1393: = registre;
! 1394: }
! 1395:
! 1396: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1397: return;
! 1398: }
! 1399:
! 1400: nanosleep(&attente, NULL);
! 1401: INCR_GRANULARITE(attente.tv_nsec);
! 1402:
! 1403: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 1404: {
! 1405: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1406: return;
! 1407: }
! 1408: }
! 1409:
! 1410: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 1411: {
! 1412: if (errno != EINTR)
! 1413: {
! 1414: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1415: return;
! 1416: }
! 1417: }
! 1418: }
! 1419: else
! 1420: {
! 1421: tid = -1;
! 1422:
! 1423: attente.tv_sec = 0;
! 1424: attente.tv_nsec = GRANULARITE_us * 1000;
! 1425:
! 1426: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 1427: {
! 1428: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1429: return;
! 1430: }
! 1431:
! 1432: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1433: (*s_etat_processus).pipe_nombre_objets_attente,
! 1434: &tid, sizeof(tid))) != sizeof(tid))
! 1435: {
! 1436: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 1437: {
! 1438: if (errno != EINTR)
! 1439: {
! 1440: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1441: return;
! 1442: }
! 1443: }
! 1444:
! 1445: if (longueur_ecriture == -1)
! 1446: {
! 1447: if (registre == 0)
! 1448: {
! 1449: if ((*s_etat_processus)
! 1450: .var_volatile_traitement_retarde_stop == -1)
! 1451: {
! 1452: (*s_etat_processus).var_volatile_requete_arret = -1;
! 1453: }
! 1454:
! 1455: (*s_etat_processus)
! 1456: .var_volatile_traitement_retarde_stop
! 1457: = registre;
! 1458: }
! 1459:
! 1460: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1461: return;
! 1462: }
! 1463:
! 1464: nanosleep(&attente, NULL);
! 1465: INCR_GRANULARITE(attente.tv_nsec);
! 1466:
! 1467: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 1468: {
! 1469: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1470: return;
! 1471: }
! 1472: }
! 1473:
! 1474: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 1475: {
! 1476: if (errno != EINTR)
! 1477: {
! 1478: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1479: return;
! 1480: }
! 1481: }
! 1482: }
! 1483:
! 1484: interruption_reduite = interruption;
! 1485:
! 1486: attente.tv_sec = 0;
! 1487: attente.tv_nsec = GRANULARITE_us * 1000;
! 1488:
! 1489: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 1490: {
! 1491: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1492: return;
! 1493: }
! 1494:
! 1495: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1496: (*s_etat_processus).pipe_interruptions,
! 1497: &interruption_reduite, sizeof(interruption_reduite)))
! 1498: != sizeof(interruption_reduite))
! 1499: {
! 1500: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 1501: {
! 1502: if (errno != EINTR)
! 1503: {
! 1504: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1505: return;
! 1506: }
! 1507: }
! 1508:
! 1509: if (longueur_ecriture == -1)
! 1510: {
! 1511: if (registre == 0)
! 1512: {
! 1513: if ((*s_etat_processus)
! 1514: .var_volatile_traitement_retarde_stop == -1)
! 1515: {
! 1516: (*s_etat_processus).var_volatile_requete_arret = -1;
! 1517: }
! 1518:
! 1519: (*s_etat_processus)
! 1520: .var_volatile_traitement_retarde_stop
! 1521: = registre;
! 1522: }
! 1523:
! 1524: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1525: return;
! 1526: }
! 1527:
! 1528: nanosleep(&attente, NULL);
! 1529: INCR_GRANULARITE(attente.tv_nsec);
! 1530:
! 1531: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 1532: {
! 1533: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1534: return;
! 1535: }
! 1536: }
! 1537:
! 1538: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 1539: {
! 1540: if (errno != EINTR)
! 1541: {
! 1542: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1543: return;
! 1544: }
! 1545: }
! 1546:
! 1547: if ((*s_etat_processus).processus_detache == d_vrai)
! 1548: {
! 1549: pid = -3;
! 1550:
! 1551: attente.tv_sec = 0;
! 1552: attente.tv_nsec = GRANULARITE_us * 1000;
! 1553:
! 1554: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 1555: {
! 1556: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1557: return;
! 1558: }
! 1559:
! 1560: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1561: (*s_etat_processus).pipe_nombre_interruptions_attente,
! 1562: &pid, sizeof(pid))) != sizeof(pid))
! 1563: {
! 1564: while(sem_wait(&((*s_etat_processus).semaphore_fork))
! 1565: == -1)
! 1566: {
! 1567: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1568: return;
! 1569: }
! 1570:
! 1571: if (longueur_ecriture == -1)
! 1572: {
! 1573: if (registre == 0)
! 1574: {
! 1575: if ((*s_etat_processus)
! 1576: .var_volatile_traitement_retarde_stop == -1)
! 1577: {
! 1578: (*s_etat_processus).var_volatile_requete_arret = -1;
! 1579: }
! 1580:
! 1581: (*s_etat_processus)
! 1582: .var_volatile_traitement_retarde_stop
! 1583: = registre;
! 1584: }
! 1585:
! 1586: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1587: return;
! 1588: }
! 1589:
! 1590: nanosleep(&attente, NULL);
! 1591: INCR_GRANULARITE(attente.tv_nsec);
! 1592:
! 1593: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 1594: {
! 1595: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1596: return;
! 1597: }
! 1598: }
! 1599:
! 1600: pid = getpid();
! 1601:
! 1602: attente.tv_sec = 0;
! 1603: attente.tv_nsec = GRANULARITE_us * 1000;
! 1604:
! 1605: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1606: (*s_etat_processus).pipe_nombre_interruptions_attente,
! 1607: &pid, sizeof(pid))) != sizeof(pid))
! 1608: {
! 1609: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 1610: {
! 1611: if (errno != EINTR)
! 1612: {
! 1613: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1614: return;
! 1615: }
! 1616: }
! 1617:
! 1618: if (longueur_ecriture == -1)
! 1619: {
! 1620: if (registre == 0)
! 1621: {
! 1622: if ((*s_etat_processus)
! 1623: .var_volatile_traitement_retarde_stop == -1)
! 1624: {
! 1625: (*s_etat_processus).var_volatile_requete_arret = -1;
! 1626: }
! 1627:
! 1628: (*s_etat_processus)
! 1629: .var_volatile_traitement_retarde_stop
! 1630: = registre;
! 1631: }
! 1632:
! 1633: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1634: return;
! 1635: }
! 1636:
! 1637: nanosleep(&attente, NULL);
! 1638: INCR_GRANULARITE(attente.tv_nsec);
! 1639:
! 1640: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 1641: {
! 1642: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1643: return;
! 1644: }
! 1645: }
! 1646:
! 1647: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 1648: {
! 1649: if (errno != EINTR)
! 1650: {
! 1651: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1652: return;
! 1653: }
! 1654: }
! 1655: }
! 1656: else
! 1657: {
! 1658: tid = -3;
! 1659:
! 1660: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 1661: {
! 1662: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1663: return;
! 1664: }
! 1665:
! 1666: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1667: (*s_etat_processus).pipe_nombre_interruptions_attente,
! 1668: &tid, sizeof(tid))) != sizeof(tid))
! 1669: {
! 1670: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 1671: {
! 1672: if (errno != EINTR)
! 1673: {
! 1674: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1675: return;
! 1676: }
! 1677: }
! 1678:
! 1679: if (longueur_ecriture == -1)
! 1680: {
! 1681: if (registre == 0)
! 1682: {
! 1683: if ((*s_etat_processus)
! 1684: .var_volatile_traitement_retarde_stop == -1)
! 1685: {
! 1686: (*s_etat_processus).var_volatile_requete_arret = -1;
! 1687: }
! 1688:
! 1689: (*s_etat_processus)
! 1690: .var_volatile_traitement_retarde_stop
! 1691: = registre;
! 1692: }
! 1693:
! 1694: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1695: return;
! 1696: }
! 1697:
! 1698: nanosleep(&attente, NULL);
! 1699: INCR_GRANULARITE(attente.tv_nsec);
! 1700:
! 1701: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 1702: {
! 1703: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1704: return;
! 1705: }
! 1706: }
! 1707:
! 1708: tid = pthread_self();
! 1709:
! 1710: attente.tv_sec = 0;
! 1711: attente.tv_nsec = GRANULARITE_us * 1000;
! 1712:
! 1713: while((longueur_ecriture = write_atomic(s_etat_processus,
! 1714: (*s_etat_processus).pipe_nombre_interruptions_attente,
! 1715: &tid, sizeof(tid))) != sizeof(tid))
! 1716: {
! 1717: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 1718: {
! 1719: if (errno != EINTR)
! 1720: {
! 1721: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1722: return;
! 1723: }
! 1724: }
! 1725:
! 1726: if (longueur_ecriture == -1)
! 1727:
! 1728: {
! 1729: if (registre == 0)
! 1730: {
! 1731: if ((*s_etat_processus)
! 1732: .var_volatile_traitement_retarde_stop == -1)
! 1733: {
! 1734: (*s_etat_processus).var_volatile_requete_arret = -1;
! 1735: }
! 1736:
! 1737: (*s_etat_processus)
! 1738: .var_volatile_traitement_retarde_stop
! 1739: = registre;
! 1740: }
! 1741:
! 1742: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1743: return;
! 1744: }
! 1745:
! 1746: nanosleep(&attente, NULL);
! 1747: INCR_GRANULARITE(attente.tv_nsec);
! 1748:
! 1749: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 1750: {
! 1751: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1752: return;
! 1753: }
! 1754: }
! 1755:
! 1756: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 1757: {
! 1758: if (errno != EINTR)
! 1759: {
! 1760: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1761: return;
! 1762: }
! 1763: }
! 1764: }
! 1765:
! 1766: attente.tv_sec = 0;
! 1767: attente.tv_nsec = GRANULARITE_us * 1000;
! 1768:
! 1769: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 1770: {
! 1771: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1772: return;
! 1773: }
! 1774:
! 1775: while(read_atomic(s_etat_processus,
! 1776: (*s_etat_processus).pipe_acquittement,
! 1777: &tampon, sizeof(unsigned char)) != sizeof(unsigned char))
! 1778: {
! 1779: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 1780: {
! 1781: if (errno != EINTR)
! 1782: {
! 1783: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1784: return;
! 1785: }
! 1786: }
! 1787:
! 1788: nanosleep(&attente, NULL);
! 1789: INCR_GRANULARITE(attente.tv_nsec);
! 1790:
! 1791: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 1792: {
! 1793: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1794: return;
! 1795: }
! 1796: }
! 1797:
! 1798: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 1799: {
! 1800: if (errno != EINTR)
! 1801: {
! 1802: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1803: return;
! 1804: }
! 1805: }
! 1806:
! 1807: if (registre == 0)
! 1808: {
! 1809: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == -1)
! 1810: {
! 1811: (*s_etat_processus).var_volatile_requete_arret = -1;
! 1812: }
! 1813:
! 1814: (*s_etat_processus).var_volatile_traitement_retarde_stop = registre;
! 1815: }
! 1816: }
! 1817: else
! 1818: {
! 1819: liberation(s_etat_processus, s_objet_argument);
! 1820:
! 1821: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1822: return;
! 1823: }
! 1824:
! 1825: liberation(s_etat_processus, s_objet_argument);
! 1826:
! 1827: return;
! 1828: }
! 1829:
! 1830:
! 1831: /*
! 1832: ================================================================================
! 1833: Fonction 'swilock'
! 1834: ================================================================================
! 1835: Entrées : structure processus
! 1836: --------------------------------------------------------------------------------
! 1837: Sorties :
! 1838: --------------------------------------------------------------------------------
! 1839: Effets de bord : néant
! 1840: ================================================================================
! 1841: */
! 1842:
! 1843: void
! 1844: instruction_swilock(struct_processus *s_etat_processus)
! 1845: {
! 1846: integer8 interruption;
! 1847:
! 1848: struct_liste_chainee *l_element_courant;
! 1849:
! 1850: struct_objet *s_objet_argument;
! 1851:
! 1852: (*s_etat_processus).erreur_execution = d_ex;
! 1853:
! 1854: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1855: {
! 1856: printf("\n SWILOCK ");
! 1857:
! 1858: if ((*s_etat_processus).langue == 'F')
! 1859: {
! 1860: printf("(verrouillage des interruptions logicielles)\n\n");
! 1861: }
! 1862: else
! 1863: {
! 1864: printf("(software interrupt lock)\n\n");
! 1865: }
! 1866:
! 1867: printf(" 1: %s, %s\n", d_INT, d_LST);
! 1868:
! 1869: return;
! 1870: }
! 1871: else if ((*s_etat_processus).test_instruction == 'Y')
! 1872: {
! 1873: (*s_etat_processus).nombre_arguments = -1;
! 1874: return;
! 1875: }
! 1876:
! 1877: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1878: {
! 1879: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 1880: {
! 1881: return;
! 1882: }
! 1883: }
! 1884:
! 1885: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1886: &s_objet_argument) == d_erreur)
! 1887: {
! 1888: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1889: return;
! 1890: }
! 1891:
! 1892: if ((*s_objet_argument).type == INT)
! 1893: {
! 1894: interruption = (*((integer8 *) (*s_objet_argument).objet));
! 1895:
! 1896: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
! 1897: {
! 1898: liberation(s_etat_processus, s_objet_argument);
! 1899:
! 1900: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide;
! 1901: return;
! 1902: }
! 1903:
! 1904: (*s_etat_processus).masque_interruptions[interruption - 1] = 'I';
! 1905: }
! 1906: else if ((*s_objet_argument).type == LST)
! 1907: {
! 1908: l_element_courant = (*s_objet_argument).objet;
! 1909:
! 1910: while(l_element_courant)
! 1911: {
! 1912: if ((*(*l_element_courant).donnee).type != INT)
! 1913: {
! 1914: liberation(s_etat_processus, s_objet_argument);
! 1915:
! 1916: (*s_etat_processus).erreur_execution =
! 1917: d_ex_erreur_type_argument;
! 1918: return;
! 1919: }
! 1920:
! 1921: interruption = (*((integer8 *) (*(*l_element_courant)
! 1922: .donnee).objet));
! 1923:
! 1924: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
! 1925: {
! 1926: liberation(s_etat_processus, s_objet_argument);
! 1927:
! 1928: (*s_etat_processus).erreur_execution =
! 1929: d_ex_interruption_invalide;
! 1930: return;
! 1931: }
! 1932:
! 1933: (*s_etat_processus).masque_interruptions[interruption - 1] = 'I';
! 1934: l_element_courant = (*l_element_courant).suivant;
! 1935: }
! 1936: }
! 1937: else
! 1938: {
! 1939: liberation(s_etat_processus, s_objet_argument);
! 1940:
! 1941: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1942: return;
! 1943: }
! 1944:
! 1945: liberation(s_etat_processus, s_objet_argument);
! 1946:
! 1947: return;
! 1948: }
! 1949:
! 1950:
! 1951: /*
! 1952: ================================================================================
! 1953: Fonction 'swistatus'
! 1954: ================================================================================
! 1955: Entrées : structure processus
! 1956: --------------------------------------------------------------------------------
! 1957: Sorties :
! 1958: --------------------------------------------------------------------------------
! 1959: Effets de bord : néant
! 1960: ================================================================================
! 1961: */
! 1962:
! 1963: void
! 1964: instruction_swistatus(struct_processus *s_etat_processus)
! 1965: {
! 1966: int i;
! 1967:
! 1968: struct_liste_chainee *l_element_courant;
! 1969: struct_liste_chainee *l_element_futur;
! 1970: struct_liste_chainee *l_element_liste;
! 1971:
! 1972: struct_objet *s_objet_resultat;
! 1973:
! 1974: (*s_etat_processus).erreur_execution = d_ex;
! 1975:
! 1976: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1977: {
! 1978: printf("\n SWISTATUS ");
! 1979:
! 1980: if ((*s_etat_processus).langue == 'F')
! 1981: {
! 1982: printf("(état des interruptions logicielles)\n\n");
! 1983: }
! 1984: else
! 1985: {
! 1986: printf("(software interrupts status)\n\n");
! 1987: }
! 1988:
! 1989: printf("-> 1: %s\n\n", d_LST);
! 1990:
! 1991: if ((*s_etat_processus).langue == 'F')
! 1992: {
! 1993: printf(" Utilisation :\n\n");
! 1994: }
! 1995: else
! 1996: {
! 1997: printf(" Usage:\n\n");
! 1998: }
! 1999:
! 2000: printf(" { { initialized interrupts }\n"
! 2001: " { unlocked interrupts }\n"
! 2002: " { queued interrupts }\n"
! 2003: " { locked interrupts } }\n");
! 2004: return;
! 2005: }
! 2006: else if ((*s_etat_processus).test_instruction == 'Y')
! 2007: {
! 2008: (*s_etat_processus).nombre_arguments = -1;
! 2009: return;
! 2010: }
! 2011:
! 2012: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 2013: {
! 2014: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 2015: {
! 2016: return;
! 2017: }
! 2018: }
! 2019:
! 2020: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
! 2021: {
! 2022: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2023: return;
! 2024: }
! 2025:
! 2026: if (((*s_objet_resultat).objet =
! 2027: allocation_maillon(s_etat_processus)) == NULL)
! 2028: {
! 2029: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2030: return;
! 2031: }
! 2032:
! 2033: l_element_courant = (struct_liste_chainee *) (*s_objet_resultat).objet;
! 2034:
! 2035: if (((*l_element_courant).donnee = allocation(s_etat_processus, LST))
! 2036: == NULL)
! 2037: {
! 2038: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2039: return;
! 2040: }
! 2041:
! 2042: l_element_liste = NULL;
! 2043: l_element_futur = NULL;
! 2044:
! 2045: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
! 2046: {
! 2047: if ((*s_etat_processus).corps_interruptions[i] != NULL)
! 2048: {
! 2049: if (l_element_liste == NULL)
! 2050: {
! 2051: if ((l_element_liste =
! 2052: allocation_maillon(s_etat_processus)) == NULL)
! 2053: {
! 2054: (*s_etat_processus).erreur_systeme =
! 2055: d_es_allocation_memoire;
! 2056: return;
! 2057: }
! 2058:
! 2059: l_element_futur = l_element_liste;
! 2060: }
! 2061: else
! 2062: {
! 2063: if (((*l_element_liste).suivant =
! 2064: allocation_maillon(s_etat_processus)) == NULL)
! 2065: {
! 2066: (*s_etat_processus).erreur_systeme =
! 2067: d_es_allocation_memoire;
! 2068: return;
! 2069: }
! 2070:
! 2071: l_element_liste = (*l_element_liste).suivant;
! 2072: }
! 2073:
! 2074: (*l_element_liste).suivant = NULL;
! 2075:
! 2076: if (((*l_element_liste).donnee = allocation(s_etat_processus,
! 2077: INT)) == NULL)
! 2078: {
! 2079: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2080: return;
! 2081: }
! 2082:
! 2083: (*((integer8 *) (*(*l_element_liste).donnee).objet)) = i + 1;
! 2084: }
! 2085: }
! 2086:
! 2087: (*(*l_element_courant).donnee).objet = l_element_futur;
! 2088:
! 2089: if (((*l_element_courant).suivant =
! 2090: allocation_maillon(s_etat_processus)) == NULL)
! 2091: {
! 2092: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2093: return;
! 2094: }
! 2095:
! 2096: l_element_courant = (*l_element_courant).suivant;
! 2097:
! 2098: if (((*l_element_courant).donnee = allocation(s_etat_processus, LST))
! 2099: == NULL)
! 2100: {
! 2101: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2102: return;
! 2103: }
! 2104:
! 2105: l_element_liste = NULL;
! 2106: l_element_futur = NULL;
! 2107:
! 2108: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
! 2109: {
! 2110: if ((*s_etat_processus).masque_interruptions[i] == 'N')
! 2111: {
! 2112: if (l_element_liste == NULL)
! 2113: {
! 2114: if ((l_element_liste =
! 2115: allocation_maillon(s_etat_processus)) == NULL)
! 2116: {
! 2117: (*s_etat_processus).erreur_systeme =
! 2118: d_es_allocation_memoire;
! 2119: return;
! 2120: }
! 2121:
! 2122: l_element_futur = l_element_liste;
! 2123: }
! 2124: else
! 2125: {
! 2126: if (((*l_element_liste).suivant =
! 2127: allocation_maillon(s_etat_processus)) == NULL)
! 2128: {
! 2129: (*s_etat_processus).erreur_systeme =
! 2130: d_es_allocation_memoire;
! 2131: return;
! 2132: }
! 2133:
! 2134: l_element_liste = (*l_element_liste).suivant;
! 2135: }
! 2136:
! 2137: (*l_element_liste).suivant = NULL;
! 2138:
! 2139: if (((*l_element_liste).donnee = allocation(s_etat_processus,
! 2140: INT)) == NULL)
! 2141: {
! 2142: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2143: return;
! 2144: }
! 2145:
! 2146: (*((integer8 *) (*(*l_element_liste).donnee).objet)) = i + 1;
! 2147: }
! 2148: }
! 2149:
! 2150: (*(*l_element_courant).donnee).objet = l_element_futur;
! 2151:
! 2152: if (((*l_element_courant).suivant = allocation_maillon(s_etat_processus))
! 2153: == NULL)
! 2154: {
! 2155: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2156: return;
! 2157: }
! 2158:
! 2159: l_element_courant = (*l_element_courant).suivant;
! 2160:
! 2161: if (((*l_element_courant).donnee = allocation(s_etat_processus, LST))
! 2162: == NULL)
! 2163: {
! 2164: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2165: return;
! 2166: }
! 2167:
! 2168: l_element_liste = NULL;
! 2169: l_element_futur = NULL;
! 2170:
! 2171: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
! 2172: {
! 2173: if ((*s_etat_processus).masque_interruptions[i] == 'Q')
! 2174: {
! 2175: if (l_element_liste == NULL)
! 2176: {
! 2177: if ((l_element_liste =
! 2178: allocation_maillon(s_etat_processus)) == NULL)
! 2179: {
! 2180: (*s_etat_processus).erreur_systeme =
! 2181: d_es_allocation_memoire;
! 2182: return;
! 2183: }
! 2184:
! 2185: l_element_futur = l_element_liste;
! 2186: }
! 2187: else
! 2188: {
! 2189: if (((*l_element_liste).suivant =
! 2190: allocation_maillon(s_etat_processus)) == NULL)
! 2191: {
! 2192: (*s_etat_processus).erreur_systeme =
! 2193: d_es_allocation_memoire;
! 2194: return;
! 2195: }
! 2196:
! 2197: l_element_liste = (*l_element_liste).suivant;
! 2198: }
! 2199:
! 2200: (*l_element_liste).suivant = NULL;
! 2201:
! 2202: if (((*l_element_liste).donnee = allocation(s_etat_processus,
! 2203: INT)) == NULL)
! 2204: {
! 2205: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2206: return;
! 2207: }
! 2208:
! 2209: (*((integer8 *) (*(*l_element_liste).donnee).objet)) = i + 1;
! 2210: }
! 2211: }
! 2212:
! 2213: (*(*l_element_courant).donnee).objet = l_element_futur;
! 2214:
! 2215: if (((*l_element_courant).suivant = allocation_maillon(s_etat_processus))
! 2216: == NULL)
! 2217: {
! 2218: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2219: return;
! 2220: }
! 2221:
! 2222: l_element_courant = (*l_element_courant).suivant;
! 2223:
! 2224: if (((*l_element_courant).donnee = allocation(s_etat_processus, LST))
! 2225: == NULL)
! 2226: {
! 2227: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2228: return;
! 2229: }
! 2230:
! 2231: l_element_liste = NULL;
! 2232: l_element_futur = NULL;
! 2233:
! 2234: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
! 2235: {
! 2236: if ((*s_etat_processus).masque_interruptions[i] == 'I')
! 2237: {
! 2238: if (l_element_liste == NULL)
! 2239: {
! 2240: if ((l_element_liste =
! 2241: allocation_maillon(s_etat_processus)) == NULL)
! 2242: {
! 2243: (*s_etat_processus).erreur_systeme =
! 2244: d_es_allocation_memoire;
! 2245: return;
! 2246: }
! 2247:
! 2248: l_element_futur = l_element_liste;
! 2249: }
! 2250: else
! 2251: {
! 2252: if (((*l_element_liste).suivant =
! 2253: allocation_maillon(s_etat_processus)) == NULL)
! 2254: {
! 2255: (*s_etat_processus).erreur_systeme =
! 2256: d_es_allocation_memoire;
! 2257: return;
! 2258: }
! 2259:
! 2260: l_element_liste = (*l_element_liste).suivant;
! 2261: }
! 2262:
! 2263: (*l_element_liste).suivant = NULL;
! 2264:
! 2265: if (((*l_element_liste).donnee = allocation(s_etat_processus,
! 2266: INT)) == NULL)
! 2267: {
! 2268: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2269: return;
! 2270: }
! 2271:
! 2272: (*((integer8 *) (*(*l_element_liste).donnee).objet)) = i + 1;
! 2273: }
! 2274: }
! 2275:
! 2276: (*(*l_element_courant).donnee).objet = l_element_futur;
! 2277:
! 2278: (*l_element_courant).suivant = NULL;
! 2279:
! 2280: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 2281: s_objet_resultat) == d_erreur)
! 2282: {
! 2283: return;
! 2284: }
! 2285:
! 2286: return;
! 2287: }
! 2288:
! 2289:
! 2290: /*
! 2291: ================================================================================
! 2292: Fonction 'swiunlock'
! 2293: ================================================================================
! 2294: Entrées : structure processus
! 2295: --------------------------------------------------------------------------------
! 2296: Sorties :
! 2297: --------------------------------------------------------------------------------
! 2298: Effets de bord : néant
! 2299: ================================================================================
! 2300: */
! 2301:
! 2302: void
! 2303: instruction_swiunlock(struct_processus *s_etat_processus)
! 2304: {
! 2305: integer8 interruption;
! 2306:
! 2307: struct_liste_chainee *l_element_courant;
! 2308:
! 2309: struct_objet *s_objet_argument;
! 2310:
! 2311: (*s_etat_processus).erreur_execution = d_ex;
! 2312:
! 2313: if ((*s_etat_processus).affichage_arguments == 'Y')
! 2314: {
! 2315: printf("\n SWIUNLOCK ");
! 2316:
! 2317: if ((*s_etat_processus).langue == 'F')
! 2318: {
! 2319: printf("(déverrouillage des interruptions logicielles)\n\n");
! 2320: }
! 2321: else
! 2322: {
! 2323: printf("(software interrupt unlock)\n\n");
! 2324: }
! 2325:
! 2326: printf(" 1: %s, %s\n", d_INT, d_LST);
! 2327:
! 2328: return;
! 2329: }
! 2330: else if ((*s_etat_processus).test_instruction == 'Y')
! 2331: {
! 2332: (*s_etat_processus).nombre_arguments = -1;
! 2333: return;
! 2334: }
! 2335:
! 2336: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 2337: {
! 2338: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 2339: {
! 2340: return;
! 2341: }
! 2342: }
! 2343:
! 2344: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 2345: &s_objet_argument) == d_erreur)
! 2346: {
! 2347: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 2348: return;
! 2349: }
! 2350:
! 2351: if ((*s_objet_argument).type == INT)
! 2352: {
! 2353: interruption = (*((integer8 *) (*s_objet_argument).objet));
! 2354:
! 2355: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
! 2356: {
! 2357: liberation(s_etat_processus, s_objet_argument);
! 2358:
! 2359: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide;
! 2360: return;
! 2361: }
! 2362:
! 2363: (*s_etat_processus).masque_interruptions[interruption - 1] = 'N';
! 2364: }
! 2365: else if ((*s_objet_argument).type == LST)
! 2366: {
! 2367: l_element_courant = (*s_objet_argument).objet;
! 2368:
! 2369: while(l_element_courant)
! 2370: {
! 2371: if ((*(*l_element_courant).donnee).type != INT)
! 2372: {
! 2373: liberation(s_etat_processus, s_objet_argument);
! 2374:
! 2375: (*s_etat_processus).erreur_execution =
! 2376: d_ex_erreur_type_argument;
! 2377: return;
! 2378: }
! 2379:
! 2380: interruption = (*((integer8 *) (*(*l_element_courant)
! 2381: .donnee).objet));
! 2382:
! 2383: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
! 2384: {
! 2385: liberation(s_etat_processus, s_objet_argument);
! 2386:
! 2387: (*s_etat_processus).erreur_execution =
! 2388: d_ex_interruption_invalide;
! 2389: return;
! 2390: }
! 2391:
! 2392: (*s_etat_processus).masque_interruptions[interruption - 1] = 'N';
! 2393: l_element_courant = (*l_element_courant).suivant;
! 2394: }
! 2395: }
! 2396: else
! 2397: {
! 2398: liberation(s_etat_processus, s_objet_argument);
! 2399:
! 2400: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 2401: return;
! 2402: }
! 2403:
! 2404: liberation(s_etat_processus, s_objet_argument);
! 2405:
! 2406: return;
! 2407: }
! 2408:
! 2409:
! 2410: /*
! 2411: ================================================================================
! 2412: Fonction 'swiqueue'
! 2413: ================================================================================
! 2414: Entrées : structure processus
! 2415: --------------------------------------------------------------------------------
! 2416: Sorties :
! 2417: --------------------------------------------------------------------------------
! 2418: Effets de bord : néant
! 2419: ================================================================================
! 2420: */
! 2421:
! 2422: void
! 2423: instruction_swiqueue(struct_processus *s_etat_processus)
! 2424: {
! 2425: integer8 interruption;
! 2426:
! 2427: struct_liste_chainee *l_element_courant;
! 2428:
! 2429: struct_objet *s_objet_argument;
! 2430:
! 2431: (*s_etat_processus).erreur_execution = d_ex;
! 2432:
! 2433: if ((*s_etat_processus).affichage_arguments == 'Y')
! 2434: {
! 2435: printf("\n SWIQUEUE ");
! 2436:
! 2437: if ((*s_etat_processus).langue == 'F')
! 2438: {
! 2439: printf("(enregistre des interruptions logicielles)\n\n");
! 2440: }
! 2441: else
! 2442: {
! 2443: printf("(software interrupt record)\n\n");
! 2444: }
! 2445:
! 2446: printf(" 1: %s, %s\n", d_INT, d_LST);
! 2447:
! 2448: return;
! 2449: }
! 2450: else if ((*s_etat_processus).test_instruction == 'Y')
! 2451: {
! 2452: (*s_etat_processus).nombre_arguments = -1;
! 2453: return;
! 2454: }
! 2455:
! 2456: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 2457: {
! 2458: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 2459: {
! 2460: return;
! 2461: }
! 2462: }
! 2463:
! 2464: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 2465: &s_objet_argument) == d_erreur)
! 2466: {
! 2467: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 2468: return;
! 2469: }
! 2470:
! 2471: if ((*s_objet_argument).type == INT)
! 2472: {
! 2473: interruption = (*((integer8 *) (*s_objet_argument).objet));
! 2474:
! 2475: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
! 2476: {
! 2477: liberation(s_etat_processus, s_objet_argument);
! 2478:
! 2479: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide;
! 2480: return;
! 2481: }
! 2482:
! 2483: (*s_etat_processus).masque_interruptions[interruption - 1] = 'Q';
! 2484: }
! 2485: else if ((*s_objet_argument).type == LST)
! 2486: {
! 2487: l_element_courant = (*s_objet_argument).objet;
! 2488:
! 2489: while(l_element_courant)
! 2490: {
! 2491: if ((*(*l_element_courant).donnee).type != INT)
! 2492: {
! 2493: liberation(s_etat_processus, s_objet_argument);
! 2494:
! 2495: (*s_etat_processus).erreur_execution =
! 2496: d_ex_erreur_type_argument;
! 2497: return;
! 2498: }
! 2499:
! 2500: interruption = (*((integer8 *) (*(*l_element_courant)
! 2501: .donnee).objet));
! 2502:
! 2503: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
! 2504: {
! 2505: liberation(s_etat_processus, s_objet_argument);
! 2506:
! 2507: (*s_etat_processus).erreur_execution =
! 2508: d_ex_interruption_invalide;
! 2509: return;
! 2510: }
! 2511:
! 2512: (*s_etat_processus).masque_interruptions[interruption - 1] = 'Q';
! 2513: l_element_courant = (*l_element_courant).suivant;
! 2514: }
! 2515: }
! 2516: else
! 2517: {
! 2518: liberation(s_etat_processus, s_objet_argument);
! 2519:
! 2520: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 2521: return;
! 2522: }
! 2523:
! 2524: liberation(s_etat_processus, s_objet_argument);
! 2525:
! 2526: return;
! 2527: }
! 2528:
! 2529:
! 2530: /*
! 2531: ================================================================================
! 2532: Fonction 'sched'
! 2533: ================================================================================
! 2534: Entrées : structure processus
! 2535: --------------------------------------------------------------------------------
! 2536: Sorties :
! 2537: --------------------------------------------------------------------------------
! 2538: Effets de bord : néant
! 2539: ================================================================================
! 2540: */
! 2541:
! 2542: void
! 2543: instruction_sched(struct_processus *s_etat_processus)
! 2544: {
! 2545: real8 pourcentage;
! 2546:
! 2547: struct_objet *s_objet_argument;
! 2548:
! 2549: (*s_etat_processus).erreur_execution = d_ex;
! 2550:
! 2551: if ((*s_etat_processus).affichage_arguments == 'Y')
! 2552: {
! 2553: printf("\n SCHED ");
! 2554:
! 2555: if ((*s_etat_processus).langue == 'F')
! 2556: {
! 2557: printf("(limitation des ressources de calcul)\n\n");
! 2558: }
! 2559: else
! 2560: {
! 2561: printf("(CPU ressources limitation)\n\n");
! 2562: }
! 2563:
! 2564: printf(" 1: %s, %s\n", d_INT, d_REL);
! 2565:
! 2566: return;
! 2567: }
! 2568: else if ((*s_etat_processus).test_instruction == 'Y')
! 2569: {
! 2570: (*s_etat_processus).nombre_arguments = -1;
! 2571: return;
! 2572: }
! 2573:
! 2574: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 2575: {
! 2576: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 2577: {
! 2578: return;
! 2579: }
! 2580: }
! 2581:
! 2582: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 2583: &s_objet_argument) == d_erreur)
! 2584: {
! 2585: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 2586: return;
! 2587: }
! 2588:
! 2589: if ((*s_objet_argument).type == INT)
! 2590: {
! 2591: pourcentage = (real8) (*((integer8 *) (*s_objet_argument).objet));
! 2592: }
! 2593: else if ((*s_objet_argument).type == REL)
! 2594: {
! 2595: pourcentage = (*((real8 *) (*s_objet_argument).objet));
! 2596: }
! 2597: else
! 2598: {
! 2599: liberation(s_etat_processus, s_objet_argument);
! 2600:
! 2601: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 2602: return;
! 2603: }
! 2604:
! 2605: liberation(s_etat_processus, s_objet_argument);
! 2606:
! 2607: if ((pourcentage <= 0) || (pourcentage > 100))
! 2608: {
! 2609: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 2610: return;
! 2611: }
! 2612:
! 2613: (*s_etat_processus).pourcentage_maximal_cpu = pourcentage;
! 2614:
! 2615: return;
! 2616: }
! 2617:
! 2618: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_s9.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src