Logo Search packages:      
Sourcecode: pcc version File versions  Download package

lex.c

/*    $Id: lex.c,v 1.12 2008/05/11 15:28:03 ragge Exp $     */
/*
 * Copyright(C) Caldera International Inc. 2001-2002. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * Redistributions of source code and documentation must retain the above
 * copyright notice, this list of conditions and the following disclaimer.
 * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditionsand the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 * All advertising materials mentioning features or use of this software
 * must display the following acknowledgement:
 *    This product includes software developed or owned by Caldera
 *    International, Inc.
 * Neither the name of Caldera International, Inc. nor the names of other
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
 * INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE
 * FOR ANY DIRECT, INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OFLIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
 * POSSIBILITY OF SUCH DAMAGE.
 */
#include "defines.h"
#include "defs.h"

#include "gram.h"

# define BLANK    ' '
# define MYQUOTE (2)
# define SEOF 0

/* card types */

# define STEOF 1
# define STINITIAL 2
# define STCONTINUE 3

/* lex states */

#define NEWSTMT   1
#define FIRSTTOKEN      2
#define OTHERTOKEN      3
#define RETEOS    4


LOCAL int stkey;
LOCAL int stno;
LOCAL long int nxtstno;
LOCAL int parlev;
LOCAL int expcom;
LOCAL int expeql;
LOCAL char *nextch;
LOCAL char *lastch;
LOCAL char *nextcd      = NULL;
LOCAL char *endcd;
LOCAL int prevlin;
LOCAL int thislin;
LOCAL int code;
LOCAL int lexstate      = NEWSTMT;
LOCAL char s[1390];
LOCAL char *send  = s+20*66;
LOCAL int nincl   = 0;

00076 struct inclfile
      {
      struct inclfile *inclnext;
      FILEP inclfp;
      char *inclname;
      int incllno;
      char *incllinp;
      int incllen;
      int inclcode;
      ftnint inclstno;
      } ;

LOCAL struct inclfile *inclp  =  NULL;
00089 struct keylist { char *keyname; int keyval; } ;
00090 struct punctlist { char punchar; int punval; };
00091 struct fmtlist { char fmtchar; int fmtval; };
00092 struct dotlist { char *dotname; int dotval; };
LOCAL struct dotlist  dots[];
LOCAL struct keylist *keystart[26], *keyend[26];
LOCAL struct keylist  keys[];

LOCAL int getcds(void);
LOCAL void crunch(void);
LOCAL void analyz(void);
LOCAL int gettok(void);
LOCAL int getcd(char *b);
LOCAL int getkwd(void);
LOCAL int popinclude(void);

/*
 * called from main() to start parsing.
 * name[0] may be \0 if stdin.
 */
int
inilex(char *name)
{
      nincl = 0;
      inclp = NULL;
      doinclude(name);
      lexstate = NEWSTMT;
      return(NO);
}



/* throw away the rest of the current line */
void
flline()
{
lexstate = RETEOS;
}



char *lexline(n)
ftnint *n;
{
*n = (lastch - nextch) + 1;
return(nextch);
}




void
doinclude(char *name)
{
      FILEP fp;
      struct inclfile *t;

      if(inclp) {
            inclp->incllno = thislin;
            inclp->inclcode = code;
            inclp->inclstno = nxtstno;
            if(nextcd)
                  inclp->incllinp =
                      copyn(inclp->incllen = endcd-nextcd , nextcd);
            else
                  inclp->incllinp = 0;
      }
      nextcd = NULL;

      if(++nincl >= MAXINCLUDES)
            fatal("includes nested too deep");
      if(name[0] == '\0')
            fp = stdin;
      else
            fp = fopen(name, "r");
      if( fp ) {
            t = inclp;
            inclp = ALLOC(inclfile);
            inclp->inclnext = t;
            prevlin = thislin = 0;
            infname = inclp->inclname = name;
            infile = inclp->inclfp = fp;
      } else {
            fprintf(diagfile, "Cannot open file %s", name);
            done(1);
      }
}




