# 2.11BSD#431 - /usr/src/usr.lib/libI77/rsnmle.c

##### Functions

    get_int           X
    get_pars          X
    get_repet         X
    l_C               X
    l_CHAR            X
    l_L               X
    l_R               X
    l_read            X
    rd_int            X
    rd_name           X
    s_rsne            X
    t_getc            X

##### Variables

    lchar             X
    ltab              X
    ltype             X
    lx                X
    ly                X
    nml_rd            X
    var_name          X

##### Macros

    AP                X
    B                 X
    BUFSIZE           X
    EX                X
    GETC              X
    INTG              X
    IRL               X
    LGC               X
    MAXSUBS           X
    RL                X
    SP                X
    UNGETC            X
    isapos            X
    isblnk            X
    isexp             X
    isint             X
    islgc             X
    isrl              X
    issep             X

       1: /*
       2:  * Copyright (c) 1980 Regents of the University of California.
       3:  * All rights reserved.  The Berkeley software License Agreement
       4:  * specifies the terms and conditions for redistribution.
       5:  *
       6:  *	@(#)rsnmle.c	5.3.1	1/1/94
       7:  */
       8:
       9: /*
      10:  *		name-list read
      11:  */
      12:
      13: #include "fio.h"
      14: #include "lio.h"
      15: #include "nmlio.h"
      16: #include <ctype.h>
      17:
      18: LOCAL char *nml_rd;
      19:
      20: static int ch;
      21: LOCAL nameflag;
      22: LOCAL   char var_name[VL+1];
      23:
      24: #define SP 1
      25: #define B  2
      26: #define AP 4
      27: #define EX 8
      28: #define INTG 16
      29: #define RL 32
      30: #define LGC 64
      31: #define IRL         (INTG | RL | LGC )
      32: #define isblnk(x)   (ltab[x+1]&B)   /* space, tab, newline */
      33: #define issep(x)    (ltab[x+1]&SP)  /* space, tab, newline, comma */
      34: #define isapos(x)   (ltab[x+1]&AP)  /* apost., quote mark */
      35: #define isexp(x)    (ltab[x+1]&EX)  /* d, e, D, E */
      36: #define isint(x)    (ltab[x+1]&INTG)    /* 0-9, plus, minus */
      37: #define isrl(x)     (ltab[x+1]&RL)  /* 0-9, plus,  minus, period */
      38: #define islgc(x)    (ltab[x+1]&LGC) /* 0-9, period, t, f, T, F */
      39:
      40: #define GETC (ch=t_getc())
      41: #define UNGETC() ungetc(ch,cf)
      42:
      43: LOCAL char *lchar;
      44: LOCAL double lx,ly;
      45: LOCAL int ltype;
      46: int t_getc(), ungetc();
      47:
      48: LOCAL char ltab[128+1] =
      49: {           0,      /* offset one for EOF */
      50: /*   0- 15 */ 0,0,0,0,0,0,0,0,0,SP|B,SP|B,0,0,0,0,0, /* TAB,NEWLINE */
      51: /*  16- 31 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
      52: /*  32- 47 */ SP|B,0,AP,0,0,0,0,AP,0,0,0,RL|INTG,SP,RL|INTG,RL|LGC,0, /* space,",',comma,., */
      53: /*  48- 63 */ IRL,IRL,IRL,IRL,IRL,IRL,IRL,IRL,IRL,IRL,0,0,0,0,0,0, /* digits */
      54: /*  64- 79 */ 0,0,0,0,EX,EX,LGC,0,0,0,0,0,0,0,0,0,  /* D,E,F */
      55: /*  80- 95 */ 0,0,0,0,LGC,0,0,0,0,0,0,0,0,0,0,0,    /* T */
      56: /*  96-111 */ 0,0,0,0,EX,EX,LGC,0,0,0,0,0,0,0,0,0,  /* d,e,f */
      57: /* 112-127 */ 0,0,0,0,LGC,0,0,0,0,0,0,0,0,0,0,0     /* t */
      58: };
      59:
      60: s_rsne(a) namelist_arglist *a;
      61: {
      62:     int n;
      63:     struct namelistentry *entry;
      64:     int nelem, vlen, vtype;
      65:     char *nmlist_nm, *addr;
      66:
      67:     nml_rd = "namelist read";
      68:     reading = YES;
      69:     formatted = NAMELIST;
      70:     fmtbuf = "ext namelist io";
      71:     if(n=c_le(a,READ)) return(n);
      72:     getn = t_getc;
      73:     ungetn = ungetc;
      74:     leof = curunit->uend;
      75:     if(curunit->uwrt && ! nowreading(curunit)) err(errflag, errno, nml_rd)
      76:
      77:     /* look for " &namelistname " */
      78:     nmlist_nm = a->namelist->namelistname;
      79:     while(isblnk(GETC)) ;
      80:     /* check for "&end" (like IBM) or "$end" (like DEC) */
      81:     if(ch != '&' && ch != '$') goto rderr;
      82:     /* save it - write out using the same character as used on input */
      83:     namelistkey_ = ch;
      84:     while( *nmlist_nm )
      85:         if( GETC != *nmlist_nm++ )
      86:             {
      87:                 nml_rd = "incorrect namelist name";
      88:                 goto rderr;
      89:             }
      90:     if(!isblnk(GETC)) goto rderr;
      91:     while(isblnk(GETC)) ;
      92:     if(leof) goto rderr;
      93:     UNGETC();
      94:
      95:     while( GETC != namelistkey_ )
      96:     {
      97:         UNGETC();
      98:         /* get variable name */
      99:         if(!nameflag && rd_name(var_name)) goto rderr;
     100:
     101:         entry = a->namelist->names;
     102:         /* loop through namelist entries looking for this variable name */
     103:         while( entry->varname[0] != 0 )
     104:         {
     105:         if( strcmp(entry->varname, var_name) == 0 ) goto got_name;
     106:         entry++;
     107:         }
     108:         nml_rd = "incorrect variable name";
     109:         goto rderr;
     110: got_name:
     111:         if( n = get_pars( entry, &addr, &nelem, &vlen, &vtype ))
     112:                             goto rderr_n;
     113:         while(isblnk(GETC)) ;
     114:         if(ch != '=') goto rderr;
     115:
     116:         nameflag = NO;
     117:         if(n = l_read( nelem, addr, vlen, vtype )) goto rderr_n;
     118:         while(isblnk(GETC));
     119:         if(ch == ',') while(isblnk(GETC));
     120:         UNGETC();
     121:         if(leof) goto rderr;
     122:     }
     123:     /* check for 'end' after '&' or '$'*/
     124:     if(GETC!='e' || GETC!='n' || GETC!='d' )
     125:         goto rderr;
     126:     /* flush to next input record */
     127: flush:
     128:     while(GETC != '\n' && ch != EOF);
     129:     return(ch == EOF ? EOF : OK);
     130:
     131: rderr:
     132:     if(leof)
     133:         n = EOF;
     134:     else
     135:         n = F_ERNMLIST;
     136: rderr_n:
     137:     if(n == EOF ) err(endflag,EOF,nml_rd);
     138:     /* flush after error in case restart I/O */
     139:     if(ch != '\n')  while(GETC != '\n' && ch != EOF) ;
     140:     err(errflag,n,nml_rd)
     141: }
     142:
     143: #define MAXSUBS 7
     144:
     145: LOCAL
     146: get_pars( entry, addr, nelem, vlen, vtype )
     147: struct namelistentry *entry;
     148: char    **addr;     /* beginning address to read into */
     149: int *nelem,     /* number of elements to read */
     150:     *vlen,      /* length of elements */
     151:     *vtype;     /* type of elements */
     152: {
     153:     int offset, i, n,
     154:         *dimptr,    /* points to dimensioning info */
     155:         ndim,       /* number of dimensions */
     156:         baseoffset, /* offset of corner element */
     157:         *span,      /* subscript span for each dimension */
     158:         subs[MAXSUBS],  /* actual subscripts */
     159:         subcnt = -1;    /* number of actual subscripts */
     160:
     161:
     162:     /* get element size and base address */
     163:     *vlen = entry->typelen;
     164:     *addr = entry->varaddr;
     165:
     166:     /* get type */
     167:     switch ( *vtype = entry->type ) {
     168:         case TYSHORT:
     169:         case TYLONG:
     170:         case TYREAL:
     171:         case TYDREAL:
     172:         case TYCOMPLEX:
     173:         case TYDCOMPLEX:
     174:         case TYLOGICAL:
     175:         case TYCHAR:
     176:             break;
     177:         default:
     178:             fatal(F_ERSYS,"unknown type in rsnmle");
     179:     }
     180:
     181:     /* get number of elements */
     182:     dimptr = entry->dimp;
     183:     if( dimptr==NULL )
     184:     {       /* scalar */
     185:         *nelem = 1;
     186:         return(OK);
     187:     }
     188:
     189:     if( GETC != '(' )
     190:     {       /* entire array */
     191:         *nelem = dimptr[1];
     192:         UNGETC();
     193:         return(OK);
     194:     }
     195:
     196:     /* get element length, number of dimensions, base, span vector */
     197:     ndim = dimptr[0];
     198:     if(ndim<=0 || ndim>MAXSUBS) fatal(F_ERSYS,"illegal dimensions");
     199:     baseoffset = dimptr[2];
     200:     span = dimptr+3;
     201:
     202:     /* get subscripts from input data */
     203:     while(ch!=')') {
     204:         if( ++subcnt > MAXSUBS-1 ) return F_ERNMLIST;
     205:         if(n=get_int(&subs[subcnt])) return n;
     206:         GETC;
     207:         if(leof) return EOF;
     208:         if(ch != ',' && ch != ')') return F_ERNMLIST;
     209:     }
     210:     if( ++subcnt != ndim ) return F_ERNMLIST;
     211:
     212:     offset = subs[ndim-1];
     213:     for( i = ndim-2; i>=0; i-- )
     214:         offset = subs[i] + span[i]*offset;
     215:     offset -= baseoffset;
     216:     *nelem = dimptr[1] - offset;
     217:     if( offset < 0 || offset >= dimptr[1] )
     218:         return F_ERNMLIST;
     219:     *addr = *addr + (*vlen)*offset;
     220:     return OK;
     221: }
     222:
     223: LOCAL
     224: get_int(subval)
     225: int *subval;
     226: {
     227:     int sign=0, value=0, cnt=0;
     228:
     229:     /* look for sign */
     230:     if(GETC == '-') sign = -1;
     231:     else if(ch == '+') ;
     232:     else UNGETC();
     233:     if(ch == EOF) return(EOF);
     234:
     235:     while(isdigit(GETC))
     236:     {
     237:         value = 10*value + ch-'0';
     238:         cnt++;
     239:     }
     240:     UNGETC();
     241: #ifndef pdp11
     242:     if(ch == 'EOF') return EOF;
     243: #endif
     244:     if(cnt == 0 ) return F_ERNMLIST;
     245:     if(sign== -1) value = -value;
     246:     *subval = value;
     247:     return OK;
     248: }
     249:
     250: LOCAL
     251: rd_name(ptr)
     252: char *ptr;
     253: {
     254:     /* read a variable name from the input stream */
     255:     char *init = ptr-1;
     256:
     257:     if(!isalpha(GETC)) {
     258:         UNGETC();
     259:         return(ERROR);
     260:     }
     261:     *ptr++ = ch;
     262:     while(isalnum(GETC))
     263:     {
     264:         if(ptr-init > VL ) return(ERROR);
     265:         *ptr++ = ch;
     266:     }
     267:     *ptr = '\0';
     268:     UNGETC();
     269:     return(OK);
     270: }
     271:
     272: LOCAL
     273: t_getc()
     274: {   int ch;
     275:     static newline = YES;
     276: rd:
     277:     if(curunit->uend) {
     278:         leof = EOF;
     279:         return(EOF);
     280:     }
     281:     if((ch=getc(cf))!=EOF)
     282:     {
     283:         if(ch == '\n') newline = YES;
     284:         else if(newline==YES)
     285:         {   /* skip first character on each line for namelist */
     286:             newline = NO;
     287:             goto rd;
     288:         }
     289:         return(ch);
     290:     }
     291:     if(feof(cf))
     292:     {   curunit->uend = YES;
     293:         leof = EOF;
     294:     }
     295:     else clearerr(cf);
     296:     return(EOF);
     297: }
     298:
     299: LOCAL
     300: l_read(number,ptr,len,type) ftnint number,type; flex *ptr; ftnlen len;
     301: {   int i,n;
     302:     double *yy;
     303:     float *xx;
     304:
     305:     lcount = 0;
     306:     for(i=0;i<number;i++)
     307:     {
     308:         if(leof) return EOF;
     309:         if(lcount==0)
     310:         {
     311:             ltype = NULL;
     312:             if(i!=0)
     313:             {   /* skip to comma */
     314:                 while(isblnk(GETC));
     315:                 if(leof) return(EOF);
     316:                 if(ch == namelistkey_)
     317:                 {   UNGETC();
     318:                     return(OK);
     319:                 }
     320:                 if(ch != ',' ) return(F_ERNMLIST);
     321:             }
     322:             while(isblnk(GETC));
     323:             if(leof) return(EOF);
     324:             UNGETC();
     325:             if(i!=0 && ch == namelistkey_) return(OK);
     326:
     327:             switch((int)type)
     328:             {
     329:             case TYSHORT:
     330:             case TYLONG:
     331:                 if(!isint(ch)) return(OK);
     332:                 ERRNM(l_R(1));
     333:                 break;
     334:             case TYREAL:
     335:             case TYDREAL:
     336:                 if(!isrl(ch)) return(OK);
     337:                 ERRNM(l_R(1));
     338:                 break;
     339:             case TYCOMPLEX:
     340:             case TYDCOMPLEX:
     341:                 if(!isdigit(ch) && ch!='(') return(OK);
     342:                 ERRNM(l_C());
     343:                 break;
     344:             case TYLOGICAL:
     345:                 if(!islgc(ch)) return(OK);
     346:                 ERRNM(l_L());
     347:                 if(nameflag) return(OK);
     348:                 break;
     349:             case TYCHAR:
     350:                 if(!isdigit(ch) && !isapos(ch)) return(OK);
     351:                 ERRNM(l_CHAR());
     352:                 break;
     353:             }
     354:
     355:             if(leof) return(EOF);
     356:             /* peek at next character -
     357: 				should be separator or namelistkey_ */
     358:             GETC; UNGETC();
     359:             if(!issep(ch) && (ch != namelistkey_))
     360:             return( leof?EOF:F_ERNMLIST );
     361:         }
     362:
     363:         if(!ltype) return(F_ERNMLIST);
     364:         switch((int)type)
     365:         {
     366:         case TYSHORT:
     367:             ptr->flshort=lx;
     368:             break;
     369:         case TYLOGICAL:
     370:             if(len == sizeof(short))
     371:                 ptr->flshort = lx;
     372:             else
     373:                 ptr->flint = lx;
     374:             break;
     375:         case TYLONG:
     376:             ptr->flint=lx;
     377:             break;
     378:         case TYREAL:
     379:             ptr->flreal=lx;
     380:             break;
     381:         case TYDREAL:
     382:             ptr->fldouble=lx;
     383:             break;
     384:         case TYCOMPLEX:
     385:             xx=(float *)ptr;
     386:             *xx++ = ly;
     387:             *xx = lx;
     388:             break;
     389:         case TYDCOMPLEX:
     390:             yy=(double *)ptr;
     391:             *yy++ = ly;
     392:             *yy = lx;
     393:             break;
     394:         case TYCHAR:
     395:             b_char(lchar,(char *)ptr,len);
     396:             break;
     397:         }
     398:         if(lcount>0) lcount--;
     399:         ptr = (flex *)((char *)ptr + len);
     400:     }
     401:     if(lcount>0) return F_ERNMLIST;
     402:     return(OK);
     403: }
     404:
     405: LOCAL
     406: get_repet()
     407: {
     408:     double lc;
     409:     if(isdigit(GETC))
     410:     {   UNGETC();
     411:         rd_int(&lc);
     412:         lcount = (int)lc;
     413:         if(GETC!='*')
     414:             if(leof) return(EOF);
     415:             else return(F_ERREPT);
     416:     }
     417:     else
     418:     {   lcount = 1;
     419:         UNGETC();
     420:     }
     421:     return(OK);
     422: }
     423:
     424: LOCAL
     425: l_R(flg) int flg;
     426: {   double a,b,c,d;
     427:     int da,db,dc,dd;
     428:     int i,sign=0;
     429:     a=b=c=d=0;
     430:     da=db=dc=dd=0;
     431:
     432:     if( flg )       /* real */
     433:     {
     434:         da=rd_int(&a);  /* repeat count ? */
     435:         if(GETC=='*')
     436:         {
     437:             if (a <= 0.) return(F_ERNREP);
     438:             lcount=(int)a;
     439:             db=rd_int(&b);  /* whole part of number */
     440:         }
     441:         else
     442:         {   UNGETC();
     443:             db=da;
     444:             b=a;
     445:             lcount=1;
     446:         }
     447:     }
     448:     else           /* complex */
     449:     {
     450:         db=rd_int(&b);
     451:     }
     452:
     453:     if(GETC=='.' && isdigit(GETC))
     454:     {   UNGETC();
     455:         dc=rd_int(&c);  /* fractional part of number */
     456:     }
     457:     else
     458:     {   UNGETC();
     459:         dc=0;
     460:         c=0.;
     461:     }
     462:     if(isexp(GETC))
     463:         dd=rd_int(&d);  /* exponent */
     464:     else if (ch == '+' || ch == '-')
     465:     {   UNGETC();
     466:         dd=rd_int(&d);
     467:     }
     468:     else
     469:     {   UNGETC();
     470:         dd=0;
     471:     }
     472:     if(db<0 || b<0)
     473:     {   sign=1;
     474:         b = -b;
     475:     }
     476:     for(i=0;i<dc;i++) c/=10.;
     477:     b=b+c;
     478:     if (dd > 0)
     479:     {   for(i=0;i<d;i++) b *= 10.;
     480:         for(i=0;i< -d;i++) b /= 10.;
     481:     }
     482:     lx=sign?-b:b;
     483:     ltype=TYLONG;
     484:     return(OK);
     485: }
     486:
     487: LOCAL
     488: rd_int(x) double *x;
     489: {   int sign=0,i=0;
     490:     double y=0.0;
     491:     if(GETC=='-') sign = -1;
     492:     else if(ch=='+') sign=0;
     493:     else UNGETC();
     494:     while(isdigit(GETC))
     495:     {   i++;
     496:         y=10*y + ch-'0';
     497:     }
     498:     UNGETC();
     499:     if(sign) y = -y;
     500:     *x = y;
     501:     return(y==0.0?sign:i); /* 0:[+]&&y==0, -1:-&&y==0, >0:#digits&&y!=0 */
     502: }
     503:
     504: LOCAL
     505: l_C()
     506: {   int n;
     507:     if(n=get_repet()) return(n);        /* get repeat count */
     508:     if(GETC!='(') err(errflag,F_ERNMLIST,"no (")
     509:     while(isblnk(GETC));
     510:     UNGETC();
     511:     l_R(0);     /* get real part */
     512:     ly = lx;
     513:     while(isblnk(GETC));  /* get comma */
     514:     if(leof) return(EOF);
     515:     if(ch!=',') return(F_ERNMLIST);
     516:     while(isblnk(GETC));
     517:     UNGETC();
     518:     if(leof) return(EOF);
     519:     l_R(0);     /* get imag part */
     520:     while(isblnk(GETC));
     521:     if(ch!=')') err(errflag,F_ERNMLIST,"no )")
     522:     ltype = TYCOMPLEX;
     523:     return(OK);
     524: }
     525:
     526: LOCAL
     527: l_L()
     528: {
     529:     int n, keychar=ch, scanned=NO;
     530:     if(ch=='f' || ch=='F' || ch=='t' || ch=='T')
     531:     {
     532:         scanned=YES;
     533:         if(rd_name(var_name))
     534:             return(leof?EOF:F_ERNMLIST);
     535:         while(isblnk(GETC));
     536:         UNGETC();
     537:         if(ch == '=' || ch == '(')
     538:         {   /* found a name, not a value */
     539:             nameflag = YES;
     540:             return(OK);
     541:         }
     542:     }
     543:     else
     544:     {
     545:         if(n=get_repet()) return(n);        /* get repeat count */
     546:         if(GETC=='.') GETC;
     547:         keychar = ch;
     548:     }
     549:     switch(keychar)
     550:     {
     551:     case 't':
     552:     case 'T':
     553:         lx=1;
     554:         break;
     555:     case 'f':
     556:     case 'F':
     557:         lx=0;
     558:         break;
     559:     default:
     560:         if(ch==EOF) return(EOF);
     561:         else    err(errflag,F_ERNMLIST,"logical not T or F");
     562:     }
     563:     ltype=TYLOGICAL;
     564:     if(scanned==NO)
     565:     {
     566:         while(!issep(GETC) && ch!=EOF) ;
     567:         UNGETC();
     568:     }
     569:     if(ch == EOF ) return(EOF);
     570:     return(OK);
     571: }
     572:
     573: #define BUFSIZE 128
     574: LOCAL
     575: l_CHAR()
     576: {   int size,i,n;
     577:     char quote,*p;
     578:     if(n=get_repet()) return(n);        /* get repeat count */
     579:     if(isapos(GETC)) quote=ch;
     580:     else if(ch == EOF) return EOF;
     581:     else return F_ERNMLIST;
     582:     ltype=TYCHAR;
     583:     if(lchar!=NULL) free(lchar);
     584:     size=BUFSIZE-1;
     585:     p=lchar=(char *)malloc(BUFSIZE);
     586:     if(lchar==NULL) return (F_ERSPACE);
     587:     for(i=0;;)
     588:     {   while( GETC!=quote && ch!='\n' && ch!=EOF && ++i<size )
     589:                 *p++ = ch;
     590:         if(i==size)
     591:         {
     592:         newone:
     593:             size += BUFSIZE;
     594:             lchar=(char *)realloc(lchar, size+1);
     595:             if(lchar==NULL) return( F_ERSPACE );
     596:             p=lchar+i-1;
     597:             *p++ = ch;
     598:         }
     599:         else if(ch==EOF) return(EOF);
     600:         else if(ch=='\n')
     601:         {   if(*(p-1) == '\\') *(p-1) = ch;
     602:         }
     603:         else if(GETC==quote)
     604:         {   if(++i<size) *p++ = ch;
     605:             else goto newone;
     606:         }
     607:         else
     608:         {   UNGETC();
     609:             *p = '\0';
     610:             return(OK);
     611:         }
     612:     }
     613: }

