Annotation of OpenXM_contrib2/asir2018/parse/lex.c, Revision 1.6
1.1 noro 1: /*
2: * Copyright (c) 1994-2000 FUJITSU LABORATORIES LIMITED
3: * All rights reserved.
4: *
5: * FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited,
6: * non-exclusive and royalty-free license to use, copy, modify and
7: * redistribute, solely for non-commercial and non-profit purposes, the
8: * computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and
9: * conditions of this Agreement. For the avoidance of doubt, you acquire
10: * only a limited right to use the SOFTWARE hereunder, and FLL or any
11: * third party developer retains all rights, including but not limited to
12: * copyrights, in and to the SOFTWARE.
13: *
14: * (1) FLL does not grant you a license in any way for commercial
15: * purposes. You may use the SOFTWARE only for non-commercial and
16: * non-profit purposes only, such as academic, research and internal
17: * business use.
18: * (2) The SOFTWARE is protected by the Copyright Law of Japan and
19: * international copyright treaties. If you make copies of the SOFTWARE,
20: * with or without modification, as permitted hereunder, you shall affix
21: * to all such copies of the SOFTWARE the above copyright notice.
22: * (3) An explicit reference to this SOFTWARE and its copyright owner
23: * shall be made on your publication or presentation in any form of the
24: * results obtained by use of the SOFTWARE.
25: * (4) In the event that you modify the SOFTWARE, you shall notify FLL by
26: * e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification
27: * for such modification or the source code of the modified part of the
28: * SOFTWARE.
29: *
30: * THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL
31: * MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND
32: * EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS
33: * FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES'
34: * RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY
35: * MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY.
36: * UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT,
37: * OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY
38: * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL
39: * DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES
40: * ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES
41: * FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY
42: * DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF
43: * SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART
44: * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY
45: * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
46: * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
47: *
1.6 ! ohara 48: * $OpenXM: OpenXM_contrib2/asir2018/parse/lex.c,v 1.5 2020/10/06 06:45:37 noro Exp $
1.1 noro 49: */
50: #include <ctype.h>
51: #include "ca.h"
52: #include "al.h"
53: #include "base.h"
54: #include "parse.h"
55: #include <sys/types.h>
56: #include <sys/stat.h>
57: #if defined(VISUAL) || defined(__MINGW32__)
58: #include "ytab.h"
59: #else
60: #include "y.tab.h"
61: #endif
62: #if FEP
1.6 ! ohara 63: #include <editline/readline.h>
1.1 noro 64: #endif
65:
66: static int Getc();
67: static void Ungetc(int c);
68: static void Gets(char *s);
69: static int skipspace();
70:
71: extern INFILE asir_infile;
72: extern struct oTKWD kwd[];
73: extern Obj VOIDobj;
74:
75: extern int main_parser;
76: extern char *parse_strp;
77:
78: #define NBUFSIZ (BUFSIZ*10)
79: #define TBUFSIZ (BUFSIZ)
80:
81: #define REALLOC_NBUF \
82: if ( i >= nbufsize ) {\
83: nbufsize += NBUFSIZ;\
84: if ( nbuf == nbuf0 ) {\
85: nbuf = (char *)MALLOC_ATOMIC(nbufsize);\
86: bcopy(nbuf0,nbuf,nbufsize-NBUFSIZ);\
87: } else\
88: nbuf = REALLOC(nbuf,nbufsize);\
89: }
90:
91: #define REALLOC_TBUF \
92: if ( i >= tbufsize ) {\
93: tbufsize += TBUFSIZ;\
94: if ( tbuf == tbuf0 ) {\
95: tbuf = (char *)MALLOC_ATOMIC(tbufsize);\
96: bcopy(tbuf0,tbuf,tbufsize-TBUFSIZ);\
97: } else\
98: tbuf = REALLOC(tbuf,tbufsize);\
99: }
100:
101: #define READ_ALNUM_NBUF \
102: while ( 1 ) {\
103: c = Getc();\
104: if ( isalnum(c) ) {\
105: REALLOC_NBUF nbuf[i++] = c;\
106: } else\
107: break;\
108: }
109:
110: #define READ_DIGIT_NBUF \
111: while ( 1 ) {\
112: c = Getc();\
113: if ( isdigit(c) ) {\
114: REALLOC_NBUF nbuf[i++] = c;\
115: } else\
116: break;\
117: }
118:
119: int yylex()
120: {
121: #define yylvalp (&yylval)
122: int c,c1;
123: int *ptr;
124: char *cptr;
125: int d,i,j;
126: char nbuf0[NBUFSIZ],tbuf0[TBUFSIZ];
127: char *nbuf, *tbuf;
128: int nbufsize, tbufsize;
129: Z n,n1;
130: Q q;
131: Obj r;
132: int floatingpoint = 0;
133: double dbl;
134: Real real;
135: double atof();
136: extern int bigfloat;
137:
138:
139: /* initialize buffer pointers */
140: nbuf = nbuf0; tbuf = tbuf0;
141: nbufsize = NBUFSIZ; tbufsize = TBUFSIZ;
142:
143: switch ( c = skipspace() ) {
144: case EOF :
145: asir_terminate(2); break;
146: case '0' :
147: while ( ( c = Getc() ) == '0' );
148: if ( c == '.' ) {
149: Ungetc(c); c = '0';
150: } else if ( c == 'x' || c == 'X' ) {
151: for ( i = 0; i < 8; i++ )
152: nbuf[i] = '0';
153: READ_ALNUM_NBUF
154: Ungetc(c); REALLOC_NBUF nbuf[i] = 0;
155: hextoz(nbuf,&n1); r = (Obj)n1;
156: yylvalp->p = (pointer)r;
157: return ( FORMULA );
158: } else if ( c == 'b' || c == 'B' ) {
159: for ( i = 0; i < 32; i++ )
160: nbuf[i] = '0';
161: READ_ALNUM_NBUF
162: Ungetc(c); REALLOC_NBUF nbuf[i] = 0;
163: binarytoz(nbuf,&n1); r = (Obj)n1;
164: yylvalp->p = (pointer)r;
165: return ( FORMULA );
166: } else if ( !isdigit(c) ) {
167: yylvalp->p = 0; Ungetc(c);
168: return ( FORMULA );
169: }
170: break;
171: case '\'' :
172: for ( i = 0; ; i++ ) {
173: c = Getc();
174: if ( c == '\'' )
175: break;
176: if ( c == '\\' )
177: c = Getc();
178: REALLOC_TBUF tbuf[i] = c;
179: }
180: REALLOC_TBUF tbuf[i] = 0;
181: cptr = (char *)MALLOC(strlen(tbuf)+1); strcpy(cptr,tbuf);
182: yylvalp->p = (pointer)cptr;
183: return LCASE; break;
184: case '"' :
185: i = 0;
186: do {
187: c = Getc();
188: if ( c == '\n' ) asir_infile->ln++;
189: if ( c == '\\' ) {
190: c1 = Getc();
191: if ( c1 == 'n' ) {
192: c1 = '\n';
193: }else if ( c1 == 'r' ) {
194: c1 = '\r';
195: }else if ( c1 == 't' ) {
196: c1 = '\t';
197: }else if ( isdigit(c1) ){
198: d = c1 - '0';
199: c1 = Getc();
200: if ( isdigit(c1) ) {
201: d = 8*d + (c1 - '0');
202: c1 = Getc();
203: if ( isdigit(c1) ) {
204: d = 8*d + (c1 - '0');
205: }else {
206: Ungetc(c1);
207: }
208: }else {
209: Ungetc(c1);
210: }
211: c1 = d;
212: }
213: REALLOC_NBUF nbuf[i++] = c1;
214: } else {
215: REALLOC_NBUF nbuf[i++] = c;
216: }
217: } while ( c != '"' );
218: nbuf[i-1] = 0; /* REALLOC_NBUF is not necessary */
219: cptr = (char *)MALLOC(strlen(nbuf)+1);
220: strcpy(cptr,nbuf); yylvalp->p = (pointer) cptr;
221: return ( STR ); break;
222: case '>': case '<': case '=': case '!':
223: if ( (c1 = Getc()) == '=' )
224: switch ( c ) {
225: case '>': yylvalp->i = (int)C_GE; break;
226: case '<': yylvalp->i = (int)C_LE; break;
227: case '=': yylvalp->i = (int)C_EQ; break;
228: case '!': yylvalp->i = (int)C_NE; break;
229: default: break;
230: }
231: else if ( (c == '<' && c1 == '<') || (c == '>' && c1 == '>') )
232: return c;
233: else {
234: Ungetc(c1);
235: switch ( c ) {
236: case '>': yylvalp->i = (int)C_GT; break;
237: case '<': yylvalp->i = (int)C_LT; break;
238: default: return c; break;
239: }
240: }
241: return CMP; break;
242: case '+': case '-': case '*': case '/': case '%': case '^':
243: case '|': case '&':
244: switch ( c ) {
245: case '+': yylvalp->p = (pointer)addfs; break;
246: case '-': yylvalp->p = (pointer)subfs; break;
247: case '*': yylvalp->p = (pointer)mulfs; break;
248: case '/': yylvalp->p = (pointer)divfs; break;
249: case '%': yylvalp->p = (pointer)remfs; break;
250: case '^': yylvalp->p = (pointer)pwrfs; break;
251: default: break;
252: }
253: if ( (c1 = Getc()) == c )
254: switch ( c ) {
255: case '+': case '-': return SELF; break;
256: case '|': return OR; break;
257: case '&': return AND; break;
258: default: Ungetc(c1); return c; break;
259: }
260: else if ( c1 == '=' )
261: return BOPASS;
262: else if ( (c == '-') && (c1 == '>') )
263: return POINT;
264: else {
265: Ungetc(c1); return c;
266: }
267: break;
268: default :
269: break;
270: }
271: if ( isdigit(c) ) {
272: for ( i = 0; i < DLENGTH; i++ )
273: nbuf[i] = '0';
274: REALLOC_NBUF nbuf[i++] = c;
275: READ_DIGIT_NBUF
276: if ( c == '.' ) {
277: floatingpoint = 1;
278:
279: REALLOC_NBUF nbuf[i++] = c;
280: READ_DIGIT_NBUF
281: if ( c == 'e' || c == 'E' ) {
282: REALLOC_NBUF nbuf[i++] = c;
283: c = Getc();
284: if ( (c == '+') || (c == '-') ) {
285: REALLOC_NBUF nbuf[i++] = c;
286: } else
287: Ungetc(c);
288: READ_DIGIT_NBUF
289: }
290: } else if ( c == 'e' || c == 'E' ) {
291: floatingpoint = 1;
292: REALLOC_NBUF nbuf[i++] = c;
293: c = Getc();
294: if ( (c == '+') || (c == '-') ) {
295: REALLOC_NBUF nbuf[i++] = c;
296: } else
297: Ungetc(c);
298: READ_DIGIT_NBUF
299: }
300: Ungetc(c); REALLOC_NBUF nbuf[i] = 0;
301: if ( floatingpoint ) {
302: if ( !bigfloat ) {
303: dbl = (double)atof(nbuf+DLENGTH);
304: MKReal(dbl,real); r = (Obj)real;
305: } else
306: strtobf(nbuf,(BF *)&r);
307: } else {
308: mpz_t z;
309:
310: mpz_init(z);
311: mpz_set_str(z,nbuf,10);
312: MPZTOZ(z,n1); r = (Obj)n1;
313: }
314: yylvalp->p = (pointer)r;
315: return ( FORMULA );
316: } else if ( isalpha(c) || c == ':' || c == '_' ) {
317: if ( c == ':' ) {
318: c1 = Getc();
319: if ( c1 != ':' ) {
320: Ungetc(c1);
321: return c;
322: }
323: c1 = Getc();
324: if ( !isalpha(c1) ) {
325: Ungetc(c1);
326: return COLONCOLON;
327: }
328: i = 0;
329: tbuf[i++] = ':';
330: tbuf[i++] = ':';
331: tbuf[i++] = c1;
332: } else {
333: i = 0;
334: tbuf[i++] = c;
335: }
336: while ( 1 ) {
337: c = Getc();
338: if ( isalpha(c)||isdigit(c)||(c=='_')||(c=='.') ) {
339: REALLOC_TBUF tbuf[i++] = c;
340: } else
341: break;
342: }
343: REALLOC_TBUF tbuf[i] = 0; Ungetc(c);
344: if ( isupper(tbuf[0]) || (tbuf[0] == '_' && isupper(tbuf[1])) ) {
345: cptr = (char *)MALLOC(strlen(tbuf)+1); strcpy(cptr,tbuf);
346: yylvalp->p = (pointer)cptr;
347: return UCASE;
348: } else {
349: for ( i = 0; kwd[i].name && strcmp(tbuf,kwd[i].name); i++ );
350: if ( kwd[i].name ) {
351: yylvalp->i = asir_infile->ln;
352: return kwd[i].token;
353: } else {
354: cptr = (char *)MALLOC(strlen(tbuf)+1); strcpy(cptr,tbuf);
355: yylvalp->p = (pointer)cptr;
356: return LCASE;
357: }
358: }
359: } else if ( c == '@' ) {
360: if ( isdigit(c = Getc()) ) {
361: i = 0;
362: nbuf[i++] = c;
363: READ_DIGIT_NBUF
364: Ungetc(c); REALLOC_NBUF nbuf[i] = 0;
365: yylvalp->i = atoi(nbuf);
366: return ANS;
367: } else if ( c == '@' ) {
368: yylvalp->i = MAX(0,APVS->n-1);
369: return ANS;
370: } else if ( c == '>' || c == '<' || c == '=' || c == '!' ) {
371: if ( (c1 = Getc()) == '=' )
372: switch ( c ) {
373: case '>': yylvalp->i = (int)L_GE; break;
374: case '<': yylvalp->i = (int)L_LE; break;
375: case '=': yylvalp->i = (int)L_EQ; break;
376: case '!': yylvalp->i = (int)L_NE; break;
377: default: break;
378: }
379: else {
380: Ungetc(c1);
381: switch ( c ) {
382: case '>': yylvalp->i = (int)L_GT; break;
383: case '<': yylvalp->i = (int)L_LT; break;
384: case '=': yylvalp->i = (int)L_EQ; break;
385: case '!': yylvalp->i = (int)L_NOT; return FOP_NOT; break;
386: default: break;
387: }
388: }
389: return LOP;
390: } else if ( c == '|' || c == '&' ) {
391: if ( (c1 = Getc()) != c )
392: Ungetc(c1);
393: switch ( c ) {
394: case '|': yylvalp->i = (int)L_OR;
395: return FOP_OR; break;
396: case '&': yylvalp->i = (int)L_AND;
397: return FOP_AND; break;
398: }
399: } else if ( isalpha(c) ) {
400: i = 0;
401: tbuf[i++] = '@';
402: tbuf[i++] = c;
403: while ( 1 ) {
404: c = Getc();
405: if ( isalpha(c) ) {
406: REALLOC_TBUF tbuf[i++] = c;
407: } else
408: break;
409: }
410: Ungetc(c); REALLOC_TBUF tbuf[i] = 0;
411: if ( !strcmp(tbuf,"@p") )
412: return GFPNGEN;
413: else if ( !strcmp(tbuf,"@s") )
414: return GFSNGEN;
415: else if ( !strcmp(tbuf,"@void") ) {
416: yylvalp->p = VOIDobj;
417: return FORMULA;
418: } else if ( !strcmp(tbuf,"@i") ) {
419: extern pointer IU;
420:
421: yylvalp->p = IU;
422: return FORMULA;
423: } else if ( !strcmp(tbuf,"@true") ) {
424: yylvalp->p = F_TRUE;
425: return FORMULA;
426: } else if ( !strcmp(tbuf,"@false") ) {
427: yylvalp->p = F_FALSE;
428: return FORMULA;
429: } else if ( !strcmp(tbuf,"@impl") ) {
430: yylvalp->i = (int)L_IMPL;
431: return FOP_IMPL;
432: } else if ( !strcmp(tbuf,"@repl") ) {
433: yylvalp->i = (int)L_REPL;
434: return FOP_REPL;
435: } else if ( !strcmp(tbuf,"@equiv") ) {
436: yylvalp->i = (int)L_EQUIV;
437: return FOP_EQUIV;
438: } else if ( !strcmp(tbuf,"@grlex") ) {
439: yylvalp->p = Symbol_grlex;
440: return FORMULA;
441: } else if ( !strcmp(tbuf,"@glex") ) {
442: yylvalp->p = Symbol_glex;
443: return FORMULA;
444: } else if ( !strcmp(tbuf,"@lex") ) {
445: yylvalp->p = Symbol_lex;
446: return FORMULA;
447: } else {
448: cptr = (char *)MALLOC(strlen(tbuf)+1); strcpy(cptr,tbuf);
449: yylvalp->p = (pointer)cptr;
450: return LCASE;
451: }
452: } else {
453: Ungetc(c);
454: return GF2NGEN;
455: }
456: } else
457: return ( c );
1.4 noro 458: /* XXX */
459: return 0;
1.1 noro 460: }
461:
1.5 noro 462: /* for __fpurge() */
463: #if defined(linux)
464: #include <stdio_ext.h>
465: #endif
466:
1.1 noro 467: void purge_stdin()
468: {
1.2 fujimoto 469: #if defined(__FreeBSD__) || defined(__DARWIN__) || defined(ANDROID)
1.1 noro 470: fpurge(stdin);
471: #elif defined(linux)
1.3 fujimoto 472: // stdin->_IO_read_end = stdin->_IO_read_base;
473: // stdin->_IO_read_ptr = stdin->_IO_read_base;
474: __fpurge(stdin);
1.1 noro 475: #elif defined(VISUAL_LIB)
476: void w_purge_stdin();
477:
478: w_purge_stdin();
479: #elif defined(VISUAL) && _MSC_VER >= 1900
480: rewind(stdin);
481: #elif defined(sparc) || defined(__alpha) || defined(__SVR4) || defined(mips) || defined(VISUAL) || defined(__MINGW32__) || defined(_IBMR2)
482: stdin->_ptr = stdin->_base; stdin->_cnt = 0;
483: #elif (defined(__MACH__) && defined(__ppc__)) || defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__INTERIX)
484: stdin->_r = 0; stdin->_p = stdin->_bf._base;
485: #else
486: --->FIXIT
487: #endif
488: }
489:
490: static int skipspace() {
491: int c,c1;
492:
493: for ( c = Getc(); ; )
494: switch ( c ) {
495: case ' ': case '\t': case '\r':
496: c = Getc(); break;
497: case '\n':
498: c = afternl(); break;
499: case '/':
500: if ( (c1 = Getc()) == '*' )
501: c = aftercomment();
502: else {
503: Ungetc(c1); return c;
504: }
505: break;
506: default:
507: return c; break;
508: }
509: }
510:
511: int afternl() {
512: int c,ac,i,quote;
513: char *ptr,*buf0;
514: char *av[BUFSIZ];
515: static int ilevel = 0;
516: char buf[BUFSIZ];
517:
518: if ( !ilevel )
519: asir_infile->ln++;
520: while ( (c = Getc()) == '#' ) {
521: Gets(buf);
522: #define LINE "line"
523: if ( !strncmp(buf,LINE,strlen(LINE)) ) buf0 = buf+strlen(LINE);
524: else buf0 = buf;
525: for ( quote = 0, ptr = buf0; *ptr; ptr++ )
526: if ( *ptr == '"' )
527: quote = quote ? 0 : 1;
528: else if ( quote && (*ptr == ' ') )
529: *ptr = '_';
1.4 noro 530: stoarg(buf0,&ac,av);
531: if ( ac == 3 ) {
1.1 noro 532: if ( (i = atoi(av[2])) == 1 )
533: ilevel++;
534: else if ( i == 2 )
535: ilevel--;
1.4 noro 536: }
1.1 noro 537: if ( !ilevel )
538: asir_infile->ln = atoi(av[0]);
539: }
540: return c;
541: }
542:
543: int aftercomment() {
544: int c,c1;
545:
546: for ( c = Getc(); ; ) {
547: if ( c == '\n' ) asir_infile->ln++;
548: c1 = Getc();
549: if ( (c == '*') && (c1 == '/') )
550: return Getc();
551: else
552: c = c1;
553: }
554: }
555:
556: int myatoi(char *s)
557: {
558: int i,r;
559: for ( i = 0, r = 0; i < DLENGTH; i++ ) r = r * 10 + ( s[i] - '0' );
560: return ( r );
561: }
562:
563: extern int ox_do_copy;
564: extern int I_am_server;
565: extern JMP_BUF main_env;
566: extern int at_root;
567: extern LIST LastStackTrace;
568: extern char *CUR_FUNC;
569:
570: void yyerror(char *s)
571: {
572: STRING fname,name,kwd;
573: USINT u;
574: NODE t;
575: LIST l,l2;
576:
577: if ( main_parser ) {
578: if ( ox_do_copy ) {
579: /* push errors to DebugStack */
580: } else {
581: if ( asir_infile->fp == stdin )
582: fprintf(stderr,"%s\n",s);
583: else
584: fprintf(stderr,"\"%s\", near line %d: %s\n",asir_infile->name,asir_infile->ln,s);
585: }
586: if ( I_am_server ) {
587: if ( NEXT(asir_infile) ) {
588: /* error in a file; record the position */
589: MKSTR(fname,asir_infile->name);
590: if ( CPVS == GPVS )
591: MKSTR(name,"");
592: else
593: MKSTR(name,CUR_FUNC);
594: MKUSINT(u,asir_infile->ln);
595: t = mknode(3,fname,name,u); MKLIST(l,t);
596: /* line number at the toplevel */
597: MKSTR(fname,"toplevel"); MKUSINT(u,at_root);
598: t = mknode(2,fname,u); MKLIST(l2,t);
599: t = mknode(2,l2,l);
600: } else {
601: MKSTR(fname,"toplevel"); MKUSINT(u,asir_infile->ln);
602: t = mknode(2,fname,u); MKLIST(l,t);
603: t = mknode(1,l);
604: }
605: MKLIST(l,t);
606: MKSTR(kwd,"asir_where"); t = mknode(2,kwd,l);
607: MKLIST(LastStackTrace,t);
608: set_lasterror(s);
609: LONGJMP(main_env,1);
610: }
611: } else
612: fprintf(stderr,"exprparse : %s\n",s);
613: }
614:
615: int echoback;
616:
617: extern int do_fep, do_file;
618:
619: unsigned char encrypt_char(unsigned char);
620: unsigned char decrypt_char(unsigned char);
621:
622: int Egetc(FILE *fp)
623: {
624: int c;
625:
626: if ( fp ) {
627: #if FEP
628: if ( do_fep && isatty(fileno(fp)) )
629: c = readline_getc();
630: else
631: #endif
632: c = getc(fp);
633: #if defined(VISUAL) || defined(__MINGW32__)
634: check_intr();
635: #endif
636: if ( c == EOF )
637: return c;
638: if ( asir_infile->encoded )
639: c = decrypt_char((unsigned char)c);
640: return c;
641: } else {
642: c = *parse_strp++;
643: if ( !c )
644: return EOF;
645: else
646: return c;
647: }
648: }
649:
650: void Eungetc(int c,FILE *fp)
651: {
652: if ( fp ) {
653: if ( asir_infile->encoded )
654: c = (int)encrypt_char((unsigned char)c);
655: #if FEP
656: if ( do_fep && isatty(fileno(fp)) )
657: readline_ungetc();
658: else
659: #endif
660: ungetc(c,fp);
661: } else
662: *--parse_strp = c;
663: }
664:
665: static int Getc() {
666: int c;
667:
668: if ( main_parser ) {
669: while ( 1 ) {
670: if ((c = Egetc(asir_infile->fp)) == EOF)
671: if ( NEXT(asir_infile) ) {
672: closecurrentinput();
673: /* if the input is the top level, generate error */
674: if ( !NEXT(asir_infile) )
675: error("end-of-file detected during parsing");
676: else
677: c = Getc();
678: break;
679: } else if ( asir_infile->fp || do_file ) {
680: if ( asir_infile->fp )
681: clearerr(asir_infile->fp);
682: asir_terminate(2);
683: } else {
684: error("end-of-line detected during parsing");
685: }
686: else
687: break;
688: }
689: if ( echoback )
690: fputc(c,asir_out);
691: } else
692: c = *parse_strp++;
693: return ( c );
694: }
695:
696: static void Ungetc(int c) {
697: if ( main_parser ) {
698: Eungetc(c,asir_infile->fp);
699: if ( echoback )
700: fputc('',asir_out);
701: } else
702: *--parse_strp = c;
703: }
704:
705: static void Gets(char *s)
706: {
707: int c;
708:
709: while ( (c = Getc()) != '\n' )
710: *s++ = c;
711: *s = 0;
712: }
713:
714: #if FEP
715:
716: static char *readline_line;
717: static int readline_nc,readline_index;
718: char *readline_console();
719:
720: int readline_getc()
721: {
722: char buf[BUFSIZ];
723:
724: if ( !readline_nc ) {
725: if ( readline_line )
726: free(readline_line);
727: sprompt(buf);
728: readline_line = readline_console(buf);
729: readline_nc = strlen(readline_line);
730: readline_index = 0;
731: }
732: readline_nc--;
733: return readline_line[readline_index++];
734: }
735:
736: void readline_ungetc()
737: {
738: readline_nc++; readline_index--;
739: }
740:
741: char *readline_console(char *prompt)
742: {
743: char *line;
744: int exp_result;
745: char *expansion;
746:
747: while ( 1 ) {
748: line = (char *)readline(prompt);
749: if ( line && *line ) {
750: using_history();
751: exp_result = history_expand(line,&expansion);
752: if ( !exp_result ) {
753: free(expansion);
754: for ( ; isspace((unsigned char)*line); line++ );
755: add_history(line);
756: break;
757: } else if ( exp_result > 0 ) {
758: free(line);
759: line = expansion;
760: break;
761: }
762: }
763: }
764: return line;
765: }
766: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to lex.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2018 / parse