LOCAL int
popinclude()
{
      struct inclfile *t;
      register char *p;
      register int k;

      if(infile != stdin)
            fclose(infile);
      ckfree(infname);

      --nincl;
      t = inclp->inclnext;
      ckfree(inclp);
      inclp = t;
      if(inclp == NULL)
            return(NO);

      infile = inclp->inclfp;
      infname = inclp->inclname;
      prevlin = thislin = inclp->incllno;
      code = inclp->inclcode;
      stno = nxtstno = inclp->inclstno;
      if(inclp->incllinp) {
            endcd = nextcd = s;
            k = inclp->incllen;
            p = inclp->incllinp;
            while(--k >= 0)
                  *endcd++ = *p++;
            ckfree(inclp->incllinp);
      } else
            nextcd = NULL;
      return(YES);
}



int
yylex()
{
static int  tokno;

      switch(lexstate)
      {
case NEWSTMT :    /* need a new statement */
      if(getcds() == STEOF)
            return(SEOF);
      crunch();
      tokno = 0;
      lexstate = FIRSTTOKEN;
      yylval.num = stno;
      stno = nxtstno;
      toklen = 0;
      return(SLABEL);

first:
case FIRSTTOKEN : /* first step on a statement */
      analyz();
      lexstate = OTHERTOKEN;
      tokno = 1;
      return(stkey);

case OTHERTOKEN : /* return next token */
      if(nextch > lastch)
            goto reteos;
      ++tokno;
      if((stkey==SLOGIF || stkey==SELSEIF) && parlev==0 && tokno>3) goto first;
      if(stkey==SASSIGN && tokno==3 && nextch<lastch &&
            nextch[0]=='t' && nextch[1]=='o')
                  {
                  nextch+=2;
                  return(STO);
                  }
      return(gettok());

reteos:
case RETEOS:
      lexstate = NEWSTMT;
      return(SEOS);
      }
fatal1("impossible lexstate %d", lexstate);
/* NOTREACHED */
return 0; /* XXX gcc */
}

LOCAL int
getcds()
{
register char *p, *q;

top:
      if(nextcd == NULL)
            {
            code = getcd( nextcd = s );
            stno = nxtstno;
            prevlin = thislin;
            }
      if(code == STEOF) {
            if( popinclude() )
                  goto top;
            else
                  return(STEOF);
      }
      if(code == STCONTINUE)
            {
            lineno = thislin;
            err("illegal continuation card ignored");
            nextcd = NULL;
            goto top;
            }

      if(nextcd > s)
            {
            q = nextcd;
            p = s;
            while(q < endcd)
                  *p++ = *q++;
            endcd = p;
            }
      for(nextcd = endcd ;
            nextcd+66<=send && (code = getcd(nextcd))==STCONTINUE ;
            nextcd = endcd )
                  ;
      nextch = s;
      lastch = nextcd - 1;
      if(nextcd >= send)
            nextcd = NULL;
      lineno = prevlin;
      prevlin = thislin;
      return(STINITIAL);
}

LOCAL int
getcd(b)
register char *b;
{
register int c;
register char *p, *bend;
int speclin;
static char a[6];
static char *aend = a+6;

top:
      endcd = b;
      bend = b+66;
      speclin = NO;

      if( (c = getc(infile)) == '&')
            {
            a[0] = BLANK;
            a[5] = 'x';
            speclin = YES;
            bend = send;
            }
      else if(c=='c' || c=='C' || c=='*')
            {
            while( (c = getc(infile)) != '\n')
                  if(c == EOF)
                        return(STEOF);
            ++thislin;
            goto top;
            }

      else if(c != EOF)
            {
            /* a tab in columns 1-6 skips to column 7 */
            ungetc(c, infile);
            for(p=a; p<aend && (c=getc(infile)) != '\n' && c!=EOF; )
                  if(c == '\t')
                        {
                        while(p < aend)
                              *p++ = BLANK;
                        speclin = YES;
                        bend = send;
                        }
                  else
                        *p++ = c;
            }
      if(c == EOF)
            return(STEOF);
      if(c == '\n')
            {
            p = a; /* XXX ??? */
            while(p < aend)
                  *p++ = BLANK;
            if( ! speclin )
                  while(endcd < bend)
                        *endcd++ = BLANK;
            }
      else  {     /* read body of line */
            while( endcd<bend && (c=getc(infile)) != '\n' && c!=EOF )
                  *endcd++ = (c == '\t' ? BLANK : c);
            if(c == EOF)
                  return(STEOF);
            if(c != '\n')
                  {
                  while( (c=getc(infile)) != '\n')
                        if(c == EOF)
                              return(STEOF);
                  }

            if( ! speclin )
                  while(endcd < bend)
                        *endcd++ = BLANK;
            }
      ++thislin;
      if(a[5]!=BLANK && a[5]!='0')
            return(STCONTINUE);
      for(p=a; p<aend; ++p)
            if(*p != BLANK) goto initline;
      for(p = b ; p<endcd ; ++p)
            if(*p != BLANK) goto initline;
      goto top;

initline:
      nxtstno = 0;
      for(p = a ; p<a+5 ; ++p)
            if(*p != BLANK) {
                  if(isdigit((int)*p))
                        nxtstno = 10*nxtstno + (*p - '0');
                  else  {
                        lineno = thislin;
                        err("nondigit in statement number field");
                        nxtstno = 0;
                        break;
                        }
            }
      return(STINITIAL);
}

