Annotation of capa/capa51/pProj/capaLexerDef.flex, revision 1.10
1.9 albertel 1: /* main CAPA lexer
2: Copyright (C) 1992-2000 Michigan State University
3:
4: The CAPA system is free software; you can redistribute it and/or
5: modify it under the terms of the GNU Library General Public License as
6: published by the Free Software Foundation; either version 2 of the
7: License, or (at your option) any later version.
8:
9: The CAPA system is distributed in the hope that it will be useful,
10: but WITHOUT ANY WARRANTY; without even the implied warranty of
11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12: Library General Public License for more details.
13:
14: You should have received a copy of the GNU Library General Public
15: License along with the CAPA system; see the file COPYING. If not,
16: write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
1.10 ! albertel 17: Boston, MA 02111-1307, USA.
! 18:
! 19: As a special exception, you have permission to link this program
! 20: with the TtH/TtM library and distribute executables, as long as you
! 21: follow the requirements of the GNU GPL in regard to all of the
! 22: software in the executable aside from TtH/TtM.
! 23: */
1.9 albertel 24:
1.1 albertel 25: /*------------------------------------------------------------------------*/
26: /* capaLexerDef.flex created by Isaac Tsai Jul 15 1996 */
27: /* added /END(variable) */
28: /* added /HIN .... /DIS(variable) ... */
29: /* Jan 15 1998 /{KeyWord}{KeyWord}{KeyWord} */
30: /* replaced by /DIS */
31: /* catch "No /END() statement found" */
32: /* catch "/DIS(")" and "/DIS(""")" errors " */
33: /* catch "/LET var = " */
34: /* add a new token EoL to indicate '\n' '\r''\n' and '\r' */
35: /* This file is based on flex 2.5.3, flex 2.3 apparantly cannot take it :-( */
36: /* DONE /RMAP() function July 14, 1998 */
37: /* DONE /AND /OR answer formats July 20, 1998 */
38: /* DONE /IF () /ENDIF July 26, 1998 */
39: /* DONE /WHILE () /ENDWHILE August 10 1998 */
40: /* DONE /VERB /ENDVERB Feb 20 1998 */
41: /*------------------------------------------------------------------------*/
42: /**************************************************************************/
43:
44: %{
45:
46: #include <stdio.h>
47: #include <stdlib.h> /* strtod(), strtol() */
48: #include <string.h>
49: #ifdef NeXT
50: #include <sys/file.h>
51: #else
52: #include <unistd.h> /* access() */
53: #endif
54:
1.8 albertel 55: #define YYSTYPE Symbol*
1.1 albertel 56: #include "capaCommon.h" /* capa_access() */
57: #include "capaParser.h" /* _symbol structure def */
1.8 albertel 58: #include "capaToken.h" /* from YACC -d capaGrammarDef.y */
1.1 albertel 59: #include "lex_debug.h" /* defined RETURN(xxx) macro */
60:
61:
62:
63: /* ============================================== begin of code */
64:
65: #define LEX_BUFLEN (8*1024) /* lexical buffer size (for each opened file) */
66:
67: #ifdef YYLMAX
68: #undef YYLMAX
69: #define YYLMAX 8192
70: #endif
71:
72: void yyfatalerror(char*msg);
73: #define YY_FATAL_ERROR yyfatalerror
74:
75: #ifdef LEX_DBUG
76: #define LLDBUG_PRL1(xx) { printf("Line %d ",Current_line[Input_idx]); printf(xx); fflush(stdout); }
77: #define LLDBUG_PRL2(xx,yy) { printf("Line %d ",Current_line[Input_idx]); printf(xx,yy); fflush(stdout); }
78: #define LLDBUG_PR1(xx) { printf(xx); fflush(stdout); }
79: #define LLDBUG_PR2(xx,yy) { printf(xx,yy); fflush(stdout); }
80: #define LLDBUG_PR3(xx,yy,zz) { printf(xx,yy,zz); fflush(stdout); }
81: #else
82: #define LLDBUG_PRL1(xx) { }
83: #define LLDBUG_PRL2(xx,yy) { }
84: #define LLDBUG_PR1(xx) { }
85: #define LLDBUG_PR2(xx,yy) { }
86: #define LLDBUG_PR3(xx,yy,zz) { }
87: #endif
88:
89: #ifdef LEX_INPUT_DBUG
90: #define LIDBUG_PR1(xx) { printf(xx); fflush(stdout); }
91: #define LIDBUG_PR2(xx,yy) { printf(xx,yy); fflush(stdout); }
92: #define LIDBUG_PR3(xx,yy,zz) { printf(xx,yy,zz); fflush(stdout); }
93: #else
94: #define LIDBUG_PR1(xx) { }
95: #define LIDBUG_PR2(xx,yy) { }
96: #define LIDBUG_PR3(xx,yy,zz) { }
97: #endif
98:
99: #ifdef USE_DYNAMIC_SYMBOLS
100: #define USE_DYNAMIC_LEXBUFS
101: #endif
102:
103: Symbol *yylval; /* global pointer to symbol */
104:
105: FILE *(Input_stream[MAX_OPENED_FILE]); /* <-- perhaps we can use linked list */
106: char Opened_filename[MAX_OPENED_FILE][QUARTER_K]; /* <-- perhaps we can use linked list */
107: int Input_idx;
108: int Lexi_pos[MAX_OPENED_FILE]; /* Current position in the line */
109:
110: #ifdef USE_DYNAMIC_LEXBUFS
111: char *(Lexi_buf[MAX_OPENED_FILE]); /* Line Buffer for current file */
112:
113: #else
114: char Lexi_buf[MAX_OPENED_FILE][LEX_BUFLEN+4]; /* Line Buffer for current file */
115:
116: #endif /* USE_DYNAMIC_LEXBUFS */
117:
118: char String_buf[LEX_BUFLEN]; /* Constant String buffer <-- perhaps we can use char pointer */
119: char *Dynamic_buf;
120: int Dynamic_buf_max;
121: int Dynamic_buf_cur;
122:
123:
124: static int End_of_input;
125: static int Pcount, Bcount; /* static means only available in this file */
126: /* --------------------------------------------------------------------------- */
127: /* GLOBAL VARIABLES */
128: /* --------------------------------------------------------------------------- */
129: int Lexi_line; /* Current source file line number, counting from beginning */
130: extern int Current_line[MAX_OPENED_FILE];
131:
132: int Func_idx;
133: Symbol FuncStack[MAX_FUNC_NEST]; /* <-- perhaps we can use linked list */
134:
135: int Array_idx;
136: Symbol *ArraySymbList_p;
137: Symbol *ArraySymbLast_p;
138: Symbol *FmlSymbList_p;
139: Symbol *FmlSymbLast_p;
140: int FmlSymb_cnt;
141: int Symb_count;
142:
143: int IFstatus[MAX_FUNC_NEST]; /* <-- perhaps we can use linked list */
144: int IFcurrent[MAX_FUNC_NEST]; /* <-- perhaps we can use linked list */
145: int IFcount;
146: WhileLoop_t WhileStack[MAX_FUNC_NEST]; /* <-- perhaps we can use linked list */
147: int While_idx, Wcount;
148:
149: #ifdef USE_DYNAMIC_SYMBOLS
150: Symbol *SymbList_p;
151: Symbol *SymbLast_p;
152: #else
153: Symbol SymbArray[MAX_SYMB_COUNT];
154: #endif /* USE_DYNAMIC_SYMBOLS */
155:
156:
157: char *Current_char_p; /* Collect string constant */
158: extern char *EndText_p;
159: extern char *StartText_p;
160: extern Problem_t *LexiProblem_p;
161: extern Problem_t *LastProblem_p;
162: int first_run=1;
163: int Stop_Parser;
164: #define FLEX
165:
166: #define YY_STACK_USED 1 /* for yy_push_state(), yy_pop_state() */
167:
168: #ifdef FLEX
169:
170: int capaL_unput();
171: int capaL_input();
172:
173:
174: /* YY_INPUT()
175: Controls scanner input. By default, YY_INPUT reads from the
176: file-pointer yyin. Its action is to place up to max_size
177: characters in the character array buf and return in the
178: integer variable result either the number of characters read
179: or the constant YY_NULL to indicate EOF.
180: max_size is defined to be num_to_read = 8192 in liby
181: Following is a sample
182: redefinition of YY_INPUT, in the definitions section of
183: the input file:
184:
185: %{
186: #undef YY_INPUT
187: #define YY_INPUT(buf,result,max_size)\
188: {\
189: int c = getchar();\
190: result = (c == EOF) ? YY_NULL : (buf[0] = c, 1);\
191: }
192: %}
193:
194: */
195:
196: /* fgets() reads the input stream until
197: n-1 bytes have been read OR
198: a newline character is read and transferred to string OR
199: an EOF (End-of-File) condition is encountered
200:
201: The string is then terminated with a NULL character.
202:
203: ii = fseek(FILE *stream,0L,SEEK_END) ;
204: if(ii!=0) { error }
205: leng = ftell(FILE *stream) + 1 ;
206: fseek(FILE *stream,0L,SEEK_SET) ;
207: Lexi_buf[Input_idx] = (char *)capa_malloc(sizeof(char)*leng,1);
208:
209: */
210:
211:
212: #ifdef AVOIDYYINPUT
213: #define MAX_INCLUDE_DEPTH 10
214: YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
215: int include_stack_ptr = 0;
216: #else
217: #ifdef USE_DYNAMIC_LEXBUFS
218: #define NEWYYINPUT
219: #endif
220:
221: #ifdef NEWYYINPUT
222: void newyy_input (char *buf,int *result,int max_size);
223: #define YY_INPUT(buf,result,max_size) newyy_input(buf,&result,max_size)
224:
225: #else
226: #ifdef USE_DYNAMIC_LEXBUFS
227:
228: #define YY_INPUT(buf,result,max_size) \
229: { int ii, leng, out_of_char; \
230: if (!Lexi_line) { /* was startup */ \
231: for(ii=0;ii < MAX_OPENED_FILE;ii++) { \
232: Lexi_buf[ii] = NULL; \
233: Lexi_pos[ii] = 0; \
234: Current_line[ii] = 0; \
235: } \
236: Input_idx = 0; \
237: first_run=0; \
238: yyin = Input_stream[Input_idx]; LIDBUG_PR1("<<yy_input() startup>>\n"); \
239: } \
240: out_of_char = 0; \
241: if ( Lexi_buf[Input_idx] == NULL ) { \
242: Lexi_buf[Input_idx] = (char *)capa_malloc(sizeof(char)*LEX_BUFLEN+1,1); out_of_char=1; \
243: } else { \
244: if (!Lexi_buf[Input_idx][Lexi_pos[Input_idx]]) { /* test if the line buffer is empty or at the end */ \
245: out_of_char=1; \
246: } \
247: } \
248: if( out_of_char ) { \
249: if (fgets(Lexi_buf[Input_idx],LEX_BUFLEN-1,Input_stream[Input_idx])==NULL) { /* read in one line */ \
250: LIDBUG_PR2("<<yy_input() fgets() returns NULL, input index=%d>>\n",Input_idx); \
251: if( (Input_idx > 0) && ( Lexi_buf[Input_idx][Lexi_pos[Input_idx]] == '\0') ) { \
252: LIDBUG_PR2("<<yy_input() close an input stream, input index=%d>>\n",Input_idx); \
253: fclose(Input_stream[Input_idx]); \
254: capa_mfree((char *)Lexi_buf[Input_idx]); \
255: Lexi_buf[Input_idx] = NULL; \
256: Input_idx--; \
257: yyin = Input_stream[Input_idx]; \
258: /* (Lexi_pos[Input_idx])++; */ \
259: buf[0] = Lexi_buf[Input_idx][Lexi_pos[Input_idx]-1]; \
260: result = 1; \
261: } else { \
262: result = YY_NULL; /* End of File */ \
263: } \
264: } else { /* successfully read in one line */ \
265: if (Lexi_buf[Input_idx]==NULL) puts("Whatup?");\
266: leng = strlen(Lexi_buf[Input_idx]); \
267: LIDBUG_PR3("<<yy_input() read into buffer a line(leng=%d), input index=%d>>\n",leng,Input_idx); \
268: Lexi_pos[Input_idx] = 0; \
269: Lexi_line++; \
270: Current_line[Input_idx]++; \
271: (Lexi_pos[Input_idx])++; \
272: buf[0] = Lexi_buf[Input_idx][Lexi_pos[Input_idx]-1]; \
273: /* need to take care of return continuation conditions */ \
274: /* so, we return to one-char-at-a-time approach */ \
275: /* for(ii=0;ii<leng;ii++) { */ \
276: /* buf[ii] = Lexi_buf[Input_idx][ii]; */ \
277: /* } */ \
278: /* buf[ii] = '\0'; */ \
279: /* printf("YY_INPUT()(Lexi_line=%d,max size=%d)(%c)",Lexi_line,max_size,buf[0]); */ \
280: result = 1; \
281: } \
282: } else { \
283: /* LIDBUG_PR2("<<yy_input() increase Lexi_pos, input index=%d>>\n",Input_idx); */ \
284: (Lexi_pos[Input_idx])++; \
285: buf[0] = Lexi_buf[Input_idx][Lexi_pos[Input_idx]-1]; \
286: result = 1; \
287: } \
288: if (Stop_Parser==1) { \
289: result = YY_NULL; \
290: } \
291: }
292:
293: #else
294:
295: #define YY_INPUT(buf,result,max_size) \
296: { int ii, leng; \
297: if (!Lexi_line) { /* was startup */ \
298: for(ii=0;ii < MAX_OPENED_FILE;ii++) { \
299: Lexi_buf[ii][0]=0; \
300: Lexi_pos[ii] = 0; \
301: Current_line[ii] = 0; \
302: } \
303: Input_idx = 0; \
304: first_run=0; \
305: yyin = Input_stream[Input_idx]; LIDBUG_PR1("<<yy_input() startup>>\n"); \
306: } \
307: if (!Lexi_buf[Input_idx][Lexi_pos[Input_idx]]) { /* test if the line buffer is empty or at the end */ \
308: if (fgets(Lexi_buf[Input_idx],LEX_BUFLEN-1,Input_stream[Input_idx])==NULL) { /* read in one line */ \
309: LIDBUG_PR2("<<yy_input() fgets() returns NULL, input index=%d>>\n",Input_idx); \
310: if( (Input_idx > 0) && ( Lexi_buf[Input_idx][Lexi_pos[Input_idx]] == '\0') ) { \
311: LIDBUG_PR2("<<yy_input() close an input stream, input index=%d>>\n",Input_idx); \
312: fclose(Input_stream[Input_idx]); \
313: Input_idx--; \
314: yyin = Input_stream[Input_idx]; \
315: /* (Lexi_pos[Input_idx])++; */ \
316: buf[0] = Lexi_buf[Input_idx][Lexi_pos[Input_idx]-1]; \
317: result = 1; \
318: } else { \
319: result = YY_NULL; /* End of File */ \
320: } \
321: } else { /* successfully read in one line */ \
322: leng = strlen(Lexi_buf[Input_idx]); \
323: LIDBUG_PR3("<<yy_input() read into buffer a line(leng=%d), input index=%d>>\n",leng,Input_idx); \
324: Lexi_pos[Input_idx] = 0; \
325: Lexi_line++; \
326: Current_line[Input_idx]++; \
327: (Lexi_pos[Input_idx])++; \
328: buf[0] = Lexi_buf[Input_idx][Lexi_pos[Input_idx]-1]; \
329: /* need to take care of return continuation conditions */ \
330: /* so, we return to one-char-at-a-time approach */ \
331: /* for(ii=0;ii<leng;ii++) { */ \
332: /* buf[ii] = Lexi_buf[Input_idx][ii]; */ \
333: /* } */ \
334: /* buf[ii] = '\0'; */ \
335: /* printf("YY_INPUT()(Lexi_line=%d,max size=%d)(%c)",Lexi_line,max_size,buf[0]); */ \
336: result = 1; \
337: } \
338: } else { \
339: /* LIDBUG_PR2("<<yy_input() increase Lexi_pos, input index=%d>>\n",Input_idx); */ \
340: (Lexi_pos[Input_idx])++; \
341: buf[0] = Lexi_buf[Input_idx][Lexi_pos[Input_idx]-1]; \
342: result = 1; \
343: } \
344: if (Stop_Parser==1) { \
345: result = YY_NULL; \
346: } \
347: }
348: #endif /* USE_DYNAMIC_LEXBUFS */
349: #endif /*NEWYYINPUT*/
350: #endif /*AVOIDYYINPUT*/
351:
352: #else
353:
354: #undef input
355: #undef unput
356:
357: #endif
358:
359: int capa_eof();
360: %}
361:
362: Alpha [a-zA-Z_]
363: KeyChar [A-Z]
364: AlphaNum [a-zA-Z_0-9]
365: Number [0-9]
366: HexNumber [0-9a-fA-F]
367: Space [ \t]
368: Spaces ({Space}*)
369: FileName (\"[^"\n]*\")
370: Qchar ([0-9a-zA-Z \t!?\._,:;'"`~@#$%\^&\+\-\*=|\[\]{}()])
371: Operator ([=\+\-\*/%<>!&|,])
372: Identifier ([a-zA-Z_][a-zA-Z_0-9]*)
373: EndLine ([\r][\n]|[\n])
374:
375: %a 10500
376: %o 15000
377: %k 10000
378: %p 10000
379: %n 1000
1.6 albertel 380: %x S_COMMENT S_HINT S_HINTEXLAINX S_IMPORT S_EXPLAIN S_ENDX S_UNIT S_IGNORE
381: %x S_SKIP S_VARIABLE S_LET S_DEFINE S_TEXT S_MAP S_FIGURE S_ANSWER
382: %x S_STRING S_ANSCONTINUE S_TRUE_FALSE_STMT S_IF_SKIP S_WHILE_SKIP
383: %x S_NEXT_LINE S_RANDOMORDER S_VERB
1.1 albertel 384: %array
385:
386:
387:
388: %%
389:
390: <S_IGNORE>{
391: {EndLine} BEGIN S_IGNORE;
392: [^\n]*$ BEGIN S_IGNORE;
393: <<EOF>> {
394: capa_eof();
395: #ifndef AVOIDYYINPUT
396: yyterminate();
397: #endif
398: }
399: }
400:
401: <S_COMMENT>[^\n]*{EndLine} BEGIN S_TEXT;
402:
403: <S_TEXT>{
404: ^{Spaces}"/LET" |
405: ^{Spaces}"/BEG" { LLDBUG_PRL1("[LET]"); Pcount = 0; init_funcstack(); BEGIN S_LET; RETURN(CAPA_LET); }
406: ^{Spaces}"/VERB" {
407: LLDBUG_PRL1("[VERBATIM]");
1.2 albertel 408: Dynamic_buf = (char *)capa_malloc(sizeof(char),10);
409: Dynamic_buf_max = 10;
1.1 albertel 410: Dynamic_buf_cur = 0;
411: Dynamic_buf[0] = '\0';
412: BEGIN S_VERB;
413: }
414: ^{Spaces}"/HIN"{Alpha}*{Spaces} { LLDBUG_PRL1("[HIN]"); Current_char_p = String_buf; BEGIN S_HINT; }
415: ^{Spaces}"/EXP"{Alpha}*{Spaces} { LLDBUG_PRL1("[EXP]"); Current_char_p = String_buf; BEGIN S_EXPLAIN; }
416: ^{Spaces}"/IMP"{Alpha}*{Space}+ { LLDBUG_PRL1("[IMP]"); BEGIN S_IMPORT; }
417: ^{Spaces}"/END" { LLDBUG_PRL1("[END]");
418: if ( (LexiProblem_p !=NULL) &&
419: (LexiProblem_p->question != NULL) &&
420: (LexiProblem_p->ans_type == 0)) {
421: EndText_p=strsave(LexiProblem_p->question);
422: free_problems(LexiProblem_p);
423: LexiProblem_p=NULL;
424: } else {
425: EndText_p=NULL;
426: }
427: End_of_input = 1; BEGIN S_IGNORE;RETURN(CAPA_END);
428: }
429: ^{Spaces}"/START"[^\n]* { LLDBUG_PRL1("[START]");
430: if (LexiProblem_p !=NULL &&
431: LexiProblem_p->question != NULL) {
432: StartText_p=strsave(LexiProblem_p->question);
433: } else {
434: StartText_p=NULL;
435: }
436: BEGIN S_TEXT;
437: RETURN(CAPA_START);
438: }
439:
440: ^{Spaces}"/END"{Spaces}[\(]{Spaces} { LLDBUG_PRL1("[END()]"); BEGIN S_ENDX; }
441: ^"/DEF" { Bcount = 0; BEGIN S_DEFINE; RETURN(CAPA_DEF); }
442: ^{Spaces}"/ANS" { LLDBUG_PRL2("[ANS(%s)]",yytext); Pcount = 0; BEGIN S_ANSWER; RETURN(CAPA_ANS); }
443: ^{Spaces}"/SUBJECTIVE" { LLDBUG_PRL1("[SUBJECTIVE ANSWER]"); Pcount = 0; BEGIN S_ANSWER; RETURN(CAPA_SUBJ); }
444: ^{Spaces}"/MAP" { LLDBUG_PRL1("[MAP]"); Pcount = 0; BEGIN S_MAP; RETURN(CAPA_MAP); }
445: ^{Spaces}"/RMAP" { LLDBUG_PRL1("[RMAP]"); Pcount = 0; BEGIN S_MAP; RETURN(CAPA_RMAP); }
446: ^{Spaces}"/RQO"{Spaces}* { LLDBUG_PRL1("[RQO]"); BEGIN S_RANDOMORDER;
447: RETURN(CAPA_RQO);}
448: ^{Spaces}"/ENDWHILE"([^\n])* { long int file_pos;
449: int top_item, input_idx;
450: LLDBUG_PRL2("[ENDWHILE While_idx=<%d>]\n",While_idx);
451:
452: top_item = While_idx - 1;
453: if( top_item < 0 ) { /* strange things must have happened here! */
454:
455: } else {
456: input_idx = WhileStack[top_item].input_idx;
457: file_pos = WhileStack[top_item].pos_idx;
458: Current_line[input_idx] = WhileStack[top_item].line_idx;
459: Lexi_pos[input_idx] = 0;
460: fseek(Input_stream[input_idx],file_pos,SEEK_SET);
461: fgets(Lexi_buf[input_idx],LEX_BUFLEN-1,Input_stream[input_idx]);
462: While_idx--;
463: }
464: BEGIN S_TEXT;
465: }
466: "/WHILE" |
467: ^{Spaces}"/WHILE" { long int file_pos;
468: int leng;
469: LLDBUG_PRL2("[WHILE While_idx=<%d>]\n",While_idx);
470: leng = strlen(Lexi_buf[Input_idx]); /* length of current line */
471: /* <-- because we use fgets() to read input,
472: thus ftell() will give the starting position of next line */
473: WhileStack[While_idx].input_idx = Input_idx;
474: file_pos = ftell(Input_stream[Input_idx]);
475: file_pos -= leng; /* calibrate the current line length */
476: WhileStack[While_idx].pos_idx = file_pos; /* begin of current line */
477: WhileStack[While_idx].line_idx = Current_line[Input_idx];
478: While_idx++; /* advance the stack pointer */
479:
480: BEGIN S_TRUE_FALSE_STMT; RETURN(CAPA_WHILE);
481:
482: }
483: ^{Spaces}"/IF" { IFcount++; IFcurrent[IFcount] = RUN_IF_PORTION;
484: LLDBUG_PRL2("[IF <IFcount=%d>]",IFcount); BEGIN S_TRUE_FALSE_STMT; RETURN(CAPA_IF); }
485: ^{Spaces}"/ELSE"([^\n])* { LLDBUG_PRL2("[ELSE <IFcount=%d>]\n",IFcount);
486: IFcurrent[IFcount] = RUN_ELSE_PORTION;
487: if( IFstatus[IFcount] == IF_TRUE ) {
488: LLDBUG_PRL1("[ELSE begin Skip]\n");
489: BEGIN S_IF_SKIP;
490: }
491: }
492: ^{Spaces}"/ENDIF"([^\n])* { IFcount--; LLDBUG_PRL2("[ENDIF <IFcount=%d>]\n",IFcount);
493: }
494: "/AND" { LLDBUG_PRL1("[AND]"); BEGIN S_ANSCONTINUE; RETURN(ANS_AND); }
495: "/DIS" { /* since S_VARIABLE treat {Space} as null, so here we do not match ( */
496: /* so that between /DIS and ( can have as many {Space} as we want */
497: LLDBUG_PR1("[DIS<]");
498: init_funcstack();
499: Pcount = 0; BEGIN S_VARIABLE;
500: RETURN(CAPA_VAR);
501: }
502: "/OR" { LLDBUG_PRL1("[OR]"); BEGIN S_ANSCONTINUE; RETURN(ANS_OR); }
503: {EndLine} { LLDBUG_PR1("[EoL within S_TEXT]\n"); /* end of the whole text line */
504: RETURN(EoL); }
505: [\\]{Space}*{EndLine} { LLDBUG_PR2("[\\EoL continue](%s)",yytext); /* continuation on next line */ }
506: ^{Spaces}"//"[^\n]*$ { LLDBUG_PRL2("[COMMENT<%s>]\n",yytext); BEGIN S_COMMENT; }
507: [^/\n\\]+$ |
508: [/] |
509: [\\] { yylval = (Symbol *) capa_malloc(1, sizeof(Symbol));
510: yylval->s_str = strsave(yytext);
511: LLDBUG_PR2("[TEXT_LINE<%s>]",yytext);
512: RETURN(TEXT_LINE);
513: }
514: ([^/\n])+[/] |
515: ([^/\n])+[\\] { /* matches anything until a '/' or a '\' */
516: LLDBUG_PR2("[TEXT_LINE( )<%s>]",yytext);
517:
518: yyless(yyleng-1); /* push back the last char */
519: yylval = (Symbol *) capa_malloc(1, sizeof(Symbol));
520: yylval->s_str = strsave(yytext);
521:
522: BEGIN S_TEXT;
523: RETURN(TEXT_LINE);
524: }
525: <<EOF>> {
526: #ifdef AVOIDYYINPUT
527: char warn_msg[ONE_K];
528:
529: if ( (--include_stack_ptr < 0) || Stop_Parser) {
530: if (Stop_Parser) {
531: if ( LexiProblem_p!=NULL &&
532: LexiProblem_p->question != NULL)
533: EndText_p=strsave(LexiProblem_p->question);
534: while (include_stack_ptr >= 0) {
535: yy_delete_buffer( YY_CURRENT_BUFFER );
536: yy_switch_to_buffer(
537: include_stack[include_stack_ptr]);
538: --include_stack_ptr;
539: }
540: } else {
541: sprintf(warn_msg,
542: "at End-of-File, a /END is needed.\n");
543: capa_msg(MESSAGE_ERROR,warn_msg);
544: }
545: free_problems(LexiProblem_p);
546: LexiProblem_p=NULL;
547: yyterminate();
548: } else {
549: yy_delete_buffer( YY_CURRENT_BUFFER );
550: yy_switch_to_buffer(include_stack[include_stack_ptr]);
551: }
552: #else
553: char warn_msg[ONE_K];
554: if (!Stop_Parser) {
555: sprintf(warn_msg,"at End-of-File, a /END is needed.\n");
556: capa_msg(MESSAGE_ERROR,warn_msg);
557: } else {
558: if (LexiProblem_p != NULL &&
559: LexiProblem_p->question != NULL)
560: EndText_p=strsave(LexiProblem_p->question);
561: }
562: capa_eof();
563: yyterminate();
564: #endif
565: }
566: }
567:
568:
569: <S_ENDX>{
570: {Alpha}{AlphaNum}* { /* DONE: add codes to handle /END() */
571: char *question_end=NULL;
572: End_of_input = 1;
573: if (EndText_p!=NULL) capa_mfree((char*)EndText_p);
574: if ((LexiProblem_p!=NULL) &&
575: (LexiProblem_p->question != NULL) &&
576: (LexiProblem_p->ans_type == 0)) {
577: question_end=strsave(LexiProblem_p->question);
578: }
579: if( yyleng > 0 ) {
580:
581: LLDBUG_PRL2("[END()<%s>]\n",yytext);
582: yylval = find_identifier(yytext);
583:
584: switch(yylval->s_type) {
585: case IDENTIFIER:
586: case I_VAR: case I_CONSTANT:
587: case R_VAR: case R_CONSTANT:
588: break;
589: case S_VAR: case S_CONSTANT:
590: EndText_p = strsave(yylval->s_str);
591: if (question_end) {
592: int leng; char *new_end;
593: leng = strlen(EndText_p) +
594: strlen(question_end) + 1;
595: new_end = capa_malloc(sizeof(char), leng);
596: strcat(new_end, question_end);
597: strcat(new_end, EndText_p);
598: capa_mfree(EndText_p);
599: capa_mfree(question_end);
600: EndText_p=new_end;
601: }
602: break;
603: default: break;
604: }
605: }
606: BEGIN S_IGNORE; RETURN(CAPA_END);
607: }
608: {Space}* { /* ignore spaces */ }
609: [\)] { /* a right paren */
610: if ( (LexiProblem_p != NULL) &&
611: (LexiProblem_p->question != NULL) &&
612: (LexiProblem_p->ans_type == 0)) {
613: EndText_p=strsave(LexiProblem_p->question);
614: } else {
615: EndText_p=NULL;
616: }
617: BEGIN S_IGNORE;
618: RETURN(CAPA_END);
619: }
620: }
621:
622: <S_HINT,S_EXPLAIN>{
623: [/][Dd][Ii][Ss]{Space}*[\(]{Space}* { yy_push_state(S_HINTEXLAINX); }
624: [^/\n]+[/\\] { char *aptr = yytext;
625: int ii;
626:
627: yyless(yyleng-1);
628: for(ii=0;ii<yyleng;ii++) {
629: *Current_char_p++ = *aptr++;
630: }
631:
632: }
633: [/] { *Current_char_p++ = '/'; }
634: [\\] { *Current_char_p++ = '\\'; }
635: [\\]{Space}*[\n] { LLDBUG_PR1("[\\CR hint explain continue]"); /* Hint and explain continuation */ }
636: [^/\n\\]+$ { char *aptr = yytext;
637: int ii;
638: for(ii=0;ii<yyleng;ii++) {
639: *Current_char_p++ = *aptr++;
640: }
641: }
642: }
643: <S_HINT>{
644: {EndLine} { LLDBUG_PR1("[CR hint]");
645: yylval = (Symbol *) capa_malloc(1, sizeof(Symbol));
646: *Current_char_p++ = '\n'; *Current_char_p = '\0';
647: yylval->s_str = strsave(String_buf);
648: BEGIN S_TEXT; RETURN(HINT_LINE);
649: }
650: }
651: <S_EXPLAIN>{
652: {EndLine} { LLDBUG_PR1("[CR explain]");
653: yylval = (Symbol *) capa_malloc(1, sizeof(Symbol));
654: *Current_char_p++ = '\n'; *Current_char_p = '\0';
655: yylval->s_str = strsave(String_buf);
656: BEGIN S_TEXT; RETURN(EXPLAIN_LINE);
657: }
658: }
659:
660: <S_HINTEXLAINX>{
661: {Alpha}{AlphaNum}* { char *aptr;
662: char tmp_str[QUARTER_K],warn_msg[ONE_K];
663: int ii, len;
664: Symbol *tmp_p;
665:
666: tmp_p = find_identifier(yytext);
667: switch(tmp_p->s_type) {
668: case IDENTIFIER:
669: sprintf(warn_msg,"var %s not defined.\n", yytext);
670: capa_msg(MESSAGE_ERROR,warn_msg);
671: break;
672: case I_VAR:
673: case I_CONSTANT:
674: sprintf(tmp_str,"%ld",tmp_p->s_int);
675: len = strlen(tmp_str);
676: for(ii=0;ii< len;ii++) {
677: *Current_char_p++ = tmp_str[ii];
678: }
679: break;
680: case R_VAR:
681: case R_CONSTANT:
682: sprintf(tmp_str,"%g",tmp_p->s_real);
683: len = strlen(tmp_str);
684: for(ii=0;ii< len;ii++) {
685: *Current_char_p++ = tmp_str[ii];
686: }
687: break;
688: case S_VAR:
689: case S_CONSTANT:
690: len = strlen(tmp_p->s_str);
691: aptr = tmp_p->s_str;
692: for(ii=0;ii< len;ii++) {
693: *Current_char_p++ = *aptr++;
694: }
695: break;
696: }
697: }
698: {Space}+ { }
699: [)] { yy_pop_state(); }
700: }
701:
702: <S_IMPORT>{
703: {FileName}{Space}* { parse_filename(yytext); BEGIN S_SKIP; }
704: {Identifier}{Space}* { parse_import_id(yytext); BEGIN S_SKIP; }
705: }
706:
707: <S_ANSWER>{
708: [Pp][Ll][Uu][Ss] { LLDBUG_PR1("[PLUS]"); RETURN(ANS_PLUS); }
709: [Mm][Ii][Nn][Uu][Ss] { LLDBUG_PR1("[MINUS]"); RETURN(ANS_MINUS); }
710: [Cc][Ss] { LLDBUG_PR1("[CS]"); RETURN(ANS_CS); }
711: [Cc][Ii] { LLDBUG_PR1("[CI]"); RETURN(ANS_CI); }
712: [Mm][Cc] { LLDBUG_PR1("[MC]"); RETURN(ANS_MC); }
713: [Oo][Nn] |
714: [Yy][Ee][Ss] { LLDBUG_PR1("[ON]"); RETURN(ANS_ON); }
715: [Oo][Ff][Ff] |
716: [Nn][Oo] { LLDBUG_PR1("[OFF]"); RETURN(ANS_OFF); }
717: [Ff][Mm][Ll] { LLDBUG_PR1("[FORMULA]"); RETURN(ANS_FORMULA); }
718: [Ff][Mm][Tt] { LLDBUG_PR1("[FMT]"); RETURN(ANS_FMT); }
719: [Uu][Nn][Ff][Mm][Tt] { LLDBUG_PR1("[UNFMT]"); RETURN(ANS_UNFMT); }
720: [,:%=@#-] { LLDBUG_PR2("[symbol(%s)]",yytext); return(yytext[0]); }
721: "<" { LLDBUG_PR2("[symbol(%s)]",yytext); return(yytext[0]); }
722: ">" { LLDBUG_PR2("[symbol(%s)]",yytext); return(yytext[0]); }
723: [Ss][Ii][Gg] { LLDBUG_PR2("[SIG(%s)]",yytext); RETURN(ANS_SIG); }
724: [Tt][Oo][Ll] { LLDBUG_PR2("[tol(%s)]",yytext); RETURN(ANS_TOLERANCE); }
725: [Ss][Tt][Rr] { LLDBUG_PR1("[STR]"); RETURN(ANS_COMPARE); }
726: [Ww][Gg][Tt] { LLDBUG_PR1("[WGT]"); RETURN(ANS_WEIGHT); }
727: [Pp][Cc][Rr] |
728: [Hh][Gg][Rr] { RETURN(ANS_PCREDIT); }
729: [Pp][Aa][Tt][Hh] { RETURN(ANS_PATH); }
730: [Cc][Aa][Ll][Cc] { RETURN(ANS_CALC); }
731: [Tt][Rr][Yy] |
732: [Tt][Rr][Ii][Ee][Ss] { LLDBUG_PR1("[TRY]"); RETURN(ANS_TRY); }
733: [Uu][Nn][Ii][Tt] |
734: [Uu][Nn][Ii][Tt][Ss] { LLDBUG_PR1("[UNIT]"); RETURN(ANS_UNIT); }
735: [Bb][Rr] { LLDBUG_PR1("[SHOW_BR]"); RETURN(ANS_SHOW_BR); }
1.7 albertel 736: [Vv][Ee][Rr][Bb][Aa][Tt][Ii][Mm] { LLDBUG_PR1("[VERBATIM]"); RETURN(ANS_VERBATIM); }
1.1 albertel 737: [Aa][Nn][Ss][Bb][Oo][Xx] { LLDBUG_PR1("[SHOW_ANS_BOX]"); RETURN(ANS_BOX_SHOW); }
738: [Hh][Ii][Nn][Tt] { LLDBUG_PR1("[HINT]"); RETURN(ANS_HINT); }
739: [Ee][Xx][Pp][Ll][Aa][Ii][Nn] { LLDBUG_PR1("[EXPLAIN]"); RETURN(ANS_EXPLAIN); }
740: [Ee][Xx][Tt][Ee][Rr][Nn][Aa][Ll] { LLDBUG_PR1("[EXTERNAL]"); RETURN(ANS_EXTERNAL); }
741: [Ee][Vv][Aa][Ll] |
742: [Ee][Vv][Aa][Ll][Uu][Aa][Tt][Ee] { LLDBUG_PR1("[EVAL]"); RETURN(ANS_EVAL); }
743: [\)] { LLDBUG_PR1("[)]"); Pcount--;
744: if(Pcount==0) {
745: BEGIN S_ANSCONTINUE;
746: }
747: return(yytext[0]);
748: }
749: }
750:
751: <S_VARIABLE,S_TRUE_FALSE_STMT,S_LET,S_ANSWER,S_MAP>{
752: {Alpha}{AlphaNum}* { LLDBUG_PR2("[ID<%s>]",yytext);LLDBUG_PR2("[SYMB CNT=<%d>]", Symb_count);
753: yylval = find_identifier(yytext); RETURN(IDENTIFIER);
754: }
755:
756: {Alpha}{AlphaNum}*{Space}*[(] { char aline[MAX_FUNC_NAME];
757: int i;
758: for(i=0;i < (yyleng-1); i++) {
759: if( yytext[i] == ' ' || yytext[i] == '\t' ||
760: yytext[i] == 0 || yytext[i] == '(' ) break;
761: aline[i] = yytext[i];
762: }
763: aline[i] = 0;
764: LLDBUG_PR3("[FUNCT<%s:%d>]",aline,Func_idx);
765: (FuncStack[Func_idx]).s_type = FUNCTION_ID;
766: (FuncStack[Func_idx]).s_name = strsave(aline); /* free it in parser() */
767: Func_idx++;
768: yyless(yyleng-1); /* <-- push back '(' char */
769: RETURN(FUNCTION_ID);
770: }
771: {Alpha}{AlphaNum}*{Space}*[\[] { char aline[MAX_FUNC_NAME];
772: int i;
773: for(i=0;i < (yyleng-1); i++) {
774: if( yytext[i] == ' ' || yytext[i] == '\t' ||
775: yytext[i] == 0 || yytext[i] == '[' ) break;
776: aline[i] = yytext[i];
777: }
778: aline[i] = 0;
779: LLDBUG_PR2("[ARRAY<%s>]",aline);
780:
781: yylval = (Symbol *) capa_malloc(1, sizeof(Symbol)); /* *** */
782: yylval->s_name = strsave(aline); /* free it in parser() */
783: yylval->s_type = ARRAY_ID;
784:
785: yyless(yyleng-1); /* <-- push back char '[' */
786: RETURN(ARRAY_ID);
787: }
788: {Number}*"\."{Number}*[Ee]"+"{Number}+ |
789: {Number}*"\."{Number}*[Ee]{Number}+ |
790: {Number}*"\."{Number}*[Ee]"-"{Number}+ |
791: {Number}+[Ee]"+"{Number}+ |
792: {Number}+[Ee]{Number}+ |
793: {Number}+[Ee]"-"{Number}+ |
794: {Number}+"\."{Number}* |
795: "\."{Number}+ { yylval = (Symbol *) capa_malloc(1, sizeof(Symbol)); /* *** */
796: yylval->s_real = strtod(yytext, (char **) 0);
797: yylval->s_type = R_CONSTANT;
798: LLDBUG_PR2("[REAL<%s>]",yytext);
799: RETURN(R_CONSTANT);
800: }
801:
802: {Number}+ { yylval = (Symbol *) capa_malloc(1, sizeof(Symbol)); /* *** */
803: yylval->s_int = strtol(yytext, (char **) 0, 0);
804: yylval->s_type= I_CONSTANT;
805: LLDBUG_PR2("[INT<%s>]",yytext);
806: RETURN(I_CONSTANT);
807: }
808: [\(] { LLDBUG_PR1("[dis let ans map (]"); Pcount++; return(yytext[0]); }
809: [\[] { LLDBUG_PR1("[dis let ans map '[']"); return(yytext[0]); }
810: [\]] { LLDBUG_PR1("[dis let ans map ']']"); return(yytext[0]); }
811: {Space}+ { /* LLDBUG_PR1("[SP ignored]"); Ignore Spaces */ }
812: [\"] { LLDBUG_PR1("[TF,V,LET,ANS,MAP str\" ]");
813: Current_char_p = String_buf;
814: yy_push_state(S_STRING);
815: }
816: }
817:
1.3 albertel 818: <S_VARIABLE,S_ANSWER>[:]{Number}+[EeFf] { char num[ONE_TWO_EIGHT], fmt[SMALL_LINE_BUFFER];
1.1 albertel 819: int i;
820: LLDBUG_PR2("[FORMAT<%s>]",yytext);
821: for(i=0;i<yyleng-2;i++) {
822: num[i] = yytext[i+1];
823: }
824: num[yyleng-2] = 0; /* terminate the numerical string */
825: yylval = (Symbol *) capa_malloc(1, sizeof(Symbol));
826: i = strtol(num, (char **) 0, 0);
827: yylval->s_type=FORMAT;
828: switch( yytext[yyleng-1] ) {
829: case 'e': sprintf(fmt,"%%.%de", i);
830: yylval->s_distype = E_FORMAT; break;
831: case 'E': sprintf(fmt,"%%.%dE", i);
832: yylval->s_distype = E_FORMAT; break;
833: case 'f':
834: case 'F': sprintf(fmt,"%%.%df", i);
835: yylval->s_distype = F_FORMAT; break;
836: }
837: yylval->s_str = strsave(fmt);
838: RETURN(FORMAT);
839: }
840:
841: <S_VARIABLE,S_TRUE_FALSE_STMT,S_LET,S_MAP>{
842: "==" { LLDBUG_PR1("[==]"); RETURN(EQ_op); }
843: "!=" { LLDBUG_PR1("[!=]"); RETURN(NE_op); }
844: ">" { LLDBUG_PR1("[>]"); RETURN(GT_op); }
845: ">=" { LLDBUG_PR1("[>=]"); RETURN(GE_op); }
846: "<" { LLDBUG_PR1("[<]"); RETURN(LT_op); }
847: "<=" { LLDBUG_PR1("[<=]"); RETURN(LE_op); }
848: "&&" { LLDBUG_PR1("[&&]"); RETURN(AND_op); }
849: "||" { LLDBUG_PR1("[||]"); RETURN(OR_op); }
850: "//" { if(Pcount==0) BEGIN S_SKIP; }
851: {Operator} { LLDBUG_PR2("[Op(%c) in VAR,TF_STMT,LET]",yytext[0]); return(yytext[0]); }
852: }
853:
854:
855: <S_RANDOMORDER>{
856: {Number}+ {
857: yylval = (Symbol *) capa_malloc(1, sizeof(Symbol));
858: yylval->s_int = strtol(yytext, (char **) 0, 0);
859: yylval->s_type= I_CONSTANT;
860: LLDBUG_PR2("[INT<%s>]",yytext);
861: RETURN(I_CONSTANT);
862: }
863: [+~,\-!] { LLDBUG_PR2("[randqo(%s)]",yytext); return(yytext[0]); }
864: {EndLine} { LLDBUG_PR1("[EoLRQO]"); BEGIN S_TEXT; RETURN(EoL);}
865: }
866:
867: <S_VARIABLE>{
868: [\)] { LLDBUG_PR1("[)]"); Pcount--; if(Pcount == 0) BEGIN S_TEXT; return(yytext[0]); }
869: [\\]{Space}*{EndLine} { LLDBUG_PR2("[\\EoL continue in S_VARIABLE (DIS?)](%s)",yytext); /* continuation on next line */ }
870: {EndLine} { LLDBUG_PR1("[EoL within /dis()]\n"); RETURN(EoL); }
871: . { char warn_msg[WARN_MSG_LENGTH];
872: sprintf(warn_msg,"When use a VARIABLE, an unexpected char [%c] is encountered.\n",yytext[0]);
873: capa_msg(MESSAGE_ERROR,warn_msg);
874: }
875: }
876:
877: <S_TRUE_FALSE_STMT>{
1.6 albertel 878: [\)] { LLDBUG_PRL1("[) in TRUE_FALSE]"); Pcount--; if(Pcount == 0) BEGIN S_NEXT_LINE; return(yytext[0]); }
1.1 albertel 879: [\\]{Space}*{EndLine} { LLDBUG_PR2("[\\EoL continue in S_TRUE_FALSE_STMT](%s)",yytext); /* continuation on next line */ }
880: {EndLine} { LLDBUG_PR1("[EoL within /IF()]\n"); RETURN(EoL); }
881: . { char warn_msg[WARN_MSG_LENGTH];
882: sprintf(warn_msg,"In /IF(), an unexpected char [%c] is encountered.\n",yytext[0]);
883: capa_msg(MESSAGE_ERROR,warn_msg);
884: }
885: }
886:
887: <S_STRING>{
888: [\\][\\] { char *aptr = yytext;
889: while( *aptr ) *Current_char_p++ = *aptr++;
890: }
891: [\\][\"] { *Current_char_p++ = '"'; }
892: [\\]{Space}*[\n] { LLDBUG_PR2("[\\CR continue in S_STRING](%s)",yytext); /* continuation on next line */ }
893: [\"] { /* end of a string constant -- */
894: yylval = (Symbol *) capa_malloc(1, sizeof(Symbol));
895: *Current_char_p = '\0';
896: yylval->s_str = strsave(String_buf); /* **** */
897: yylval->s_type = S_CONSTANT;
898: /* printf("STRING:%s\n", String_buf); */
899: LLDBUG_PR2("[%s\"END str]",String_buf);
900: yy_pop_state();
901: RETURN(S_CONSTANT); }
902: {EndLine} { /* check for termination of string constant */
903: char warn_msg[WARN_MSG_LENGTH];
904:
905: *Current_char_p = '\0';
906: sprintf(warn_msg,"STRING not terminated properly, an EoL encountered in the middle.\n%s\n",String_buf);
907: capa_msg(MESSAGE_ERROR,warn_msg);
908: yy_pop_state();
909: }
910: . { char *aptr = yytext;
911: while( *aptr ) *Current_char_p++ = *aptr++;
912: }
913: }
914:
915: <S_LET>[\)] { LLDBUG_PR1("[) in LET]"); Pcount--; return(yytext[0]); }
916:
917: <S_SKIP>{
918: [^\n]+$ { }
919: {EndLine} { BEGIN S_TEXT; RETURN(EoL); }
920: }
921:
922: <S_LET,S_ANSWER,S_MAP>{
923: [\\]{Space}*{EndLine} { LLDBUG_PR1("[\\EoL let ans map]"); /* continuation */ }
924: {EndLine} { LLDBUG_PR1("[EoL END let ans map]\n"); if(Pcount == 0) BEGIN S_TEXT; RETURN(EoL); }
925: }
926:
927: <S_MAP>{
928: [;,] { LLDBUG_PR2("[%c]",yytext[0]); return(yytext[0]); }
929: [\)] { LLDBUG_PR1("[) in MAP]"); Pcount--;
930: if(Pcount==0) {
931: BEGIN S_SKIP;
932: }
933: return(yytext[0]);
934: }
935: }
936:
937: <S_ANSCONTINUE>{
938: {Space}+ { /* ignore white spaces */ }
939: [\\]{Space}*{EndLine} { /* continuation */ }
940: {EndLine} { /* end of answer and/or other answers */ LLDBUG_PR1("[complete an answer<EoL>]");
941: BEGIN S_TEXT; }
942: "/AND" { LLDBUG_PR1("[AND]"); RETURN(ANS_AND); }
943: "/OR" { LLDBUG_PR1("[OR]"); RETURN(ANS_OR); }
944: }
945:
946: <S_IF_SKIP>{
947: ^{Spaces}"/IF"[^\n]*{EndLine} { IFcount++; LLDBUG_PRL2("[Skip IF <IFcount=%d>]\n",IFcount);
948: IFstatus[IFcount] = IF_DONT_CARE;
949: }
950: ^{Spaces}"/ELSE"[^\n]*{EndLine} { LLDBUG_PRL2("[Skip ELSE <IFcount=%d>]",IFcount);
951: IFcurrent[IFcount]=RUN_ELSE_PORTION;
952: if( IFstatus[IFcount] == IF_FALSE ) {
953: LLDBUG_PRL1("[ELSE begin TEXT CR]\n");
954: BEGIN S_TEXT;
955: }
956: if( IFstatus[IFcount] == IF_TRUE ) {
957: LLDBUG_PRL1("[ELSE THIS SHOULD NEVER HAPPEN.]\n");
958: }
959: }
960: ^{Spaces}"/ENDIF"[^\n]*{EndLine} { IFcount--; LLDBUG_PRL2("[Skip ENDIF <IFcount=%d>]\n",IFcount);
961: if( IFcount == 0 ) {
962: LLDBUG_PRL1("[ENDIF begin TEXT CR]\n");
963: BEGIN S_TEXT;
964: }
965: if( (IFcurrent[IFcount] == RUN_IF_PORTION )&&(IFstatus[IFcount] == IF_TRUE)) {
966: LLDBUG_PRL1("[ENDIF begin TEXT CR]\n");
967: BEGIN S_TEXT;
968: }
969: if( (IFcurrent[IFcount] == RUN_ELSE_PORTION )&&(IFstatus[IFcount] == IF_FALSE)) {
970: LLDBUG_PRL1("[ENDIF begin TEXT CR]\n");
971: BEGIN S_TEXT;
972: }
973: }
974: {EndLine} { LLDBUG_PRL1("[SkipIF a CR]\n"); }
975: [^\n]*$ { LLDBUG_PRL2("[SkipIF anything <IFcount=%d>]",IFcount); }
976: }
977: <S_NEXT_LINE>{
1.6 albertel 978: ([.]*){EndLine} { /* this ignores everything until it hits an EoL */
979: LLDBUG_PRL2("[<S_NEXT_LINE> skip \'%s\' until EoL]\n",yytext);
980: BEGIN S_TEXT;
981: }
1.1 albertel 982: }
983:
984: <S_WHILE_SKIP>{
985: ^{Spaces}"/WHILE"[^\n]*{EndLine} { Wcount++;
986: LLDBUG_PRL2("[SkipWHILE /WHILE <Wcount=%d>]\n",Wcount);
987: }
988: ^{Spaces}"/ENDWHILE"[^\n]*{EndLine} {
989: if(Wcount==0) {
990: LLDBUG_PRL2("[SkipWHILE->/ENDWHILE <Wcount=%d>]\n",Wcount);
991: BEGIN S_TEXT;
992: } else {
993: Wcount--;
994: LLDBUG_PRL2("[SkipWHILE /ENDWHILE <Wcount=%d>]\n",Wcount);
995: }
996: }
997: {EndLine} { LLDBUG_PRL1("[SkipWHILE a CR]\n"); }
998: [^\n]*$ { LLDBUG_PRL2("[SkipWHILE anything <Wcount=%d>]",Wcount); }
999: }
1000:
1001: <S_VERB>{
1002: ^{Spaces}"/ENDVERB" { LLDBUG_PRL1("[END VERB]\n");
1003: yylval = (Symbol *) capa_malloc(1, sizeof(Symbol));
1004: yylval->s_str = strsave(Dynamic_buf); /* **** */
1005: yylval->s_type = S_CONSTANT;
1006: capa_mfree(Dynamic_buf);
1007: Dynamic_buf_cur=-1;
1008: Dynamic_buf_max=0;
1009: BEGIN S_TEXT; RETURN(VERBATIM);
1010: }
1011: .*|{EndLine} { append_dynamic_buf(yytext); }
1012: }
1013:
1014: %%
1015:
1016: /* ========================================================================================== */
1017: extern void
1018: begin_if_skip() { BEGIN S_IF_SKIP; }
1019:
1020: extern void
1021: begin_while_skip() { Wcount=0; While_idx--; /* while is FALSE, pop it out from stack */ BEGIN S_WHILE_SKIP; }
1022:
1023: extern void
1024: begin_next_line() { BEGIN S_NEXT_LINE; }
1025:
1026: extern void
1027: begin_var() { BEGIN S_VARIABLE; }
1028:
1029: extern void
1030: begin_let() { BEGIN S_LET; }
1031:
1032: extern void
1033: begin_def() { BEGIN S_DEFINE; }
1034:
1035: extern void
1036: begin_ans() { BEGIN S_ANSWER; }
1037:
1038: extern void
1039: begin_map() { BEGIN S_MAP; }
1040:
1041: extern void
1042: begin_ignore() { BEGIN S_IGNORE; }
1043:
1044: extern void
1045: begin_text() { BEGIN S_TEXT; }
1046:
1047: extern void
1048: begin_question() { LLDBUG_PR1("[<S_TEXT>]");
1049: IFcount = 0; While_idx=0; /* initialize some stacks */
1050: End_of_input = 0; YY_FLUSH_BUFFER; BEGIN S_TEXT; }
1051:
1052: extern void
1053: end_problemset() { End_of_input = 0; YY_FLUSH_BUFFER; BEGIN S_TEXT; }
1054:
1055:
1056: /* ========================================================================================== */
1057:
1058: #define NUM_KEY 2
1059: int
1060: match_keyword(key) char *key;
1061: {
1062: char *keyword[NUM_KEY] = {"/DIS", "/DIR" };
1063: int i;
1064:
1065: for(i=0;i < NUM_KEY; i++) {
1066: if( !strncmp(keyword[i], key, 4) ) {
1067: return (1);
1068: }
1069: }
1070: return (0);
1071: }
1072:
1073: int
1074: match_functionid(key) char *key;
1075: {
1076: char *keyword[NUM_KEY] = {"/DIS", "/DIR" };
1077: int i;
1078:
1079: for(i=0;i < NUM_KEY; i++) {
1080: if( !strncmp(keyword[i], key, 4) ) {
1081: return (1);
1082: }
1083: }
1084: return (0);
1085: }
1086: /* -------------------------------------------------------------------------- */
1087: /* -------------------------------------------------------------------------- */
1088:
1089: void init_funcstack()
1090: {
1091: int ii;
1092: for(ii=0;ii<Func_idx;ii++) {
1093: capa_mfree(FuncStack[ii].s_name);
1094: }
1095: Func_idx = 0;
1096: }
1097:
1098:
1099: /* -------------------------------------------------------------------------- */
1100: /* GET THE NEXT CHARACTER OF THE SOURCE FILE */
1101: /* -------------------------------------------------------------------------- */
1102:
1103: #ifdef FLEX
1104: int capaL_input()
1105: #else
1106: int /* RETURNS: next character */
1107: input() /* ARGUMENTS: (none) */
1108: #endif
1109:
1110: { /* LOCAL VARIABLES: */
1111: static int startup=1; /* First call flag */
1112:
1113: LLDBUG_PRL1("<<capaL_input() is called>>\n");
1114: if (!Lexi_line) { /* was startup */
1115: for(Input_idx=0;Input_idx < MAX_OPENED_FILE;Input_idx++) {
1116: /* for(ii=0;ii<LEX_BUFLEN;ii++) {
1117: Lexi_buf[Input_idx][ii]=0;
1118: }
1119: */
1120: Lexi_buf[Input_idx][0]=0;
1121: Lexi_pos[Input_idx] = 0;
1122: }
1123: Input_idx = 0;
1124: startup=0;
1125: yyin = Input_stream[Input_idx];
1126: }
1127: if (!Lexi_buf[Input_idx][Lexi_pos[Input_idx]]) {
1128: if (fgets(Lexi_buf[Input_idx],LEX_BUFLEN-1,Input_stream[Input_idx])==NULL) {
1129: /* EOF? */
1130: /* no use in flex
1131: printf("capaL_input()EOF %s\n",Opened_filename[Input_idx+1]); fflush(stdout); */
1132: return (0);
1133: }
1134: Lexi_pos[Input_idx] = 0;
1135: Lexi_line++;
1136: printf("input()(%d)\n",Lexi_line);
1137: }
1138: (Lexi_pos[Input_idx])++;
1139: return ( Lexi_buf[Input_idx][Lexi_pos[Input_idx]-1] );
1140: }
1141:
1142: /******************************************************************************/
1143: /* PUSH BACK ONE CHARACTER OF THE INPUT */
1144: /******************************************************************************/
1145:
1146: int /* RETURNS: nothing */
1147: capaL_unput(ch) /* ARGUMENTS: */
1148: register int ch; /* Character to push */
1149: {
1150: if (ch) (Lexi_pos[Input_idx])--;
1151:
1152: /* unput() stream cannot be re-defined */
1153: /* unput(ch); inconsistency between YY_INPUT() and internal matched yytext */
1154: return (0);
1155:
1156: }
1157:
1158:
1159: /******************************************************/
1160:
1161: #ifndef DMALLOC
1162:
1163: char *
1164: strsave(char *s)
1165: {
1166: char *p;
1.4 albertel 1167: if (s==NULL) {return s;}
1.1 albertel 1168: p=capa_malloc(strlen(s)+1,1);
1169: strcpy(p,s);
1170: return (p);
1171: }
1172:
1173: #endif
1174:
1175: /* =========================================================================== */
1176:
1177: #ifndef DMALLOC
1178: char *
1179: capa_malloc(unsigned num,unsigned sz)
1180: {
1181: char *p;
1182: p = calloc(num, sz);
1183: bzero(p, num*sz); /* added Jan 21 1998 */
1184: return (p);
1185: }
1186:
1187: #endif
1188:
1189: #ifndef DMALLOC
1190: void
1191: capa_mfree(p) char *p;
1192: {
1193: free(p);
1194: }
1195: #endif
1196:
1197: void
1198: capa_msg(int type, char *p)
1199: { int idx, i, j;
1200: int len;
1201: char warn_msg[WARN_MSG_LENGTH];
1202: char tmp_line[ONE_TWO_EIGHT];
1203: char *tmp_str;
1204:
1205: strcpy(warn_msg,"File: ");
1206: idx=6;
1207: for(i=0;i<=Input_idx;i++) {
1208: len=strlen(Opened_filename[i]);
1209: for(j=0;j<len;j++) {
1210: warn_msg[idx++] = Opened_filename[i][j];
1211: }
1212: if(i < Input_idx) {
1213: warn_msg[idx++]='-';
1214: warn_msg[idx++]='>';
1215: }
1216: warn_msg[idx]=0;
1217: }
1218: switch (type) {
1219: case MESSAGE_ERROR:
1220: sprintf(tmp_line,", Line %d: ERROR:", Current_line[Input_idx]);
1221: len=strlen(tmp_line);
1222: for(j=0;j<len;j++) {
1223: warn_msg[idx++] = tmp_line[j];
1224: }
1225: warn_msg[idx]=0;
1226: append_error(warn_msg); append_error(p);
1.5 albertel 1227: break;
1.1 albertel 1228: case MESSAGE_WARN:
1229: default:
1230: sprintf(tmp_line,", Line %d: WARNING:", Current_line[Input_idx]);
1231: len=strlen(tmp_line);
1232: for(j=0;j<len;j++) {
1233: warn_msg[idx++] = tmp_line[j];
1234: }
1235: warn_msg[idx]=0;
1236: j = strlen(warn_msg);
1237: len = strlen(p);
1238: tmp_str = (char *)capa_malloc(len+j+1,1);
1239: for(i=0;i<j;i++) {
1240: tmp_str[i]=warn_msg[i];
1241: }
1242: for(i=j;i<j+len;i++) {
1243: tmp_str[i] = p[i-j];
1244: }
1245: append_warn(type,tmp_str);
1246: capa_mfree(tmp_str);
1247: break;
1248: }
1249: }
1250:
1251: /* ======================================================================== */
1252: void
1253: capa_warn_header(int type)
1254: {
1255: int idx, i, j;
1256: int len;
1257: char warn_msg[WARN_MSG_LENGTH];
1258: char tmp_line[ONE_TWO_EIGHT];
1259:
1260: strcpy(warn_msg,"File: ");
1261: idx=6;
1262: for(i=0;i<=Input_idx;i++) {
1263: len=strlen(Opened_filename[i]);
1264: for(j=0;j<len;j++) {
1265: warn_msg[idx++] = Opened_filename[i][j];
1266: }
1267: if(i < Input_idx) {
1268: warn_msg[idx++]='-';
1269: warn_msg[idx++]='>';
1270: }
1271: warn_msg[idx]=0;
1272: }
1273: switch (type) {
1274: case MESSAGE_ERROR:
1275: sprintf(tmp_line,", Line %d: ERROR:", Current_line[Input_idx]);
1276:
1277: break;
1278: case MESSAGE_WARN:
1279: sprintf(tmp_line,", Line %d: WARNING:", Current_line[Input_idx]);break;
1280: default:
1281: sprintf(tmp_line,", Line %d: ERROR:", Current_line[Input_idx]);break;
1282: }
1283: len=strlen(tmp_line);
1284: for(j=0;j<len;j++) {
1285: warn_msg[idx++] = tmp_line[j];
1286: }
1287: warn_msg[idx]=0;
1288: append_error(warn_msg);
1289: }
1290:
1291: /* --------------------------------------------------------------------------- */
1292: #ifdef AVOIDYYINPUT
1293:
1294: void change_file(char *fname)
1295: {
1296: char warn_msg[WARN_MSG_LENGTH];
1297: if( capa_access(fname, (F_OK | R_OK)) == -1 ) {
1298: sprintf(warn_msg,"/IMP \"%s\", import file does not exist or is not readable.\n",
1299: fname);
1300: capa_msg(MESSAGE_ERROR,warn_msg);
1301: return;
1302: }
1303:
1304: if ( include_stack_ptr >= MAX_INCLUDE_DEPTH ) {
1305: sprintf(warn_msg,"Includes nested too deeply" );
1306: capa_msg(MESSAGE_ERROR,warn_msg);
1307: return;
1308: }
1309:
1310: include_stack[include_stack_ptr++] = YY_CURRENT_BUFFER;
1311: yyin = fopen( fname, "r" );
1312: yy_switch_to_buffer( yy_create_buffer( yyin, YY_BUF_SIZE ) );
1313: }
1314:
1315: void
1316: parse_filename(char *line)
1317: {
1318: char *start, fname[MAX_BUFFER_SIZE], warn_msg[WARN_MSG_LENGTH];
1319: int ii,len;
1320:
1321: start = index(line, '\"'); /*** hpux complained */
1322: if( start == NULL ) {
1323: sprintf(warn_msg,"/IMP was not given a filename.\n");
1324: capa_msg(MESSAGE_ERROR,warn_msg);
1325: return;
1326: }
1327: start++; len = strlen(start) - 1;
1328: ii = 0;
1329: while( start[ii] != '\"' ) fname[ii++] = start[ii];
1330: fname[ii] = 0;
1331: LLDBUG_PR2("[parse_filename<%s>]\n",fname);
1332:
1333: change_file(fname);
1334: }
1335:
1336: void
1337: parse_import_id(char *line)
1338: {
1339: char fname[QUARTER_K], warn_msg[WARN_MSG_LENGTH];
1340: int ii, dup_open;
1341: Symbol *symb_p;
1342: int no_error = 0;
1343:
1344: ii = 0;
1345: while( line[ii] != '\0' && line[ii] != ' ' && line[ii] != '\n' && line[ii] != '\t' )
1346: fname[ii++] = line[ii];
1347: fname[ii] = 0;
1348:
1349: LLDBUG_PR2("[parse_import_id<%s>]\n",fname);
1350: symb_p = find_identifier(fname);
1351:
1352: switch (symb_p->s_type) {
1353: case IDENTIFIER:
1354: sprintf(warn_msg,"/IMP %s, var is not defined.\n", fname);
1355: capa_msg(MESSAGE_ERROR,warn_msg);
1356: break;
1357: case I_VAR: case I_CONSTANT: case R_VAR: case R_CONSTANT:
1358: sprintf(warn_msg,"var cannot be a number.\n");
1359: capa_msg(MESSAGE_ERROR,warn_msg);
1360: break;
1361: case S_VAR: case S_CONSTANT: sprintf(fname,"%s",symb_p->s_str);
1362: no_error = 1;
1363: break;
1364: }
1365: if( no_error ) change_file(fname);
1366: }
1367:
1368: #else
1369: void
1370: parse_filename(char *line)
1371: {
1372: char *start, fname[QUARTER_K], warn_msg[WARN_MSG_LENGTH];
1373: int ii, len, dup_open;
1374:
1375: /* printf("IMPORT %s\n", line); */
1376:
1377: start = index(line, '\"'); /*** hpux complained */
1378: if( start != NULL ) {
1379: start++; len = strlen(start) - 1;
1380: ii = 0;
1381: while( start[ii] != '\"' ) {
1382: fname[ii] = start[ii]; ii++;
1383: }
1384: fname[ii] = 0;
1385: LLDBUG_PR2("[parse_filename<%s>]\n",fname);
1386: if(Input_idx < (MAX_OPENED_FILE -1)) {
1387: dup_open = 0;
1388: /* -- no need to check duplicated opening a file
1389: for(ii=0;ii<Input_idx;ii++) {
1390: if(strcmp(Opened_filename[ii],fname)==0) {
1391: dup_open =1;
1392: }
1393: }
1394: */
1395: if( !dup_open ) {
1396: if( capa_access(fname, (F_OK | R_OK)) == -1 ) {
1397: sprintf(warn_msg,"/IMP \"%s\", import file does not exist or is not readable.\n",fname);
1398: capa_msg(MESSAGE_ERROR,warn_msg);
1399: } else {
1400: Input_idx++;
1401: Input_stream[Input_idx]=fopen(fname,"r");
1402: sprintf(Opened_filename[Input_idx], "%s",fname);
1403: Current_line[Input_idx] = 0;
1404: }
1405: } else {
1406: /*
1407: sprintf(warn_msg,"/IMP \"%s\", import file has already been imported.\n",fname);
1408: capa_msg(MESSAGE_WARN,warn_msg);
1409: */
1410: if( capa_access(fname, (F_OK | R_OK)) == -1 ) {
1411: sprintf(warn_msg,"/IMP \"%s\", import file does not exist or is not readable.\n",fname);
1412: capa_msg(MESSAGE_ERROR,warn_msg);
1413: } else {
1414: Input_idx++;
1415: Input_stream[Input_idx]=fopen(fname,"r");
1416: sprintf(Opened_filename[Input_idx], "%s",fname);
1417: Current_line[Input_idx] = 0;
1418: }
1419: }
1420: } else {
1421: sprintf(warn_msg,"/IMP more the %d levels deep ignoring further imports.\n",MAX_OPENED_FILE-1);
1422: capa_msg(MESSAGE_WARN,warn_msg);
1423: }
1424: } else {
1425: sprintf(warn_msg,"%s, is not a valid file name.\n",line);
1426: capa_msg(MESSAGE_ERROR,warn_msg);
1427: }
1428:
1429: }
1430:
1431: void
1432: parse_import_id(char *line)
1433: {
1434: char fname[QUARTER_K], warn_msg[WARN_MSG_LENGTH];
1435: int ii, dup_open;
1436: Symbol *symb_p;
1437: int no_error = 0;
1438:
1439: ii = 0;
1440: while (line[ii] != '\0' && line[ii] != ' ' && line[ii] != '\n' && line[ii] != '\t') {
1441: fname[ii] = line[ii]; ii++;
1442: }
1443: fname[ii] = 0;
1444: LLDBUG_PR2("[parse_import_id<%s>]\n",fname);
1445: symb_p = find_identifier(fname);
1446:
1447: switch (symb_p->s_type) {
1448: case IDENTIFIER:
1449: sprintf(warn_msg,"/IMP %s, var is not defined.\n", fname);
1450: capa_msg(MESSAGE_ERROR,warn_msg);
1451: break;
1452: case I_VAR: case I_CONSTANT: case R_VAR: case R_CONSTANT:
1453: sprintf(warn_msg,"var cannot be a number.\n");
1454: capa_msg(MESSAGE_ERROR,warn_msg);
1455: break;
1456: case S_VAR:
1457: case S_CONSTANT:
1458: sprintf(fname,"%s",symb_p->s_str);
1459: no_error = 1;
1460: break;
1461: }
1462: if( no_error ) {
1463: if(Input_idx < (MAX_OPENED_FILE -1) ) {
1464: dup_open = 0;
1465: /* no need to check duplicated opening a file
1466: for(ii=0;ii<Input_idx;ii++) {
1467: if(strcmp(Opened_filename[ii],fname)==0) dup_open =1;
1468: }
1469: */
1470: if( !dup_open ) {
1471: if( capa_access(fname, (F_OK | R_OK)) == -1 ) {
1472: sprintf(warn_msg,"/IMP \"%s\", import file does not exist or is not readable.\n", fname);
1473: capa_msg(MESSAGE_ERROR,warn_msg);
1474: } else {
1475: Input_idx++;
1476: Input_stream[Input_idx]=fopen(fname,"r");
1477: sprintf(Opened_filename[Input_idx], "%s",fname);
1478: Current_line[Input_idx] = 0;
1479: }
1480: } else {
1481: /* NO warning on duplicated open a file
1482: sprintf(warn_msg,"/IMP \"%s\", file has already been imported.\n", fname);
1483: capa_msg(MESSAGE_WARN,warn_msg);
1484: */
1485: if( capa_access(fname, (F_OK | R_OK)) == -1 ) {
1486: sprintf(warn_msg,"/IMP \"%s\", import file does not exist or is not readable.\n", fname);
1487: capa_msg(MESSAGE_ERROR,warn_msg);
1488: } else {
1489: Input_idx++;
1490: Input_stream[Input_idx]=fopen(fname,"r");
1491: sprintf(Opened_filename[Input_idx], "%s",fname);
1492: Current_line[Input_idx] = 0;
1493: }
1494:
1495: }
1496: } else {
1497: sprintf(warn_msg,"/IMP , too many files has been imported. The maximum is %d files.\n",
1498: MAX_OPENED_FILE-1);
1499: capa_msg(MESSAGE_WARN,warn_msg);
1500: }
1501: }
1502: }
1503: #endif /*AVOIDYYINPUT*/
1504:
1505: void append_dynamic_buf(new_str) char *new_str;
1506: {
1507: int ii,len;
1508:
1509: if(new_str==NULL) return;
1510: len=strlen(new_str);
1511: #ifdef LEX_DBUG
1512: printf("before: len %d; Dynamic_buf_cur %d; Dynamic_buf_max %d\n",
1513: len,Dynamic_buf_cur,Dynamic_buf_max);
1514: #endif /* LEX_DBUG */
1515: if (Dynamic_buf_cur+len+1>Dynamic_buf_max) {
1516: char *temp_text;
1517: Dynamic_buf_max=(Dynamic_buf_cur+len)*2;
1518: temp_text=(char*)capa_malloc(sizeof(char),Dynamic_buf_max);
1519: strncpy(temp_text,Dynamic_buf,Dynamic_buf_max);
1520: free(Dynamic_buf);
1521: Dynamic_buf=temp_text;
1522: }
1523: for(ii=0;ii<len;ii++) {
1524: Dynamic_buf[Dynamic_buf_cur+ii]=new_str[ii];
1525: }
1526: Dynamic_buf_cur += len;
1527: Dynamic_buf[Dynamic_buf_cur+1]='\0';
1528: #ifdef LEX_DBUG
1529: printf("after: len %d; Dynamic_buf_cur %d; Dynamic_buf_max %d\n",
1530: len,Dynamic_buf_cur,Dynamic_buf_max);
1.2 albertel 1531: printf("Dyn_buf %s; added %s\n",Dynamic_buf,new_str);
1.1 albertel 1532: #endif /* LEX_DBUG */
1533: }
1534:
1535: char* parser_status()
1536: {
1537: char *buf,small[SMALL_LINE_BUFFER];
1538: int i,j,totlen=0,len,idx=0;
1539:
1540: for(i=0;i<=Input_idx;i++) totlen+=strlen(Opened_filename[i])+6;
1541: buf=capa_malloc(sizeof(char),totlen);
1542: for(i=0;i<=Input_idx;i++) {
1543: len=strlen(Opened_filename[i]);
1544: for(j=0;j<len;j++) buf[idx++] = Opened_filename[i][j];
1545: buf[idx++] = ':';
1546: sprintf(small,"%d",Current_line[i]);
1547: len=strlen(small);
1548: for(j=0;j<len;j++) buf[idx++] = small[j];
1549: buf[idx++]=' ';
1550: buf[idx]='\0';
1551: }
1552: return buf;
1553: }
1554:
1555: void yyfatalerror(char*msg)
1556: {
1557: char warn_msg[WARN_MSG_LENGTH];
1.6 albertel 1558: sprintf(warn_msg,"Invalid character[\'%s\']\n",yytext);
1.1 albertel 1559: capa_msg(MESSAGE_ERROR,warn_msg);
1.6 albertel 1560: capa_msg(MESSAGE_ERROR,msg);
1.1 albertel 1561: }
1562: void yyerror(char* msg)
1563: {
1564: char warn_msg[WARN_MSG_LENGTH];
1565: sprintf(warn_msg,"%s\n",msg);
1566: capa_msg(MESSAGE_ERROR,warn_msg);
1567: }
1568:
1569: void newyy_input (char *buf,int *result,int max_size)
1570: { int ii, leng, out_of_char;
1571: if (!Lexi_line) { /* was startup */
1572: for(ii=0;ii < MAX_OPENED_FILE;ii++) {
1573: Lexi_buf[ii] = NULL;
1574: Lexi_pos[ii] = 0;
1575: Current_line[ii] = 0;
1576: }
1577: Input_idx = 0;
1578: first_run=0;
1579: yyin = Input_stream[Input_idx]; LIDBUG_PR1("<<yy_input() startup>>\n");
1580: }
1581: out_of_char = 0;
1582: if ( Lexi_buf[Input_idx] == NULL ) {
1583: Lexi_buf[Input_idx] = (char *)capa_malloc(sizeof(char)*LEX_BUFLEN+1,1); out_of_char=1;
1584: } else {
1585: if (!Lexi_buf[Input_idx][Lexi_pos[Input_idx]]) {
1586: /* test if the line buffer is empty or at the end */
1587: out_of_char=1;
1588: }
1589: }
1590: if( out_of_char ) {
1591: if (fgets(Lexi_buf[Input_idx],LEX_BUFLEN-1,Input_stream[Input_idx])==NULL) {
1592: /* read in one line */
1593: LIDBUG_PR2("<<yy_input() fgets() returns NULL, input index=%d>>\n",Input_idx);
1594: if( (Input_idx > 0) && ( Lexi_buf[Input_idx][Lexi_pos[Input_idx]] == '\0') ) {
1595: LIDBUG_PR2("<<yy_input() close an input stream, input index=%d>>\n",Input_idx);
1596: fclose(Input_stream[Input_idx]);
1597: capa_mfree((char *)Lexi_buf[Input_idx]);
1598: Lexi_buf[Input_idx] = NULL;
1599: Input_idx--;
1600: yyin = Input_stream[Input_idx];
1601: /* (Lexi_pos[Input_idx])++; */
1602: buf[0] = Lexi_buf[Input_idx][Lexi_pos[Input_idx]-1];
1603: *result = 1;
1604: } else {
1605: *result = YY_NULL; /* End of File */
1606: }
1607: } else { /* successfully read in one line */
1608: leng = strlen(Lexi_buf[Input_idx]);
1609: LIDBUG_PR3("<<yy_input() read into buffer a line(leng=%d), input index=%d>>\n",
1610: leng,Input_idx);
1611: Lexi_pos[Input_idx] = 0;
1612: Lexi_line++;
1613: Current_line[Input_idx]++;
1614: (Lexi_pos[Input_idx])++;
1615: buf[0] = Lexi_buf[Input_idx][Lexi_pos[Input_idx]-1];
1616: /* need to take care of return continuation conditions */
1617: /* so, we return to one-char-at-a-time approach */
1618: /* for(ii=0;ii<leng;ii++) { */
1619: /* buf[ii] = Lexi_buf[Input_idx][ii]; */
1620: /* } */
1621: /* buf[ii] = '\0'; */
1622: /* printf("YY_INPUT()(Lexi_line=%d,max size=%d)(%c)",Lexi_line,max_size,buf[0]); */
1623: *result = 1;
1624: }
1625: } else {
1626: /* LIDBUG_PR2("<<yy_input() increase Lexi_pos, input index=%d>>\n",Input_idx); */
1627: (Lexi_pos[Input_idx])++;
1628: buf[0] = Lexi_buf[Input_idx][Lexi_pos[Input_idx]-1];
1629: *result = 1;
1630: }
1631: if (Stop_Parser==1) *result = YY_NULL;
1632: }
1633:
1634: int capa_eof()
1635: {
1636: #ifdef AVOIDYYINPUT
1637: if ( --include_stack_ptr < 0 ) yyterminate();
1638: else {
1639: yy_delete_buffer( YY_CURRENT_BUFFER );
1640: yy_switch_to_buffer(include_stack[include_stack_ptr]);
1641: }
1642: #else
1643: if(Input_idx == 0) {
1644: fclose(Input_stream[Input_idx]);
1645: capa_mfree((char *)Lexi_buf[Input_idx]);
1646: free_problems(LexiProblem_p);
1647: LexiProblem_p=NULL;
1648: /* printf("\nCAPA EOF\n"); fflush(stdout); */
1649: }
1650: return (0);
1651: #endif /*AVOIDYYINPUT*/
1652: }
1653: /* ------------ */
1654:
1655:
1656: /* =========================================================== */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to capaLexerDef.flex CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [LON-CAPA] / capa / capa51 / pProj