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