![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to yy.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / pgrm / pascal / src|
Return to yy.h CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / pascal / src |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: *
6: * @(#)yy.h 5.2 (Berkeley) 6/21/85
7: */
8:
9: #include "y.tab.h"
10: #undef CBSIZE /* from paramsys/param.h */
11: /*
12: * INPUT/OUTPUT
13: */
14:
15: /*
16: * The buffer for the input file is normally "ibuf".
17: * When files are included, however, this may be
18: * pushed down in the stack of currently active
19: * files. For this reason, the pointer ibp always
20: * references the i/o buffer of the current input file.
21: */
22: FILE *ibuf, *ibp;
23:
24: /*
25: * Line and token buffers. Charbuf is the character buffer for
26: * input lines, token the buffer for tokens returned
27: * by the scanner. CBSIZE defines the maximum line
28: * length allowed on input and is doubtless too small.
29: * The token buffer should be a local array in yylex.
30: */
31: #ifdef ADDR16
32: #define CBSIZE 161
33: #endif ADDR16
34: #ifdef ADDR32
35: #define CBSIZE 1024
36: #endif ADDR32
37:
38: char charbuf[CBSIZE], *bufp, token[CBSIZE];
39:
40: #define digit(c) (c >= '0' && c <= '9')
41: #define alph(c) ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
42:
43: /*
44: * Flag to prevent reprinting current line after
45: * an error.
46: */
47: char yyprtd;
48:
49: /*
50: * The following variables are maintained by
51: * the scanner in the file lex and used in scanning
52: * and in parsing.
53: *
54: * The variable yychar is the current scanner character.
55: * Currently, the scanner must be called as
56: * yychar = yylex()
57: * even though it should set yychar itself.
58: * Yychar has value YEOF at end of file, and negative value if
59: * there is no yychar, e.g. after a shift in the parser.
60: *
61: * The variable yycol is the current column in the line whose number
62: * is given by yyline. Yyecol and yyeline give the position for an
63: * error message to flag, usually the start of an input token.
64: * Yylval is the semantic return from the scanner.
65: *
66: * In fact all of these variables are "per token".
67: * In the usual case, only the copies in the scanner token structure
68: * 'Y' are used, and the #defines below serve to make them look
69: * like variables.
70: *
71: * For the purposes of the error recovery, however, they are copied
72: * and restored quite freely. For the error recovery also, the
73: * file name which the input line this token is on and the seek
74: * pointer of this line in its source file are saved as yyefile
75: * and yyseekp. The global variable yylinpt is the seek pointer
76: * of the current input line.
77: */
78: int yycol;
79: int yyline;
80: int yyseqid;
81: int yysavc;
82: int yylinpt;
83:
84: /* *** NOTE ***
85: * It would be much better to not have the Yyeline and Yyefile
86: * in the scanner structure and to have a mechanism for mapping
87: * seqid's to these globally.
88: */
89: struct yytok {
90: int Yychar;
91: int Yylval;
92: int Yyecol;
93: int Yyeline;
94: int Yyseekp;
95: char *Yyefile;
96: int Yyeseqid;
97: } Y, OY;
98:
99: #define yychar Y.Yychar
100: #define yylval Y.Yylval
101: #define yyecol Y.Yyecol
102: #define yyeline Y.Yyeline
103: #define yyseekp Y.Yyseekp
104: #define yyefile Y.Yyefile
105: #define yyeseqid Y.Yyeseqid
106:
107: /* Semantic Stack so that y.tab.c will lint */
108:
109: union semstack
110: {
111: int i_entry;
112: struct nl *nl_entry;
113: struct tnode *tr_entry;
114: char *cptr;
115: } yyval;
116:
117: /*
118: * Yyval is the semantic value returned by a reduction.
119: * It is what "$$" is expanded to by yacc.
120: */
121:
122: int *Ps;
123:
124: /*
125: * N is the length of a reduction.
126: * Used externally by "lineof" to get the left and
127: * right margins for a reduction.
128: */
129: int N;
130: /*
131: * Definitions for looking up keywords.
132: * The keyword array is called yykey, and
133: * lastkey points at the end of it.
134: */
135: char *lastkey;
136:
137: struct kwtab {
138: char *kw_str;
139: int kw_val;
140: } yykey[];
141:
142: /*
143: * ERROR RECOVERY EXTERNALS
144: */
145:
146: #define CLIMIT 40 /* see yyrecover.c */
147: char *tokname();
148: char *charname();
149:
150: char *classes[];
151:
152: /*
153: * Tokens which yacc doesn't define
154: */
155: #define YEOF 0
156: #define ERROR 256
157:
158: /*
159: * Limit on the number of syntax errors
160: */
161: #define MAXSYNERR 100
162:
163: /*
164: * Big costs
165: */
166: #define HUGE 50
167: #define INFINITY 100
168:
169: /*
170: * Kinds of panics
171: */
172: #define PDECL 0
173: #define PSTAT 1
174: #define PEXPR 2
175: #define PPROG 3
176:
177: #define yyresume() yyResume = 1;
178:
179: char yyResume;
180:
181: char dquote;
182:
183: #ifndef PC
184: #ifndef OBJ
185: char errout;
186: #endif OBJ
187: #endif PC
188:
189: /*
190: * Yyidwant and yyidhave are the namelist classes
191: * of identifiers associated with a identifier reduce
192: * error, set before the recovery is called.
193: * Since they may be set again during the forward move
194: * they must be saved by yyrecover, which uses them in printing
195: * error messages.
196: */
197: int yyidhave, yyidwant;
198:
199: /*
200: * The variables yy*shifts are used to prevent looping and the printing
201: * of spurious messages in the parser. Yyshifts gives the number of
202: * true input shifts since the last corrective action. YyOshifts
203: * is the value of yyshifts before it was last cleared, and is used
204: * by yyPerror in yypanic.c to suppress messages.
205: *
206: * Yytshifts counts true input shifts. It is used to prevent looping
207: * inserting unique symbols. If yytshifts == yyTshifts (local to
208: * yyrecover.c) then there has been no shift over true input since
209: * the last unique symbol insertion. We refuse, in this case,
210: * to insert more unique symbols so as to prevent looping.
211: *
212: * The recovery cannot loop because it guarantees the progress of the
213: * parse, i.e.:
214: *
215: * 1) Any insertion guarantees to shift over 2 symbols, a replacement
216: * over one symbol.
217: *
218: * 2) Unique symbol insertions are limited to one for each true
219: * symbol of input, or "safe" insertion of the keywords "end"
220: * and "until" at zero cost (safe since these are know to match
221: * stack that cannot have been generated - e.g. "begin" or "repeat")
222: *
223: * 3) We never panic more than once from a given state without
224: * shifting over input, i.e. we force the parse stack to shrink
225: * after each unsuccessful panic.
226: */
227: int yyshifts, yyOshifts;
228: unsigned yytshifts;
229:
230: #ifdef PXP
231:
232: /*
233: * Identifier class definitions
234: */
235: #define UNDEF 0
236: #define CONST 1
237: #define TYPE 2
238: #define VAR 3
239: #define ARRAY 4
240: #define PTRFILE 5
241: #define RECORD 6
242: #define FIELD 7
243: #define PROC 8
244: #define FUNC 9
245: #define FVAR 10
246: #define REF 11
247: #define PTR 12
248: #define FILET 13
249: #define SET 14
250: #define RANGE 15
251: #define LABEL 16
252: #define WITHPTR 17
253: #define SCAL 18
254: #define STR 19
255: #define PROG 20
256: #define IMPROPER 21
257:
258: /*
259: * COMMENT FORMATTING DEFINITIONS
260: */
261:
262: /*
263: * Count of tokens on this input line
264: * Note that this can be off if input is not syntactically correct.
265: */
266: int yytokcnt;
267: int yywhcnt;
268:
269: /*
270: * Types of comments
271: */
272: #define CLMARG 0
273: #define CALIGN 1
274: #define CTRAIL 2
275: #define CRMARG 3
276: #define CSRMARG 4
277: #define CNL 5
278: #define CNLBL 6
279: #define CFORM 7
280: #define CINCLUD 8
281:
282: /*
283: * Comment structure
284: * Cmhp is the head of the current list of comments
285: */
286: struct comment {
287: struct comment *cmnext;
288: int cmdelim;
289: struct commline *cml;
290: int cmjust;
291: int cmseqid;
292: } *cmhp;
293:
294: /*
295: * Structure for holding a comment line
296: */
297: struct commline {
298: char *cmtext;
299: int cmcol; /* Only used for first line of comment currently */
300: struct commline *cml;
301: };
302:
303: struct W {
304: int Wseqid;
305: int Wcol;
306: } yyw[MAXDEPTH + 1], *yypw;
307:
308: #define commform() quickcomm(CFORM)
309: #define commnl() quickcomm(CNL)
310: #define commnlbl() quickcomm(CNLBL)
311: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.