Annotation of rpl/src/rplcore.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 'rplcore' générant un fichier de débogage
! 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: rplcore(struct_processus *s_etat_processus)
! 40: {
! 41: file *fichier;
! 42:
! 43: logical1 erreur;
! 44: logical1 fin_boucle;
! 45:
! 46: long i;
! 47: long j;
! 48: long longueur_lignes = 65;
! 49:
! 50: struct_liste_chainee *l_base_pile;
! 51: struct_liste_chainee *l_element_courant;
! 52:
! 53: struct_objet *s_objet_last;
! 54:
! 55: unsigned char *expression;
! 56: unsigned char *nom;
! 57: unsigned char *message_erreur;
! 58: unsigned char *pile;
! 59: unsigned char *ptr;
! 60: unsigned char *ptr_bis;
! 61: unsigned char registre_langue;
! 62:
! 63: (*s_etat_processus).core = d_faux;
! 64:
! 65: sf(s_etat_processus, 37);
! 66: sf(s_etat_processus, 38);
! 67: sf(s_etat_processus, 39);
! 68: sf(s_etat_processus, 40);
! 69: sf(s_etat_processus, 41);
! 70: sf(s_etat_processus, 42);
! 71:
! 72: cf(s_etat_processus, 43);
! 73: cf(s_etat_processus, 44);
! 74:
! 75: sf(s_etat_processus, 45);
! 76:
! 77: cf(s_etat_processus, 48);
! 78:
! 79: cf(s_etat_processus, 49);
! 80: cf(s_etat_processus, 50);
! 81:
! 82: cf(s_etat_processus, 53);
! 83: cf(s_etat_processus, 54);
! 84: cf(s_etat_processus, 55);
! 85: cf(s_etat_processus, 56);
! 86:
! 87: sf(s_etat_processus, 60);
! 88:
! 89: registre_langue = (*s_etat_processus).langue;
! 90: (*s_etat_processus).langue = 'E';
! 91:
! 92: message_erreur = messages(s_etat_processus);
! 93:
! 94: (*s_etat_processus).langue = registre_langue;
! 95:
! 96: if ((nom = malloc((strlen(ds_rplcore) + 64 + 1) * sizeof(unsigned char)))
! 97: == NULL)
! 98: {
! 99: free(message_erreur);
! 100: return;
! 101: }
! 102:
! 103: snprintf(nom, strlen(ds_rplcore) + 64 + 1,
! 104: "%s-%lu-%lu", ds_rplcore, (unsigned long) getpid(),
! 105: (unsigned long) pthread_self());
! 106:
! 107: if ((fichier = fopen(nom, "w+")) == NULL)
! 108: {
! 109: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 110: free(message_erreur);
! 111: free(nom);
! 112:
! 113: return;
! 114: }
! 115:
! 116: free(nom);
! 117:
! 118: if (fprintf(fichier, "// RPL/2 version %s process image\n",
! 119: d_version_rpl) < 0)
! 120: {
! 121: free(message_erreur);
! 122:
! 123: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 124: return;
! 125: }
! 126:
! 127: if (fprintf(fichier, "// Process %d\n", (int) getpid()) < 0)
! 128: {
! 129: free(message_erreur);
! 130:
! 131: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 132: return;
! 133: }
! 134:
! 135: if (fprintf(fichier, "// Source file : %s\n\n",
! 136: (*s_etat_processus).nom_fichier_source) < 0)
! 137: {
! 138: free(message_erreur);
! 139:
! 140: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 141: return;
! 142: }
! 143:
! 144: if (fprintf(fichier, "// Error :\n%s [%s at level %lu]\n\n",
! 145: message_erreur, (*s_etat_processus).instruction_derniere_erreur,
! 146: (*s_etat_processus).niveau_derniere_erreur) < 0)
! 147: {
! 148: free(message_erreur);
! 149:
! 150: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 151: return;
! 152: }
! 153:
! 154: free(message_erreur);
! 155:
! 156: if (fprintf(fichier, "// Process stack\n\n") < 0)
! 157: {
! 158: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 159: return;
! 160: }
! 161:
! 162: l_element_courant = (struct_liste_chainee *)
! 163: (*s_etat_processus).l_base_pile_processus;
! 164: i = 0;
! 165:
! 166: if (pthread_mutex_trylock(&((*s_etat_processus).mutex)) == 0)
! 167: {
! 168: while(l_element_courant != NULL)
! 169: {
! 170: if ((*(*((struct_processus_fils *)
! 171: (*(*l_element_courant).donnee).objet)).thread)
! 172: .processus_detache == d_vrai)
! 173: {
! 174: if (fprintf(fichier, "%ld: Process [%d]\n",
! 175: i++, (int) (*(*((struct_processus_fils *)
! 176: (*(*l_element_courant).donnee).objet)).thread).pid) < 0)
! 177: {
! 178: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 179: return;
! 180: }
! 181: }
! 182: else
! 183: {
! 184: if (fprintf(fichier, "%ld: Thread [%llu] from [%llu]\n",
! 185: i++, (unsigned long long) (*(*((struct_processus_fils *)
! 186: (*(*l_element_courant).donnee).objet)).thread)
! 187: .tid, (unsigned long long)
! 188: (*(*((struct_processus_fils *) (*(*l_element_courant)
! 189: .donnee).objet)).thread).pid) < 0)
! 190: {
! 191: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 192: return;
! 193: }
! 194: }
! 195:
! 196: l_element_courant = (*l_element_courant).suivant;
! 197: }
! 198:
! 199: if (fprintf(fichier, "%ld: Process [%d]\n\n", i,
! 200: (int) getpid()) < 0)
! 201: {
! 202: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 203: return;
! 204: }
! 205:
! 206: pthread_mutex_unlock(&((*s_etat_processus).mutex));
! 207: }
! 208:
! 209: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 210: {
! 211: // LAST valide
! 212:
! 213: if (fprintf(fichier, "// Arguments\n\n") < 0)
! 214: {
! 215: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 216: return;
! 217: }
! 218:
! 219: l_base_pile = NULL;
! 220:
! 221: while((*s_etat_processus).l_base_pile_last != NULL)
! 222: {
! 223: if (depilement(s_etat_processus, &((*s_etat_processus)
! 224: .l_base_pile_last), &s_objet_last) == d_erreur)
! 225: {
! 226: return;
! 227: }
! 228:
! 229: if (empilement(s_etat_processus, &l_base_pile, s_objet_last)
! 230: == d_erreur)
! 231: {
! 232: return;
! 233: }
! 234: }
! 235:
! 236: if ((*s_etat_processus).l_base_pile != NULL)
! 237: {
! 238: ecriture_pile(s_etat_processus, fichier, l_base_pile, 1);
! 239: }
! 240: else
! 241: {
! 242: if (fprintf(fichier, " No argument\n") < 0)
! 243: {
! 244: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 245: return;
! 246: }
! 247: }
! 248:
! 249: while(l_base_pile != NULL)
! 250: {
! 251: if (depilement(s_etat_processus, &l_base_pile,
! 252: &s_objet_last) == d_erreur)
! 253: {
! 254: return;
! 255: }
! 256:
! 257: if (empilement(s_etat_processus, &((*s_etat_processus)
! 258: .l_base_pile_last), s_objet_last) == d_erreur)
! 259: {
! 260: return;
! 261: }
! 262: }
! 263: }
! 264: else
! 265: {
! 266: // LAST invalide
! 267:
! 268: if (fprintf(fichier, "// Current stack (LAST disabled)\n") < 0)
! 269: {
! 270: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 271: return;
! 272: }
! 273: }
! 274:
! 275: if (fprintf(fichier, "\n// Stack\n\n") < 0)
! 276: {
! 277: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 278: return;
! 279: }
! 280:
! 281: if ((*s_etat_processus).l_base_pile != NULL)
! 282: {
! 283: ecriture_pile(s_etat_processus, fichier,
! 284: (*s_etat_processus).l_base_pile, 1);
! 285: }
! 286: else
! 287: {
! 288: if (fprintf(fichier, " Empty stack\n") < 0)
! 289: {
! 290: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 291: return;
! 292: }
! 293: }
! 294:
! 295: if ((*s_etat_processus).s_objet_errone != NULL)
! 296: {
! 297: if (fprintf(fichier, "\n// Current evaluation\n") < 0)
! 298: {
! 299: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 300: return;
! 301: }
! 302:
! 303: // L'objet ne peut être qu'une expression algébrique ou RPN
! 304:
! 305: if (((*(*s_etat_processus).s_objet_errone).type == RPN) ||
! 306: ((*(*s_etat_processus).s_objet_errone).type == ALG))
! 307: {
! 308: l_element_courant = (*(*s_etat_processus).s_objet_errone).objet;
! 309:
! 310: if (fprintf(fichier, "\n") < 0)
! 311: {
! 312: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 313: return;
! 314: }
! 315:
! 316: while(l_element_courant != NULL)
! 317: {
! 318: if ((*l_element_courant).donnee ==
! 319: (*s_etat_processus).s_objet_erreur)
! 320: {
! 321: if ((expression = formateur(s_etat_processus, 4,
! 322: (*l_element_courant).donnee)) == NULL)
! 323: {
! 324: return;
! 325: }
! 326:
! 327: if ((*(*l_element_courant).donnee).type == CHN)
! 328: {
! 329: if (fprintf(fichier, " -> \"%s\"\n", expression) < 0)
! 330: {
! 331: (*s_etat_processus).erreur_systeme =
! 332: d_es_erreur_fichier;
! 333: return;
! 334: }
! 335: }
! 336: else
! 337: {
! 338: if (fprintf(fichier, " -> %s\n", expression) < 0)
! 339: {
! 340: (*s_etat_processus).erreur_systeme =
! 341: d_es_erreur_fichier;
! 342: return;
! 343: }
! 344: }
! 345: }
! 346: else
! 347: {
! 348: if ((expression = formateur(s_etat_processus, 4,
! 349: (*l_element_courant).donnee)) == NULL)
! 350: {
! 351: return;
! 352: }
! 353:
! 354: if ((*(*l_element_courant).donnee).type == CHN)
! 355: {
! 356: if (fprintf(fichier, " \"%s\"\n", expression) < 0)
! 357: {
! 358: (*s_etat_processus).erreur_systeme =
! 359: d_es_erreur_fichier;
! 360: return;
! 361: }
! 362: }
! 363: else
! 364: {
! 365: if (fprintf(fichier, " %s\n", expression) < 0)
! 366: {
! 367: (*s_etat_processus).erreur_systeme =
! 368: d_es_erreur_fichier;
! 369: return;
! 370: }
! 371: }
! 372: }
! 373:
! 374: free(expression);
! 375: l_element_courant = (*l_element_courant).suivant;
! 376: }
! 377: }
! 378: else
! 379: {
! 380: if ((expression = formateur(s_etat_processus, 4,
! 381: (*s_etat_processus).s_objet_errone)) == NULL)
! 382: {
! 383: return;
! 384: }
! 385:
! 386: if (fprintf(fichier, "\n%s\n", expression) < 0)
! 387: {
! 388: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 389: return;
! 390: }
! 391:
! 392: free(expression);
! 393: }
! 394: }
! 395:
! 396: if ((*s_etat_processus).longueur_definitions_chainees != 0)
! 397: {
! 398: if (fprintf(fichier, "\n// Definitions\n") < 0)
! 399: {
! 400: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 401: return;
! 402: }
! 403:
! 404: ptr = (*s_etat_processus).definitions_chainees;
! 405: i = 0;
! 406: erreur = d_faux;
! 407:
! 408: while(((*ptr) != d_code_fin_chaine) || (erreur == d_vrai))
! 409: {
! 410: if ((i % longueur_lignes) == 0)
! 411: {
! 412: if (fprintf(fichier, "\n") < 0)
! 413: {
! 414: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 415: return;
! 416: }
! 417:
! 418: if (erreur == d_vrai)
! 419: {
! 420: if (fprintf(fichier, "PC :") < 0)
! 421: {
! 422: (*s_etat_processus).erreur_systeme =
! 423: d_es_erreur_fichier;
! 424: return;
! 425: }
! 426:
! 427: if ((j = i - longueur_lignes) < 0)
! 428: {
! 429: j = 0;
! 430: ptr_bis = (*s_etat_processus).definitions_chainees;
! 431: }
! 432: else
! 433: {
! 434: ptr_bis = ptr - longueur_lignes;
! 435: }
! 436:
! 437: fin_boucle = d_faux;
! 438:
! 439: while(((*ptr_bis) != d_code_fin_chaine) &&
! 440: (fin_boucle == d_faux))
! 441: {
! 442: if (j == (long) (*s_etat_processus).position_courante)
! 443: {
! 444: if (fprintf(fichier, ">|<") < 0)
! 445: {
! 446: (*s_etat_processus).erreur_systeme =
! 447: d_es_erreur_fichier;
! 448: return;
! 449: }
! 450:
! 451: fin_boucle = d_vrai;
! 452: }
! 453: else
! 454: {
! 455: if (fprintf(fichier, " ") < 0)
! 456: {
! 457: (*s_etat_processus).erreur_systeme =
! 458: d_es_erreur_fichier;
! 459: return;
! 460: }
! 461: }
! 462:
! 463: j++;
! 464: ptr_bis++;
! 465: }
! 466:
! 467: if (fprintf(fichier, "\n") < 0)
! 468: {
! 469: (*s_etat_processus).erreur_systeme =
! 470: d_es_erreur_fichier;
! 471: return;
! 472: }
! 473: }
! 474:
! 475: if ((*ptr) != d_code_fin_chaine)
! 476: {
! 477: if (erreur == d_vrai)
! 478: {
! 479: if (fprintf(fichier, "\n") < 0)
! 480: {
! 481: (*s_etat_processus).erreur_systeme =
! 482: d_es_erreur_fichier;
! 483: return;
! 484: }
! 485: }
! 486:
! 487: if ((i <= (long) (*s_etat_processus).position_courante) &&
! 488: ((i + longueur_lignes) > (long) (*s_etat_processus)
! 489: .position_courante))
! 490: {
! 491: if (fprintf(fichier, "\nError : ") < 0)
! 492: {
! 493: (*s_etat_processus).erreur_systeme =
! 494: d_es_erreur_fichier;
! 495: return;
! 496: }
! 497:
! 498: erreur = d_vrai;
! 499: }
! 500: else
! 501: {
! 502: if (fprintf(fichier, " ") < 0)
! 503: {
! 504: (*s_etat_processus).erreur_systeme =
! 505: d_es_erreur_fichier;
! 506: return;
! 507: }
! 508:
! 509: erreur = d_faux;
! 510: }
! 511: }
! 512: else
! 513: {
! 514: erreur = d_faux;
! 515: }
! 516: }
! 517:
! 518: if ((*ptr) != d_code_fin_chaine)
! 519: {
! 520: if (ufprintf(fichier, "%c", *ptr) < 0)
! 521: {
! 522: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 523: return;
! 524: }
! 525:
! 526: ptr++;
! 527: }
! 528:
! 529: i++;
! 530: }
! 531:
! 532: if (fprintf(fichier, "\n// End of definitions\n") < 0)
! 533: {
! 534: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 535: return;
! 536: }
! 537: }
! 538:
! 539: if (fprintf(fichier, "\n// Externals\n\n") < 0)
! 540: {
! 541: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 542: return;
! 543: }
! 544:
! 545: instruction_externals(s_etat_processus);
! 546:
! 547: if (fprintf(fichier, "%s\n", pile =
! 548: formateur(s_etat_processus, 0, (*(*s_etat_processus).l_base_pile)
! 549: .donnee)) < 0)
! 550: {
! 551: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 552: return;
! 553: }
! 554:
! 555: free(pile);
! 556:
! 557: if (fprintf(fichier, "\n// Variables\n\n") < 0)
! 558: {
! 559: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 560: return;
! 561: }
! 562:
! 563: instruction_vars(s_etat_processus);
! 564:
! 565: if (fprintf(fichier, "%s\n", pile =
! 566: formateur(s_etat_processus, 0, (*(*s_etat_processus).l_base_pile)
! 567: .donnee)) < 0)
! 568: {
! 569: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 570: return;
! 571: }
! 572:
! 573: free(pile);
! 574:
! 575: instruction_drop2(s_etat_processus);
! 576:
! 577: if (fclose(fichier) != 0)
! 578: {
! 579: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 580: return;
! 581: }
! 582:
! 583: free((*s_etat_processus).instruction_derniere_erreur);
! 584: (*s_etat_processus).instruction_derniere_erreur = NULL;
! 585:
! 586: return;
! 587: }
! 588:
! 589: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rplcore.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src