Annotation of rpl/src/instructions_r6.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 'recv'
! 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_recv(struct_processus *s_etat_processus)
! 40: {
! 41: integer8 nombre_donnees;
! 42:
! 43: sig_atomic_t registre_stop;
! 44:
! 45: ssize_t longueur_ecriture;
! 46:
! 47: struct_liste_chainee *l_element_courant;
! 48:
! 49: struct_objet *s_objet_argument;
! 50: struct_objet *s_objet_resultat;
! 51:
! 52: struct sigaction action;
! 53: struct sigaction registre;
! 54:
! 55: (*s_etat_processus).erreur_execution = d_ex;
! 56:
! 57: if ((*s_etat_processus).affichage_arguments == 'Y')
! 58: {
! 59: printf("\n RECV ");
! 60:
! 61: if ((*s_etat_processus).langue == 'F')
! 62: {
! 63: printf("(réception de données d'un processus fils)\n\n");
! 64: }
! 65: else
! 66: {
! 67: printf("(data reception from child process)\n\n");
! 68: }
! 69:
! 70: printf(" 1: %s\n", d_PRC);
! 71: printf("-> 1: %s (0)\n\n", d_INT);
! 72:
! 73: printf(" 1: %s\n", d_PRC);
! 74: printf("-> 2: %s, %s, %s, %s, %s, %s,\n"
! 75: " %s, %s, %s, %s, %s,\n"
! 76: " %s, %s, %s, %s\n",
! 77: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
! 78: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN);
! 79: printf(" 1: %s (-1)\n", d_INT);
! 80:
! 81: return;
! 82: }
! 83: else if ((*s_etat_processus).test_instruction == 'Y')
! 84: {
! 85: (*s_etat_processus).nombre_arguments = -1;
! 86: return;
! 87: }
! 88:
! 89: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 90: {
! 91: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 92: {
! 93: return;
! 94: }
! 95: }
! 96:
! 97: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 98: &s_objet_argument) == d_erreur)
! 99: {
! 100: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 101: return;
! 102: }
! 103:
! 104: if ((*s_objet_argument).type == PRC)
! 105: {
! 106: /*
! 107: * Le champ de la structure nombre_objets_dans_pipe à jour
! 108: * est celui présent dans *s_etat_processus et non celui
! 109: * de la structure présente dans la pile opérationnelle.
! 110: */
! 111:
! 112: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
! 113: {
! 114: (*s_etat_processus).erreur_systeme_processus_fils =
! 115: d_es_processus;
! 116: return;
! 117: }
! 118:
! 119: l_element_courant = (struct_liste_chainee *)
! 120: (*s_etat_processus).l_base_pile_processus;
! 121: nombre_donnees = -1;
! 122:
! 123: while(l_element_courant != NULL)
! 124: {
! 125: if ((*(*((struct_processus_fils *) (*s_objet_argument).objet))
! 126: .thread).processus_detache == d_vrai)
! 127: {
! 128: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
! 129: .donnee).objet)).thread).processus_detache == d_faux)
! 130: {
! 131: l_element_courant = (*l_element_courant).suivant;
! 132: continue;
! 133: }
! 134:
! 135: if ((*(*((struct_processus_fils *) (*s_objet_argument).objet))
! 136: .thread).pid == (*(*((struct_processus_fils *)
! 137: (*(*l_element_courant).donnee).objet)).thread).pid)
! 138: {
! 139: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
! 140: (*s_objet_argument).objet)).thread).mutex)) != 0)
! 141: {
! 142: (*s_etat_processus).erreur_systeme = d_es_processus;
! 143: return;
! 144: }
! 145:
! 146: nombre_donnees = (*(*((struct_processus_fils *)
! 147: (*(*l_element_courant).donnee).objet)).thread)
! 148: .nombre_objets_dans_pipe;
! 149:
! 150: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
! 151: (*s_objet_argument).objet)).thread).mutex)) != 0)
! 152: {
! 153: (*s_etat_processus).erreur_systeme = d_es_processus;
! 154: return;
! 155: }
! 156:
! 157: break;
! 158: }
! 159: }
! 160: else
! 161: {
! 162: if ((*(*((struct_processus_fils *) (*(*l_element_courant)
! 163: .donnee).objet)).thread).processus_detache == d_vrai)
! 164: {
! 165: l_element_courant = (*l_element_courant).suivant;
! 166: continue;
! 167: }
! 168:
! 169: if ((pthread_equal((*(*((struct_processus_fils *)
! 170: (*s_objet_argument).objet)).thread).tid,
! 171: (*(*((struct_processus_fils *) (*(*l_element_courant)
! 172: .donnee).objet)).thread).tid) != 0) &&
! 173: ((*(*((struct_processus_fils *)
! 174: (*s_objet_argument).objet)).thread).pid ==
! 175: (*(*((struct_processus_fils *) (*(*l_element_courant)
! 176: .donnee).objet)).thread).pid))
! 177: {
! 178: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
! 179: (*s_objet_argument).objet)).thread).mutex)) != 0)
! 180: {
! 181: (*s_etat_processus).erreur_systeme = d_es_processus;
! 182: return;
! 183: }
! 184:
! 185: nombre_donnees = (*(*((struct_processus_fils *)
! 186: (*(*l_element_courant).donnee).objet)).thread)
! 187: .nombre_objets_dans_pipe;
! 188:
! 189: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
! 190: (*s_objet_argument).objet)).thread).mutex)) != 0)
! 191: {
! 192: (*s_etat_processus).erreur_systeme = d_es_processus;
! 193: return;
! 194: }
! 195:
! 196: break;
! 197: }
! 198: }
! 199:
! 200: l_element_courant = (*l_element_courant).suivant;
! 201: }
! 202:
! 203: /*
! 204: * 0 : aucune donnée dans le pipe du processus.
! 205: * -1 : processus absent de la pile
! 206: */
! 207:
! 208: if (nombre_donnees == -1)
! 209: {
! 210: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
! 211: {
! 212: (*s_etat_processus).erreur_systeme_processus_fils =
! 213: d_es_processus;
! 214: return;
! 215: }
! 216:
! 217: (*s_etat_processus).erreur_execution = d_ex_processus;
! 218: return;
! 219: }
! 220: else if (nombre_donnees == 0)
! 221: {
! 222: /*
! 223: * On empile une valeur nulle
! 224: */
! 225:
! 226: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
! 227: {
! 228: (*s_etat_processus).erreur_systeme_processus_fils =
! 229: d_es_processus;
! 230: return;
! 231: }
! 232:
! 233: if ((s_objet_resultat = allocation(s_etat_processus, INT))
! 234: == NULL)
! 235: {
! 236: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 237: return;
! 238: }
! 239:
! 240: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
! 241:
! 242: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 243: s_objet_resultat) == d_erreur)
! 244: {
! 245: return;
! 246: }
! 247:
! 248: liberation(s_etat_processus, s_objet_argument);
! 249:
! 250: return;
! 251: }
! 252:
! 253: registre_stop = (*s_etat_processus)
! 254: .var_volatile_traitement_retarde_stop;
! 255: (*s_etat_processus).var_volatile_traitement_retarde_stop = 1;
! 256:
! 257: if ((*s_etat_processus).profilage == d_vrai)
! 258: {
! 259: profilage(s_etat_processus, "Interprocess or interthread "
! 260: "communications (RECV)");
! 261:
! 262: if ((*s_etat_processus).erreur_systeme != d_es)
! 263: {
! 264: return;
! 265: }
! 266: }
! 267:
! 268: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 269: {
! 270: (*s_etat_processus).erreur_systeme = d_es_processus;
! 271: return;
! 272: }
! 273:
! 274: if ((s_objet_resultat = lecture_pipe(s_etat_processus,
! 275: (*(*((struct_processus_fils *) (*s_objet_argument).objet))
! 276: .thread).pipe_objets[0])) == NULL)
! 277: {
! 278: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 279: {
! 280: if (errno != EINTR)
! 281: {
! 282: (*s_etat_processus).erreur_systeme = d_es_processus;
! 283: return;
! 284: }
! 285: }
! 286:
! 287: if (registre_stop == 0)
! 288: {
! 289: if ((*s_etat_processus).var_volatile_traitement_retarde_stop
! 290: == -1)
! 291: {
! 292: (*s_etat_processus).var_volatile_requete_arret = -1;
! 293: }
! 294:
! 295: (*s_etat_processus).var_volatile_traitement_retarde_stop
! 296: = registre_stop;
! 297: }
! 298:
! 299: if ((*s_etat_processus).profilage == d_vrai)
! 300: {
! 301: profilage(s_etat_processus, NULL);
! 302: }
! 303:
! 304: pthread_mutex_unlock(&((*s_etat_processus).mutex));
! 305: return;
! 306: }
! 307:
! 308: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 309: {
! 310: if (errno != EINTR)
! 311: {
! 312: (*s_etat_processus).erreur_systeme = d_es_processus;
! 313: return;
! 314: }
! 315: }
! 316:
! 317: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
! 318: (*(*l_element_courant).donnee).objet)).thread).mutex)) != 0)
! 319: {
! 320: (*s_etat_processus).erreur_systeme = d_es_processus;
! 321: return;
! 322: }
! 323:
! 324: (*(*((struct_processus_fils *) (*(*l_element_courant).donnee).objet))
! 325: .thread).nombre_objets_dans_pipe--;
! 326:
! 327: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
! 328: (*(*l_element_courant).donnee).objet)).thread).mutex)) != 0)
! 329: {
! 330: (*s_etat_processus).erreur_systeme = d_es_processus;
! 331: return;
! 332: }
! 333:
! 334: action.sa_handler = SIG_IGN;
! 335: action.sa_flags = SA_ONSTACK;
! 336:
! 337: if (sigaction(SIGPIPE, &action, ®istre) != 0)
! 338: {
! 339: if (registre_stop == 0)
! 340: {
! 341: if ((*s_etat_processus).var_volatile_traitement_retarde_stop
! 342: == -1)
! 343: {
! 344: (*s_etat_processus).var_volatile_requete_arret = -1;
! 345: }
! 346:
! 347: (*s_etat_processus).var_volatile_traitement_retarde_stop
! 348: = registre_stop;
! 349: }
! 350:
! 351: pthread_mutex_unlock(&((*s_etat_processus).mutex));
! 352:
! 353: if ((*s_etat_processus).profilage == d_vrai)
! 354: {
! 355: profilage(s_etat_processus, NULL);
! 356: }
! 357:
! 358: (*s_etat_processus).erreur_systeme = d_es_signal;
! 359: return;
! 360: }
! 361:
! 362: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 363: {
! 364: (*s_etat_processus).erreur_systeme = d_es_processus;
! 365: return;
! 366: }
! 367:
! 368: while((longueur_ecriture = write_atomic(s_etat_processus,
! 369: (*(*((struct_processus_fils *) (*(*l_element_courant)
! 370: .donnee).objet)).thread).pipe_nombre_injections[1], "+",
! 371: sizeof(unsigned char))) != sizeof(unsigned char))
! 372: {
! 373: if (longueur_ecriture == -1)
! 374: {
! 375: // Le processus n'existe plus.
! 376: break;
! 377: }
! 378: }
! 379:
! 380: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 381: {
! 382: if (errno != EINTR)
! 383: {
! 384: (*s_etat_processus).erreur_systeme = d_es_processus;
! 385: return;
! 386: }
! 387: }
! 388:
! 389: if ((*s_etat_processus).profilage == d_vrai)
! 390: {
! 391: profilage(s_etat_processus, NULL);
! 392: }
! 393:
! 394: if (registre_stop == 0)
! 395: {
! 396: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == -1)
! 397: {
! 398: (*s_etat_processus).var_volatile_requete_arret = -1;
! 399: }
! 400:
! 401: (*s_etat_processus).var_volatile_traitement_retarde_stop
! 402: = registre_stop;
! 403: }
! 404:
! 405: if (sigaction(SIGPIPE, ®istre, NULL) != 0)
! 406: {
! 407: pthread_mutex_unlock(&((*s_etat_processus).mutex));
! 408:
! 409: (*s_etat_processus).erreur_systeme = d_es_signal;
! 410: return;
! 411: }
! 412:
! 413: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
! 414: {
! 415: (*s_etat_processus).erreur_systeme_processus_fils =
! 416: d_es_processus;
! 417: }
! 418: }
! 419: else
! 420: {
! 421: liberation(s_etat_processus, s_objet_argument);
! 422:
! 423: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 424: return;
! 425: }
! 426:
! 427: liberation(s_etat_processus, s_objet_argument);
! 428:
! 429: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 430: s_objet_resultat) == d_erreur)
! 431: {
! 432: return;
! 433: }
! 434:
! 435: /*
! 436: * On rajoute "-1" dans la pile.
! 437: */
! 438:
! 439: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
! 440: {
! 441: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 442: return;
! 443: }
! 444:
! 445: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
! 446:
! 447: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 448: s_objet_resultat) == d_erreur)
! 449: {
! 450: return;
! 451: }
! 452:
! 453: return;
! 454: }
! 455:
! 456:
! 457: /*
! 458: ================================================================================
! 459: Fonction 'row->'
! 460: ================================================================================
! 461: Entrées :
! 462: --------------------------------------------------------------------------------
! 463: Sorties :
! 464: --------------------------------------------------------------------------------
! 465: Effets de bord : néant
! 466: ================================================================================
! 467: */
! 468:
! 469: void
! 470: instruction_row_fleche(struct_processus *s_etat_processus)
! 471: {
! 472: struct_objet *s_objet;
! 473: struct_objet *s_objet_elementaire;
! 474:
! 475: unsigned long i;
! 476: unsigned long j;
! 477:
! 478: (*s_etat_processus).erreur_execution = d_ex;
! 479:
! 480: if ((*s_etat_processus).affichage_arguments == 'Y')
! 481: {
! 482: printf("\n ROW-> ");
! 483:
! 484: if ((*s_etat_processus).langue == 'F')
! 485: {
! 486: printf("(extraction des lignes d'une matrice)\n\n");
! 487: }
! 488: else
! 489: {
! 490: printf("(extract matrix rows)\n\n");
! 491: }
! 492:
! 493: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
! 494: printf("-> n: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
! 495: printf(" ...\n");
! 496: printf(" 2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
! 497: printf(" 1: %s\n", d_INT);
! 498:
! 499: return;
! 500: }
! 501: else if ((*s_etat_processus).test_instruction == 'Y')
! 502: {
! 503: (*s_etat_processus).nombre_arguments = -1;
! 504: return;
! 505: }
! 506:
! 507: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 508: {
! 509: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 510: {
! 511: return;
! 512: }
! 513: }
! 514:
! 515: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 516: &s_objet) == d_erreur)
! 517: {
! 518: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 519: return;
! 520: }
! 521:
! 522: if ((*s_objet).type == MIN)
! 523: {
! 524: for(i = 0; i < (*((struct_matrice *)
! 525: (*s_objet).objet)).nombre_lignes; i++)
! 526: {
! 527: if ((s_objet_elementaire = allocation(s_etat_processus, MIN))
! 528: == NULL)
! 529: {
! 530: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 531: return;
! 532: }
! 533:
! 534: (*((struct_matrice *) (*s_objet_elementaire).objet))
! 535: .nombre_lignes = 1;
! 536: (*((struct_matrice *) (*s_objet_elementaire).objet))
! 537: .nombre_colonnes = (*((struct_matrice *) (*s_objet).objet))
! 538: .nombre_colonnes;
! 539:
! 540: if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau =
! 541: malloc(sizeof(integer8 *))) == NULL)
! 542: {
! 543: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 544: return;
! 545: }
! 546:
! 547: if ((((integer8 **) (*((struct_matrice *) (*s_objet_elementaire)
! 548: .objet)).tableau)[0] = malloc((*((struct_matrice *)
! 549: (*s_objet_elementaire).objet)).nombre_colonnes *
! 550: sizeof(integer8))) == NULL)
! 551: {
! 552: (*s_etat_processus).erreur_systeme =
! 553: d_es_allocation_memoire;
! 554: return;
! 555: }
! 556:
! 557: for(j = 0; j < (*((struct_matrice *) (*s_objet_elementaire).objet))
! 558: .nombre_colonnes; j++)
! 559: {
! 560: ((integer8 **) (*((struct_matrice *) (*s_objet_elementaire)
! 561: .objet)).tableau)[0][j] =
! 562: ((integer8 **) (*((struct_matrice *)
! 563: (*s_objet).objet)).tableau)[i][j];
! 564: }
! 565:
! 566: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 567: s_objet_elementaire) == d_erreur)
! 568: {
! 569: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 570: return;
! 571: }
! 572: }
! 573: }
! 574: else if ((*s_objet).type == MRL)
! 575: {
! 576: for(i = 0; i < (*((struct_matrice *)
! 577: (*s_objet).objet)).nombre_lignes; i++)
! 578: {
! 579: if ((s_objet_elementaire = allocation(s_etat_processus, MRL))
! 580: == NULL)
! 581: {
! 582: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 583: return;
! 584: }
! 585:
! 586: (*((struct_matrice *) (*s_objet_elementaire).objet))
! 587: .nombre_lignes = 1;
! 588: (*((struct_matrice *) (*s_objet_elementaire).objet))
! 589: .nombre_colonnes = (*((struct_matrice *) (*s_objet).objet))
! 590: .nombre_colonnes;
! 591:
! 592: if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau =
! 593: malloc(sizeof(real8 *))) == NULL)
! 594: {
! 595: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 596: return;
! 597: }
! 598:
! 599: if ((((real8 **) (*((struct_matrice *) (*s_objet_elementaire)
! 600: .objet)).tableau)[0] = malloc((*((struct_matrice *)
! 601: (*s_objet_elementaire).objet)).nombre_colonnes *
! 602: sizeof(real8))) == NULL)
! 603: {
! 604: (*s_etat_processus).erreur_systeme =
! 605: d_es_allocation_memoire;
! 606: return;
! 607: }
! 608:
! 609: for(j = 0; j < (*((struct_matrice *) (*s_objet_elementaire).objet))
! 610: .nombre_colonnes; j++)
! 611: {
! 612: ((real8 **) (*((struct_matrice *) (*s_objet_elementaire)
! 613: .objet)).tableau)[0][j] =
! 614: ((real8 **) (*((struct_matrice *)
! 615: (*s_objet).objet)).tableau)[i][j];
! 616: }
! 617:
! 618: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 619: s_objet_elementaire) == d_erreur)
! 620: {
! 621: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 622: return;
! 623: }
! 624: }
! 625: }
! 626: else if ((*s_objet).type == MCX)
! 627: {
! 628: for(i = 0; i < (*((struct_matrice *)
! 629: (*s_objet).objet)).nombre_lignes; i++)
! 630: {
! 631: if ((s_objet_elementaire = allocation(s_etat_processus, MCX))
! 632: == NULL)
! 633: {
! 634: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 635: return;
! 636: }
! 637:
! 638: (*((struct_matrice *) (*s_objet_elementaire).objet))
! 639: .nombre_lignes = 1;
! 640: (*((struct_matrice *) (*s_objet_elementaire).objet))
! 641: .nombre_colonnes = (*((struct_matrice *) (*s_objet).objet))
! 642: .nombre_colonnes;
! 643:
! 644: if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau =
! 645: malloc(sizeof(complex16 *))) == NULL)
! 646: {
! 647: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 648: return;
! 649: }
! 650:
! 651: if ((((complex16 **) (*((struct_matrice *) (*s_objet_elementaire)
! 652: .objet)).tableau)[0] = malloc((*((struct_matrice *)
! 653: (*s_objet_elementaire).objet)).nombre_colonnes *
! 654: sizeof(complex16))) == NULL)
! 655: {
! 656: (*s_etat_processus).erreur_systeme =
! 657: d_es_allocation_memoire;
! 658: return;
! 659: }
! 660:
! 661: for(j = 0; j < (*((struct_matrice *) (*s_objet_elementaire).objet))
! 662: .nombre_colonnes; j++)
! 663: {
! 664: ((complex16 **) (*((struct_matrice *) (*s_objet_elementaire)
! 665: .objet)).tableau)[0][j].partie_reelle =
! 666: ((complex16 **) (*((struct_matrice *)
! 667: (*s_objet).objet)).tableau)[i][j].partie_reelle;
! 668: ((complex16 **) (*((struct_matrice *) (*s_objet_elementaire)
! 669: .objet)).tableau)[0][j].partie_imaginaire =
! 670: ((complex16 **) (*((struct_matrice *)
! 671: (*s_objet).objet)).tableau)[i][j].partie_imaginaire;
! 672: }
! 673:
! 674: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 675: s_objet_elementaire) == d_erreur)
! 676: {
! 677: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 678: return;
! 679: }
! 680: }
! 681: }
! 682: else
! 683: {
! 684: liberation(s_etat_processus, s_objet);
! 685:
! 686: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 687: return;
! 688: }
! 689:
! 690: if ((s_objet_elementaire = allocation(s_etat_processus, INT)) == NULL)
! 691: {
! 692: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 693: return;
! 694: }
! 695:
! 696: (*((integer8 *) (*s_objet_elementaire).objet)) =
! 697: (*((struct_matrice *) (*s_objet).objet)).nombre_lignes;
! 698:
! 699: liberation(s_etat_processus, s_objet);
! 700:
! 701: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 702: s_objet_elementaire) == d_erreur)
! 703: {
! 704: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 705: return;
! 706: }
! 707:
! 708: return;
! 709: }
! 710:
! 711:
! 712: /*
! 713: ================================================================================
! 714: Fonction 'rdate'
! 715: ================================================================================
! 716: Entrées : pointeur sur une structure struct_processus
! 717: --------------------------------------------------------------------------------
! 718: Sorties :
! 719: --------------------------------------------------------------------------------
! 720: Effets de bord : néant
! 721: ================================================================================
! 722: */
! 723:
! 724: void
! 725: instruction_rdate(struct_processus *s_etat_processus)
! 726: {
! 727: struct_objet *s_objet;
! 728: struct_objet *s_objet_argument;
! 729:
! 730: struct timeval horodatage;
! 731:
! 732: (*s_etat_processus).erreur_execution = d_ex;
! 733:
! 734: if ((*s_etat_processus).affichage_arguments == 'Y')
! 735: {
! 736: printf("\n RDATE ");
! 737:
! 738: if ((*s_etat_processus).langue == 'F')
! 739: {
! 740: printf("(information sur la date et l'heure avec offset)\n\n");
! 741: }
! 742: else
! 743: {
! 744: printf("(date and time with offset)\n\n");
! 745: }
! 746:
! 747: printf(" 1: %s\n", d_INT);
! 748: printf("-> 1: %s\n", d_LST);
! 749:
! 750: return;
! 751: }
! 752: else if ((*s_etat_processus).test_instruction == 'Y')
! 753: {
! 754: (*s_etat_processus).nombre_arguments = 1;
! 755: return;
! 756: }
! 757:
! 758: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 759: {
! 760: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 761: {
! 762: return;
! 763: }
! 764: }
! 765:
! 766: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 767: &s_objet_argument) == d_erreur)
! 768: {
! 769: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 770: return;
! 771: }
! 772:
! 773: if ((*s_objet_argument).type == INT)
! 774: {
! 775: gettimeofday(&horodatage, NULL);
! 776: horodatage.tv_sec += (*((integer8 *) (*s_objet_argument).objet));
! 777:
! 778: if (horodatage.tv_sec < 0)
! 779: {
! 780: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 781:
! 782: liberation(s_etat_processus, s_objet_argument);
! 783: return;
! 784: }
! 785:
! 786: if ((s_objet = formateur_date(s_etat_processus, &horodatage)) == NULL)
! 787: {
! 788: liberation(s_etat_processus, s_objet_argument);
! 789: return;
! 790: }
! 791:
! 792: liberation(s_etat_processus, s_objet_argument);
! 793: }
! 794: else
! 795: {
! 796: liberation(s_etat_processus, s_objet_argument);
! 797:
! 798: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 799: return;
! 800: }
! 801:
! 802: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 803: s_objet) == d_erreur)
! 804: {
! 805: return;
! 806: }
! 807:
! 808: return;
! 809: }
! 810:
! 811:
! 812: /*
! 813: ================================================================================
! 814: Fonction 'rclswi'
! 815: ================================================================================
! 816: Entrées : pointeur sur une structure struct_processus
! 817: --------------------------------------------------------------------------------
! 818: Sorties :
! 819: --------------------------------------------------------------------------------
! 820: Effets de bord : néant
! 821: ================================================================================
! 822: */
! 823:
! 824: void
! 825: instruction_rclswi(struct_processus *s_etat_processus)
! 826: {
! 827: integer8 interruption;
! 828:
! 829: struct_objet *s_objet_argument;
! 830: struct_objet *s_objet_resultat;
! 831:
! 832: (*s_etat_processus).erreur_execution = d_ex;
! 833:
! 834: if ((*s_etat_processus).affichage_arguments == 'Y')
! 835: {
! 836: printf("\n RCLSWI ");
! 837:
! 838: if ((*s_etat_processus).langue == 'F')
! 839: {
! 840: printf("(rappel d'une interruption logicielle)\n\n");
! 841: }
! 842: else
! 843: {
! 844: printf("(recall software interrupt)\n\n");
! 845: }
! 846:
! 847: printf(" 1: %s\n", d_INT);
! 848: printf("-> 1: %s, %s\n", d_NOM, d_RPN);
! 849:
! 850: return;
! 851: }
! 852: else if ((*s_etat_processus).test_instruction == 'Y')
! 853: {
! 854: (*s_etat_processus).nombre_arguments = -1;
! 855: return;
! 856: }
! 857:
! 858: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 859: {
! 860: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 861: {
! 862: return;
! 863: }
! 864: }
! 865:
! 866: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 867: &s_objet_argument) == d_erreur)
! 868: {
! 869: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 870: return;
! 871: }
! 872:
! 873: if ((*s_objet_argument).type == INT)
! 874: {
! 875: interruption = (*((integer8 *) (*s_objet_argument).objet));
! 876:
! 877: if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
! 878: {
! 879: liberation(s_etat_processus, s_objet_argument);
! 880:
! 881: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide;
! 882: return;
! 883: }
! 884:
! 885: if ((*s_etat_processus).corps_interruptions[interruption - 1] == NULL)
! 886: {
! 887: liberation(s_etat_processus, s_objet_argument);
! 888:
! 889: (*s_etat_processus).erreur_execution = d_ex_interruption_invalide;
! 890: return;
! 891: }
! 892:
! 893: if ((s_objet_resultat = copie_objet(s_etat_processus,
! 894: (*s_etat_processus).corps_interruptions[interruption - 1], 'P'))
! 895: == NULL)
! 896: {
! 897: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 898: return;
! 899: }
! 900: }
! 901: else
! 902: {
! 903: liberation(s_etat_processus, s_objet_argument);
! 904:
! 905: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 906: return;
! 907: }
! 908:
! 909: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 910: s_objet_resultat) == d_erreur)
! 911: {
! 912: return;
! 913: }
! 914:
! 915: return;
! 916: }
! 917:
! 918:
! 919: /*
! 920: ================================================================================
! 921: Fonction 'revlist'
! 922: ================================================================================
! 923: Entrées : pointeur sur une structure struct_processus
! 924: --------------------------------------------------------------------------------
! 925: Sorties :
! 926: --------------------------------------------------------------------------------
! 927: Effets de bord : néant
! 928: ================================================================================
! 929: */
! 930:
! 931: void
! 932: instruction_revlist(struct_processus *s_etat_processus)
! 933: {
! 934: struct_liste_chainee *l_ancienne_base;
! 935: struct_liste_chainee *l_nouvelle_base;
! 936:
! 937: struct_objet *s_objet_argument;
! 938: struct_objet *s_objet_intermediaire;
! 939: struct_objet *s_objet_resultat;
! 940:
! 941: (*s_etat_processus).erreur_execution = d_ex;
! 942:
! 943: if ((*s_etat_processus).affichage_arguments == 'Y')
! 944: {
! 945: printf("\n REVLIST ");
! 946:
! 947: if ((*s_etat_processus).langue == 'F')
! 948: {
! 949: printf("(inverse les éléments d'une liste)\n\n");
! 950: }
! 951: else
! 952: {
! 953: printf("(inverts list elements)\n\n");
! 954: }
! 955:
! 956: printf(" 1: %s\n", d_LST);
! 957: printf("-> 1: %s\n", d_LST);
! 958:
! 959: return;
! 960: }
! 961: else if ((*s_etat_processus).test_instruction == 'Y')
! 962: {
! 963: (*s_etat_processus).nombre_arguments = -1;
! 964: return;
! 965: }
! 966:
! 967: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 968: {
! 969: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 970: {
! 971: return;
! 972: }
! 973: }
! 974:
! 975: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 976: &s_objet_argument) == d_erreur)
! 977: {
! 978: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 979: return;
! 980: }
! 981:
! 982: if ((*s_objet_argument).type == LST)
! 983: {
! 984: if ((s_objet_resultat = copie_objet(s_etat_processus,
! 985: s_objet_argument, 'N')) == NULL)
! 986: {
! 987: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 988: return;
! 989: }
! 990:
! 991: l_ancienne_base = (*s_objet_resultat).objet;
! 992: l_nouvelle_base = NULL;
! 993:
! 994: while(l_ancienne_base != NULL)
! 995: {
! 996: if (depilement(s_etat_processus, &l_ancienne_base,
! 997: &s_objet_intermediaire) == d_erreur)
! 998: {
! 999: (*s_etat_processus).erreur_systeme = d_es_pile_vide;
! 1000: return;
! 1001: }
! 1002:
! 1003: if (empilement(s_etat_processus, &l_nouvelle_base,
! 1004: s_objet_intermediaire) == d_erreur)
! 1005: {
! 1006: return;
! 1007: }
! 1008: }
! 1009:
! 1010: (*s_objet_resultat).objet = l_nouvelle_base;
! 1011: }
! 1012: else
! 1013: {
! 1014: liberation(s_etat_processus, s_objet_argument);
! 1015:
! 1016: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1017: return;
! 1018: }
! 1019:
! 1020: liberation(s_etat_processus, s_objet_argument);
! 1021:
! 1022: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1023: s_objet_resultat) == d_erreur)
! 1024: {
! 1025: return;
! 1026: }
! 1027:
! 1028: return;
! 1029: }
! 1030:
! 1031:
! 1032: /*
! 1033: ================================================================================
! 1034: Fonction 'rstop'
! 1035: ================================================================================
! 1036: Entrées :
! 1037: --------------------------------------------------------------------------------
! 1038: Sorties :
! 1039: --------------------------------------------------------------------------------
! 1040: Effets de bord : néant
! 1041: ================================================================================
! 1042: */
! 1043:
! 1044: void
! 1045: instruction_rstop(struct_processus *s_etat_processus)
! 1046: {
! 1047: (*s_etat_processus).erreur_execution = d_ex;
! 1048:
! 1049: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1050: {
! 1051: printf("\n RSTOP ");
! 1052:
! 1053: if ((*s_etat_processus).langue == 'F')
! 1054: {
! 1055: printf("(libère le signal stop)\n\n");
! 1056: printf(" Aucun argument\n");
! 1057: }
! 1058: else
! 1059: {
! 1060: printf("(release stop signal)\n\n");
! 1061: printf(" No argument\n");
! 1062: }
! 1063:
! 1064: return;
! 1065: }
! 1066: else if ((*s_etat_processus).test_instruction == 'Y')
! 1067: {
! 1068: (*s_etat_processus).nombre_arguments = -1;
! 1069: return;
! 1070: }
! 1071:
! 1072: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1073: {
! 1074: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 1075: {
! 1076: return;
! 1077: }
! 1078: }
! 1079:
! 1080: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0)
! 1081: {
! 1082: (*s_etat_processus).erreur_execution = d_ex_stop;
! 1083: return;
! 1084: }
! 1085:
! 1086: if ((*s_etat_processus).var_volatile_traitement_retarde_stop == -1)
! 1087: {
! 1088: (*s_etat_processus).var_volatile_requete_arret = -1;
! 1089: }
! 1090:
! 1091: (*s_etat_processus).var_volatile_traitement_retarde_stop = 0;
! 1092:
! 1093: return;
! 1094: }
! 1095:
! 1096:
! 1097: /*
! 1098: ================================================================================
! 1099: fonction 'rfuse'
! 1100: ================================================================================
! 1101: entrées :
! 1102: --------------------------------------------------------------------------------
! 1103: sorties :
! 1104: --------------------------------------------------------------------------------
! 1105: effets de bord : néant
! 1106: ================================================================================
! 1107: */
! 1108:
! 1109: void
! 1110: instruction_rfuse(struct_processus *s_etat_processus)
! 1111: {
! 1112: struct_objet *s_objet_resultat;
! 1113:
! 1114: (*s_etat_processus).erreur_execution = d_ex;
! 1115:
! 1116: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1117: {
! 1118: printf("\n RFUSE ");
! 1119:
! 1120: if ((*s_etat_processus).langue == 'F')
! 1121: {
! 1122: printf("(valeur courante du fusible)\n\n");
! 1123: }
! 1124: else
! 1125: {
! 1126: printf("(remaining fuse value)\n\n");
! 1127: }
! 1128:
! 1129: printf("-> 1: %s\n", d_REL);
! 1130: return;
! 1131: }
! 1132: else if ((*s_etat_processus).test_instruction == 'Y')
! 1133: {
! 1134: (*s_etat_processus).nombre_arguments = -1;
! 1135: return;
! 1136: }
! 1137:
! 1138: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1139: {
! 1140: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 1141: {
! 1142: return;
! 1143: }
! 1144: }
! 1145:
! 1146: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
! 1147: {
! 1148: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1149: return;
! 1150: }
! 1151:
! 1152: (*((real8 *) (*s_objet_resultat).objet)) =
! 1153: (*s_etat_processus).temps_maximal_cpu;
! 1154:
! 1155: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1156: s_objet_resultat) == d_erreur)
! 1157: {
! 1158: return;
! 1159: }
! 1160:
! 1161: return;
! 1162: }
! 1163:
! 1164:
! 1165: /*
! 1166: ================================================================================
! 1167: fonction 'rdgn'
! 1168: ================================================================================
! 1169: entrées :
! 1170: --------------------------------------------------------------------------------
! 1171: sorties :
! 1172: --------------------------------------------------------------------------------
! 1173: effets de bord : néant
! 1174: ================================================================================
! 1175: */
! 1176:
! 1177: void
! 1178: instruction_rdgn(struct_processus *s_etat_processus)
! 1179: {
! 1180: const gsl_rng_type **type_courant;
! 1181: const gsl_rng_type **types;
! 1182:
! 1183: const unsigned char *message = "UNINITIALIZED RANDOM GENERATOR";
! 1184:
! 1185: long dernier;
! 1186: long i;
! 1187: long j;
! 1188: long premier;
! 1189:
! 1190: struct_objet *s_objet_argument;
! 1191: struct_objet *s_objet_resultat;
! 1192:
! 1193: unsigned char *requete;
! 1194: unsigned char **types_generateurs;
! 1195:
! 1196: unsigned long nombre_types;
! 1197:
! 1198: (*s_etat_processus).erreur_execution = d_ex;
! 1199:
! 1200: types = gsl_rng_types_setup();
! 1201:
! 1202: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1203: {
! 1204: printf("\n RDGN ");
! 1205:
! 1206: if ((*s_etat_processus).langue == 'F')
! 1207: {
! 1208: printf("(choix du générateur de nombres aléatoires)\n\n");
! 1209: }
! 1210: else
! 1211: {
! 1212: printf("(random number generator specification)\n\n");
! 1213: }
! 1214:
! 1215: printf(" 1: %s\n\n", d_CHN);
! 1216:
! 1217: printf(" 1: \"QUERY\"\n");
! 1218: printf("-> 1: %s\n\n", d_CHN);
! 1219:
! 1220: if ((*s_etat_processus).langue == 'F')
! 1221: {
! 1222: printf(" Générateurs disponibles :\n\n");
! 1223: }
! 1224: else
! 1225: {
! 1226: printf(" Available generators:\n\n");
! 1227: }
! 1228:
! 1229: for(nombre_types = 0, type_courant = types;
! 1230: (*type_courant) != NULL; type_courant++, nombre_types++);
! 1231:
! 1232: if ((types_generateurs = malloc(nombre_types * sizeof(unsigned char *)))
! 1233: == NULL)
! 1234: {
! 1235: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1236: return;
! 1237: }
! 1238:
! 1239: for(i = 0, type_courant = types; (*type_courant) != NULL;
! 1240: type_courant++, i++)
! 1241: {
! 1242: if ((types_generateurs[i] = malloc((strlen((**type_courant).name)
! 1243: + 1) * sizeof(unsigned char))) == NULL)
! 1244: {
! 1245: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1246: return;
! 1247: }
! 1248:
! 1249: strcpy(types_generateurs[i], (**type_courant).name);
! 1250: }
! 1251:
! 1252: // Tri des types de générateurs (tri shaker)
! 1253:
! 1254: premier = 1;
! 1255: dernier = nombre_types - 2;
! 1256:
! 1257: while((dernier - premier) >= 2)
! 1258: {
! 1259: for(j = 2, i = premier; i <= dernier; i++)
! 1260: {
! 1261: if (strcmp(types_generateurs[i], types_generateurs[i + 1]) > 0)
! 1262: {
! 1263: swap(&(types_generateurs[i]),
! 1264: &(types_generateurs[i + 1]),
! 1265: sizeof(unsigned char *));
! 1266: j = i;
! 1267: }
! 1268: }
! 1269:
! 1270: dernier = j;
! 1271: i = nombre_types - 2;
! 1272:
! 1273: for(i = dernier; i >= premier; i--)
! 1274: {
! 1275: if (strcmp(types_generateurs[i - 1], types_generateurs[i]) > 0)
! 1276: {
! 1277: swap(&(types_generateurs[i - 1]),
! 1278: &(types_generateurs[i]),
! 1279: sizeof(unsigned char *));
! 1280: j = i;
! 1281: }
! 1282: }
! 1283:
! 1284: premier = j;
! 1285: }
! 1286:
! 1287: for(i = 0; i < (long) nombre_types; i++)
! 1288: {
! 1289: printf(" - %s\n", types_generateurs[i]);
! 1290: free(types_generateurs[i]);
! 1291: }
! 1292:
! 1293: free(types_generateurs);
! 1294: return;
! 1295: }
! 1296: else if ((*s_etat_processus).test_instruction == 'Y')
! 1297: {
! 1298: (*s_etat_processus).nombre_arguments = -1;
! 1299: return;
! 1300: }
! 1301:
! 1302: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1303: {
! 1304: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 1305: {
! 1306: return;
! 1307: }
! 1308: }
! 1309:
! 1310: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1311: &s_objet_argument) == d_erreur)
! 1312: {
! 1313: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1314: return;
! 1315: }
! 1316:
! 1317: if ((*s_objet_argument).type == CHN)
! 1318: {
! 1319: if ((requete = conversion_majuscule((unsigned char *)
! 1320: (*s_objet_argument).objet)) == NULL)
! 1321: {
! 1322: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1323: return;
! 1324: }
! 1325:
! 1326: if (strcmp(requete, "QUERY") == 0)
! 1327: {
! 1328: /*
! 1329: * Récupération du type du générateur
! 1330: */
! 1331:
! 1332: free(requete);
! 1333:
! 1334: if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
! 1335: {
! 1336: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1337: return;
! 1338: }
! 1339:
! 1340: if ((*s_etat_processus).type_generateur_aleatoire == NULL)
! 1341: {
! 1342: if (((*s_objet_resultat).objet = malloc((strlen(message) + 1) *
! 1343: sizeof(unsigned char))) == NULL)
! 1344: {
! 1345: (*s_etat_processus).erreur_systeme =
! 1346: d_es_allocation_memoire;
! 1347: return;
! 1348: }
! 1349:
! 1350: strcpy((unsigned char *) (*s_objet_resultat).objet, message);
! 1351: }
! 1352: else
! 1353: {
! 1354: if (((*s_objet_resultat).objet = conversion_majuscule(
! 1355: (unsigned char *) gsl_rng_name(
! 1356: (*s_etat_processus).generateur_aleatoire))) == NULL)
! 1357: {
! 1358: (*s_etat_processus).erreur_systeme =
! 1359: d_es_allocation_memoire;
! 1360: return;
! 1361: }
! 1362: }
! 1363:
! 1364: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1365: s_objet_resultat) == d_erreur)
! 1366: {
! 1367: return;
! 1368: }
! 1369: }
! 1370: else
! 1371: {
! 1372: /*
! 1373: * Affectation d'un nouveau type de générateur
! 1374: */
! 1375:
! 1376: # include "generateurs.c"
! 1377:
! 1378: free(requete);
! 1379:
! 1380: if ((*s_etat_processus).generateur_aleatoire != NULL)
! 1381: {
! 1382: liberation_generateur_aleatoire(s_etat_processus);
! 1383: }
! 1384:
! 1385: initialisation_generateur_aleatoire(s_etat_processus, d_vrai, 0);
! 1386: }
! 1387: }
! 1388: else
! 1389: {
! 1390: liberation(s_etat_processus, s_objet_argument);
! 1391:
! 1392: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1393: return;
! 1394: }
! 1395:
! 1396: liberation(s_etat_processus, s_objet_argument);
! 1397:
! 1398: return;
! 1399: }
! 1400:
! 1401:
! 1402: /*
! 1403: ================================================================================
! 1404: fonction 'rank'
! 1405: ================================================================================
! 1406: entrées :
! 1407: --------------------------------------------------------------------------------
! 1408: sorties :
! 1409: --------------------------------------------------------------------------------
! 1410: effets de bord : néant
! 1411: ================================================================================
! 1412: */
! 1413:
! 1414: void
! 1415: instruction_rank(struct_processus *s_etat_processus)
! 1416: {
! 1417: struct_objet *s_objet_argument;
! 1418: struct_objet *s_objet_resultat;
! 1419:
! 1420: (*s_etat_processus).erreur_execution = d_ex;
! 1421:
! 1422: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1423: {
! 1424: printf("\n RANK ");
! 1425:
! 1426: if ((*s_etat_processus).langue == 'F')
! 1427: {
! 1428: printf("(rang de la matrice)\n\n");
! 1429: }
! 1430: else
! 1431: {
! 1432: printf("(matrix rank)\n\n");
! 1433: }
! 1434:
! 1435: printf(" 1: %s, %s, %s\n", d_MIN, d_REL, d_MCX);
! 1436: printf("-> 1: %s\n", d_INT);
! 1437:
! 1438: return;
! 1439: }
! 1440: else if ((*s_etat_processus).test_instruction == 'Y')
! 1441: {
! 1442: (*s_etat_processus).nombre_arguments = -1;
! 1443: return;
! 1444: }
! 1445:
! 1446: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1447: {
! 1448: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 1449: {
! 1450: return;
! 1451: }
! 1452: }
! 1453:
! 1454: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1455: &s_objet_argument) == d_erreur)
! 1456: {
! 1457: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1458: return;
! 1459: }
! 1460:
! 1461: if (((*s_objet_argument).type == MIN) ||
! 1462: ((*s_objet_argument).type == MRL) ||
! 1463: ((*s_objet_argument).type == MCX))
! 1464: {
! 1465: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
! 1466: {
! 1467: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1468: return;
! 1469: }
! 1470:
! 1471: rang(s_etat_processus, (*s_objet_argument).objet,
! 1472: (*s_objet_resultat).objet);
! 1473:
! 1474: if ((*s_etat_processus).erreur_systeme != d_es)
! 1475: {
! 1476: return;
! 1477: }
! 1478:
! 1479: if (((*s_etat_processus).erreur_execution != d_ex) ||
! 1480: ((*s_etat_processus).exception != d_ep))
! 1481: {
! 1482: liberation(s_etat_processus, s_objet_argument);
! 1483: liberation(s_etat_processus, s_objet_resultat);
! 1484: return;
! 1485: }
! 1486: }
! 1487: else
! 1488: {
! 1489: liberation(s_etat_processus, s_objet_argument);
! 1490:
! 1491: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1492: return;
! 1493: }
! 1494:
! 1495: liberation(s_etat_processus, s_objet_argument);
! 1496:
! 1497: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1498: s_objet_resultat) == d_erreur)
! 1499: {
! 1500: return;
! 1501: }
! 1502:
! 1503: return;
! 1504: }
! 1505:
! 1506:
! 1507: /*
! 1508: ================================================================================
! 1509: Fonction 'recode'
! 1510: ================================================================================
! 1511: Entrées :
! 1512: --------------------------------------------------------------------------------
! 1513: Sorties :
! 1514: --------------------------------------------------------------------------------
! 1515: Effets de bord : néant
! 1516: ================================================================================
! 1517: */
! 1518:
! 1519: void
! 1520: instruction_recode(struct_processus *s_etat_processus)
! 1521: {
! 1522: struct_objet *s_objet_argument_1;
! 1523: struct_objet *s_objet_argument_2;
! 1524: struct_objet *s_objet_argument_3;
! 1525: struct_objet *s_objet_resultat;
! 1526:
! 1527: unsigned char *encodage_destination;
! 1528: unsigned char *encodage_source;
! 1529: unsigned char *tampon;
! 1530:
! 1531: (*s_etat_processus).erreur_execution = d_ex;
! 1532:
! 1533: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1534: {
! 1535: printf("\n RECODE ");
! 1536:
! 1537: if ((*s_etat_processus).langue == 'F')
! 1538: {
! 1539: printf("(conversion d'encodage d'une chaîne de caractères)\n\n");
! 1540: }
! 1541: else
! 1542: {
! 1543: printf("(string recodage)\n\n");
! 1544: }
! 1545:
! 1546: printf(" 3: %s\n", d_CHN);
! 1547: printf(" 2: %s\n", d_CHN);
! 1548: printf(" 1: %s\n", d_CHN);
! 1549: printf("-> 1: %s\n\n", d_CHN);
! 1550:
! 1551: if ((*s_etat_processus).langue == 'F')
! 1552: {
! 1553: printf(" Utilisation :\n\n");
! 1554: }
! 1555: else
! 1556: {
! 1557: printf(" Usage:\n\n");
! 1558: }
! 1559:
! 1560: printf(" \"string\" \"ISO8859-1\" \"UTF-8\" recode\n");
! 1561: printf(" \"string\" \"ISO8859-1\" \"UTF-8//TRANSLIT\" recode\n");
! 1562: printf(" \"string\" \"ISO8859-1\" \"UTF-8//IGNORE\" recode\n");
! 1563: return;
! 1564: }
! 1565: else if ((*s_etat_processus).test_instruction == 'Y')
! 1566: {
! 1567: (*s_etat_processus).nombre_arguments = -1;
! 1568: return;
! 1569: }
! 1570:
! 1571: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1572: {
! 1573: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
! 1574: {
! 1575: return;
! 1576: }
! 1577: }
! 1578:
! 1579: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1580: &s_objet_argument_1) == d_erreur)
! 1581: {
! 1582: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1583: return;
! 1584: }
! 1585:
! 1586: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1587: &s_objet_argument_2) == d_erreur)
! 1588: {
! 1589: liberation(s_etat_processus, s_objet_argument_1);
! 1590:
! 1591: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1592: return;
! 1593: }
! 1594:
! 1595: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1596: &s_objet_argument_3) == d_erreur)
! 1597: {
! 1598: liberation(s_etat_processus, s_objet_argument_1);
! 1599: liberation(s_etat_processus, s_objet_argument_2);
! 1600:
! 1601: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1602: return;
! 1603: }
! 1604:
! 1605: if (((*s_objet_argument_1).type == CHN) &&
! 1606: ((*s_objet_argument_2).type == CHN) &&
! 1607: ((*s_objet_argument_3).type == CHN))
! 1608: {
! 1609: if ((encodage_source = conversion_majuscule((unsigned char *)
! 1610: (*s_objet_argument_2).objet)) == NULL)
! 1611: {
! 1612: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1613: return;
! 1614: }
! 1615:
! 1616: if ((encodage_destination = conversion_majuscule((unsigned char *)
! 1617: (*s_objet_argument_1).objet)) == NULL)
! 1618: {
! 1619: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1620: return;
! 1621: }
! 1622:
! 1623: tampon = reencodage(s_etat_processus,
! 1624: (*s_objet_argument_3).objet, encodage_source,
! 1625: encodage_destination);
! 1626:
! 1627: free(encodage_destination);
! 1628: free(encodage_source);
! 1629:
! 1630: if (tampon == NULL)
! 1631: {
! 1632: liberation(s_etat_processus, s_objet_argument_1);
! 1633: liberation(s_etat_processus, s_objet_argument_2);
! 1634: liberation(s_etat_processus, s_objet_argument_3);
! 1635: return;
! 1636: }
! 1637:
! 1638: if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
! 1639: {
! 1640: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1641: return;
! 1642: }
! 1643:
! 1644: (*s_objet_resultat).objet = tampon;
! 1645: }
! 1646: else
! 1647: {
! 1648: liberation(s_etat_processus, s_objet_argument_1);
! 1649: liberation(s_etat_processus, s_objet_argument_2);
! 1650: liberation(s_etat_processus, s_objet_argument_3);
! 1651:
! 1652: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1653: return;
! 1654: }
! 1655:
! 1656: liberation(s_etat_processus, s_objet_argument_1);
! 1657: liberation(s_etat_processus, s_objet_argument_2);
! 1658: liberation(s_etat_processus, s_objet_argument_3);
! 1659:
! 1660: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1661: s_objet_resultat) == d_erreur)
! 1662: {
! 1663: return;
! 1664: }
! 1665:
! 1666: return;
! 1667: }
! 1668:
! 1669:
! 1670: /*
! 1671: ================================================================================
! 1672: Fonction 'repl'
! 1673: ================================================================================
! 1674: Entrées :
! 1675: --------------------------------------------------------------------------------
! 1676: Sorties :
! 1677: --------------------------------------------------------------------------------
! 1678: Effets de bord : néant
! 1679: ================================================================================
! 1680: */
! 1681:
! 1682: void
! 1683: instruction_repl(struct_processus *s_etat_processus)
! 1684: {
! 1685: integer8 position;
! 1686:
! 1687: long difference;
! 1688: long difference_ecriture;
! 1689: long difference_lecture;
! 1690: long nombre_occurrences;
! 1691:
! 1692: struct_liste_chainee *l_element_a_supprimer;
! 1693: struct_liste_chainee *l_element_courant;
! 1694: struct_liste_chainee *l_element_courant_2;
! 1695: struct_liste_chainee *l_element_precedent;
! 1696: struct_liste_chainee *l_element_precedent_2;
! 1697:
! 1698: struct_objet *s_objet_argument_1;
! 1699: struct_objet *s_objet_argument_2;
! 1700: struct_objet *s_objet_argument_3;
! 1701: struct_objet *s_objet_intermediaire;
! 1702: struct_objet *s_objet_resultat;
! 1703:
! 1704: unsigned char *ancien_pointeur_ecriture;
! 1705: unsigned char *ancien_pointeur_lecture;
! 1706: unsigned char *pointeur_ecriture;
! 1707: unsigned char *pointeur_lecture;
! 1708:
! 1709: (*s_etat_processus).erreur_execution = d_ex;
! 1710:
! 1711: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1712: {
! 1713: printf("\n REPL ");
! 1714:
! 1715: if ((*s_etat_processus).langue == 'F')
! 1716: {
! 1717: printf("(remplacement d'éléments dans une liste ou une chaîne)");
! 1718: }
! 1719: else
! 1720: {
! 1721: printf("(replace elements in list or string)\n\n");
! 1722: }
! 1723:
! 1724: printf(" 3: %s\n", d_LST);
! 1725: printf(" 2: %s\n", d_INT);
! 1726: printf(" 1: %s\n", d_LST);
! 1727: printf("-> 1: %s\n\n", d_LST);
! 1728:
! 1729: printf(" 3: %s\n", d_CHN);
! 1730: printf(" 2: %s\n", d_CHN);
! 1731: printf(" 1: %s\n", d_CHN);
! 1732: printf("-> 1: %s\n\n", d_CHN);
! 1733: return;
! 1734: }
! 1735: else if ((*s_etat_processus).test_instruction == 'Y')
! 1736: {
! 1737: (*s_etat_processus).nombre_arguments = -1;
! 1738: return;
! 1739: }
! 1740:
! 1741: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1742: {
! 1743: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
! 1744: {
! 1745: return;
! 1746: }
! 1747: }
! 1748:
! 1749: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1750: &s_objet_argument_1) == d_erreur)
! 1751: {
! 1752: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1753: return;
! 1754: }
! 1755:
! 1756: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1757: &s_objet_argument_2) == d_erreur)
! 1758: {
! 1759: liberation(s_etat_processus, s_objet_argument_1);
! 1760:
! 1761: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1762: return;
! 1763: }
! 1764:
! 1765: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1766: &s_objet_argument_3) == d_erreur)
! 1767: {
! 1768: liberation(s_etat_processus, s_objet_argument_1);
! 1769: liberation(s_etat_processus, s_objet_argument_2);
! 1770:
! 1771: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1772: return;
! 1773: }
! 1774:
! 1775: if (((*s_objet_argument_1).type == CHN) &&
! 1776: ((*s_objet_argument_2).type == CHN) &&
! 1777: ((*s_objet_argument_3).type == CHN))
! 1778: {
! 1779: if (strcmp((unsigned char *) (*s_objet_argument_2).objet, "") == 0)
! 1780: {
! 1781: liberation(s_etat_processus, s_objet_argument_1);
! 1782: liberation(s_etat_processus, s_objet_argument_2);
! 1783: liberation(s_etat_processus, s_objet_argument_3);
! 1784:
! 1785: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 1786: return;
! 1787: }
! 1788:
! 1789: nombre_occurrences = 0;
! 1790: pointeur_lecture = (unsigned char *) (*s_objet_argument_3).objet;
! 1791:
! 1792: for(;;)
! 1793: {
! 1794: pointeur_lecture = strstr(pointeur_lecture, (unsigned char *)
! 1795: (*s_objet_argument_2).objet);
! 1796:
! 1797: if (pointeur_lecture == NULL)
! 1798: {
! 1799: break;
! 1800: }
! 1801:
! 1802: pointeur_lecture++;
! 1803: nombre_occurrences++;
! 1804: }
! 1805:
! 1806: // Différence est positive si la nouvelle chaîne est plus longue
! 1807: // que la chaîne originelle.
! 1808:
! 1809: difference = strlen((unsigned char *) (*s_objet_argument_1).objet)
! 1810: - strlen((unsigned char *) (*s_objet_argument_2).objet);
! 1811:
! 1812: if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
! 1813: {
! 1814: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1815: return;
! 1816: }
! 1817:
! 1818: if (((*s_objet_resultat).objet = malloc((strlen((unsigned char *)
! 1819: (*s_objet_argument_3).objet) + (nombre_occurrences *
! 1820: difference) + 1) * sizeof(unsigned char))) == NULL)
! 1821: {
! 1822: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1823: return;
! 1824: }
! 1825:
! 1826: pointeur_lecture = (unsigned char *) (*s_objet_argument_3).objet;
! 1827: pointeur_ecriture = (unsigned char *) (*s_objet_resultat).objet;
! 1828: difference_lecture = strlen((unsigned char *)
! 1829: (*s_objet_argument_2).objet);
! 1830: difference_ecriture = strlen((unsigned char *)
! 1831: (*s_objet_argument_1).objet);
! 1832:
! 1833: for(;;)
! 1834: {
! 1835: ancien_pointeur_lecture = pointeur_lecture;
! 1836: ancien_pointeur_ecriture = pointeur_ecriture;
! 1837:
! 1838: pointeur_lecture = strstr(ancien_pointeur_lecture,
! 1839: (unsigned char *) (*s_objet_argument_2).objet);
! 1840:
! 1841: if (pointeur_lecture == NULL)
! 1842: {
! 1843: strcpy(ancien_pointeur_ecriture, ancien_pointeur_lecture);
! 1844: break;
! 1845: }
! 1846:
! 1847: strncpy(ancien_pointeur_ecriture, ancien_pointeur_lecture,
! 1848: pointeur_lecture - ancien_pointeur_lecture);
! 1849: strcpy(ancien_pointeur_ecriture +
! 1850: (pointeur_lecture - ancien_pointeur_lecture),
! 1851: (unsigned char *) (*s_objet_argument_1).objet);
! 1852:
! 1853: pointeur_ecriture += difference_ecriture +
! 1854: (pointeur_lecture - ancien_pointeur_lecture);
! 1855: pointeur_lecture += difference_lecture;
! 1856: }
! 1857: }
! 1858: else if (((*s_objet_argument_1).type == LST) &&
! 1859: ((*s_objet_argument_2).type == INT) &&
! 1860: ((*s_objet_argument_3).type == LST))
! 1861: {
! 1862: if ((*((integer8 *) (*s_objet_argument_2).objet)) <= 0)
! 1863: {
! 1864: liberation(s_etat_processus, s_objet_argument_1);
! 1865: liberation(s_etat_processus, s_objet_argument_2);
! 1866: liberation(s_etat_processus, s_objet_argument_3);
! 1867:
! 1868: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
! 1869: return;
! 1870: }
! 1871:
! 1872: if ((s_objet_resultat = copie_objet(s_etat_processus,
! 1873: s_objet_argument_3, 'N')) == NULL)
! 1874: {
! 1875: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1876: return;
! 1877: }
! 1878:
! 1879: l_element_courant = (*s_objet_resultat).objet;
! 1880: l_element_precedent = NULL;
! 1881: position = 1;
! 1882:
! 1883: while(position < (*((integer8 *) (*s_objet_argument_2).objet)))
! 1884: {
! 1885: if (l_element_courant == NULL)
! 1886: {
! 1887: liberation(s_etat_processus, s_objet_argument_1);
! 1888: liberation(s_etat_processus, s_objet_argument_2);
! 1889: liberation(s_etat_processus, s_objet_argument_3);
! 1890: liberation(s_etat_processus, s_objet_resultat);
! 1891:
! 1892: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
! 1893: return;
! 1894: }
! 1895:
! 1896: position++;
! 1897: l_element_precedent = l_element_courant;
! 1898: l_element_courant = (*l_element_courant).suivant;
! 1899: }
! 1900:
! 1901: l_element_a_supprimer = l_element_courant;
! 1902:
! 1903: if (l_element_courant == NULL)
! 1904: {
! 1905: liberation(s_etat_processus, s_objet_argument_1);
! 1906: liberation(s_etat_processus, s_objet_argument_2);
! 1907: liberation(s_etat_processus, s_objet_argument_3);
! 1908: liberation(s_etat_processus, s_objet_resultat);
! 1909:
! 1910: (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
! 1911: return;
! 1912: }
! 1913:
! 1914: if ((s_objet_intermediaire = copie_objet(s_etat_processus,
! 1915: s_objet_argument_1, 'N')) == NULL)
! 1916: {
! 1917: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1918: return;
! 1919: }
! 1920:
! 1921: if (l_element_precedent == NULL)
! 1922: {
! 1923: (*s_objet_resultat).objet = (*s_objet_intermediaire).objet;
! 1924: }
! 1925: else
! 1926: {
! 1927: (*l_element_precedent).suivant = (*s_objet_intermediaire).objet;
! 1928: }
! 1929:
! 1930: // (*l_element_precedent).suivant contient le premier maillon
! 1931: // de la liste accrochée, l_element_a_supprimer est le premier maillons
! 1932: // à supprimer.
! 1933:
! 1934: l_element_courant = (*s_objet_intermediaire).objet;
! 1935: (*s_objet_intermediaire).objet = l_element_a_supprimer;
! 1936:
! 1937: l_element_courant_2 = l_element_a_supprimer;
! 1938: l_element_precedent_2 = NULL;
! 1939:
! 1940: for(;;)
! 1941: {
! 1942: if (l_element_courant == NULL)
! 1943: {
! 1944: // La nouvelle liste est plus courte. On raboute les éléments
! 1945: // restant de l'ancienne liste à la nouvelle.
! 1946:
! 1947: if (l_element_precedent == NULL)
! 1948: {
! 1949: (*s_objet_resultat).objet = l_element_courant_2;
! 1950: }
! 1951: else
! 1952: {
! 1953: (*l_element_precedent).suivant = l_element_courant_2;
! 1954: }
! 1955:
! 1956: if (l_element_precedent_2 == NULL)
! 1957: {
! 1958: (*s_objet_intermediaire).objet = NULL;
! 1959: }
! 1960: else
! 1961: {
! 1962: (*l_element_precedent_2).suivant = NULL;
! 1963: }
! 1964:
! 1965: break;
! 1966: }
! 1967:
! 1968: if (l_element_courant_2 == NULL)
! 1969: {
! 1970: // L'ancienne liste est plus courte.
! 1971: break;
! 1972: }
! 1973:
! 1974: l_element_precedent = l_element_courant;
! 1975: l_element_precedent_2 = l_element_courant_2;
! 1976: l_element_courant = (*l_element_courant).suivant;
! 1977: l_element_courant_2 = (*l_element_courant_2).suivant;
! 1978: }
! 1979:
! 1980: liberation(s_etat_processus, s_objet_intermediaire);
! 1981: }
! 1982: else
! 1983: {
! 1984: liberation(s_etat_processus, s_objet_argument_1);
! 1985: liberation(s_etat_processus, s_objet_argument_2);
! 1986: liberation(s_etat_processus, s_objet_argument_3);
! 1987:
! 1988: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1989: return;
! 1990: }
! 1991:
! 1992: liberation(s_etat_processus, s_objet_argument_1);
! 1993: liberation(s_etat_processus, s_objet_argument_2);
! 1994: liberation(s_etat_processus, s_objet_argument_3);
! 1995:
! 1996: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1997: s_objet_resultat) == d_erreur)
! 1998: {
! 1999: return;
! 2000: }
! 2001:
! 2002: return;
! 2003: }
! 2004:
! 2005: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_r6.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src