LOCAL void
crunch()
{
register char *i, *j, *j0, *j1, *prvstr;
int ten, nh, quote;

/* i is the next input character to be looked at
j is the next output character */
parlev = 0;
expcom = 0; /* exposed ','s */
expeql = 0; /* exposed equal signs */
j = s;
prvstr = s;
for(i=s ; i<=lastch ; ++i)
      {
      if(*i == BLANK) continue;
      if(*i=='\'' ||  *i=='"')
            {
            quote = *i;
            *j = MYQUOTE; /* special marker */
            for(;;)
                  {
                  if(++i > lastch)
                        {
                        err("unbalanced quotes; closing quote supplied");
                        break;
                        }
                  if(*i == quote)
                        if(i<lastch && i[1]==quote) ++i;
                        else break;
                  else if(*i=='\\' && i<lastch)
                        switch(*++i)
                              {
                              case 't':
                                    *i = '\t'; break;
                              case 'b':
                                    *i = '\b'; break;
                              case 'n':
                                    *i = '\n'; break;
                              case 'f':
                                    *i = '\f'; break;
                              case '0':
                                    *i = '\0'; break;
                              default:
                                    break;
                              }
                  *++j = *i;
                  }
            j[1] = MYQUOTE;
            j += 2;
            prvstr = j;
            }
      else if( (*i=='h' || *i=='H')  && j>prvstr)     /* test for Hollerith strings */
            {
            if( ! isdigit((int)j[-1])) goto copychar;
            nh = j[-1] - '0';
            ten = 10;
            j1 = prvstr - 1;
            if (j1<j-5) j1=j-5;
            for(j0=j-2 ; j0>j1; -- j0)
                  {
                  if( ! isdigit((int)*j0 ) ) break;
                  nh += ten * (*j0-'0');
                  ten*=10;
                  }
            if(j0 <= j1) goto copychar;
/* a hollerith must be preceded by a punctuation mark.
   '*' is possible only as repetition factor in a data statement
   not, in particular, in character*2h
*/

            if( !(*j0=='*'&&s[0]=='d') && *j0!='/' && *j0!='(' &&
                  *j0!=',' && *j0!='=' && *j0!='.')
                        goto copychar;
            if(i+nh > lastch)
                  {
                  err1("%dH too big", nh);
                  nh = lastch - i;
                  }
            j0[1] = MYQUOTE; /* special marker */
            j = j0 + 1;
            while(nh-- > 0)
                  {
                  if(*++i == '\\')
                        switch(*++i)
                              {
                              case 't':
                                    *i = '\t'; break;
                              case 'b':
                                    *i = '\b'; break;
                              case 'n':
                                    *i = '\n'; break;
                              case 'f':
                                    *i = '\f'; break;
                              case '0':
                                    *i = '\0'; break;
                              default:
                                    break;
                              }
                  *++j = *i;
                  }
            j[1] = MYQUOTE;
            j+=2;
            prvstr = j;
            }
      else  {
            if(*i == '(') ++parlev;
            else if(*i == ')') --parlev;
            else if(parlev == 0) {
                  if(*i == '=') expeql = 1;
                  else if(*i == ',') expcom = 1;
copychar:   ;     /*not a string of BLANK -- copy, shifting case if necessary */
            }
            if(shiftcase && isupper((int)*i))
                  *j++ = tolower((int)*i);
            else  *j++ = *i;
            }
      }
lastch = j - 1;
nextch = s;
}

