Return to agh3 CVS log

Up to [Research Unix] / researchv10no / cmd / mk

Annotation of researchv10no/cmd/mk/agh3, revision 1.1

1.1     ! root        1: mkdir fio libc
        !             2: echo fio/fioprint.c 1>&2
        !             3: sed 's/^-//' >fio/fioprint.c <<'!'
        !             4: -#define       FIO_IMP
        !             5: -#include      <varargs.h>
        !             6: -#include      <fio.h>
        !             7: 
        !             8: -/* VARARGS 2 */
        !             9: -Fprint(f, fmt, va_alist)
        !            10: int f;
        !            11: char *fmt;
        !            12: va_dcl
        !            13: -{
        !            14: -      char buf[FIOBSIZE], *out;
        !            15: -      register long n;
        !            16: -      va_list ap;
        !            17: -      extern char *doprint();
        !            18: 
        !            19: -      va_start(ap);
        !            20: -      out = doprint(buf, fmt, &ap);
        !            21: -      va_end(ap);
        !            22: -      n = out-buf;
        !            23: -      if(Fwrite(f, buf, n) != n)
        !            24: -              return(-1);
        !            25: -      else
        !            26: -              return((int)n);
        !            27: -}
        !            28: !
        !            29: echo libc/doprint.c 1>&2
        !            30: sed 's/^-//' >libc/doprint.c <<'!'
        !            31: -#include <varargs.h>
        !            32: 
        !            33: -#define       SIZE    1024
        !            34: -#define       FUNSIGN 4
        !            35: -#define       FSHORT  2
        !            36: -#define       FLONG   1
        !            37: -#define       PTR     sizeof (char *)
        !            38: -#define       SHORT   sizeof (int)
        !            39: -#define       INT     sizeof (int)
        !            40: -#define       LONG    sizeof (long)
        !            41: -#define       FLOAT   sizeof (double)
        !            42: -#define       FDIGIT  30
        !            43: -#define       FDEFLT  8
        !            44: -#define       IDIGIT  40
        !            45: -#define       MAXCONV 30
        !            46: 
        !            47: static char    *out, *eout;
        !            48: static         convcount  = { 13 };
        !            49: 
        !            50: static noconv();
        !            51: static cconv(), dconv(), hconv(), lconv();
        !            52: static oconv(), sconv(), uconv(), xconv();
        !            53: 
        !            54: static econv(), fconv(), gconv(), percent();
        !            55: int    printcol;
        !            56: static
        !            57: int    (*fmtconv[MAXCONV])() =
        !            58: -{
        !            59: -      noconv,
        !            60: -      cconv, dconv, hconv, lconv,
        !            61: -      oconv, sconv, uconv, xconv,
        !            62: -      econv, fconv, gconv, percent,
        !            63: -};
        !            64: static
        !            65: char   fmtindex[128] =
        !            66: -{
        !            67: -      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        !            68: -      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        !            69: -      0, 0, 0, 0, 0,12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        !            70: -      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        !            71: -      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        !            72: -      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        !            73: -      0, 0, 0, 1, 2, 9,10,11, 3, 0, 0, 0, 4, 0, 0, 5,
        !            74: -      0, 0, 0, 6, 0, 7, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0,
        !            75: -};
        !            76: 
        !            77: fmtinstall(c, f)
        !            78: char c;
        !            79: int (*f)();
        !            80: -{
        !            81: 
        !            82: -      c &= 0177;
        !            83: -      if(fmtindex[c] == 0) {
        !            84: -              if(convcount >= MAXCONV)
        !            85: -                      return 1;
        !            86: -              fmtindex[c] = convcount++;
        !            87: -      }
        !            88: -      fmtconv[fmtindex[c]] = f;
        !            89: -      return 0;
        !            90: -}
        !            91: 
        !            92: char*
        !            93: donprint(s, es, fmt, argpp)
        !            94: char *s, *es;
        !            95: register char *fmt;
        !            96: va_list *argpp;
        !            97: -{
        !            98: -      register int f1, f2, f3, sf1, c;
        !            99: -      char *sout, *seout;
        !           100: 
        !           101: -      sout = out;
        !           102: -      seout = eout;
        !           103: -      out = s;
        !           104: -      eout = es-1;
        !           105: loop:
        !           106: -      c = *fmt++;
        !           107: -      if(c != '%') {
        !           108: -              if(c == 0) {
        !           109: -                      *out = 0;
        !           110: -                      s = out;
        !           111: -                      out = sout;
        !           112: -                      eout = seout;
        !           113: -                      return s;
        !           114: -              }
        !           115: -              if(out < eout)
        !           116: -                      *out++ = c;
        !           117: -              printcol++;
        !           118: -              if(c == '\n')
        !           119: -                      printcol = 0; else
        !           120: -              if(c == '\t')
        !           121: -                      printcol = (printcol+7) & ~7;
        !           122: -              goto loop;
        !           123: -      }
        !           124: -      f1 = 0;
        !           125: -      f2 = -1;
        !           126: -      f3 = 0;
        !           127: -      c = *fmt++;
        !           128: -      sf1 = 0;
        !           129: -      if(c == '-') {
        !           130: -              sf1 = 1;
        !           131: -              c = *fmt++;
        !           132: -      }
        !           133: -      while(c >= '0' && c <= '9') {
        !           134: -              f1 = f1*10 + c-'0';
        !           135: -              c = *fmt++;
        !           136: -      }
        !           137: -      if(sf1)
        !           138: -              f1 = -f1;
        !           139: -      if(c != '.')
        !           140: -              goto l1;
        !           141: -      c = *fmt++;
        !           142: -      while(c >= '0' && c <= '9') {
        !           143: -              if(f2 < 0)
        !           144: -                      f2 = 0;
        !           145: -              f2 = f2*10 + c-'0';
        !           146: -              c = *fmt++;
        !           147: -      }
        !           148: l1:
        !           149: -      if(c == 0)
        !           150: -              fmt--;
        !           151: -      /* NB: first arg is now a (va_list *) */
        !           152: -      c = (*fmtconv[fmtindex[c&0177]])(argpp, f1, f2, f3);
        !           153: -      if(c < 0) {
        !           154: -              f3 |= -c;
        !           155: -              c = *fmt++;
        !           156: -              goto l1;
        !           157: -      }
        !           158: -#ifdef notdef
        !           159: -      argp += c;      /* increment is now done in called routine by va_arg() */
        !           160: -#endif
        !           161: -      goto loop;
        !           162: -}
        !           163: 
        !           164: numbconv(o, f1, f2, f3, b)
        !           165: va_list *o;
        !           166: -{
        !           167: -      char s[IDIGIT];
        !           168: -      register long v;
        !           169: -      register int i, f, n, r;
        !           170: 
        !           171: -      switch(f3 & (FLONG|FSHORT|FUNSIGN)) {
        !           172: -      case FLONG:
        !           173: -              v = va_arg(*o, long);
        !           174: -              r = LONG;
        !           175: -              break;
        !           176: 
        !           177: -      case FUNSIGN|FLONG:
        !           178: -              v = va_arg(*o, unsigned long);
        !           179: -              r = LONG;
        !           180: -              break;
        !           181: 
        !           182: -      /* NB: a (unsigned) short argument is promoted to an (unsigned) int arg. */
        !           183: -      case FSHORT:
        !           184: -              v = (short)va_arg(*o, int);
        !           185: -              r = SHORT;
        !           186: -              break;
        !           187: 
        !           188: -      case FUNSIGN|FSHORT:
        !           189: -              v = (unsigned short)va_arg(*o, unsigned);
        !           190: -              r = SHORT;
        !           191: -              break;
        !           192: 
        !           193: -      default:
        !           194: -              v = va_arg(*o, int);
        !           195: -              r = INT;
        !           196: -              break;
        !           197: 
        !           198: -      case FUNSIGN:
        !           199: -              v = va_arg(*o, unsigned);
        !           200: -              r = INT;
        !           201: -              break;
        !           202: -      }
        !           203: -      f = 0;
        !           204: -      if(!(f3 & FUNSIGN) && v < 0) {
        !           205: -              v = -v;
        !           206: -              f = 1;
        !           207: -      }
        !           208: -      s[IDIGIT-1] = 0;
        !           209: -      for(i = IDIGIT-2; i >= 1; i--) {
        !           210: -              n = (unsigned long)v % b;
        !           211: -              n += '0';
        !           212: -              if(n > '9')
        !           213: -                      n += 'a' - ('9'+1);
        !           214: -              s[i] = n;
        !           215: -              v = (unsigned long)v / b;
        !           216: -              if(f2 >= 0 && i >= IDIGIT-f2)
        !           217: -                      continue;
        !           218: -              if(v <= 0)
        !           219: -                      break;
        !           220: -      }
        !           221: -      if(f)
        !           222: -              s[--i] = '-';
        !           223: -      strconv(s+i, f1, -1);
        !           224: -      return r;
        !           225: -}
        !           226: 
        !           227: char*
        !           228: doprint(s, fmt, argp)
        !           229: char *s, *fmt;
        !           230: va_list *argp;
        !           231: -{
        !           232: 
        !           233: -      return donprint(s, s+SIZE, fmt, argp);
        !           234: -}
        !           235: 
        !           236: -/*
        !           237: -      if you change this, change chconv
        !           238: -*/
        !           239: 
        !           240: strconv(o, f1, f2)
        !           241: char *o;
        !           242: -{
        !           243: -      register int n, c;
        !           244: -      register char *s;
        !           245: 
        !           246: -      n = 0;
        !           247: -      for(s = o; *s++;)
        !           248: -              n++;
        !           249: -      if(f1 >= 0)
        !           250: -              while(n < f1) {
        !           251: -                      if(out < eout)
        !           252: -                              *out++ = ' ';
        !           253: -                      printcol++;
        !           254: -                      n++;
        !           255: -              }
        !           256: -      for(s=o; c = *s++;)
        !           257: -              if(f2 != 0) {
        !           258: -                      if(out < eout)
        !           259: -                              *out++ = c;
        !           260: -                      printcol++;
        !           261: -                      if(c == '\n')
        !           262: -                              printcol = 0; else
        !           263: -                      if(c == '\t')
        !           264: -                              printcol = (printcol+7) & ~7;
        !           265: -                      f2--;
        !           266: -              }
        !           267: -      if(f1 < 0) {
        !           268: -              f1 = -f1;
        !           269: -              while(n < f1) {
        !           270: -                      if(out < eout)
        !           271: -                              *out++ = ' ';
        !           272: -                      printcol++;
        !           273: -                      n++;
        !           274: -              }
        !           275: -      }
        !           276: -}
        !           277: 
        !           278: chconv(o, f1)
        !           279: char o;
        !           280: -{
        !           281: -      register int n;
        !           282: 
        !           283: -      n = 1;
        !           284: -      if(f1 >= 0)
        !           285: -              while(n < f1) {
        !           286: -                      if(out < eout)
        !           287: -                              *out++ = ' ';
        !           288: -                      printcol++;
        !           289: -                      n++;
        !           290: -              }
        !           291: -      if(out < eout)
        !           292: -              *out++ = o;
        !           293: -      printcol++;
        !           294: -      if(o == '\n')
        !           295: -              printcol = 0; else
        !           296: -      if(o == '\t')
        !           297: -              printcol = (printcol+7) & ~7;
        !           298: -      if(f1 < 0) {
        !           299: -              f1 = -f1;
        !           300: -              while(n < f1) {
        !           301: -                      if(out < eout)
        !           302: -                              *out++ = ' ';
        !           303: -                      printcol++;
        !           304: -                      n++;
        !           305: -              }
        !           306: -      }
        !           307: -}
        !           308: 
        !           309: -/* ARGSUSED */
        !           310: static
        !           311: noconv(o, f1, f2, f3)
        !           312: char *o;
        !           313: -{
        !           314: 
        !           315: -      strconv("***", 0, -1);
        !           316: -      return 0;
        !           317: -}
        !           318: 
        !           319: -/* ARGSUSED */
        !           320: static
        !           321: cconv(o, f1, f2, f3)
        !           322: va_list *o;
        !           323: -{
        !           324: -      chconv((char)va_arg(*o, int), f1);
        !           325: -      return INT;
        !           326: -}
        !           327: 
        !           328: static
        !           329: dconv(o, f1, f2, f3)
        !           330: va_list *o;
        !           331: -{
        !           332: -      int r;
        !           333: 
        !           334: -      r = numbconv(o, f1, f2, f3, 10);
        !           335: -      return r;
        !           336: -}
        !           337: 
        !           338: -/* ARGSUSED */
        !           339: static
        !           340: hconv(o, f1, f2, f3)
        !           341: -{
        !           342: -      return -FSHORT;
        !           343: -}
        !           344: 
        !           345: -/* ARGSUSED */
        !           346: static
        !           347: lconv(o, f1, f2, f3)
        !           348: -{
        !           349: 
        !           350: -      return -FLONG;
        !           351: -}
        !           352: 
        !           353: static
        !           354: oconv(o, f1, f2, f3)
        !           355: va_list *o;
        !           356: -{
        !           357: -      int r;
        !           358: 
        !           359: -      r = numbconv(o, f1, f2, f3, 8);
        !           360: -      return r;
        !           361: -}
        !           362: 
        !           363: -/* ARGSUSED */
        !           364: static
        !           365: sconv(o, f1, f2, f3)
        !           366: va_list *o;
        !           367: -{
        !           368: 
        !           369: -      strconv(va_arg(*o, char *), f1, f2);
        !           370: -      return PTR;
        !           371: -}
        !           372: 
        !           373: -/* ARGSUSED */
        !           374: static
        !           375: uconv(o, f1, f2, f3)
        !           376: -{
        !           377: -      return -FUNSIGN;
        !           378: -}
        !           379: 
        !           380: static
        !           381: xconv(o, f1, f2, f3)
        !           382: va_list *o;
        !           383: -{
        !           384: -      int r;
        !           385: 
        !           386: -      r = numbconv(o, f1, f2, f3, 16);
        !           387: -      return r;
        !           388: -}
        !           389: 
        !           390: double pow10(), frexp();
        !           391: -/* ARGSUSED */
        !           392: fltconv(f, f1, f2, f3, c)
        !           393: register double f;
        !           394: -{
        !           395: -      char s1[FDIGIT+10], s2[FDIGIT+10];
        !           396: -      register double g;
        !           397: -      register int d, i, n, s;
        !           398: -      double h;
        !           399: -      int e;
        !           400: -      int c1, c2, c3;
        !           401: 
        !           402: -      s = 0;
        !           403: -      if(f < 0) {
        !           404: -              f = -f;
        !           405: -              s++;
        !           406: -      }
        !           407: 
        !           408: loop:
        !           409: -      e = 0;
        !           410: -      g = 0;
        !           411: -      if(f != 0) {
        !           412: -              g = frexp(f, &e);
        !           413: -              e = e * .30103;
        !           414: -              d = e/2;
        !           415: -              h = f * pow10(-d);              /* 10**-e in 2 parts */
        !           416: -              g = h * pow10(d-e);
        !           417: -              while(g < 1) {
        !           418: -                      e--;
        !           419: -                      g = h * pow10(d-e);
        !           420: -              }
        !           421: -              while(g >= 10) {
        !           422: -                      e++;
        !           423: -                      g = h * pow10(d-e);
        !           424: -              }
        !           425: -      }
        !           426: -      if(f2 < 0)
        !           427: -              f2 = FDEFLT;
        !           428: -      if(c == 'g' && f2 > 0)
        !           429: -              f2--;
        !           430: -      if(f2 > FDIGIT)
        !           431: -              f2 = FDIGIT;
        !           432: -      /*
        !           433: -       * n is number of digits to convert
        !           434: -       * 1 before, f2 after, 1 extra for rounding
        !           435: -       */
        !           436: -      n = f2 + 2;
        !           437: -      if(c == 'f') {
        !           438: -              /*
        !           439: -               * e+1 before, f2 after, 1 extra
        !           440: -               */
        !           441: -              n += e;
        !           442: -              if(n <= 0) {
        !           443: -                      n = 1;
        !           444: -                      g = 0;
        !           445: -              }
        !           446: -      }
        !           447: -      if(n >= FDIGIT+2) {
        !           448: -              if(c == 'e')
        !           449: -                      f2 = -1;
        !           450: -              c = 'e';
        !           451: -              goto loop;
        !           452: -      }
        !           453: -      /*
        !           454: -       * convert n digits
        !           455: -       */
        !           456: -      for(i=0; i<n; i++) {
        !           457: -              d = g;
        !           458: -              if(d > g)
        !           459: -                      d--;
        !           460: -              g -= d;
        !           461: -              s1[i+1] = d + '0';
        !           462: -              g *= 10;
        !           463: -      }
        !           464: -      /*
        !           465: -       * round by adding .5 into extra digit
        !           466: -       */
        !           467: -      d = 5;
        !           468: -      for(i=n-1; i>=0; i--) {
        !           469: -              s1[i+1] += d;
        !           470: -              d = 0;
        !           471: -              if(s1[i+1] > '9') {
        !           472: -                      s1[i+1] -= 10;
        !           473: -                      d++;
        !           474: -              }
        !           475: -      }
        !           476: -      i = 1;
        !           477: -      if(d) {
        !           478: -              s1[0] = '1';
        !           479: -              e++;
        !           480: -              i = 0;
        !           481: -      } 
        !           482: -      /*
        !           483: -       * copy into final place
        !           484: -       * c1 digits of leading '0'
        !           485: -       * c2 digits from conversion
        !           486: -       * c3 digits after '.'
        !           487: -       */
        !           488: -      d = 0;
        !           489: -      if(s)
        !           490: -              s2[d++] = '-';
        !           491: -      c1 = 0;
        !           492: -      c2 = f2 + 1;
        !           493: -      c3 = f2;
        !           494: -      if(c == 'g')
        !           495: -      if(e >= -5 && e <= f2) {
        !           496: -              c1 = -e - 1;
        !           497: -              c3 = c1;
        !           498: -              if(c1 < 0)
        !           499: -                      c1 = 0;
        !           500: -              c3 = f2 - e;
        !           501: -              c = 'h';
        !           502: -      }
        !           503: -      if(c == 'f') {
        !           504: -              c1 = -e;
        !           505: -              if(c1 < 0)
        !           506: -                      c1 = 0;
        !           507: -              if(c1 > f2)
        !           508: -                      c1 = c2;
        !           509: -              c2 += e;
        !           510: -              if(c2 < 0)
        !           511: -                      c2 = 0;
        !           512: -      }
        !           513: -      while(c1 > 0) {
        !           514: -              if(c1+c2 == c3)
        !           515: -                      s2[d++] = '.';
        !           516: -              s2[d++] = '0';
        !           517: -              c1--;
        !           518: -      }
        !           519: -      while(c2 > 0) {
        !           520: -              if(c1+c2 == c3)
        !           521: -                      s2[d++] = '.';
        !           522: -              s2[d++] = s1[i++];
        !           523: -              c2--;
        !           524: -      }
        !           525: -      /*
        !           526: -       * strip trailing '0' on g conv
        !           527: -       */
        !           528: -      if(c == 'g' || c == 'h') {
        !           529: -              for(n=d-1; n>=0; n--)
        !           530: -                      if(s2[n] != '0')
        !           531: -                              break;
        !           532: -              for(i=n; i>=0; i--)
        !           533: -                      if(s2[i] == '.') {
        !           534: -                              d = n;
        !           535: -                              if(i != n)
        !           536: -                                      d++;
        !           537: -                              break;
        !           538: -                      }
        !           539: -      }
        !           540: -      if(c == 'e' || c == 'g') {
        !           541: -              s2[d++] = 'e';
        !           542: -              s2[d++] = '+';
        !           543: -              c1 = e;
        !           544: -              if(c1 < 0) {
        !           545: -                      s2[d-1] = '-';
        !           546: -                      c1 = -c1;
        !           547: -              }
        !           548: -              if(c1 >= 100) {
        !           549: -                      s2[d++] = c1/100 + '0';
        !           550: -                      c1 %= 100;
        !           551: -              }
        !           552: -              s2[d++] = c1/10 + '0';
        !           553: -              s2[d++] = c1%10 + '0';
        !           554: -      }
        !           555: -      s2[d] = 0;
        !           556: -      strconv(s2, f1, -1);
        !           557: -      return FLOAT;
        !           558: -}
        !           559: 
        !           560: static
        !           561: econv(o, f1, f2, f3)
        !           562: va_list *o;
        !           563: -{
        !           564: 
        !           565: -      return fltconv(va_arg(*o, double), f1, f2, f3, 'e');
        !           566: -}
        !           567: 
        !           568: static
        !           569: fconv(o, f1, f2, f3)
        !           570: va_list *o;
        !           571: -{
        !           572: 
        !           573: -      return fltconv(va_arg(*o, double), f1, f2, f3, 'f');
        !           574: -}
        !           575: 
        !           576: static
        !           577: gconv(o, f1, f2, f3)
        !           578: va_list *o;
        !           579: -{
        !           580: 
        !           581: -      return fltconv(va_arg(*o, double), f1, f2, f3, 'g');
        !           582: -}
        !           583: 
        !           584: static
        !           585: percent()
        !           586: -{
        !           587: 
        !           588: -      if(out < eout)
        !           589: -              *out++ = '%';
        !           590: -      return 0;
        !           591: -}
        !           592: !
        !           593: echo libc/print.c 1>&2
        !           594: sed 's/^-//' >libc/print.c <<'!'
        !           595: -#include <varargs.h>
        !           596: 
        !           597: -#define       SIZE    1024
        !           598: extern int     printcol;
        !           599: 
        !           600: char   *doprint();
        !           601: 
        !           602: -/* VARARGS 1 */
        !           603: print(fmt, va_alist)
        !           604: char *fmt;
        !           605: va_dcl
        !           606: -{
        !           607: -      char buf[SIZE], *out;
        !           608: -      va_list ap;
        !           609: 
        !           610: -      va_start(ap);
        !           611: -      out = doprint(buf, fmt, &ap);
        !           612: -      va_end(ap);
        !           613: -      return write(1, buf, (int)(out-buf));
        !           614: -}
        !           615: 
        !           616: -/* VARARGS 2 */
        !           617: fprint(fd, fmt, va_alist)
        !           618: char *fmt;
        !           619: va_dcl
        !           620: -{
        !           621: -      char buf[SIZE], *out;
        !           622: -      va_list ap;
        !           623: 
        !           624: -      va_start(ap);
        !           625: -      out = doprint(buf, fmt, &ap);
        !           626: -      va_end(ap);
        !           627: -      return write(fd, buf, (int)(out-buf));
        !           628: -}
        !           629: 
        !           630: -/* VARARGS 2 */
        !           631: sprint(buf, fmt, va_alist)
        !           632: char *buf;
        !           633: char *fmt;
        !           634: va_dcl
        !           635: -{
        !           636: -      char *out;
        !           637: -      int scol;
        !           638: -      va_list ap;
        !           639: 
        !           640: -      scol = printcol;
        !           641: -      va_start(ap);
        !           642: -      out = doprint(buf, fmt, &ap);
        !           643: -      va_end(ap);
        !           644: -      printcol = scol;
        !           645: -      return out-buf;
        !           646: -}
        !           647: !
        !           648: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.