home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume11 / rpl / part02 / misccmd.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-03-10  |  3.8 KB  |  284 lines
  1. /****************************************************************
  2.  
  3.     Miscellaneous user commands
  4.  
  5. 0.0    hjp    89-06-27
  6.  
  7.     initial version
  8.  
  9. 0.1    hjp    89-07-14
  10.  
  11.     TRON, TROFF added
  12.  
  13. 0.2    hjp    89-08-29
  14.  
  15.     TIME added
  16.  
  17. 0.3    hjp    89-09-03
  18.  
  19.     TIME changed: uses ftime now instead of time
  20.  
  21. 0.4    hjp    89-10-04
  22.  
  23.     -> added.
  24.  
  25. 0.5    hjp    89-11-23
  26.  
  27.     BIN, OCT, DEC, HEX added.
  28.  
  29. 0.6    hjp    90-02-27
  30.  
  31.     comment object added in local_var.
  32.  
  33. 0.7    hjp    90-03-02
  34.  
  35.     } added.
  36.  
  37. 0.8    hjp    90-03-03
  38.  
  39.     malloc replaced by mallocobj (at last!).
  40.  
  41. 0.9    hjp    90-03-06
  42.  
  43.     sys/types.h added for UNIX-compatibility.
  44.  
  45. ****************************************************************/
  46.  
  47.  
  48. #include <math.h>
  49. #include <process.h>
  50. #include <string.h>
  51. #include <sys/types.h>
  52. #include <sys/timeb.h>
  53.  
  54. #include "errors.h"
  55. #include "globvar.h"
  56. #include "rpl.h"
  57. #include "intcmd.h"
  58. #include "misccmd.h"
  59. #include "debug.h"
  60. #include "stackcmd.h"
  61.  
  62. /*
  63.     exit from HP28-Emulator
  64. */
  65.  
  66. void    c_off (void)
  67. {
  68.     exit (0);
  69. }
  70.  
  71.  
  72. void c_pbegin (void)
  73. {
  74.     /*    dummy function -- does nothing    */
  75. }
  76.  
  77.  
  78. void c_pend (void)
  79. {
  80.     /*    dummy function -- does nothing    */
  81. }
  82.  
  83.  
  84. /*
  85.     evaluate object in level 1
  86. */
  87.  
  88. void    c_eval (void)
  89. {
  90.     listobj * l;
  91.  
  92.     l = stack;
  93.  
  94.     if (l) {
  95.         if (l->id == LIST) {
  96.             stack = l->next;
  97.  
  98.             interprete (l->obj, 0);
  99.  
  100.             destroy ((genobj *)l, 0);
  101.         } else {
  102.             error ("eval", INT_STKNOLIST);
  103.         }
  104.     } else {
  105.         error ("eval", ERR_STKEMPTY);
  106.     }
  107. }
  108.  
  109. void    c_tron (void)
  110. {
  111.     traceflag = 1;
  112. }
  113.  
  114. void    c_troff (void)
  115. {
  116.     traceflag = 0;
  117. }
  118.  
  119.  
  120. void    c_time (void)
  121. {
  122.     struct timeb tb;
  123.  
  124.     realobj * c;
  125.  
  126.     ftime (&tb);
  127.     if (!(c = mallocobj (REAL))) {
  128.         error ("TIME", ERR_NOMEM);
  129.         return;
  130.     }
  131.     c->val = tb.time + tb.millitm * 0.001;
  132.     push (c);
  133.  
  134. }
  135.  
  136. /*
  137.     ->
  138.  
  139.     Syntax required:
  140.  
  141.         -> UNAME { UNAME } PROGRAM
  142.  
  143.     1. create local variable for each uname assigning values from the stack.
  144.     2. execute program.
  145.     3. delete the local variables created in step 1.
  146.  
  147.     Example:
  148.  
  149.         -> a b c << some program >>
  150.  
  151.         Stack:
  152.             1
  153.             2
  154.             3
  155.             4
  156.  
  157.         before execution of << some program >>, the stack will contain
  158.         the single value 1,
  159.         the local variable a will contain the value 2,
  160.                    b will contain the value 3,
  161.                    c will contain the value 4.
  162.  
  163.         This twisted arrangement (the variable found last by the interpreter
  164.         gets the value in level one) makes programs more readable,
  165.         but complicates the assignment to local variables.
  166. */
  167.  
  168. static
  169. int    local_var (void)
  170. {
  171.     int    n_var;
  172.     varobj    * v;
  173.     nameobj    * n;
  174.  
  175.     if ((* ++ ip)->id == UNAME) {
  176.  
  177.         n = * ip;    /*    remember name    */
  178.  
  179.         /*    create local variables following in the list first    */
  180.  
  181.         n_var = local_var () + 1;
  182.  
  183.         /*    is there a value on the stack ?    */
  184.  
  185.         if (! stack) {
  186.             error ("->", ERR_2FEWARG);
  187.             return (n_var - 1);
  188.         }
  189.  
  190.         /*     create local variable    */
  191.  
  192.         if (! (v = mallocobj (VARIABLE))) {
  193.             error ("->", ERR_NOMEM);
  194.             return (n_var - 1);
  195.         }
  196.  
  197.         /*    and move value from stack to new var.    */
  198.  
  199.         v->id = VARIABLE;
  200.         v->size = sizeof (varobj);
  201.         v->link = 1;
  202.         strcpy (v->name, n->name);
  203.         v->val = stack->obj; stack->obj->link ++;
  204.         v->next = localvars; localvars = v;
  205.         c_drop ();
  206.         return    n_var;
  207.     } else if ((* ip)->id == COMMENT) {
  208.         /*    skip it and try next    */
  209.         return local_var ();
  210.     } else {
  211.         return 0;
  212.     }
  213. }
  214.  
  215. void    c_local (void)
  216. {
  217.     int    n_var;        /*    number of local variables    */
  218.  
  219.     n_var = local_var ();
  220.  
  221.     /*    now * ip should point to a program    */
  222.  
  223.     if ((* ip)->id != PROGRAM) {
  224.         error ("->", ERR_WRTYPE, id2str ((* ip)->id));
  225.         return;
  226.     }
  227.  
  228.     interprete ((* ip), 0);
  229.  
  230.     /*    remove all local variables created    */
  231.  
  232.     while (-- n_var >= 0) {
  233.         varobj * v = localvars->next;
  234.         destroy (localvars, 0);
  235.         localvars = v;
  236.     }
  237. }
  238.  
  239.  
  240. /*
  241.     BIN    set radix for binaries to 2.
  242. */
  243.  
  244. void c_bin (void)
  245. {
  246.     radix = 2;
  247. }
  248.  
  249.  
  250. /*
  251.     OCT    set radix for binaries to 8.
  252. */
  253.  
  254. void c_oct (void)
  255. {
  256.     radix = 8;
  257. }
  258.  
  259.  
  260. /*
  261.     DEC    set radix for binaries to 10.
  262. */
  263.  
  264. void c_dec (void)
  265. {
  266.     radix = 10;
  267. }
  268.  
  269.  
  270. /*
  271.     HEX    set radix for binaries to 16.
  272. */
  273.  
  274. void c_hex (void)
  275. {
  276.     radix = 16;
  277. }
  278.  
  279.  
  280. void c_listend (void)
  281. {
  282.     /*    dummy function -- does nothing    */
  283. }
  284.