Annotation of rpl/src/instructions_h1.c, revision 1.43
1.1 bertrand 1: /*
2: ================================================================================
1.41 bertrand 3: RPL/2 (R) version 4.1.12
1.43 ! bertrand 4: Copyright (C) 1989-2013 Dr. BERTRAND Joël
1.1 bertrand 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:
1.11 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 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
1.11 bertrand 718: # include "completion-conv.h"
719: # include "usages-conv.h"
1.1 bertrand 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");
1.35 bertrand 888: printf(" CTRL+c : interruption de l'instruction en cours ;\n");
889: printf(" CTRL+d : en mode interactif, provoque un ABORT\n");
890: printf(" CTRL+g : en mode interactif, provoque l'annulation de la "
891: "commande en cours ;\n");
892: printf(" CTRL+z : en cours d'exécution, provoque un HALT "
1.1 bertrand 893: "asynchrone.\n\n");
894:
895: printf("Drapeaux (valeurs par défaut) :\n");
896: printf(" 1 à 30 : drapeaux banalisés (désarmés)\n");
897: printf(" 31 : pile LAST active (armé en mode interactif, "
898: "désarmé sinon)\n");
899: printf(" 32 : impression automatique (désarmé)\n");
900: printf(" 33 : retour à la ligne automatique invalidé "
901: "(désarmé)\n");
1.18 bertrand 902: printf(" 34 : évaluation des caractères de contrôle (armé)\n");
1.1 bertrand 903: printf(" 35 : évaluation symbolique des constantes (armé)\n");
904: printf(" 36 : évaluation symbolique des fonctions (armé)\n");
905: printf(" 37 à 42 : taille des entiers binaires, bit de poids faible "
906: "en tête (armés)\n");
907: printf(" 43 à 44 : base de numérotation binaire (désarmés)\n");
908: printf(" 45 : affichage multiligne (armé)\n");
909: printf(" 46 à 47 : réservés (désarmés)\n");
910: printf(" 48 : virgule comme séparateur décimal (désarmé)\n");
911: printf(" 49 à 50 : format des nombres (désarmés)\n");
912: printf(" 51 : tonalité désactivée (désarmé)\n");
913: printf(" 52 : mise à jour automatique des graphiques désactivée "
914: "(désarmé)\n");
915: printf(" 53 à 56 : nombre de chiffres décimaux, bit de poids fort "
916: "en tête (désarmés)\n");
917: printf(" 57 à 59 : réservés (désarmés)\n");
918: printf(" 60 : radian et non degré comme unité angulaire "
919: "(armé)\n");
920: printf(" 61 à 64 : réservés (désarmés)\n");
921: }
922: else
923: {
924: printf("Hot keys :\n");
1.35 bertrand 925: printf(" CTRL+c : interruption ;\n");
926: printf(" CTRL+d : in interactive mode only sends ABORT on empty "
927: "command line ;\n");
928: printf(" CTRL+g : in interactive mode only, nullifies current "
929: "command line ;\n");
930: printf(" CTRL+z : HALT.\n\n");
1.1 bertrand 931:
932: printf("Flags (default values) :\n");
1.17 bertrand 933: printf(" 1 to 30 : user flags (cleared)\n");
934: printf(" 31 : LAST stack enabled (set in interactive mode, "
1.1 bertrand 935: "cleared if not)\n");
1.17 bertrand 936: printf(" 32 : automatic printing (cleared)\n");
937: printf(" 33 : automatic carriage return disabled "
1.1 bertrand 938: "(cleared)\n");
1.19 bertrand 939: printf(" 34 : control characters evaluation (set)\n");
1.17 bertrand 940: printf(" 35 : constant symbolic evaluation (set)\n");
941: printf(" 36 : function symbolic evaluation (set)\n");
942: printf(" 37 to 42 : size of binary integers, while starting with "
943: "less significant bit\n");
944: printf(" (set)\n");
945: printf(" 43 to 44 : binary integer basis (cleared)\n");
946: printf(" 45 : multiline conversion (set)\n");
947: printf(" 46 to 47 : reserved (cleared)\n");
948: printf(" 48 : comma as decimal separator (cleared)\n");
949: printf(" 49 to 50 : numbers format (cleared)\n");
950: printf(" 51 : visual bell disabled (cleared)\n");
951: printf(" 52 : graphic automatic redrawing disabled "
1.1 bertrand 952: "(cleared)\n");
1.17 bertrand 953: printf(" 53 to 56 : precision, while starting with "
1.1 bertrand 954: "less significant bit (cleared)\n");
1.17 bertrand 955: printf(" 57 to 59 : reserved (cleared)\n");
956: printf(" 60 : radian mode instead of degree one (set)\n");
957: printf(" 61 to 64 : reserved (cleared)\n");
1.1 bertrand 958: }
959:
960: printf("\n");
961:
962: if ((*s_etat_processus).langue == 'F')
963: {
964: printf("Types d'arguments :\n\n");
965: printf(" %s : entier (64 bits)\n", d_INT);
966: printf(" %s : réel (64 bits)\n", d_REL);
967: printf(" %s : complexe (128 bits)\n", d_CPL);
968: printf(" %s : vecteur entier\n", d_VIN);
969: printf(" %s : vecteur réel\n", d_VRL);
970: printf(" %s : vecteur complexe\n", d_VCX);
971: printf(" %s : matrice entière\n", d_MIN);
972: printf(" %s : matrice réelle\n", d_MRL);
973: printf(" %s : matrice complexe\n", d_MCX);
974: printf(" %s : table\n", d_TAB);
975: printf(" %s : entier binaire\n", d_BIN);
976: printf(" %s : nom\n", d_NOM);
977: printf(" %s : chaîne de caractères\n", d_CHN);
978: printf(" %s : liste\n", d_LST);
979: printf(" %s : expression algébrique\n", d_ALG);
980: printf(" %s : expression RPN\n", d_RPN);
981: printf(" %s : descripteur de fichier\n", d_FCH);
982: printf(" %s : socket\n", d_SCK);
983: printf(" %s : descripteur de bibliothèque\n", d_SLB);
984: printf(" %s : processus\n", d_PRC);
985: printf(" %s : connexion à une base de données SQL\n", d_SQL);
986: printf(" %s : mutex\n", d_MTX);
987: printf(" %s : sémaphore nommé\n", d_SPH);
988: }
989: else
990: {
991: printf("Types :\n\n");
992: printf(" %s : integer (64 bits)\n", d_INT);
993: printf(" %s : real (64 bits)\n", d_REL);
994: printf(" %s : complex (128 bits)\n", d_CPL);
995: printf(" %s : integer vector\n", d_VIN);
996: printf(" %s : real vector\n", d_VRL);
997: printf(" %s : complex vector\n", d_VCX);
998: printf(" %s : integer matrix\n", d_MIN);
999: printf(" %s : real matrix\n", d_MRL);
1000: printf(" %s : complex matrix\n", d_MCX);
1001: printf(" %s : table\n", d_TAB);
1002: printf(" %s : binary integer\n", d_BIN);
1003: printf(" %s : name\n", d_NOM);
1004: printf(" %s : string of chars\n", d_CHN);
1005: printf(" %s : list\n", d_LST);
1006: printf(" %s : algebraic expression\n", d_ALG);
1007: printf(" %s : RPN expression\n", d_RPN);
1008: printf(" %s : file descriptor\n", d_FCH);
1009: printf(" %s : socket\n", d_SCK);
1010: printf(" %s : library descriptor\n", d_SLB);
1011: printf(" %s : process\n", d_PRC);
1012: printf(" %s : connection to SQL database\n", d_SQL);
1013: printf(" %s : mutex\n", d_MTX);
1014: printf(" %s : named semaphore\n", d_SPH);
1015: }
1016:
1017: /*
1018: * HELP ne doit pas être récursif sous peine de boucler indéfiniment
1019: * dans la fonction.
1020: */
1021:
1022: if ((*s_etat_processus).affichage_arguments == 'Y')
1023: {
1024: return;
1025: }
1026:
1027: printf("\n");
1028:
1029: registre = (*s_etat_processus).instruction_courante;
1030:
1031: flockfile(stdin);
1032: flockfile(stdout);
1033:
1034: while((fonction = readline("HELP> ")) != NULL)
1035: {
1036: if (strcmp(fonction, "") == 0)
1037: {
1038: break;
1039: }
1040:
1.13 bertrand 1041: funlockfile(stdin);
1042: funlockfile(stdout);
1043:
1.1 bertrand 1044: /*
1045: * Élimination des blancs précédents l'instruction
1046: */
1047:
1048: pointeur = fonction;
1049:
1050: while(((*pointeur) == d_code_tabulation) ||
1051: ((*pointeur) == d_code_espace))
1052: {
1053: pointeur++;
1054: }
1055:
1056: (*s_etat_processus).instruction_courante = pointeur;
1057:
1058: /*
1059: * Élimination des blancs et caractères suivant la première
1060: * instruction.
1061: */
1062:
1063: while(((*pointeur) != d_code_tabulation) &&
1064: ((*pointeur) != d_code_espace) &&
1065: ((*pointeur) != d_code_fin_chaine))
1066: {
1067: pointeur++;
1068: }
1069:
1070: (*pointeur) = d_code_fin_chaine;
1071:
1072: add_history(pointeur);
1073: stifle_history(ds_longueur_historique);
1074:
1075: (*s_etat_processus).test_instruction = 'Y';
1076: analyse(s_etat_processus, NULL);
1077: (*s_etat_processus).test_instruction = 'N';
1078:
1079: if ((*s_etat_processus).instruction_valide == 'Y')
1080: {
1081: (*s_etat_processus).affichage_arguments = 'Y';
1082: analyse(s_etat_processus, NULL);
1083: (*s_etat_processus).affichage_arguments = 'N';
1084:
1085: printf("\n");
1086: }
1087: else
1088: {
1089: if ((*s_etat_processus).langue == 'F')
1090: {
1091: printf("Fonction inconnue.\n");
1092: }
1093: else
1094: {
1095: printf("Unknown function\n");
1096: }
1097: }
1098:
1099: free(fonction);
1100: flockfile(stdin);
1101: flockfile(stdout);
1102: }
1103:
1104: funlockfile(stdin);
1105: funlockfile(stdout);
1106:
1107: if (fonction == NULL)
1108: {
1109: printf("\n");
1110: }
1111:
1112: (*s_etat_processus).instruction_courante = registre;
1113:
1114: /*
1115: * Évite l'empilement de 'HELP()' dans la pile opérationnelle dans le
1116: * cas où la dernière commande entrée à l'invite "HELP> " n'existe pas.
1117: */
1118:
1119: (*s_etat_processus).instruction_valide = 'Y';
1120:
1121: return;
1122: }
1123:
1124: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_h1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src