LOCAL void
analyz()
{
register char *i;

      if(parlev != 0)
            {
            err("unbalanced parentheses, statement skipped");
            stkey = SUNKNOWN;
            return;
            }
      if(nextch+2<=lastch && nextch[0]=='i' && nextch[1]=='f' && nextch[2]=='(')
            {
/* assignment or if statement -- look at character after balancing paren */
            parlev = 1;
            for(i=nextch+3 ; i<=lastch; ++i)
                  if(*i == (MYQUOTE))
                        {
                        while(*++i != MYQUOTE)
                              ;
                        }
                  else if(*i == '(')
                        ++parlev;
                  else if(*i == ')')
                        {
                        if(--parlev == 0)
                              break;
                        }
            if(i >= lastch)
                  stkey = SLOGIF;
            else if(i[1] == '=')
                  stkey = SLET;
            else if( isdigit((int)i[1]) )
                  stkey = SARITHIF;
            else  stkey = SLOGIF;
            if(stkey != SLET)
                  nextch += 2;
            }
      else if(expeql) /* may be an assignment */
            {
            if(expcom && nextch<lastch &&
                  nextch[0]=='d' && nextch[1]=='o')
                        {
                        stkey = SDO;
                        nextch += 2;
                        }
            else  stkey = SLET;
            }
/* otherwise search for keyword */
      else  {
            stkey = getkwd();
            if(stkey==SGOTO && lastch>=nextch) {
                  if(nextch[0]=='(')
                        stkey = SCOMPGOTO;
                  else if(isalpha((int)nextch[0]))
                        stkey = SASGOTO;
            }
      }
      parlev = 0;
}



LOCAL int
getkwd()
{
register char *i, *j;
register struct keylist *pk, *pend;
int k;

if(! isalpha((int)nextch[0]) )
      return(SUNKNOWN);
k = nextch[0] - 'a';
if((pk = keystart[k]))
      for(pend = keyend[k] ; pk<=pend ; ++pk )
            {
            i = pk->keyname;
            j = nextch;
            while(*++i==*++j && *i!='\0')
                  ;
            if(*i == '\0')
                  {
                  nextch = j;
                  return(pk->keyval);
                  }
            }
return(SUNKNOWN);
}


void
initkey()
{
register struct keylist *p;
register int i,j;

for(i = 0 ; i<26 ; ++i)
      keystart[i] = NULL;

for(p = keys ; p->keyname ; ++p)
      {
      j = p->keyname[0] - 'a';
      if(keystart[j] == NULL)
            keystart[j] = p;
      keyend[j] = p;
      }
}

