Doxygen Source Code Documentation
lex.c File Reference
#include "defs.h"
#include "tokdefs.h"
#include "p1defs.h"
Go to the source code of this file.
Data Structures | |
struct | comment_buf |
struct | Dotlist |
struct | Fmtlist |
struct | Inclfile |
struct | Keylist |
struct | Punctlist |
Defines | |
#define | EOF_CHAR 26 |
#define | BLANK ' ' |
#define | MYQUOTE (2) |
#define | SEOF 0 |
#define | STEOF 1 |
#define | STINITIAL 2 |
#define | STCONTINUE 3 |
#define | NEWSTMT 1 |
#define | FIRSTTOKEN 2 |
#define | OTHERTOKEN 3 |
#define | RETEOS 4 |
#define | USC (unsigned char *) |
#define | isalnum_(x) anum_buf[x] |
#define | isalpha_(x) (anum_buf[x] == 1) |
#define | COMMENT_BUF_STORE 4088 |
Typedefs | |
typedef comment_buf | comment_buf |
Functions | |
void flush_comments | Argdcl ((void)) |
void | putlineno (Void) |
int getcd | Argdcl ((char *, int)) |
void store_comment | Argdcl ((char *)) |
int | inilex (char *name) |
void | flline (Void) |
char * | lexline (int *n) |
void | doinclude (char *name) |
LOCAL int | popinclude (Void) |
void | p1_line_number (long line_number) |
int | yylex (Void) |
LOCAL void | contmax (Void) |
LOCAL int | getcds (Void) |
void | bang (char *a, char *b, char *c, register char *d, register char *e) |
LOCAL int | getcd (register char *b, int nocont) |
LOCAL void | adjtoklen (int newlen) |
LOCAL void | crunch (Void) |
LOCAL void | analyz (Void) |
LOCAL int | getkwd (Void) |
void | initkey (Void) |
LOCAL int | hexcheck (int key) |
LOCAL int | gettok (Void) |
void | store_comment (char *str) |
void | flush_comments (Void) |
void | unclassifiable (Void) |
Variables | |
LOCAL int | stkey |
int | needwkey |
ftnint | yystno |
flag | intonly |
int | new_dcl |
LOCAL long int | stno |
LOCAL long int | nxtstno |
LOCAL int | parlev |
LOCAL int | parseen |
LOCAL int | expcom |
LOCAL int | expeql |
LOCAL char * | nextch |
LOCAL char * | lastch |
LOCAL char * | nextcd = NULL |
LOCAL char * | endcd |
LOCAL long | prevlin |
LOCAL long | thislin |
LOCAL int | code |
LOCAL int | lexstate = NEWSTMT |
LOCAL char * | sbuf |
LOCAL char * | send |
LOCAL int | maxcont |
LOCAL int | nincl = 0 |
LOCAL long | firstline |
LOCAL char * | laststb |
LOCAL char * | stb0 |
int | addftnsrc |
char ** | linestart |
LOCAL int | ncont |
LOCAL char | comstart [Table_size] |
char | anum_buf [Table_size] |
comment_buf * | cbfirst |
comment_buf * | cbcur |
char * | cbinit |
char * | cbnext |
char * | cblast |
flag | use_bs |
char * | lastfile = "??" |
char * | lastfile0 = "?" |
char | fbuf [P1_FILENAME_MAX] |
long | lastline |
LOCAL struct Inclfile * | inclp = NULL |
LOCAL struct Keylist * | keystart [26] |
LOCAL struct Keylist * | keyend [26] |
Punctlist | puncts [] |
LOCAL struct Dotlist | dots [] |
LOCAL struct Keylist | keys [] |
LOCAL char * | stbuf [3] |
Define Documentation
|
Definition at line 36 of file lex.c. Referenced by getcd(). |
|
Definition at line 89 of file lex.c. Referenced by flush_comments(), and store_comment(). |
|
|
|
Definition at line 49 of file lex.c. Referenced by yylex(). |
|
Definition at line 86 of file lex.c. Referenced by gettok(). |
|
|
|
Definition at line 37 of file lex.c. Referenced by analyz(), crunch(), gettok(), and unclassifiable(). |
|
|
|
Definition at line 50 of file lex.c. Referenced by yylex(). |
|
|
|
Definition at line 38 of file lex.c. Referenced by yylex(). |
|
Definition at line 44 of file lex.c. Referenced by getcds(). |
|
|
|
|
|
|
Typedef Documentation
|
|
Function Documentation
|
Definition at line 1021 of file lex.c. References realloc. Referenced by crunch().
01023 { 01024 while(maxtoklen < newlen) 01025 maxtoklen = 2*maxtoklen + 2; 01026 if (token = (char *)realloc(token, maxtoklen)) 01027 return; 01028 fprintf(stderr, "adjtoklen: realloc(%d) failure!\n", maxtoklen); 01029 exit(2); 01030 } |
|
Definition at line 1171 of file lex.c. References err, expcom, getkwd(), i, isalpha_, lastch, MYQUOTE, needwkey, nextch, parlev, parseen, sbuf, stkey, and USC. Referenced by yylex().
01172 { 01173 register char *i; 01174 01175 if(parlev != 0) 01176 { 01177 err("unbalanced parentheses, statement skipped"); 01178 stkey = SUNKNOWN; 01179 lastch = sbuf - 1; /* prevent double error msg */ 01180 return; 01181 } 01182 if(nextch+2<=lastch && nextch[0]=='i' && nextch[1]=='f' && nextch[2]=='(') 01183 { 01184 /* assignment or if statement -- look at character after balancing paren */ 01185 parlev = 1; 01186 for(i=nextch+3 ; i<=lastch; ++i) 01187 if(*i == (MYQUOTE)) 01188 { 01189 while(*++i != MYQUOTE) 01190 ; 01191 } 01192 else if(*i == '(') 01193 ++parlev; 01194 else if(*i == ')') 01195 { 01196 if(--parlev == 0) 01197 break; 01198 } 01199 if(i >= lastch) 01200 stkey = SLOGIF; 01201 else if(i[1] == '=') 01202 stkey = SLET; 01203 else if( isdigit(i[1]) ) 01204 stkey = SARITHIF; 01205 else stkey = SLOGIF; 01206 if(stkey != SLET) 01207 nextch += 2; 01208 } 01209 else if(expeql) /* may be an assignment */ 01210 { 01211 if(expcom && nextch<lastch && 01212 nextch[0]=='d' && nextch[1]=='o') 01213 { 01214 stkey = SDO; 01215 nextch += 2; 01216 } 01217 else stkey = SLET; 01218 } 01219 else if (parseen && nextch + 7 < lastch 01220 && nextch[2] != 'u' /* screen out "double..." early */ 01221 && nextch[0] == 'd' && nextch[1] == 'o' 01222 && ((nextch[2] >= '0' && nextch[2] <= '9') 01223 || nextch[2] == ',' 01224 || nextch[2] == 'w')) 01225 { 01226 stkey = SDO; 01227 nextch += 2; 01228 needwkey = 1; 01229 } 01230 /* otherwise search for keyword */ 01231 else { 01232 stkey = getkwd(); 01233 if(stkey==SGOTO && lastch>=nextch) 01234 if(nextch[0]=='(') 01235 stkey = SCOMPGOTO; 01236 else if(isalpha_(* USC nextch)) 01237 stkey = SASGOTO; 01238 } 01239 parlev = 0; 01240 } |
|
|
|
|
|
|
|
Definition at line 651 of file lex.c. References a, c, COMMENT_BUFFER_SIZE, p, and store_comment(). Referenced by crunch(), and getcd().
00654 { 00655 char buf[COMMENT_BUFFER_SIZE + 1]; 00656 register char *p, *pe; 00657 00658 p = buf; 00659 pe = buf + COMMENT_BUFFER_SIZE; 00660 *pe = 0; 00661 while(a < b) 00662 if (!(*p++ = *a++)) 00663 p[-1] = 0; 00664 if (b < c) 00665 *p++ = '\t'; 00666 while(d < e) { 00667 if (!(*p++ = *d++)) 00668 p[-1] = ' '; 00669 if (p == pe) { 00670 store_comment(buf); 00671 p = buf; 00672 } 00673 } 00674 if (p > buf) { 00675 while(--p >= buf && *p == ' '); 00676 p[1] = 0; 00677 store_comment(buf); 00678 } 00679 } |
|
Definition at line 566 of file lex.c. References many(), and thislin. Referenced by crunch(), and getcds().
|
|
Definition at line 1036 of file lex.c. References addftnsrc, adjtoklen(), bang(), contmax(), err, erri(), expcom, expeql, i, lastch, linestart, maxcont, MYQUOTE, needwkey, new_dcl, nextch, parlev, parseen, sbuf, and use_bs. Referenced by yylex().
01037 { 01038 register char *i, *j, *j0, *j1, *prvstr; 01039 int k, ten, nh, nh0, quote; 01040 01041 /* i is the next input character to be looked at 01042 j is the next output character */ 01043 01044 new_dcl = needwkey = parlev = parseen = 0; 01045 expcom = 0; /* exposed ','s */ 01046 expeql = 0; /* exposed equal signs */ 01047 j = sbuf; 01048 prvstr = sbuf; 01049 k = 0; 01050 for(i=sbuf ; i<=lastch ; ++i) 01051 { 01052 if(isspace(*i) ) 01053 continue; 01054 if (*i == '!') { 01055 while(i >= linestart[k]) 01056 if (++k >= maxcont) 01057 contmax(); 01058 j0 = linestart[k]; 01059 if (!addftnsrc) 01060 bang(sbuf,sbuf,sbuf,i+1,j0); 01061 i = j0-1; 01062 continue; 01063 } 01064 01065 /* Keep everything in a quoted string */ 01066 01067 if(*i=='\'' || *i=='"') 01068 { 01069 int len = 0; 01070 01071 quote = *i; 01072 *j = MYQUOTE; /* special marker */ 01073 for(;;) 01074 { 01075 if(++i > lastch) 01076 { 01077 err("unbalanced quotes; closing quote supplied"); 01078 if (j >= lastch) 01079 j = lastch - 1; 01080 break; 01081 } 01082 if(*i == quote) 01083 if(i<lastch && i[1]==quote) ++i; 01084 else break; 01085 else if(*i=='\\' && i<lastch && use_bs) { 01086 ++i; 01087 *i = escapes[*(unsigned char *)i]; 01088 } 01089 *++j = *i; 01090 len++; 01091 } /* for (;;) */ 01092 01093 if ((len = j - sbuf) > maxtoklen) 01094 adjtoklen(len); 01095 j[1] = MYQUOTE; 01096 j += 2; 01097 prvstr = j; 01098 } 01099 else if( (*i=='h' || *i=='H') && j>prvstr) /* test for Hollerith strings */ 01100 { 01101 j0 = j - 1; 01102 if( ! isdigit(*j0)) goto copychar; 01103 nh = *j0 - '0'; 01104 ten = 10; 01105 j1 = prvstr; 01106 if (j1+4 < j) 01107 j1 = j-4; 01108 for(;;) { 01109 if (j0-- <= j1) 01110 goto copychar; 01111 if( ! isdigit(*j0 ) ) break; 01112 nh += ten * (*j0-'0'); 01113 ten*=10; 01114 } 01115 /* a hollerith must be preceded by a punctuation mark. 01116 '*' is possible only as repetition factor in a data statement 01117 not, in particular, in character*2h 01118 */ 01119 01120 if( !(*j0=='*'&&sbuf[0]=='d') && *j0!='/' 01121 && *j0!='(' && *j0!=',' && *j0!='=' && *j0!='.') 01122 goto copychar; 01123 nh0 = nh; 01124 if(i+nh > lastch) 01125 { 01126 erri("%dH too big", nh); 01127 nh = lastch - i; 01128 nh0 = -1; 01129 } 01130 if (nh > maxtoklen) 01131 adjtoklen(nh); 01132 j0[1] = MYQUOTE; /* special marker */ 01133 j = j0 + 1; 01134 while(nh-- > 0) 01135 { 01136 if (++i > lastch) { 01137 hol_overflow: 01138 if (nh0 >= 0) 01139 erri("escapes make %dH too big", 01140 nh0); 01141 break; 01142 } 01143 if(*i == '\\' && use_bs) { 01144 if (++i > lastch) 01145 goto hol_overflow; 01146 *i = escapes[*(unsigned char *)i]; 01147 } 01148 *++j = *i; 01149 } 01150 j[1] = MYQUOTE; 01151 j+=2; 01152 prvstr = j; 01153 } 01154 else { 01155 if(*i == '(') parseen = ++parlev; 01156 else if(*i == ')') --parlev; 01157 else if(parlev == 0) 01158 if(*i == '=') expeql = 1; 01159 else if(*i == ',') expcom = 1; 01160 copychar: /*not a string or space -- copy, shifting case if necessary */ 01161 if(shiftcase && isupper(*i)) 01162 *j++ = tolower(*i); 01163 else *j++ = *i; 01164 } 01165 } 01166 lastch = j - 1; 01167 nextch = sbuf; 01168 } |
|
Definition at line 302 of file lex.c. References ALLOC, Alloc, code, copyn(), Chain::datap, endcd, Fatal(), FILEP, free, Iargs, Inclfile::inclcode, Inclfile::inclfp, Inclfile::incllen, Inclfile::incllinp, Inclfile::incllno, Inclfile::inclname, Inclfile::inclnext, Inclfile::inclstno, lastline, MAXINCLUDES, name, nextcd, Chain::nextp, nincl, nxtstno, prevlin, putlineno(), and thislin. Referenced by inilex(), and yyparse().
00304 { 00305 FILEP fp; 00306 struct Inclfile *t; 00307 char *name0, *lastslash, *s, *s0, *temp; 00308 int j, k; 00309 chainp I; 00310 extern chainp Iargs; 00311 00312 err_lineno = -1; 00313 if(inclp) 00314 { 00315 inclp->incllno = thislin; 00316 inclp->inclcode = code; 00317 inclp->inclstno = nxtstno; 00318 if(nextcd && (j = endcd - nextcd) > 0) 00319 inclp->incllinp = copyn(inclp->incllen = j, nextcd); 00320 else 00321 inclp->incllinp = 0; 00322 } 00323 nextcd = NULL; 00324 00325 if(++nincl >= MAXINCLUDES) 00326 Fatal("includes nested too deep"); 00327 if(name[0] == '\0') 00328 fp = stdin; 00329 else if(name[0] == '/' || inclp == NULL 00330 #ifdef MSDOS 00331 || name[0] == '\\' 00332 || name[1] == ':' 00333 #endif 00334 ) 00335 fp = fopen(name, textread); 00336 else { 00337 lastslash = NULL; 00338 s = s0 = inclp->inclname; 00339 #ifdef MSDOS 00340 if (s[1] == ':') 00341 lastslash = s + 1; 00342 #endif 00343 for(; *s ; ++s) 00344 if(*s == '/' 00345 #ifdef MSDOS 00346 || *s == '\\' 00347 #endif 00348 ) 00349 lastslash = s; 00350 name0 = name; 00351 if(lastslash) { 00352 k = lastslash - s0 + 1; 00353 temp = Alloc(k + strlen(name) + 1); 00354 strncpy(temp, s0, k); 00355 strcpy(temp+k, name); 00356 name = temp; 00357 } 00358 fp = fopen(name, textread); 00359 if (!fp && (I = Iargs)) { 00360 k = strlen(name0) + 2; 00361 for(; I; I = I->nextp) { 00362 j = strlen(s = I->datap); 00363 name = Alloc(j + k); 00364 strcpy(name, s); 00365 switch(s[j-1]) { 00366 case '/': 00367 #ifdef MSDOS 00368 case ':': 00369 case '\\': 00370 #endif 00371 break; 00372 default: 00373 name[j++] = '/'; 00374 } 00375 strcpy(name+j, name0); 00376 if (fp = fopen(name, textread)) { 00377 free(name0); 00378 goto havefp; 00379 } 00380 free(name); 00381 name = name0; 00382 } 00383 } 00384 } 00385 if (fp) 00386 { 00387 havefp: 00388 t = inclp; 00389 inclp = ALLOC(Inclfile); 00390 inclp->inclnext = t; 00391 prevlin = thislin = 0; 00392 infname = inclp->inclname = name; 00393 infile = inclp->inclfp = fp; 00394 lastline = 0; 00395 putlineno(); 00396 lastline = 0; 00397 } 00398 else 00399 { 00400 fprintf(diagfile, "Cannot open file %s\n", name); 00401 done(1); 00402 } 00403 } |
|
Definition at line 275 of file lex.c. References lexstate, and RETEOS. Referenced by setfmt(), and yyparse().
|
|
Definition at line 1655 of file lex.c. References comment_buf::buf, cbinit, cblast, cbnext, COMMENT_BUF_STORE, comment_buf::last, comment_buf::next, and p1_comment(). Referenced by getcds(), store_comment(), and yylex().
01656 { 01657 register char *s, *s1; 01658 register comment_buf *cb; 01659 if (cbnext == cbinit) 01660 return; 01661 cbcur->last = cbnext; 01662 for(cb = cbfirst;; cb = cb->next) { 01663 for(s = cb->buf; s < cb->last; s = s1) { 01664 /* compute s1 = new s value first, since */ 01665 /* p1_comment may insert nulls into s */ 01666 s1 = s + strlen(s) + 1; 01667 p1_comment(s); 01668 } 01669 if (cb == cbcur) 01670 break; 01671 } 01672 cbcur = cbfirst; 01673 cbnext = cbinit; 01674 cblast = cbnext + COMMENT_BUF_STORE; 01675 } |
|
Definition at line 693 of file lex.c. References a, addftnsrc, Alloc, bang(), BLANK, c, COMMENT_BUFFER_SIZE, comstart, endcd, EOF_CHAR, errstr(), firstline, free, i, Inclfile::inclname, L, lastfile, lastline, laststb, NO, nxtstno, p, send, stb0, stbuf, STEOF, store_comment(), Table_size, thislin, top, ungetc(), warn72, and YES. Referenced by getcds().
00695 { 00696 register int c; 00697 register char *p, *bend; 00698 int speclin; /* Special line - true when the line is allowed 00699 to have more than 66 characters (e.g. the 00700 "&" shorthand for continuation, use of a "\t" 00701 to skip part of the label columns) */ 00702 static char a[6]; /* Statement label buffer */ 00703 static char *aend = a+6; 00704 static char *stb, *stbend; 00705 static int nst; 00706 char *atend, *endcd0; 00707 extern int warn72; 00708 char buf72[24]; 00709 int amp, i; 00710 char storage[COMMENT_BUFFER_SIZE + 1]; 00711 char *pointer; 00712 long L; 00713 00714 top: 00715 endcd = b; 00716 bend = b+66; 00717 amp = speclin = NO; 00718 atend = aend; 00719 00720 /* Handle the continuation shorthand of "&" in the first column, which stands 00721 for " x" */ 00722 00723 if( (c = getc(infile)) == '&') 00724 { 00725 a[0] = c; 00726 a[1] = 0; 00727 a[5] = 'x'; 00728 amp = speclin = YES; 00729 bend = send; 00730 p = aend; 00731 } 00732 00733 /* Handle the Comment cards (a 'C', 'c', '*', or '!' in the first column). */ 00734 00735 else if(comstart[c & (Table_size-1)]) 00736 { 00737 if (feof (infile) 00738 #ifdef EOF_CHAR 00739 || c == EOF_CHAR 00740 #endif 00741 ) 00742 return STEOF; 00743 00744 if (c == '#') { 00745 *endcd++ = c; 00746 while((c = getc(infile)) != '\n') 00747 if (c == EOF) 00748 return STEOF; 00749 else if (endcd < bend) 00750 *endcd++ = c; 00751 ++thislin; 00752 *endcd = 0; 00753 if (b[1] == ' ') 00754 p = b + 2; 00755 else if (!strncmp(b,"#line ",6)) 00756 p = b + 6; 00757 else { 00758 bad_cpp: 00759 errstr("Bad # line: \"%s\"", b); 00760 goto top; 00761 } 00762 if (*p < '1' || *p > '9') 00763 goto bad_cpp; 00764 L = *p - '0'; 00765 while((c = *++p) >= '0' && c <= '9') 00766 L = 10*L + c - '0'; 00767 if (c != ' ' || *++p != '"') 00768 goto bad_cpp; 00769 bend = p; 00770 while(*++p != '"') 00771 if (!*p) 00772 goto bad_cpp; 00773 *p = 0; 00774 i = p - bend++; 00775 thislin = L - 1; 00776 if (!infname || strcmp(infname, bend)) { 00777 if (infname) 00778 free(infname); 00779 lastfile = 0; 00780 infname = Alloc(i); 00781 strcpy(infname, bend); 00782 if (inclp) 00783 inclp->inclname = infname; 00784 } 00785 goto top; 00786 } 00787 00788 storage[COMMENT_BUFFER_SIZE] = c = '\0'; 00789 pointer = storage; 00790 while( !feof (infile) && (*pointer++ = c = getc(infile)) != '\n') { 00791 00792 /* Handle obscure end of file conditions on many machines */ 00793 00794 if (feof (infile) && (c == '\377' || c == EOF)) { 00795 pointer--; 00796 break; 00797 } /* if (feof (infile)) */ 00798 00799 if (c == '\0') 00800 *(pointer - 1) = ' '; 00801 00802 if (pointer == &storage[COMMENT_BUFFER_SIZE]) { 00803 store_comment (storage); 00804 pointer = storage; 00805 } /* if (pointer == BUFFER_SIZE) */ 00806 } /* while */ 00807 00808 if (pointer > storage) { 00809 if (c == '\n') 00810 00811 /* Get rid of the newline */ 00812 00813 pointer[-1] = 0; 00814 else 00815 *pointer = 0; 00816 00817 store_comment (storage); 00818 } /* if */ 00819 00820 if (feof (infile)) 00821 if (c != '\n') /* To allow the line index to 00822 increment correctly */ 00823 return STEOF; 00824 00825 ++thislin; 00826 goto top; 00827 } 00828 00829 else if(c != EOF) 00830 { 00831 00832 /* Load buffer a with the statement label */ 00833 00834 /* a tab in columns 1-6 skips to column 7 */ 00835 ungetc(c, infile); 00836 for(p=a; p<aend && (c=getc(infile)) != '\n' && c!=EOF; ) 00837 if(c == '\t') 00838 00839 /* The tab character translates into blank characters in the statement label */ 00840 00841 { 00842 atend = p; 00843 while(p < aend) 00844 *p++ = BLANK; 00845 speclin = YES; 00846 bend = send; 00847 } 00848 else 00849 *p++ = c; 00850 } 00851 00852 /* By now we've read either a continuation character or the statement label 00853 field */ 00854 00855 if(c == EOF) 00856 return(STEOF); 00857 00858 /* The next 'if' block handles lines that have fewer than 7 characters */ 00859 00860 if(c == '\n') 00861 { 00862 while(p < aend) 00863 *p++ = BLANK; 00864 00865 /* Blank out the buffer on lines which are not longer than 66 characters */ 00866 00867 endcd0 = endcd; 00868 if( ! speclin ) 00869 while(endcd < bend) 00870 *endcd++ = BLANK; 00871 } 00872 else { /* read body of line */ 00873 if (warn72 & 2) { 00874 speclin = YES; 00875 bend = send; 00876 } 00877 while( endcd<bend && (c=getc(infile)) != '\n' && c!=EOF ) 00878 *endcd++ = c; 00879 if(c == EOF) 00880 return(STEOF); 00881 00882 /* Drop any extra characters on the input card; this usually means those after 00883 column 72 */ 00884 00885 if(c != '\n') 00886 { 00887 i = 0; 00888 while( (c=getc(infile)) != '\n' && c != EOF) 00889 if (i < 23) 00890 buf72[i++] = c; 00891 if (warn72 && i && !speclin) { 00892 buf72[i] = 0; 00893 if (i >= 23) 00894 strcpy(buf72+20, "..."); 00895 lineno = thislin + 1; 00896 errstr("text after column 72: %s", buf72); 00897 } 00898 if(c == EOF) 00899 return(STEOF); 00900 } 00901 00902 endcd0 = endcd; 00903 if( ! speclin ) 00904 while(endcd < bend) 00905 *endcd++ = BLANK; 00906 } 00907 00908 /* The flow of control usually gets to this line (unless an earlier RETURN has 00909 been taken) */ 00910 00911 ++thislin; 00912 00913 /* Fortran 77 specifies that a 0 in column 6 */ 00914 /* does not signify continuation */ 00915 00916 if( !isspace(a[5]) && a[5]!='0') { 00917 if (!amp) 00918 for(p = a; p < aend;) 00919 if (*p++ == '!' && p != aend) 00920 goto initcheck; 00921 if (addftnsrc && stb) { 00922 if (stbend > stb + 7) { /* otherwise forget col 1-6 */ 00923 /* kludge around funny p1gets behavior */ 00924 *stb++ = '$'; 00925 if (amp) 00926 *stb++ = '&'; 00927 else 00928 for(p = a; p < atend;) 00929 *stb++ = *p++; 00930 } 00931 if (endcd0 - b > stbend - stb) { 00932 if (stb > stbend) 00933 stb = stbend; 00934 endcd0 = b + (stbend - stb); 00935 } 00936 for(p = b; p < endcd0;) 00937 *stb++ = *p++; 00938 *stb++ = '\n'; 00939 *stb = 0; 00940 } 00941 if (nocont) { 00942 lineno = thislin; 00943 errstr("illegal continuation card (starts \"%.6s\")",a); 00944 } 00945 else if (!amp && strncmp(a," ",5)) { 00946 lineno = thislin; 00947 errstr("labeled continuation line (starts \"%.6s\")",a); 00948 } 00949 return(STCONTINUE); 00950 } 00951 initcheck: 00952 for(p=a; p<atend; ++p) 00953 if( !isspace(*p) ) { 00954 if (*p++ != '!') 00955 goto initline; 00956 bang(p, atend, aend, b, endcd); 00957 goto top; 00958 } 00959 for(p = b ; p<endcd ; ++p) 00960 if( !isspace(*p) ) { 00961 if (*p++ != '!') 00962 goto initline; 00963 bang(a, a, a, p, endcd); 00964 goto top; 00965 } 00966 00967 /* Skip over blank cards by reading the next one right away */ 00968 00969 goto top; 00970 00971 initline: 00972 if (!lastline) 00973 lastline = thislin; 00974 if (addftnsrc) { 00975 nst = (nst+1)%3; 00976 if (!laststb && stb0) 00977 laststb = stb0; 00978 stb0 = stb = stbuf[nst]; 00979 *stb++ = '$'; /* kludge around funny p1gets behavior */ 00980 stbend = stb + sizeof(stbuf[0])-2; 00981 for(p = a; p < atend;) 00982 *stb++ = *p++; 00983 if (atend < aend) 00984 *stb++ = '\t'; 00985 for(p = b; p < endcd0;) 00986 *stb++ = *p++; 00987 *stb++ = '\n'; 00988 *stb = 0; 00989 } 00990 00991 /* Set nxtstno equal to the integer value of the statement label */ 00992 00993 nxtstno = 0; 00994 bend = a + 5; 00995 for(p = a ; p < bend ; ++p) 00996 if( !isspace(*p) ) 00997 if(isdigit(*p)) 00998 nxtstno = 10*nxtstno + (*p - '0'); 00999 else if (*p == '!') { 01000 if (!addftnsrc) 01001 bang(p+1,atend,aend,b,endcd); 01002 endcd = b; 01003 break; 01004 } 01005 else { 01006 lineno = thislin; 01007 errstr( 01008 "nondigit in statement label field \"%.5s\"", a); 01009 nxtstno = 0; 01010 break; 01011 } 01012 firstline = thislin; 01013 return(STINITIAL); 01014 } |
|
Definition at line 578 of file lex.c. References code, contmax(), endcd, errext(), flush_comments(), getcd(), lastch, linestart, maxcont, ncont, nextcd, nextch, nxtstno, p, popinclude(), prevlin, q, sbuf, send, STCONTINUE, STEOF, stno, thislin, and top. Referenced by yylex().
00579 { 00580 register char *p, *q; 00581 00582 flush_comments (); 00583 top: 00584 if(nextcd == NULL) 00585 { 00586 code = getcd( nextcd = sbuf, 1 ); 00587 stno = nxtstno; 00588 prevlin = thislin; 00589 } 00590 if(code == STEOF) 00591 if( popinclude() ) 00592 goto top; 00593 else 00594 return(STEOF); 00595 00596 if(code == STCONTINUE) 00597 { 00598 lineno = thislin; 00599 nextcd = NULL; 00600 goto top; 00601 } 00602 00603 /* Get rid of unused space at the head of the buffer */ 00604 00605 if(nextcd > sbuf) 00606 { 00607 q = nextcd; 00608 p = sbuf; 00609 while(q < endcd) 00610 *p++ = *q++; 00611 endcd = p; 00612 } 00613 00614 /* Be aware that the input (i.e. the string at the address nextcd) is NOT 00615 NULL-terminated */ 00616 00617 /* This loop merges all continuations into one long statement, AND puts the next 00618 card to be read at the end of the buffer (i.e. it stores the look-ahead card 00619 when there's room) */ 00620 00621 ncont = 0; 00622 for(;;) { 00623 nextcd = endcd; 00624 if (ncont >= maxcont || nextcd+66 > send) 00625 contmax(); 00626 linestart[ncont++] = nextcd; 00627 if ((code = getcd(nextcd,0)) != STCONTINUE) 00628 break; 00629 if (ncont == 20 && noextflag) { 00630 lineno = thislin; 00631 errext("more than 19 continuation lines"); 00632 } 00633 } 00634 nextch = sbuf; 00635 lastch = nextcd - 1; 00636 00637 lineno = prevlin; 00638 prevlin = thislin; 00639 return(STINITIAL); 00640 } |
|
Definition at line 1245 of file lex.c. References errstr(), i, isalpha_, Keylist::keyname, Keylist::keyval, lastch, letter, nextch, Keylist::notinf66, and USC. Referenced by analyz(), and gettok().
01246 { 01247 register char *i, *j; 01248 register struct Keylist *pk, *pend; 01249 int k; 01250 01251 if(! isalpha_(* USC nextch) ) 01252 return(SUNKNOWN); 01253 k = letter(nextch[0]); 01254 if(pk = keystart[k]) 01255 for(pend = keyend[k] ; pk<=pend ; ++pk ) 01256 { 01257 i = pk->keyname; 01258 j = nextch; 01259 while(*++i==*++j && *i!='\0') 01260 ; 01261 if(*i=='\0' && j<=lastch+1) 01262 { 01263 nextch = j; 01264 if(no66flag && pk->notinf66) 01265 errstr("Not a Fortran 66 keyword: %s", 01266 pk->keyname); 01267 return(pk->keyval); 01268 } 01269 } 01270 return(SUNKNOWN); 01271 } |
|
Definition at line 1356 of file lex.c. References Dotlist::dotname, Dotlist::dotval, eqn(), err, errext(), erri(), getkwd(), hexcheck(), hextoi, i, intonly, isalnum_, isalpha_, lastch, MAXNAMELEN, MYQUOTE, n1, needwkey, new_dcl, nextch, NO, NOEXT, p, parlev, Punctlist::punchar, Punctlist::punval, sbuf, USC, and YES. Referenced by yylex().
01357 { 01358 int havdot, havexp, havdbl; 01359 int radix, val; 01360 struct Punctlist *pp; 01361 struct Dotlist *pd; 01362 register int ch; 01363 static char Exp_mi[] = "X**-Y treated as X**(-Y)", 01364 Exp_pl[] = "X**+Y treated as X**(+Y)"; 01365 01366 char *i, *j, *n1, *p; 01367 01368 ch = * USC nextch; 01369 if(ch == (MYQUOTE)) 01370 { 01371 ++nextch; 01372 p = token; 01373 while(*nextch != MYQUOTE) 01374 *p++ = *nextch++; 01375 toklen = p - token; 01376 *p = 0; 01377 /* allow octal, binary, hex constants of the form 'abc'x (etc.) */ 01378 if (++nextch <= lastch && isalpha_(val = * USC nextch)) { 01379 ++nextch; 01380 return hexcheck(val); 01381 } 01382 return (SHOLLERITH); 01383 } 01384 01385 if(needkwd) 01386 { 01387 needkwd = 0; 01388 return( getkwd() ); 01389 } 01390 01391 for(pp=puncts; pp->punchar; ++pp) 01392 if(ch == pp->punchar) { 01393 val = pp->punval; 01394 if (++nextch <= lastch) 01395 switch(ch) { 01396 case '/': 01397 switch(*nextch) { 01398 case '/': 01399 nextch++; 01400 val = SCONCAT; 01401 break; 01402 case '=': 01403 goto sne; 01404 default: 01405 if (new_dcl && parlev == 0) 01406 val = SSLASHD; 01407 } 01408 return val; 01409 case '*': 01410 if (*nextch == '*') { 01411 nextch++; 01412 if (noextflag 01413 && nextch <= lastch) 01414 switch(*nextch) { 01415 case '-': 01416 errext(Exp_mi); 01417 break; 01418 case '+': 01419 errext(Exp_pl); 01420 } 01421 return SPOWER; 01422 } 01423 break; 01424 case '<': 01425 switch(*nextch) { 01426 case '=': 01427 nextch++; 01428 val = SLE; 01429 break; 01430 case '>': 01431 sne: 01432 nextch++; 01433 val = SNE; 01434 } 01435 goto extchk; 01436 case '=': 01437 if (*nextch == '=') { 01438 nextch++; 01439 val = SEQ; 01440 goto extchk; 01441 } 01442 break; 01443 case '>': 01444 if (*nextch == '=') { 01445 nextch++; 01446 val = SGE; 01447 } 01448 extchk: 01449 NOEXT("Fortran 8x comparison operator"); 01450 return val; 01451 } 01452 else if (ch == '/' && new_dcl && parlev == 0) 01453 return SSLASHD; 01454 switch(val) { 01455 case SLPAR: 01456 ++parlev; 01457 break; 01458 case SRPAR: 01459 --parlev; 01460 } 01461 return(val); 01462 } 01463 if(ch == '.') 01464 if(nextch >= lastch) goto badchar; 01465 else if(isdigit(nextch[1])) goto numconst; 01466 else { 01467 for(pd=dots ; (j=pd->dotname) ; ++pd) 01468 { 01469 for(i=nextch+1 ; i<=lastch ; ++i) 01470 if(*i != *j) break; 01471 else if(*i != '.') ++j; 01472 else { 01473 nextch = i+1; 01474 return(pd->dotval); 01475 } 01476 } 01477 goto badchar; 01478 } 01479 if( isalpha_(ch) ) 01480 { 01481 p = token; 01482 *p++ = *nextch++; 01483 while(nextch<=lastch) 01484 if( isalnum_(* USC nextch) ) 01485 *p++ = *nextch++; 01486 else break; 01487 toklen = p - token; 01488 *p = 0; 01489 if (needwkey) { 01490 needwkey = 0; 01491 if (toklen == 5 01492 && nextch <= lastch && *nextch == '(' /*)*/ 01493 && !strcmp(token,"while")) 01494 return(SWHILE); 01495 } 01496 if(inioctl && nextch<=lastch && *nextch=='=') 01497 { 01498 ++nextch; 01499 return(SNAMEEQ); 01500 } 01501 if(toklen>8 && eqn(8,token,"function") 01502 && isalpha_(* USC (token+8)) && 01503 nextch<lastch && nextch[0]=='(' && 01504 (nextch[1]==')' || isalpha_(* USC (nextch+1))) ) 01505 { 01506 nextch -= (toklen - 8); 01507 return(SFUNCTION); 01508 } 01509 01510 if(toklen > MAXNAMELEN) 01511 { 01512 char buff[MAXNAMELEN+50]; 01513 sprintf(buff, toklen >= MAXNAMELEN+10 01514 ? "name %.*s... too long, truncated to %.*s" 01515 : "name %s too long, truncated to %.*s", 01516 MAXNAMELEN+6, token, MAXNAMELEN, token); 01517 err(buff); 01518 toklen = MAXNAMELEN; 01519 token[MAXNAMELEN] = '\0'; 01520 } 01521 if(toklen==1 && *nextch==MYQUOTE) { 01522 val = token[0]; 01523 ++nextch; 01524 for(p = token ; *nextch!=MYQUOTE ; ) 01525 *p++ = *nextch++; 01526 ++nextch; 01527 toklen = p - token; 01528 *p = 0; 01529 return hexcheck(val); 01530 } 01531 return(SNAME); 01532 } 01533 01534 if (isdigit(ch)) { 01535 01536 /* Check for NAG's special hex constant */ 01537 01538 if (nextch[1] == '#' && nextch < lastch 01539 || nextch[2] == '#' && isdigit(nextch[1]) 01540 && lastch - nextch >= 2) { 01541 01542 radix = atoi (nextch); 01543 if (*++nextch != '#') 01544 nextch++; 01545 if (radix != 2 && radix != 8 && radix != 16) { 01546 erri("invalid base %d for constant, defaulting to hex", 01547 radix); 01548 radix = 16; 01549 } /* if */ 01550 if (++nextch > lastch) 01551 goto badchar; 01552 for (p = token; hextoi(*nextch) < radix;) { 01553 *p++ = *nextch++; 01554 if (nextch > lastch) 01555 break; 01556 } 01557 toklen = p - token; 01558 *p = 0; 01559 return (radix == 16) ? SHEXCON : ((radix == 8) ? SOCTCON : 01560 SBITCON); 01561 } 01562 } 01563 else 01564 goto badchar; 01565 numconst: 01566 havdot = NO; 01567 havexp = NO; 01568 havdbl = NO; 01569 for(n1 = nextch ; nextch<=lastch ; ++nextch) 01570 { 01571 if(*nextch == '.') 01572 if(havdot) break; 01573 else if(nextch+2<=lastch && isalpha_(* USC (nextch+1)) 01574 && isalpha_(* USC (nextch+2))) 01575 break; 01576 else havdot = YES; 01577 else if( !intonly && (*nextch=='d' || *nextch=='e') ) 01578 { 01579 p = nextch; 01580 havexp = YES; 01581 if(*nextch == 'd') 01582 havdbl = YES; 01583 if(nextch<lastch) 01584 if(nextch[1]=='+' || nextch[1]=='-') 01585 ++nextch; 01586 if( ! isdigit(*++nextch) ) 01587 { 01588 nextch = p; 01589 havdbl = havexp = NO; 01590 break; 01591 } 01592 for(++nextch ; 01593 nextch<=lastch && isdigit(* USC nextch); 01594 ++nextch); 01595 break; 01596 } 01597 else if( ! isdigit(* USC nextch) ) 01598 break; 01599 } 01600 p = token; 01601 i = n1; 01602 while(i < nextch) 01603 *p++ = *i++; 01604 toklen = p - token; 01605 *p = 0; 01606 if(havdbl) return(SDCON); 01607 if(havdot || havexp) return(SRCON); 01608 return(SICON); 01609 badchar: 01610 sbuf[0] = *nextch++; 01611 return(SUNKNOWN); 01612 } |
|
Definition at line 1312 of file lex.c. References err, errstr(), hextoi, key, and p. Referenced by gettok().
01314 { 01315 register int radix; 01316 register char *p; 01317 char *kind; 01318 01319 switch(key) { 01320 case 'z': 01321 case 'Z': 01322 case 'x': 01323 case 'X': 01324 radix = 16; 01325 key = SHEXCON; 01326 kind = "hexadecimal"; 01327 break; 01328 case 'o': 01329 case 'O': 01330 radix = 8; 01331 key = SOCTCON; 01332 kind = "octal"; 01333 break; 01334 case 'b': 01335 case 'B': 01336 radix = 2; 01337 key = SBITCON; 01338 kind = "binary"; 01339 break; 01340 default: 01341 err("bad bit identifier"); 01342 return(SNAME); 01343 } 01344 for(p = token; *p; p++) 01345 if (hextoi(*p) >= radix) { 01346 errstr("invalid %s character", kind); 01347 break; 01348 } 01349 return key; 01350 } |
|
Definition at line 258 of file lex.c. References Alloc, doinclude(), lexstate, name, NEWSTMT, nincl, P1_STMTBUFSIZE, and stbuf. Referenced by main().
00260 { 00261 stbuf[0] = Alloc(3*P1_STMTBUFSIZE); 00262 stbuf[1] = stbuf[0] + P1_STMTBUFSIZE; 00263 stbuf[2] = stbuf[1] + P1_STMTBUFSIZE; 00264 nincl = 0; 00265 inclp = NULL; 00266 doinclude(name); 00267 lexstate = NEWSTMT; 00268 return(NO); 00269 } |
|
Definition at line 1274 of file lex.c. References anum_buf, ckalloc(), comstart, EOF_CHAR, i, Keylist::keyname, letter, linestart, maxcont, sbuf, and send. Referenced by main().
01275 { 01276 register struct Keylist *p; 01277 register int i,j; 01278 register char *s; 01279 01280 for(i = 0 ; i<26 ; ++i) 01281 keystart[i] = NULL; 01282 01283 for(p = keys ; p->keyname ; ++p) { 01284 j = letter(p->keyname[0]); 01285 if(keystart[j] == NULL) 01286 keystart[j] = p; 01287 keyend[j] = p; 01288 } 01289 i = (maxcontin + 2) * 66; 01290 sbuf = (char *)ckalloc(i + 70); 01291 send = sbuf + i; 01292 maxcont = maxcontin + 1; 01293 linestart = (char **)ckalloc(maxcont*sizeof(char*)); 01294 comstart['c'] = comstart['C'] = comstart['*'] = comstart['!'] = 01295 comstart['#'] = 1; 01296 #ifdef EOF_CHAR 01297 comstart[EOF_CHAR] = 1; 01298 #endif 01299 s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_"; 01300 while(i = *s++) 01301 anum_buf[i] = 1; 01302 s = "0123456789"; 01303 while(i = *s++) 01304 anum_buf[i] = 2; 01305 } |
|
Definition at line 287 of file lex.c. References lastch, and nextch. Referenced by setfmt().
|
|
Definition at line 457 of file lex.c. References fbuf, lastfile, lastfile0, P1_FILENAME, P1_SET_LINE, and p1puts(). Referenced by enddcl(), and putlineno().
00459 { 00460 if (lastfile != lastfile0) { 00461 p1puts(P1_FILENAME, fbuf); 00462 lastfile0 = lastfile; 00463 } 00464 fprintf(pass1_file, "%d: %ld\n", P1_SET_LINE, line_number); 00465 } |
|
Definition at line 409 of file lex.c. References charptr, clf(), code, endcd, free, Inclfile::inclcode, Inclfile::inclfp, Inclfile::incllen, Inclfile::incllinp, Inclfile::incllno, Inclfile::inclname, Inclfile::inclnext, Inclfile::inclstno, lastline, nextcd, nincl, nxtstno, p, prevlin, putlineno(), sbuf, stno, and thislin. Referenced by getcds().
00410 { 00411 struct Inclfile *t; 00412 register char *p; 00413 register int k; 00414 00415 if(infile != stdin) 00416 clf(&infile, infname, 1); /* Close the input file */ 00417 free(infname); 00418 00419 --nincl; 00420 err_lineno = -1; 00421 t = inclp->inclnext; 00422 free( (charptr) inclp); 00423 inclp = t; 00424 if(inclp == NULL) { 00425 infname = 0; 00426 return(NO); 00427 } 00428 00429 infile = inclp->inclfp; 00430 infname = inclp->inclname; 00431 lineno = prevlin = thislin = inclp->incllno; 00432 code = inclp->inclcode; 00433 stno = nxtstno = inclp->inclstno; 00434 if(inclp->incllinp) 00435 { 00436 lastline = 0; 00437 putlineno(); 00438 lastline = lineno; 00439 endcd = nextcd = sbuf; 00440 k = inclp->incllen; 00441 p = inclp->incllinp; 00442 while(--k >= 0) 00443 *endcd++ = *p++; 00444 free( (charptr) (inclp->incllinp) ); 00445 } 00446 else 00447 nextcd = NULL; 00448 return(YES); 00449 } |
|
Definition at line 468 of file lex.c. References fbuf, firstline, lastfile, lastline, laststb, P1_FORTRAN, p1_line_number(), p1puts(), and stb0. Referenced by doinclude(), popinclude(), and yylex().
00469 { 00470 extern int gflag; 00471 register char *s0, *s1; 00472 00473 if (gflag) { 00474 if (lastline) 00475 p1_line_number(lastline); 00476 lastline = firstline; 00477 if (lastfile != infname) 00478 if (lastfile = infname) { 00479 strncpy(fbuf, lastfile, sizeof(fbuf)); 00480 fbuf[sizeof(fbuf)-1] = 0; 00481 } 00482 else 00483 fbuf[0] = 0; 00484 } 00485 if (addftnsrc) { 00486 if (laststb && *laststb) { 00487 for(s1 = laststb; *s1; s1++) { 00488 for(s0 = s1; *s1 != '\n'; s1++) 00489 if (*s1 == '*' && s1[1] == '/') 00490 *s1 = '+'; 00491 *s1 = 0; 00492 p1puts(P1_FORTRAN, s0); 00493 } 00494 *laststb = 0; /* prevent trouble after EOF */ 00495 } 00496 laststb = stb0; 00497 } 00498 } |
|
Definition at line 1621 of file lex.c. References Alloc, comment_buf::buf, cbinit, cblast, cbnext, COMMENT_BUF_STORE, flush_comments(), comment_buf::last, comment_buf::next, nextcd, p1_comment(), and sbuf. Referenced by bang(), and getcd().
01623 { 01624 int len; 01625 comment_buf *ncb; 01626 01627 if (nextcd == sbuf) { 01628 flush_comments(); 01629 p1_comment(str); 01630 return; 01631 } 01632 len = strlen(str) + 1; 01633 if (cbnext + len > cblast) { 01634 if (!cbcur || !(ncb = cbcur->next)) { 01635 ncb = (comment_buf *) Alloc(sizeof(comment_buf)); 01636 if (cbcur) { 01637 cbcur->last = cbnext; 01638 cbcur->next = ncb; 01639 } 01640 else { 01641 cbfirst = ncb; 01642 cbinit = ncb->buf; 01643 } 01644 ncb->next = 0; 01645 } 01646 cbcur = ncb; 01647 cbnext = ncb->buf; 01648 cblast = cbnext + COMMENT_BUF_STORE; 01649 } 01650 strcpy(cbnext, str); 01651 cbnext += len; 01652 } |
|
Definition at line 1678 of file lex.c. References errstr(), lastch, MYQUOTE, and sbuf. Referenced by yyparse().
01679 { 01680 register char *s, *se; 01681 01682 s = sbuf; 01683 se = lastch; 01684 if (se < sbuf) 01685 return; 01686 lastch = s - 1; 01687 if (++se - s > 10) 01688 se = s + 10; 01689 for(; s < se; s++) 01690 if (*s == MYQUOTE) { 01691 se = s; 01692 break; 01693 } 01694 *se = 0; 01695 errstr("unclassifiable statement (starts \"%s\")", sbuf); 01696 } |
|
Definition at line 501 of file lex.c. References analyz(), crunch(), fatali(), FIRSTTOKEN, flush_comments(), getcds(), gettok(), lastch, lexstate, NEWSTMT, nextch, nxtstno, OTHERTOKEN, parlev, putlineno(), RETEOS, retval(), SEOF, STEOF, stkey, stno, and yystno. Referenced by yyparse().
00502 { 00503 static int tokno; 00504 int retval; 00505 00506 switch(lexstate) 00507 { 00508 case NEWSTMT : /* need a new statement */ 00509 retval = getcds(); 00510 putlineno(); 00511 if(retval == STEOF) { 00512 retval = SEOF; 00513 break; 00514 } /* if getcds() == STEOF */ 00515 crunch(); 00516 tokno = 0; 00517 lexstate = FIRSTTOKEN; 00518 yystno = stno; 00519 stno = nxtstno; 00520 toklen = 0; 00521 retval = SLABEL; 00522 break; 00523 00524 first: 00525 case FIRSTTOKEN : /* first step on a statement */ 00526 analyz(); 00527 lexstate = OTHERTOKEN; 00528 tokno = 1; 00529 retval = stkey; 00530 break; 00531 00532 case OTHERTOKEN : /* return next token */ 00533 if(nextch > lastch) 00534 goto reteos; 00535 ++tokno; 00536 if( (stkey==SLOGIF || stkey==SELSEIF) && parlev==0 && tokno>3) 00537 goto first; 00538 00539 if(stkey==SASSIGN && tokno==3 && nextch<lastch && 00540 nextch[0]=='t' && nextch[1]=='o') 00541 { 00542 nextch+=2; 00543 retval = STO; 00544 break; 00545 } 00546 retval = gettok(); 00547 break; 00548 00549 reteos: 00550 case RETEOS: 00551 lexstate = NEWSTMT; 00552 retval = SEOS; 00553 break; 00554 default: 00555 fatali("impossible lexstate %d", lexstate); 00556 break; 00557 } 00558 00559 if (retval == SEOF) 00560 flush_comments (); 00561 00562 return retval; 00563 } |
Variable Documentation
|
|
|
Definition at line 85 of file lex.c. Referenced by initkey(). |
|
|
|
|
|
Definition at line 97 of file lex.c. Referenced by flush_comments(), and store_comment(). |
|
Definition at line 97 of file lex.c. Referenced by flush_comments(), and store_comment(). |
|
Definition at line 97 of file lex.c. Referenced by flush_comments(), and store_comment(). |
|
Definition at line 71 of file lex.c. Referenced by doinclude(), getcds(), and popinclude(). |
|
|
|
Initial value: { "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 } |
|
Definition at line 68 of file lex.c. Referenced by doinclude(), getcd(), getcds(), and popinclude(). |
|
|
|
Definition at line 64 of file lex.c. Referenced by crunch(). |
|
Definition at line 101 of file lex.c. Referenced by p1_line_number(), and putlineno(). |
|
Definition at line 77 of file lex.c. Referenced by getcd(), putlineno(), qh_readfeasible(), qh_readpoints(), and SUMA_write1D(). |
|
|
|
|
|
|
|
|
|
|
|
Definition at line 66 of file lex.c. Referenced by analyz(), crunch(), getcds(), getkwd(), gettok(), lexline(), process_COM(), unclassifiable(), and yylex(). |
|
Definition at line 100 of file lex.c. Referenced by getcd(), p1_line_number(), and putlineno(). |
|
Definition at line 100 of file lex.c. Referenced by p1_line_number(). |
|
Definition at line 102 of file lex.c. Referenced by doinclude(), getcd(), popinclude(), and putlineno(). |
|
Definition at line 78 of file lex.c. Referenced by getcd(), and putlineno(). |
|
|
|
|
|
|
|
Definition at line 81 of file lex.c. Referenced by getcds(). |
|
|
|
|
|
Definition at line 67 of file lex.c. Referenced by doinclude(), getcds(), popinclude(), and store_comment(). |
|
Definition at line 65 of file lex.c. Referenced by analyz(), crunch(), getcds(), getkwd(), gettok(), lexline(), and yylex(). |
|
Definition at line 76 of file lex.c. Referenced by doinclude(), inilex(), and popinclude(). |
|
Definition at line 60 of file lex.c. Referenced by doinclude(), getcd(), getcds(), popinclude(), and yylex(). |
|
|
|
|
|
Definition at line 69 of file lex.c. Referenced by doinclude(), getcds(), and popinclude(). |
|
Initial value: { '(', SLPAR, ')', SRPAR, '=', SEQUALS, ',', SCOMMA, '+', SPLUS, '-', SMINUS, '*', SSTAR, '/', SSLASH, '$', SCURRENCY, ':', SCOLON, '<', SLT, '>', SGT, 0, 0 } |
|
Definition at line 73 of file lex.c. Referenced by analyz(), crunch(), getcds(), gettok(), initkey(), popinclude(), store_comment(), and unclassifiable(). |
|
Definition at line 74 of file lex.c. Referenced by getcd(), getcds(), initkey(), iochan_send(), NIML_to_stderr(), RT_mp_comm_close(), RT_mp_comm_init(), and RT_mp_comm_send_data(). |
|
Definition at line 78 of file lex.c. Referenced by getcd(), and putlineno(). |
|
Definition at line 251 of file lex.c. Referenced by getcd(), inilex(), ListDirectory(), main(), SUMA_Get_AFNI_Default_Color_Maps(), and SUMA_process_environ(). |
|
|
|
Definition at line 59 of file lex.c. Referenced by exassign(), getcds(), popinclude(), and yylex(). |
|
Definition at line 70 of file lex.c. Referenced by contmax(), doinclude(), getcd(), getcds(), and popinclude(). |
|
Definition at line 99 of file lex.c. Referenced by crunch(). |
|
|