![]() ![]() | ![]() |
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 'hex' 29: ================================================================================ 30: Entrées : 31: -------------------------------------------------------------------------------- 32: Sorties : 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: void 39: instruction_hex(struct_processus *s_etat_processus) 40: { 41: (*s_etat_processus).erreur_execution = d_ex; 42: 43: if ((*s_etat_processus).affichage_arguments == 'Y') 44: { 45: printf("\n HEX "); 46: 47: if ((*s_etat_processus).langue == 'F') 48: { 49: printf("(base hexadécimale)\n\n"); 50: printf(" Aucun argument\n"); 51: } 52: else 53: { 54: printf("(hexadecimal base)\n\n"); 55: printf(" No argument\n"); 56: } 57: 58: return; 59: } 60: else if ((*s_etat_processus).test_instruction == 'Y') 61: { 62: (*s_etat_processus).nombre_arguments = -1; 63: return; 64: } 65: 66: sf(s_etat_processus, 43); 67: sf(s_etat_processus, 44); 68: 69: if (test_cfsf(s_etat_processus, 31) == d_vrai) 70: { 71: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 72: { 73: return; 74: } 75: } 76: 77: return; 78: } 79: 80: 81: /* 82: ================================================================================ 83: Fonction 'HMS->' 84: ================================================================================ 85: Entrées : structure processus 86: -------------------------------------------------------------------------------- 87: Sorties : 88: -------------------------------------------------------------------------------- 89: Effets de bord : néant 90: ================================================================================ 91: */ 92: 93: void 94: instruction_hms_fleche(struct_processus *s_etat_processus) 95: { 96: struct_objet *s_copie; 97: struct_objet *s_objet; 98: 99: (*s_etat_processus).erreur_execution = d_ex; 100: 101: if ((*s_etat_processus).affichage_arguments == 'Y') 102: { 103: printf("\n HMS-> "); 104: 105: if ((*s_etat_processus).langue == 'F') 106: { 107: printf("(conversion décimale)\n\n"); 108: } 109: else 110: { 111: printf("(conversion from hours minutes seconds to decimal)\n\n"); 112: } 113: 114: printf(" 1: %s\n", d_INT); 115: printf("-> 1: %s\n\n", d_INT); 116: 117: printf(" 1: %s\n", d_REL); 118: printf("-> 1: %s\n", d_REL); 119: 120: return; 121: } 122: else if ((*s_etat_processus).test_instruction == 'Y') 123: { 124: (*s_etat_processus).nombre_arguments = -1; 125: return; 126: } 127: 128: if (test_cfsf(s_etat_processus, 31) == d_vrai) 129: { 130: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 131: { 132: return; 133: } 134: } 135: 136: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 137: &s_objet) == d_erreur) 138: { 139: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 140: return; 141: } 142: 143: /* 144: -------------------------------------------------------------------------------- 145: Argument entier 146: --------------------------------------------------------------------------------*/ 147: 148: if ((*s_objet).type == INT) 149: { 150: /* 151: * On ne fait rien... 152: */ 153: } 154: 155: /* 156: -------------------------------------------------------------------------------- 157: Argument réel 158: -------------------------------------------------------------------------------- 159: */ 160: 161: else if ((*s_objet).type == REL) 162: { 163: if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL) 164: { 165: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 166: return; 167: } 168: 169: liberation(s_etat_processus, s_objet); 170: s_objet = s_copie; 171: 172: conversion_hms_vers_decimal((real8 *) (*s_objet).objet); 173: } 174: 175: /* 176: -------------------------------------------------------------------------------- 177: Argument invalide 178: -------------------------------------------------------------------------------- 179: */ 180: 181: else 182: { 183: liberation(s_etat_processus, s_objet); 184: 185: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 186: return; 187: } 188: 189: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 190: s_objet) == d_erreur) 191: { 192: return; 193: } 194: 195: return; 196: } 197: 198: 199: /* 200: ================================================================================ 201: Fonction 'HMS+' 202: ================================================================================ 203: Entrées : structure processus 204: -------------------------------------------------------------------------------- 205: Sorties : 206: -------------------------------------------------------------------------------- 207: Effets de bord : néant 208: ================================================================================ 209: */ 210: 211: void 212: instruction_hms_plus(struct_processus *s_etat_processus) 213: { 214: integer8 tampon; 215: 216: struct_objet *s_objet_argument_1; 217: struct_objet *s_objet_argument_2; 218: struct_objet *s_objet_resultat; 219: 220: (*s_etat_processus).erreur_execution = d_ex; 221: 222: if ((*s_etat_processus).affichage_arguments == 'Y') 223: { 224: printf("\n HMS+ "); 225: 226: if ((*s_etat_processus).langue == 'F') 227: { 228: printf("(addition sexadécimale)\n\n"); 229: } 230: else 231: { 232: printf("(addition in hours minutes seconds format)\n\n"); 233: } 234: 235: printf(" 2: %s\n", d_INT); 236: printf(" 1: %s\n", d_INT); 237: printf("-> 1: %s, %s\n\n", d_INT, d_REL); 238: 239: printf(" 2: %s, %s\n", d_INT, d_REL); 240: printf(" 1: %s, %s\n", d_INT, d_REL); 241: printf("-> 1: %s\n", d_REL); 242: 243: return; 244: } 245: else if ((*s_etat_processus).test_instruction == 'Y') 246: { 247: (*s_etat_processus).nombre_arguments = -1; 248: return; 249: } 250: 251: if (test_cfsf(s_etat_processus, 31) == d_vrai) 252: { 253: if (empilement_pile_last(s_etat_processus, 2) == d_erreur) 254: { 255: return; 256: } 257: } 258: 259: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 260: &s_objet_argument_1) == d_erreur) 261: { 262: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 263: return; 264: } 265: 266: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 267: &s_objet_argument_2) == d_erreur) 268: { 269: liberation(s_etat_processus, s_objet_argument_1); 270: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 271: return; 272: } 273: 274: /* 275: -------------------------------------------------------------------------------- 276: Arguments entiers 277: --------------------------------------------------------------------------------*/ 278: 279: if (((*s_objet_argument_1).type == INT) && 280: ((*s_objet_argument_2).type == INT)) 281: { 282: if (depassement_addition((integer8 *) (*s_objet_argument_1).objet, 283: (integer8 *) (*s_objet_argument_2).objet, &tampon) == 284: d_absence_erreur) 285: { 286: if ((s_objet_resultat = allocation(s_etat_processus, INT)) 287: == NULL) 288: { 289: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 290: return; 291: } 292: 293: (*((integer8 *) (*s_objet_resultat).objet)) = tampon; 294: } 295: else 296: { 297: if ((s_objet_resultat = allocation(s_etat_processus, REL)) 298: == NULL) 299: { 300: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 301: return; 302: } 303: 304: (*((real8 *) (*s_objet_resultat).objet)) = ((real8) 305: (*((integer8 *) (*s_objet_argument_1).objet))) + ((real8) 306: (*((integer8 *) (*s_objet_argument_2).objet))); 307: } 308: } 309: 310: /* 311: -------------------------------------------------------------------------------- 312: Au moins un argument réel 313: -------------------------------------------------------------------------------- 314: */ 315: 316: else if (((*s_objet_argument_1).type == REL) && 317: ((*s_objet_argument_2).type == INT)) 318: { 319: conversion_hms_vers_decimal((real8 *) (*s_objet_argument_1).objet); 320: 321: if ((s_objet_resultat = allocation(s_etat_processus, REL)) 322: == NULL) 323: { 324: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 325: return; 326: } 327: 328: (*((real8 *) (*s_objet_resultat).objet)) = (*((integer8 *) 329: (*s_objet_argument_2).objet)) + (*((real8 *) 330: (*s_objet_argument_1).objet)); 331: 332: conversion_decimal_vers_hms((real8 *) (*s_objet_resultat).objet); 333: } 334: else if (((*s_objet_argument_1).type == INT) && 335: ((*s_objet_argument_2).type == REL)) 336: { 337: conversion_hms_vers_decimal((real8 *) (*s_objet_argument_2).objet); 338: 339: if ((s_objet_resultat = allocation(s_etat_processus, REL)) 340: == NULL) 341: { 342: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 343: return; 344: } 345: 346: (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *) 347: (*s_objet_argument_2).objet)) + (*((integer8 *) 348: (*s_objet_argument_1).objet)); 349: 350: conversion_decimal_vers_hms((real8 *) (*s_objet_resultat).objet); 351: } 352: else if (((*s_objet_argument_1).type == REL) && 353: ((*s_objet_argument_2).type == REL)) 354: { 355: conversion_hms_vers_decimal((real8 *) (*s_objet_argument_1).objet); 356: conversion_hms_vers_decimal((real8 *) (*s_objet_argument_2).objet); 357: 358: if ((s_objet_resultat = allocation(s_etat_processus, REL)) 359: == NULL) 360: { 361: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 362: return; 363: } 364: 365: (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *) 366: (*s_objet_argument_2).objet)) + (*((real8 *) 367: (*s_objet_argument_1).objet)); 368: 369: conversion_decimal_vers_hms((real8 *) (*s_objet_resultat).objet); 370: } 371: 372: /* 373: -------------------------------------------------------------------------------- 374: Argument invalide 375: -------------------------------------------------------------------------------- 376: */ 377: 378: else 379: { 380: liberation(s_etat_processus, s_objet_argument_1); 381: liberation(s_etat_processus, s_objet_argument_2); 382: 383: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 384: return; 385: } 386: 387: liberation(s_etat_processus, s_objet_argument_1); 388: liberation(s_etat_processus, s_objet_argument_2); 389: 390: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 391: s_objet_resultat) == d_erreur) 392: { 393: return; 394: } 395: 396: return; 397: } 398: 399: 400: /* 401: ================================================================================ 402: Fonction 'HMS-' 403: ================================================================================ 404: Entrées : structure processus 405: -------------------------------------------------------------------------------- 406: Sorties : 407: -------------------------------------------------------------------------------- 408: Effets de bord : néant 409: ================================================================================ 410: */ 411: 412: void 413: instruction_hms_moins(struct_processus *s_etat_processus) 414: { 415: integer8 tampon; 416: 417: struct_objet *s_objet_argument_1; 418: struct_objet *s_objet_argument_2; 419: struct_objet *s_objet_resultat; 420: 421: (*s_etat_processus).erreur_execution = d_ex; 422: 423: if ((*s_etat_processus).affichage_arguments == 'Y') 424: { 425: printf("\n HMS- "); 426: 427: if ((*s_etat_processus).langue == 'F') 428: { 429: printf("(soustraction sexadécimale)\n\n"); 430: } 431: else 432: { 433: printf("(substraction in hours minutes seconds format)\n\n"); 434: } 435: 436: printf(" 2: %s\n", d_INT); 437: printf(" 1: %s\n", d_INT); 438: printf("-> 1: %s, %s\n\n", d_INT, d_REL); 439: 440: printf(" 2: %s, %s\n", d_INT, d_REL); 441: printf(" 1: %s, %s\n", d_INT, d_REL); 442: printf("-> 1: %s\n", d_REL); 443: 444: return; 445: } 446: else if ((*s_etat_processus).test_instruction == 'Y') 447: { 448: (*s_etat_processus).nombre_arguments = -1; 449: return; 450: } 451: 452: if (test_cfsf(s_etat_processus, 31) == d_vrai) 453: { 454: if (empilement_pile_last(s_etat_processus, 2) == d_erreur) 455: { 456: return; 457: } 458: } 459: 460: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 461: &s_objet_argument_1) == d_erreur) 462: { 463: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 464: return; 465: } 466: 467: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 468: &s_objet_argument_2) == d_erreur) 469: { 470: liberation(s_etat_processus, s_objet_argument_1); 471: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 472: return; 473: } 474: 475: /* 476: -------------------------------------------------------------------------------- 477: Arguments entiers 478: --------------------------------------------------------------------------------*/ 479: 480: if (((*s_objet_argument_1).type == INT) && 481: ((*s_objet_argument_2).type == INT)) 482: { 483: (*((integer8 *) (*s_objet_argument_1).objet)) = 484: -(*((integer8 *) (*s_objet_argument_1).objet)); 485: 486: if (depassement_addition((integer8 *) (*s_objet_argument_1).objet, 487: (integer8 *) (*s_objet_argument_2).objet, &tampon) == 488: d_absence_erreur) 489: { 490: if ((s_objet_resultat = allocation(s_etat_processus, INT)) 491: == NULL) 492: { 493: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 494: return; 495: } 496: 497: (*((integer8 *) (*s_objet_resultat).objet)) = tampon; 498: } 499: else 500: { 501: if ((s_objet_resultat = allocation(s_etat_processus, REL)) 502: == NULL) 503: { 504: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 505: return; 506: } 507: 508: (*((real8 *) (*s_objet_resultat).objet)) = ((real8) 509: (*((integer8 *) (*s_objet_argument_1).objet))) + ((real8) 510: (*((integer8 *) (*s_objet_argument_2).objet))); 511: } 512: } 513: 514: /* 515: -------------------------------------------------------------------------------- 516: Au moins un argument réel 517: -------------------------------------------------------------------------------- 518: */ 519: 520: else if (((*s_objet_argument_1).type == REL) && 521: ((*s_objet_argument_2).type == INT)) 522: { 523: conversion_hms_vers_decimal((real8 *) (*s_objet_argument_1).objet); 524: 525: if ((s_objet_resultat = allocation(s_etat_processus, REL)) 526: == NULL) 527: { 528: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 529: return; 530: } 531: 532: (*((real8 *) (*s_objet_resultat).objet)) = (*((integer8 *) 533: (*s_objet_argument_2).objet)) - (*((real8 *) 534: (*s_objet_argument_1).objet)); 535: 536: conversion_decimal_vers_hms((real8 *) (*s_objet_resultat).objet); 537: } 538: else if (((*s_objet_argument_1).type == INT) && 539: ((*s_objet_argument_2).type == REL)) 540: { 541: conversion_hms_vers_decimal((real8 *) (*s_objet_argument_2).objet); 542: 543: if ((s_objet_resultat = allocation(s_etat_processus, REL)) 544: == NULL) 545: { 546: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 547: return; 548: } 549: 550: (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *) 551: (*s_objet_argument_2).objet)) - (*((integer8 *) 552: (*s_objet_argument_1).objet)); 553: 554: conversion_decimal_vers_hms((real8 *) (*s_objet_resultat).objet); 555: } 556: else if (((*s_objet_argument_1).type == REL) && 557: ((*s_objet_argument_2).type == REL)) 558: { 559: conversion_hms_vers_decimal((real8 *) (*s_objet_argument_1).objet); 560: conversion_hms_vers_decimal((real8 *) (*s_objet_argument_2).objet); 561: 562: if ((s_objet_resultat = allocation(s_etat_processus, REL)) 563: == NULL) 564: { 565: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 566: return; 567: } 568: 569: (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *) 570: (*s_objet_argument_2).objet)) - (*((real8 *) 571: (*s_objet_argument_1).objet)); 572: 573: conversion_decimal_vers_hms((real8 *) (*s_objet_resultat).objet); 574: } 575: 576: /* 577: -------------------------------------------------------------------------------- 578: Argument invalide 579: -------------------------------------------------------------------------------- 580: */ 581: 582: else 583: { 584: liberation(s_etat_processus, s_objet_argument_1); 585: liberation(s_etat_processus, s_objet_argument_2); 586: 587: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 588: return; 589: } 590: 591: liberation(s_etat_processus, s_objet_argument_1); 592: liberation(s_etat_processus, s_objet_argument_2); 593: 594: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 595: s_objet_resultat) == d_erreur) 596: { 597: return; 598: } 599: 600: return; 601: } 602: 603: 604: /* 605: ================================================================================ 606: Fonction 'halt' 607: ================================================================================ 608: Entrées : 609: -------------------------------------------------------------------------------- 610: Sorties : 611: -------------------------------------------------------------------------------- 612: Effets de bord : néant 613: ================================================================================ 614: */ 615: 616: void 617: instruction_halt(struct_processus *s_etat_processus) 618: { 619: (*s_etat_processus).erreur_execution = d_ex; 620: 621: if ((*s_etat_processus).affichage_arguments == 'Y') 622: { 623: printf("\n HALT "); 624: 625: if ((*s_etat_processus).langue == 'F') 626: { 627: printf("(arrêt du programme)\n\n"); 628: printf(" Aucun argument\n"); 629: } 630: else 631: { 632: printf("(program halt)\n\n"); 633: printf(" No argument\n"); 634: } 635: 636: return; 637: } 638: else if ((*s_etat_processus).test_instruction == 'Y') 639: { 640: (*s_etat_processus).nombre_arguments = -1; 641: return; 642: } 643: 644: (*s_etat_processus).debug_programme = d_vrai; 645: 646: return; 647: } 648: 649: 650: /* 651: ================================================================================ 652: Fonction 'histogram' 653: ================================================================================ 654: Entrées : 655: -------------------------------------------------------------------------------- 656: Sorties : 657: -------------------------------------------------------------------------------- 658: Effets de bord : néant 659: ================================================================================ 660: */ 661: 662: void 663: instruction_histogram(struct_processus *s_etat_processus) 664: { 665: (*s_etat_processus).erreur_execution = d_ex; 666: 667: if ((*s_etat_processus).affichage_arguments == 'Y') 668: { 669: printf("\n HISTOGRAM "); 670: 671: if ((*s_etat_processus).langue == 'F') 672: { 673: printf("(graphique statistique de type histogramme)\n\n"); 674: printf(" Aucun argument\n"); 675: } 676: else 677: { 678: printf("(histogram statistical graphic)\n\n"); 679: printf(" No argument\n"); 680: } 681: 682: return; 683: } 684: else if ((*s_etat_processus).test_instruction == 'Y') 685: { 686: (*s_etat_processus).nombre_arguments = -1; 687: return; 688: } 689: 690: strcpy((*s_etat_processus).type_trace_sigma, "HISTOGRAMME"); 691: 692: return; 693: } 694: 695: 696: /* 697: ================================================================================ 698: Fonction 'help' 699: ================================================================================ 700: Entrées : 701: -------------------------------------------------------------------------------- 702: Sorties : 703: -------------------------------------------------------------------------------- 704: Effets de bord : néant 705: ================================================================================ 706: */ 707: 708: void 709: instruction_help(struct_processus *s_etat_processus) 710: { 711: unsigned char *fonction; 712: unsigned char ligne[80 + 1]; 713: unsigned char *pointeur; 714: unsigned char **ptr; 715: unsigned char *registre; 716: 717: # undef COMPLETION 718: # include "completion-conv.h" 719: # include "usages-conv.h" 720: 721: if ((*s_etat_processus).test_instruction == 'Y') 722: { 723: (*s_etat_processus).nombre_arguments = -1; 724: return; 725: } 726: 727: (*s_etat_processus).erreur_execution = d_ex; 728: 729: printf("\n"); 730: 731: if ((*s_etat_processus).langue == 'F') 732: { 733: printf("Liste alphabétique des fonctions intrinsèques :\n\n"); 734: } 735: else 736: { 737: printf("Alphabetical list of intrinsic functions :\n\n"); 738: } 739: 740: ptr = commandes; 741: *ligne = d_code_fin_chaine; 742: 743: while(*ptr != (unsigned char *) NULL) 744: { 745: if (strcmp((*ptr), COMPLETION_RC) == 0) 746: { 747: printf("%s\n\n", ligne); 748: *ligne = d_code_fin_chaine; 749: } 750: else if ((strlen(ligne) + strlen(*ptr) + 2) > 80) 751: { 752: printf("%s\n", ligne); 753: *ligne = d_code_fin_chaine; 754: strcpy(ligne, " "); 755: strcat(ligne, *ptr); 756: 757: if (*(ptr + 1) != NULL) 758: { 759: strcat(ligne, ", "); 760: } 761: } 762: else 763: { 764: if (*ligne == d_code_fin_chaine) 765: { 766: strcat(ligne, " "); 767: } 768: 769: strcat(ligne, *ptr); 770: 771: if (*(ptr + 1) != NULL) 772: { 773: strcat(ligne, ", "); 774: } 775: } 776: 777: ptr++; 778: } 779: 780: if (strlen(ligne) != 0) 781: { 782: printf("%s\n", ligne); 783: } 784: 785: printf("\n"); 786: 787: if ((*s_etat_processus).langue == 'F') 788: { 789: printf("Délimiteurs :\n\n"); 790: printf(" aucun : scalaire, nombre entier ou réel ;\n"); 791: printf(" ( ) : nombre complexe ;\n"); 792: printf(" # : entier binaire ;\n"); 793: printf(" << >> : fonction utilisateur ou équation en notation " 794: "polonaise inversée ;\n"); 795: printf(" ' ' : équation en notation algébrique ou nom de " 796: "variable ;\n"); 797: printf(" [ ] : vecteur ;\n"); 798: printf(" [[ ]] : matrice ;\n"); 799: printf(" <[ ]> : table ;\n"); 800: printf(" \" \" : chaîne de caractères ;\n"); 801: printf(" { } : liste ;\n"); 802: printf(" /* */ : commentaire ;\n"); 803: printf(" // : commentaire allant jusqu'à la fin de la ligne." 804: "\n\n"); 805: printf("Fonctions classées par usage :\n"); 806: printf("(les instructions écrites en majuscules sont insensibles à " 807: "la casse)\n\n"); 808: } 809: else 810: { 811: printf("Delimiters :\n\n"); 812: printf(" none : scalar, integer or real number ;\n"); 813: printf(" ( ) : complex number ;\n"); 814: printf(" # : binary integer ;\n"); 815: printf(" << >> : user-defined function, or equation expressed in " 816: "RPN ;\n"); 817: printf(" ' ' : algebraic equation or variable name ;\n"); 818: printf(" [ ] : scalar vector ;\n"); 819: printf(" [[ ]] : scalar matrix ;\n"); 820: printf(" <[ ]> : table ;\n"); 821: printf(" \" \" : character string ;\n"); 822: printf(" { } : list ;\n"); 823: printf(" /* */ : comment ;\n"); 824: printf(" // : comment running to the end of the line.\n\n"); 825: printf("Functions ordre by usage :\n"); 826: printf("(instructions written in upper case are case-unsensitive)\n\n"); 827: } 828: 829: ptr = usages; 830: *ligne = d_code_fin_chaine; 831: 832: while(*ptr != (unsigned char *) NULL) 833: { 834: if (strcmp((*ptr), USAGES_RC) == 0) 835: { 836: printf(" %s\n\n", ligne); 837: *ligne = d_code_fin_chaine; 838: } 839: else if (strcmp((*ptr), USAGES_TITRE) == 0) 840: { 841: ptr++; 842: 843: if ((*s_etat_processus).langue == 'F') 844: { 845: ptr++; 846: printf(" %s\n", *ptr); 847: } 848: else 849: { 850: printf(" %s\n", *ptr); 851: ptr++; 852: } 853: } 854: else if ((strlen(ligne) + strlen(*ptr) + 2) > 76) 855: { 856: printf(" %s\n", ligne); 857: *ligne = d_code_fin_chaine; 858: strcat(ligne, *ptr); 859: 860: if (*(ptr + 1) != NULL) 861: { 862: strcat(ligne, ", "); 863: } 864: } 865: else 866: { 867: strcat(ligne, *ptr); 868: 869: if (*(ptr + 1) != NULL) 870: { 871: strcat(ligne, ", "); 872: } 873: } 874: 875: ptr++; 876: } 877: 878: if (strlen(ligne) != 0) 879: { 880: printf(" %s\n", ligne); 881: } 882: 883: printf("\n"); 884: 885: if ((*s_etat_processus).langue == 'F') 886: { 887: printf("Processus asynchrones :\n"); 888: printf(" CTRL+C : interruption de l'instruction en cours ;\n"); 889: printf(" CTRL+D : en mode interactif, provque un ABORT ;\n"); 890: printf(" CTRL+Z : en cours d'exécution, provoque un HALT " 891: "asynchrone.\n\n"); 892: 893: printf("Drapeaux (valeurs par défaut) :\n"); 894: printf(" 1 à 30 : drapeaux banalisés (désarmés)\n"); 895: printf(" 31 : pile LAST active (armé en mode interactif, " 896: "désarmé sinon)\n"); 897: printf(" 32 : impression automatique (désarmé)\n"); 898: printf(" 33 : retour à la ligne automatique invalidé " 899: "(désarmé)\n"); 900: printf(" 34 : évaluation des caractères de contrôle (armé)\n"); 901: printf(" 35 : évaluation symbolique des constantes (armé)\n"); 902: printf(" 36 : évaluation symbolique des fonctions (armé)\n"); 903: printf(" 37 à 42 : taille des entiers binaires, bit de poids faible " 904: "en tête (armés)\n"); 905: printf(" 43 à 44 : base de numérotation binaire (désarmés)\n"); 906: printf(" 45 : affichage multiligne (armé)\n"); 907: printf(" 46 à 47 : réservés (désarmés)\n"); 908: printf(" 48 : virgule comme séparateur décimal (désarmé)\n"); 909: printf(" 49 à 50 : format des nombres (désarmés)\n"); 910: printf(" 51 : tonalité désactivée (désarmé)\n"); 911: printf(" 52 : mise à jour automatique des graphiques désactivée " 912: "(désarmé)\n"); 913: printf(" 53 à 56 : nombre de chiffres décimaux, bit de poids fort " 914: "en tête (désarmés)\n"); 915: printf(" 57 à 59 : réservés (désarmés)\n"); 916: printf(" 60 : radian et non degré comme unité angulaire " 917: "(armé)\n"); 918: printf(" 61 à 64 : réservés (désarmés)\n"); 919: } 920: else 921: { 922: printf("Hot keys :\n"); 923: printf(" CTRL+C : interruption ;\n"); 924: printf(" CTRL+D : ABORT (in interactive mode only) ;\n"); 925: printf(" CTRL+Z : HALT.\n\n"); 926: 927: printf("Flags (default values) :\n"); 928: printf(" 1 to 30 : user flags (cleared)\n"); 929: printf(" 31 : LAST stack enabled (set in interactive mode, " 930: "cleared if not)\n"); 931: printf(" 32 : automatic printing (cleared)\n"); 932: printf(" 33 : automatic carriage return disabled " 933: "(cleared)\n"); 934: printf(" 34 : control characters evaluation (set)\n"); 935: printf(" 35 : constant symbolic evaluation (set)\n"); 936: printf(" 36 : function symbolic evaluation (set)\n"); 937: printf(" 37 to 42 : size of binary integers, while starting with " 938: "less significant bit\n"); 939: printf(" (set)\n"); 940: printf(" 43 to 44 : binary integer basis (cleared)\n"); 941: printf(" 45 : multiline conversion (set)\n"); 942: printf(" 46 to 47 : reserved (cleared)\n"); 943: printf(" 48 : comma as decimal separator (cleared)\n"); 944: printf(" 49 to 50 : numbers format (cleared)\n"); 945: printf(" 51 : visual bell disabled (cleared)\n"); 946: printf(" 52 : graphic automatic redrawing disabled " 947: "(cleared)\n"); 948: printf(" 53 to 56 : precision, while starting with " 949: "less significant bit (cleared)\n"); 950: printf(" 57 to 59 : reserved (cleared)\n"); 951: printf(" 60 : radian mode instead of degree one (set)\n"); 952: printf(" 61 to 64 : reserved (cleared)\n"); 953: } 954: 955: printf("\n"); 956: 957: if ((*s_etat_processus).langue == 'F') 958: { 959: printf("Types d'arguments :\n\n"); 960: printf(" %s : entier (64 bits)\n", d_INT); 961: printf(" %s : réel (64 bits)\n", d_REL); 962: printf(" %s : complexe (128 bits)\n", d_CPL); 963: printf(" %s : vecteur entier\n", d_VIN); 964: printf(" %s : vecteur réel\n", d_VRL); 965: printf(" %s : vecteur complexe\n", d_VCX); 966: printf(" %s : matrice entière\n", d_MIN); 967: printf(" %s : matrice réelle\n", d_MRL); 968: printf(" %s : matrice complexe\n", d_MCX); 969: printf(" %s : table\n", d_TAB); 970: printf(" %s : entier binaire\n", d_BIN); 971: printf(" %s : nom\n", d_NOM); 972: printf(" %s : chaîne de caractères\n", d_CHN); 973: printf(" %s : liste\n", d_LST); 974: printf(" %s : expression algébrique\n", d_ALG); 975: printf(" %s : expression RPN\n", d_RPN); 976: printf(" %s : descripteur de fichier\n", d_FCH); 977: printf(" %s : socket\n", d_SCK); 978: printf(" %s : descripteur de bibliothèque\n", d_SLB); 979: printf(" %s : processus\n", d_PRC); 980: printf(" %s : connexion à une base de données SQL\n", d_SQL); 981: printf(" %s : mutex\n", d_MTX); 982: printf(" %s : sémaphore nommé\n", d_SPH); 983: } 984: else 985: { 986: printf("Types :\n\n"); 987: printf(" %s : integer (64 bits)\n", d_INT); 988: printf(" %s : real (64 bits)\n", d_REL); 989: printf(" %s : complex (128 bits)\n", d_CPL); 990: printf(" %s : integer vector\n", d_VIN); 991: printf(" %s : real vector\n", d_VRL); 992: printf(" %s : complex vector\n", d_VCX); 993: printf(" %s : integer matrix\n", d_MIN); 994: printf(" %s : real matrix\n", d_MRL); 995: printf(" %s : complex matrix\n", d_MCX); 996: printf(" %s : table\n", d_TAB); 997: printf(" %s : binary integer\n", d_BIN); 998: printf(" %s : name\n", d_NOM); 999: printf(" %s : string of chars\n", d_CHN); 1000: printf(" %s : list\n", d_LST); 1001: printf(" %s : algebraic expression\n", d_ALG); 1002: printf(" %s : RPN expression\n", d_RPN); 1003: printf(" %s : file descriptor\n", d_FCH); 1004: printf(" %s : socket\n", d_SCK); 1005: printf(" %s : library descriptor\n", d_SLB); 1006: printf(" %s : process\n", d_PRC); 1007: printf(" %s : connection to SQL database\n", d_SQL); 1008: printf(" %s : mutex\n", d_MTX); 1009: printf(" %s : named semaphore\n", d_SPH); 1010: } 1011: 1012: /* 1013: * HELP ne doit pas être récursif sous peine de boucler indéfiniment 1014: * dans la fonction. 1015: */ 1016: 1017: if ((*s_etat_processus).affichage_arguments == 'Y') 1018: { 1019: return; 1020: } 1021: 1022: printf("\n"); 1023: 1024: registre = (*s_etat_processus).instruction_courante; 1025: 1026: flockfile(stdin); 1027: flockfile(stdout); 1028: 1029: while((fonction = readline("HELP> ")) != NULL) 1030: { 1031: if (strcmp(fonction, "") == 0) 1032: { 1033: break; 1034: } 1035: 1036: funlockfile(stdin); 1037: funlockfile(stdout); 1038: 1039: /* 1040: * Élimination des blancs précédents l'instruction 1041: */ 1042: 1043: pointeur = fonction; 1044: 1045: while(((*pointeur) == d_code_tabulation) || 1046: ((*pointeur) == d_code_espace)) 1047: { 1048: pointeur++; 1049: } 1050: 1051: (*s_etat_processus).instruction_courante = pointeur; 1052: 1053: /* 1054: * Élimination des blancs et caractères suivant la première 1055: * instruction. 1056: */ 1057: 1058: while(((*pointeur) != d_code_tabulation) && 1059: ((*pointeur) != d_code_espace) && 1060: ((*pointeur) != d_code_fin_chaine)) 1061: { 1062: pointeur++; 1063: } 1064: 1065: (*pointeur) = d_code_fin_chaine; 1066: 1067: add_history(pointeur); 1068: stifle_history(ds_longueur_historique); 1069: 1070: (*s_etat_processus).test_instruction = 'Y'; 1071: analyse(s_etat_processus, NULL); 1072: (*s_etat_processus).test_instruction = 'N'; 1073: 1074: if ((*s_etat_processus).instruction_valide == 'Y') 1075: { 1076: (*s_etat_processus).affichage_arguments = 'Y'; 1077: analyse(s_etat_processus, NULL); 1078: (*s_etat_processus).affichage_arguments = 'N'; 1079: 1080: printf("\n"); 1081: } 1082: else 1083: { 1084: if ((*s_etat_processus).langue == 'F') 1085: { 1086: printf("Fonction inconnue.\n"); 1087: } 1088: else 1089: { 1090: printf("Unknown function\n"); 1091: } 1092: } 1093: 1094: free(fonction); 1095: flockfile(stdin); 1096: flockfile(stdout); 1097: } 1098: 1099: funlockfile(stdin); 1100: funlockfile(stdout); 1101: 1102: if (fonction == NULL) 1103: { 1104: printf("\n"); 1105: } 1106: 1107: (*s_etat_processus).instruction_courante = registre; 1108: 1109: /* 1110: * Évite l'empilement de 'HELP()' dans la pile opérationnelle dans le 1111: * cas où la dernière commande entrée à l'invite "HELP> " n'existe pas. 1112: */ 1113: 1114: (*s_etat_processus).instruction_valide = 'Y'; 1115: 1116: return; 1117: } 1118: 1119: // vim: ts=4