home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 13 / MA_Cover_13.bin / source / c / apl / a9.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-11-23  |  3.8 KB  |  215 lines
  1. #include "apl.h"
  2.  
  3. ex_dibm()
  4. {
  5.     int j, arg;
  6.     struct item *p;
  7.  
  8.     /* Dyadic i-beam functions.  I-beam 63 assumes that the
  9.      * "empty" system call (check whether pipe empty) has been
  10.      * implemented in the Unix kernel.
  11.      */
  12.  
  13.     arg = topfix();                    /* Get left argument */
  14.  
  15.     switch(topfix()) {
  16.  
  17.     default:
  18.         error("unknown i-beam");
  19.  
  20.     case 29:                         /* Set origin, return old one */
  21.         datum = thread.iorg;
  22.         thread.iorg = arg;
  23.         break;
  24.  
  25.     case 30:                         /* Set width, return old one */
  26.         datum = thread.width;
  27.         thread.width = arg;
  28.         break;
  29.  
  30.     case 31:                         /* Set number of digits, return old one */
  31.         datum = thread.digits;
  32.         thread.digits = arg;
  33.         break;
  34.  
  35.     case 34:                         /* "Nice" system call */
  36.         datum = nice(arg);
  37.         break;
  38.  
  39.     case 35:                        /* "Sleep" system call */
  40.         datum = sleep(arg);
  41.         break;
  42.  
  43.     case 63:                        /* "Empty" system call */
  44.         datum = empty(arg);
  45.         break;
  46.  
  47.     case 90:                        /* Enable/disable exit with ")off" only */
  48.         datum = offexit;
  49.         arg = !!arg;
  50.         offexit = arg ? isatty(0) : arg;
  51.         break;
  52.  
  53.     case 99:                        /* Buffer flush */
  54.         /* Warning -- information is lost if an input pipe
  55.          * file descriptor is flushed.  No checking is
  56.          * made for this i-beam function!!
  57.          */
  58.         datum = zero;
  59.         break;
  60.  
  61.     }
  62.  
  63.     p = newdat(DA, 0, 1);
  64.     p->datap[0] = datum;
  65.     *sp++ = p;
  66. }
  67.  
  68.  
  69. int afnfree, afnused;
  70.  
  71. ex_mibm()
  72. {
  73.     struct tm *tp, *localtime();
  74.     struct si *gp;
  75.     struct item *p;
  76.     int i;
  77.     long tvec;
  78.     struct {
  79.         long proc_user_time;
  80.         long proc_system_time;
  81.         long child_user_time;
  82.         long child_system_time;
  83.     } t;
  84.  
  85.     switch(topfix()) {
  86.  
  87.     default:
  88.         error("unknown i-beam");
  89.  
  90.     case 20:                        /* time of day */
  91.         time(&tvec);
  92.         goto tod;
  93.  
  94.     case 21:                        /* CPU time */
  95.         times(&t);
  96.         datum = t.proc_user_time+t.proc_system_time;
  97.         break;
  98.  
  99.     case 22:                        /* ws bytes unused */
  100.         datum = afnfree;
  101.         break;
  102.  
  103.     case 24:                        /* starting time */
  104.         tvec = startTime;
  105.  
  106.     tod:
  107.         tp = localtime(&tvec);
  108.         datum = 60.*(tp->tm_sec+60.*(tp->tm_min+60.*tp->tm_hour));
  109.         break;
  110.  
  111.     case 25:                        /* date */
  112.         time(&tvec);
  113.         goto dt;
  114.  
  115.     case 26:                        /* current line */
  116.         datum = (gsip ? gsip->funlc - 1 : 0);
  117.         break;
  118.  
  119.     case 27:                        /* vector of line numbers of fn activations # */
  120.         i = 0;
  121.         gp = gsip;
  122.         while(gp){
  123.             if(gp->np) i++;
  124.             gp = gp->sip;
  125.         }
  126.         p = newdat(DA, 1, i);
  127.         gp = gsip;
  128.         i = 0;
  129.         while(gp){
  130.             if(gp->np); p->datap[i++] = gp->funlc - 1;
  131.             gp = gp->sip;
  132.         }
  133.         *sp++ = p;
  134.         return;
  135.  
  136.     /*
  137.      * non standard I functions
  138.      */
  139.  
  140.     case 28:                        /* starting date */
  141.         tvec = startTime;
  142.  
  143.     dt:
  144.         tp = localtime(&tvec);
  145.         datum = tp->tm_year+100.*(tp->tm_mday+100.*(tp->tm_mon+1));
  146.         break;
  147.  
  148.     case 29:                        /* iorg */
  149.         datum = thread.iorg;
  150.         break;
  151.  
  152.     case 30:                        /* width */
  153.         datum = thread.width;
  154.         break;
  155.  
  156.     case 31:                        /* digits */
  157.         datum = thread.digits;
  158.         break;
  159.  
  160.     case 32:                        /* ws bytes in use */
  161.         datum = afnused;
  162.         break;
  163.  
  164.     case 36:                        /* 2nd element of ib27 */
  165.         datum = ((gsip && gsip->sip) ? gsip->sip->funlc - 1 : 0);
  166.         break;
  167.  
  168.     case 40:                        /* Total accumulated child's time */
  169.         times(&t);
  170.         datum = t.child_user_time+t.child_system_time;
  171.         break;
  172.  
  173.     case 41:                        /* Total accumulated user time -- including all kids */
  174.         times(&t);
  175.         datum = t.proc_user_time+t.child_user_time;
  176.         break;
  177.  
  178.     case 42:                        /* Total system time -- including all kids */
  179.         times(&t);
  180.         datum = t.proc_system_time+t.child_system_time;
  181.         break;
  182.  
  183.     case 43:                        /* User time -- parent only */
  184.         times(&t);
  185.         datum = t.proc_user_time;
  186.         break;
  187.  
  188.     case 44:                        /* System time -- parent only */
  189.         times(&t);
  190.         datum = t.proc_system_time;
  191.         break;
  192.  
  193.     case 96:
  194.         dstack();
  195.  
  196.  
  197.     case 97:
  198.         datum = (sp - stack) / 2;
  199.         break;
  200.  
  201.     case 98:                        /* turn off alloc/free trace */
  202.         datum = aftrace;
  203.         aftrace = 0;
  204.         break;
  205.  
  206.     case 99:                        /* turn on alloc/free trace */
  207.         datum = aftrace;
  208.         aftrace = 1;
  209.         break;
  210.     }
  211.     p = newdat(DA, 0, 1);
  212.     p->datap[0] = datum;
  213.     *sp++ = p;
  214. }
  215.