Annotation of rpl/src/instructions_t2.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 'trn'
! 29: ================================================================================
! 30: Entrées : pointeur sur une structure struct_processus
! 31: --------------------------------------------------------------------------------
! 32: Sorties :
! 33: --------------------------------------------------------------------------------
! 34: Effets de bord : néant
! 35: ================================================================================
! 36: */
! 37:
! 38: void
! 39: instruction_trn(struct_processus *s_etat_processus)
! 40: {
! 41: struct_objet *s_objet_argument;
! 42: struct_objet *s_objet_resultat;
! 43:
! 44: logical1 argument_nom;
! 45: logical1 variable_partagee;
! 46:
! 47: unsigned long i;
! 48: unsigned long j;
! 49:
! 50: (*s_etat_processus).erreur_execution = d_ex;
! 51:
! 52: if ((*s_etat_processus).affichage_arguments == 'Y')
! 53: {
! 54: printf("\n TRN ");
! 55:
! 56: if ((*s_etat_processus).langue == 'F')
! 57: {
! 58: printf("(transposition)\n\n");
! 59: }
! 60: else
! 61: {
! 62: printf("(transposition)\n\n");
! 63: }
! 64:
! 65: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
! 66: printf("-> 1: %s, %s, %s\n\n", d_MIN, d_MRL, d_MCX);
! 67:
! 68: printf(" 1: %s\n", d_NOM);
! 69:
! 70: return;
! 71: }
! 72: else if ((*s_etat_processus).test_instruction == 'Y')
! 73: {
! 74: (*s_etat_processus).nombre_arguments = -1;
! 75: return;
! 76: }
! 77:
! 78: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 79: {
! 80: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 81: {
! 82: return;
! 83: }
! 84: }
! 85:
! 86: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 87: &s_objet_argument) == d_erreur)
! 88: {
! 89: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 90: return;
! 91: }
! 92:
! 93: variable_partagee = d_faux;
! 94:
! 95: if ((*s_objet_argument).type == NOM)
! 96: {
! 97: argument_nom = d_vrai;
! 98:
! 99: if (recherche_variable(s_etat_processus, (*((struct_nom *)
! 100: (*s_objet_argument).objet)).nom) == d_faux)
! 101: {
! 102: (*s_etat_processus).erreur_systeme = d_es;
! 103: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
! 104:
! 105: liberation(s_etat_processus, s_objet_argument);
! 106:
! 107: return;
! 108: }
! 109:
! 110: liberation(s_etat_processus, s_objet_argument);
! 111:
! 112: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
! 113: .position_variable_courante].variable_verrouillee == d_vrai)
! 114: {
! 115: (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
! 116: return;
! 117: }
! 118:
! 119: if ((*s_etat_processus).s_liste_variables
! 120: [(*s_etat_processus).position_variable_courante].objet != NULL)
! 121: {
! 122: s_objet_argument = (*s_etat_processus).s_liste_variables
! 123: [(*s_etat_processus).position_variable_courante].objet;
! 124: }
! 125: else
! 126: {
! 127: if (pthread_mutex_lock(&((*(*s_etat_processus)
! 128: .s_liste_variables_partagees).mutex)) != 0)
! 129: {
! 130: (*s_etat_processus).erreur_systeme = d_es_processus;
! 131: return;
! 132: }
! 133:
! 134: if (recherche_variable_partagee(s_etat_processus,
! 135: (*s_etat_processus).s_liste_variables
! 136: [(*s_etat_processus).position_variable_courante].nom,
! 137: (*s_etat_processus).s_liste_variables
! 138: [(*s_etat_processus).position_variable_courante]
! 139: .variable_partagee, (*s_etat_processus).s_liste_variables
! 140: [(*s_etat_processus).position_variable_courante].origine)
! 141: == d_faux)
! 142: {
! 143: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 144: .s_liste_variables_partagees).mutex)) != 0)
! 145: {
! 146: (*s_etat_processus).erreur_systeme = d_es_processus;
! 147: return;
! 148: }
! 149:
! 150: (*s_etat_processus).erreur_systeme = d_es;
! 151: (*s_etat_processus).erreur_execution =
! 152: d_ex_variable_non_definie;
! 153:
! 154: liberation(s_etat_processus, s_objet_argument);
! 155:
! 156: return;
! 157: }
! 158:
! 159: variable_partagee = d_vrai;
! 160: }
! 161: }
! 162: else
! 163: {
! 164: argument_nom = d_faux;
! 165: }
! 166:
! 167: /*
! 168: --------------------------------------------------------------------------------
! 169: Matrice transposée d'une matrice entière
! 170: --------------------------------------------------------------------------------
! 171: */
! 172:
! 173: if ((*s_objet_argument).type == MIN)
! 174: {
! 175: if ((s_objet_resultat = allocation(s_etat_processus, MIN)) == NULL)
! 176: {
! 177: if (variable_partagee == d_vrai)
! 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:
! 187: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 188: return;
! 189: }
! 190:
! 191: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 192: (*((struct_matrice *) (*s_objet_argument).objet))
! 193: .nombre_colonnes;
! 194: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 195: (*((struct_matrice *) (*s_objet_argument).objet))
! 196: .nombre_lignes;
! 197:
! 198: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 199: malloc((*((struct_matrice *) (*s_objet_resultat).objet))
! 200: .nombre_lignes * sizeof(integer8 *))) == NULL)
! 201: {
! 202: if (variable_partagee == d_vrai)
! 203: {
! 204: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 205: .s_liste_variables_partagees).mutex)) != 0)
! 206: {
! 207: (*s_etat_processus).erreur_systeme = d_es_processus;
! 208: return;
! 209: }
! 210: }
! 211:
! 212: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 213: return;
! 214: }
! 215:
! 216: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet))
! 217: .nombre_lignes; i++)
! 218: {
! 219: if ((((integer8 **) (*((struct_matrice *) (*s_objet_resultat)
! 220: .objet)).tableau)[i] =
! 221: malloc((*((struct_matrice *) (*s_objet_resultat).objet))
! 222: .nombre_colonnes * sizeof(integer8))) == NULL)
! 223: {
! 224: if (variable_partagee == d_vrai)
! 225: {
! 226: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 227: .s_liste_variables_partagees).mutex)) != 0)
! 228: {
! 229: (*s_etat_processus).erreur_systeme = d_es_processus;
! 230: return;
! 231: }
! 232: }
! 233:
! 234: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 235: return;
! 236: }
! 237:
! 238: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat).objet))
! 239: .nombre_colonnes; j++)
! 240: {
! 241: ((integer8 **) (*((struct_matrice *) (*s_objet_resultat)
! 242: .objet)).tableau)[i][j] =
! 243: ((integer8 **) (*((struct_matrice *)
! 244: (*s_objet_argument).objet)).tableau)[j][i];
! 245: }
! 246: }
! 247: }
! 248:
! 249: /*
! 250: --------------------------------------------------------------------------------
! 251: Matrice tranposée d'une matrice réelle
! 252: --------------------------------------------------------------------------------
! 253: */
! 254:
! 255: else if ((*s_objet_argument).type == MRL)
! 256: {
! 257: if ((s_objet_resultat = allocation(s_etat_processus, MRL)) == NULL)
! 258: {
! 259: if (variable_partagee == d_vrai)
! 260: {
! 261: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 262: .s_liste_variables_partagees).mutex)) != 0)
! 263: {
! 264: (*s_etat_processus).erreur_systeme = d_es_processus;
! 265: return;
! 266: }
! 267: }
! 268:
! 269: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 270: return;
! 271: }
! 272:
! 273: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 274: (*((struct_matrice *) (*s_objet_argument).objet))
! 275: .nombre_colonnes;
! 276: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 277: (*((struct_matrice *) (*s_objet_argument).objet))
! 278: .nombre_lignes;
! 279:
! 280: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 281: malloc((*((struct_matrice *) (*s_objet_resultat).objet))
! 282: .nombre_lignes * sizeof(real8 *))) == NULL)
! 283: {
! 284: if (variable_partagee == d_vrai)
! 285: {
! 286: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 287: .s_liste_variables_partagees).mutex)) != 0)
! 288: {
! 289: (*s_etat_processus).erreur_systeme = d_es_processus;
! 290: return;
! 291: }
! 292: }
! 293:
! 294: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 295: return;
! 296: }
! 297:
! 298: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet))
! 299: .nombre_lignes; i++)
! 300: {
! 301: if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat)
! 302: .objet)).tableau)[i] =
! 303: malloc((*((struct_matrice *) (*s_objet_resultat).objet))
! 304: .nombre_colonnes * sizeof(real8))) == NULL)
! 305: {
! 306: if (variable_partagee == d_vrai)
! 307: {
! 308: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 309: .s_liste_variables_partagees).mutex)) != 0)
! 310: {
! 311: (*s_etat_processus).erreur_systeme = d_es_processus;
! 312: return;
! 313: }
! 314: }
! 315:
! 316: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 317: return;
! 318: }
! 319:
! 320: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat).objet))
! 321: .nombre_colonnes; j++)
! 322: {
! 323: ((real8 **) (*((struct_matrice *) (*s_objet_resultat)
! 324: .objet)).tableau)[i][j] =
! 325: ((real8 **) (*((struct_matrice *)
! 326: (*s_objet_argument).objet)).tableau)[j][i];
! 327: }
! 328: }
! 329: }
! 330:
! 331: /*
! 332: --------------------------------------------------------------------------------
! 333: Matrice transposée (et conjuguée) d'une matrice complexe
! 334: --------------------------------------------------------------------------------
! 335: */
! 336:
! 337: else if ((*s_objet_argument).type == MCX)
! 338: {
! 339: if ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL)
! 340: {
! 341: if (variable_partagee == d_vrai)
! 342: {
! 343: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 344: .s_liste_variables_partagees).mutex)) != 0)
! 345: {
! 346: (*s_etat_processus).erreur_systeme = d_es_processus;
! 347: return;
! 348: }
! 349: }
! 350:
! 351: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 352: return;
! 353: }
! 354:
! 355: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
! 356: (*((struct_matrice *) (*s_objet_argument).objet))
! 357: .nombre_colonnes;
! 358: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
! 359: (*((struct_matrice *) (*s_objet_argument).objet))
! 360: .nombre_lignes;
! 361:
! 362: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
! 363: malloc((*((struct_matrice *) (*s_objet_resultat).objet))
! 364: .nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
! 365: {
! 366: if (variable_partagee == d_vrai)
! 367: {
! 368: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 369: .s_liste_variables_partagees).mutex)) != 0)
! 370: {
! 371: (*s_etat_processus).erreur_systeme = d_es_processus;
! 372: return;
! 373: }
! 374: }
! 375:
! 376: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 377: return;
! 378: }
! 379:
! 380: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet))
! 381: .nombre_lignes; i++)
! 382: {
! 383: if ((((struct_complexe16 **) (*((struct_matrice *)
! 384: (*s_objet_resultat).objet)).tableau)[i] =
! 385: malloc((*((struct_matrice *)
! 386: (*s_objet_resultat).objet)).nombre_colonnes *
! 387: sizeof(struct_complexe16))) == NULL)
! 388: {
! 389: if (variable_partagee == d_vrai)
! 390: {
! 391: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 392: .s_liste_variables_partagees).mutex)) != 0)
! 393: {
! 394: (*s_etat_processus).erreur_systeme = d_es_processus;
! 395: return;
! 396: }
! 397: }
! 398:
! 399: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 400: return;
! 401: }
! 402:
! 403: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat).objet))
! 404: .nombre_colonnes; j++)
! 405: {
! 406: ((struct_complexe16 **) (*((struct_matrice *)
! 407: (*s_objet_resultat).objet)).tableau)[i][j]
! 408: .partie_reelle =
! 409: ((struct_complexe16 **) (*((struct_matrice *)
! 410: (*s_objet_argument).objet)).tableau)[j][i]
! 411: .partie_reelle;
! 412: ((struct_complexe16 **) (*((struct_matrice *)
! 413: (*s_objet_resultat).objet)).tableau)[i][j]
! 414: .partie_imaginaire =
! 415: -((struct_complexe16 **) (*((struct_matrice *)
! 416: (*s_objet_argument).objet)).tableau)[j][i]
! 417: .partie_imaginaire;
! 418: }
! 419: }
! 420: }
! 421:
! 422: /*
! 423: --------------------------------------------------------------------------------
! 424: Fonction transposée impossible à réaliser
! 425: --------------------------------------------------------------------------------
! 426: */
! 427:
! 428: else
! 429: {
! 430: if (argument_nom == d_faux)
! 431: {
! 432: liberation(s_etat_processus, s_objet_argument);
! 433: }
! 434:
! 435: if (variable_partagee == d_vrai)
! 436: {
! 437: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 438: .s_liste_variables_partagees).mutex)) != 0)
! 439: {
! 440: (*s_etat_processus).erreur_systeme = d_es_processus;
! 441: return;
! 442: }
! 443: }
! 444:
! 445: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 446: return;
! 447: }
! 448:
! 449: liberation(s_etat_processus, s_objet_argument);
! 450:
! 451: if (argument_nom == d_faux)
! 452: {
! 453: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 454: s_objet_resultat) == d_erreur)
! 455: {
! 456: return;
! 457: }
! 458: }
! 459: else
! 460: {
! 461: if (variable_partagee == d_vrai)
! 462: {
! 463: (*(*s_etat_processus).s_liste_variables_partagees).table
! 464: [(*(*s_etat_processus).s_liste_variables_partagees)
! 465: .position_variable].objet = s_objet_resultat;
! 466:
! 467: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 468: .s_liste_variables_partagees).mutex)) != 0)
! 469: {
! 470: (*s_etat_processus).erreur_systeme = d_es_processus;
! 471: return;
! 472: }
! 473: }
! 474: else
! 475: {
! 476: (*s_etat_processus).s_liste_variables
! 477: [(*s_etat_processus).position_variable_courante].objet =
! 478: s_objet_resultat;
! 479: }
! 480: }
! 481:
! 482: return;
! 483: }
! 484:
! 485:
! 486: /*
! 487: ================================================================================
! 488: Fonction 'tot'
! 489: ================================================================================
! 490: Entrées : pointeur sur une structure struct_processus
! 491: --------------------------------------------------------------------------------
! 492: Sorties :
! 493: --------------------------------------------------------------------------------
! 494: Effets de bord : néant
! 495: ================================================================================
! 496: */
! 497:
! 498: void
! 499: instruction_tot(struct_processus *s_etat_processus)
! 500: {
! 501: logical1 presence_variable;
! 502:
! 503: long i;
! 504:
! 505: struct_objet *s_objet_statistique;
! 506: struct_objet *s_objet_resultat;
! 507: struct_objet *s_objet_temporaire;
! 508:
! 509: unsigned long nombre_colonnes;
! 510:
! 511: (*s_etat_processus).erreur_execution = d_ex;
! 512:
! 513: if ((*s_etat_processus).affichage_arguments == 'Y')
! 514: {
! 515: printf("\n TOT ");
! 516:
! 517: if ((*s_etat_processus).langue == 'F')
! 518: {
! 519: printf("(somme des colonnes statistiques)\n\n");
! 520: }
! 521: else
! 522: {
! 523: printf("(sum of statistical columns)\n\n");
! 524: }
! 525:
! 526: printf("-> 1: %s, %s, %s, %s\n", d_INT, d_REL, d_VIN, d_REL);
! 527:
! 528: return;
! 529: }
! 530: else if ((*s_etat_processus).test_instruction == 'Y')
! 531: {
! 532: (*s_etat_processus).nombre_arguments = -1;
! 533: return;
! 534: }
! 535:
! 536: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 537: {
! 538: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 539: {
! 540: return;
! 541: }
! 542: }
! 543:
! 544: /*
! 545: * Recherche d'une variable globale référencée par SIGMA
! 546: */
! 547:
! 548: if (recherche_variable(s_etat_processus, ds_sdat) == d_faux)
! 549: {
! 550: /*
! 551: * Aucune variable SIGMA
! 552: */
! 553:
! 554: (*s_etat_processus).erreur_systeme = d_es;
! 555: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
! 556: return;
! 557: }
! 558: else
! 559: {
! 560: /*
! 561: * Il existe une variable locale SIGMA. Reste à vérifier l'existence
! 562: * d'une variable SIGMA globale...
! 563: */
! 564:
! 565: i = (*s_etat_processus).position_variable_courante;
! 566: presence_variable = d_faux;
! 567:
! 568: while(i >= 0)
! 569: {
! 570: if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
! 571: ds_sdat) == 0) && ((*s_etat_processus)
! 572: .s_liste_variables[i].niveau == 1))
! 573: {
! 574: presence_variable = d_vrai;
! 575: break;
! 576: }
! 577:
! 578: i--;
! 579: }
! 580:
! 581: if (presence_variable == d_faux)
! 582: {
! 583: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
! 584: return;
! 585: }
! 586: else
! 587: {
! 588: (*s_etat_processus).position_variable_courante = i;
! 589:
! 590: if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
! 591: {
! 592: (*s_etat_processus).erreur_execution = d_ex_variable_partagee;
! 593: return;
! 594: }
! 595:
! 596: if (((*((*s_etat_processus).s_liste_variables
! 597: [(*s_etat_processus).position_variable_courante].objet))
! 598: .type != MIN) && ((*((*s_etat_processus)
! 599: .s_liste_variables[(*s_etat_processus)
! 600: .position_variable_courante].objet)).type != MRL))
! 601: {
! 602: (*s_etat_processus).erreur_execution =
! 603: d_ex_matrice_statistique_invalide;
! 604: return;
! 605: }
! 606:
! 607: nombre_colonnes = (*((struct_matrice *) (*((*s_etat_processus)
! 608: .s_liste_variables[(*s_etat_processus)
! 609: .position_variable_courante].objet)).objet))
! 610: .nombre_colonnes;
! 611: }
! 612: }
! 613:
! 614: if (nombre_colonnes == 0)
! 615: {
! 616: (*s_etat_processus).erreur_execution =
! 617: d_ex_matrice_statistique_invalide;
! 618: return;
! 619: }
! 620:
! 621: s_objet_statistique = ((*s_etat_processus).s_liste_variables
! 622: [(*s_etat_processus).position_variable_courante]).objet;
! 623:
! 624: if (((*s_objet_statistique).type == MIN) ||
! 625: ((*s_objet_statistique).type == MRL))
! 626: {
! 627: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
! 628: {
! 629: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 630: return;
! 631: }
! 632:
! 633: if (((*s_objet_resultat).objet = sommation_statistique(
! 634: (struct_matrice *) (*s_objet_statistique).objet)) == NULL)
! 635: {
! 636: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 637: return;
! 638: }
! 639:
! 640: if (nombre_colonnes == 1)
! 641: {
! 642: if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I')
! 643: {
! 644: (*s_objet_resultat).type = VIN;
! 645: s_objet_temporaire = s_objet_resultat;
! 646:
! 647: if ((s_objet_resultat = allocation(s_etat_processus, INT))
! 648: == NULL)
! 649: {
! 650: (*s_etat_processus).erreur_systeme =
! 651: d_es_allocation_memoire;
! 652: return;
! 653: }
! 654:
! 655: (*((integer8 *) (*s_objet_resultat).objet)) =
! 656: ((integer8 *) (*((struct_vecteur *)
! 657: (*s_objet_temporaire).objet)).tableau)[0];
! 658:
! 659: liberation(s_etat_processus, s_objet_temporaire);
! 660: }
! 661: else
! 662: {
! 663: (*s_objet_resultat).type = VRL;
! 664: s_objet_temporaire = s_objet_resultat;
! 665:
! 666: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 667: == NULL)
! 668: {
! 669: (*s_etat_processus).erreur_systeme =
! 670: d_es_allocation_memoire;
! 671: return;
! 672: }
! 673:
! 674: (*((real8 *) (*s_objet_resultat).objet)) =
! 675: ((real8 *) (*((struct_vecteur *)
! 676: (*s_objet_temporaire).objet)).tableau)[0];
! 677:
! 678: liberation(s_etat_processus, s_objet_temporaire);
! 679: }
! 680: }
! 681: else
! 682: {
! 683: if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I')
! 684: {
! 685: (*s_objet_resultat).type = VIN;
! 686: }
! 687: else
! 688: {
! 689: (*s_objet_resultat).type = VRL;
! 690: }
! 691: }
! 692:
! 693: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 694: s_objet_resultat) == d_erreur)
! 695: {
! 696: return;
! 697: }
! 698: }
! 699: else
! 700: {
! 701: (*s_etat_processus).erreur_execution =
! 702: d_ex_matrice_statistique_invalide;
! 703: return;
! 704: }
! 705:
! 706: return;
! 707: }
! 708:
! 709:
! 710: /*
! 711: ================================================================================
! 712: Fonction 'title'
! 713: ================================================================================
! 714: Entrées :
! 715: --------------------------------------------------------------------------------
! 716: Sorties :
! 717: --------------------------------------------------------------------------------
! 718: Effets de bord : néant
! 719: ================================================================================
! 720: */
! 721:
! 722: void
! 723: instruction_title(struct_processus *s_etat_processus)
! 724: {
! 725: struct_objet *s_objet;
! 726:
! 727: (*s_etat_processus).erreur_execution = d_ex;
! 728:
! 729: if ((*s_etat_processus).affichage_arguments == 'Y')
! 730: {
! 731: printf("\n TITLE ");
! 732:
! 733: if ((*s_etat_processus).langue == 'F')
! 734: {
! 735: printf("(titre d'un graphique)\n\n");
! 736: }
! 737: else
! 738: {
! 739: printf("(title of graphic)\n\n");
! 740: }
! 741:
! 742: printf(" 1: %s\n", d_CHN);
! 743:
! 744: return;
! 745: }
! 746: else if ((*s_etat_processus).test_instruction == 'Y')
! 747: {
! 748: (*s_etat_processus).nombre_arguments = -1;
! 749: return;
! 750: }
! 751:
! 752: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 753: {
! 754: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 755: {
! 756: return;
! 757: }
! 758: }
! 759:
! 760: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 761: &s_objet) == d_erreur)
! 762: {
! 763: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 764: return;
! 765: }
! 766:
! 767: if ((*s_objet).type == CHN)
! 768: {
! 769: free((*s_etat_processus).titre);
! 770:
! 771: if (((*s_etat_processus).titre = malloc((strlen((unsigned char *)
! 772: (*s_objet).objet) + 1) * sizeof(unsigned char))) == NULL)
! 773: {
! 774: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 775: return;
! 776: }
! 777:
! 778: strcpy((*s_etat_processus).titre, (unsigned char *) (*s_objet).objet);
! 779: liberation(s_etat_processus, s_objet);
! 780: }
! 781: else
! 782: {
! 783: liberation(s_etat_processus, s_objet);
! 784:
! 785: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 786: return;
! 787: }
! 788:
! 789: if (test_cfsf(s_etat_processus, 52) == d_faux)
! 790: {
! 791: if ((*s_etat_processus).fichiers_graphiques != NULL)
! 792: {
! 793: appel_gnuplot(s_etat_processus, 'N');
! 794: }
! 795: }
! 796:
! 797: return;
! 798: }
! 799:
! 800:
! 801: /*
! 802: ================================================================================
! 803: Fonction 'time'
! 804: ================================================================================
! 805: Entrées :
! 806: --------------------------------------------------------------------------------
! 807: Sorties :
! 808: --------------------------------------------------------------------------------
! 809: Effets de bord : néant
! 810: ================================================================================
! 811: */
! 812:
! 813: void
! 814: instruction_time(struct_processus *s_etat_processus)
! 815: {
! 816: struct rusage s_usage_processus_fils;
! 817: struct rusage s_usage_processus_pere;
! 818:
! 819: struct_liste_chainee *l_element_courant;
! 820:
! 821: struct_objet *s_objet;
! 822:
! 823: (*s_etat_processus).erreur_execution = d_ex;
! 824:
! 825: if ((*s_etat_processus).affichage_arguments == 'Y')
! 826: {
! 827: printf("\n TIME ");
! 828:
! 829: if ((*s_etat_processus).langue == 'F')
! 830: {
! 831: printf("(temps CPU)\n\n");
! 832: }
! 833: else
! 834: {
! 835: printf("(CPU time)\n\n");
! 836: }
! 837:
! 838: printf("-> 1: %s\n", d_LST);
! 839:
! 840: return;
! 841: }
! 842: else if ((*s_etat_processus).test_instruction == 'Y')
! 843: {
! 844: (*s_etat_processus).nombre_arguments = -1;
! 845: return;
! 846: }
! 847:
! 848: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 849: {
! 850: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 851: {
! 852: return;
! 853: }
! 854: }
! 855:
! 856: /*
! 857: * Lecture des différents temps
! 858: */
! 859:
! 860: if ((getrusage(RUSAGE_SELF, &s_usage_processus_pere)) != 0)
! 861: {
! 862: (*s_etat_processus).erreur_systeme = d_es_processus;
! 863: return;
! 864: }
! 865:
! 866: if ((getrusage(RUSAGE_CHILDREN, &s_usage_processus_fils)) != 0)
! 867: {
! 868: (*s_etat_processus).erreur_systeme = d_es_processus;
! 869: return;
! 870: }
! 871:
! 872: /*
! 873: * Initialisation de la liste
! 874: */
! 875:
! 876: if ((s_objet = allocation(s_etat_processus, LST)) == NULL)
! 877: {
! 878: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 879: return;
! 880: }
! 881:
! 882: /*
! 883: * User time du processus père (séquenceur)
! 884: */
! 885:
! 886: if ((l_element_courant = allocation_maillon(s_etat_processus)) == NULL)
! 887: {
! 888: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 889: return;
! 890: }
! 891:
! 892: (*s_objet).objet = l_element_courant;
! 893:
! 894: if (((*l_element_courant).donnee = allocation(s_etat_processus, REL))
! 895: == NULL)
! 896: {
! 897: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 898: return;
! 899: }
! 900:
! 901: (*((real8 *) (*(*l_element_courant).donnee).objet)) =
! 902: s_usage_processus_pere.ru_utime.tv_sec +
! 903: (((real8) s_usage_processus_pere.ru_utime.tv_usec) /
! 904: ((real8) 1E6));
! 905:
! 906: /*
! 907: * System time du processus père
! 908: */
! 909:
! 910: if (((*l_element_courant).suivant =
! 911: allocation_maillon(s_etat_processus)) == NULL)
! 912: {
! 913: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 914: return;
! 915: }
! 916:
! 917: l_element_courant = (*l_element_courant).suivant;
! 918:
! 919: if (((*l_element_courant).donnee = allocation(s_etat_processus, REL))
! 920: == NULL)
! 921: {
! 922: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 923: return;
! 924: }
! 925:
! 926: (*((real8 *) (*(*l_element_courant).donnee).objet)) =
! 927: s_usage_processus_pere.ru_stime.tv_sec +
! 928: (((real8) s_usage_processus_pere.ru_stime.tv_usec) /
! 929: ((real8) 1E6));
! 930:
! 931: /*
! 932: * User time des processus fils achevés
! 933: */
! 934:
! 935: if (((*l_element_courant).suivant =
! 936: allocation_maillon(s_etat_processus)) == NULL)
! 937: {
! 938: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 939: return;
! 940: }
! 941:
! 942: l_element_courant = (*l_element_courant).suivant;
! 943:
! 944: if (((*l_element_courant).donnee = allocation(s_etat_processus, REL))
! 945: == NULL)
! 946: {
! 947: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 948: return;
! 949: }
! 950:
! 951: (*((real8 *) (*(*l_element_courant).donnee).objet)) =
! 952: s_usage_processus_fils.ru_utime.tv_sec +
! 953: (((real8) s_usage_processus_fils.ru_utime.tv_usec) /
! 954: ((real8) 1E6));
! 955:
! 956: /*
! 957: * System time des processus fils achevés
! 958: */
! 959:
! 960: if (((*l_element_courant).suivant =
! 961: allocation_maillon(s_etat_processus)) == NULL)
! 962: {
! 963: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 964: return;
! 965: }
! 966:
! 967: l_element_courant = (*l_element_courant).suivant;
! 968:
! 969: if (((*l_element_courant).donnee = allocation(s_etat_processus, REL))
! 970: == NULL)
! 971: {
! 972: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 973: return;
! 974: }
! 975:
! 976: (*((real8 *) (*(*l_element_courant).donnee).objet)) =
! 977: s_usage_processus_fils.ru_stime.tv_sec +
! 978: (((real8) s_usage_processus_fils.ru_stime.tv_usec) /
! 979: ((real8) 1E6));
! 980:
! 981: /*
! 982: * Fermeture de la liste
! 983: */
! 984:
! 985: (*l_element_courant).suivant = NULL;
! 986:
! 987: /*
! 988: * Empilement du résultat
! 989: */
! 990:
! 991: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 992: s_objet) == d_erreur)
! 993: {
! 994: return;
! 995: }
! 996:
! 997: return;
! 998: }
! 999:
! 1000:
! 1001: /*
! 1002: ================================================================================
! 1003: Fonction 'taylr'
! 1004: ================================================================================
! 1005: Entrées :
! 1006: --------------------------------------------------------------------------------
! 1007: Sorties :
! 1008: --------------------------------------------------------------------------------
! 1009: Effets de bord : néant
! 1010: ================================================================================
! 1011: */
! 1012:
! 1013: void
! 1014: instruction_taylr(struct_processus *s_etat_processus)
! 1015: {
! 1016: integer8 i;
! 1017:
! 1018: logical1 last_valide;
! 1019: logical1 zero;
! 1020:
! 1021: struct_liste_chainee *l_element_courant;
! 1022:
! 1023: struct_objet *s_objet_argument;
! 1024: struct_objet *s_objet_argument_1;
! 1025: struct_objet *s_objet_argument_2;
! 1026: struct_objet *s_objet_argument_3;
! 1027: struct_objet *s_objet_argument_4;
! 1028: struct_objet *s_objet_resultat;
! 1029: struct_objet *s_objet_variable_derivation;
! 1030:
! 1031: struct_variable s_variable;
! 1032:
! 1033: (*s_etat_processus).erreur_execution = d_ex;
! 1034:
! 1035: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1036: {
! 1037: printf("\n TAYLR ");
! 1038:
! 1039: if ((*s_etat_processus).langue == 'F')
! 1040: {
! 1041: printf("(série de Taylor)\n\n");
! 1042: }
! 1043: else
! 1044: {
! 1045: printf("(Taylor serie)\n\n");
! 1046: }
! 1047:
! 1048: printf(" 4: %s\n", d_ALG);
! 1049: printf(" 3: %s\n", d_NOM);
! 1050: printf(" 2: %s, %s\n", d_INT, d_REL);
! 1051: printf(" 1: %s\n", d_INT);
! 1052: printf("-> 1: %s\n\n", d_ALG);
! 1053:
! 1054: return;
! 1055: }
! 1056: else if ((*s_etat_processus).test_instruction == 'Y')
! 1057: {
! 1058: (*s_etat_processus).nombre_arguments = -1;
! 1059: return;
! 1060: }
! 1061:
! 1062: if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai)
! 1063: {
! 1064: if (empilement_pile_last(s_etat_processus, 4) == d_erreur)
! 1065: {
! 1066: return;
! 1067: }
! 1068: }
! 1069:
! 1070: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1071: &s_objet_argument_1) == d_erreur)
! 1072: {
! 1073: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1074: return;
! 1075: }
! 1076:
! 1077: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1078: &s_objet_argument_2) == d_erreur)
! 1079: {
! 1080: liberation(s_etat_processus, s_objet_argument_1);
! 1081:
! 1082: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1083: return;
! 1084: }
! 1085:
! 1086: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1087: &s_objet_argument_3) == d_erreur)
! 1088: {
! 1089: liberation(s_etat_processus, s_objet_argument_1);
! 1090: liberation(s_etat_processus, s_objet_argument_2);
! 1091:
! 1092: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1093: return;
! 1094: }
! 1095:
! 1096: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1097: &s_objet_argument_4) == d_erreur)
! 1098: {
! 1099: liberation(s_etat_processus, s_objet_argument_1);
! 1100: liberation(s_etat_processus, s_objet_argument_2);
! 1101: liberation(s_etat_processus, s_objet_argument_3);
! 1102: liberation(s_etat_processus, s_objet_argument_4);
! 1103:
! 1104: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1105: return;
! 1106: }
! 1107:
! 1108: if (((*s_objet_argument_4).type == ALG) &&
! 1109: ((*s_objet_argument_3).type == NOM) &&
! 1110: (((*s_objet_argument_2).type == INT) ||
! 1111: ((*s_objet_argument_2).type == REL)) &&
! 1112: ((*s_objet_argument_1).type == INT))
! 1113: {
! 1114: if ((*((integer8 *) (*s_objet_argument_1).objet)) <= 0)
! 1115: {
! 1116: liberation(s_etat_processus, s_objet_argument_1);
! 1117: liberation(s_etat_processus, s_objet_argument_2);
! 1118: liberation(s_etat_processus, s_objet_argument_3);
! 1119: liberation(s_etat_processus, s_objet_argument_4);
! 1120:
! 1121: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 1122: return;
! 1123: }
! 1124:
! 1125: if ((*s_objet_argument_2).type == REL)
! 1126: {
! 1127: if ((*((real8 *) (*s_objet_argument_2).objet)) == 0)
! 1128: {
! 1129: zero = d_vrai;
! 1130: }
! 1131: else
! 1132: {
! 1133: zero = d_faux;
! 1134: }
! 1135: }
! 1136: else
! 1137: {
! 1138: if ((*((integer8 *) (*s_objet_argument_2).objet)) == 0)
! 1139: {
! 1140: zero = d_vrai;
! 1141: }
! 1142: else
! 1143: {
! 1144: zero = d_faux;
! 1145: }
! 1146: }
! 1147:
! 1148: /*
! 1149: * Conversion du drapeau symbole des variables symboliques
! 1150: */
! 1151:
! 1152: l_element_courant = (*s_objet_argument_4).objet;
! 1153:
! 1154: while(l_element_courant != NULL)
! 1155: {
! 1156: if ((*(*l_element_courant).donnee).type == NOM)
! 1157: {
! 1158: if (strcmp((*((struct_nom *) (*(*l_element_courant).donnee)
! 1159: .objet)).nom, (*((struct_nom *) (*s_objet_argument_3)
! 1160: .objet)).nom) == 0)
! 1161: {
! 1162: (*((struct_nom *) (*(*l_element_courant).donnee).objet))
! 1163: .symbole = d_faux;
! 1164: }
! 1165: }
! 1166:
! 1167: l_element_courant = (*l_element_courant).suivant;
! 1168: }
! 1169:
! 1170: /*
! 1171: * Création de la variable locale et initialisation
! 1172: */
! 1173:
! 1174: (*s_etat_processus).niveau_courant++;
! 1175:
! 1176: if ((s_variable.nom = malloc((strlen((*((struct_nom *)
! 1177: (*s_objet_argument_3).objet)).nom) + 1) *
! 1178: sizeof(unsigned char))) == NULL)
! 1179: {
! 1180: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1181: return;
! 1182: }
! 1183:
! 1184: s_variable.niveau = (*s_etat_processus).niveau_courant;
! 1185: strcpy(s_variable.nom, (*((struct_nom *) (*s_objet_argument_3)
! 1186: .objet)).nom);
! 1187:
! 1188: if ((s_variable.objet = copie_objet(s_etat_processus,
! 1189: s_objet_argument_2, 'O')) == NULL)
! 1190: {
! 1191: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1192: return;
! 1193: }
! 1194:
! 1195: if (creation_variable(s_etat_processus, &s_variable, 'V', 'P')
! 1196: == d_erreur)
! 1197: {
! 1198: return;
! 1199: }
! 1200:
! 1201: /*
! 1202: * Création de la série
! 1203: */
! 1204:
! 1205: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
! 1206: {
! 1207: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1208: return;
! 1209: }
! 1210:
! 1211: if (((*s_objet_resultat).objet =
! 1212: allocation_maillon(s_etat_processus)) == NULL)
! 1213: {
! 1214: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1215: return;
! 1216: }
! 1217:
! 1218: l_element_courant = (*s_objet_resultat).objet;
! 1219:
! 1220: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 1221: == NULL)
! 1222: {
! 1223: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1224: return;
! 1225: }
! 1226:
! 1227: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1228: .nombre_arguments = 0;
! 1229: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1230: .fonction = instruction_vers_niveau_superieur;
! 1231:
! 1232: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1233: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 1234: {
! 1235: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1236: return;
! 1237: }
! 1238:
! 1239: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1240: .nom_fonction, "<<");
! 1241:
! 1242: if (last_valide == d_vrai)
! 1243: {
! 1244: cf(s_etat_processus, 31);
! 1245: }
! 1246:
! 1247: /*
! 1248: * Calcul de la série de Taylor
! 1249: *
! 1250: * s(x) = \sum_{i=0}{n} (1/i!)*((d^i f(x=a))/d(x^i)*(x-a)^i)
! 1251: */
! 1252:
! 1253: for(i = 0; (i <= (*((integer8 *) (*s_objet_argument_1).objet))) &&
! 1254: ((*s_etat_processus).var_volatile_requete_arret == 0); i++)
! 1255: {
! 1256: /*
! 1257: * Calcul de ((d^i f(x=a))/d(x^i)*(x-a)^i)/i!
! 1258: */
! 1259:
! 1260: if (i != 0)
! 1261: {
! 1262: // Calcul de la valeur de la dérivée n-ième
! 1263: // Expression empilée puis dérivée et sauvegardée dans
! 1264: // s_argument_4.
! 1265:
! 1266: if (empilement(s_etat_processus, &((*s_etat_processus)
! 1267: .l_base_pile), s_objet_argument_4) == d_erreur)
! 1268: {
! 1269: if (last_valide == d_vrai)
! 1270: {
! 1271: sf(s_etat_processus, 31);
! 1272: }
! 1273:
! 1274: return;
! 1275: }
! 1276:
! 1277: if ((s_objet_variable_derivation =
! 1278: copie_objet(s_etat_processus, s_objet_argument_3, 'O'))
! 1279: == NULL)
! 1280: {
! 1281: (*s_etat_processus).erreur_systeme =
! 1282: d_es_allocation_memoire;
! 1283: return;
! 1284: }
! 1285:
! 1286: if (empilement(s_etat_processus, &((*s_etat_processus)
! 1287: .l_base_pile), s_objet_variable_derivation) == d_erreur)
! 1288: {
! 1289: if (last_valide == d_vrai)
! 1290: {
! 1291: sf(s_etat_processus, 31);
! 1292: }
! 1293:
! 1294: return;
! 1295: }
! 1296:
! 1297: instruction_der(s_etat_processus);
! 1298:
! 1299: if ((*s_etat_processus).erreur_execution != d_ex)
! 1300: {
! 1301: liberation(s_etat_processus, s_objet_argument_1);
! 1302: liberation(s_etat_processus, s_objet_argument_2);
! 1303: liberation(s_etat_processus, s_objet_argument_3);
! 1304:
! 1305: (*l_element_courant).suivant = NULL;
! 1306:
! 1307: liberation(s_etat_processus, s_objet_resultat);
! 1308:
! 1309: if (last_valide == d_vrai)
! 1310: {
! 1311: sf(s_etat_processus, 31);
! 1312: }
! 1313:
! 1314: return;
! 1315: }
! 1316: else if ((*s_etat_processus).erreur_systeme != d_es)
! 1317: {
! 1318: return;
! 1319: }
! 1320:
! 1321: if ((*s_etat_processus).var_volatile_requete_arret != 0)
! 1322: {
! 1323: /*
! 1324: * instruction_der() n'a rien renvoyé dans la pile. On
! 1325: * injecte une valeur nulle dans s_objet_argument_4.
! 1326: */
! 1327:
! 1328: if ((s_objet_argument_4 = allocation(s_etat_processus,
! 1329: INT)) == NULL)
! 1330: {
! 1331: (*s_etat_processus).erreur_systeme =
! 1332: d_es_allocation_memoire;
! 1333: return;
! 1334: }
! 1335: }
! 1336: else if (depilement(s_etat_processus, &((*s_etat_processus)
! 1337: .l_base_pile), &s_objet_argument_4) == d_erreur)
! 1338: {
! 1339: liberation(s_etat_processus, s_objet_argument_1);
! 1340: liberation(s_etat_processus, s_objet_argument_2);
! 1341: liberation(s_etat_processus, s_objet_argument_3);
! 1342:
! 1343: (*l_element_courant).suivant = NULL;
! 1344:
! 1345: liberation(s_etat_processus, s_objet_resultat);
! 1346:
! 1347: if (last_valide == d_vrai)
! 1348: {
! 1349: sf(s_etat_processus, 31);
! 1350: }
! 1351:
! 1352: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1353: return;
! 1354: }
! 1355: }
! 1356:
! 1357: if (evaluation(s_etat_processus, s_objet_argument_4, 'E')
! 1358: == d_erreur)
! 1359: {
! 1360: liberation(s_etat_processus, s_objet_argument_1);
! 1361: liberation(s_etat_processus, s_objet_argument_2);
! 1362: liberation(s_etat_processus, s_objet_argument_3);
! 1363: liberation(s_etat_processus, s_objet_argument_4);
! 1364:
! 1365: (*l_element_courant).suivant = NULL;
! 1366:
! 1367: liberation(s_etat_processus, s_objet_resultat);
! 1368:
! 1369: if (last_valide == d_vrai)
! 1370: {
! 1371: sf(s_etat_processus, 31);
! 1372: }
! 1373:
! 1374: return;
! 1375: }
! 1376:
! 1377: // Division par i!
! 1378:
! 1379: if (i > 1)
! 1380: {
! 1381:
! 1382: if ((s_objet_argument = allocation(s_etat_processus, INT))
! 1383: == NULL)
! 1384: {
! 1385: (*s_etat_processus).erreur_systeme =
! 1386: d_es_allocation_memoire;
! 1387: return;
! 1388: }
! 1389:
! 1390: (*((integer8 *) (*s_objet_argument).objet)) = i;
! 1391:
! 1392: if (empilement(s_etat_processus, &((*s_etat_processus)
! 1393: .l_base_pile), s_objet_argument) == d_erreur)
! 1394: {
! 1395: liberation(s_etat_processus, s_objet_argument_1);
! 1396: liberation(s_etat_processus, s_objet_argument_2);
! 1397: liberation(s_etat_processus, s_objet_argument_3);
! 1398: liberation(s_etat_processus, s_objet_argument_4);
! 1399:
! 1400: (*l_element_courant).suivant = NULL;
! 1401:
! 1402: liberation(s_etat_processus, s_objet_resultat);
! 1403: liberation(s_etat_processus, s_objet_argument);
! 1404:
! 1405: if (last_valide == d_vrai)
! 1406: {
! 1407: sf(s_etat_processus, 31);
! 1408: }
! 1409:
! 1410: return;
! 1411: }
! 1412:
! 1413: if (i > 2)
! 1414: {
! 1415: instruction_fact(s_etat_processus);
! 1416:
! 1417: if ((*s_etat_processus).erreur_execution != d_ex)
! 1418: {
! 1419: liberation(s_etat_processus, s_objet_argument_1);
! 1420: liberation(s_etat_processus, s_objet_argument_2);
! 1421: liberation(s_etat_processus, s_objet_argument_3);
! 1422: liberation(s_etat_processus, s_objet_argument_4);
! 1423:
! 1424: (*l_element_courant).suivant = NULL;
! 1425:
! 1426: liberation(s_etat_processus, s_objet_resultat);
! 1427:
! 1428: if (last_valide == d_vrai)
! 1429: {
! 1430: sf(s_etat_processus, 31);
! 1431: }
! 1432:
! 1433: return;
! 1434: }
! 1435: else if ((*s_etat_processus).erreur_systeme != d_es)
! 1436: {
! 1437: return;
! 1438: }
! 1439: }
! 1440:
! 1441: instruction_division(s_etat_processus);
! 1442:
! 1443: if ((*s_etat_processus).erreur_execution != d_ex)
! 1444: {
! 1445: liberation(s_etat_processus, s_objet_argument_1);
! 1446: liberation(s_etat_processus, s_objet_argument_2);
! 1447: liberation(s_etat_processus, s_objet_argument_3);
! 1448: liberation(s_etat_processus, s_objet_argument_4);
! 1449:
! 1450: (*l_element_courant).suivant = NULL;
! 1451:
! 1452: liberation(s_etat_processus, s_objet_resultat);
! 1453:
! 1454: if (last_valide == d_vrai)
! 1455: {
! 1456: sf(s_etat_processus, 31);
! 1457: }
! 1458:
! 1459: return;
! 1460: }
! 1461: else if ((*s_etat_processus).erreur_systeme != d_es)
! 1462: {
! 1463: return;
! 1464: }
! 1465: }
! 1466:
! 1467: if (((*l_element_courant).suivant =
! 1468: allocation_maillon(s_etat_processus)) == NULL)
! 1469: {
! 1470: (*s_etat_processus).erreur_systeme =
! 1471: d_es_allocation_memoire;
! 1472: return;
! 1473: }
! 1474:
! 1475: l_element_courant = (*l_element_courant).suivant;
! 1476:
! 1477: if (depilement(s_etat_processus, &((*s_etat_processus)
! 1478: .l_base_pile), &((*l_element_courant).donnee))
! 1479: == d_erreur)
! 1480: {
! 1481: liberation(s_etat_processus, s_objet_argument_1);
! 1482: liberation(s_etat_processus, s_objet_argument_2);
! 1483: liberation(s_etat_processus, s_objet_argument_3);
! 1484: liberation(s_etat_processus, s_objet_argument_4);
! 1485:
! 1486: (*l_element_courant).donnee = NULL;
! 1487: (*l_element_courant).suivant = NULL;
! 1488:
! 1489: liberation(s_etat_processus, s_objet_resultat);
! 1490:
! 1491: if (last_valide == d_vrai)
! 1492: {
! 1493: sf(s_etat_processus, 31);
! 1494: }
! 1495:
! 1496: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1497: return;
! 1498: }
! 1499:
! 1500: /*
! 1501: * Multiplication par le terme (x-a)**i
! 1502: */
! 1503:
! 1504: if (i != 0)
! 1505: {
! 1506: if (((*l_element_courant).suivant =
! 1507: allocation_maillon(s_etat_processus)) == NULL)
! 1508: {
! 1509: (*s_etat_processus).erreur_systeme =
! 1510: d_es_allocation_memoire;
! 1511: return;
! 1512: }
! 1513:
! 1514: l_element_courant = (*l_element_courant).suivant;
! 1515:
! 1516: if (((*l_element_courant).donnee =
! 1517: copie_objet(s_etat_processus, s_objet_argument_3, 'O'))
! 1518: == NULL)
! 1519: {
! 1520: (*s_etat_processus).erreur_systeme =
! 1521: d_es_allocation_memoire;
! 1522: return;
! 1523: }
! 1524:
! 1525: if (zero == d_faux)
! 1526: {
! 1527: if (((*l_element_courant).suivant =
! 1528: allocation_maillon(s_etat_processus)) == NULL)
! 1529: {
! 1530: (*s_etat_processus).erreur_systeme =
! 1531: d_es_allocation_memoire;
! 1532: return;
! 1533: }
! 1534:
! 1535: l_element_courant = (*l_element_courant).suivant;
! 1536:
! 1537: if (((*l_element_courant).donnee =
! 1538: copie_objet(s_etat_processus, s_objet_argument_2,
! 1539: 'O')) == NULL)
! 1540: {
! 1541: (*s_etat_processus).erreur_systeme =
! 1542: d_es_allocation_memoire;
! 1543: return;
! 1544: }
! 1545:
! 1546: if (((*l_element_courant).suivant =
! 1547: allocation_maillon(s_etat_processus)) == NULL)
! 1548: {
! 1549: (*s_etat_processus).erreur_systeme =
! 1550: d_es_allocation_memoire;
! 1551: return;
! 1552: }
! 1553:
! 1554: l_element_courant = (*l_element_courant).suivant;
! 1555:
! 1556: if (((*l_element_courant).donnee =
! 1557: allocation(s_etat_processus, FCT)) == NULL)
! 1558: {
! 1559: (*s_etat_processus).erreur_systeme =
! 1560: d_es_allocation_memoire;
! 1561: return;
! 1562: }
! 1563:
! 1564: (*((struct_fonction *) (*(*l_element_courant).donnee)
! 1565: .objet)).nombre_arguments = 0;
! 1566: (*((struct_fonction *) (*(*l_element_courant).donnee)
! 1567: .objet)).fonction = instruction_moins;
! 1568:
! 1569: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
! 1570: .objet)).nom_fonction = malloc(2 *
! 1571: sizeof(unsigned char))) == NULL)
! 1572: {
! 1573: (*s_etat_processus).erreur_systeme =
! 1574: d_es_allocation_memoire;
! 1575: return;
! 1576: }
! 1577:
! 1578: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
! 1579: .objet)).nom_fonction, "-");
! 1580: }
! 1581:
! 1582: if (i > 1)
! 1583: {
! 1584: if (((*l_element_courant).suivant =
! 1585: allocation_maillon(s_etat_processus)) == NULL)
! 1586: {
! 1587: (*s_etat_processus).erreur_systeme =
! 1588: d_es_allocation_memoire;
! 1589: return;
! 1590: }
! 1591:
! 1592: l_element_courant = (*l_element_courant).suivant;
! 1593:
! 1594: if (((*l_element_courant).donnee =
! 1595: allocation(s_etat_processus, INT)) == NULL)
! 1596: {
! 1597: (*s_etat_processus).erreur_systeme =
! 1598: d_es_allocation_memoire;
! 1599: return;
! 1600: }
! 1601:
! 1602: (*((integer8 *) (*(*l_element_courant).donnee).objet)) = i;
! 1603:
! 1604: if (((*l_element_courant).suivant =
! 1605: allocation_maillon(s_etat_processus)) == NULL)
! 1606: {
! 1607: (*s_etat_processus).erreur_systeme =
! 1608: d_es_allocation_memoire;
! 1609: return;
! 1610: }
! 1611:
! 1612: l_element_courant = (*l_element_courant).suivant;
! 1613:
! 1614: if (((*l_element_courant).donnee =
! 1615: allocation(s_etat_processus, FCT)) == NULL)
! 1616: {
! 1617: (*s_etat_processus).erreur_systeme =
! 1618: d_es_allocation_memoire;
! 1619: return;
! 1620: }
! 1621:
! 1622: (*((struct_fonction *) (*(*l_element_courant).donnee)
! 1623: .objet)).nombre_arguments = 0;
! 1624: (*((struct_fonction *) (*(*l_element_courant).donnee)
! 1625: .objet)).fonction = instruction_puissance;
! 1626:
! 1627: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
! 1628: .objet)).nom_fonction = malloc(2 *
! 1629: sizeof(unsigned char))) == NULL)
! 1630: {
! 1631: (*s_etat_processus).erreur_systeme =
! 1632: d_es_allocation_memoire;
! 1633: return;
! 1634: }
! 1635:
! 1636: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
! 1637: .objet)).nom_fonction, "^");
! 1638: }
! 1639:
! 1640: if (((*l_element_courant).suivant =
! 1641: allocation_maillon(s_etat_processus)) == NULL)
! 1642: {
! 1643: (*s_etat_processus).erreur_systeme =
! 1644: d_es_allocation_memoire;
! 1645: return;
! 1646: }
! 1647:
! 1648: l_element_courant = (*l_element_courant).suivant;
! 1649:
! 1650: if (((*l_element_courant).donnee = allocation(s_etat_processus,
! 1651: FCT)) == NULL)
! 1652: {
! 1653: (*s_etat_processus).erreur_systeme =
! 1654: d_es_allocation_memoire;
! 1655: return;
! 1656: }
! 1657:
! 1658: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1659: .nombre_arguments = 0;
! 1660: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1661: .fonction = instruction_multiplication;
! 1662:
! 1663: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
! 1664: .objet)).nom_fonction = malloc(2 *
! 1665: sizeof(unsigned char))) == NULL)
! 1666: {
! 1667: (*s_etat_processus).erreur_systeme =
! 1668: d_es_allocation_memoire;
! 1669: return;
! 1670: }
! 1671:
! 1672: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
! 1673: .objet)).nom_fonction, "*");
! 1674:
! 1675: if (((*l_element_courant).suivant =
! 1676: allocation_maillon(s_etat_processus)) == NULL)
! 1677: {
! 1678: (*s_etat_processus).erreur_systeme =
! 1679: d_es_allocation_memoire;
! 1680: return;
! 1681: }
! 1682:
! 1683: l_element_courant = (*l_element_courant).suivant;
! 1684:
! 1685: if (((*l_element_courant).donnee = allocation(s_etat_processus,
! 1686: FCT)) == NULL)
! 1687: {
! 1688: (*s_etat_processus).erreur_systeme =
! 1689: d_es_allocation_memoire;
! 1690: return;
! 1691: }
! 1692:
! 1693: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1694: .nombre_arguments = 0;
! 1695: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1696: .fonction = instruction_plus;
! 1697:
! 1698: if (((*((struct_fonction *) (*(*l_element_courant).donnee)
! 1699: .objet)).nom_fonction = malloc(2 *
! 1700: sizeof(unsigned char))) == NULL)
! 1701: {
! 1702: (*s_etat_processus).erreur_systeme =
! 1703: d_es_allocation_memoire;
! 1704: return;
! 1705: }
! 1706:
! 1707: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee)
! 1708: .objet)).nom_fonction, "+");
! 1709: }
! 1710: }
! 1711:
! 1712: /*
! 1713: * Fermeture de l'expression
! 1714: */
! 1715:
! 1716: if (last_valide == d_vrai)
! 1717: {
! 1718: sf(s_etat_processus, 31);
! 1719: }
! 1720:
! 1721: if (((*l_element_courant).suivant =
! 1722: allocation_maillon(s_etat_processus)) == NULL)
! 1723: {
! 1724: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1725: return;
! 1726: }
! 1727:
! 1728: l_element_courant = (*l_element_courant).suivant;
! 1729:
! 1730: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 1731: == NULL)
! 1732: {
! 1733: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1734: return;
! 1735: }
! 1736:
! 1737: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1738: .nombre_arguments = 0;
! 1739: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1740: .fonction = instruction_vers_niveau_inferieur;
! 1741:
! 1742: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1743: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 1744: {
! 1745: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1746: return;
! 1747: }
! 1748:
! 1749: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1750: .nom_fonction, ">>");
! 1751:
! 1752: (*l_element_courant).suivant = NULL;
! 1753:
! 1754: /*
! 1755: * Destruction de la variable locale
! 1756: */
! 1757:
! 1758: (*s_etat_processus).niveau_courant--;
! 1759:
! 1760: if (retrait_variable(s_etat_processus, (*((struct_nom *)
! 1761: (*s_objet_argument_3).objet)).nom, 'L') == d_erreur)
! 1762: {
! 1763: liberation(s_etat_processus, s_objet_argument_1);
! 1764: liberation(s_etat_processus, s_objet_argument_2);
! 1765: liberation(s_etat_processus, s_objet_argument_3);
! 1766: liberation(s_etat_processus, s_objet_argument_4);
! 1767: liberation(s_etat_processus, s_objet_resultat);
! 1768:
! 1769: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
! 1770: return;
! 1771: }
! 1772: }
! 1773: else
! 1774: {
! 1775: liberation(s_etat_processus, s_objet_argument_1);
! 1776: liberation(s_etat_processus, s_objet_argument_2);
! 1777: liberation(s_etat_processus, s_objet_argument_3);
! 1778: liberation(s_etat_processus, s_objet_argument_4);
! 1779:
! 1780: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1781: return;
! 1782: }
! 1783:
! 1784: liberation(s_etat_processus, s_objet_argument_1);
! 1785: liberation(s_etat_processus, s_objet_argument_2);
! 1786: liberation(s_etat_processus, s_objet_argument_3);
! 1787: liberation(s_etat_processus, s_objet_argument_4);
! 1788:
! 1789: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1790: s_objet_resultat) == d_erreur)
! 1791: {
! 1792: return;
! 1793: }
! 1794:
! 1795: return;
! 1796: }
! 1797:
! 1798:
! 1799: /*
! 1800: ================================================================================
! 1801: Fonction 'target'
! 1802: ================================================================================
! 1803: Entrées :
! 1804: --------------------------------------------------------------------------------
! 1805: Sorties :
! 1806: --------------------------------------------------------------------------------
! 1807: Effets de bord : néant
! 1808: ================================================================================
! 1809: */
! 1810:
! 1811: void
! 1812: instruction_target(struct_processus *s_etat_processus)
! 1813: {
! 1814: struct_liste_chainee *l_element_courant;
! 1815:
! 1816: struct addrinfo *resolution;
! 1817: struct addrinfo *resolution_courante;
! 1818:
! 1819: struct_objet *s_objet_argument_1;
! 1820: struct_objet *s_objet_argument_2;
! 1821:
! 1822: unsigned long i;
! 1823: unsigned long nombre_elements;
! 1824:
! 1825: (*s_etat_processus).erreur_execution = d_ex;
! 1826:
! 1827: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1828: {
! 1829: printf("\n TARGET ");
! 1830:
! 1831: if ((*s_etat_processus).langue == 'F')
! 1832: {
! 1833: printf("(cible d'une socket non connectée)\n\n");
! 1834: }
! 1835: else
! 1836: {
! 1837: printf("(target of unconnected socket)\n\n");
! 1838: }
! 1839:
! 1840: printf(" 2: %s, %s\n", d_CHN, d_LST);
! 1841: printf(" 1: %s\n", d_SCK);
! 1842: printf("-> 1: %s\n", d_SCK);
! 1843:
! 1844: return;
! 1845: }
! 1846: else if ((*s_etat_processus).test_instruction == 'Y')
! 1847: {
! 1848: (*s_etat_processus).nombre_arguments = -1;
! 1849: return;
! 1850: }
! 1851:
! 1852: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1853: {
! 1854: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
! 1855: {
! 1856: return;
! 1857: }
! 1858: }
! 1859:
! 1860: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1861: &s_objet_argument_1) == d_erreur)
! 1862: {
! 1863: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1864: return;
! 1865: }
! 1866:
! 1867: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1868: &s_objet_argument_2) == d_erreur)
! 1869: {
! 1870: liberation(s_etat_processus, s_objet_argument_1);
! 1871:
! 1872: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1873: return;
! 1874: }
! 1875:
! 1876: if ((*s_objet_argument_1).type == SCK)
! 1877: {
! 1878:
! 1879: /*
! 1880: * Vérification du type de socket
! 1881: */
! 1882:
! 1883: if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,
! 1884: "STREAM") == 0) || (strcmp((*((struct_socket *)
! 1885: (*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM")
! 1886: == 0))
! 1887: {
! 1888: liberation(s_etat_processus, s_objet_argument_1);
! 1889: liberation(s_etat_processus, s_objet_argument_2);
! 1890:
! 1891: (*s_etat_processus).erreur_execution =
! 1892: d_ex_erreur_parametre_fichier;
! 1893: return;
! 1894: }
! 1895:
! 1896: if ((*s_objet_argument_2).type == CHN)
! 1897: {
! 1898: /*
! 1899: * La socket ne peut être que du domaine UNIX
! 1900: */
! 1901:
! 1902: if ((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
! 1903: != PF_UNIX)
! 1904: {
! 1905: liberation(s_etat_processus, s_objet_argument_1);
! 1906: liberation(s_etat_processus, s_objet_argument_2);
! 1907:
! 1908: (*s_etat_processus).erreur_execution =
! 1909: d_ex_erreur_parametre_fichier;
! 1910: return;
! 1911: }
! 1912:
! 1913: free((*((struct_socket *) (*s_objet_argument_1).objet))
! 1914: .adresse_distante);
! 1915:
! 1916: if (((*((struct_socket *) (*s_objet_argument_1).objet))
! 1917: .adresse_distante = malloc((strlen((unsigned char *)
! 1918: (*s_objet_argument_2).objet) + 1) * sizeof(unsigned char)))
! 1919: == NULL)
! 1920: {
! 1921: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1922: return;
! 1923: }
! 1924:
! 1925: strcpy((*((struct_socket *) (*s_objet_argument_1).objet))
! 1926: .adresse_distante, (unsigned char *)
! 1927: (*s_objet_argument_2).objet);
! 1928: }
! 1929: else if ((*s_objet_argument_2).type == LST)
! 1930: {
! 1931: l_element_courant = (struct_liste_chainee *)
! 1932: (*s_objet_argument_2).objet;
! 1933: nombre_elements = 0;
! 1934:
! 1935: while(l_element_courant != NULL)
! 1936: {
! 1937: nombre_elements++;
! 1938: l_element_courant = (*l_element_courant).suivant;
! 1939: }
! 1940:
! 1941: if (nombre_elements != 2)
! 1942: {
! 1943: liberation(s_etat_processus, s_objet_argument_1);
! 1944: liberation(s_etat_processus, s_objet_argument_2);
! 1945:
! 1946: (*s_etat_processus).erreur_execution =
! 1947: d_ex_erreur_parametre_fichier;
! 1948: return;
! 1949: }
! 1950:
! 1951: l_element_courant = (struct_liste_chainee *)
! 1952: (*s_objet_argument_2).objet;
! 1953:
! 1954: if ((*(*l_element_courant).donnee).type == VIN)
! 1955: {
! 1956: if ((*((struct_vecteur *) (*(*l_element_courant).donnee).objet))
! 1957: .taille == 4)
! 1958: {
! 1959: if ((*((struct_socket *) (*s_objet_argument_1).objet))
! 1960: .domaine != PF_INET)
! 1961: {
! 1962: liberation(s_etat_processus, s_objet_argument_1);
! 1963: liberation(s_etat_processus, s_objet_argument_2);
! 1964:
! 1965: (*s_etat_processus).erreur_execution =
! 1966: d_ex_erreur_parametre_fichier;
! 1967: return;
! 1968: }
! 1969:
! 1970: free((*((struct_socket *) (*s_objet_argument_1).objet))
! 1971: .adresse_distante);
! 1972:
! 1973: if (((*((struct_socket *) (*s_objet_argument_1)
! 1974: .objet)).adresse_distante = malloc(22 *
! 1975: sizeof(unsigned char))) == NULL)
! 1976: {
! 1977: (*s_etat_processus).erreur_systeme =
! 1978: d_es_allocation_memoire;
! 1979: return;
! 1980: }
! 1981:
! 1982: (*((struct_socket *) (*s_objet_argument_1).objet))
! 1983: .adresse_distante[0] = d_code_fin_chaine;
! 1984:
! 1985: for(i = 0; i < 4; i++)
! 1986: {
! 1987: if ((((integer8 *) (*((struct_vecteur *)
! 1988: (*(*l_element_courant).donnee).objet)).tableau)
! 1989: [i] >= 0) && (((integer8 *)
! 1990: (*((struct_vecteur *) (*(*l_element_courant)
! 1991: .donnee).objet)).tableau)[i] <= 255))
! 1992: {
! 1993: sprintf((*((struct_socket *) (*s_objet_argument_1)
! 1994: .objet)).adresse_distante,
! 1995: (i == 0) ? "%s%d" : "%s.%d",
! 1996: (*((struct_socket *) (*s_objet_argument_1)
! 1997: .objet)).adresse_distante, (int)
! 1998: ((integer8 *) (*((struct_vecteur *)
! 1999: (*(*l_element_courant).donnee).objet))
! 2000: .tableau)[i]);
! 2001: }
! 2002: else
! 2003: {
! 2004: liberation(s_etat_processus, s_objet_argument_1);
! 2005: liberation(s_etat_processus, s_objet_argument_2);
! 2006:
! 2007: (*s_etat_processus).erreur_execution =
! 2008: d_ex_erreur_parametre_fichier;
! 2009: return;
! 2010: }
! 2011: }
! 2012: }
! 2013: else if ((*((struct_vecteur *) (*(*l_element_courant).donnee)
! 2014: .objet)).taille == 16)
! 2015: {
! 2016: if ((*((struct_socket *) (*s_objet_argument_1).objet))
! 2017: .domaine != PF_INET6)
! 2018: {
! 2019: liberation(s_etat_processus, s_objet_argument_1);
! 2020: liberation(s_etat_processus, s_objet_argument_2);
! 2021:
! 2022: (*s_etat_processus).erreur_execution =
! 2023: d_ex_erreur_parametre_fichier;
! 2024: return;
! 2025: }
! 2026:
! 2027: free((*((struct_socket *) (*s_objet_argument_1).objet))
! 2028: .adresse_distante);
! 2029:
! 2030: if (((*((struct_socket *) (*s_objet_argument_1)
! 2031: .objet)).adresse_distante = malloc(55 *
! 2032: sizeof(unsigned char))) == NULL)
! 2033: {
! 2034: (*s_etat_processus).erreur_systeme =
! 2035: d_es_allocation_memoire;
! 2036: return;
! 2037: }
! 2038:
! 2039: (*((struct_socket *) (*s_objet_argument_1).objet))
! 2040: .adresse_distante[0] = d_code_fin_chaine;
! 2041:
! 2042: for(i = 0; i < 16; i++)
! 2043: {
! 2044: if ((((integer8 *) (*((struct_vecteur *)
! 2045: (*(*l_element_courant).donnee).objet)).tableau)
! 2046: [i] >= 0) && (((integer8 *)
! 2047: (*((struct_vecteur *) (*(*l_element_courant)
! 2048: .donnee).objet)).tableau)[i] <= 255))
! 2049: {
! 2050: sprintf((*((struct_socket *) (*s_objet_argument_1)
! 2051: .objet)).adresse_distante,
! 2052: (i == 0) ? "%s%d" : "%s:%X",
! 2053: (*((struct_socket *) (*s_objet_argument_1)
! 2054: .objet)).adresse_distante, (int)
! 2055: ((integer8 *) (*((struct_vecteur *)
! 2056: (*(*l_element_courant).donnee).objet))
! 2057: .tableau)[i]);
! 2058: }
! 2059: else
! 2060: {
! 2061: liberation(s_etat_processus, s_objet_argument_1);
! 2062: liberation(s_etat_processus, s_objet_argument_2);
! 2063:
! 2064: (*s_etat_processus).erreur_execution =
! 2065: d_ex_erreur_parametre_fichier;
! 2066: return;
! 2067: }
! 2068: }
! 2069: }
! 2070: else
! 2071: {
! 2072: liberation(s_etat_processus, s_objet_argument_1);
! 2073: liberation(s_etat_processus, s_objet_argument_2);
! 2074:
! 2075: (*s_etat_processus).erreur_execution =
! 2076: d_ex_erreur_parametre_fichier;
! 2077: return;
! 2078: }
! 2079: }
! 2080: else if ((*(*l_element_courant).donnee).type == CHN)
! 2081: {
! 2082: resolution = NULL;
! 2083:
! 2084: if (getaddrinfo((unsigned char *) (*(*l_element_courant)
! 2085: .donnee).objet, NULL, NULL, &resolution) != 0)
! 2086: {
! 2087: liberation(s_etat_processus, s_objet_argument_1);
! 2088: liberation(s_etat_processus, s_objet_argument_2);
! 2089:
! 2090: if (resolution != NULL)
! 2091: {
! 2092: freeaddrinfo(resolution);
! 2093: }
! 2094:
! 2095: (*s_etat_processus).erreur_execution =
! 2096: d_ex_erreur_acces_fichier;
! 2097: return;
! 2098: }
! 2099:
! 2100: if ((*((struct_socket *) (*s_objet_argument_1).objet))
! 2101: .domaine == PF_INET)
! 2102: { // Résolution du nom en IPv4
! 2103: resolution_courante = resolution;
! 2104:
! 2105: while(resolution_courante != NULL)
! 2106: {
! 2107: if ((*resolution_courante).ai_family == AF_INET)
! 2108: {
! 2109: break;
! 2110: }
! 2111:
! 2112: resolution_courante = (*resolution_courante).ai_next;
! 2113: }
! 2114:
! 2115: if (resolution_courante == NULL)
! 2116: {
! 2117: liberation(s_etat_processus, s_objet_argument_1);
! 2118: liberation(s_etat_processus, s_objet_argument_2);
! 2119:
! 2120: freeaddrinfo(resolution);
! 2121:
! 2122: (*s_etat_processus).erreur_execution =
! 2123: d_ex_erreur_acces_fichier;
! 2124: return;
! 2125: }
! 2126:
! 2127: free((*((struct_socket *) (*s_objet_argument_1).objet))
! 2128: .adresse_distante);
! 2129:
! 2130: if (((*((struct_socket *) (*s_objet_argument_1)
! 2131: .objet)).adresse_distante = malloc(22 *
! 2132: sizeof(unsigned char))) == NULL)
! 2133: {
! 2134: (*s_etat_processus).erreur_systeme =
! 2135: d_es_allocation_memoire;
! 2136: return;
! 2137: }
! 2138:
! 2139: sprintf((*((struct_socket *) (*s_objet_argument_1).objet))
! 2140: .adresse_distante, "%d.%d.%d.%d",
! 2141: (ntohl((*((struct sockaddr_in *)
! 2142: (*resolution_courante).ai_addr)).sin_addr.s_addr)
! 2143: >> 24) & 0xFF,
! 2144: (ntohl((*((struct sockaddr_in *)
! 2145: (*resolution_courante).ai_addr)).sin_addr.s_addr)
! 2146: >> 16) & 0xFF,
! 2147: (ntohl((*((struct sockaddr_in *)
! 2148: (*resolution_courante).ai_addr)).sin_addr.s_addr)
! 2149: >> 8) & 0xFF,
! 2150: ntohl((*((struct sockaddr_in *)
! 2151: (*resolution_courante).ai_addr)).sin_addr.s_addr)
! 2152: & 0xFF);
! 2153: }
! 2154: else if ((*((struct_socket *) (*s_objet_argument_1).objet))
! 2155: .domaine == PF_INET6)
! 2156: { // Résolution du nom en IPv6
! 2157: resolution_courante = resolution;
! 2158:
! 2159: while(resolution_courante != NULL)
! 2160: {
! 2161: if ((*resolution_courante).ai_family == AF_INET6)
! 2162: {
! 2163: break;
! 2164: }
! 2165:
! 2166: resolution_courante = (*resolution_courante).ai_next;
! 2167: }
! 2168:
! 2169: if (resolution_courante == NULL)
! 2170: {
! 2171: liberation(s_etat_processus, s_objet_argument_1);
! 2172: liberation(s_etat_processus, s_objet_argument_2);
! 2173:
! 2174: freeaddrinfo(resolution);
! 2175:
! 2176: (*s_etat_processus).erreur_execution =
! 2177: d_ex_erreur_acces_fichier;
! 2178: return;
! 2179: }
! 2180:
! 2181: if (((*((struct_socket *) (*s_objet_argument_1)
! 2182: .objet)).adresse_distante = malloc(55 *
! 2183: sizeof(unsigned char))) == NULL)
! 2184: {
! 2185: (*s_etat_processus).erreur_systeme =
! 2186: d_es_allocation_memoire;
! 2187: return;
! 2188: }
! 2189:
! 2190: (*((struct_socket *) (*s_objet_argument_1).objet))
! 2191: .adresse_distante[0] = d_code_fin_chaine;
! 2192:
! 2193: for(i = 0; i < 16; i++)
! 2194: {
! 2195: sprintf((*((struct_socket *) (*s_objet_argument_1)
! 2196: .objet)).adresse_distante,
! 2197: (i == 0) ? "%s%X" : "%s:%X",
! 2198: (*((struct_socket *) (*s_objet_argument_1)
! 2199: .objet)).adresse_distante,
! 2200: (*((struct sockaddr_in6 *)
! 2201: (*resolution_courante).ai_addr)).sin6_addr
! 2202: .s6_addr[i]);
! 2203: }
! 2204: }
! 2205: else
! 2206: {
! 2207: liberation(s_etat_processus, s_objet_argument_1);
! 2208: liberation(s_etat_processus, s_objet_argument_2);
! 2209:
! 2210: freeaddrinfo(resolution);
! 2211:
! 2212: (*s_etat_processus).erreur_execution =
! 2213: d_ex_erreur_parametre_fichier;
! 2214: return;
! 2215: }
! 2216:
! 2217: freeaddrinfo(resolution);
! 2218: }
! 2219: else
! 2220: {
! 2221: liberation(s_etat_processus, s_objet_argument_1);
! 2222: liberation(s_etat_processus, s_objet_argument_2);
! 2223:
! 2224: (*s_etat_processus).erreur_execution =
! 2225: d_ex_erreur_parametre_fichier;
! 2226: return;
! 2227: }
! 2228:
! 2229: l_element_courant = (*l_element_courant).suivant;
! 2230:
! 2231: if ((*(*l_element_courant).donnee).type == INT)
! 2232: {
! 2233: if (((*((integer8 *) (*(*l_element_courant).donnee).objet))
! 2234: >= 0) && ((*((integer8 *) (*(*l_element_courant)
! 2235: .donnee).objet)) <= 65535))
! 2236: {
! 2237: sprintf((*((struct_socket *) (*s_objet_argument_1)
! 2238: .objet)).adresse_distante, "%s(%u)",
! 2239: (*((struct_socket *) (*s_objet_argument_1)
! 2240: .objet)).adresse_distante, (unsigned int)
! 2241: (*((integer8 *) (*(*l_element_courant).donnee)
! 2242: .objet)));
! 2243: }
! 2244: else
! 2245: {
! 2246: liberation(s_etat_processus, s_objet_argument_1);
! 2247: liberation(s_etat_processus, s_objet_argument_2);
! 2248:
! 2249: (*s_etat_processus).erreur_execution =
! 2250: d_ex_erreur_parametre_fichier;
! 2251: return;
! 2252: }
! 2253: }
! 2254: else
! 2255: {
! 2256: liberation(s_etat_processus, s_objet_argument_1);
! 2257: liberation(s_etat_processus, s_objet_argument_2);
! 2258:
! 2259: (*s_etat_processus).erreur_execution =
! 2260: d_ex_erreur_parametre_fichier;
! 2261: return;
! 2262: }
! 2263: }
! 2264: else
! 2265: {
! 2266: liberation(s_etat_processus, s_objet_argument_1);
! 2267: liberation(s_etat_processus, s_objet_argument_2);
! 2268:
! 2269: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 2270: return;
! 2271: }
! 2272: }
! 2273: else
! 2274: {
! 2275: liberation(s_etat_processus, s_objet_argument_1);
! 2276: liberation(s_etat_processus, s_objet_argument_2);
! 2277:
! 2278: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 2279: return;
! 2280: }
! 2281:
! 2282: liberation(s_etat_processus, s_objet_argument_2);
! 2283:
! 2284: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 2285: s_objet_argument_1) == d_erreur)
! 2286: {
! 2287: return;
! 2288: }
! 2289:
! 2290: return;
! 2291: }
! 2292:
! 2293:
! 2294: /*
! 2295: ================================================================================
! 2296: Fonction 'tail'
! 2297: ================================================================================
! 2298: Entrées :
! 2299: --------------------------------------------------------------------------------
! 2300: Sorties :
! 2301: --------------------------------------------------------------------------------
! 2302: Effets de bord : néant
! 2303: ================================================================================
! 2304: */
! 2305:
! 2306: void
! 2307: instruction_tail(struct_processus *s_etat_processus)
! 2308: {
! 2309: integer8 longueur;
! 2310:
! 2311: struct_liste_chainee *l_element_courant;
! 2312:
! 2313: struct_objet *s_objet_argument;
! 2314: struct_objet *s_objet_resultat;
! 2315:
! 2316: (*s_etat_processus).erreur_execution = d_ex;
! 2317:
! 2318: if ((*s_etat_processus).affichage_arguments == 'Y')
! 2319: {
! 2320: printf("\n TAIL ");
! 2321:
! 2322: if ((*s_etat_processus).langue == 'F')
! 2323: {
! 2324: printf("(remplace une liste par tous ses éléments hormis "
! 2325: "son premier)\n\n");
! 2326: }
! 2327: else
! 2328: {
! 2329: printf("(replace a list by all but its first element)\n\n");
! 2330: }
! 2331:
! 2332: printf(" 1: %s\n", d_LST);
! 2333: printf("-> 1: %s\n", d_LST);
! 2334:
! 2335: return;
! 2336: }
! 2337: else if ((*s_etat_processus).test_instruction == 'Y')
! 2338: {
! 2339: (*s_etat_processus).nombre_arguments = -1;
! 2340: return;
! 2341: }
! 2342:
! 2343: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 2344: {
! 2345: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 2346: {
! 2347: return;
! 2348: }
! 2349: }
! 2350:
! 2351: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 2352: &s_objet_argument) == d_erreur)
! 2353: {
! 2354: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 2355: return;
! 2356: }
! 2357:
! 2358: if ((*s_objet_argument).type == LST)
! 2359: {
! 2360: l_element_courant = (*s_objet_argument).objet;
! 2361: longueur = 0;
! 2362:
! 2363: while(l_element_courant != NULL)
! 2364: {
! 2365: longueur++;
! 2366: l_element_courant = (*l_element_courant).suivant;
! 2367: }
! 2368:
! 2369: if (longueur == 0)
! 2370: {
! 2371: if ((s_objet_resultat = allocation(s_etat_processus, LST))
! 2372: == NULL)
! 2373: {
! 2374: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2375: return;
! 2376: }
! 2377:
! 2378: (*s_objet_resultat).objet = NULL;
! 2379: }
! 2380: else
! 2381: {
! 2382: if ((s_objet_resultat = copie_objet(s_etat_processus,
! 2383: s_objet_argument, 'N')) == NULL)
! 2384: {
! 2385: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2386: return;
! 2387: }
! 2388:
! 2389: l_element_courant = (*s_objet_resultat).objet;
! 2390:
! 2391: (*s_objet_resultat).objet = (*((struct_liste_chainee *)
! 2392: (*s_objet_resultat).objet)).suivant;
! 2393:
! 2394: liberation(s_etat_processus, (*l_element_courant).donnee);
! 2395: free(l_element_courant);
! 2396: }
! 2397: }
! 2398: else
! 2399: {
! 2400: liberation(s_etat_processus, s_objet_argument);
! 2401:
! 2402: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 2403: return;
! 2404: }
! 2405:
! 2406: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 2407: s_objet_resultat) == d_erreur)
! 2408: {
! 2409: return;
! 2410: }
! 2411:
! 2412: liberation(s_etat_processus, s_objet_argument);
! 2413:
! 2414: return;
! 2415: }
! 2416:
! 2417: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_t2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src