LOCAL int
gettok()
{
int havdot, havexp, havdbl;
int radix;
extern struct punctlist puncts[];
struct punctlist *pp;
#if 0
extern struct fmtlist fmts[];
#endif
struct dotlist *pd;

char *i, *j, *n1, *p;

      if(*nextch == (MYQUOTE))
            {
            ++nextch;
            p = token;
            while(*nextch != MYQUOTE)
                  *p++ = *nextch++;
            ++nextch;
            toklen = p - token;
            *p = '\0';
            return (SHOLLERITH);
            }
/*
      if(stkey == SFORMAT)
            {
            for(pf = fmts; pf->fmtchar; ++pf)
                  {
                  if(*nextch == pf->fmtchar)
                        {
                        ++nextch;
                        if(pf->fmtval == SLPAR)
                              ++parlev;
                        else if(pf->fmtval == SRPAR)
                              --parlev;
                        return(pf->fmtval);
                        }
                  }
            if( isdigit(*nextch) )
                  {
                  p = token;
                  *p++ = *nextch++;
                  while(nextch<=lastch && isdigit(*nextch) )
                        *p++ = *nextch++;
                  toklen = p - token;
                  *p = '\0';
                  if(nextch<=lastch && *nextch=='p')
                        {
                        ++nextch;
                        return(SSCALE);
                        }
                  else  return(SICON);
                  }
            if( isalpha(*nextch) )
                  {
                  p = token;
                  *p++ = *nextch++;
                  while(nextch<=lastch &&
                        (*nextch=='.' || isdigit(*nextch) || isalpha(*nextch) ))
                              *p++ = *nextch++;
                  toklen = p - token;
                  *p = '\0';
                  return(SFIELD);
                  }
            goto badchar;
            }
 XXX ??? */
/* Not a format statement */

if(needkwd)
      {
      needkwd = 0;
      return( getkwd() );
      }

      for(pp=puncts; pp->punchar; ++pp)
            if(*nextch == pp->punchar)
                  {
                  if( (*nextch=='*' || *nextch=='/') &&
                        nextch<lastch && nextch[1]==nextch[0])
                              {
                              if(*nextch == '*')
                                    yylval.num = SPOWER;
                              else  yylval.num = SCONCAT;
                              nextch+=2;
                              }
                  else  {yylval.num=pp->punval;
                              if(yylval.num==SLPAR)
                                    ++parlev;
                              else if(yylval.num==SRPAR)
                                    --parlev;
                              ++nextch;
                        }
                  return(yylval.num);
                  }
      if(*nextch == '.') {
            if(nextch >= lastch) goto badchar;
            else if(isdigit((int)nextch[1])) goto numconst;
            else  {
                  for(pd=dots ; (j=pd->dotname) ; ++pd)
                        {
                        for(i=nextch+1 ; i<=lastch ; ++i)
                              if(*i != *j) break;
                              else if(*i != '.') ++j;
                              else  {
                                    nextch = i+1;
                                    return(pd->dotval);
                                    }
                        }
                  goto badchar;
                  }
      }
      if( isalpha((int)*nextch) )
            {
            p = token;
            *p++ = *nextch++;
            while(nextch<=lastch)
                  if( isalpha((int)*nextch) || isdigit((int)*nextch) )
                        *p++ = *nextch++;
                  else break;
            toklen = p - token;
            *p = '\0';
            if(inioctl && nextch<=lastch && *nextch=='=')
                  {
                  ++nextch;
                  return(SNAMEEQ);
                  }
            if(toklen>=8 && eqn(8, token, "function") &&
                  nextch<lastch && *nextch=='(')
                        {
                        nextch -= (toklen - 8);
                        return(SFUNCTION);
                        }
            if(toklen > VL)
                  {
                  err2("name %s too long, truncated to %d", token, VL);
                  toklen = VL;
                  token[6] = '\0';
                  }
            if(toklen==1 && *nextch==MYQUOTE)
                  {
                  switch(token[0])
                        {
                        case 'z':  case 'Z':
                        case 'x':  case 'X':
                              radix = 16; break;
                        case 'o':  case 'O':
                              radix = 8; break;
                        case 'b':  case 'B':
                              radix = 2; break;
                        default:
                              err("bad bit identifier");
                              return(SFNAME);
                        }
                  ++nextch;
                  for(p = token ; *nextch!=MYQUOTE ; )
                        if( hextoi(*p++ = *nextch++) >= radix)
                              {
                              err("invalid binary character");
                              break;
                              }
                  ++nextch;
                  toklen = p - token;
                  return( radix==16 ? SHEXCON : (radix==8 ? SOCTCON : SBITCON) );
                  }
            return(SFNAME);
            }
      if( ! isdigit((int)*nextch) ) goto badchar;
numconst:
      havdot = NO;
      havexp = NO;
      havdbl = NO;
      for(n1 = nextch ; nextch<=lastch ; ++nextch)
            {
            if(*nextch == '.')
                  if(havdot) break;
                  else if(nextch+2<=lastch && isalpha((int)nextch[1])
                        && isalpha((int)nextch[2]))
                              break;
                  else  havdot = YES;
            else if(*nextch=='d' || *nextch=='e')
                  {
                  p = nextch;
                  havexp = YES;
                  if(*nextch == 'd')
                        havdbl = YES;
                  if(nextch<lastch)
                        if(nextch[1]=='+' || nextch[1]=='-')
                              ++nextch;
                  if( ! isdigit((int)*++nextch) )
                        {
                        nextch = p;
                        havdbl = havexp = NO;
                        break;
                        }
                  for(++nextch ;
                        nextch<=lastch && isdigit((int)*nextch);
                        ++nextch);
                  break;
                  }
            else if( ! isdigit((int)*nextch) )
                  break;
            }
      p = token;
      i = n1;
      while(i < nextch)
            *p++ = *i++;
      toklen = p - token;
      *p = '\0';
      if(havdbl) return(SDCON);
      if(havdot || havexp) return(SRCON);
      return(SICON);
badchar:
      s[0] = *nextch++;
      return(SUNKNOWN);
}

