libf2c/libI77/rdfmt.c

   1 #include "config.h"
   2 #include <ctype.h>
   3 #include "f2c.h"
   4 #include "fio.h"
   5
   6 extern int f__cursor;
   7 #undef abs
   8 #undef min
   9 #undef max
  10 #include <stdlib.h>
  11
  12 #include "fmt.h"
  13 #include "fp.h"
  14
  15 static int
  16 rd_Z (Uint * n, int w, ftnlen len)
  17 {
  18   long x[9];
  19   char *s, *s0, *s1, *se, *t;
  20   int ch, i, w1, w2;
  21   static char hex[256];
  22   static int one = 1;
  23   int bad = 0;
  24
  25   if (!hex['0'])
  26     {
  27       s = "0123456789";
  28       while ((ch = *s++))
  29         hex[ch] = ch - '0' + 1;
  30       s = "ABCDEF";
  31       while ((ch = *s++))
  32         hex[ch] = hex[ch + 'a' - 'A'] = ch - 'A' + 11;
  33     }
  34   s = s0 = (char *) x;
  35   s1 = (char *) &x[4];
  36   se = (char *) &x[8];
  37   if (len > 4 * (ftnlen) sizeof (long))
  38     return errno = 117;
  39   while (w)
  40     {
  41       GET (ch);
  42       if (ch == ',' || ch == '\n')
  43         break;
  44       w--;
  45       if (ch > ' ')
  46         {
  47           if (!hex[ch & 0xff])
  48             bad++;
  49           *s++ = ch;
  50           if (s == se)
  51             {
  52               /* discard excess characters */
  53               for (t = s0, s = s1; t < s1;)
  54                 *t++ = *s++;
  55               s = s1;
  56             }
  57         }
  58     }
  59   if (bad)
  60     return errno = 115;
  61   w = (int) len;
  62   w1 = s - s0;
  63   w2 = (w1 + 1) >> 1;
  64   t = (char *) n;
  65   if (*(char *) &one)
  66     {
  67       /* little endian */
  68       t += w - 1;
  69       i = -1;
  70     }
  71   else
  72     i = 1;
  73   for (; w > w2; t += i, --w)
  74     *t = 0;
  75   if (!w)
  76     return 0;
  77   if (w < w2)
  78     s0 = s - (w << 1);
  79   else if (w1 & 1)
  80     {
  81       *t = hex[*s0++ & 0xff] - 1;
  82       if (!--w)
  83         return 0;
  84       t += i;
  85     }
  86   do
  87     {
  88       *t = (hex[*s0 & 0xff] - 1) << 4 | (hex[s0[1] & 0xff] - 1);
  89       t += i;
  90       s0 += 2;
  91     }
  92   while (--w);
  93   return 0;
  94 }
  95
  96 static int
  97 rd_I (Uint * n, int w, ftnlen len, register int base)
  98 {
  99   int ch, sign;
 100   longint x = 0;
 101
 102   if (w <= 0)
 103     goto have_x;
 104   for (;;)
 105     {
 106       GET (ch);
 107       if (ch != ' ')
 108         break;
 109       if (!--w)
 110         goto have_x;
 111     }
 112   sign = 0;
 113   switch (ch)
 114     {
 115     case ',':
 116     case '\n':
 117       w = 0;
 118       goto have_x;
 119     case '-':
 120       sign = 1;
 121     case '+':
 122       break;
 123     default:
 124       if (ch >= '0' && ch <= '9')
 125         {
 126           x = ch - '0';
 127           break;
 128         }
 129       goto have_x;
 130     }
 131   while (--w)
 132     {
 133       GET (ch);
 134       if (ch >= '0' && ch <= '9')
 135         {
 136           x = x * base + ch - '0';
 137           continue;
 138         }
 139       if (ch != ' ')
 140         {
 141           if (ch == '\n' || ch == ',')
 142             w = 0;
 143           break;
 144         }
 145       if (f__cblank)
 146         x *= base;
 147     }
 148   if (sign)
 149     x = -x;
 150 have_x:
 151   if (len == sizeof (integer))
 152     n->il = x;
 153   else if (len == sizeof (char))
 154     n->ic = (char) x;
 155 #ifdef Allow_TYQUAD
 156   else if (len == sizeof (longint))
 157     n->ili = x;
 158 #endif
 159   else
 160     n->is = (short) x;
 161   if (w)
 162     {
 163       while (--w)
 164         GET (ch);
 165       return errno = 115;
 166     }
 167   return 0;
 168 }
 169
 170 static int
 171 rd_L (ftnint * n, int w, ftnlen len)
 172 {
 173   int ch, dot, lv;
 174
 175   if (w <= 0)
 176     goto bad;
 177   for (;;)
 178     {
 179       GET (ch);
 180       --w;
 181       if (ch != ' ')
 182         break;
 183       if (!w)
 184         goto bad;
 185     }
 186   dot = 0;
 187 retry:
 188   switch (ch)
 189     {
 190     case '.':
 191       if (dot++ || !w)
 192         goto bad;
 193       GET (ch);
 194       --w;
 195       goto retry;
 196     case 't':
 197     case 'T':
 198       lv = 1;
 199       break;
 200     case 'f':
 201     case 'F':
 202       lv = 0;
 203       break;
 204     default:
 205     bad:
 206       for (; w > 0; --w)
 207         GET (ch);
 208       /* no break */
 209     case ',':
 210     case '\n':
 211       return errno = 116;
 212     }
 213   /* The switch statement that was here
 214      didn't cut it:  It broke down for targets
 215      where sizeof(char) == sizeof(short). */
 216   if (len == sizeof (char))
 217     *(char *) n = (char) lv;
 218   else if (len == sizeof (short))
 219     *(short *) n = (short) lv;
 220   else
 221     *n = lv;
 222   while (w-- > 0)
 223     {
 224       GET (ch);
 225       if (ch == ',' || ch == '\n')
 226         break;
 227     }
 228   return 0;
 229 }
 230
 231 static int
 232 rd_F (ufloat * p, int w, int d, ftnlen len)
 233 {
 234   char s[FMAX + EXPMAXDIGS + 4];
 235   register int ch;
 236   register char *sp, *spe, *sp1;
 237   double x;
 238   int scale1, se;
 239   long e, exp;
 240
 241   sp1 = sp = s;
 242   spe = sp + FMAX;
 243   exp = -d;
 244   x = 0.;
 245
 246   do
 247     {
 248       GET (ch);
 249       w--;
 250     }
 251   while (ch == ' ' && w);
 252   switch (ch)
 253     {
 254     case '-':
 255       *sp++ = ch;
 256       sp1++;
 257       spe++;
 258     case '+':
 259       if (!w)
 260         goto zero;
 261       --w;
 262       GET (ch);
 263     }
 264   while (ch == ' ')
 265     {
 266     blankdrop:
 267       if (!w--)
 268         goto zero;
 269       GET (ch);
 270     }
 271   while (ch == '0')
 272     {
 273       if (!w--)
 274         goto zero;
 275       GET (ch);
 276     }
 277   if (ch == ' ' && f__cblank)
 278     goto blankdrop;
 279   scale1 = f__scale;
 280   while (isdigit (ch))
 281     {
 282     digloop1:
 283       if (sp < spe)
 284         *sp++ = ch;
 285       else
 286         ++exp;
 287     digloop1e:
 288       if (!w--)
 289         goto done;
 290       GET (ch);
 291     }
 292   if (ch == ' ')
 293     {
 294       if (f__cblank)
 295         {
 296           ch = '0';
 297           goto digloop1;
 298         }
 299       goto digloop1e;
 300     }
 301   if (ch == '.')
 302     {
 303       exp += d;
 304       if (!w--)
 305         goto done;
 306       GET (ch);
 307       if (sp == sp1)
 308         {                       /* no digits yet */
 309           while (ch == '0')
 310             {
 311             skip01:
 312               --exp;
 313             skip0:
 314               if (!w--)
 315                 goto done;
 316               GET (ch);
 317             }
 318           if (ch == ' ')
 319             {
 320               if (f__cblank)
 321                 goto skip01;
 322               goto skip0;
 323             }
 324         }
 325       while (isdigit (ch))
 326         {
 327         digloop2:
 328           if (sp < spe)
 329             {
 330               *sp++ = ch;
 331               --exp;
 332             }
 333         digloop2e:
 334           if (!w--)
 335             goto done;
 336           GET (ch);
 337         }
 338       if (ch == ' ')
 339         {
 340           if (f__cblank)
 341             {
 342               ch = '0';
 343               goto digloop2;
 344             }
 345           goto digloop2e;
 346         }
 347     }
 348   switch (ch)
 349     {
 350     default:
 351       break;
 352     case '-':
 353       se = 1;
 354       goto signonly;
 355     case '+':
 356       se = 0;
 357       goto signonly;
 358     case 'e':
 359     case 'E':
 360     case 'd':
 361     case 'D':
 362       if (!w--)
 363         goto bad;
 364       GET (ch);
 365       while (ch == ' ')
 366         {
 367           if (!w--)
 368             goto bad;
 369           GET (ch);
 370         }
 371       se = 0;
 372       switch (ch)
 373         {
 374         case '-':
 375           se = 1;
 376         case '+':
 377         signonly:
 378           if (!w--)
 379             goto bad;
 380           GET (ch);
 381         }
 382       while (ch == ' ')
 383         {
 384           if (!w--)
 385             goto bad;
 386           GET (ch);
 387         }
 388       if (!isdigit (ch))
 389         goto bad;
 390
 391       e = ch - '0';
 392       for (;;)
 393         {
 394           if (!w--)
 395             {
 396               ch = '\n';
 397               break;
 398             }
 399           GET (ch);
 400           if (!isdigit (ch))
 401             {
 402               if (ch == ' ')
 403                 {
 404                   if (f__cblank)
 405                     ch = '0';
 406                   else
 407                     continue;
 408                 }
 409               else
 410                 break;
 411             }
 412           e = 10 * e + ch - '0';
 413           if (e > EXPMAX && sp > sp1)
 414             goto bad;
 415         }
 416       if (se)
 417         exp -= e;
 418       else
 419         exp += e;
 420       scale1 = 0;
 421     }
 422   switch (ch)
 423     {
 424     case '\n':
 425     case ',':
 426       break;
 427     default:
 428     bad:
 429       return (errno = 115);
 430     }
 431 done:
 432   if (sp > sp1)
 433     {
 434       while (*--sp == '0')
 435         ++exp;
 436       if (exp -= scale1)
 437         sprintf (sp + 1, "e%ld", exp);
 438       else
 439         sp[1] = 0;
 440       x = atof (s);
 441     }
 442 zero:
 443   if (len == sizeof (real))
 444     p->pf = x;
 445   else
 446     p->pd = x;
 447   return (0);
 448 }
 449
 450
 451 static int
 452 rd_A (char *p, ftnlen len)
 453 {
 454   int i, ch;
 455   for (i = 0; i < len; i++)
 456     {
 457       GET (ch);
 458       *p++ = VAL (ch);
 459     }
 460   return (0);
 461 }
 462 static int
 463 rd_AW (char *p, int w, ftnlen len)
 464 {
 465   int i, ch;
 466   if (w >= len)
 467     {
 468       for (i = 0; i < w - len; i++)
 469         GET (ch);
 470       for (i = 0; i < len; i++)
 471         {
 472           GET (ch);
 473           *p++ = VAL (ch);
 474         }
 475       return (0);
 476     }
 477   for (i = 0; i < w; i++)
 478     {
 479       GET (ch);
 480       *p++ = VAL (ch);
 481     }
 482   for (i = 0; i < len - w; i++)
 483     *p++ = ' ';
 484   return (0);
 485 }
 486 static int
 487 rd_H (int n, char *s)
 488 {
 489   int i, ch;
 490   for (i = 0; i < n; i++)
 491     if ((ch = (*f__getn) ()) < 0)
 492       return (ch);
 493     else
 494       *s++ = ch == '\n' ? ' ' : ch;
 495   return (1);
 496 }
 497 static int
 498 rd_POS (char *s)
 499 {
 500   char quote;
 501   int ch;
 502   quote = *s++;
 503   for (; *s; s++)
 504     if (*s == quote && *(s + 1) != quote)
 505       break;
 506     else if ((ch = (*f__getn) ()) < 0)
 507       return (ch);
 508     else
 509       *s = ch == '\n' ? ' ' : ch;
 510   return (1);
 511 }
 512
 513 int
 514 rd_ed (struct syl * p, char *ptr, ftnlen len)
 515 {
 516   int ch;
 517   for (; f__cursor > 0; f__cursor--)
 518     if ((ch = (*f__getn) ()) < 0)
 519       return (ch);
 520   if (f__cursor < 0)
 521     {
 522       if (f__recpos + f__cursor < 0)    /*err(elist->cierr,110,"fmt") */
 523         f__cursor = -f__recpos; /* is this in the standard? */
 524       if (f__external == 0)
 525         {
 526           extern char *f__icptr;
 527           f__icptr += f__cursor;
 528         }
 529       else if (f__curunit && f__curunit->useek)
 530         FSEEK (f__cf, (off_t) f__cursor, SEEK_CUR);
 531       else
 532         err (f__elist->cierr, 106, "fmt");
 533       f__recpos += f__cursor;
 534       f__cursor = 0;
 535     }
 536   switch (p->op)
 537     {
 538     default:
 539       fprintf (stderr, "rd_ed, unexpected code: %d\n", p->op);
 540       sig_die (f__fmtbuf, 1);
 541     case IM:
 542     case I:
 543       ch = rd_I ((Uint *) ptr, p->p1, len, 10);
 544       break;
 545
 546       /* O and OM don't work right for character, double, complex, */
 547       /* or doublecomplex, and they differ from Fortran 90 in */
 548       /* showing a minus sign for negative values. */
 549
 550     case OM:
 551     case O:
 552       ch = rd_I ((Uint *) ptr, p->p1, len, 8);
 553       break;
 554     case L:
 555       ch = rd_L ((ftnint *) ptr, p->p1, len);
 556       break;
 557     case A:
 558       ch = rd_A (ptr, len);
 559       break;
 560     case AW:
 561       ch = rd_AW (ptr, p->p1, len);
 562       break;
 563     case E:
 564     case EE:
 565     case D:
 566     case G:
 567     case GE:
 568     case F:
 569       ch = rd_F ((ufloat *) ptr, p->p1, p->p2.i[0], len);
 570       break;
 571
 572       /* Z and ZM assume 8-bit bytes. */
 573
 574     case ZM:
 575     case Z:
 576       ch = rd_Z ((Uint *) ptr, p->p1, len);
 577       break;
 578     }
 579   if (ch == 0)
 580     return (ch);
 581   else if (ch == EOF)
 582     return (EOF);
 583   if (f__cf)
 584     clearerr (f__cf);
 585   return (errno);
 586 }
 587
 588 int
 589 rd_ned (struct syl * p)
 590 {
 591   switch (p->op)
 592     {
 593     default:
 594       fprintf (stderr, "rd_ned, unexpected code: %d\n", p->op);
 595       sig_die (f__fmtbuf, 1);
 596     case APOS:
 597       return (rd_POS (p->p2.s));
 598     case H:
 599       return (rd_H (p->p1, p->p2.s));
 600     case SLASH:
 601       return ((*f__donewrec) ());
 602     case TR:
 603     case X:
 604       f__cursor += p->p1;
 605       return (1);
 606     case T:
 607       f__cursor = p->p1 - f__recpos - 1;
 608       return (1);
 609     case TL:
 610       f__cursor -= p->p1;
 611       if (f__cursor < -f__recpos)       /* TL1000, 1X */
 612         f__cursor = -f__recpos;
 613       return (1);
 614     }
 615 }