#### Defined functions

get_int defined in line 223; used 1 times

- in line 205

get_pars defined in line 145; used 1 times

- in line 111

get_repet defined in line 405; used 3 times

- in line 507, 545, 578

l_C defined in line 504; used 1 times

- in line 342

l_CHAR defined in line 574; used 1 times

- in line 351

l_L defined in line 526; used 1 times

- in line 346

l_R defined in line 424; used 4 times

- in line 332-337(2), 511, 519

l_read defined in line 299; used 3 times

- in line 117
- in /usr/src/usr.lib/libI77/rsli.c line 16-21(2)

rd_int defined in line 487; used 7 times

- in line 411, 434-439(2), 450-455(2), 463-466(2)

rd_name defined in line 250; used 2 times

- in line 99, 533

s_rsne defined in line 60; never used
t_getc defined in line 272; used 3 times

- in line 40, 46, 72

#### Defined variables

ch defined in line 20; used 63 times

- in line 40-41(2), 81-83(3), 114-119(2), 128-129(2), 139(2), 203-208(3), 231-242(4), 261-265(2), 274, 281-283(2), 289, 316-325(3), 331-350(7), 359(2), 464(2), 492-496(2), 515, 521, 529-530(5), 537(2), 547, 560, 566-569(2), 579-580(2), 588-589(3), 597-604(5)

