![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gram_utils.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront|
Return to gram_utils.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront |
1.1 root 1: /* utilities used by the grammar. We never change them, so why
2: compile them constantly ? */
3:
4: #include "cfront.h"
5:
6: /* macros filtched from gram.skeleton */
7:
8: #define yylex lalex
9: extern TOK la_look();
10: extern void la_backup( TOK, YYSTYPE );
11: extern int la_cast();
12: extern int la_decl();
13: extern TOK lalex();
14: extern int yychar, must_be_id, DECL_TYPE, declTag;
15: FILE * yydebugfile;
16:
17: char * gram_print_node (int tok, YYSTYPE* val)
18: {
19: static char buffer[1000];
20:
21: switch(tok) {
22: case ID:
23: case TNAME:
24: Pname n = val->pn;
25: return n->string;
26: case STRING:
27: return val->s;
28: default:
29: sprintf(buffer, "0x%x", val->p);
30: return buffer;
31: }
32: }
33:
34: #define NEXTTOK() ( (yychar==-1) ? (yychar=yylex(),yychar) : yychar )
35: #define EXPECT_ID() must_be_id = 1
36: #define NOT_EXPECT_ID() must_be_id = 0
37:
38: Pptr doptr(TOK p, TOK t)
39: {
40: Pptr r = new ptr(p,0);
41: switch (t) {
42: case CONST:
43: r->rdo = 1;
44: // if (p == RPTR) error('w',"redundant `const' after &");
45: break;
46: case VOLATILE:
47: error('w',"\"volatile\" not implemented (ignored)");
48: break;
49: default:
50: error("syntax error: *%k",t);
51: }
52: return r;
53: }
54:
55: Pbcl dobase(TOK pr, Pname n, TOK v = 0)
56: {
57: Pbcl b = new basecl(0,0);
58:
59: if (pr == PROTECTED) {
60: pr = PUBLIC;
61: error("protectedBC");
62: }
63: b->ppp = pr; // save protection indicator
64:
65: if (n) {
66: if (n->base != TNAME) {
67: error("BN%n not aTN",n);
68: return 0;
69: }
70:
71: Pbase bt = Pbase(n->tp);
72: while (bt->base == TYPE) bt = Pbase(bt->b_name->tp);
73:
74: if (bt->base != COBJ) {
75: error("BN%n not aCN",n);
76: return 0;
77: }
78:
79: if (v) {
80: if (v != VIRTUAL) error("syntax error:%k inBCD",v);
81: b->base = VIRTUAL;
82: }
83: else
84: b->base = NAME;
85:
86: b->bclass = Pclass(bt->b_name->tp);
87: }
88:
89: return b;
90: }
91:
92: extern int yyparse ();
93: extern YYSTYPE yylval, yyval;
94:
95: Pname syn()
96: {
97: ll:
98: switch (yyparse()) {
99: case 0: return 0; // EOF
100: case 1: goto ll; // no action needed
101: default: return yyval.pn;
102: }
103: }
104:
105: void
106: check_cast()
107: /*
108: Lookahead to direct parsing of cast
109: la_cast() returns 1 if lookahead sees an ambiguous old-style C cast.
110: */
111: {
112: switch( NEXTTOK() ) {
113: case TYPE: case TNAME:
114: if ( la_look() == LP && la_cast() ) {
115: must_be_id = 0;
116: yychar = DECL_MARKER;
117: }
118: }
119: }
120:
121: void
122: check_decl()
123: /*
124: Lookahead to direct parsing of local/arg type declarations
125: la_decl() returns 1 if lookahead sees a declaration.
126: */
127: {
128:
129: switch( NEXTTOK() ) {
130: case TYPE: case TNAME:
131: if ( la_look() == LP && la_decl() ) {
132: must_be_id = 0;
133: DECL_TYPE=yychar;
134: yychar = DECL_MARKER;
135: }
136: }
137: }
138:
139: void
140: check_tag()
141: /*
142: Allow the case of inline/virtual/overload as
143: modifiers of return type of form struct/class/union x foo()
144: SM, COLON, LC ==> real class declaration, not return type
145: */
146: {
147: switch ( NEXTTOK() ) {
148: case SM: case COLON: case LC:
149: declTag = 1;
150: break;
151: default:
152: declTag = 0;
153: break;
154: }
155: }
156:
157: Pname find_fct_dcl (Pname fname)
158: {
159: Pname function_name;
160:
161: if(!(fname && fname->base == NAME && fname->tp && fname->tp->base == FCT))
162: return 0;
163: /* In an ideal world, we would defer this to something in semantics.
164: oh well, here we go. */
165:
166: if (fname->n_qualifier) {
167: Pname cn = fname->n_qualifier;
168:
169: switch (cn->base) {
170: case TNAME:
171: break;
172: case NAME:
173: cn = gtbl->look(cn->string,0);
174: if (cn && cn->base==TNAME) break;
175: default:
176: error("badQr%n for%n",fname->n_qualifier,fname);
177: return 0;
178: }
179:
180: if (cn->tp->base != COBJ) {
181: return 0;
182: }
183:
184: cn = Pbase(cn->tp)->b_name;
185:
186: Pclass cl = Pclass(cn->tp);
187:
188: if ((cl->defined&(DEFINED|SIMPLIFIED)) == 0) {
189: error("C%nU",cn);
190: return 0;
191: }
192:
193: Ptable etbl = cl->memtbl;
194: Pname x = etbl->look(fname->string,0);
195: if (x==0 || x->n_table!=etbl) {
196: error("%n is not aM of%n",fname,cn);
197: return 0;
198: }
199:
200: if(x->base != NAME || x->tp == 0) {
201: return 0;
202: }
203:
204: function_name = x;
205: } else {
206: function_name = gtbl->look (fname->string, 0);
207: if(!function_name) {
208: err::print ("No function %s.", err::name_string (fname));
209: return 0;
210: }
211: }
212:
213: switch(function_name->tp->base) {
214: case FCT:
215: break;
216: case OVERLOAD:
217: function_name = Pgen(function_name->tp)->find(Pfct(fname->tp),0);
218: if(!function_name) {
219: err::print ("Pragma specifies undefined function.");
220: return 0;
221: }
222: }
223:
224: return function_name;
225: }
226:
227:
228: void mark_abnormal_query_function (Pname fname)
229: {
230: Pname function_name = find_fct_dcl(fname);
231: if(!function_name) {
232: err::print("#pragma ObjectStore query_abnormal_operator must be followed by a function declaration.");
233: }
234: else Pfct(function_name->tp)->f_query_abnormal = 1;
235: }
236:
237: void declare_query_zvec_compare_function (Pname fn)
238: {
239: Pname function_name = find_fct_dcl(fn);
240: int found = 0;
241: if(!function_name)
242: err::print("#pragma ObjectStore query_zvec_compare_function must be followed by a function declaration.");
243: else Pfct(function_name->tp)->f_query_compare = 1;
244: }
245:
246: void declare_query_zvec_copy_function (Pname fn)
247: {
248: Pname function_name = find_fct_dcl(fn);
249: int found = 0;
250: if(!function_name)
251: err::print("#pragma ObjectStore query_zvec_copy_function must be followed by a function declaration.");
252: else Pfct(function_name->tp)->f_query_copy = 1;
253: }
254:
255: void register_zvec_type (Ptype t);
256:
257: void declare_query_zvec_type (Pname tn)
258: {
259: register_zvec_type (tn->tp);
260: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.