![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to yycosts.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / pascal / src|
Return to yycosts.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / 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:
7: #ifndef lint
8: static char sccsid[] = "@(#)yycosts.c 5.1 (Berkeley) 6/5/85";
9: #endif not lint
10:
11: #include "whoami.h"
12: #include "0.h"
13: #include "tree_ty.h" /* must be included for yy.h */
14: #include "yy.h"
15:
16: /*
17: * Symbol costs for Pascal.
18: *
19: * Cost strategy of August 14, 1977.
20: *
21: * The costs determined by the routines in this file are used by
22: * the recovery in choosing appropriate corrections.
23: * The cost vectors and the error productions in the grammar
24: * work together to define the corrective capacity of the grammar.
25: *
26: * The costs here largely derive from those given in Steve Rhode's
27: * thesis for the Pascal-I error correcting parser which he implemented.
28: * Some minor changes have been made to adjust for the fact that
29: * the current error recovery is not as "smart", both because of the
30: * limited forward move and because of the lack of any type information
31: * about identifiers.
32: *
33: * These adjustments largely take the form of increased costs for certain
34: * tokens, noticeably keywords which are major brackets such as "begin"
35: * "label", "procedure", etc.
36: *
37: * The overall weighting strategy is still similar to Rhodes' strategy.
38: * The costs can be considered:
39: *
40: * LOW <= 3
41: * MEDIUM 4 or 5
42: * HIGH >= 6
43: */
44:
45: /*
46: * Insertion costs
47: *
48: * In addition to the normal symbol insertion costs,
49: * there are zero cost insertions here.
50: * The current error recovery system treats symbols
51: * which have zero insertion cost in a special way,
52: * inserting them but suppressing diagnostics.
53: * This allows the system to hold of on bracketing
54: * error diagnostics about missing end's until the
55: * reduction occurs which knows the line number of the
56: * corresponding "begin", "repeat", etc.
57: * A more intelligent and useful diagnostic can then
58: * be printed.
59: *
60: * Although this routine never allows the insertion
61: * of the keyword begin, it can be inserted after a
62: * procedure or function body starts, if it was omitted
63: * by a special case in the panic routine, which notices
64: * the keywords in the statement body of the procedure
65: * and inserts the begin to recover.
66: *
67: * Similarly, we do not insert end-of-file, but
68: * the fact that end-of-file is the unique input
69: * is noticed by the recovery routines as a special
70: * case and handled there.
71: */
72: inscost(sy, before)
73: register int sy, before;
74: {
75:
76: switch (before) {
77: case YEND:
78: if (sy == YEND)
79: break;
80: case YPROCEDURE:
81: case YFUNCTION:
82: if (sy == YUNTIL || sy == YEND)
83: return (0);
84: }
85: switch (sy) {
86: case ';':
87: return (1);
88: case ',':
89: case ':':
90: case YOF:
91: case YDO:
92: return (2);
93: case YARRAY:
94: case '+':
95: case '*':
96: return (3);
97: default:
98: return (4);
99: case '^':
100: case YNOT:
101: case YLABEL:
102: case YCONST:
103: case YTYPE:
104: case YVAR:
105: case YUNTIL:
106: case '(':
107: case '[':
108: case YWHILE:
109: case YWITH:
110: return (5);
111: case YPROCEDURE:
112: case YFUNCTION:
113: case YCASE:
114: return (6);
115: case YEND:
116: return (8);
117: case YBEGIN:
118: case YEOF:
119: case YREPEAT:
120: case YRECORD:
121: return (INFINITY);
122: }
123: }
124:
125: /*
126: * Replacement costs
127: *
128: * Most replacement costs are the same as an insertion
129: * plus a deletion cost. One special case is the replacement
130: * of a large number of keywords by an identifier.
131: * These are given lower costs, especially the keyword "to".
132: */
133: repcost(what, with)
134: register int what, with;
135: {
136: register int c;
137:
138: if (with == what)
139: return (INFINITY);
140: if (with == YID && what > ERROR)
141: switch (what) {
142: case YID:
143: case YDOTDOT:
144: case YINT:
145: case YBINT:
146: case YSTRING:
147: case YNUMB:
148: break;
149: case YTO:
150: return (3);
151: default:
152: return (5);
153: case YRECORD:
154: case YTHEN:
155: return (6);
156: case YBEGIN:
157: break;
158: }
159: if (what == YID && with == YFORWARD)
160: return(5);
161: if (what == ';' && (with == ',' || with == '.'))
162: return (CLIMIT - 1);
163: c = delcost(what) + inscost(with, what);
164: /*
165: * It costs extra to replace something which has
166: * semantics by something which doesn't.
167: */
168: if (nullsem(what) == NIL && nullsem(with) != NIL)
169: c += 4;
170: return (c);
171: }
172:
173: /*
174: * Deletion costs
175: */
176: delcost(what)
177: int what;
178: {
179:
180: switch (what) {
181: case '.':
182: case ':':
183: case ',':
184: case '=':
185: case '(':
186: return (3);
187: case YELSE:
188: case YTHEN:
189: return (4);
190: default:
191: return (5);
192: case YLABEL:
193: case YCONST:
194: case YTYPE:
195: case YVAR:
196: return (10);
197: case YPROCEDURE:
198: case YFUNCTION:
199: case YBEGIN:
200: case YEND:
201: return ((CLIMIT * 3) / 4);
202: case ';':
203: case YEOF:
204: return (INFINITY);
205: }
206: }
207: #ifdef DEBUG
208:
209: /*
210: * Routine to print out costs with "-K" option.
211: */
212: char yysyms[] = ";,:=*+/-|&()[]<>~^";
213:
214:
215: yycosts()
216: {
217: register int c;
218: register char *cp;
219:
220: printf("Insert\tDelete\tRep(ID)\tSymbol\n");
221: for (cp = yysyms; *cp; cp++)
222: yydocost(*cp);
223: for (c = ERROR + 1; c < YLAST; c++)
224: yydocost(c);
225: #ifdef PXP
226: flush();
227: #endif
228: }
229:
230: yydocost(c)
231: int c;
232: {
233:
234: printf("%4d\t", inscost(c, -1));
235: printf("%4d\t", delcost(c));
236: if (repcost(c, YID) != inscost(YID, c) + delcost(c))
237: printf("%4d", repcost(c, YID));
238: printf("\t%s%s\n", charname(c,1));
239: }
240: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.