lchar defined in line 43; used 9 times

- in line 395, 583-586(4), 594-596(4)

ltab defined in line 48; used 7 times

- in line 32-38(7)

ltype defined in line 45; used 6 times

- in line 311, 363, 483, 522, 563, 582

lx defined in line 44; used 12 times

- in line 367-392(8), 482, 512, 553-557(2)

ly defined in line 44; used 3 times

- in line 386-391(2), 512

nml_rd defined in line 18; used 6 times

- in line 67, 75, 87, 108, 137-140(2)

var_name defined in line 22; used 3 times

- in line 99, 105, 533

#### Defined macros

AP defined in line 26; used 3 times

- in line 34, 52(2)

B defined in line 25; used 4 times

- in line 32, 50-52(3)

BUFSIZE defined in line 573; used 3 times

- in line 584-585(2), 593

EX defined in line 27; used 5 times

- in line 35, 54-56(4)

GETC defined in line 40; used 42 times

- in line 79, 85-95(4), 113-128(7), 139, 189, 206, 230-235(2), 257-262(2), 314, 322, 358, 409-413(2), 435, 453(2), 462, 491-494(2), 508-520(5), 535, 546(2), 566, 579, 588, 603

INTG defined in line 28; used 4 times

- in line 31-36(2), 52(2)

IRL defined in line 31; used 10 times

- in line 53(10)

LGC defined in line 30; used 7 times

- in line 31, 38, 52-57(5)

MAXSUBS defined in line 143; used 3 times

- in line 158, 198, 204

RL defined in line 29; used 5 times

- in line 31, 37, 52(3)

SP defined in line 24; used 5 times

- in line 33, 50-52(4)

UNGETC defined in line 41; used 25 times

- in line 93-97(2), 120, 192, 232, 240, 258, 268, 317, 324, 358, 410, 419, 442, 454-458(2), 465-469(2), 493-498(2), 510, 517, 536, 567, 608

isapos defined in line 34; used 2 times

- in line 350, 579

isblnk defined in line 32; used 13 times

- in line 79, 90-91(2), 113-119(3), 314, 322, 509-520(4), 535

isexp defined in line 35; used 1 times

- in line 462

isint defined in line 36; used 1 times

- in line 331

islgc defined in line 38; used 1 times

- in line 345

isrl defined in line 37; used 1 times

- in line 336

issep defined in line 33; used 2 times

- in line 359, 566

Last modified: 1994-01-11 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1856 |