]> andersk Git - splint.git/blame - src/cgrammar.y
andersk / splint.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Making changes to try to support loops.
[splint.git] / src / cgrammar.y
CommitLineData
885824d3 1/*;-*-C-*-;
2** Copyright (c) Massachusetts Institute of Technology 1994-1998.
3** All Rights Reserved.
4** Unpublished rights reserved under the copyright laws of
5** the United States.
6**
7** THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
8** OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
9**
10** This code is distributed freely and may be used freely under the
11** following conditions:
12**
13** 1. This notice may not be removed or altered.
14**
15** 2. Works derived from this code are not distributed for
16** commercial gain without explicit permission from MIT
17** (for permission contact lclint-request@sds.lcs.mit.edu).
18*/
19%{
20/*
21**
22** cgrammar.y
23**
24** Yacc/Bison grammar for extended ANSI C used by LCLint.
25**
26** original grammar by Nate Osgood ---
27** hacrat@catfish.lcs.mit.edu Mon Jun 14 13:06:32 1993
28**
29** changes for LCLint --- handle typedef names correctly
30** fix struct/union parsing bug (empty struct is accepted)
31** add productions to handle macros --- require
32** error correction --- main source of conflicts in grammar.
33** need to process initializations sequentially, L->R
34**
35** production names are cryptic, so more productions fit on one line
36**
37** conflicts: 87 shift/reduce, 18 reduce/reduce
38** most of these are due to handling macros
39** a few are due to handling type expressions
40*/
41
42/*@=allmacros@*/
43
44extern int yylex ();
45extern void swallowMacro (void);
46
47# include "lclintMacros.nf"
48# include "basic.h"
49# include "cgrammar.h"
50# include "exprChecks.h"
51
52/*@-allmacros@*/
53/*@-matchfields@*/
54
55# define SHOWCSYM FALSE
56void yyerror (char *s);
57
58/*
59** This is necessary, or else when the bison-generated code #include's malloc.h,
60** there will be a parse error.
61**
62** Unfortunately, it means the error checking on malloc, etc. is lost for allocations
63** in bison-generated files under Win32.
64*/
65
66# ifdef WIN32
67# undef malloc
68# undef calloc
69# undef realloc
70# endif
71
1ac6313d 72void checkandsetBufState(idDecl id, exprNode is);
885824d3 73%}
74
75%union
76{
77 lltok tok;
78 int count;
79 specialClauseKind sck;
80 qual typequal;
81 qualList tquallist;
82 ctype ctyp;
83 sRef sr;
84 /*@only@*/ qtype qtyp;
85 /*@only@*/ cstring cname;
86 /*@only@*/ idDecl ntyp;
87 /*@only@*/ idDeclList ntyplist;
88 /*@only@*/ uentryList flist;
89 /*@owned@*/ uentryList entrylist;
90 /*@observer@*/ /*@dependent@*/ uentry entry;
91 /*@only@*/ uentry oentry;
92 /*@only@*/ exprNode expr;
93 /*@only@*/ enumNameList enumnamelist;
94 /*@only@*/ exprNodeList alist;
95 /*@only@*/ sRefSet srset;
96 /*@only@*/ cstringList cstringlist;
97}
98
99/* standard C tokens */
100
101%token <tok> BADTOK SKIPTOK
102%token <tok> CTOK_ELIPSIS CASE DEFAULT CIF CELSE SWITCH WHILE DO CFOR
103%token <tok> GOTO CONTINUE BREAK RETURN
104%token <tok> TSEMI TLBRACE TRBRACE TCOMMA TCOLON TASSIGN TLPAREN
105%token <tok> TRPAREN TLSQBR TRSQBR TDOT TAMPERSAND TEXCL TTILDE
106%token <tok> TMINUS TPLUS TMULT TDIV TPERCENT TLT TGT TCIRC TBAR TQUEST
107%token <tok> CSIZEOF CALIGNOF ARROW_OP CTYPEDEF COFFSETOF
108%token <tok> INC_OP DEC_OP LEFT_OP RIGHT_OP
109%token <tok> LE_OP GE_OP EQ_OP NE_OP AND_OP OR_OP
110%token <tok> MUL_ASSIGN DIV_ASSIGN MOD_ASSIGN ADD_ASSIGN SUB_ASSIGN
111%token <tok> LEFT_ASSIGN RIGHT_ASSIGN AND_ASSIGN XOR_ASSIGN OR_ASSIGN
112%token <tok> CSTRUCT CUNION CENUM
113%token <tok> VA_ARG VA_DCL
114%token <tok> QGLOBALS
115%token <tok> QMODIFIES
116%token <tok> QNOMODS
117%token <tok> QCONSTANT
118%token <tok> QFUNCTION
119%token <tok> QITER
120%token <tok> QDEFINES
121%token <tok> QUSES
122%token <tok> QALLOCATES
123%token <tok> QSETS
124%token <tok> QRELEASES
125%token <tok> QPRECLAUSE
126%token <tok> QPOSTCLAUSE
127%token <tok> QALT
128%token <tok> QUNDEF QKILLED
129%token <tok> QENDMACRO
130
131/* additional tokens introduced by lclint pre-processor. */
132%token <tok> LLMACRO LLMACROITER LLMACROEND TENDMACRO
133
134/* break comments: */
135%token <tok> QSWITCHBREAK QLOOPBREAK QINNERBREAK QSAFEBREAK
136%token <tok> QINNERCONTINUE
137
138/* case fall-through marker: */
139%token <tok> QFALLTHROUGH
140
141/* used in scanner only */
142%token <tok> QLINTNOTREACHED
143%token <tok> QLINTFALLTHROUGH
144%token <tok> QLINTFALLTHRU
145%token <tok> QARGSUSED
146%token <tok> QPRINTFLIKE QLINTPRINTFLIKE QSCANFLIKE QMESSAGELIKE
147
148/* not-reached marker: (used like a label) */
149%token <tok> QNOTREACHED
150
151/* type qualifiers: */
152%token <tok> QCONST QVOLATILE QINLINE QEXTENSION QEXTERN QSTATIC QAUTO QREGISTER
153%token <tok> QOUT QIN QYIELD QONLY QTEMP QSHARED QREF QUNIQUE
154%token <tok> QCHECKED QUNCHECKED QCHECKEDSTRICT QCHECKMOD
155%token <tok> QKEEP QKEPT QPARTIAL QSPECIAL QOWNED QDEPENDENT
156%token <tok> QRETURNED QEXPOSED QNULL QOBSERVER QISNULL
157%token <tok> QEXITS QMAYEXIT QNEVEREXIT QTRUEEXIT QFALSEEXIT
158%token <tok> QLONG QSIGNED QUNSIGNED QSHORT QUNUSED QSEF QNOTNULL QRELNULL
159%token <tok> QABSTRACT QCONCRETE QMUTABLE QIMMUTABLE
160%token <tok> QTRUENULL QFALSENULL QEXTERNAL
161%token <tok> QREFCOUNTED QREFS QNEWREF QTEMPREF QKILLREF QRELDEF
162%token <ctyp> CGCHAR CBOOL CINT CGFLOAT CDOUBLE CVOID
163%token <tok> QANYTYPE QINTEGRALTYPE QUNSIGNEDINTEGRALTYPE QSIGNEDINTEGRALTYPE
164
93307a76 165%token <tok> QNULLTERMINATED
11ed4f45 166%token <tok> QSETBUFFERSIZE
93307a76 167%token <tok> QBUFFERCONSTRAINT
ef2aa32a 168%token <tok> QENSURESCONSTRAINT
11ed4f45 169%token <tok> QSETSTRINGLENGTH
93307a76 170%token <tok> QMAXSET
171%token <tok> QMAXREAD
a0a162cd 172%token <tok> QTESTINRANGE
11ed4f45 173
93307a76 174
175
885824d3 176/* identifiers, literals */
177%token <entry> IDENTIFIER
178%token <cname> NEW_IDENTIFIER TYPE_NAME_OR_ID
179%token <expr> CCONSTANT
180%token <entry> ITER_NAME ITER_ENDNAME
181%type <entry> endIter
182%type <sr> globId
183%token <ctyp> TYPE_NAME
184%type <cname> enumerator newId /*@-varuse@*/ /* yacc declares yytranslate here */
185%type <count> pointers /*@=varuse@*/
186
187%type <tok> doHeader specialTag endSpecialTag stateSpecialClause endStateTag
188%type <sck> specialClauseType
189
190/* type construction */
191%type <ctyp> abstractDecl abstractDeclBase optAbstractDeclBase
192%type <ctyp> suSpc enumSpc typeName typeSpecifier
193
194%type <ntyp> namedDecl namedDeclBase optNamedDecl
195%type <ntyp> plainNamedDecl plainNamedDeclBase
196%type <ntyp> structNamedDecl
197%type <ntyp> fcnDefHdrAux plainFcn
198
199%type <oentry> paramDecl
200%type <entry> id
201
202%type <ntyplist> structNamedDeclList
203
204%type <entrylist> genericParamList paramTypeList paramList idList paramIdList
205%type <alist> argumentExprList iterArgList
206%type <alist> initList
207%type <flist> structDeclList structDecl
208%type <srset> locModifies locPlainModifies modList specClauseList
209%type <sr> mExpr modListExpr specClauseListExpr
93307a76 210
211/*drl*/
212%type <sr> BufConstraint
213%type <tok> relationalOp
214%type <tok> BufBinaryOp
215%type <tok> bufferModifier
216
217%type <sr> BufConstraintExpr
218
219%type <sr> BufConstraintTerm
220
221%type <sr> BufConstraintList
222
223%type <tok> BufUnaryOp
224
885824d3 225%type <enumnamelist> enumeratorList
226%type <cstringlist> fieldDesignator
227
228%type <expr> sizeofExpr sizeofExprAux offsetofExpr
229%type <expr> openScope closeScope
230%type <expr> instanceDecl namedInitializer optDeclarators
231%type <expr> primaryExpr postfixExpr primaryIterExpr postfixIterExpr
232%type <expr> unaryExpr castExpr timesExpr plusExpr
233%type <expr> unaryIterExpr castIterExpr timesIterExpr plusIterExpr
234%type <expr> shiftExpr relationalExpr equalityExpr bitandExpr
235%type <expr> xorExpr bitorExpr andExpr
236%type <expr> orExpr conditionalExpr assignExpr
237%type <expr> shiftIterExpr relationalIterExpr equalityIterExpr bitandIterExpr
238%type <expr> xorIterExpr bitorIterExpr andIterExpr
239%type <expr> orIterExpr conditionalIterExpr assignIterExpr iterArgExpr
240%type <expr> expr optExpr constantExpr
241%type <expr> init macroBody iterBody endBody partialIterStmt iterSelectionStmt
242%type <expr> stmt stmtList fcnBody iterStmt iterDefStmt iterDefStmtList
243%type <expr> labeledStmt caseStmt defaultStmt
244%type <expr> compoundStmt compoundStmtAux compoundStmtRest compoundStmtAuxErr
245%type <expr> expressionStmt selectionStmt iterationStmt jumpStmt iterDefIterationStmt
246%type <expr> stmtErr stmtListErr compoundStmtErr expressionStmtErr
247%type <expr> iterationStmtErr initializerList initializer ifPred whilePred forPred iterWhilePred
11ed4f45 248%type <expr> tst1
885824d3 249
250%type <typequal> storageSpecifier typeQualifier typeModifier globQual
251%type <tquallist> optGlobQuals
252%type <qtyp> completeType completeTypeSpecifier optCompleteType
253%type <qtyp> completeTypeSpecifierAux altType typeExpression
11ed4f45 254%type <expr> lclintassertion
885824d3 255
256%start file
257
258%%
259
260file
261 :
262 | externalDefs
263
264externalDefs
265 : externalDef
266 | externalDefs externalDef
267
268externalDef
269 : fcnDef optSemi { uentry_clearDecl (); }
270 | constantDecl { uentry_clearDecl (); }
271 | fcnDecl { uentry_clearDecl (); }
272 | iterDecl { uentry_clearDecl (); }
273 | macroDef { uentry_clearDecl (); }
274 | initializer { uentry_checkDecl (); exprNode_free ($1); }
275 | error { uentry_clearDecl (); }
276
277constantDecl
278 : QCONSTANT completeTypeSpecifier NotType namedDecl NotType optSemi IsType QENDMACRO
279 { checkConstant ($2, $4); }
280 | QCONSTANT completeTypeSpecifier NotType namedDecl NotType TASSIGN IsType init optDeclarators optSemi QENDMACRO
281 { checkValueConstant ($2, $4, $8) ; }
282
283fcnDecl
284 : QFUNCTION { context_enterFunctionDecl (); } plainFcn optSemi QENDMACRO
285 { declareStaticFunction ($3); context_quietExitFunction ();
286 context_exitFunctionDecl (); }
287
288plainFcn
289 : plainNamedDecl
290 {
291 qtype qint = qtype_create (ctype_int);
292 $$ = idDecl_fixBase ($1, qint);
293 qtype_free (qint);
294 }
295 | completeTypeSpecifier NotType plainNamedDecl
296 { $$ = idDecl_fixBase ($3, $1); }
297
298plainNamedDecl
299 : plainNamedDeclBase
300 | pointers plainNamedDeclBase
301 { $$ = $2; qtype_adjustPointers ($1, idDecl_getTyp ($$)); }
302
303namedDeclBase
304 : newId { $$ = idDecl_create ($1, qtype_unknown ()); }
305 | IsType TLPAREN NotType namedDecl IsType TRPAREN
306 { $$ = idDecl_expectFunction ($4); }
307 | namedDeclBase TLSQBR TRSQBR
308 { $$ = idDecl_replaceCtype ($1, ctype_makeArray (idDecl_getCtype ($1))); }
309 | namedDeclBase TLSQBR IsType constantExpr TRSQBR NotType
310 {
a0a162cd 311 $$ = idDecl_replaceCtype ($1, ctype_makeFixedArray (idDecl_getCtype ($1), exprNode_getLongValue ($4)));
885824d3 312 }
313 | namedDeclBase PushType TLPAREN TRPAREN
314 { setCurrentParams (uentryList_missingParams);
315 }
93307a76 316 optGlobMods optGlobBufConstraints
885824d3 317 { /* need to support globals and modifies here! */
318 ctype ct = ctype_makeFunction (idDecl_getCtype ($1),
319 uentryList_makeMissingParams ());
320
321 $$ = idDecl_replaceCtype ($1, ct);
322 context_popLoc ();
323 }
324 | namedDeclBase PushType TLPAREN genericParamList TRPAREN
325 { setCurrentParams ($4);
326 }
93307a76 327 optGlobMods optGlobBufConstraints
885824d3 328 { clearCurrentParams ();
329 $$ = idDecl_replaceCtype ($1, ctype_makeFunction (idDecl_getCtype ($1), $4));
93307a76 330 context_popLoc ();
331
34f0c5e7 332 // printf("Done nameDeclBase\n");
885824d3 333 }
334
335plainNamedDeclBase
336 : newId { $$ = idDecl_create ($1, qtype_unknown ()); }
337 | IsType TLPAREN NotType plainNamedDecl IsType TRPAREN
338 { $$ = idDecl_expectFunction ($4); }
339 | plainNamedDeclBase TLSQBR TRSQBR
340 { $$ = idDecl_replaceCtype ($1, ctype_makeArray (idDecl_getCtype ($1))); }
341 | plainNamedDeclBase TLSQBR IsType constantExpr TRSQBR NotType
342 {
343 int value;
344
345 if (exprNode_hasValue ($4)
346 && multiVal_isInt (exprNode_getValue ($4)))
347 {
348 value = (int) multiVal_forceInt (exprNode_getValue ($4));
349 }
350 else
351 {
352 value = 0;
353 }
354
355 $$ = idDecl_replaceCtype ($1, ctype_makeFixedArray (idDecl_getCtype ($1), value));
356 }
357 | plainNamedDeclBase PushType TLPAREN TRPAREN
358 { setCurrentParams (uentryList_missingParams);
359 }
360 optPlainGlobMods
361 { /* need to support globals and modifies here! */
362 ctype ct = ctype_makeFunction (idDecl_getCtype ($1),
363 uentryList_makeMissingParams ());
364
365 $$ = idDecl_replaceCtype ($1, ct);
366 context_popLoc ();
367 }
368 | plainNamedDeclBase PushType TLPAREN genericParamList TRPAREN
369 { setCurrentParams ($4);
370 }
371 optPlainGlobMods
372 { clearCurrentParams ();
373 $$ = idDecl_replaceCtype ($1, ctype_makeFunction (idDecl_getCtype ($1), $4));
374 context_popLoc ();
375 }
376
377iterDecl
378 : QITER newId TLPAREN genericParamList TRPAREN
379 { setCurrentParams ($4); } optPlainGlobMods
380 { clearCurrentParams (); } optSemi QENDMACRO
381 { declareCIter ($2, $4); }
382
383macroDef
384 : LLMACRO macroBody TENDMACRO { exprNode_checkMacroBody ($2); }
385 | LLMACROITER iterBody TENDMACRO { exprNode_checkIterBody ($2); }
386 | LLMACROEND endBody TENDMACRO { exprNode_checkIterEnd ($2); }
387 | LLMACRO TENDMACRO /* no stmt */ { exprChecks_checkEmptyMacroBody (); }
388
389fcnDefHdr
390 : fcnDefHdrAux { declareFunction ($1); }
391
392optGlobMods
393 : { setProcessingGlobMods (); } optGlobModsRest
394 { clearProcessingGlobMods (); }
395
93307a76 396
397/*drl*/
398
38496f11 399optGlobBufConstraints
93307a76 400 : { setProcessingGlobMods (); } optGlobBufConstraintsRest
401 { clearProcessingGlobMods (); }
402
38496f11 403
404optGlobBufConstraintsRest
ef2aa32a 405 : optGlobBufConstraintsAux optGlobEnsuresConstraintsAux
406
407
408optGlobEnsuresConstraintsAux
409: {
410 DPRINTF ( ("doing optGlobEnsuresConstraintsAux\n") );
411context_setProtectVars (); enterParamsTemp ();
412 sRef_setGlobalScopeSafe ();
413
414} QENSURESCONSTRAINT BufConstraintList QENDMACRO
415{
416 setEnsuresConstraints ($3);
417 exitParamsTemp ();
418 sRef_clearGlobalScopeSafe ();
419 context_releaseVars ();
420 DPRINTF (("done optGlobBufConstraintsAux\n"));}
421 | /*empty*/
422
38496f11 423
424optGlobBufConstraintsAux
93307a76 425: {
34f0c5e7 426 DPRINTF ( ("doing optGlobBufConstraintsAux\n") );
93307a76 427context_setProtectVars (); enterParamsTemp ();
428 sRef_setGlobalScopeSafe ();
429
430} QBUFFERCONSTRAINT BufConstraintList QENDMACRO
431{
432 setFunctionConstraints ($3);
433 exitParamsTemp ();
434 sRef_clearGlobalScopeSafe ();
435 context_releaseVars ();
ef2aa32a 436 DPRINTF (("done optGlobBufConstraintsAux\n"));}
38496f11 437 | /*empty*/
438
93307a76 439BufConstraintList
440: BufConstraint BufConstraintList{ $$ = constraintList_add ($2, $1); }
441| BufConstraint {constraintList c; c = constraintList_new(); c = constraintList_add (c, $1); $$ = c}
442
443BufConstraint
444: BufConstraintExpr relationalOp BufConstraintExpr TSEMI {
445 $$ = makeConstraintParse3 ($1, $2, $3);
ef2aa32a 446 DPRINTF(("Done BufConstraint1\n")); }
93307a76 447
448bufferModifier
449 : QMAXSET
450 |QMAXREAD
451
452relationalOp
453 : GE_OP
454 | LE_OP
455 | EQ_OP
456
457BufConstraintExpr
458 : BufConstraintTerm
34f0c5e7 459 | BufUnaryOp TLPAREN BufConstraintExpr TRPAREN {$$ = constraintExpr_parseMakeUnaryOp ($1, $3); DPRINTF( ("Got BufConstraintExpr UNary Op ") ); }
93307a76 460 | TLPAREN BufConstraintExpr BufBinaryOp BufConstraintExpr TRPAREN {
34f0c5e7 461 DPRINTF( ("Got BufConstraintExpr BINary Op ") );
93307a76 462 $$ = constraintExpr_parseMakeBinaryOp ($2, $3, $4); }
463
464BufConstraintTerm
ef2aa32a 465: id { /* $$ = constraintExpr_makeTermsRef (checkSpecClausesId ($1)); */
466 $$ = constraintExpr_makeTermsRef (checkbufferConstraintClausesId ($1));}
467 | NEW_IDENTIFIER { $$ = constraintExpr_makeTermsRef(fixSpecClausesId ($1) ); }
93307a76 468 | CCONSTANT { char *t; int c;
469 t = cstring_toCharsSafe (exprNode_unparse($1));
470 c = atoi( t );
471 $$ = constraintExpr_makeIntLiteral (c);
472}
473
474/*BufConstraintExpr
475: BufConstraintTerm
476*/
477
478BufUnaryOp
479: bufferModifier
480;
481
482BufBinaryOp
483 : TPLUS
484| TMINUS
485;
486
487
488koptPlainGlobMods
489 : { setProcessingGlobMods (); } optPlainGlobModsRest
490 { clearProcessingGlobMods (); }
491
492
493/*: id { $$ = unentry_getSref($1); checkModifiesId ($1); }
494| NEW_INDENTIFIER { $$ = fixModifiesId ($1)} */
495
38496f11 496/*end*/
497
93307a76 498
885824d3 499optPlainGlobMods
500 : { setProcessingGlobMods (); } optPlainGlobModsRest
501 { clearProcessingGlobMods (); }
502
503optGlobModsRest
504 : optGlobModsAux
505 | specialClauses optGlobModsAux
506
507optPlainGlobModsRest
508 : optPlainGlobModsAux
509 | specialClauses optPlainGlobModsAux
510
511specialClauses
512 : specialClause
513 | specialClause specialClauses
514
515globIdList
516 : globIdListExpr { ; }
517 | globIdList TCOMMA globIdListExpr { ; }
518
519globIdListExpr
520 : optGlobQuals globId { globListAdd ($2, $1); }
521
522globId
523 : id { $$ = uentry_getSref ($1); }
524 | NEW_IDENTIFIER { $$ = globListUnrecognized ($1); }
525
526globQual
527 : QUNDEF { $$ = qual_createUndef (); }
528 | QKILLED { $$ = qual_createKilled (); }
529 | QOUT { $$ = qual_createOut (); }
530 | QIN { $$ = qual_createIn (); }
531 | QPARTIAL { $$ = qual_createPartial (); }
532
533optGlobQuals
534 : /* empty */ { $$ = qualList_undefined; }
535 | globQual optGlobQuals { $$ = qualList_add ($2, $1); }
536
537optGlobModsAux
538 : QGLOBALS { setProcessingGlobalsList (); } initializerList optSemi
539 QENDMACRO optMods
540 { unsetProcessingGlobals (); }
541 | QGLOBALS { setProcessingGlobalsList (); } globIdList optSemi
542 QENDMACRO optMods
543 { unsetProcessingGlobals (); }
544 | QNOMODS
545 { setFunctionNoGlobals ();
546 setFunctionModifies (sRefSet_single (sRef_makeNothing ()));
547 }
548 | fcnMods
549 | /* empty */
550
551optPlainGlobModsAux
552 : QGLOBALS { setProcessingGlobalsList (); } initializerList optSemi
553 optMods
554 { unsetProcessingGlobals (); }
555 | QGLOBALS { setProcessingGlobalsList (); } globIdList optSemi
556 optMods
557 { unsetProcessingGlobals (); }
558 | QNOMODS
559 { setFunctionNoGlobals ();
560 setFunctionModifies (sRefSet_single (sRef_makeNothing ()));
561 }
562 | fcnPlainMods
563 | /* empty */
564
565optMods
566 : fcnMods
567 | /* empty */
568
569fcnMods
570 : QMODIFIES
571 {
572 context_setProtectVars (); enterParamsTemp ();
573 sRef_setGlobalScopeSafe ();
574 }
575 locModifies
576 {
577 setFunctionModifies ($3); exitParamsTemp ();
578 sRef_clearGlobalScopeSafe ();
579 context_releaseVars ();
580 }
581
582fcnPlainMods
583 : QMODIFIES
584 {
585 context_setProtectVars (); enterParamsTemp ();
586 sRef_setGlobalScopeSafe ();
587 }
588 locPlainModifies
589 {
590 setFunctionModifies ($3); exitParamsTemp ();
591 sRef_clearGlobalScopeSafe ();
592 context_releaseVars ();
593 }
594
595specialTag
596 : QDEFINES
597 | QUSES
598 | QALLOCATES
599 | QSETS
600 | QRELEASES
601
602endStateTag
603 : QENDMACRO
604
605endSpecialTag
606 : QENDMACRO
607
608stateSpecialClause
609 : QPRECLAUSE
610 | QPOSTCLAUSE
611
612specialClauseType
613 : QONLY { $$ = SP_ISONLY; }
614 | QOBSERVER { $$ = SP_ISOBSERVER; }
615 | QEXPOSED { $$ = SP_ISEXPOSED; }
616 | QDEPENDENT { $$ = SP_ISDEPENDENT; }
617 | QOWNED { $$ = SP_ISOWNED; }
618 | QSHARED { $$ = SP_ISSHARED; }
619 | QISNULL { $$ = SP_ISNULL; }
620 | QNOTNULL { $$ = SP_ISNOTNULL; }
621
622specialClause
623 : specialTag NotType
624 {
625 context_setProtectVars ();
626 enterParamsTemp ();
627 sRef_setGlobalScopeSafe ();
628 }
629 specClauseList optSemi endSpecialTag IsType
630 {
631 setFunctionSpecialClause ($1, $4, $6);
632 exitParamsTemp ();
633 sRef_clearGlobalScopeSafe ();
634 context_releaseVars ();
635 }
636 | stateSpecialClause NotType specialClauseType
637 {
638 context_setProtectVars ();
639 enterParamsTemp ();
640 sRef_setGlobalScopeSafe ();
641 }
642 specClauseList optSemi endStateTag IsType
643 {
644 setFunctionStateSpecialClause ($1, $3, $5, $7);
645 exitParamsTemp ();
646 sRef_clearGlobalScopeSafe ();
647 context_releaseVars ();
648 }
649
650fcnDefHdrAux
651 : namedDecl
652 {
653 qtype qint = qtype_create (ctype_int);
654 $$ = idDecl_fixBase ($1, qint);
655 qtype_free (qint);
656 }
657 | completeTypeSpecifier NotType namedDecl
658 { $$ = idDecl_fixBase ($3, $1); }
659
660fcnBody
661 : TLBRACE { checkDoneParams (); context_enterInnerContext (); }
662 compoundStmtRest
663 {
664 exprNode_checkFunctionBody ($3); $$ = $3;
665 context_exitInner ($3);
666 }
667 | initializerList
668 { doneParams (); context_enterInnerContext (); }
669 compoundStmt
670 {
671 context_exitInner ($3);
672 exprNode_checkFunctionBody ($3);
673 $$ = $3; /* old style */
674 }
675
676fcnDef
677 : fcnDefHdr fcnBody
678 {
679 context_setFunctionDefined (exprNode_loc ($2));
ef2aa32a 680 /* exprNode_checkFunction (context_getHeader (), $2); */
4cccc6ad 681 /* DRL 8 8 2000 */
682
885824d3 683 context_exitFunction ();
684 }
685
686locModifies
687 : modList optSemi QENDMACRO { $$ = $1; }
688 | optSemi QENDMACRO { $$ = sRefSet_new (); }
689
690locPlainModifies
691 : modList optSemi { $$ = $1; }
692 | optSemi { $$ = sRefSet_new (); }
693
694modListExpr
695 : id { $$ = uentry_getSref ($1); checkModifiesId ($1); }
696 | NEW_IDENTIFIER { $$ = fixModifiesId ($1); }
697 | modListExpr TLSQBR TRSQBR { $$ = modListArrayFetch ($1, sRef_undefined); }
698 | modListExpr TLSQBR mExpr TRSQBR { $$ = modListArrayFetch ($1, $3); }
699 | TMULT modListExpr { $$ = modListPointer ($2); }
700 | TLPAREN modListExpr TRPAREN { $$ = $2; }
701 | modListExpr TDOT newId { $$ = modListFieldAccess ($1, $3); }
702 | modListExpr ARROW_OP newId { $$ = modListArrowAccess ($1, $3); }
703
704
705mExpr
706 : modListExpr { $$ = $1; }
707 | CCONSTANT { $$ = sRef_makeUnknown (); /* sRef_makeConstant ($1); ? */ }
708 /* arithmetic? */
709
710modList
711 : modListExpr { $$ = sRefSet_single ($1); }
712 | modList TCOMMA modListExpr { $$ = sRefSet_insert ($1, $3); }
713
714specClauseListExpr
715 : id
716 { $$ = checkSpecClausesId ($1); }
717 | NEW_IDENTIFIER
718 { $$ = fixSpecClausesId ($1); }
719 | specClauseListExpr TLSQBR TRSQBR { $$ = sRef_makeAnyArrayFetch ($1); }
720 | specClauseListExpr TLSQBR mExpr TRSQBR { $$ = sRef_makeAnyArrayFetch ($1); }
721 | TMULT specClauseListExpr { $$ = sRef_constructPointer ($2); }
722 | TLPAREN specClauseListExpr TRPAREN { $$ = $2; }
723 | specClauseListExpr TDOT newId { cstring_markOwned ($3);
724 $$ = sRef_buildField ($1, $3); }
725 | specClauseListExpr ARROW_OP newId { cstring_markOwned ($3);
726 $$ = sRef_makeArrow ($1, $3); }
727
728specClauseList
729 : specClauseListExpr
730 { if (sRef_isValid ($1)) { $$ = sRefSet_single ($1); }
731 else { $$ = sRefSet_undefined; }
732 }
733 | specClauseList TCOMMA specClauseListExpr
734 { if (sRef_isValid ($3))
735 {
736 $$ = sRefSet_insert ($1, $3);
737 }
738 else
739 {
740 $$ = $1;
741 }
742 }
743
744primaryExpr
745 : id { $$ = exprNode_fromIdentifier ($1); }
746 | NEW_IDENTIFIER { $$ = exprNode_fromUIO ($1); }
1ac6313d 747 | CCONSTANT { $$ = $1; }
885824d3 748 | TLPAREN expr TRPAREN { $$ = exprNode_addParens ($1, $2); }
749 | TYPE_NAME_OR_ID { $$ = exprNode_fromIdentifier (coerceId ($1)); }
750 | QEXTENSION { $$ = exprNode_makeError (); }
751
752postfixExpr
753 : primaryExpr
754 | postfixExpr TLSQBR expr TRSQBR { $$ = exprNode_arrayFetch ($1, $3); }
755 | postfixExpr TLPAREN TRPAREN { $$ = exprNode_functionCall ($1, exprNodeList_new ()); }
756 | postfixExpr TLPAREN argumentExprList TRPAREN { $$ = exprNode_functionCall ($1, $3); }
757 | VA_ARG TLPAREN assignExpr TCOMMA typeExpression TRPAREN { $$ = exprNode_vaArg ($1, $3, $5); }
758 | postfixExpr NotType TDOT newId IsType { $$ = exprNode_fieldAccess ($1, $4); }
759 | postfixExpr NotType ARROW_OP newId IsType { $$ = exprNode_arrowAccess ($1, $4); }
760 | postfixExpr INC_OP { $$ = exprNode_postOp ($1, $2); }
761 | postfixExpr DEC_OP { $$ = exprNode_postOp ($1, $2); }
762
763argumentExprList
764 : assignExpr { $$ = exprNodeList_singleton ($1); }
765 | argumentExprList TCOMMA assignExpr { $$ = exprNodeList_push ($1, $3); }
766
767unaryExpr
768 : postfixExpr
769 | INC_OP unaryExpr { $$ = exprNode_preOp ($2, $1); }
770 | DEC_OP unaryExpr { $$ = exprNode_preOp ($2, $1); }
771 | TAMPERSAND castExpr { $$ = exprNode_preOp ($2, $1); }
772 | TMULT castExpr { $$ = exprNode_preOp ($2, $1); }
773 | TPLUS castExpr { $$ = exprNode_preOp ($2, $1); }
774 | TMINUS castExpr { $$ = exprNode_preOp ($2, $1); }
775 | TTILDE castExpr { $$ = exprNode_preOp ($2, $1); }
776 | TEXCL castExpr { $$ = exprNode_preOp ($2, $1); }
777 | sizeofExpr { $$ = $1; }
778 | offsetofExpr { $$ = $1; }
779
780fieldDesignator
781 : fieldDesignator TDOT newId { $$ = cstringList_add ($1, $3); }
782 | newId { $$ = cstringList_single ($1); }
783
784offsetofExpr
785 : COFFSETOF IsType TLPAREN typeExpression NotType TCOMMA fieldDesignator TRPAREN IsType
786 { $$ = exprNode_offsetof ($4, $7); }
787
788sizeofExpr
789 : IsType { context_setProtectVars (); }
790 sizeofExprAux { context_sizeofReleaseVars (); $$ = $3; }
791
792sizeofExprAux
793 : CSIZEOF TLPAREN typeExpression TRPAREN { $$ = exprNode_sizeofType ($3); }
794 | CSIZEOF unaryExpr { $$ = exprNode_sizeofExpr ($2); }
795 | CALIGNOF TLPAREN typeExpression TRPAREN { $$ = exprNode_alignofType ($3); }
796 | CALIGNOF unaryExpr { $$ = exprNode_alignofExpr ($2); }
797
798castExpr
799 : unaryExpr
800 | TLPAREN typeExpression TRPAREN castExpr
801 { $$ = exprNode_cast ($1, $4, $2); }
802
803timesExpr
804 : castExpr
805 | timesExpr TMULT castExpr { $$ = exprNode_op ($1, $3, $2); }
806 | timesExpr TDIV castExpr { $$ = exprNode_op ($1, $3, $2); }
807 | timesExpr TPERCENT castExpr { $$ = exprNode_op ($1, $3, $2); }
808
809plusExpr
810 : timesExpr
811 | plusExpr TPLUS timesExpr { $$ = exprNode_op ($1, $3, $2); }
812 | plusExpr TMINUS timesExpr { $$ = exprNode_op ($1, $3, $2); }
813
814shiftExpr
815 : plusExpr
816 | shiftExpr LEFT_OP plusExpr { $$ = exprNode_op ($1, $3, $2); }
817 | shiftExpr RIGHT_OP plusExpr { $$ = exprNode_op ($1, $3, $2); }
818
819relationalExpr
820 : shiftExpr
821 | relationalExpr TLT shiftExpr { $$ = exprNode_op ($1, $3, $2); }
822 | relationalExpr TGT shiftExpr { $$ = exprNode_op ($1, $3, $2); }
823 | relationalExpr LE_OP shiftExpr { $$ = exprNode_op ($1, $3, $2); }
824 | relationalExpr GE_OP shiftExpr { $$ = exprNode_op ($1, $3, $2); }
825
826equalityExpr
827 : relationalExpr
828 | equalityExpr EQ_OP relationalExpr { $$ = exprNode_op ($1, $3, $2); }
829 | equalityExpr NE_OP relationalExpr { $$ = exprNode_op ($1, $3, $2); }
830
831bitandExpr
832 : equalityExpr
833 | bitandExpr TAMPERSAND equalityExpr { $$ = exprNode_op ($1, $3, $2); }
834
835xorExpr
836 : bitandExpr
837 | xorExpr TCIRC bitandExpr { $$ = exprNode_op ($1, $3, $2); }
838;
839
840bitorExpr
841 : xorExpr
842 | bitorExpr TBAR xorExpr { $$ = exprNode_op ($1, $3, $2); }
843
844andExpr
845 : bitorExpr
846 | andExpr AND_OP
847 { exprNode_produceGuards ($1);
848 context_enterAndClause ($1);
849 }
850 bitorExpr
851 {
852 $$ = exprNode_op ($1, $4, $2);
853 context_exitAndClause ($$, $4);
854 }
855
856orExpr
857 : andExpr
858 | orExpr OR_OP
859 {
860 exprNode_produceGuards ($1);
861 context_enterOrClause ($1);
862 }
863 andExpr
864 {
865 $$ = exprNode_op ($1, $4, $2);
866 context_exitOrClause ($$, $4);
867 }
868
869conditionalExpr
870 : orExpr
871 | orExpr TQUEST { exprNode_produceGuards ($1); context_enterTrueClause ($1); } expr TCOLON
872 { context_enterFalseClause ($1); } conditionalExpr
873 { $$ = exprNode_cond ($1, $4, $7); context_exitClause ($1, $4, $7); }
874
875assignExpr
876 : conditionalExpr
877 | unaryExpr TASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
878 | unaryExpr MUL_ASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
879 | unaryExpr DIV_ASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
880 | unaryExpr MOD_ASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
881 | unaryExpr ADD_ASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
882 | unaryExpr SUB_ASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
883 | unaryExpr LEFT_ASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
884 | unaryExpr RIGHT_ASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
885 | unaryExpr AND_ASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
886 | unaryExpr XOR_ASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
887 | unaryExpr OR_ASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
888
889expr
890 : assignExpr
891 | expr TCOMMA assignExpr { $$ = exprNode_comma ($1, $3); }
892
893optExpr
894 : /* empty */ { $$ = exprNode_undefined; }
895 | expr
896
897constantExpr
898 : conditionalExpr
899
900/* instance_orTypeDecl_and_possible_initialization */
901
902initializer
903 : instanceDecl { $$ = $1; }
904 | VA_DCL { doVaDcl (); $$ = exprNode_makeError (); }
905 | typeDecl { $$ = exprNode_makeError (); }
906
907instanceDecl
908 : completeTypeSpecifier IsType TSEMI { $$ = exprNode_makeError (); }
909 /*
910 ** This causes r/r conflicts with function definitions.
911 ** Instead we need to snarf one first. (gack)
912 **
913 ** | completeTypeSpecifier { setProcessingVars ($1); }
914 ** NotType
915 ** namedInitializerList IsType TSEMI
916 ** { unsetProcessingVars (); }
917 **;
918 **
919 ** the solution is pretty ugly:
920 */
921 | completeTypeSpecifier NotType namedDecl NotType
922 {
923 setProcessingVars ($1);
924 processNamedDecl ($3); }
925 IsType optDeclarators TSEMI IsType { unsetProcessingVars (); $$ = $7; }
926 | completeTypeSpecifier NotType namedDecl NotType TASSIGN
927 { setProcessingVars ($1); processNamedDecl ($3);
928 }
929 IsType init optDeclarators TSEMI IsType
930 { $$ = exprNode_concat ($9, exprNode_makeInitialization ($3, $8));
931 unsetProcessingVars ();
932 }
933namedInitializer
934 : namedDecl NotType { processNamedDecl ($1); $$ = exprNode_makeError (); }
935 | namedDecl NotType TASSIGN { processNamedDecl ($1); } IsType init
936 { $$ = exprNode_makeInitialization ($1, $6); }
937
938
939typeDecl
940 : CTYPEDEF completeTypeSpecifier { setProcessingTypedef ($2); }
941 NotType namedInitializerList IsType TSEMI { unsetProcessingTypedef (); }
942 | CTYPEDEF completeTypeSpecifier IsType TSEMI { /* in the ANSI grammar, semantics unclear */ }
943 | CTYPEDEF namedInitializerList IsType TSEMI { /* in the ANSI grammar, semantics unclear */ }
944
945IsType
946 : { g_expectingTypeName = TRUE; }
947
948PushType
949 : { g_expectingTypeName = TRUE; context_pushLoc (); }
950
951namedInitializerList
952 : namedInitializerListAux IsType { ; }
953
954namedInitializerListAux
955 : namedInitializer { ; }
956 | namedInitializerList TCOMMA NotType namedInitializer { ; }
957
958optDeclarators
959 : /* empty */ { $$ = exprNode_makeError (); }
960 | optDeclarators TCOMMA NotType namedInitializer { $$ = exprNode_concat ($1, $4); }
961
962init
1ac6313d 963 : assignExpr { $$ = $1; }
885824d3 964 | TLBRACE initList TRBRACE { $$ = exprNode_makeInitBlock ($1, $2); }
965 | TLBRACE initList TCOMMA TRBRACE { $$ = exprNode_makeInitBlock ($1, $2); }
966
967
968initList
969 : init
970 { $$ = exprNodeList_singleton ($1); }
971 | initList TCOMMA init
972 { $$ = exprNodeList_push ($1, $3); }
973
974/*
975** need to do the storage class global hack so tags are
976** declared with the right storage class.
977*/
978
979storageSpecifier
980 : QEXTERN { setStorageClass (SCEXTERN); $$ = qual_createExtern (); }
981 | QINLINE { $$ = qual_createInline (); }
982 | QSTATIC { setStorageClass (SCSTATIC); $$ = qual_createStatic (); }
983 | QAUTO { $$ = qual_createAuto (); }
984 | QREGISTER { $$ = qual_createRegister (); }
985
986typeQualifier
987 : QCONST IsType { $$ = qual_createConst (); }
988 | QVOLATILE IsType { $$ = qual_createVolatile (); }
989 | QOUT IsType { $$ = qual_createOut (); }
990 | QIN IsType { $$ = qual_createIn (); }
991 | QPARTIAL IsType { $$ = qual_createPartial (); }
992 | QSPECIAL IsType { $$ = qual_createSpecial (); }
993 | QOWNED IsType { $$ = qual_createOwned (); }
994 | QDEPENDENT IsType { $$ = qual_createDependent (); }
995 | QYIELD IsType { $$ = qual_createYield (); }
996 | QTEMP IsType { $$ = qual_createTemp (); }
997 | QONLY IsType { $$ = qual_createOnly (); }
998 | QKEEP IsType { $$ = qual_createKeep (); }
999 | QKEPT IsType { $$ = qual_createKept (); }
1000 | QSHARED IsType { $$ = qual_createShared (); }
1001 | QUNIQUE IsType { $$ = qual_createUnique (); }
1002 | QEXITS IsType { $$ = qual_createExits (); }
1003 | QMAYEXIT IsType { $$ = qual_createMayExit (); }
1004 | QTRUEEXIT IsType { $$ = qual_createTrueExit (); }
1005 | QFALSEEXIT IsType { $$ = qual_createFalseExit (); }
1006 | QNEVEREXIT IsType { $$ = qual_createNeverExit (); }
1007 | QNULL IsType { $$ = qual_createNull (); }
1008 | QRELNULL IsType { $$ = qual_createRelNull (); }
1009 | QRETURNED IsType { $$ = qual_createReturned (); }
1010 | QEXPOSED IsType { $$ = qual_createExposed (); }
1011 | QOBSERVER IsType { $$ = qual_createObserver (); }
1012 | QCHECKED IsType { $$ = qual_createChecked (); }
1013 | QCHECKMOD IsType { $$ = qual_createCheckMod (); }
1014 | QUNCHECKED IsType { $$ = qual_createUnchecked (); }
1015 | QCHECKEDSTRICT IsType { $$ = qual_createCheckedStrict (); }
1016 | QTRUENULL IsType { $$ = qual_createTrueNull (); }
1017 | QFALSENULL IsType { $$ = qual_createFalseNull (); }
1018 | QUNUSED IsType { $$ = qual_createUnused (); }
1019 | QEXTERNAL IsType { $$ = qual_createExternal (); }
1020 | QSEF IsType { $$ = qual_createSef (); }
1021 | QABSTRACT IsType { $$ = qual_createAbstract (); }
1022 | QCONCRETE IsType { $$ = qual_createConcrete (); }
1023 | QMUTABLE IsType { $$ = qual_createMutable (); }
1024 | QIMMUTABLE IsType { $$ = qual_createImmutable (); }
1025 | QNOTNULL IsType { $$ = qual_createNotNull (); }
1026 | QREFCOUNTED IsType { $$ = qual_createRefCounted (); }
1027 | QREFS IsType { $$ = qual_createRefs (); }
1028 | QKILLREF IsType { $$ = qual_createKillRef (); }
1029 | QRELDEF IsType { $$ = qual_createRelDef (); }
1030 | QNEWREF IsType { $$ = qual_createNewRef (); }
1031 | QTEMPREF IsType { $$ = qual_createTempRef (); }
1ac6313d 1032 | QNULLTERMINATED IsType { $$ = qual_createNullTerminated (); }
885824d3 1033
11ed4f45 1034/* | QSETBUFFERSIZE IsType { $$ = qual_createSetBufferSize (); } */
1035
1036
885824d3 1037typeModifier
1038 : QSHORT { $$ = qual_createShort (); }
1039 | QLONG { $$ = qual_createLong (); }
1040 | QSIGNED { $$ = qual_createSigned (); }
1041 | QUNSIGNED { $$ = qual_createUnsigned (); }
1042
1043typeSpecifier
1044 : CGCHAR NotType
1045 | CINT NotType
1046 | CBOOL NotType
1047 | CGFLOAT NotType
1048 | CDOUBLE NotType
1049 | CVOID NotType
1050 | QANYTYPE NotType { $$ = ctype_unknown; }
1051 | QINTEGRALTYPE NotType { $$ = ctype_anyintegral; }
1052 | QUNSIGNEDINTEGRALTYPE NotType { $$ = ctype_unsignedintegral; }
1053 | QSIGNEDINTEGRALTYPE NotType { $$ = ctype_signedintegral; }
1054 | typeName NotType
1055 | suSpc NotType
1056 | enumSpc NotType
1057 | typeModifier NotType { $$ = ctype_fromQual ($1); }
1058
1059completeType
1060 : IsType completeTypeSpecifier IsType
1061 { $$ = qtype_resolve ($2); }
1062
1063completeTypeSpecifier
1064 : completeTypeSpecifierAux { $$ = $1; }
1065 | completeTypeSpecifierAux QALT altType QENDMACRO
1066 { $$ = qtype_mergeAlt ($1, $3); }
1067
1068altType
1069 : typeExpression
1070 | typeExpression TCOMMA altType
1071 { $$ = qtype_mergeAlt ($1, $3); }
1072
1073completeTypeSpecifierAux
1074 : storageSpecifier optCompleteType { $$ = qtype_addQual ($2, $1); }
1075 | typeQualifier optCompleteType { $$ = qtype_addQual ($2, $1); }
1076 | typeSpecifier optCompleteType { $$ = qtype_combine ($2, $1); }
1077
1078optCompleteType
1079 : /* empty */ { $$ = qtype_unknown (); }
1080 | completeTypeSpecifier { $$ = $1; }
1081
1082suSpc
1083 : NotType CSTRUCT newId IsType TLBRACE { sRef_setGlobalScopeSafe (); }
1084 CreateStructInnerScope
1085 structDeclList DeleteStructInnerScope { sRef_clearGlobalScopeSafe (); }
1086 TRBRACE
1087 { $$ = declareStruct ($3, $8); }
1088 | NotType CUNION newId IsType TLBRACE { sRef_setGlobalScopeSafe (); }
1089 CreateStructInnerScope
1090 structDeclList DeleteStructInnerScope { sRef_clearGlobalScopeSafe (); }
1091 TRBRACE
1092 { $$ = declareUnion ($3, $8); }
1093 | NotType CSTRUCT newId IsType TLBRACE TRBRACE
1094 { $$ = declareStruct ($3, uentryList_new ()); }
1095 | NotType CUNION newId IsType TLBRACE TRBRACE
1096 { $$ = declareUnion ($3, uentryList_new ()); }
1097 | NotType CSTRUCT IsType TLBRACE { sRef_setGlobalScopeSafe (); }
1098 CreateStructInnerScope
1099 structDeclList DeleteStructInnerScope { sRef_clearGlobalScopeSafe (); }
1100 TRBRACE
1101 { $$ = declareUnnamedStruct ($7); }
1102 | NotType CUNION IsType TLBRACE { sRef_setGlobalScopeSafe (); }
1103 CreateStructInnerScope
1104 structDeclList DeleteStructInnerScope { sRef_clearGlobalScopeSafe (); }
1105 TRBRACE
1106 { $$ = declareUnnamedUnion ($7); }
1107 | NotType CSTRUCT IsType TLBRACE TRBRACE
1108 { $$ = ctype_createUnnamedStruct (uentryList_new ()); }
1109 | NotType CUNION IsType TLBRACE TRBRACE
1110 { $$ = ctype_createUnnamedUnion (uentryList_new ()); }
1111 | NotType CSTRUCT newId NotType { $$ = handleStruct ($3); }
1112 | NotType CUNION newId NotType { $$ = handleUnion ($3); }
1113
1114NotType
1115 : { g_expectingTypeName = FALSE; }
1116
1117structDeclList
1118 : structDecl
1119 | macroDef { $$ = uentryList_undefined; /* bogus! */ }
1120 | structDeclList structDecl { $$ = uentryList_mergeFields ($1, $2); }
1121
1122structDecl
1123 : completeTypeSpecifier NotType structNamedDeclList IsType TSEMI
1124 { $$ = fixUentryList ($3, $1); }
1125 | completeTypeSpecifier IsType TSEMI
1126 { $$ = fixUnnamedDecl ($1); }
1127
1128structNamedDeclList
1129 : structNamedDecl NotType
1130 { $$ = idDeclList_singleton ($1); }
1131 | structNamedDeclList TCOMMA structNamedDecl NotType
1132 { $$ = idDeclList_add ($1, $3); }
1133
1134structNamedDecl /* hack to get around namespace problems */
1135 : namedDecl { $$ = $1; }
1136 | TCOLON IsType constantExpr { $$ = idDecl_undefined; }
1137 | namedDecl TCOLON IsType constantExpr { $$ = $1; }
1138 /* Need the IsType in case there is a cast in the constant expression. */
1139
1140enumSpc
1141 : NotType CENUM TLBRACE enumeratorList TRBRACE IsType
1142 { $$ = declareUnnamedEnum ($4); }
1143 | NotType CENUM newId TLBRACE { context_pushLoc (); } enumeratorList TRBRACE IsType
1144 { context_popLoc (); $$ = declareEnum ($3, $6); }
1145 | NotType CENUM newId IsType { $$ = handleEnum ($3); }
1146
1147enumeratorList
1148 : enumerator
1149 { $$ = enumNameList_single ($1); }
1150 | enumeratorList TCOMMA enumerator
1151 { $$ = enumNameList_push ($1, $3); }
1152 | enumeratorList TCOMMA
1153
1154enumerator
1155 : newId
1156 { uentry ue = uentry_makeEnumConstant ($1, ctype_unknown);
1157 usymtab_supGlobalEntry (ue);
1158 $$ = $1;
1159 }
1160 | newId TASSIGN IsType constantExpr
1161 { uentry ue = uentry_makeEnumInitializedConstant ($1, ctype_unknown, $4);
1162 usymtab_supGlobalEntry (ue);
1163 $$ = $1;
1164 }
1165
1166optNamedDecl
1167 : namedDeclBase
1168 | optAbstractDeclBase { $$ = idDecl_create (cstring_undefined, qtype_create ($1)); }
1169 | pointers TYPE_NAME
1170 {
1171 qtype qt = qtype_unknown ();
1172
1173 qtype_adjustPointers ($1, qt);
1174 $$ = idDecl_create (cstring_copy (LastIdentifier ()), qt);
1175 }
1176 | pointers optNamedDecl
1177 { $$ = $2; qtype_adjustPointers ($1, idDecl_getTyp ($$)); }
1178
1179namedDecl
1180 : namedDeclBase
1181 | pointers namedDeclBase
1182 { $$ = $2; qtype_adjustPointers ($1, idDecl_getTyp ($$)); }
1183
1184genericParamList
1185 : paramTypeList { $$ = handleParamTypeList ($1); }
1186 | NotType paramIdList { $$ = handleParamIdList ($2); }
1187
1188innerMods
1189 : QCONST { /* ignored for now */; }
1190 | QVOLATILE { ; }
1191
1192innerModsList
1193 : innerMods { ; }
1194 | innerModsList innerMods { ; }
1195
1196pointers
1197 : TMULT { $$ = 1; }
1198 | TMULT innerModsList { $$ = 1; }
1199 | TMULT pointers { $$ = 1 + $2; }
1200 | TMULT innerModsList pointers { $$ = 1 + $3; }
1201
1202paramIdList
1203 : idList
1204 | idList TCOMMA CTOK_ELIPSIS { $$ = uentryList_add ($1, uentry_makeElipsisMarker ()); }
1205
1206idList
1207 : newId { $$ = uentryList_single (uentry_makeVariableLoc ($1, ctype_int)); }
1208 | idList TCOMMA newId { $$ = uentryList_add ($1, uentry_makeVariableLoc ($3, ctype_int)); }
1209
1210paramTypeList
1211 : CTOK_ELIPSIS { $$ = uentryList_single (uentry_makeElipsisMarker ()); }
1212 | paramList
1213 | paramList TCOMMA CTOK_ELIPSIS { $$ = uentryList_add ($1, uentry_makeElipsisMarker ()); }
1214
1215paramList
1216 : { storeLoc (); } paramDecl { $$ = uentryList_single ($2); }
1217 | paramList TCOMMA { storeLoc (); } paramDecl
1218 { $$ = uentryList_add ($1, $4); }
1219
1220paramDecl
1221 : IsType completeTypeSpecifier optNamedDecl IsType
1222 {
1223 if (isFlipOldStyle ())
1224 {
1225 llparseerror (cstring_makeLiteral ("Inconsistent function parameter syntax (mixing old and new style declaration)"));
1226 }
1227 else
1228 {
1229 setNewStyle ();
1230 }
1231 $$ = makeCurrentParam (idDecl_fixParamBase ($3, $2));
1232 }
1233 | newId /* its an old-style declaration */
1234 {
1235 idDecl tparam = idDecl_create ($1, qtype_unknown ());
1236
1237 if (isNewStyle ())
1238 {
1239 llparseerror (message ("Inconsistent function parameter syntax: %q",
1240 idDecl_unparse (tparam)));
1241 }
1242
1243 setFlipOldStyle ();
1244 $$ = makeCurrentParam (tparam);
1245 idDecl_free (tparam);
1246 }
1247
1248typeExpression
1249 : completeType
1250 | completeType abstractDecl { $$ = qtype_newBase ($1, $2); }
1251
1252abstractDecl
1253 : pointers { $$ = ctype_adjustPointers ($1, ctype_unknown); }
1254 | abstractDeclBase
1255 | pointers abstractDeclBase { $$ = ctype_adjustPointers ($1, $2); }
1256
1257optAbstractDeclBase
1258 : /* empty */ { $$ = ctype_unknown; }
1259 | abstractDeclBase
1260
1261abstractDeclBase
1262 : IsType TLPAREN NotType abstractDecl TRPAREN
1263 { $$ = ctype_expectFunction ($4); }
1264 | TLSQBR TRSQBR { $$ = ctype_makeArray (ctype_unknown); }
a0a162cd 1265 | TLSQBR constantExpr TRSQBR
1266 { $$ = ctype_makeFixedArray (ctype_unknown, exprNode_getLongValue ($2)); }
885824d3 1267 | abstractDeclBase TLSQBR TRSQBR { $$ = ctype_makeArray ($1); }
a0a162cd 1268 | abstractDeclBase TLSQBR constantExpr TRSQBR
1269 { $$ = ctype_makeFixedArray ($1, exprNode_getLongValue ($3)); }
885824d3 1270 | IsType TLPAREN TRPAREN
1271 { $$ = ctype_makeFunction (ctype_unknown, uentryList_makeMissingParams ()); }
1272 | IsType TLPAREN paramTypeList TRPAREN
1273 { $$ = ctype_makeParamsFunction (ctype_unknown, $3); }
1274 | abstractDeclBase IsType TLPAREN TRPAREN
1275 { $$ = ctype_makeFunction ($1, uentryList_makeMissingParams ()); }
1276 | abstractDeclBase IsType TLPAREN paramTypeList TRPAREN
1277 { $$ = ctype_makeParamsFunction ($1, $4); }
1278
1279/* statement */
1280
1281stmt
1282 : labeledStmt
1283 | caseStmt
1284 | defaultStmt
1285 | compoundStmt
1286 | expressionStmt
1287 | selectionStmt
1288 | iterationStmt
1289 | iterStmt
1290 | jumpStmt
11ed4f45 1291/* | tst1 */
1292 | lclintassertion {$$ = $1; printf ("Doing stmt lclintassertion\n"); }
1293
1294
1295lclintassertion
1296 : QSETBUFFERSIZE id CCONSTANT QENDMACRO { printf(" QSETBUFFERSIZE id CCONSTANT HEllo World\n"); uentry_setBufferSize($2, $3); $$ = exprNode_createTok ($4);
1297 }
1298 | QSETSTRINGLENGTH id CCONSTANT QENDMACRO { printf(" QSETSTRINGLENGTH id CCONSTANT HEllo World\n"); uentry_setStringLength($2, $3); $$ = exprNode_createTok ($4);
1299 }
a0a162cd 1300 | QTESTINRANGE id CCONSTANT QENDMACRO {printf(" QTESTINRANGE\n"); uentry_testInRange($2, $3); $$ = exprNode_createTok ($4);
1301 }
11ed4f45 1302
1303/* | QSETBUFFERSIZE id id {$$ = $2; printf(" QSETBUFFERSIZE id id HEllo World\n");} */
1304
1305tst1
1306: TCOLON newId { $$ = exprNode_labelMarker ($2); }
1307
1308
885824d3 1309
1310iterBody
1311 : iterDefStmtList { $$ = $1; }
1312
1313endBody
1314 : iterBody
1315
1316iterDefStmtList
1317 : iterDefStmt
1318 | iterDefStmtList iterDefStmt
1319 { $$ = exprNode_concat ($1, $2); }
1320
1321iterDefIterationStmt
1322 : iterWhilePred iterDefStmtList
1323 { $$ = exprNode_while ($1, $2); }
1324 | doHeader stmtErr WHILE TLPAREN expr TRPAREN TSEMI
1325 { $$ = exprNode_doWhile ($2, $5); }
1326 | doHeader stmtErr WHILE TLPAREN expr TRPAREN
1327 { $$ = exprNode_doWhile ($2, $5); }
1328 | forPred iterDefStmt
1329 { $$ = exprNode_for ($1, $2); }
1330
1331forPred
1332 : CFOR TLPAREN optExpr TSEMI optExpr TSEMI
1333 { context_setProtectVars (); } optExpr { context_sizeofReleaseVars (); }
1334 TRPAREN
1335 { $$ = exprNode_forPred ($3, $5, $8);
1336 context_enterForClause ($5); }
1337
1338partialIterStmt
1339 : ITER_NAME CreateInnerScope TLPAREN
1340 { setProcessingIterVars ($1); }
1341 iterArgList TRPAREN
1342 { $$ = exprNode_iterStart ($1, $5); }
1343 | ITER_ENDNAME { $$ = exprNode_createId ($1); }
1344
1345iterDefStmt
1346 : labeledStmt
1347 | caseStmt
1348 | defaultStmt
1349 | openScope initializerList { $$ = $2; }
1350 | openScope
1351 | closeScope
1352 | expressionStmt
1353 | iterSelectionStmt
1354 | iterDefIterationStmt
1355 | partialIterStmt
1356 | jumpStmt
1357 | TLPAREN iterDefStmt TRPAREN { $$ = $2; }
1358 | error { $$ = exprNode_makeError (); }
1359
1360iterSelectionStmt
1361 : ifPred iterDefStmt
1362 { /* don't: context_exitTrueClause ($1, $2); */
1363 $$ = exprNode_if ($1, $2);
1364 }
1365
1366openScope
1367 : CreateInnerScope TLBRACE { $$ = exprNode_createTok ($2); }
1368
1369closeScope
1370 : DeleteInnerScopeSafe TRBRACE { $$ = exprNode_createTok ($2); }
1371
1372macroBody
1373 : stmtErr
1374 | stmtListErr
1375
1376stmtErr
1377 : labeledStmt
1378 | caseStmt
1379 | defaultStmt
1380 | compoundStmtErr
1381 | expressionStmtErr
1382 | selectionStmt
1383 | iterStmt
1384 | iterationStmtErr
1385 | TLPAREN stmtErr TRPAREN { $$ = exprNode_addParens ($1, $2); }
1386 | jumpStmt
1387 | error { $$ = exprNode_makeError (); }
1388
1389labeledStmt
a0a162cd 1390 : newId TCOLON { $$ = exprNode_labelMarker ($1); }
1391 | QNOTREACHED stmt { $$ = exprNode_notReached ($2); }
885824d3 1392
1393/* Note that we can semantically check that the object to the case is
1394 indeed constant. In this case, we may not want to go through this effort */
1395
1396caseStmt
1397 : CASE constantExpr { context_enterCaseClause ($2); }
1398 TCOLON { $$ = exprNode_caseMarker ($2, FALSE); }
1399 | QFALLTHROUGH CASE constantExpr { context_enterCaseClause ($3); }
1400 TCOLON { $$ = exprNode_caseMarker ($3, TRUE); }
1401
1402defaultStmt
1403 : DEFAULT { context_enterCaseClause (exprNode_undefined); }
1404 TCOLON { $$ = exprNode_defaultMarker ($1, FALSE); }
1405 | QFALLTHROUGH DEFAULT { context_enterCaseClause (exprNode_undefined); }
1406 TCOLON { $$ = exprNode_defaultMarker ($2, TRUE); }
1407
1408compoundStmt
1409 : TLPAREN compoundStmt TRPAREN { $$ = $2; }
1410 | CreateInnerScope compoundStmtAux
1411 { $$ = $2; context_exitInner ($2); }
1412
1413compoundStmtErr
1414 : CreateInnerScope compoundStmtAuxErr DeleteInnerScope { $$ = $2; }
1415
1416CreateInnerScope
1417 : { context_enterInnerContext (); }
1418
1419DeleteInnerScope
1420 : { context_exitInnerPlain (); }
1421
1422CreateStructInnerScope
1423 : { context_enterStructInnerContext (); }
1424
1425DeleteStructInnerScope
1426 : { context_exitStructInnerContext (); }
1427
1428DeleteInnerScopeSafe
1429 : { context_exitInnerSafe (); }
1430
1431compoundStmtRest
1432 : TRBRACE { $$ = exprNode_createTok ($1); }
1433 | QNOTREACHED TRBRACE { $$ = exprNode_notReached (exprNode_createTok ($2)); }
1434 | stmtList TRBRACE { $$ = exprNode_updateLocation ($1, lltok_getLoc ($2)); }
1435 | stmtList QNOTREACHED TRBRACE
1436 { $$ = exprNode_notReached (exprNode_updateLocation ($1, lltok_getLoc ($3))); }
1437 | initializerList TRBRACE { $$ = exprNode_updateLocation ($1, lltok_getLoc ($2)); }
1438 | initializerList QNOTREACHED TRBRACE
1439 { $$ = exprNode_notReached (exprNode_updateLocation ($1, lltok_getLoc ($3))); }
1440 | initializerList stmtList TRBRACE
1441 { $$ = exprNode_updateLocation (exprNode_concat ($1, $2), lltok_getLoc ($3)); }
1442 | initializerList stmtList QNOTREACHED TRBRACE
1443 { $$ = exprNode_notReached (exprNode_updateLocation (exprNode_concat ($1, $2),
1444 lltok_getLoc ($3)));
1445 }
1446
1447
1448compoundStmtAux
1449 : TLBRACE compoundStmtRest
1450 { $$ = exprNode_makeBlock ($2); }
1451
1452compoundStmtAuxErr
1453 : TLBRACE TRBRACE
1454 { $$ = exprNode_createTok ($2); }
1455 | TLBRACE stmtListErr TRBRACE
1456 { $$ = exprNode_updateLocation ($2, lltok_getLoc ($3)); }
1457 | TLBRACE initializerList TRBRACE
1458 { $$ = exprNode_updateLocation ($2, lltok_getLoc ($3)); }
1459 | TLBRACE initializerList stmtList TRBRACE
1460 { $$ = exprNode_updateLocation (exprNode_concat ($2, $3), lltok_getLoc ($4)); }
1461
1462stmtListErr
1463 : stmtErr
1464 | stmtListErr stmtErr { $$ = exprNode_concat ($1, $2); }
1465
1466initializerList
1467 : initializer { $$ = $1; }
1468 | initializerList initializer { $$ = exprNode_concat ($1, $2); }
1469
1470stmtList
a0a162cd 1471 : stmt { $$ = $1; }
1472 | stmtList stmt { $$ = exprNode_concat ($1, $2); }
885824d3 1473
1474expressionStmt
1475 : TSEMI { $$ = exprNode_createTok ($1); }
4cccc6ad 1476 | expr TSEMI { $$ = exprNode_statement ($1, $2); }
885824d3 1477
1478expressionStmtErr
1479 : TSEMI { $$ = exprNode_createTok ($1); }
4cccc6ad 1480 | expr TSEMI { $$ = exprNode_statement ($1, $2); }
885824d3 1481 | expr { $$ = exprNode_checkExpr ($1); }
1482
1483ifPred
1484 : CIF TLPAREN expr TRPAREN
1485 { $$ = $3; exprNode_produceGuards ($3); context_enterTrueClause ($3); }
1486 /*
1487 ** not ANSI: | CIF TLPAREN compoundStmt TRPAREN
1488 ** { $$ = $3; context_enterTrueClause (); }
1489 */
1490
1491selectionStmt
1492 : ifPred stmt
1493 {
1494 context_exitTrueClause ($1, $2);
1495 $$ = exprNode_if ($1, $2);
1496 }
1497 | ifPred stmt CELSE { context_enterFalseClause ($1); } stmt
1498 {
1499 context_exitClause ($1, $2, $5);
1500 $$ = exprNode_ifelse ($1, $2, $5);
1501 }
1502 | SWITCH TLPAREN expr { context_enterSwitch ($3); }
1503 TRPAREN stmt { $$ = exprNode_switch ($3, $6); }
1504
1505whilePred
1506 : WHILE TLPAREN expr TRPAREN
1507 { $$ = exprNode_whilePred ($3); context_enterWhileClause ($3); }
1508 /* not ANSI: | WHILE TLPAREN compoundStmt TRPAREN stmt { $$ = exprNode_while ($3, $5); } */
1509
1510iterWhilePred
1511 : WHILE TLPAREN expr TRPAREN { $$ = exprNode_whilePred($3); }
1512
1513iterStmt
1514 : ITER_NAME { context_enterIterClause (); }
1515 CreateInnerScope TLPAREN { setProcessingIterVars ($1); }
1516 iterArgList TRPAREN
1517 compoundStmt endIter DeleteInnerScope
1518 {
1519 $$ = exprNode_iter ($1, $6, $8, $9);
1520
1521 }
1522
1523iterArgList
1524 : iterArgExpr { $$ = exprNodeList_singleton ($1); }
1525 | iterArgList { nextIterParam (); } TCOMMA iterArgExpr
1526 { $$ = exprNodeList_push ($1, $4); }
1527
1528iterArgExpr
1529 : assignIterExpr { $$ = exprNode_iterExpr ($1); }
1530 | id { $$ = exprNode_iterId ($1); }
1531 | TYPE_NAME_OR_ID { uentry ue = coerceIterId ($1);
1532
1533 if (uentry_isValid (ue))
1534 {
1535 $$ = exprNode_iterId (ue);
1536 }
1537 else
1538 {
1539 $$ = exprNode_iterNewId (cstring_copy (LastIdentifier ()));
1540 }
1541 }
1542 | NEW_IDENTIFIER { $$ = exprNode_iterNewId ($1); }
1543
1544/*
1545** everything is the same, EXCEPT it cannot be a NEW_IDENTIFIER
1546*/
1547
1548primaryIterExpr
1549 : CCONSTANT
1550 | TLPAREN expr TRPAREN { $$ = exprNode_addParens ($1, $2); }
1551
1552postfixIterExpr
1553 : primaryIterExpr
1554 | postfixExpr TLSQBR expr TRSQBR { $$ = exprNode_arrayFetch ($1, $3); }
1555 | postfixExpr TLPAREN TRPAREN { $$ = exprNode_functionCall ($1, exprNodeList_new ()); }
1556 | postfixExpr TLPAREN argumentExprList TRPAREN { $$ = exprNode_functionCall ($1, $3); }
1557 | VA_ARG TLPAREN assignExpr TCOMMA typeExpression TRPAREN
1558 { $$ = exprNode_vaArg ($1, $3, $5); }
1559 | postfixExpr NotType TDOT newId IsType { $$ = exprNode_fieldAccess ($1, $4); }
1560 | postfixExpr NotType ARROW_OP newId IsType { $$ = exprNode_arrowAccess ($1, $4); }
1561 | postfixExpr INC_OP { $$ = exprNode_postOp ($1, $2); }
1562 | postfixExpr DEC_OP { $$ = exprNode_postOp ($1, $2); }
1563
1564unaryIterExpr
1565 : postfixIterExpr
1566 | INC_OP unaryExpr { $$ = exprNode_preOp ($2, $1); }
1567 | DEC_OP unaryExpr { $$ = exprNode_preOp ($2, $1); }
1568 | TAMPERSAND castExpr { $$ = exprNode_preOp ($2, $1); }
1569 | TMULT castExpr { $$ = exprNode_preOp ($2, $1); }
1570 | TPLUS castExpr { $$ = exprNode_preOp ($2, $1); }
1571 | TMINUS castExpr { $$ = exprNode_preOp ($2, $1); }
1572 | TTILDE castExpr { $$ = exprNode_preOp ($2, $1); }
1573 | TEXCL castExpr { $$ = exprNode_preOp ($2, $1); }
1574 | sizeofExpr { $$ = $1; }
1575
1576castIterExpr
1577 : unaryIterExpr
1578 | TLPAREN typeExpression TRPAREN castExpr { $$ = exprNode_cast ($1, $4, $2); }
1579
1580timesIterExpr
1581 : castIterExpr
1582 | timesExpr TMULT castExpr { $$ = exprNode_op ($1, $3, $2); }
1583 | timesExpr TDIV castExpr { $$ = exprNode_op ($1, $3, $2); }
1584 | timesExpr TPERCENT castExpr { $$ = exprNode_op ($1, $3, $2); }
1585
1586plusIterExpr
1587 : timesIterExpr
1588 | plusExpr TPLUS timesExpr { $$ = exprNode_op ($1, $3, $2); }
1589 | plusExpr TMINUS timesExpr { $$ = exprNode_op ($1, $3, $2); }
1590
1591shiftIterExpr
1592 : plusIterExpr
1593 | shiftExpr LEFT_OP plusExpr { $$ = exprNode_op ($1, $3, $2); }
1594 | shiftExpr RIGHT_OP plusExpr { $$ = exprNode_op ($1, $3, $2); }
1595
1596relationalIterExpr
1597 : shiftIterExpr
1598 | relationalExpr TLT shiftExpr { $$ = exprNode_op ($1, $3, $2); }
1599 | relationalExpr TGT shiftExpr { $$ = exprNode_op ($1, $3, $2); }
1600 | relationalExpr LE_OP shiftExpr { $$ = exprNode_op ($1, $3, $2); }
1601 | relationalExpr GE_OP shiftExpr { $$ = exprNode_op ($1, $3, $2); }
1602
1603equalityIterExpr
1604 : relationalIterExpr
1605 | equalityExpr EQ_OP relationalExpr { $$ = exprNode_op ($1, $3, $2); }
1606 | equalityExpr NE_OP relationalExpr { $$ = exprNode_op ($1, $3, $2); }
1607
1608bitandIterExpr
1609 : equalityIterExpr
1610 | bitandExpr TAMPERSAND equalityExpr { $$ = exprNode_op ($1, $3, $2); }
1611
1612xorIterExpr
1613 : bitandIterExpr
1614 | xorExpr TCIRC bitandExpr { $$ = exprNode_op ($1, $3, $2); }
1615;
1616
1617bitorIterExpr
1618 : xorIterExpr
1619 | bitorExpr TBAR xorExpr { $$ = exprNode_op ($1, $3, $2); }
1620
1621andIterExpr
1622 : bitorIterExpr
1623 | andExpr AND_OP bitorExpr { $$ = exprNode_op ($1, $3, $2); }
1624
1625orIterExpr
1626 : andIterExpr
1627 | orExpr OR_OP andExpr { $$ = exprNode_op ($1, $3, $2); }
1628
1629conditionalIterExpr
1630 : orIterExpr
1631 | orExpr TQUEST { context_enterTrueClause ($1); }
1632 expr TCOLON { context_enterFalseClause ($1); } conditionalExpr
1633 { $$ = exprNode_cond ($1, $4, $7); }
1634
1635assignIterExpr
1636 : conditionalIterExpr
1637 | unaryExpr TASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
1638 | unaryExpr MUL_ASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
1639 | unaryExpr DIV_ASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
1640 | unaryExpr MOD_ASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
1641 | unaryExpr ADD_ASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
1642 | unaryExpr SUB_ASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
1643 | unaryExpr LEFT_ASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
1644 | unaryExpr RIGHT_ASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
1645 | unaryExpr AND_ASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
1646 | unaryExpr XOR_ASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
1647 | unaryExpr OR_ASSIGN assignExpr { $$ = exprNode_assign ($1, $3, $2); }
1648
1649endIter
1650 : ITER_ENDNAME { $$ = $1; }
1651 | /* empty */ { $$ = uentry_undefined; }
1652
1653doHeader
1654 : DO { context_enterDoWhileClause (); $$ = $1; }
1655
1656iterationStmt
1657 : whilePred stmt
1658 { $$ = exprNode_while ($1, $2); context_exitWhileClause ($1, $2); }
1659 | doHeader stmt WHILE TLPAREN expr TRPAREN TSEMI
4cccc6ad 1660 { $$ = exprNode_statement (exprNode_doWhile ($2, $5), $7); }
885824d3 1661 | forPred stmt
1662 { $$ = exprNode_for ($1, $2); context_exitForClause ($1, $2); }
1663
1664iterationStmtErr
1665 : whilePred stmtErr { $$ = exprNode_while ($1, $2); context_exitWhileClause ($1, $2); }
1666 | doHeader stmtErr WHILE TLPAREN expr TRPAREN TSEMI
4cccc6ad 1667 { $$ = exprNode_statement (exprNode_doWhile ($2, $5), $7); }
885824d3 1668 | doHeader stmtErr WHILE TLPAREN expr TRPAREN
1669 { $$ = exprNode_doWhile ($2, $5); }
1670 | forPred stmtErr { $$ = exprNode_for ($1, $2); context_exitForClause ($1, $2); }
1671
1672jumpStmt
1673 : GOTO newId TSEMI { $$ = exprNode_goto ($2); }
1674 | CONTINUE TSEMI { $$ = exprNode_continue ($1, BADTOK); }
1675 | QINNERCONTINUE CONTINUE TSEMI
1676 { $$ = exprNode_continue ($1, QINNERCONTINUE); }
1677 | BREAK TSEMI { $$ = exprNode_break ($1, BADTOK); }
1678 | QSWITCHBREAK BREAK TSEMI { $$ = exprNode_break ($2, QSWITCHBREAK); }
1679 | QLOOPBREAK BREAK TSEMI { $$ = exprNode_break ($2, QLOOPBREAK); }
1680 | QINNERBREAK BREAK TSEMI { $$ = exprNode_break ($2, QINNERBREAK); }
1681 | QSAFEBREAK BREAK TSEMI { $$ = exprNode_break ($2, QSAFEBREAK); }
1682 | RETURN TSEMI { $$ = exprNode_nullReturn ($1); }
1683 | RETURN expr TSEMI { $$ = exprNode_return ($2); }
1684
1685optSemi
1686 :
1687 | TSEMI { ; }
1688
1689id
1690 : IDENTIFIER
1691
1692newId
1693 : NEW_IDENTIFIER
1694 | ITER_NAME { $$ = uentry_getName ($1); }
1695 | ITER_ENDNAME { $$ = uentry_getName ($1); }
1696 | id { $$ = uentry_getName ($1); }
1697 | TYPE_NAME_OR_ID { $$ = $1; }
1698
1699typeName
1700 : TYPE_NAME
1701 | TYPE_NAME_OR_ID { $$ = ctype_unknown; }
1702
1703%%
1704
1705/*@-redecl@*/
1706extern char *yytext;
1707/*@=redecl@*/
1708
1709# include "bison.reset"
1710
1711void yyerror (/*@unused@*/ char *s)
1712{
1713 static bool givehint = FALSE;
1714
1715 if (context_inIterDef ())
1716 {
1717 llerror (FLG_SYNTAX, message ("Iter syntax not parseable: %s",
1718 context_inFunctionName ()));
1719 }
1720 else if (context_inIterEnd ())
1721 {
1722 llerror (FLG_SYNTAX, message ("Iter finalizer syntax not parseable: %s",
1723 context_inFunctionName ()));
1724 }
1725 else if (context_inMacro ())
1726 {
1727 llerror (FLG_SYNTAX, message ("Macro syntax not parseable: %s",
1728 context_inFunctionName ()));
1729
1730 if (context_inMacroUnknown ())
1731 {
1732 if (!givehint)
1733 {
1734 llhint (cstring_makeLiteral
1735 ("Precede macro definition with /*@notfunction@*/ "
1736 "to suppress checking and force expansion"));
1737 givehint = TRUE;
1738 }
1739 }
1740
1741 swallowMacro ();
1742 }
1743 else
1744 {
1745 llparseerror (cstring_undefined);
1746 }
1747}
1748
1ac6313d 1749void printState (idDecl t) {
1750 cstring id = idDecl_getName (t);
1751 uentry ue = usymtab_lookupSafe (id);
885824d3 1752
1ac6313d 1753 sRef s = uentry_getSref (ue);
1754
1755 printf("State = %d\n", s->bufinfo.bufstate);
1756}
11ed4f45 1757
1758
1759/*take this out soon */
1760/* void testassert1 (cstring id, icstring cons ) { */
1761 /* uentry ue =usymtab_lookupSafe (id); */
1762/* sRef s = uentry_getSref (ue); */
1763/* printf ("Doing testassert1 with setbuffersize\n"); */
1764/* printf("State = %d\n", s->bufinfo.bufstate); */
1765/* } */
1766/* void testassert2 (cstring id) { */
1767/* uentry ue =usymtab_lookupSafe (id); */
1768/* sRef s = uentry_getSref (ue); */
1769/* printf ("Doing testassert2 with setbuffersize\n"); */
1770/* printf("State = %d\n", s->bufinfo.bufstate); */
1771/* } */
1772
1773
1774
1775
1776
1777
git-cvsimport mirror of splint
This page took 0.29071 seconds and 5 git commands to generate.