home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / unixen.tar / unixen / PDP-11 / Distributions / ucb / spencer_2bsd.tar.gz / 2bsd.tar / src / px / pwrite.c < prev    next >
C/C++ Source or Header  |  1980-02-17  |  4KB  |  245 lines
  1. /* (c) 1979 Regents of the University of California */
  2. #
  3. #include "0x.h"
  4. #include "opcode.h"
  5.  
  6. pwrite(opc, subopc, av)
  7. {
  8.     register char *ap, *cp;
  9.     register i;
  10.     int w, w1, sign, decpt;
  11.     char *acp;
  12.     long along;
  13.     double adouble;
  14.     int k2,k3;
  15.  
  16.     ap = &av;
  17.     if (opc == O_WRITLN || opc == O_PAGE)
  18.         opc = O_WRITC;
  19.     switch(opc) {
  20.         case O_WRIT2:
  21.             along = ap->pint;
  22.             ap =+ 2;
  23.             w = 10;
  24.             break;
  25.         case O_WRIT4:
  26.             along = ap->plong;
  27.             ap =+ 4;
  28.             w = 10;
  29.             break;
  30.         case O_WRITC:
  31.             acp = ap;
  32.             ap =+ 2;
  33.             w = 1;
  34.             break;
  35.         case O_WRITB:
  36.             i = ap->pint;
  37.             ap =+ 2;
  38.             w = 10;
  39.             break;
  40.         case O_WRITG:
  41.             w1 = ap->pint;
  42.             ap =+ 2;
  43.             acp = ap;
  44.             ap =+ (w1 + 1) & ~1;
  45.             w = 0;
  46.             break;
  47.         case O_WRIT8:
  48.         case O_WRIT82:
  49.             adouble = ap->pdouble;
  50.             ap =+ 8;
  51.             w = 22;
  52.             break;
  53.         case O_WRHEX2:
  54.         case O_WROCT2:
  55.             (&along)->pint = 0;
  56.             (&along)->p2int = ap->pint;
  57.             ap =+ 2;
  58.             w = opc == O_WROCT2 ? 11 : 8;
  59.             break;
  60.         case O_WRHEX2+1:    /* ugh, cc string table too small */
  61.         case O_WROCT2+1:    /* ugh, cc string table too small */
  62.             along = ap->plong;
  63.             ap =+ 4;
  64.             w = opc == O_WROCT2+1 ? 11 : 8;
  65.             break;
  66.     }
  67. again:
  68.     switch(subopc & 07) {
  69.         case 0:
  70.             break;
  71.         case 2:
  72.             w = ap->pint;
  73.             ap =+ 2;
  74.             break;
  75.         case 4:
  76.             w = ap->plong;
  77.             ap =+ 4;
  78.             break;
  79.     }
  80.     if (opc == O_WRIT82 && (i = (subopc >> 3) & 07) != 0) {
  81.         subopc = i;
  82.         w1 = w;
  83.         goto again;
  84.     }
  85.     switch(opc) {
  86.         case O_WROCT2+1:
  87.         case O_WROCT2:
  88.             while (w > 11) {
  89.                 pputch(' ');
  90.                 w--;
  91.             }
  92.             if (w > 0)
  93.                 wro(along, w);
  94.             break;
  95.         case O_WRHEX2:
  96.         case O_WRHEX2+1:
  97.             while (w > 8) {
  98.                 pputch(' ');
  99.                 w--;
  100.             }
  101.             if (w > 0)
  102.                 wrhex(along, w);
  103.             break;
  104.         case O_WRIT2:
  105.         case O_WRIT4:
  106.             pwril(w, along);
  107.             break;
  108.         case O_WRITC:
  109.             while (w > 1) {
  110.                 pputch(' ');
  111.                 w--;
  112.             }
  113.             pputch(*acp);
  114.             break;
  115.         case O_WRITB:
  116.             if (i) {
  117.                 acp = "true";
  118.                 w1 = 4;
  119.             } else {
  120.                 acp = "false";
  121.                 w1 = 5;
  122.             }
  123.         case O_WRITG:
  124.             cp = acp;
  125.             while (w > w1) {
  126.                 pputch(' ');
  127.                 w--;
  128.             }
  129.             while(w1 > 0) {
  130.                 pputch(*cp++);
  131.                 w1--;
  132.             }
  133.             break;
  134.         case O_WRIT8:
  135.             if (adouble == 0.0) {
  136.                 do
  137.                     pputch(' ');
  138.                 while (--w > 0);
  139.                 pputch('0');
  140.                 break;
  141.             }
  142.             if (w <= 9)
  143.                 w = 3;
  144.             else
  145.                 w =- 6;
  146.             do
  147.                 pputch(' ');
  148.             while (--w > 17);
  149.             cp = ecvt(adouble, w+1, &decpt, &sign);
  150.             pputch(sign ? '-' : ' ');
  151.             pputch(*cp++);
  152.             pputch('.');
  153.             do
  154.                 pputch(*cp++);
  155.             while (--w > 0);
  156.             pputch('e');
  157.             if (--decpt >= 0)
  158.                 pputch('+');
  159.             else {
  160.                 pputch('-');
  161.                 decpt = -decpt;
  162.             }
  163.             pputch(decpt / 10 + '0');
  164.             pputch(decpt % 10 + '0');
  165.             break;
  166.         case O_WRIT82:
  167.             if (adouble == 0.0) {
  168.                 do
  169.                     pputch(' ');
  170.                 while(--w1 > 1);
  171.                 pputch('0');
  172.                 break;
  173.             }
  174.             if (w < 0)
  175.                 w = 0;
  176.             cp = fcvt(adouble, w, &decpt, &sign);
  177.             cp[17] = '\0';
  178.             if (decpt > 0) {
  179.                 w1 = w1-w-decpt-2;
  180.                 k2 = decpt;
  181.                 k3 = 0;
  182.             } else {
  183.                 w1 = w1-w-3;
  184.                 k2 = 0;
  185.                 if (w+decpt >= 0)
  186.                     k3 = -decpt;
  187.                 else
  188.                     k3 = w;
  189.                 w =- k3;
  190.             }
  191.             while (w1 > 0) {
  192.                 pputch(' ');
  193.                 w1--;
  194.             }
  195.             pputch(sign ? '-' : ' ');
  196.             if (k2 <= 0)
  197.                 pputch('0');
  198.             else
  199.                 do
  200.                     pputch(*cp ? *cp++ : '0');
  201.                 while (--k2 > 0);
  202.             pputch('.');
  203.             if (k3 <= 0 && w <= 0) {
  204.                 pputch('0');
  205.                 break;
  206.             }
  207.             while(k3 > 0) {
  208.                 pputch('0');
  209.                 k3--;
  210.             }
  211.             while(w > 0) {
  212.                 pputch(*cp ? *cp++ : '0');
  213.                 w--;
  214.             }
  215.             break;
  216.     }
  217.     return(ap);
  218. }
  219.  
  220. wro(l, w)
  221. long l;
  222. {
  223.     register c;
  224.  
  225.     c = (&l)->p2int & 07;
  226.     l =>> 3;
  227.     (&l)->pint =& 017777;
  228.     if (w > 1 || l != 0)
  229.         wro(l, w-1);
  230.     pputch(c | '0');
  231. }
  232.  
  233. wrhex(l, w)
  234. long l;
  235. {
  236.     register c;
  237.  
  238.     c = (&l)->p2int & 017;
  239.     l =>> 4;
  240.     (&l)->pint =& 07777;
  241.     if (w > 1 || l != 0)
  242.         wrhex(l, w-1);
  243.     pputch(c <= 9 ? c | '0' : 'a' + (c - 10));
  244. }
  245.