/* KEYWORD AND SPECIAL CHARACTER TABLES
*/

struct punctlist puncts[ ] =
      {
{     '(', SLPAR, },
{     ')', SRPAR, },
{     '=', SEQUALS, },
{     ',', SCOMMA, },
{     '+', SPLUS, },
{     '-', SMINUS, },
{     '*', SSTAR, },
{     '/', SSLASH, },
{     '$', SCURRENCY, },
{     ':', SCOLON, },
{     0, 0 }, } ;

/*
LOCAL struct fmtlist  fmts[ ] =
      {
      '(', SLPAR,
      ')', SRPAR,
      '/', SSLASH,
      ',', SCOMMA,
      '-', SMINUS,
      ':', SCOLON,
      0, 0 } ;
*/

LOCAL struct dotlist  dots[ ] =
      {
{     "and.", SAND, },
{     "or.", SOR, },
{     "not.", SNOT, },
{     "true.", STRUE, },
{     "false.", SFALSE, },
{     "eq.", SEQ, },
{     "ne.", SNE, },
{     "lt.", SLT, },
{     "le.", SLE, },
{     "gt.", SGT, },
{     "ge.", SGE, },
{     "neqv.", SNEQV, },
{     "eqv.", SEQV, },
{     0, 0 }, } ;

LOCAL struct keylist  keys[ ] =
      {
{     "assign",  SASSIGN, },
{     "automatic",  SAUTOMATIC, },
{     "backspace",  SBACKSPACE, },
{     "blockdata",  SBLOCK, },
{     "call",  SCALL, },
{     "character",  SCHARACTER, },
{     "close",  SCLOSE, },
{     "common",  SCOMMON, },
{     "complex",  SCOMPLEX, },
{     "continue",  SCONTINUE, },
{     "data",  SDATA, },
{     "dimension",  SDIMENSION, },
{     "doubleprecision",  SDOUBLE, },
{     "doublecomplex", SDCOMPLEX, },
{     "elseif",  SELSEIF, },
{     "else",  SELSE, },
{     "endfile",  SENDFILE, },
{     "endif",  SENDIF, },
{     "end",  SEND, },
{     "entry",  SENTRY, },
{     "equivalence",  SEQUIV, },
{     "external",  SEXTERNAL, },
{     "format",  SFORMAT, },
{     "function",  SFUNCTION, },
{     "goto",  SGOTO, },
{     "implicit",  SIMPLICIT, },
{     "include",  SINCLUDE, },
{     "inquire",  SINQUIRE, },
{     "intrinsic",  SINTRINSIC, },
{     "integer",  SINTEGER, },
{     "logical",  SLOGICAL, },
{     "open",  SOPEN, },
{     "parameter",  SPARAM, },
{     "pause",  SPAUSE, },
{     "print",  SPRINT, },
{     "program",  SPROGRAM, },
{     "punch",  SPUNCH, },
{     "read",  SREAD, },
{     "real",  SREAL, },
{     "return",  SRETURN, },
{     "rewind",  SREWIND, },
{     "save",  SSAVE, },
{     "static",  SSTATIC, },
{     "stop",  SSTOP, },
{     "subroutine",  SSUBROUTINE, },
{     "then",  STHEN, },
{     "undefined", SUNDEFINED, },
{     "write",  SWRITE, },
{     0, 0 }, };

Generated by  Doxygen 1.6.0   Back to index