source: code/trunk/vendor/modernc.org/cc/v3/parser.go@ 822

Last change on this file since 822 was 822, checked in by yakumo.izuru, 22 months ago

Prefer immortal.run over runit and rc.d, use vendored modules
for convenience.

Signed-off-by: Izuru Yakumo <yakumo.izuru@…>
File size: 119.3 KB
Line 
1// Copyright 2019 The CC Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5package cc // import "modernc.org/cc/v3"
6
7import (
8 "bytes"
9 "fmt"
10 "hash/maphash"
11 "strings"
12)
13
14const (
15 unicodePrivateAreaFirst = 0xe000
16 unicodePrivateAreaLast = 0xf8ff
17)
18
19var (
20 noDeclSpecs = &DeclarationSpecifiers{}
21 panicOnParserError bool //TODOOK
22
23 idChar = dict.sid("char")
24 idComma = dict.sid(",")
25 idConst = dict.sid("const")
26 idEq = dict.sid("=")
27 idFFlush = dict.sid("fflush")
28 idFprintf = dict.sid("fprintf")
29 idFunc = dict.sid("__func__")
30 idLBracket = dict.sid("[")
31 idLParen = dict.sid("(")
32 idRBracket = dict.sid("]")
33 idRParen = dict.sid(")")
34 idSemicolon = dict.sid(";")
35 idStatic = dict.sid("static")
36 idStderr = dict.sid("stderr")
37)
38
39// Values of Token.Rune for lexemes.
40const (
41 _ = iota + unicodePrivateAreaFirst //TODOOK
42
43 ACCUM // _Accum
44 ADDASSIGN // +=
45 ALIGNAS // _Alignas
46 ALIGNOF // _Alignof
47 ANDAND // &&
48 ANDASSIGN // &=
49 ARROW // ->
50 ASM // __asm__
51 ATOMIC // _Atomic
52 ATTRIBUTE // __attribute__
53 AUTO // auto
54 BOOL // _Bool
55 BREAK // break
56 BUILTINCHOOSEEXPR // __builtin_choose_expr
57 BUILTINTYPESCOMPATIBLE // __builtin_types_compatible_p
58 CASE // case
59 CHAR // char
60 CHARCONST // 'a'
61 COMPLEX // _Complex
62 CONST // const
63 CONTINUE // continue
64 DDD // ...
65 DEC // --
66 DECIMAL128 // _Decimal128
67 DECIMAL32 // _Decimal32
68 DECIMAL64 // _Decimal64
69 DEFAULT // default
70 DIVASSIGN // /=
71 DO // do
72 DOUBLE // double
73 ELSE // else
74 ENUM // enum
75 ENUMCONST // foo in enum x { foo, bar };
76 EQ // ==
77 EXTERN // extern
78 FLOAT // float
79 FLOAT128 // _Float128
80 FLOAT16 // __fp16
81 FLOAT32 // _Float32
82 FLOAT32X // _Float32x
83 FLOAT64 // _Float64
84 FLOAT64X // _Float64x
85 FLOAT80 // __float80
86 FLOATCONST // 1.23
87 FOR // for
88 FRACT // _Fract
89 GEQ // >=
90 GOTO // goto
91 IDENTIFIER // foo
92 IF // if
93 IMAG // __imag__
94 INC // ++
95 INLINE // inline
96 INT // int
97 INT8 // __int8
98 INT16 // __int16
99 INT32 // __int32
100 INT64 // __int64
101 INT128 // __int128
102 INTCONST // 42
103 LABEL // __label__
104 LEQ // <=
105 LONG // long
106 LONGCHARCONST // L'a'
107 LONGSTRINGLITERAL // L"foo"
108 LSH // <<
109 LSHASSIGN // <<=
110 MODASSIGN // %=
111 MULASSIGN // *=
112 NEQ // !=
113 NORETURN // _Noreturn
114 ORASSIGN // |=
115 OROR // ||
116 PPNUMBER // .32e.
117 PPPASTE // ##
118 PRAGMASTDC // __pragma_stdc
119 REAL // __real__
120 REGISTER // register
121 RESTRICT // restrict
122 RETURN // return
123 RSH // >>
124 RSHASSIGN // >>=
125 SAT // _Sat
126 SHORT // short
127 SIGNED // signed
128 SIZEOF // sizeof
129 STATIC // static
130 STRINGLITERAL // "foo"
131 STRUCT // struct
132 SUBASSIGN // -=
133 SWITCH // switch
134 THREADLOCAL // _Thread_local
135 TYPEDEF // typedef
136 TYPEDEFNAME // int_t in typedef int int_t;
137 TYPEOF // typeof
138 UNION // union
139 UNSIGNED // unsigned
140 VOID // void
141 VOLATILE // volatile
142 WHILE // while
143 XORASSIGN // ^=
144
145 lastTok
146)
147
148var (
149 tokNames = map[rune]StringID{
150 ACCUM: dict.sid("ACCUM"),
151 ADDASSIGN: dict.sid("ADDASSIGN"),
152 ALIGNAS: dict.sid("ALIGNAS"),
153 ALIGNOF: dict.sid("ALIGNOF"),
154 ANDAND: dict.sid("ANDAND"),
155 ANDASSIGN: dict.sid("ANDASSIGN"),
156 ARROW: dict.sid("ARROW"),
157 ASM: dict.sid("ASM"),
158 ATOMIC: dict.sid("ATOMIC"),
159 ATTRIBUTE: dict.sid("ATTRIBUTE"),
160 AUTO: dict.sid("AUTO"),
161 BOOL: dict.sid("BOOL"),
162 BREAK: dict.sid("BREAK"),
163 BUILTINCHOOSEEXPR: dict.sid("BUILTINCHOOSEEXPR"),
164 BUILTINTYPESCOMPATIBLE: dict.sid("BUILTINTYPESCOMPATIBLE"),
165 CASE: dict.sid("CASE"),
166 CHAR: dict.sid("CHAR"),
167 CHARCONST: dict.sid("CHARCONST"),
168 COMPLEX: dict.sid("COMPLEX"),
169 CONST: dict.sid("CONST"),
170 CONTINUE: dict.sid("CONTINUE"),
171 DDD: dict.sid("DDD"),
172 DEC: dict.sid("DEC"),
173 DECIMAL128: dict.sid("DECIMAL128"),
174 DECIMAL32: dict.sid("DECIMAL32"),
175 DECIMAL64: dict.sid("DECIMAL64"),
176 DEFAULT: dict.sid("DEFAULT"),
177 DIVASSIGN: dict.sid("DIVASSIGN"),
178 DO: dict.sid("DO"),
179 DOUBLE: dict.sid("DOUBLE"),
180 ELSE: dict.sid("ELSE"),
181 ENUM: dict.sid("ENUM"),
182 ENUMCONST: dict.sid("ENUMCONST"),
183 EQ: dict.sid("EQ"),
184 EXTERN: dict.sid("EXTERN"),
185 FLOAT128: dict.sid("FLOAT128"),
186 FLOAT16: dict.sid("FLOAT16"),
187 FLOAT32: dict.sid("FLOAT32"),
188 FLOAT32X: dict.sid("FLOAT32X"),
189 FLOAT64: dict.sid("FLOAT64"),
190 FLOAT64X: dict.sid("FLOAT64X"),
191 FLOAT80: dict.sid("FLOAT80"),
192 FLOAT: dict.sid("FLOAT"),
193 FLOATCONST: dict.sid("FLOATCONST"),
194 FOR: dict.sid("FOR"),
195 FRACT: dict.sid("FRACT"),
196 GEQ: dict.sid("GEQ"),
197 GOTO: dict.sid("GOTO"),
198 IDENTIFIER: dict.sid("IDENTIFIER"),
199 IF: dict.sid("IF"),
200 IMAG: dict.sid("IMAG"),
201 INC: dict.sid("INC"),
202 INLINE: dict.sid("INLINE"),
203 INT8: dict.sid("INT8"),
204 INT16: dict.sid("INT16"),
205 INT32: dict.sid("INT32"),
206 INT64: dict.sid("INT64"),
207 INT128: dict.sid("INT128"),
208 INT: dict.sid("INT"),
209 INTCONST: dict.sid("INTCONST"),
210 LABEL: dict.sid("LABEL"),
211 LEQ: dict.sid("LEQ"),
212 LONG: dict.sid("LONG"),
213 LONGCHARCONST: dict.sid("LONGCHARCONST"),
214 LONGSTRINGLITERAL: dict.sid("LONGSTRINGLITERAL"),
215 LSH: dict.sid("LSH"),
216 LSHASSIGN: dict.sid("LSHASSIGN"),
217 MODASSIGN: dict.sid("MODASSIGN"),
218 MULASSIGN: dict.sid("MULASSIGN"),
219 NEQ: dict.sid("NEQ"),
220 NORETURN: dict.sid("NORETURN"),
221 ORASSIGN: dict.sid("ORASSIGN"),
222 OROR: dict.sid("OROR"),
223 PPNUMBER: dict.sid("PPNUMBER"),
224 PPPASTE: dict.sid("PPPASTE"),
225 PRAGMASTDC: dict.sid("PPPRAGMASTDC"),
226 REAL: dict.sid("REAL"),
227 REGISTER: dict.sid("REGISTER"),
228 RESTRICT: dict.sid("RESTRICT"),
229 RETURN: dict.sid("RETURN"),
230 RSH: dict.sid("RSH"),
231 RSHASSIGN: dict.sid("RSHASSIGN"),
232 SAT: dict.sid("SAT"),
233 SHORT: dict.sid("SHORT"),
234 SIGNED: dict.sid("SIGNED"),
235 SIZEOF: dict.sid("SIZEOF"),
236 STATIC: dict.sid("STATIC"),
237 STRINGLITERAL: dict.sid("STRINGLITERAL"),
238 STRUCT: dict.sid("STRUCT"),
239 SUBASSIGN: dict.sid("SUBASSIGN"),
240 SWITCH: dict.sid("SWITCH"),
241 THREADLOCAL: dict.sid("THREADLOCAL"),
242 TYPEDEF: dict.sid("TYPEDEF"),
243 TYPEDEFNAME: dict.sid("TYPEDEFNAME"),
244 TYPEOF: dict.sid("TYPEOF"),
245 UNION: dict.sid("UNION"),
246 UNSIGNED: dict.sid("UNSIGNED"),
247 VOID: dict.sid("VOID"),
248 VOLATILE: dict.sid("VOLATILE"),
249 WHILE: dict.sid("WHILE"),
250 XORASSIGN: dict.sid("XORASSIGN"),
251 }
252
253 keywords = map[StringID]rune{
254
255 // [0], 6.4.1
256 dict.sid("auto"): AUTO,
257 dict.sid("break"): BREAK,
258 dict.sid("case"): CASE,
259 dict.sid("char"): CHAR,
260 dict.sid("const"): CONST,
261 dict.sid("continue"): CONTINUE,
262 dict.sid("default"): DEFAULT,
263 dict.sid("do"): DO,
264 dict.sid("double"): DOUBLE,
265 dict.sid("else"): ELSE,
266 dict.sid("enum"): ENUM,
267 dict.sid("extern"): EXTERN,
268 dict.sid("float"): FLOAT,
269 dict.sid("for"): FOR,
270 dict.sid("goto"): GOTO,
271 dict.sid("if"): IF,
272 dict.sid("inline"): INLINE,
273 dict.sid("int"): INT,
274 dict.sid("long"): LONG,
275 dict.sid("register"): REGISTER,
276 dict.sid("restrict"): RESTRICT,
277 dict.sid("return"): RETURN,
278 dict.sid("short"): SHORT,
279 dict.sid("signed"): SIGNED,
280 dict.sid("sizeof"): SIZEOF,
281 dict.sid("static"): STATIC,
282 dict.sid("struct"): STRUCT,
283 dict.sid("switch"): SWITCH,
284 dict.sid("typedef"): TYPEDEF,
285 dict.sid("union"): UNION,
286 dict.sid("unsigned"): UNSIGNED,
287 dict.sid("void"): VOID,
288 dict.sid("volatile"): VOLATILE,
289 dict.sid("while"): WHILE,
290
291 dict.sid("_Alignas"): ALIGNAS,
292 dict.sid("_Alignof"): ALIGNOF,
293 dict.sid("_Atomic"): ATOMIC,
294 dict.sid("_Bool"): BOOL,
295 dict.sid("_Complex"): COMPLEX,
296 dict.sid("_Noreturn"): NORETURN,
297 dict.sid("_Thread_local"): THREADLOCAL,
298 dict.sid("__alignof"): ALIGNOF,
299 dict.sid("__alignof__"): ALIGNOF,
300 dict.sid("__asm"): ASM,
301 dict.sid("__asm__"): ASM,
302 dict.sid("__attribute"): ATTRIBUTE,
303 dict.sid("__attribute__"): ATTRIBUTE,
304 dict.sid("__complex"): COMPLEX,
305 dict.sid("__complex__"): COMPLEX,
306 dict.sid("__const"): CONST,
307 dict.sid("__inline"): INLINE,
308 dict.sid("__inline__"): INLINE,
309 dict.sid("__int16"): INT16,
310 dict.sid("__int32"): INT32,
311 dict.sid("__int64"): INT64,
312 dict.sid("__int8"): INT8,
313 dict.sid("__pragma_stdc"): PRAGMASTDC,
314 dict.sid("__restrict"): RESTRICT,
315 dict.sid("__restrict__"): RESTRICT,
316 dict.sid("__signed"): SIGNED,
317 dict.sid("__signed__"): SIGNED,
318 dict.sid("__thread"): THREADLOCAL,
319 dict.sid("__typeof"): TYPEOF,
320 dict.sid("__typeof__"): TYPEOF,
321 dict.sid("__volatile"): VOLATILE,
322 dict.sid("__volatile__"): VOLATILE,
323 dict.sid("typeof"): TYPEOF,
324 }
325
326 gccKeywords = map[StringID]rune{
327 dict.sid("_Accum"): ACCUM,
328 dict.sid("_Decimal128"): DECIMAL128,
329 dict.sid("_Decimal32"): DECIMAL32,
330 dict.sid("_Decimal64"): DECIMAL64,
331 dict.sid("_Float128"): FLOAT128,
332 dict.sid("_Float16"): FLOAT16,
333 dict.sid("_Float32"): FLOAT32,
334 dict.sid("_Float32x"): FLOAT32X,
335 dict.sid("_Float64"): FLOAT64,
336 dict.sid("_Float64x"): FLOAT64X,
337 dict.sid("_Fract"): FRACT,
338 dict.sid("_Sat"): SAT,
339 dict.sid("__builtin_choose_expr"): BUILTINCHOOSEEXPR,
340 dict.sid("__builtin_types_compatible_p"): BUILTINTYPESCOMPATIBLE,
341 dict.sid("__float80"): FLOAT80,
342 dict.sid("__fp16"): FLOAT16,
343 dict.sid("__imag"): IMAG,
344 dict.sid("__imag__"): IMAG,
345 dict.sid("__int128"): INT128,
346 dict.sid("__label__"): LABEL,
347 dict.sid("__real"): REAL,
348 dict.sid("__real__"): REAL,
349 }
350)
351
352func init() {
353 for r := rune(0xe001); r < lastTok; r++ {
354 if _, ok := tokNames[r]; !ok {
355 panic(internalError())
356 }
357 }
358 for k, v := range keywords {
359 gccKeywords[k] = v
360 }
361}
362
363func tokName(r rune) string {
364 switch {
365 case r < 0:
366 return "<EOF>"
367 case r >= unicodePrivateAreaFirst && r <= unicodePrivateAreaLast:
368 return tokNames[r].String()
369 default:
370 return fmt.Sprintf("%+q", r)
371 }
372}
373
374type parser struct {
375 block *CompoundStatement
376 ctx *context
377 currFn *FunctionDefinition
378 declScope Scope
379 fileScope Scope
380 hash *maphash.Hash
381 in chan *[]Token
382 inBuf []Token
383 inBufp *[]Token
384 key sharedFunctionDefinitionKey
385 prev Token
386 resolveScope Scope
387 resolvedIn Scope // Typedef name
388 scopes int
389 sepLen int
390 seps []StringID
391 strcatLen int
392 strcats []StringID
393 switches int
394
395 tok Token
396
397 closed bool
398 errored bool
399 ignoreKeywords bool
400 typedefNameEnabled bool
401}
402
403func newParser(ctx *context, in chan *[]Token) *parser {
404 s := Scope{}
405 var hash *maphash.Hash
406 if s := ctx.cfg.SharedFunctionDefinitions; s != nil {
407 hash = &s.hash
408 }
409 return &parser{
410 ctx: ctx,
411 declScope: s,
412 fileScope: s,
413 hash: hash,
414 in: in,
415 resolveScope: s,
416 }
417}
418
419func (p *parser) openScope(skip bool) {
420 p.scopes++
421 p.declScope = p.declScope.new()
422 if skip {
423 p.declScope[scopeSkip] = nil
424 }
425 p.resolveScope = p.declScope
426 // var a []string
427 // for s := p.declScope; s != nil; s = s.Parent() {
428 // a = append(a, fmt.Sprintf("%p", s))
429 // }
430 // trc("openScope(%v) %p: %v", skip, p.declScope, strings.Join(a, " "))
431}
432
433func (p *parser) closeScope() {
434 // declScope := p.declScope
435 p.declScope = p.declScope.Parent()
436 p.resolveScope = p.declScope
437 p.scopes--
438 // var a []string
439 // for s := p.declScope; s != nil; s = s.Parent() {
440 // a = append(a, fmt.Sprintf("%p", s))
441 // }
442 // trc("%p.closeScope %v", declScope, strings.Join(a, " "))
443}
444
445func (p *parser) err0(consume bool, msg string, args ...interface{}) {
446 if panicOnParserError { //TODOOK
447 s := fmt.Sprintf("FAIL: "+msg, args...)
448 panic(fmt.Sprintf("%s\n%s: ", s, PrettyString(p.tok))) //TODOOK
449 }
450 // s := fmt.Sprintf("FAIL: "+p.tok.Position().String()+": "+msg, args...)
451 // caller("%s: %s: ", s, PrettyString(p.tok))
452 p.errored = true
453 if consume {
454 p.tok.Rune = 0
455 }
456 if p.ctx.err(p.tok.Position(), "`%s`: "+msg, append([]interface{}{p.tok}, args...)...) {
457 p.closed = true
458 }
459}
460
461func (p *parser) err(msg string, args ...interface{}) { p.err0(true, msg, args...) }
462
463func (p *parser) rune() rune {
464 if p.tok.Rune == 0 {
465 p.next()
466 }
467 return p.tok.Rune
468}
469
470func (p *parser) shift() (r Token) {
471 if p.tok.Rune == 0 {
472 p.next()
473 }
474 r = p.tok
475 p.tok.Rune = 0
476 // dbg("", shift(r))
477 return r
478}
479
480func (p *parser) unget(toks ...Token) { //TODO injected __func__ has two trailing semicolons, why?
481 p.inBuf = append(toks, p.inBuf...)
482 // fmt.Printf("unget %q\n", tokStr(toks, "|")) //TODO-
483}
484
485func (p *parser) peek(handleTypedefname bool) rune {
486 if p.closed {
487 return -1
488 }
489
490 if len(p.inBuf) == 0 {
491 if p.inBufp != nil {
492 tokenPool.Put(p.inBufp)
493 }
494 var ok bool
495 if p.inBufp, ok = <-p.in; !ok {
496 // dbg("parser: EOF")
497 return -1
498 }
499
500 p.inBuf = *p.inBufp
501 // dbg("parser receives: %q", tokStr(p.inBuf, "|"))
502 // fmt.Printf("parser receives %v: %q\n", p.inBuf[0].Position(), tokStr(p.inBuf, "|")) //TODO-
503 }
504 tok := p.inBuf[0]
505 r := tok.Rune
506 if r == IDENTIFIER {
507 if x, ok := p.ctx.keywords[p.inBuf[0].Value]; ok && !p.ignoreKeywords {
508 return x
509 }
510
511 if handleTypedefname {
512 nm := tok.Value
513 seq := tok.seq
514 for s := p.resolveScope; s != nil; s = s.Parent() {
515 for _, v := range s[nm] {
516 switch x := v.(type) {
517 case *Declarator:
518 if !x.isVisible(seq) {
519 continue
520 }
521
522 if x.IsTypedefName && p.peek(false) != ':' {
523 return TYPEDEFNAME
524 }
525
526 return IDENTIFIER
527 case *Enumerator:
528 return IDENTIFIER
529 case *EnumSpecifier, *StructOrUnionSpecifier, *StructDeclarator, *LabeledStatement:
530 // nop
531 default:
532 panic(internalErrorf("%T", x))
533 }
534 }
535 }
536 }
537 }
538 return r
539}
540
541func (p *parser) next() {
542 if p.closed {
543 // dbg("parser: EOF")
544 p.tok.Rune = -1
545 return
546 }
547
548more:
549 if len(p.inBuf) == 0 {
550 if p.inBufp != nil {
551 tokenPool.Put(p.inBufp)
552 }
553 var ok bool
554 if p.inBufp, ok = <-p.in; !ok {
555 // dbg("parser: EOF")
556 p.closed = true
557 p.tok.Rune = -1
558 return
559 }
560
561 p.inBuf = *p.inBufp
562 // dbg("parser receives: %q", tokStr(p.inBuf, "|"))
563 // fmt.Printf("parser receives %v: %q\n", p.inBuf[0].Position(), tokStr(p.inBuf, "|")) //TODO-
564 }
565 p.tok = p.inBuf[0]
566 switch p.tok.Rune {
567 case STRINGLITERAL, LONGSTRINGLITERAL:
568 switch p.prev.Rune {
569 case STRINGLITERAL, LONGSTRINGLITERAL:
570 p.strcatLen += len(p.tok.Value.String())
571 p.strcats = append(p.strcats, p.tok.Value)
572 p.sepLen += len(p.tok.Sep.String())
573 p.seps = append(p.seps, p.tok.Sep)
574 p.inBuf = p.inBuf[1:]
575 goto more
576 default:
577 p.strcatLen = len(p.tok.Value.String())
578 p.strcats = []StringID{p.tok.Value}
579 p.sepLen = len(p.tok.Sep.String())
580 p.seps = []StringID{p.tok.Sep}
581 p.prev = p.tok
582 p.inBuf = p.inBuf[1:]
583 goto more
584 }
585 default:
586 switch p.prev.Rune {
587 case STRINGLITERAL, LONGSTRINGLITERAL:
588 p.tok = p.prev
589 var b bytes.Buffer
590 b.Grow(p.strcatLen)
591 for _, v := range p.strcats {
592 b.WriteString(v.String())
593 }
594 p.tok.Value = dict.id(b.Bytes())
595 b.Reset()
596 b.Grow(p.sepLen)
597 for _, v := range p.seps {
598 b.WriteString(v.String())
599 }
600 p.tok.Sep = dict.id(b.Bytes())
601 p.prev.Rune = 0
602 default:
603 p.inBuf = p.inBuf[1:]
604 }
605 }
606 p.resolvedIn = nil
607out:
608 switch p.tok.Rune {
609 case IDENTIFIER:
610 nm := p.tok.Value
611 if x, ok := p.ctx.keywords[nm]; ok && !p.ignoreKeywords {
612 p.tok.Rune = x
613 break
614 }
615
616 if p.typedefNameEnabled {
617 seq := p.tok.seq
618 // dbg("checking for typedefname in scope %p", p.resolveScope)
619 for s := p.resolveScope; s != nil; s = s.Parent() {
620 // dbg("scope %p", s)
621 for _, v := range s[nm] {
622 // dbg("%v: %T", nm, v)
623 switch x := v.(type) {
624 case *Declarator:
625 if !x.isVisible(seq) {
626 continue
627 }
628
629 // dbg("", x.isVisible(pos), x.IsTypedefName)
630 if x.IsTypedefName && p.peek(false) != ':' {
631 p.tok.Rune = TYPEDEFNAME
632 p.resolvedIn = s
633 }
634
635 p.typedefNameEnabled = false
636 break out
637 case *Enumerator:
638 if x.isVisible(seq) {
639 break out
640 }
641 case *EnumSpecifier, *StructOrUnionSpecifier, *StructDeclarator, *LabeledStatement:
642 // nop
643 default:
644 panic(internalError())
645 }
646 }
647 }
648 }
649 case PPNUMBER:
650 switch s := p.tok.Value.String(); {
651 case strings.ContainsAny(s, ".+-ijpIJP"):
652 p.tok.Rune = FLOATCONST
653 case strings.HasPrefix(s, "0x") || strings.HasPrefix(s, "0X"):
654 p.tok.Rune = INTCONST
655 case strings.ContainsAny(s, "Ee"):
656 p.tok.Rune = FLOATCONST
657 default:
658 p.tok.Rune = INTCONST
659 }
660 }
661 if p.ctx.cfg.SharedFunctionDefinitions != nil {
662 p.hashTok()
663 }
664 // dbg("parser.next p.tok %v", PrettyString(p.tok))
665 // fmt.Printf("%s%s/* %s */", p.tok.Sep, p.tok.Value, tokName(p.tok.Rune)) //TODO-
666}
667
668func (p *parser) hashTok() {
669 n := p.tok.Rune
670 for i := 0; i < 4; i++ {
671 p.hash.WriteByte(byte(n))
672 n >>= 8
673 }
674 n = int32(p.tok.Value)
675 for i := 0; i < 4; i++ {
676 p.hash.WriteByte(byte(n))
677 n >>= 8
678 }
679}
680
681// [0], 6.5.1 Primary expressions
682//
683// primary-expression:
684// identifier
685// constant
686// string-literal
687// ( expression )
688// ( compound-statement )
689func (p *parser) primaryExpression() *PrimaryExpression {
690 var kind PrimaryExpressionCase
691 var resolvedIn Scope
692 var resolvedTo Node
693out:
694 switch p.rune() {
695 case IDENTIFIER:
696 kind = PrimaryExpressionIdent
697 nm := p.tok.Value
698 seq := p.tok.seq
699 for s := p.resolveScope; s != nil; s = s.Parent() {
700 for _, v := range s[nm] {
701 switch x := v.(type) {
702 case *Enumerator:
703 if x.isVisible(seq) {
704 resolvedIn = s
705 resolvedTo = x
706 p.tok.Rune = ENUMCONST
707 kind = PrimaryExpressionEnum
708 break out
709 }
710 case *Declarator:
711 if x.IsTypedefName || !x.isVisible(seq) {
712 continue
713 }
714
715 resolvedIn = s
716 resolvedTo = x
717 break out
718 case *EnumSpecifier, *StructOrUnionSpecifier, *StructDeclarator, *LabeledStatement:
719 // nop
720 default:
721 panic(internalError())
722 }
723 }
724 }
725
726 if !p.ctx.cfg.ignoreUndefinedIdentifiers && p.ctx.cfg.RejectLateBinding {
727 p.err0(false, "front-end: undefined: %s", nm)
728 }
729 case INTCONST:
730 kind = PrimaryExpressionInt
731 case FLOATCONST:
732 kind = PrimaryExpressionFloat
733 case ENUMCONST:
734 kind = PrimaryExpressionEnum
735 case CHARCONST:
736 kind = PrimaryExpressionChar
737 case LONGCHARCONST:
738 kind = PrimaryExpressionLChar
739 case STRINGLITERAL:
740 kind = PrimaryExpressionString
741 case LONGSTRINGLITERAL:
742 kind = PrimaryExpressionLString
743 case '(':
744 t := p.shift()
745 switch p.peek(false) {
746 case '{':
747 if p.ctx.cfg.RejectStatementExpressions {
748 p.err0(false, "statement expressions not allowed")
749 }
750 s := p.compoundStatement(nil, nil)
751 var t2 Token
752 switch p.rune() {
753 case ')':
754 t2 = p.shift()
755 default:
756 p.err("expected )")
757 }
758 return &PrimaryExpression{Case: PrimaryExpressionStmt, Token: t, CompoundStatement: s, Token2: t2, lexicalScope: p.declScope}
759 default:
760 e := p.expression()
761 var t2 Token
762 switch p.rune() {
763 case ')':
764 t2 = p.shift()
765 default:
766 p.err("expected )")
767 }
768 return &PrimaryExpression{Case: PrimaryExpressionExpr, Token: t, Expression: e, Token2: t2, lexicalScope: p.declScope}
769 }
770 default:
771 p.err("expected primary-expression")
772 return nil
773 }
774
775 return &PrimaryExpression{Case: kind, Token: p.shift(), lexicalScope: p.declScope, resolvedIn: resolvedIn, resolvedTo: resolvedTo}
776}
777
778// [0], 6.5.2 Postfix operators
779//
780// postfix-expression:
781// primary-expression
782// postfix-expression [ expression ]
783// postfix-expression ( argument-expression-list_opt )
784// postfix-expression . identifier
785// postfix-expression -> identifier
786// postfix-expression ++
787// postfix-expression --
788// ( type-name ) { initializer-list }
789// ( type-name ) { initializer-list , }
790// __builtin_types_compatible_p ( type-name , type-name )
791func (p *parser) postfixExpression(typ *TypeName) (r *PostfixExpression) {
792 var t, t2, t3, t4, t5 Token
793out:
794 switch {
795 case typ != nil:
796 switch p.rune() {
797 case '{':
798 t3 = p.shift()
799 default:
800 p.err("expected {")
801 return nil
802 }
803
804 var list *InitializerList
805 switch p.rune() {
806 case '}':
807 if p.ctx.cfg.RejectEmptyInitializerList {
808 p.err0(false, "expected initializer-list")
809 }
810 default:
811 list = p.initializerList(nil)
812 if p.rune() == ',' {
813 t4 = p.shift()
814 }
815 }
816 switch p.rune() {
817 case '}':
818 t5 = p.shift()
819 default:
820 p.err("expected }")
821 }
822 r = &PostfixExpression{Case: PostfixExpressionComplit, Token: t, TypeName: typ, Token2: t2, Token3: t3, InitializerList: list, Token4: t4, Token5: t5}
823 break out
824 default:
825 switch p.rune() {
826 case BUILTINCHOOSEEXPR:
827 t = p.shift()
828 switch p.rune() {
829 case '(':
830 t2 = p.shift()
831 default:
832 p.err("expected (")
833 }
834 expr1 := p.assignmentExpression()
835 switch p.rune() {
836 case ',':
837 t3 = p.shift()
838 default:
839 p.err("expected ,")
840 }
841 expr2 := p.assignmentExpression()
842 switch p.rune() {
843 case ',':
844 t4 = p.shift()
845 default:
846 p.err("expected ,")
847 }
848 expr3 := p.assignmentExpression()
849 switch p.rune() {
850 case ')':
851 t5 = p.shift()
852 default:
853 p.err("expected )")
854 }
855 return &PostfixExpression{Case: PostfixExpressionChooseExpr, Token: t, Token2: t2, Token3: t3, Token4: t4, Token5: t5, AssignmentExpression: expr1, AssignmentExpression2: expr2, AssignmentExpression3: expr3}
856 case BUILTINTYPESCOMPATIBLE:
857 t = p.shift()
858 switch p.rune() {
859 case '(':
860 t2 = p.shift()
861 default:
862 p.err("expected (")
863 }
864 typ := p.typeName()
865 switch p.rune() {
866 case ',':
867 t3 = p.shift()
868 default:
869 p.err("expected ,")
870 }
871 typ2 := p.typeName()
872 switch p.rune() {
873 case ')':
874 t4 = p.shift()
875 default:
876 p.err("expected )")
877 }
878 return &PostfixExpression{Case: PostfixExpressionTypeCmp, Token: t, Token2: t2, TypeName: typ, Token3: t3, TypeName2: typ2, Token4: t4}
879 case '(':
880 switch p.peek(true) {
881 case VOID, CHAR, SHORT, INT, INT8, INT16, INT32, INT64, INT128, LONG, FLOAT, FLOAT16, FLOAT80, FLOAT32, FLOAT32X, FLOAT64, FLOAT64X, FLOAT128, DECIMAL32, DECIMAL64, DECIMAL128, FRACT, SAT, ACCUM, DOUBLE, SIGNED, UNSIGNED, BOOL, COMPLEX, STRUCT, UNION, ENUM, TYPEDEFNAME, TYPEOF, ATOMIC,
882 ATTRIBUTE, CONST, RESTRICT, VOLATILE:
883 p.typedefNameEnabled = true
884 t = p.shift()
885 typ := p.typeName()
886 p.typedefNameEnabled = false
887 switch p.rune() {
888 case ')':
889 t2 = p.shift()
890 default:
891 p.err("expected )")
892 }
893 switch p.rune() {
894 case '{':
895 t3 = p.shift()
896 default:
897 p.err("expected {")
898 }
899 var list *InitializerList
900 switch p.rune() {
901 case '}':
902 if p.ctx.cfg.RejectEmptyInitializerList {
903 p.err0(false, "expected initializer-list")
904 }
905 default:
906 list = p.initializerList(nil)
907 if p.rune() == ',' {
908 t4 = p.shift()
909 }
910 }
911 switch p.rune() {
912 case '}':
913 t5 = p.shift()
914 default:
915 p.err("expected }")
916 }
917 r = &PostfixExpression{Case: PostfixExpressionComplit, Token: t, TypeName: typ, Token2: t2, Token3: t3, InitializerList: list, Token4: t4, Token5: t5}
918 break out
919 }
920
921 fallthrough
922 default:
923 pe := p.primaryExpression()
924 if pe == nil {
925 return nil
926 }
927
928 r = &PostfixExpression{Case: PostfixExpressionPrimary, PrimaryExpression: pe}
929 }
930 }
931
932 for {
933 switch p.rune() {
934 case '[':
935 t = p.shift()
936 e := p.expression()
937 switch p.rune() {
938 case ']':
939 t2 = p.shift()
940 default:
941 p.err("expected ]")
942 }
943 r = &PostfixExpression{Case: PostfixExpressionIndex, PostfixExpression: r, Token: t, Expression: e, Token2: t2}
944 case '(':
945 t = p.shift()
946 list := p.argumentExpressionListOpt()
947 switch p.rune() {
948 case ')':
949 t2 = p.shift()
950 default:
951 p.err("expected )")
952 }
953 r = &PostfixExpression{Case: PostfixExpressionCall, PostfixExpression: r, Token: t, ArgumentExpressionList: list, Token2: t2}
954 case '.':
955 t = p.shift()
956 switch p.rune() {
957 case IDENTIFIER:
958 t2 = p.shift()
959 default:
960 p.err("expected identifier")
961 }
962 r = &PostfixExpression{Case: PostfixExpressionSelect, PostfixExpression: r, Token: t, Token2: t2}
963 case ARROW:
964 t = p.shift()
965 switch p.rune() {
966 case IDENTIFIER:
967 t2 = p.shift()
968 default:
969 p.err("expected identifier")
970 }
971 r = &PostfixExpression{Case: PostfixExpressionPSelect, PostfixExpression: r, Token: t, Token2: t2}
972 case INC:
973 r = &PostfixExpression{Case: PostfixExpressionInc, PostfixExpression: r, Token: p.shift()}
974 case DEC:
975 r = &PostfixExpression{Case: PostfixExpressionDec, PostfixExpression: r, Token: p.shift()}
976 default:
977 return r
978 }
979 }
980}
981
982// argument-expression-list:
983// assignment-expression
984// argument-expression-list , assignment-expression
985func (p *parser) argumentExpressionListOpt() (r *ArgumentExpressionList) {
986 if p.rune() == ')' {
987 return nil
988 }
989
990 e := p.assignmentExpression()
991 if e == nil {
992 return nil
993 }
994
995 r = &ArgumentExpressionList{AssignmentExpression: e}
996 for prev := r; ; prev = prev.ArgumentExpressionList {
997 switch p.rune() {
998 case ',':
999 t := p.shift()
1000 prev.ArgumentExpressionList = &ArgumentExpressionList{Token: t, AssignmentExpression: p.assignmentExpression()}
1001 case ')':
1002 return r
1003 default:
1004 p.err("expected , or )")
1005 return r
1006 }
1007 }
1008}
1009
1010// [0], 6.5.3 Unary operators
1011//
1012// unary-expression:
1013// postfix-expression
1014// ++ unary-expression
1015// -- unary-expression
1016// unary-operator cast-expression
1017// sizeof unary-expression
1018// sizeof ( type-name )
1019// && identifier
1020// _Alignof unary-expression
1021// _Alignof ( type-name )
1022// __imag__ unary-expression
1023// __real__ unary-expression
1024//
1025// unary-operator: one of
1026// & * + - ~ !
1027func (p *parser) unaryExpression(typ *TypeName) *UnaryExpression {
1028 if typ != nil {
1029 return &UnaryExpression{Case: UnaryExpressionPostfix, PostfixExpression: p.postfixExpression(typ), lexicalScope: p.declScope}
1030 }
1031
1032 var kind UnaryExpressionCase
1033 var t, t2, t3 Token
1034 switch p.rune() {
1035 case INC:
1036 t = p.shift()
1037 return &UnaryExpression{Case: UnaryExpressionInc, Token: t, UnaryExpression: p.unaryExpression(nil), lexicalScope: p.declScope}
1038 case DEC:
1039 t = p.shift()
1040 return &UnaryExpression{Case: UnaryExpressionDec, Token: t, UnaryExpression: p.unaryExpression(nil), lexicalScope: p.declScope}
1041 case '&':
1042 kind = UnaryExpressionAddrof
1043 case '*':
1044 kind = UnaryExpressionDeref
1045 case '+':
1046 kind = UnaryExpressionPlus
1047 case '-':
1048 kind = UnaryExpressionMinus
1049 case '~':
1050 kind = UnaryExpressionCpl
1051 case '!':
1052 kind = UnaryExpressionNot
1053 case SIZEOF:
1054 t = p.shift()
1055 switch p.rune() {
1056 case '(':
1057 switch p.peek(true) {
1058 case VOID, CHAR, SHORT, INT, INT8, INT16, INT32, INT64, INT128, LONG, FLOAT, FLOAT16, FLOAT80, FLOAT32, FLOAT32X, FLOAT64, FLOAT64X, FLOAT128, DECIMAL32, DECIMAL64, DECIMAL128, FRACT, SAT, ACCUM, DOUBLE, SIGNED, UNSIGNED, BOOL, COMPLEX, STRUCT, UNION, ENUM, TYPEDEFNAME, TYPEOF, ATOMIC,
1059 ATTRIBUTE, CONST, RESTRICT, VOLATILE:
1060 p.typedefNameEnabled = true
1061 t2 = p.shift()
1062 typ := p.typeName()
1063 p.typedefNameEnabled = false
1064 switch p.rune() {
1065 case ')':
1066 t3 = p.shift()
1067 default:
1068 p.err("expected )")
1069 }
1070 if p.peek(false) == '{' {
1071 return &UnaryExpression{Case: UnaryExpressionSizeofExpr, Token: t, UnaryExpression: p.unaryExpression(typ), lexicalScope: p.declScope}
1072 }
1073
1074 return &UnaryExpression{Case: UnaryExpressionSizeofType, Token: t, Token2: t2, TypeName: typ, Token3: t3, lexicalScope: p.declScope}
1075 }
1076
1077 fallthrough
1078 default:
1079 return &UnaryExpression{Case: UnaryExpressionSizeofExpr, Token: t, UnaryExpression: p.unaryExpression(nil), lexicalScope: p.declScope}
1080 }
1081 case ANDAND:
1082 t = p.shift()
1083 var t2 Token
1084 switch p.rune() {
1085 case IDENTIFIER:
1086 t2 = p.shift()
1087 default:
1088 p.err("expected identifier")
1089 }
1090 return &UnaryExpression{Case: UnaryExpressionLabelAddr, Token: t, Token2: t2, lexicalScope: p.declScope}
1091 case ALIGNOF:
1092 t = p.shift()
1093 switch p.rune() {
1094 case '(':
1095 switch p.peek(true) {
1096 case VOID, CHAR, SHORT, INT, INT8, INT16, INT32, INT64, INT128, LONG, FLOAT, FLOAT16, FLOAT80, FLOAT32, FLOAT32X, FLOAT64, FLOAT64X, FLOAT128, DECIMAL32, DECIMAL64, DECIMAL128, FRACT, SAT, ACCUM, DOUBLE, SIGNED, UNSIGNED, BOOL, COMPLEX, STRUCT, UNION, ENUM, TYPEDEFNAME, TYPEOF, ATOMIC,
1097 ATTRIBUTE, CONST, RESTRICT, VOLATILE,
1098 ALIGNAS:
1099 t2 = p.shift()
1100 typ := p.typeName()
1101 switch p.rune() {
1102 case ')':
1103 t3 = p.shift()
1104 default:
1105 p.err("expected )")
1106 }
1107 return &UnaryExpression{Case: UnaryExpressionAlignofType, Token: t, Token2: t2, TypeName: typ, Token3: t2, lexicalScope: p.declScope}
1108 default:
1109 return &UnaryExpression{Case: UnaryExpressionAlignofExpr, Token: t, UnaryExpression: p.unaryExpression(nil), lexicalScope: p.declScope}
1110 }
1111 default:
1112 return &UnaryExpression{Case: UnaryExpressionAlignofExpr, Token: t, UnaryExpression: p.unaryExpression(nil), lexicalScope: p.declScope}
1113 }
1114 case IMAG:
1115 t = p.shift()
1116 return &UnaryExpression{Case: UnaryExpressionImag, Token: t, UnaryExpression: p.unaryExpression(nil), lexicalScope: p.declScope}
1117 case REAL:
1118 t = p.shift()
1119 return &UnaryExpression{Case: UnaryExpressionReal, Token: t, UnaryExpression: p.unaryExpression(nil), lexicalScope: p.declScope}
1120 default:
1121 return &UnaryExpression{Case: UnaryExpressionPostfix, PostfixExpression: p.postfixExpression(nil), lexicalScope: p.declScope}
1122 }
1123
1124 t = p.shift()
1125 return &UnaryExpression{Case: kind, Token: t, CastExpression: p.castExpression(), lexicalScope: p.declScope}
1126}
1127
1128// [0], 6.5.4 Cast operators
1129//
1130// cast-expression:
1131// unary-expression
1132// ( type-name ) cast-expression
1133func (p *parser) castExpression() *CastExpression {
1134 var t, t2 Token
1135 switch p.rune() {
1136 case '(':
1137 switch p.peek(true) {
1138 case VOID, CHAR, SHORT, INT, INT8, INT16, INT32, INT64, INT128, LONG, FLOAT, FLOAT16, FLOAT80, FLOAT32, FLOAT32X, FLOAT64, FLOAT64X, FLOAT128, DECIMAL32, DECIMAL64, DECIMAL128, FRACT, SAT, ACCUM, DOUBLE, SIGNED, UNSIGNED, BOOL, COMPLEX, STRUCT, UNION, ENUM, TYPEDEFNAME, TYPEOF, ATOMIC,
1139 ATTRIBUTE, CONST, RESTRICT, VOLATILE:
1140 p.typedefNameEnabled = true
1141 t = p.shift()
1142 typ := p.typeName()
1143 p.typedefNameEnabled = false
1144 switch p.rune() {
1145 case ')':
1146 t2 = p.shift()
1147 default:
1148 p.err("expected )")
1149 }
1150 if p.peek(false) == '{' {
1151 return &CastExpression{Case: CastExpressionUnary, UnaryExpression: p.unaryExpression(typ)}
1152 }
1153
1154 return &CastExpression{Case: CastExpressionCast, Token: t, TypeName: typ, Token2: t2, CastExpression: p.castExpression()}
1155 }
1156
1157 fallthrough
1158 default:
1159 return &CastExpression{Case: CastExpressionUnary, UnaryExpression: p.unaryExpression(nil)}
1160 }
1161}
1162
1163// [0], 6.5.5 Multiplicative operators
1164//
1165// multiplicative-expression:
1166// cast-expression
1167// multiplicative-expression * cast-expression
1168// multiplicative-expression / cast-expression
1169// multiplicative-expression % cast-expression
1170func (p *parser) multiplicativeExpression() (r *MultiplicativeExpression) {
1171 r = &MultiplicativeExpression{Case: MultiplicativeExpressionCast, CastExpression: p.castExpression()}
1172 for {
1173 var kind MultiplicativeExpressionCase
1174 switch p.rune() {
1175 case '*':
1176 kind = MultiplicativeExpressionMul
1177 case '/':
1178 kind = MultiplicativeExpressionDiv
1179 case '%':
1180 kind = MultiplicativeExpressionMod
1181 default:
1182 return r
1183 }
1184
1185 t := p.shift()
1186 r = &MultiplicativeExpression{Case: kind, MultiplicativeExpression: r, Token: t, CastExpression: p.castExpression()}
1187 }
1188}
1189
1190// [0], 6.5.6 Additive operators
1191//
1192// additive-expression:
1193// multiplicative-expression
1194// additive-expression + multiplicative-expression
1195// additive-expression - multiplicative-expression
1196func (p *parser) additiveExpression() (r *AdditiveExpression) {
1197 r = &AdditiveExpression{Case: AdditiveExpressionMul, MultiplicativeExpression: p.multiplicativeExpression()}
1198 for {
1199 var kind AdditiveExpressionCase
1200 switch p.rune() {
1201 case '+':
1202 kind = AdditiveExpressionAdd
1203 case '-':
1204 kind = AdditiveExpressionSub
1205 default:
1206 return r
1207 }
1208
1209 t := p.shift()
1210 r = &AdditiveExpression{Case: kind, AdditiveExpression: r, Token: t, MultiplicativeExpression: p.multiplicativeExpression(), lexicalScope: p.declScope}
1211 }
1212}
1213
1214// [0], 6.5.7 Bitwise shift operators
1215//
1216// shift-expression:
1217// additive-expression
1218// shift-expression << additive-expression
1219// shift-expression >> additive-expression
1220func (p *parser) shiftExpression() (r *ShiftExpression) {
1221 r = &ShiftExpression{Case: ShiftExpressionAdd, AdditiveExpression: p.additiveExpression()}
1222 for {
1223 var kind ShiftExpressionCase
1224 switch p.rune() {
1225 case LSH:
1226 kind = ShiftExpressionLsh
1227 case RSH:
1228 kind = ShiftExpressionRsh
1229 default:
1230 return r
1231 }
1232
1233 t := p.shift()
1234 r = &ShiftExpression{Case: kind, ShiftExpression: r, Token: t, AdditiveExpression: p.additiveExpression()}
1235 }
1236}
1237
1238// [0], 6.5.8 Relational operators
1239//
1240// relational-expression:
1241// shift-expression
1242// relational-expression < shift-expression
1243// relational-expression > shift-expression
1244// relational-expression <= shift-expression
1245// relational-expression >= shift-expression
1246func (p *parser) relationalExpression() (r *RelationalExpression) {
1247 r = &RelationalExpression{Case: RelationalExpressionShift, ShiftExpression: p.shiftExpression()}
1248 for {
1249 var kind RelationalExpressionCase
1250 switch p.rune() {
1251 case '<':
1252 kind = RelationalExpressionLt
1253 case '>':
1254 kind = RelationalExpressionGt
1255 case LEQ:
1256 kind = RelationalExpressionLeq
1257 case GEQ:
1258 kind = RelationalExpressionGeq
1259 default:
1260 return r
1261 }
1262
1263 t := p.shift()
1264 r = &RelationalExpression{Case: kind, RelationalExpression: r, Token: t, ShiftExpression: p.shiftExpression()}
1265 }
1266}
1267
1268// [0], 6.5.9 Equality operators
1269//
1270// equality-expression:
1271// relational-expression
1272// equality-expression == relational-expression
1273// equality-expression != relational-expression
1274func (p *parser) equalityExpression() (r *EqualityExpression) {
1275 r = &EqualityExpression{Case: EqualityExpressionRel, RelationalExpression: p.relationalExpression()}
1276 for {
1277 var kind EqualityExpressionCase
1278 switch p.rune() {
1279 case EQ:
1280 kind = EqualityExpressionEq
1281 case NEQ:
1282 kind = EqualityExpressionNeq
1283 default:
1284 return r
1285 }
1286
1287 t := p.shift()
1288 r = &EqualityExpression{Case: kind, EqualityExpression: r, Token: t, RelationalExpression: p.relationalExpression()}
1289 }
1290}
1291
1292// [0], 6.5.10 Bitwise AND operator
1293//
1294// AND-expression:
1295// equality-expression
1296// AND-expression & equality-expression
1297func (p *parser) andExpression() (r *AndExpression) {
1298 r = &AndExpression{Case: AndExpressionEq, EqualityExpression: p.equalityExpression()}
1299 for {
1300 switch p.rune() {
1301 case '&':
1302 t := p.shift()
1303 r = &AndExpression{Case: AndExpressionAnd, AndExpression: r, Token: t, EqualityExpression: p.equalityExpression()}
1304 default:
1305 return r
1306 }
1307 }
1308}
1309
1310// [0], 6.5.11 Bitwise exclusive OR operator
1311//
1312// exclusive-OR-expression:
1313// AND-expression
1314// exclusive-OR-expression ^ AND-expression
1315func (p *parser) exclusiveOrExpression() (r *ExclusiveOrExpression) {
1316 r = &ExclusiveOrExpression{Case: ExclusiveOrExpressionAnd, AndExpression: p.andExpression()}
1317 for {
1318 switch p.rune() {
1319 case '^':
1320 t := p.shift()
1321 r = &ExclusiveOrExpression{Case: ExclusiveOrExpressionXor, ExclusiveOrExpression: r, Token: t, AndExpression: p.andExpression()}
1322 default:
1323 return r
1324 }
1325 }
1326}
1327
1328// [0], 6.5.12 Bitwise inclusive OR operator
1329//
1330// inclusive-OR-expression:
1331// exclusive-OR-expression
1332// inclusive-OR-expression | exclusive-OR-expression
1333func (p *parser) inclusiveOrExpression() (r *InclusiveOrExpression) {
1334 r = &InclusiveOrExpression{Case: InclusiveOrExpressionXor, ExclusiveOrExpression: p.exclusiveOrExpression()}
1335 for {
1336 switch p.rune() {
1337 case '|':
1338 t := p.shift()
1339 r = &InclusiveOrExpression{Case: InclusiveOrExpressionOr, InclusiveOrExpression: r, Token: t, ExclusiveOrExpression: p.exclusiveOrExpression()}
1340 default:
1341 return r
1342 }
1343 }
1344}
1345
1346// [0], 6.5.13 Logical AND operator
1347//
1348// logical-AND-expression:
1349// inclusive-OR-expression
1350// logical-AND-expression && inclusive-OR-expression
1351func (p *parser) logicalAndExpression() (r *LogicalAndExpression) {
1352 r = &LogicalAndExpression{Case: LogicalAndExpressionOr, InclusiveOrExpression: p.inclusiveOrExpression()}
1353 for {
1354 switch p.rune() {
1355 case ANDAND:
1356 t := p.shift()
1357 r = &LogicalAndExpression{Case: LogicalAndExpressionLAnd, LogicalAndExpression: r, Token: t, InclusiveOrExpression: p.inclusiveOrExpression()}
1358 default:
1359 return r
1360 }
1361 }
1362}
1363
1364// [0], 6.5.14 Logical OR operator
1365//
1366// logical-OR-expression:
1367// logical-AND-expression
1368// logical-OR-expression || logical-AND-expression
1369func (p *parser) logicalOrExpression() (r *LogicalOrExpression) {
1370 r = &LogicalOrExpression{Case: LogicalOrExpressionLAnd, LogicalAndExpression: p.logicalAndExpression()}
1371 for {
1372 switch p.rune() {
1373 case OROR:
1374 t := p.shift()
1375 r = &LogicalOrExpression{Case: LogicalOrExpressionLOr, LogicalOrExpression: r, Token: t, LogicalAndExpression: p.logicalAndExpression()}
1376 default:
1377 return r
1378 }
1379 }
1380}
1381
1382// [0], 6.5.15 Conditional operator
1383//
1384// conditional-expression:
1385// logical-OR-expression
1386// logical-OR-expression ? expression : conditional-expression
1387func (p *parser) conditionalExpression() (r *ConditionalExpression) {
1388 lo := p.logicalOrExpression()
1389 var t, t2 Token
1390 switch p.rune() {
1391 case '?':
1392 t = p.shift()
1393 var e *Expression
1394 switch p.rune() {
1395 case ':':
1396 if p.ctx.cfg.RejectMissingConditionalExpr {
1397 p.err("expected expression")
1398 }
1399 default:
1400 e = p.expression()
1401 }
1402 switch p.rune() {
1403 case ':':
1404 t2 = p.shift()
1405 default:
1406 p.err("expected :")
1407 }
1408 return &ConditionalExpression{Case: ConditionalExpressionCond, LogicalOrExpression: lo, Token: t, Expression: e, Token2: t2, ConditionalExpression: p.conditionalExpression()}
1409 default:
1410 return &ConditionalExpression{Case: ConditionalExpressionLOr, LogicalOrExpression: lo}
1411 }
1412}
1413
1414// [0], 6.5.16 Assignment operators
1415//
1416// assignment-expression:
1417// conditional-expression
1418// unary-expression assignment-operator assignment-expression
1419//
1420// assignment-operator: one of
1421// = *= /= %= += -= <<= >>= &= ^= |=
1422func (p *parser) assignmentExpression() (r *AssignmentExpression) {
1423 ce := p.conditionalExpression()
1424 if ce == nil || ce.Case != ConditionalExpressionLOr {
1425 return &AssignmentExpression{Case: AssignmentExpressionCond, ConditionalExpression: ce, lexicalScope: p.declScope}
1426 }
1427
1428 loe := ce.LogicalOrExpression
1429 if loe == nil || loe.Case != LogicalOrExpressionLAnd {
1430 return &AssignmentExpression{Case: AssignmentExpressionCond, ConditionalExpression: ce, lexicalScope: p.declScope}
1431 }
1432
1433 lae := loe.LogicalAndExpression
1434 if lae == nil || lae.Case != LogicalAndExpressionOr {
1435 return &AssignmentExpression{Case: AssignmentExpressionCond, ConditionalExpression: ce, lexicalScope: p.declScope}
1436 }
1437
1438 ioe := lae.InclusiveOrExpression
1439 if ioe == nil || ioe.Case != InclusiveOrExpressionXor {
1440 return &AssignmentExpression{Case: AssignmentExpressionCond, ConditionalExpression: ce, lexicalScope: p.declScope}
1441 }
1442
1443 eoe := ioe.ExclusiveOrExpression
1444 if eoe == nil || eoe.Case != ExclusiveOrExpressionAnd {
1445 return &AssignmentExpression{Case: AssignmentExpressionCond, ConditionalExpression: ce, lexicalScope: p.declScope}
1446 }
1447
1448 ae := eoe.AndExpression
1449 if ae == nil || ae.Case != AndExpressionEq {
1450 return &AssignmentExpression{Case: AssignmentExpressionCond, ConditionalExpression: ce, lexicalScope: p.declScope}
1451 }
1452
1453 ee := ae.EqualityExpression
1454 if ee == nil || ee.Case != EqualityExpressionRel {
1455 return &AssignmentExpression{Case: AssignmentExpressionCond, ConditionalExpression: ce, lexicalScope: p.declScope}
1456 }
1457
1458 re := ee.RelationalExpression
1459 if re == nil || re.Case != RelationalExpressionShift {
1460 return &AssignmentExpression{Case: AssignmentExpressionCond, ConditionalExpression: ce, lexicalScope: p.declScope}
1461 }
1462
1463 se := re.ShiftExpression
1464 if se == nil || se.Case != ShiftExpressionAdd {
1465 return &AssignmentExpression{Case: AssignmentExpressionCond, ConditionalExpression: ce, lexicalScope: p.declScope}
1466 }
1467
1468 adde := se.AdditiveExpression
1469 if adde == nil || adde.Case != AdditiveExpressionMul {
1470 return &AssignmentExpression{Case: AssignmentExpressionCond, ConditionalExpression: ce, lexicalScope: p.declScope}
1471 }
1472
1473 me := adde.MultiplicativeExpression
1474 if me == nil || me.Case != MultiplicativeExpressionCast {
1475 return &AssignmentExpression{Case: AssignmentExpressionCond, ConditionalExpression: ce, lexicalScope: p.declScope}
1476 }
1477
1478 cast := me.CastExpression
1479 if cast == nil || cast.Case != CastExpressionUnary {
1480 return &AssignmentExpression{Case: AssignmentExpressionCond, ConditionalExpression: ce, lexicalScope: p.declScope}
1481 }
1482
1483 var kind AssignmentExpressionCase
1484 switch p.rune() {
1485 case '=':
1486 kind = AssignmentExpressionAssign
1487 case MULASSIGN:
1488 kind = AssignmentExpressionMul
1489 case DIVASSIGN:
1490 kind = AssignmentExpressionDiv
1491 case MODASSIGN:
1492 kind = AssignmentExpressionMod
1493 case ADDASSIGN:
1494 kind = AssignmentExpressionAdd
1495 case SUBASSIGN:
1496 kind = AssignmentExpressionSub
1497 case LSHASSIGN:
1498 kind = AssignmentExpressionLsh
1499 case RSHASSIGN:
1500 kind = AssignmentExpressionRsh
1501 case ANDASSIGN:
1502 kind = AssignmentExpressionAnd
1503 case XORASSIGN:
1504 kind = AssignmentExpressionXor
1505 case ORASSIGN:
1506 kind = AssignmentExpressionOr
1507 default:
1508 return &AssignmentExpression{Case: AssignmentExpressionCond, ConditionalExpression: ce, lexicalScope: p.declScope}
1509 }
1510
1511 t := p.shift()
1512 return &AssignmentExpression{Case: kind, UnaryExpression: cast.UnaryExpression, Token: t, AssignmentExpression: p.assignmentExpression(), lexicalScope: p.declScope}
1513}
1514
1515// [0], 6.5.17 Comma operator
1516//
1517// expression:
1518// assignment-expression
1519// expression , assignment-expression
1520func (p *parser) expression() (r *Expression) {
1521 r = &Expression{Case: ExpressionAssign, AssignmentExpression: p.assignmentExpression()}
1522 for {
1523 switch p.rune() {
1524 case ',':
1525 t := p.shift()
1526 r = &Expression{Case: ExpressionComma, Expression: r, Token: t, AssignmentExpression: p.assignmentExpression()}
1527 default:
1528 return r
1529 }
1530 }
1531}
1532
1533// [0], 6.6 Constant expressions
1534//
1535// constant-expression:
1536// conditional-expression
1537func (p *parser) constantExpression() (r *ConstantExpression) {
1538 return &ConstantExpression{ConditionalExpression: p.conditionalExpression()}
1539}
1540
1541// [0], 6.7 Declarations
1542//
1543// declaration:
1544// declaration-specifiers init-declarator-list_opt attribute-specifier-list_opt ;
1545func (p *parser) declaration(ds *DeclarationSpecifiers, d *Declarator) (r *Declaration) {
1546 defer func() {
1547 if cs := p.block; cs != nil && r != nil {
1548 cs.declarations = append(cs.declarations, r)
1549 }
1550 }()
1551
1552 if ds == nil {
1553 ds = p.declarationSpecifiers(nil, nil)
1554 }
1555 if ds == noDeclSpecs {
1556 ds = nil
1557 }
1558 if d == nil {
1559 switch p.rune() {
1560 case ';':
1561 p.typedefNameEnabled = true
1562 return &Declaration{DeclarationSpecifiers: ds, Token: p.shift()}
1563 }
1564 }
1565
1566 list := p.initDeclaratorList(d, ds.typedef())
1567 p.typedefNameEnabled = true
1568 var t Token
1569 switch p.rune() {
1570 case ';':
1571 t = p.shift()
1572 default:
1573 p.err("expected ;")
1574 }
1575 return &Declaration{DeclarationSpecifiers: ds, InitDeclaratorList: list, Token: t}
1576}
1577
1578// declaration-specifiers:
1579// storage-class-specifier declaration-specifiers_opt
1580// type-specifier declaration-specifiers_opt
1581// type-qualifier declaration-specifiers_opt
1582// function-specifier declaration-specifiers_opt
1583// alignment-specifier declaration-specifiers_opt
1584// attribute-specifier declaration-specifiers_opt
1585func (p *parser) declarationSpecifiers(extern, inline *bool) (r *DeclarationSpecifiers) {
1586 switch p.rune() {
1587 case TYPEDEF, EXTERN, STATIC, AUTO, REGISTER, THREADLOCAL:
1588 if extern != nil && p.rune() == EXTERN {
1589 *extern = true
1590 }
1591 r = &DeclarationSpecifiers{Case: DeclarationSpecifiersStorage, StorageClassSpecifier: p.storageClassSpecifier()}
1592 if r.StorageClassSpecifier.Case == StorageClassSpecifierTypedef {
1593 r.class = fTypedef
1594 }
1595 case VOID, CHAR, SHORT, INT, INT8, INT16, INT32, INT64, INT128, LONG, FLOAT, FLOAT16, FLOAT80, FLOAT32, FLOAT32X, FLOAT64, FLOAT64X, FLOAT128, DECIMAL32, DECIMAL64, DECIMAL128, FRACT, SAT, ACCUM, DOUBLE, SIGNED, UNSIGNED, BOOL, COMPLEX, STRUCT, UNION, ENUM, TYPEDEFNAME, TYPEOF:
1596 r = &DeclarationSpecifiers{Case: DeclarationSpecifiersTypeSpec, TypeSpecifier: p.typeSpecifier()}
1597 case CONST, RESTRICT, VOLATILE:
1598 r = &DeclarationSpecifiers{Case: DeclarationSpecifiersTypeQual, TypeQualifier: p.typeQualifier()}
1599 case INLINE, NORETURN:
1600 r = &DeclarationSpecifiers{Case: DeclarationSpecifiersFunc, FunctionSpecifier: p.functionSpecifier(inline)}
1601 case ALIGNAS:
1602 r = &DeclarationSpecifiers{Case: DeclarationSpecifiersAlignSpec, AlignmentSpecifier: p.alignmentSpecifier()}
1603 case ATOMIC:
1604 switch p.peek(false) {
1605 case '(':
1606 r = &DeclarationSpecifiers{Case: DeclarationSpecifiersTypeSpec, TypeSpecifier: p.typeSpecifier()}
1607 default:
1608 r = &DeclarationSpecifiers{Case: DeclarationSpecifiersTypeQual, TypeQualifier: p.typeQualifier()}
1609 }
1610 case ATTRIBUTE:
1611 r = &DeclarationSpecifiers{Case: DeclarationSpecifiersAttribute, AttributeSpecifier: p.attributeSpecifier()}
1612 default:
1613 p.err("expected declaration-specifiers")
1614 return nil
1615 }
1616 r0 := r
1617 for prev := r; ; prev = prev.DeclarationSpecifiers {
1618 switch p.rune() {
1619 case TYPEDEF, EXTERN, STATIC, AUTO, REGISTER, THREADLOCAL:
1620 if extern != nil && p.rune() == EXTERN {
1621 *extern = true
1622 }
1623 prev.DeclarationSpecifiers = &DeclarationSpecifiers{Case: DeclarationSpecifiersStorage, StorageClassSpecifier: p.storageClassSpecifier()}
1624 if prev.DeclarationSpecifiers.StorageClassSpecifier.Case == StorageClassSpecifierTypedef {
1625 r0.class |= fTypedef
1626 }
1627 case VOID, CHAR, SHORT, INT, INT8, INT16, INT32, INT64, INT128, LONG, FLOAT, FLOAT16, FLOAT80, FLOAT32, FLOAT32X, FLOAT64, FLOAT64X, FLOAT128, DECIMAL32, DECIMAL64, DECIMAL128, FRACT, SAT, ACCUM, DOUBLE, SIGNED, UNSIGNED, BOOL, COMPLEX, STRUCT, UNION, ENUM, TYPEDEFNAME, TYPEOF:
1628 prev.DeclarationSpecifiers = &DeclarationSpecifiers{Case: DeclarationSpecifiersTypeSpec, TypeSpecifier: p.typeSpecifier()}
1629 case CONST, RESTRICT, VOLATILE:
1630 prev.DeclarationSpecifiers = &DeclarationSpecifiers{Case: DeclarationSpecifiersTypeQual, TypeQualifier: p.typeQualifier()}
1631 case INLINE, NORETURN:
1632 prev.DeclarationSpecifiers = &DeclarationSpecifiers{Case: DeclarationSpecifiersFunc, FunctionSpecifier: p.functionSpecifier(inline)}
1633 case ALIGNAS:
1634 prev.DeclarationSpecifiers = &DeclarationSpecifiers{Case: DeclarationSpecifiersAlignSpec, AlignmentSpecifier: p.alignmentSpecifier()}
1635 case ATOMIC:
1636 switch p.peek(false) {
1637 case '(':
1638 prev.DeclarationSpecifiers = &DeclarationSpecifiers{Case: DeclarationSpecifiersTypeSpec, TypeSpecifier: p.typeSpecifier()}
1639 default:
1640 prev.DeclarationSpecifiers = &DeclarationSpecifiers{Case: DeclarationSpecifiersTypeQual, TypeQualifier: p.typeQualifier()}
1641 }
1642 case ATTRIBUTE:
1643 prev.DeclarationSpecifiers = &DeclarationSpecifiers{Case: DeclarationSpecifiersAttribute, AttributeSpecifier: p.attributeSpecifier()}
1644 default:
1645 return r
1646 }
1647 }
1648}
1649
1650// init-declarator-list:
1651// init-declarator
1652// init-declarator-list , attribute-specifier-list_opt init-declarator
1653func (p *parser) initDeclaratorList(d *Declarator, isTypedefName bool) (r *InitDeclaratorList) {
1654 r = &InitDeclaratorList{InitDeclarator: p.initDeclarator(d, isTypedefName)}
1655 for prev := r; ; prev = prev.InitDeclaratorList {
1656 switch p.rune() {
1657 case ',':
1658 t := p.shift()
1659 attr := p.attributeSpecifierListOpt()
1660 // if attr != nil {
1661 // trc("%v: ATTRS", attr.Position())
1662 // }
1663 prev.InitDeclaratorList = &InitDeclaratorList{Token: t, AttributeSpecifierList: attr, InitDeclarator: p.initDeclarator(nil, isTypedefName)}
1664 default:
1665 return r
1666 }
1667 }
1668}
1669
1670func (p *parser) attributeSpecifierListOpt() (r *AttributeSpecifierList) {
1671 if p.rune() == ATTRIBUTE {
1672 r = p.attributeSpecifierList()
1673 }
1674 return r
1675}
1676
1677// init-declarator:
1678// declarator attribute-specifier-list_opt
1679// declarator attribute-specifier-list_opt = initializer
1680func (p *parser) initDeclarator(d *Declarator, isTypedefName bool) *InitDeclarator {
1681 if d == nil {
1682 d = p.declarator(true, isTypedefName, nil)
1683 }
1684 attr := p.attributeSpecifierListOpt()
1685 // if attr != nil {
1686 // trc("%v: ATTRS", attr.Position())
1687 // }
1688 switch p.rune() {
1689 case '=':
1690 t := p.shift()
1691 return &InitDeclarator{Case: InitDeclaratorInit, Declarator: d, AttributeSpecifierList: attr, Token: t, Initializer: p.initializer(nil)}
1692 }
1693
1694 return &InitDeclarator{Case: InitDeclaratorDecl, Declarator: d, AttributeSpecifierList: attr}
1695}
1696
1697// [0], 6.7.1 Storage-class specifiers
1698//
1699// storage-class-specifier:
1700// typedef
1701// extern
1702// static
1703// auto
1704// register
1705func (p *parser) storageClassSpecifier() *StorageClassSpecifier {
1706 var kind StorageClassSpecifierCase
1707 switch p.rune() {
1708 case TYPEDEF:
1709 kind = StorageClassSpecifierTypedef
1710 case EXTERN:
1711 kind = StorageClassSpecifierExtern
1712 case STATIC:
1713 kind = StorageClassSpecifierStatic
1714 case AUTO:
1715 kind = StorageClassSpecifierAuto
1716 case REGISTER:
1717 kind = StorageClassSpecifierRegister
1718 case THREADLOCAL:
1719 kind = StorageClassSpecifierThreadLocal
1720 default:
1721 p.err("expected storage-class-specifier")
1722 return nil
1723 }
1724
1725 return &StorageClassSpecifier{Case: kind, Token: p.shift()}
1726}
1727
1728// [0], 6.7.2 Type specifiers
1729//
1730// type-specifier:
1731// void
1732// char
1733// short
1734// int
1735// long
1736// float
1737// __fp16
1738// __float80
1739// double
1740// signed
1741// unsigned
1742// _Bool
1743// _Complex
1744// _Float128
1745// struct-or-union-specifier
1746// enum-specifier
1747// typedef-name
1748// typeof ( expression )
1749// typeof ( type-name )
1750// atomic-type-specifier
1751// _Frac
1752// _Sat
1753// _Accum
1754// _Float32
1755func (p *parser) typeSpecifier() *TypeSpecifier {
1756 var kind TypeSpecifierCase
1757 switch p.rune() {
1758 case VOID:
1759 kind = TypeSpecifierVoid
1760 case CHAR:
1761 kind = TypeSpecifierChar
1762 case SHORT:
1763 kind = TypeSpecifierShort
1764 case INT:
1765 kind = TypeSpecifierInt
1766 case INT8:
1767 kind = TypeSpecifierInt8
1768 case INT16:
1769 kind = TypeSpecifierInt16
1770 case INT32:
1771 kind = TypeSpecifierInt32
1772 case INT64:
1773 kind = TypeSpecifierInt64
1774 case INT128:
1775 kind = TypeSpecifierInt128
1776 case LONG:
1777 kind = TypeSpecifierLong
1778 case FLOAT:
1779 kind = TypeSpecifierFloat
1780 case FLOAT16:
1781 kind = TypeSpecifierFloat16
1782 case FLOAT80:
1783 kind = TypeSpecifierFloat80
1784 case FLOAT32:
1785 kind = TypeSpecifierFloat32
1786 case FLOAT32X:
1787 kind = TypeSpecifierFloat32x
1788 case FLOAT64:
1789 kind = TypeSpecifierFloat64
1790 case FLOAT64X:
1791 kind = TypeSpecifierFloat64x
1792 case FLOAT128:
1793 kind = TypeSpecifierFloat128
1794 case DECIMAL32:
1795 kind = TypeSpecifierDecimal32
1796 case DECIMAL64:
1797 kind = TypeSpecifierDecimal64
1798 case DECIMAL128:
1799 kind = TypeSpecifierDecimal128
1800 case DOUBLE:
1801 kind = TypeSpecifierDouble
1802 case SIGNED:
1803 kind = TypeSpecifierSigned
1804 case UNSIGNED:
1805 kind = TypeSpecifierUnsigned
1806 case BOOL:
1807 kind = TypeSpecifierBool
1808 case COMPLEX:
1809 kind = TypeSpecifierComplex
1810 case FRACT:
1811 kind = TypeSpecifierFract
1812 case SAT:
1813 kind = TypeSpecifierSat
1814 case ACCUM:
1815 kind = TypeSpecifierAccum
1816 case TYPEDEFNAME:
1817 kind = TypeSpecifierTypedefName
1818 case STRUCT, UNION:
1819 r := &TypeSpecifier{Case: TypeSpecifierStructOrUnion, StructOrUnionSpecifier: p.structOrUnionSpecifier()}
1820 p.typedefNameEnabled = false
1821 return r
1822 case ENUM:
1823 r := &TypeSpecifier{Case: TypeSpecifierEnum, EnumSpecifier: p.enumSpecifier()}
1824 p.typedefNameEnabled = false
1825 return r
1826 case TYPEOF:
1827 var t, t2, t3 Token
1828 t = p.shift()
1829 switch p.rune() {
1830 case '(':
1831 t2 = p.shift()
1832 default:
1833 p.err("expected (")
1834 }
1835 switch p.rune() {
1836 case VOID, CHAR, SHORT, INT, INT8, INT16, INT32, INT64, INT128, LONG, FLOAT, FLOAT16, FLOAT80, FLOAT32, FLOAT32X, FLOAT64, FLOAT64X, FLOAT128, DECIMAL32, DECIMAL64, DECIMAL128, FRACT, SAT, ACCUM, DOUBLE, SIGNED, UNSIGNED, BOOL, COMPLEX, STRUCT, UNION, ENUM, TYPEDEFNAME, TYPEOF, ATOMIC,
1837 ATTRIBUTE, CONST, RESTRICT, VOLATILE,
1838 ALIGNAS:
1839 typ := p.typeName()
1840 switch p.rune() {
1841 case ')':
1842 t3 = p.shift()
1843 default:
1844 p.err("expected )")
1845 }
1846 return &TypeSpecifier{Case: TypeSpecifierTypeofType, Token: t, Token2: t2, TypeName: typ, Token3: t3}
1847 default:
1848 e := p.expression()
1849 switch p.rune() {
1850 case ')':
1851 t3 = p.shift()
1852 default:
1853 p.err("expected )")
1854 }
1855 return &TypeSpecifier{Case: TypeSpecifierTypeofExpr, Token: t, Token2: t2, Expression: e, Token3: t3}
1856 }
1857 case ATOMIC:
1858 return &TypeSpecifier{Case: TypeSpecifierAtomic, AtomicTypeSpecifier: p.atomicTypeSpecifier()}
1859 default:
1860 p.err("expected type-specifier")
1861 return nil
1862 }
1863
1864 p.typedefNameEnabled = false
1865 return &TypeSpecifier{Case: kind, Token: p.shift(), resolvedIn: p.resolvedIn}
1866}
1867
1868// [0], 6.7.2.1 Structure and union specifiers
1869//
1870// struct-or-union-specifier:
1871// struct-or-union attribute-specifier-list_opt identifier_opt { struct-declaration-list }
1872// struct-or-union attribute-specifier-list_opt identifier
1873func (p *parser) structOrUnionSpecifier() *StructOrUnionSpecifier {
1874 switch p.rune() {
1875 case STRUCT, UNION:
1876 default:
1877 p.err("expected struct-or-union-specifier")
1878 return nil
1879 }
1880
1881 sou := p.structOrUnion()
1882 attr := p.attributeSpecifierListOpt()
1883 // if attr != nil {
1884 // trc("%v: ATTRS", attr.Position())
1885 // }
1886 var t, t2, t3 Token
1887 switch p.rune() {
1888 case IDENTIFIER:
1889 t = p.shift()
1890 if p.rune() != '{' {
1891 return &StructOrUnionSpecifier{Case: StructOrUnionSpecifierTag, StructOrUnion: sou, AttributeSpecifierList: attr, Token: t, lexicalScope: p.declScope}
1892 }
1893
1894 fallthrough
1895 case '{':
1896 maxAlign := p.ctx.maxAlign
1897 p.openScope(true)
1898 p.typedefNameEnabled = true
1899 p.resolveScope = p.declScope.Parent()
1900 t2 = p.shift()
1901 var list *StructDeclarationList
1902 switch p.peek(false) {
1903 case '}':
1904 if p.ctx.cfg.RejectEmptyStructs {
1905 p.err("expected struct-declarator-list")
1906 }
1907 default:
1908 list = p.structDeclarationList()
1909 }
1910 p.closeScope()
1911 switch p.rune() {
1912 case '}':
1913 t3 = p.shift()
1914 default:
1915 p.err("expected }")
1916 }
1917 r := &StructOrUnionSpecifier{Case: StructOrUnionSpecifierDef, StructOrUnion: sou, AttributeSpecifierList: attr, Token: t, Token2: t2, StructDeclarationList: list, Token3: t3, lexicalScope: p.declScope, maxAlign: maxAlign}
1918 if t.Value != 0 {
1919 p.declScope.declare(t.Value, r)
1920 }
1921 return r
1922 default:
1923 p.err("expected identifier or {")
1924 return nil
1925 }
1926}
1927
1928// struct-or-union:
1929// struct
1930// union
1931func (p *parser) structOrUnion() *StructOrUnion {
1932 var kind StructOrUnionCase
1933 switch p.rune() {
1934 case STRUCT:
1935 kind = StructOrUnionStruct
1936 case UNION:
1937 kind = StructOrUnionUnion
1938 default:
1939 p.err("expected struct-or-union")
1940 return nil
1941 }
1942
1943 p.typedefNameEnabled = false
1944 return &StructOrUnion{Case: kind, Token: p.shift()}
1945}
1946
1947// struct-declaration-list:
1948// struct-declaration
1949// struct-declaration-list struct-declaration
1950func (p *parser) structDeclarationList() (r *StructDeclarationList) {
1951 r = &StructDeclarationList{StructDeclaration: p.structDeclaration()}
1952 for prev := r; ; prev = prev.StructDeclarationList {
1953 switch p.rune() {
1954 case VOID, CHAR, SHORT, INT, INT8, INT16, INT32, INT64, INT128, LONG, FLOAT, FLOAT16, FLOAT80, FLOAT32, FLOAT32X, FLOAT64, FLOAT64X, FLOAT128, DECIMAL32, DECIMAL64, DECIMAL128, FRACT, SAT, ACCUM, DOUBLE, SIGNED, UNSIGNED, BOOL, COMPLEX, STRUCT, UNION, ENUM, TYPEDEFNAME, TYPEOF, ATOMIC,
1955 ATTRIBUTE, CONST, RESTRICT, VOLATILE,
1956 ALIGNAS:
1957 prev.StructDeclarationList = &StructDeclarationList{StructDeclaration: p.structDeclaration()}
1958 case ';':
1959 p.shift()
1960 if p.ctx.cfg.RejectEmptyFields {
1961 p.err("expected struct-declaration")
1962 }
1963 default:
1964 return r
1965 }
1966 }
1967}
1968
1969// struct-declaration:
1970// specifier-qualifier-list struct-declarator-list ;
1971func (p *parser) structDeclaration() (r *StructDeclaration) {
1972 if p.rune() == ';' {
1973 if p.ctx.cfg.RejectEmptyStructDeclaration {
1974 p.err("expected struct-declaration")
1975 }
1976 return &StructDeclaration{Empty: true, Token: p.shift()}
1977 }
1978 sql := p.specifierQualifierList()
1979 r = &StructDeclaration{SpecifierQualifierList: sql}
1980 switch p.rune() {
1981 case ';':
1982 if p.ctx.cfg.RejectAnonymousFields {
1983 p.err("expected struct-declarator")
1984 }
1985 default:
1986 r.StructDeclaratorList = p.structDeclaratorList(r)
1987 }
1988 var t Token
1989 p.typedefNameEnabled = true
1990 switch p.rune() {
1991 case '}':
1992 if p.ctx.cfg.RejectMissingFinalStructFieldSemicolon {
1993 p.err0(false, "expected ;")
1994 }
1995 case ';':
1996 t = p.shift()
1997 default:
1998 p.err("expected ;")
1999 }
2000 r.Token = t
2001 return r
2002}
2003
2004// specifier-qualifier-list:
2005// type-specifier specifier-qualifier-list_opt
2006// type-qualifier specifier-qualifier-list_opt
2007// alignment-specifier-qualifier-list_opt
2008func (p *parser) specifierQualifierList() (r *SpecifierQualifierList) {
2009 switch p.rune() {
2010 case VOID, CHAR, SHORT, INT, INT8, INT16, INT32, INT64, INT128, LONG, FLOAT, FLOAT16, FLOAT80, FLOAT32, FLOAT32X, FLOAT64, FLOAT64X, FLOAT128, DECIMAL32, DECIMAL64, DECIMAL128, FRACT, SAT, ACCUM, DOUBLE, SIGNED, UNSIGNED, BOOL, COMPLEX, STRUCT, UNION, ENUM, TYPEDEFNAME, TYPEOF:
2011 r = &SpecifierQualifierList{Case: SpecifierQualifierListTypeSpec, TypeSpecifier: p.typeSpecifier()}
2012 case CONST, RESTRICT, VOLATILE:
2013 r = &SpecifierQualifierList{Case: SpecifierQualifierListTypeQual, TypeQualifier: p.typeQualifier()}
2014 case ALIGNAS:
2015 r = &SpecifierQualifierList{Case: SpecifierQualifierListAlignSpec, AlignmentSpecifier: p.alignmentSpecifier()}
2016 case ATOMIC:
2017 switch p.peek(false) {
2018 case '(':
2019 r = &SpecifierQualifierList{Case: SpecifierQualifierListTypeSpec, TypeSpecifier: p.typeSpecifier()}
2020 default:
2021 r = &SpecifierQualifierList{Case: SpecifierQualifierListTypeQual, TypeQualifier: p.typeQualifier()}
2022 }
2023 case ATTRIBUTE:
2024 r = &SpecifierQualifierList{Case: SpecifierQualifierListAttribute, AttributeSpecifier: p.attributeSpecifier()}
2025 default:
2026 p.err("expected specifier-qualifier-list: %s", tokName(p.rune()))
2027 return nil
2028 }
2029 for prev := r; ; prev = prev.SpecifierQualifierList {
2030 switch p.rune() {
2031 case VOID, CHAR, SHORT, INT, INT8, INT16, INT32, INT64, INT128, LONG, FLOAT, FLOAT16, FLOAT80, FLOAT32, FLOAT32X, FLOAT64, FLOAT64X, FLOAT128, DECIMAL32, DECIMAL64, DECIMAL128, FRACT, SAT, ACCUM, DOUBLE, SIGNED, UNSIGNED, BOOL, COMPLEX, STRUCT, UNION, ENUM, TYPEDEFNAME, TYPEOF:
2032 prev.SpecifierQualifierList = &SpecifierQualifierList{Case: SpecifierQualifierListTypeSpec, TypeSpecifier: p.typeSpecifier()}
2033 case CONST, RESTRICT, VOLATILE:
2034 prev.SpecifierQualifierList = &SpecifierQualifierList{Case: SpecifierQualifierListTypeQual, TypeQualifier: p.typeQualifier()}
2035 case ALIGNAS:
2036 prev.SpecifierQualifierList = &SpecifierQualifierList{Case: SpecifierQualifierListAlignSpec, AlignmentSpecifier: p.alignmentSpecifier()}
2037 case ATOMIC:
2038 switch p.peek(false) {
2039 case '(':
2040 prev.SpecifierQualifierList = &SpecifierQualifierList{Case: SpecifierQualifierListTypeSpec, TypeSpecifier: p.typeSpecifier()}
2041 default:
2042 prev.SpecifierQualifierList = &SpecifierQualifierList{Case: SpecifierQualifierListTypeQual, TypeQualifier: p.typeQualifier()}
2043 }
2044 case ATTRIBUTE:
2045 prev.SpecifierQualifierList = &SpecifierQualifierList{Case: SpecifierQualifierListAttribute, AttributeSpecifier: p.attributeSpecifier()}
2046 default:
2047 return r
2048 }
2049 }
2050}
2051
2052// struct-declarator-list:
2053// struct-declarator
2054// struct-declarator-list , struct-declarator
2055func (p *parser) structDeclaratorList(decl *StructDeclaration) (r *StructDeclaratorList) {
2056 r = &StructDeclaratorList{StructDeclarator: p.structDeclarator(decl)}
2057 for prev := r; ; prev = prev.StructDeclaratorList {
2058 switch p.rune() {
2059 case ',':
2060 t := p.shift()
2061 prev.StructDeclaratorList = &StructDeclaratorList{Token: t, StructDeclarator: p.structDeclarator(decl)}
2062 default:
2063 return r
2064 }
2065 }
2066}
2067
2068// struct-declarator:
2069// declarator
2070// declarator_opt : constant-expression attribute-specifier-list_opt
2071func (p *parser) structDeclarator(decl *StructDeclaration) (r *StructDeclarator) {
2072 var d *Declarator
2073 if p.rune() != ':' {
2074 d = p.declarator(false, false, nil)
2075 }
2076
2077 switch p.rune() {
2078 case ':':
2079 t := p.shift()
2080 r = &StructDeclarator{Case: StructDeclaratorBitField, Declarator: d, Token: t, ConstantExpression: p.constantExpression(), decl: decl}
2081 r.AttributeSpecifierList = p.attributeSpecifierListOpt()
2082 // if r.AttributeSpecifierList != nil {
2083 // trc("%v: ATTRS", r.AttributeSpecifierList.Position())
2084 // }
2085 default:
2086 r = &StructDeclarator{Case: StructDeclaratorDecl, Declarator: d, decl: decl}
2087 }
2088 if d != nil {
2089 p.declScope.declare(d.Name(), r)
2090 }
2091 return r
2092}
2093
2094// [0], 6.7.2.2 Enumeration specifiers
2095//
2096// enum-specifier:
2097// enum attribute-specifier-list_opt identifier_opt { enumerator-list }
2098// enum attribute-specifier-list_opt identifier_opt { enumerator-list , }
2099// enum attribute-specifier-list_opt identifier
2100func (p *parser) enumSpecifier() *EnumSpecifier {
2101 if p.rune() != ENUM {
2102 p.err("expected enum")
2103 return nil
2104 }
2105
2106 var t, t2, t3, t4, t5 Token
2107 p.typedefNameEnabled = false
2108 t = p.shift()
2109 attr := p.attributeSpecifierListOpt()
2110 // if attr != nil {
2111 // trc("%v: ATTRS", attr.Position())
2112 // }
2113 if p.rune() == IDENTIFIER {
2114 t2 = p.shift()
2115 if p.rune() != '{' {
2116 return &EnumSpecifier{Case: EnumSpecifierTag, AttributeSpecifierList: attr, Token: t, Token2: t2, lexicalScope: p.declScope}
2117 }
2118 }
2119
2120 if p.rune() != '{' {
2121 p.err("expected identifier or {")
2122 return nil
2123 }
2124
2125 p.typedefNameEnabled = false
2126 t3 = p.shift()
2127 list := p.enumeratorList()
2128 if p.rune() == ',' {
2129 t4 = p.shift()
2130 }
2131
2132 switch p.rune() {
2133 case '}':
2134 t5 = p.shift()
2135 default:
2136 p.err("expected }")
2137 }
2138 r := &EnumSpecifier{Case: EnumSpecifierDef, AttributeSpecifierList: attr, Token: t, Token2: t2, Token3: t3, EnumeratorList: list, Token4: t4, Token5: t5, lexicalScope: p.declScope}
2139 if t2.Value != 0 {
2140 p.declScope.declare(t2.Value, r)
2141 }
2142 return r
2143}
2144
2145// enumerator-list:
2146// enumerator
2147// enumerator-list , enumerator
2148func (p *parser) enumeratorList() *EnumeratorList {
2149 r := &EnumeratorList{Enumerator: p.enumerator()}
2150 for prev := r; ; prev = prev.EnumeratorList {
2151 switch p.rune() {
2152 case ',':
2153 if p.peek(false) == '}' {
2154 return r
2155 }
2156
2157 t := p.shift()
2158 prev.EnumeratorList = &EnumeratorList{Token: t, Enumerator: p.enumerator()}
2159 default:
2160 return r
2161 }
2162 }
2163}
2164
2165// enumerator:
2166// enumeration-constant attribute-specifier-list_opt
2167// enumeration-constant attribute-specifier-list_opt = constant-expression
2168func (p *parser) enumerator() (r *Enumerator) {
2169 if p.rune() != IDENTIFIER {
2170 p.err("expected enumeration-constant")
2171 return nil
2172 }
2173
2174 t := p.shift()
2175 attr := p.attributeSpecifierListOpt()
2176 // if attr != nil {
2177 // trc("%v: ATTRS", attr.Position())
2178 // }
2179 if p.rune() != '=' {
2180 r = &Enumerator{Case: EnumeratorIdent, Token: t, AttributeSpecifierList: attr, lexicalScope: p.declScope}
2181 p.declScope.declare(t.Value, r)
2182 return r
2183 }
2184
2185 t2 := p.shift()
2186 r = &Enumerator{Case: EnumeratorExpr, Token: t, AttributeSpecifierList: attr, Token2: t2, ConstantExpression: p.constantExpression(), lexicalScope: p.declScope}
2187 p.declScope.declare(t.Value, r)
2188 return r
2189}
2190
2191// [2], 6.7.2.4 Atomic type specifiers
2192//
2193// atomic-type-specifier:
2194// _Atomic ( type-name )
2195func (p *parser) atomicTypeSpecifier() *AtomicTypeSpecifier {
2196 if p.rune() != ATOMIC {
2197 p.err("expected _Atomic")
2198 return nil
2199 }
2200
2201 t := p.shift()
2202 var t2, t3 Token
2203 switch p.rune() {
2204 case '(':
2205 t2 = p.shift()
2206 default:
2207 p.err("expected (")
2208 }
2209 typ := p.typeName()
2210 switch p.rune() {
2211 case ')':
2212 t3 = p.shift()
2213 default:
2214 p.err("expected )")
2215 }
2216 return &AtomicTypeSpecifier{Token: t, Token2: t2, TypeName: typ, Token3: t3}
2217}
2218
2219// [0], 6.7.3 Type qualifiers
2220//
2221// type-qualifier:
2222// const
2223// restrict
2224// volatile
2225// _Atomic
2226func (p *parser) typeQualifier() *TypeQualifier {
2227 switch p.rune() {
2228 case CONST:
2229 return &TypeQualifier{Case: TypeQualifierConst, Token: p.shift()}
2230 case RESTRICT:
2231 return &TypeQualifier{Case: TypeQualifierRestrict, Token: p.shift()}
2232 case VOLATILE:
2233 return &TypeQualifier{Case: TypeQualifierVolatile, Token: p.shift()}
2234 case ATOMIC:
2235 return &TypeQualifier{Case: TypeQualifierAtomic, Token: p.shift()}
2236 default:
2237 p.err("expected type-qualifier")
2238 return nil
2239 }
2240}
2241
2242// [0], 6.7.4 Function specifiers
2243//
2244// function-specifier:
2245// inline
2246// _Noreturn
2247func (p *parser) functionSpecifier(inline *bool) *FunctionSpecifier {
2248 switch p.rune() {
2249 case INLINE:
2250 if inline != nil {
2251 *inline = true
2252 }
2253 return &FunctionSpecifier{Case: FunctionSpecifierInline, Token: p.shift()}
2254 case NORETURN:
2255 return &FunctionSpecifier{Case: FunctionSpecifierNoreturn, Token: p.shift()}
2256 default:
2257 p.err("expected function-specifier")
2258 return nil
2259 }
2260}
2261
2262// [0], 6.7.5 Declarators
2263//
2264// declarator:
2265// pointer_opt direct-declarator attribute-specifier-list_opt
2266func (p *parser) declarator(declare, isTypedefName bool, ptr *Pointer) *Declarator {
2267 if ptr == nil && (p.rune() == '*' || p.rune() == '^') {
2268 ptr = p.pointer()
2269 }
2270 r := &Declarator{IsTypedefName: isTypedefName, Pointer: ptr, DirectDeclarator: p.directDeclarator(nil)}
2271 r.AttributeSpecifierList = p.attributeSpecifierListOpt()
2272 // if r.AttributeSpecifierList != nil {
2273 // trc("%v: ATTRS", r.AttributeSpecifierList.Position())
2274 // }
2275 if declare {
2276 p.declScope.declare(r.Name(), r)
2277 }
2278 return r
2279}
2280
2281// [2], 6.7.5 Alignment specifier
2282//
2283// alignment-specifier:
2284// _Alignas ( type-name )
2285// _Alignas ( constant-expression )
2286func (p *parser) alignmentSpecifier() *AlignmentSpecifier {
2287 if p.rune() != ALIGNAS {
2288 p.err("expected _Alignas")
2289 return nil
2290 }
2291
2292 t := p.shift()
2293 var t2, t3 Token
2294 switch p.rune() {
2295 case '(':
2296 t2 = p.shift()
2297 default:
2298 p.err("expected (")
2299 }
2300 switch p.rune() {
2301 case VOID, CHAR, SHORT, INT, INT8, INT16, INT32, INT64, INT128, LONG, FLOAT, FLOAT16, FLOAT80, FLOAT32, FLOAT32X, FLOAT64, FLOAT64X, FLOAT128, DECIMAL32, DECIMAL64, DECIMAL128, FRACT, SAT, ACCUM, DOUBLE, SIGNED, UNSIGNED, BOOL, COMPLEX, STRUCT, UNION, ENUM, TYPEDEFNAME, TYPEOF, ATOMIC,
2302 ATTRIBUTE, CONST, RESTRICT, VOLATILE,
2303 ALIGNAS:
2304 typ := p.typeName()
2305 switch p.rune() {
2306 case ')':
2307 t3 = p.shift()
2308 default:
2309 p.err("expected )")
2310 }
2311 return &AlignmentSpecifier{Case: AlignmentSpecifierAlignasType, Token: t, Token2: t2, TypeName: typ, Token3: t3}
2312 default:
2313 e := p.constantExpression()
2314 switch p.rune() {
2315 case ')':
2316 t3 = p.shift()
2317 default:
2318 p.err("expected )")
2319 }
2320 return &AlignmentSpecifier{Case: AlignmentSpecifierAlignasExpr, Token: t, Token2: t2, ConstantExpression: e, Token3: t3}
2321 }
2322}
2323
2324// direct-declarator:
2325// identifier asm_opt
2326// ( attribute-specifier-list_opt declarator )
2327// direct-declarator [ type-qualifier-list_opt assignment-expression_opt ]
2328// direct-declarator [ static type-qualifier-list_opt assignment-expression ]
2329// direct-declarator [ type-qualifier-list static assignment-expression ]
2330// direct-declarator [ type-qualifier-list_opt * ]
2331// direct-declarator ( parameter-type-list )
2332// direct-declarator ( identifier-list_opt )
2333func (p *parser) directDeclarator(d *DirectDeclarator) (r *DirectDeclarator) {
2334 switch {
2335 case d != nil:
2336 r = d
2337 default:
2338 switch p.rune() {
2339 case IDENTIFIER:
2340 t := p.shift()
2341 var a *Asm
2342 if p.rune() == ASM {
2343 a = p.asm()
2344 }
2345 r = &DirectDeclarator{Case: DirectDeclaratorIdent, Token: t, Asm: a, lexicalScope: p.declScope}
2346 case '(':
2347 t := p.shift()
2348 attr := p.attributeSpecifierListOpt()
2349 // if attr != nil {
2350 // trc("%v: ATTRS", attr.Position())
2351 // }
2352 d := p.declarator(false, false, nil)
2353 var t2 Token
2354 switch p.rune() {
2355 case ')':
2356 t2 = p.shift()
2357 default:
2358 p.err("expected )")
2359 }
2360 r = &DirectDeclarator{Case: DirectDeclaratorDecl, Token: t, AttributeSpecifierList: attr, Declarator: d, Token2: t2, lexicalScope: p.declScope}
2361 default:
2362 p.err("expected direct-declarator")
2363 return nil
2364 }
2365 }
2366
2367 var t, t2, t3 Token
2368 for {
2369 var e *AssignmentExpression
2370 switch p.rune() {
2371 case '[':
2372 t = p.shift()
2373 switch p.rune() {
2374 case ']':
2375 t2 = p.shift()
2376 r = &DirectDeclarator{Case: DirectDeclaratorArr, DirectDeclarator: r, Token: t, Token2: t2, lexicalScope: p.declScope}
2377 case ATTRIBUTE, CONST, RESTRICT, VOLATILE, ATOMIC: // type-qualifier
2378 list := p.typeQualifierList()
2379 switch p.rune() {
2380 case STATIC:
2381 t2 = p.shift()
2382 e = p.assignmentExpression()
2383 switch p.rune() {
2384 case ']':
2385 t3 = p.shift()
2386 default:
2387 p.err("expected ]")
2388 }
2389 r = &DirectDeclarator{Case: DirectDeclaratorArrStatic, DirectDeclarator: r, Token: t, TypeQualifiers: list, Token2: t2, AssignmentExpression: e, Token3: t3, lexicalScope: p.declScope}
2390 case ']':
2391 r = &DirectDeclarator{Case: DirectDeclaratorArr, DirectDeclarator: r, Token: t, TypeQualifiers: list, Token2: p.shift(), lexicalScope: p.declScope}
2392 case '*':
2393 switch p.peek(false) {
2394 case ']':
2395 t2 = p.shift()
2396 r = &DirectDeclarator{Case: DirectDeclaratorStar, DirectDeclarator: r, Token: t, TypeQualifiers: list, Token2: t2, Token3: p.shift(), lexicalScope: p.declScope}
2397 default:
2398 e = p.assignmentExpression()
2399 switch p.rune() {
2400 case ']':
2401 t2 = p.shift()
2402 default:
2403 p.err("expected ]")
2404 }
2405 r = &DirectDeclarator{Case: DirectDeclaratorArr, DirectDeclarator: r, Token: t, TypeQualifiers: list, AssignmentExpression: e, Token2: t2, lexicalScope: p.declScope}
2406 }
2407 default:
2408 e = p.assignmentExpression()
2409 switch p.rune() {
2410 case ']':
2411 t2 = p.shift()
2412 default:
2413 p.err("expected ]")
2414 }
2415 r = &DirectDeclarator{Case: DirectDeclaratorArr, DirectDeclarator: r, Token: t, TypeQualifiers: list, AssignmentExpression: e, Token2: t2, lexicalScope: p.declScope}
2416 }
2417 case STATIC:
2418 t2 := p.shift()
2419 var list *TypeQualifiers
2420 switch p.peek(false) {
2421 case ATTRIBUTE, CONST, RESTRICT, VOLATILE, ATOMIC:
2422 list = p.typeQualifierList()
2423 }
2424 e := p.assignmentExpression()
2425 switch p.rune() {
2426 case ']':
2427 t3 = p.shift()
2428 default:
2429 p.err("expected ]")
2430 }
2431 r = &DirectDeclarator{Case: DirectDeclaratorStaticArr, DirectDeclarator: r, Token: t, Token2: t2, TypeQualifiers: list, AssignmentExpression: e, Token3: t3, lexicalScope: p.declScope}
2432 case '*':
2433 if p.peek(false) == ']' {
2434 t2 = p.shift()
2435 r = &DirectDeclarator{Case: DirectDeclaratorStar, DirectDeclarator: r, Token: t, Token2: t2, Token3: p.shift(), lexicalScope: p.declScope}
2436 break
2437 }
2438
2439 fallthrough
2440 default:
2441 e = p.assignmentExpression()
2442 switch p.rune() {
2443 case ']':
2444 t2 = p.shift()
2445 default:
2446 p.err("expected ]")
2447 }
2448 r = &DirectDeclarator{Case: DirectDeclaratorArr, DirectDeclarator: r, Token: t, AssignmentExpression: e, Token2: t2, lexicalScope: p.declScope}
2449 }
2450 case '(':
2451 p.openScope(false)
2452 p.typedefNameEnabled = true
2453 t = p.shift()
2454 paramScope := p.declScope
2455 switch p.rune() {
2456 case IDENTIFIER:
2457 list := p.identifierList()
2458 p.closeScope()
2459 p.typedefNameEnabled = true
2460 switch p.rune() {
2461 case ')':
2462 t2 = p.shift()
2463 default:
2464 p.err("expected )")
2465 }
2466 r = &DirectDeclarator{Case: DirectDeclaratorFuncIdent, DirectDeclarator: r, Token: t, IdentifierList: list, Token2: t2, paramScope: paramScope, lexicalScope: p.declScope}
2467 case ')':
2468 p.closeScope()
2469 p.typedefNameEnabled = true
2470 r = &DirectDeclarator{Case: DirectDeclaratorFuncIdent, DirectDeclarator: r, Token: t, Token2: p.shift(), paramScope: paramScope, lexicalScope: p.declScope}
2471 default:
2472 list := p.parameterTypeList()
2473 p.closeScope()
2474 p.typedefNameEnabled = true
2475 switch p.rune() {
2476 case ')':
2477 t2 = p.shift()
2478 default:
2479 p.err("expected )")
2480 }
2481 r = &DirectDeclarator{Case: DirectDeclaratorFuncParam, DirectDeclarator: r, Token: t, ParameterTypeList: list, Token2: t2, paramScope: paramScope, lexicalScope: p.declScope}
2482 }
2483 default:
2484 return r
2485 }
2486 }
2487}
2488
2489// pointer:
2490// * type-qualifier-list_opt
2491// * type-qualifier-list_opt pointer
2492// ^ type-qualifier-list_opt
2493func (p *parser) pointer() (r *Pointer) {
2494 if p.rune() == '^' {
2495 t := p.shift()
2496 var list *TypeQualifiers
2497 switch p.rune() {
2498 case ATTRIBUTE, CONST, RESTRICT, VOLATILE, ATOMIC:
2499 list = p.typeQualifierList()
2500 }
2501
2502 return &Pointer{Case: PointerBlock, Token: t, TypeQualifiers: list}
2503 }
2504
2505 if p.rune() != '*' {
2506 p.err("expected * or ^")
2507 return nil
2508 }
2509
2510 t := p.shift()
2511 var list *TypeQualifiers
2512 switch p.rune() {
2513 case ATTRIBUTE, CONST, RESTRICT, VOLATILE, ATOMIC:
2514 list = p.typeQualifierList()
2515 }
2516
2517 switch p.rune() {
2518 case '*':
2519 return &Pointer{Case: PointerPtr, Token: t, TypeQualifiers: list, Pointer: p.pointer()}
2520 default:
2521 return &Pointer{Case: PointerTypeQual, Token: t, TypeQualifiers: list}
2522 }
2523}
2524
2525// type-qualifier-list:
2526// type-qualifier
2527// attribute-specifier
2528// type-qualifier-list type-qualifier
2529// type-qualifier-list attribute-specifier
2530func (p *parser) typeQualifierList() (r *TypeQualifiers) {
2531 switch p.rune() {
2532 case ATTRIBUTE:
2533 r = &TypeQualifiers{Case: TypeQualifiersAttribute, AttributeSpecifier: p.attributeSpecifier()}
2534 default:
2535 r = &TypeQualifiers{Case: TypeQualifiersTypeQual, TypeQualifier: p.typeQualifier()}
2536 }
2537 for prev := r; ; prev = prev.TypeQualifiers {
2538 switch p.rune() {
2539 case ATTRIBUTE:
2540 prev.TypeQualifiers = &TypeQualifiers{Case: TypeQualifiersAttribute, AttributeSpecifier: p.attributeSpecifier()}
2541 case CONST, RESTRICT, VOLATILE, ATOMIC:
2542 prev.TypeQualifiers = &TypeQualifiers{TypeQualifier: p.typeQualifier()}
2543 default:
2544 return r
2545 }
2546 }
2547}
2548
2549// parameter-type-list:
2550// parameter-list
2551// parameter-list , ...
2552func (p *parser) parameterTypeList() *ParameterTypeList {
2553 list := p.parameterList()
2554 switch p.rune() {
2555 case ',':
2556 t := p.shift()
2557 var t2 Token
2558 switch p.rune() {
2559 case DDD:
2560 t2 = p.shift()
2561 default:
2562 p.err("expected ...")
2563 }
2564 return &ParameterTypeList{Case: ParameterTypeListVar, ParameterList: list, Token: t, Token2: t2}
2565 default:
2566 return &ParameterTypeList{Case: ParameterTypeListList, ParameterList: list}
2567 }
2568}
2569
2570// parameter-list:
2571// parameter-declaration
2572// parameter-list , parameter-declaration
2573func (p *parser) parameterList() (r *ParameterList) {
2574 r = &ParameterList{ParameterDeclaration: p.parameterDeclaration()}
2575 for prev := r; ; prev = prev.ParameterList {
2576 switch p.rune() {
2577 case ';':
2578 if p.ctx.cfg.RejectParamSemicolon {
2579 p.err0(false, "expected ,")
2580 }
2581 fallthrough
2582 case ',':
2583 if p.peek(false) == DDD {
2584 return r
2585 }
2586
2587 p.typedefNameEnabled = true
2588 t := p.shift()
2589 prev.ParameterList = &ParameterList{Token: t, ParameterDeclaration: p.parameterDeclaration()}
2590 default:
2591 return r
2592 }
2593 }
2594}
2595
2596// parameter-declaration:
2597// declaration-specifiers declarator attribute-specifier-list_opt
2598// declaration-specifiers abstract-declarator_opt
2599func (p *parser) parameterDeclaration() *ParameterDeclaration {
2600 ds := p.declarationSpecifiers(nil, nil)
2601 switch p.rune() {
2602 case ',', ')':
2603 r := &ParameterDeclaration{Case: ParameterDeclarationAbstract, DeclarationSpecifiers: ds}
2604 return r
2605 default:
2606 switch x := p.declaratorOrAbstractDeclarator(ds.typedef()).(type) {
2607 case *AbstractDeclarator:
2608 return &ParameterDeclaration{Case: ParameterDeclarationAbstract, DeclarationSpecifiers: ds, AbstractDeclarator: x}
2609 case *Declarator:
2610 p.declScope.declare(x.Name(), x)
2611 attr := p.attributeSpecifierListOpt()
2612 // if attr != nil {
2613 // trc("%v: ATTRS", attr.Position())
2614 // }
2615 return &ParameterDeclaration{Case: ParameterDeclarationDecl, DeclarationSpecifiers: ds, Declarator: x, AttributeSpecifierList: attr}
2616 default:
2617 panic(internalError())
2618 }
2619 }
2620}
2621
2622func (p *parser) declaratorOrAbstractDeclarator(isTypedefName bool) (r Node) {
2623 var ptr *Pointer
2624 switch p.rune() {
2625 case '*', '^':
2626 ptr = p.pointer()
2627 }
2628 switch p.rune() {
2629 case IDENTIFIER:
2630 return p.declarator(false, isTypedefName, ptr)
2631 case '[':
2632 return p.abstractDeclarator(ptr)
2633 case '(':
2634 switch p.peek(true) {
2635 case ')':
2636 t := p.shift()
2637 t2 := p.shift()
2638 return &AbstractDeclarator{
2639 Case: AbstractDeclaratorDecl,
2640 Pointer: ptr,
2641 DirectAbstractDeclarator: p.directAbstractDeclarator(
2642 &DirectAbstractDeclarator{
2643 Case: DirectAbstractDeclaratorFunc,
2644 Token: t,
2645 Token2: t2,
2646 },
2647 ),
2648 }
2649 case TYPEDEF, EXTERN, STATIC, AUTO, REGISTER, THREADLOCAL,
2650 VOID, CHAR, SHORT, INT, INT8, INT16, INT32, INT64, INT128, LONG, FLOAT, FLOAT16, FLOAT80, FLOAT32, FLOAT32X, FLOAT64, FLOAT64X, FLOAT128, DECIMAL32, DECIMAL64, DECIMAL128, FRACT, SAT, ACCUM, DOUBLE, SIGNED, UNSIGNED, BOOL, COMPLEX, STRUCT, UNION, ENUM, TYPEDEFNAME, TYPEOF, ATOMIC,
2651 CONST, RESTRICT, VOLATILE,
2652 INLINE, NORETURN, ATTRIBUTE,
2653 ALIGNAS:
2654 p.openScope(false)
2655 paramScope := p.declScope
2656 p.typedefNameEnabled = true
2657 t := p.shift()
2658 list := p.parameterTypeList()
2659 p.closeScope()
2660 p.typedefNameEnabled = true
2661 var t2 Token
2662 switch p.rune() {
2663 case ')':
2664 t2 = p.shift()
2665 default:
2666 p.err("expected )")
2667 }
2668 return &AbstractDeclarator{
2669 Case: AbstractDeclaratorDecl,
2670 Pointer: ptr,
2671 DirectAbstractDeclarator: p.directAbstractDeclarator(
2672 &DirectAbstractDeclarator{
2673 Case: DirectAbstractDeclaratorFunc,
2674 Token: t,
2675 ParameterTypeList: list,
2676 Token2: t2,
2677 paramScope: paramScope,
2678 },
2679 ),
2680 }
2681 }
2682
2683 t := p.shift()
2684 switch x := p.declaratorOrAbstractDeclarator(isTypedefName).(type) {
2685 case *AbstractDeclarator:
2686 var t2 Token
2687 switch p.rune() {
2688 case ')':
2689 t2 = p.shift()
2690 default:
2691 p.err("expected )")
2692 }
2693 return &AbstractDeclarator{
2694 Case: AbstractDeclaratorDecl,
2695 Pointer: ptr,
2696 DirectAbstractDeclarator: p.directAbstractDeclarator(
2697 &DirectAbstractDeclarator{
2698 Case: DirectAbstractDeclaratorDecl,
2699 Token: t,
2700 AbstractDeclarator: x,
2701 Token2: t2,
2702 },
2703 ),
2704 }
2705 case *Declarator:
2706 var t2 Token
2707 switch p.rune() {
2708 case ')':
2709 t2 = p.shift()
2710 default:
2711 p.err("expected )")
2712 }
2713 return &Declarator{
2714 Pointer: ptr,
2715 DirectDeclarator: p.directDeclarator(
2716 &DirectDeclarator{
2717 Case: DirectDeclaratorDecl,
2718 Token: t,
2719 Declarator: x,
2720 Token2: t2,
2721 },
2722 ),
2723 }
2724 default:
2725 panic(internalError())
2726 }
2727 case ')', ',':
2728 return p.abstractDeclarator(ptr)
2729 default:
2730 p.err("unexpected %s", p.tok.Value)
2731 return p.abstractDeclarator(ptr)
2732 }
2733}
2734
2735// identifier-list:
2736// identifier
2737// identifier-list , identifier
2738func (p *parser) identifierList() (r *IdentifierList) {
2739 switch p.rune() {
2740 case IDENTIFIER:
2741 r = &IdentifierList{Token: p.shift(), lexicalScope: p.declScope}
2742 default:
2743 p.err("expected identifier")
2744 return nil
2745 }
2746
2747 for prev := r; p.rune() == ','; prev = prev.IdentifierList {
2748 t := p.shift()
2749 var t2 Token
2750 switch p.rune() {
2751 case IDENTIFIER:
2752 t2 = p.shift()
2753 default:
2754 p.err("expected identifier")
2755 }
2756 prev.IdentifierList = &IdentifierList{Token: t, Token2: t2, lexicalScope: p.declScope}
2757 }
2758 return r
2759}
2760
2761// [0], 6.7.6 Type names
2762//
2763// type-name:
2764// specifier-qualifier-list abstract-declarator_opt
2765func (p *parser) typeName() *TypeName {
2766 p.typedefNameEnabled = true
2767 list := p.specifierQualifierList()
2768 switch p.rune() {
2769 case ')', ',':
2770 return &TypeName{SpecifierQualifierList: list}
2771 case '*', '(', '[':
2772 return &TypeName{SpecifierQualifierList: list, AbstractDeclarator: p.abstractDeclarator(nil)}
2773 default:
2774 p.err("expected ) or * or ( or [ or ,")
2775 return &TypeName{SpecifierQualifierList: list}
2776 }
2777}
2778
2779// abstract-declarator:
2780// pointer
2781// pointer_opt direct-abstract-declarator
2782func (p *parser) abstractDeclarator(ptr *Pointer) *AbstractDeclarator {
2783 if ptr == nil && (p.rune() == '*' || p.rune() == '^') {
2784 ptr = p.pointer()
2785 }
2786 switch p.rune() {
2787 case '[', '(':
2788 return &AbstractDeclarator{Case: AbstractDeclaratorDecl, Pointer: ptr, DirectAbstractDeclarator: p.directAbstractDeclarator(nil)}
2789 default:
2790 return &AbstractDeclarator{Case: AbstractDeclaratorPtr, Pointer: ptr}
2791 }
2792}
2793
2794// direct-abstract-declarator:
2795// ( abstract-declarator )
2796// direct-abstract-declarator_opt [ type-qualifier-list_opt assignment-expression_opt ]
2797// direct-abstract-declarator_opt [ static type-qualifier-list_opt assignment-expression ]
2798// direct-abstract-declarator_opt [ type-qualifier-list static assignment-expression ]
2799// direct-abstract-declarator_opt [ * ]
2800// direct-abstract-declarator_opt ( parameter-type-list_opt )
2801func (p *parser) directAbstractDeclarator(d *DirectAbstractDeclarator) (r *DirectAbstractDeclarator) {
2802 var t, t2, t3 Token
2803 switch {
2804 case d != nil:
2805 r = d
2806 default:
2807 switch p.rune() {
2808 case '[':
2809 t = p.shift()
2810 switch p.rune() {
2811 case '*':
2812 t2 = p.shift()
2813 switch p.rune() {
2814 case ']':
2815 t3 = p.shift()
2816 default:
2817 p.err("expected ]")
2818 }
2819 r = &DirectAbstractDeclarator{Case: DirectAbstractDeclaratorArrStar, Token: t, Token2: t2, Token3: t3}
2820 case ATTRIBUTE, CONST, RESTRICT, VOLATILE, ATOMIC:
2821 list := p.typeQualifierList()
2822 switch p.rune() {
2823 case STATIC:
2824 t2 = p.shift()
2825 e := p.assignmentExpression()
2826 switch p.rune() {
2827 case ']':
2828 t3 = p.shift()
2829 default:
2830 p.err("expected ]")
2831 }
2832 r = &DirectAbstractDeclarator{Case: DirectAbstractDeclaratorArrStatic, Token: t, TypeQualifiers: list, Token2: t2, AssignmentExpression: e, Token3: t3}
2833 default:
2834 e := p.assignmentExpression()
2835 switch p.rune() {
2836 case ']':
2837 t2 = p.shift()
2838 default:
2839 p.err("expected ]")
2840 }
2841 r = &DirectAbstractDeclarator{Case: DirectAbstractDeclaratorArr, Token: t, TypeQualifiers: list, AssignmentExpression: e, Token2: t2}
2842 }
2843 case STATIC:
2844 t2 = p.shift()
2845 var list *TypeQualifiers
2846 switch p.rune() {
2847 case ATTRIBUTE, CONST, RESTRICT, VOLATILE, ATOMIC:
2848 list = p.typeQualifierList()
2849 }
2850 e := p.assignmentExpression()
2851 switch p.rune() {
2852 case ']':
2853 t3 = p.shift()
2854 default:
2855 p.err("expected ]")
2856 }
2857 r = &DirectAbstractDeclarator{Case: DirectAbstractDeclaratorStaticArr, Token: t, Token2: t2, TypeQualifiers: list, AssignmentExpression: e, Token3: t3}
2858 case ']':
2859 r = &DirectAbstractDeclarator{Case: DirectAbstractDeclaratorArr, Token: t, Token2: p.shift()}
2860 default:
2861 e := p.assignmentExpression()
2862 switch p.rune() {
2863 case ']':
2864 t2 = p.shift()
2865 default:
2866 p.err("expected ]")
2867 }
2868 r = &DirectAbstractDeclarator{Case: DirectAbstractDeclaratorArr, Token: t, AssignmentExpression: e, Token2: t2}
2869 }
2870 case '(':
2871 switch p.peek(true) {
2872 case ')':
2873 t := p.shift()
2874 r = &DirectAbstractDeclarator{Case: DirectAbstractDeclaratorFunc, Token: t, Token2: p.shift()}
2875 case VOID, CHAR, SHORT, INT, INT8, INT16, INT32, INT64, INT128, LONG, FLOAT, FLOAT16, FLOAT80, FLOAT32, FLOAT32X, FLOAT64, FLOAT64X, FLOAT128, DECIMAL32, DECIMAL64, DECIMAL128, FRACT, SAT, ACCUM, DOUBLE, SIGNED, UNSIGNED, BOOL, COMPLEX, STRUCT, UNION, ENUM, TYPEDEFNAME, TYPEOF, ATOMIC,
2876 ATTRIBUTE, CONST, RESTRICT, VOLATILE,
2877 ALIGNAS:
2878 p.openScope(false)
2879 paramScope := p.declScope
2880 p.typedefNameEnabled = true
2881 t = p.shift()
2882 list := p.parameterTypeList()
2883 p.closeScope()
2884 p.typedefNameEnabled = true
2885 switch p.rune() {
2886 case ')':
2887 t2 = p.shift()
2888 default:
2889 p.err("expected )")
2890 }
2891 r = &DirectAbstractDeclarator{Case: DirectAbstractDeclaratorFunc, Token: t, ParameterTypeList: list, Token2: t2, paramScope: paramScope}
2892 default:
2893 p.openScope(false)
2894 paramScope := p.declScope
2895 p.typedefNameEnabled = true
2896 t = p.shift()
2897 d := p.abstractDeclarator(nil)
2898 p.closeScope()
2899 p.typedefNameEnabled = true
2900 switch p.rune() {
2901 case ')':
2902 t2 = p.shift()
2903 default:
2904 p.err("expected )")
2905 }
2906 r = &DirectAbstractDeclarator{Case: DirectAbstractDeclaratorDecl, Token: t, AbstractDeclarator: d, Token2: t2, paramScope: paramScope}
2907 }
2908 default:
2909 panic(internalError())
2910 }
2911 }
2912
2913 for {
2914 switch p.rune() {
2915 case '(':
2916 if p.peek(false) == ')' {
2917 t = p.shift()
2918 r = &DirectAbstractDeclarator{Case: DirectAbstractDeclaratorFunc, DirectAbstractDeclarator: r, Token: t, Token2: p.shift()}
2919 break
2920 }
2921
2922 p.openScope(false)
2923 p.typedefNameEnabled = true
2924 t = p.shift()
2925 paramScope := p.declScope
2926 list := p.parameterTypeList()
2927 p.closeScope()
2928 p.typedefNameEnabled = true
2929 switch p.rune() {
2930 case ')':
2931 t2 = p.shift()
2932 default:
2933 p.err("expected )")
2934 }
2935 r = &DirectAbstractDeclarator{Case: DirectAbstractDeclaratorFunc, DirectAbstractDeclarator: r, Token: t, ParameterTypeList: list, Token2: t2, paramScope: paramScope}
2936 case '[':
2937 t = p.shift()
2938 switch p.rune() {
2939 case '*':
2940 t2 = p.shift()
2941 switch p.rune() {
2942 case ']':
2943 t3 = p.shift()
2944 default:
2945 p.err("expected ]")
2946 }
2947 r = &DirectAbstractDeclarator{Case: DirectAbstractDeclaratorArrStar, DirectAbstractDeclarator: r, Token: t, Token2: t2, Token3: t3}
2948 case ATTRIBUTE, CONST, RESTRICT, VOLATILE, ATOMIC:
2949 list := p.typeQualifierList()
2950 switch p.rune() {
2951 case STATIC:
2952 t2 = p.shift()
2953 e := p.assignmentExpression()
2954 switch p.rune() {
2955 case ']':
2956 t3 = p.shift()
2957 default:
2958 p.err("expected ]")
2959 }
2960 r = &DirectAbstractDeclarator{Case: DirectAbstractDeclaratorArrStatic, DirectAbstractDeclarator: r, Token: t, TypeQualifiers: list, Token2: t2, AssignmentExpression: e, Token3: t3}
2961 default:
2962 e := p.assignmentExpression()
2963 switch p.rune() {
2964 case ']':
2965 t2 = p.shift()
2966 default:
2967 p.err("expected ]")
2968 }
2969 r = &DirectAbstractDeclarator{Case: DirectAbstractDeclaratorArr, DirectAbstractDeclarator: r, Token: t, TypeQualifiers: list, AssignmentExpression: e, Token2: t2}
2970 }
2971 case STATIC:
2972 t2 = p.shift()
2973 var list *TypeQualifiers
2974 switch p.rune() {
2975 case ATTRIBUTE, CONST, RESTRICT, VOLATILE, ATOMIC:
2976 list = p.typeQualifierList()
2977 }
2978 e := p.assignmentExpression()
2979 switch p.rune() {
2980 case ']':
2981 t3 = p.shift()
2982 default:
2983 p.err("expected ]")
2984 }
2985 r = &DirectAbstractDeclarator{Case: DirectAbstractDeclaratorStaticArr, DirectAbstractDeclarator: r, Token: t, Token2: t2, TypeQualifiers: list, AssignmentExpression: e, Token3: t3}
2986 case ']':
2987 r = &DirectAbstractDeclarator{Case: DirectAbstractDeclaratorArr, DirectAbstractDeclarator: r, Token: t, Token2: p.shift()}
2988 default:
2989 e := p.assignmentExpression()
2990 switch p.rune() {
2991 case ']':
2992 t2 = p.shift()
2993 default:
2994 p.err("expected ]")
2995 }
2996 r = &DirectAbstractDeclarator{Case: DirectAbstractDeclaratorArr, DirectAbstractDeclarator: r, Token: t, AssignmentExpression: e, Token2: t2}
2997 }
2998 default:
2999 return r
3000 }
3001 }
3002}
3003
3004// [0], 6.7.8 Initialization
3005//
3006// initializer:
3007// assignment-expression
3008// { initializer-list }
3009// { initializer-list , }
3010func (p *parser) initializer(parent *Initializer) *Initializer {
3011 switch p.rune() {
3012 case '{':
3013 t := p.shift()
3014 if p.peek(false) == '}' {
3015 if p.ctx.cfg.RejectEmptyInitializerList {
3016 p.err("expected initializer-list")
3017 }
3018 return &Initializer{Case: InitializerInitList, Token: t, Token3: p.shift()}
3019 }
3020
3021 r := &Initializer{Case: InitializerInitList, Token: t, parent: parent}
3022 r.InitializerList = p.initializerList(r)
3023 if p.rune() == ',' {
3024 r.Token2 = p.shift()
3025 }
3026 switch p.rune() {
3027 case '}':
3028 r.Token3 = p.shift()
3029 default:
3030 p.err("expected }")
3031 }
3032 return r
3033 default:
3034 return &Initializer{Case: InitializerExpr, AssignmentExpression: p.assignmentExpression(), parent: parent}
3035 }
3036}
3037
3038// initializer-list:
3039// designation_opt initializer
3040// initializer-list , designation_opt initializer
3041func (p *parser) initializerList(parent *Initializer) (r *InitializerList) {
3042 var d *Designation
3043 switch p.rune() {
3044 case '[', '.':
3045 d = p.designation()
3046 case IDENTIFIER:
3047 if p.peek(false) == ':' {
3048 d = p.designation()
3049 }
3050 }
3051 r = &InitializerList{Designation: d, Initializer: p.initializer(parent)}
3052 for prev := r; ; prev = prev.InitializerList {
3053 switch p.rune() {
3054 case ',':
3055 t := p.tok
3056 prev.Initializer.trailingComma = &t
3057 if p.peek(false) == '}' {
3058 return r
3059 }
3060
3061 t = p.shift()
3062 d = nil
3063 switch p.rune() {
3064 case '[', '.':
3065 d = p.designation()
3066 case IDENTIFIER:
3067 if p.peek(false) == ':' {
3068 d = p.designation()
3069 }
3070 }
3071 prev.InitializerList = &InitializerList{Token: t, Designation: d, Initializer: p.initializer(parent)}
3072 default:
3073 return r
3074 }
3075 }
3076}
3077
3078// designation:
3079// designator-list =
3080func (p *parser) designation() *Designation {
3081 var t Token
3082 list, colon := p.designatorList()
3083 if !colon {
3084 switch p.rune() {
3085 case '=':
3086 t = p.shift()
3087 default:
3088 p.err("expected =")
3089 }
3090 }
3091 return &Designation{DesignatorList: list, Token: t}
3092}
3093
3094// designator-list:
3095// designator
3096// designator-list designator
3097func (p *parser) designatorList() (r *DesignatorList, colon bool) {
3098 d, isCol := p.designator(true)
3099 if isCol {
3100 return &DesignatorList{Designator: d}, true
3101 }
3102
3103 r = &DesignatorList{Designator: d}
3104 for prev := r; ; prev = prev.DesignatorList {
3105 switch p.rune() {
3106 case '[', '.':
3107 d, _ = p.designator(false)
3108 prev.DesignatorList = &DesignatorList{Designator: d}
3109 default:
3110 return r, false
3111 }
3112 }
3113}
3114
3115// designator:
3116// [ constant-expression ]
3117// . identifier
3118// identifier :
3119func (p *parser) designator(acceptCol bool) (*Designator, bool) {
3120 var t, t2 Token
3121 switch p.rune() {
3122 case '[':
3123 t = p.shift()
3124 e := p.constantExpression()
3125 switch p.rune() {
3126 case ']':
3127 t2 = p.shift()
3128 default:
3129 p.err("expected ]")
3130 }
3131 return &Designator{Case: DesignatorIndex, Token: t, ConstantExpression: e, Token2: t2, lexicalScope: p.declScope}, false
3132 case '.':
3133 t = p.shift()
3134 switch p.rune() {
3135 case IDENTIFIER:
3136 t2 = p.shift()
3137 default:
3138 p.err("expected identifier")
3139 }
3140 return &Designator{Case: DesignatorField, Token: t, Token2: t2, lexicalScope: p.declScope}, false
3141 case IDENTIFIER:
3142 if acceptCol && p.peek(false) == ':' {
3143 t = p.shift()
3144 return &Designator{Case: DesignatorField2, Token: t, Token2: p.shift(), lexicalScope: p.declScope}, true
3145 }
3146
3147 p.err("expected designator")
3148 return nil, false
3149 default:
3150 p.err("expected [ or .")
3151 return nil, false
3152 }
3153}
3154
3155// [0], 6.8 Statements and blocks
3156//
3157// statement:
3158// labeled-statement
3159// compound-statement
3160// expression-statement
3161// selection-statement
3162// iteration-statement
3163// jump-statement
3164// asm-statement
3165func (p *parser) statement() (r *Statement) {
3166 var r0 *Statement
3167 var prevLS, ls *LabeledStatement
3168
3169 defer func() {
3170 if ls != nil {
3171 ls.Statement = r
3172 r = r0
3173 }
3174 }()
3175
3176 for {
3177 switch p.rune() {
3178 case IDENTIFIER:
3179 switch {
3180 case p.peek(false) == ':':
3181 ls = p.labeledStatement()
3182 default:
3183 return &Statement{Case: StatementExpr, ExpressionStatement: p.expressionStatement()}
3184 }
3185 case '{':
3186 return &Statement{Case: StatementCompound, CompoundStatement: p.compoundStatement(nil, nil)}
3187 case IF, SWITCH:
3188 return &Statement{Case: StatementSelection, SelectionStatement: p.selectionStatement()}
3189 case WHILE, DO, FOR:
3190 return &Statement{Case: StatementIteration, IterationStatement: p.iterationStatement()}
3191 case GOTO, BREAK, CONTINUE, RETURN:
3192 return &Statement{Case: StatementJump, JumpStatement: p.jumpStatement()}
3193 case CASE, DEFAULT:
3194 ls = p.labeledStatement()
3195 case ASM:
3196 return &Statement{Case: StatementAsm, AsmStatement: p.asmStatement()}
3197 default:
3198 return &Statement{Case: StatementExpr, ExpressionStatement: p.expressionStatement()}
3199 }
3200
3201 switch {
3202 case r0 == nil:
3203 r0 = &Statement{Case: StatementLabeled, LabeledStatement: ls}
3204 default:
3205 prevLS.Statement = &Statement{Case: StatementLabeled, LabeledStatement: ls}
3206 }
3207 prevLS = ls
3208 }
3209}
3210
3211// [0], 6.8.1 Labeled statements
3212//
3213// labeled-statement:
3214// identifier : statement
3215// case constant-expression : statement
3216// case constant-expression ... constant-expression : statement
3217// default : statement
3218func (p *parser) labeledStatement() (r *LabeledStatement) {
3219 defer func() {
3220 if r != nil {
3221 p.block.labeledStmts = append(p.block.labeledStmts, r)
3222 }
3223 }()
3224
3225 var t, t2, t3 Token
3226 switch p.rune() {
3227 case IDENTIFIER:
3228 t = p.shift()
3229 switch p.rune() {
3230 case ':':
3231 t2 = p.shift()
3232 default:
3233 p.err("expected :")
3234 return nil
3235 }
3236
3237 attr := p.attributeSpecifierListOpt()
3238 // if attr != nil {
3239 // trc("%v: ATTRS", attr.Position())
3240 // }
3241 p.block.hasLabel()
3242 r = &LabeledStatement{
3243 Case: LabeledStatementLabel, Token: t, Token2: t2, AttributeSpecifierList: attr,
3244 lexicalScope: p.declScope, block: p.block,
3245 }
3246 p.declScope.declare(t.Value, r)
3247 return r
3248 case CASE:
3249 if p.switches == 0 {
3250 p.err("case label not within a switch statement")
3251 }
3252 t = p.shift()
3253 e := p.constantExpression()
3254 switch p.rune() {
3255 case DDD:
3256 if p.ctx.cfg.RejectCaseRange {
3257 p.err0(false, "expected :")
3258 }
3259 t2 = p.shift()
3260 e2 := p.constantExpression()
3261 switch p.rune() {
3262 case ':':
3263 t3 = p.shift()
3264 default:
3265 p.err("expected :")
3266 }
3267 return &LabeledStatement{
3268 Case: LabeledStatementRange, Token: t, ConstantExpression: e,
3269 Token2: t2, ConstantExpression2: e2, Token3: t3,
3270 lexicalScope: p.declScope, block: p.block,
3271 }
3272 case ':':
3273 t2 = p.shift()
3274 default:
3275 p.err("expected :")
3276 }
3277 return &LabeledStatement{
3278 Case: LabeledStatementCaseLabel, Token: t, ConstantExpression: e,
3279 Token2: t2, lexicalScope: p.declScope, block: p.block,
3280 }
3281 case DEFAULT:
3282 if p.switches == 0 {
3283 p.err("'deafult' label not within a switch statement")
3284 }
3285 t = p.shift()
3286 switch p.rune() {
3287 case ':':
3288 t2 = p.shift()
3289 default:
3290 p.err("expected :")
3291 }
3292 return &LabeledStatement{
3293 Case: LabeledStatementDefault, Token: t, Token2: t2,
3294 lexicalScope: p.declScope, block: p.block,
3295 }
3296 default:
3297 p.err("expected labeled-statement")
3298 return &LabeledStatement{}
3299 }
3300}
3301
3302// [0], 6.8.2 Compound statement
3303//
3304// compound-statement:
3305// { block-item-list_opt }
3306func (p *parser) compoundStatement(s Scope, inject []Token) (r *CompoundStatement) {
3307 if p.rune() != '{' {
3308 p.err("expected {")
3309 return nil
3310 }
3311
3312 r = &CompoundStatement{parent: p.block}
3313 if fn := p.currFn; fn != nil {
3314 fn.compoundStatements = append(fn.compoundStatements, r)
3315 }
3316 sv := p.block
3317 if sv != nil {
3318 sv.children = append(sv.children, r)
3319 }
3320 p.block = r
3321 switch {
3322 case s != nil:
3323 p.declScope = s
3324 p.resolveScope = s
3325 p.scopes++
3326 // var a []string
3327 // for s := p.declScope; s != nil; s = s.Parent() {
3328 // a = append(a, fmt.Sprintf("%p", s))
3329 // }
3330 // dbg("using func scope %p: %v", s, strings.Join(a, " "))
3331 default:
3332 p.openScope(false)
3333 }
3334 s = p.declScope
3335 p.typedefNameEnabled = true
3336 t := p.shift()
3337 if len(inject) != 0 {
3338 p.unget(inject...)
3339 }
3340 list := p.blockItemList()
3341 var t2 Token
3342 p.closeScope()
3343 p.typedefNameEnabled = true
3344 switch p.rune() {
3345 case '}':
3346 t2 = p.shift()
3347 default:
3348 p.err("expected }")
3349 }
3350 r.Token = t
3351 r.BlockItemList = list
3352 r.Token2 = t2
3353 r.scope = s
3354 p.block = sv
3355 return r
3356}
3357
3358// block-item-list:
3359// block-item
3360// block-item-list block-item
3361func (p *parser) blockItemList() (r *BlockItemList) {
3362 var prev *BlockItemList
3363 for p.rune() != '}' && p.rune() > 0 {
3364 n := &BlockItemList{BlockItem: p.blockItem()}
3365 if r == nil {
3366 r = n
3367 prev = r
3368 continue
3369 }
3370
3371 prev.BlockItemList = n
3372 prev = n
3373 }
3374 return r
3375}
3376
3377// block-item:
3378// declaration
3379// statement
3380// label-declaration
3381// declaration-specifiers declarator compound-statement
3382func (p *parser) blockItem() *BlockItem {
3383 switch p.rune() {
3384 case
3385 TYPEDEF, EXTERN, STATIC, AUTO, REGISTER, THREADLOCAL,
3386 VOID, CHAR, SHORT, INT, INT8, INT16, INT32, INT64, INT128, LONG, FLOAT, FLOAT16, FLOAT80, FLOAT32, FLOAT32X, FLOAT64, FLOAT64X, FLOAT128, DECIMAL32, DECIMAL64, DECIMAL128, FRACT, SAT, ACCUM, DOUBLE, SIGNED, UNSIGNED, BOOL, COMPLEX, STRUCT, UNION, ENUM, TYPEDEFNAME, TYPEOF, ATOMIC,
3387 CONST, RESTRICT, VOLATILE,
3388 ALIGNAS,
3389 INLINE, NORETURN, ATTRIBUTE:
3390 ds := p.declarationSpecifiers(nil, nil)
3391 switch p.rune() {
3392 case ';':
3393 r := &BlockItem{Case: BlockItemDecl, Declaration: p.declaration(ds, nil)}
3394 p.typedefNameEnabled = true
3395 return r
3396 }
3397
3398 d := p.declarator(true, ds.typedef(), nil)
3399 switch p.rune() {
3400 case '{':
3401 if p.ctx.cfg.RejectNestedFunctionDefinitions {
3402 p.err0(false, "nested functions not allowed")
3403 }
3404 r := &BlockItem{Case: BlockItemFuncDef, DeclarationSpecifiers: ds, Declarator: d, CompoundStatement: p.compoundStatement(d.ParamScope(), p.fn(d.Name()))}
3405 p.typedefNameEnabled = true
3406 return r
3407 default:
3408 r := &BlockItem{Case: BlockItemDecl, Declaration: p.declaration(ds, d)}
3409 return r
3410 }
3411 case LABEL:
3412 p.block.hasLabel()
3413 return &BlockItem{Case: BlockItemLabel, LabelDeclaration: p.labelDeclaration()}
3414 case PRAGMASTDC:
3415 return &BlockItem{Case: BlockItemPragma, PragmaSTDC: p.pragmaSTDC()}
3416 default:
3417 return &BlockItem{Case: BlockItemStmt, Statement: p.statement()}
3418 }
3419}
3420
3421// label-declaration
3422// __label__ identifier-list ;
3423func (p *parser) labelDeclaration() *LabelDeclaration {
3424 if p.rune() != LABEL {
3425 p.err("expected __label__")
3426 return nil
3427 }
3428
3429 t := p.shift()
3430 list := p.identifierList()
3431 p.typedefNameEnabled = true
3432 var t2 Token
3433 switch p.rune() {
3434 case ';':
3435 t2 = p.shift()
3436 default:
3437 p.err("expected ;")
3438 }
3439 return &LabelDeclaration{Token: t, IdentifierList: list, Token2: t2}
3440}
3441
3442// [0], 6.8.3 Expression and null statements
3443//
3444// expression-statement:
3445// expression_opt attribute-specifier-list_opt;
3446func (p *parser) expressionStatement() *ExpressionStatement {
3447 switch p.rune() {
3448 case '}':
3449 p.typedefNameEnabled = true
3450 return &ExpressionStatement{}
3451 case ';':
3452 p.typedefNameEnabled = true
3453 return &ExpressionStatement{Token: p.shift()}
3454 case ATTRIBUTE:
3455 p.typedefNameEnabled = true
3456 attr := p.attributeSpecifierList()
3457 // if attr != nil {
3458 // trc("%v: ATTRS", attr.Position())
3459 // }
3460 var t Token
3461 switch p.rune() {
3462 case ';':
3463 t = p.shift()
3464 default:
3465 p.err("expected ;")
3466 }
3467 return &ExpressionStatement{AttributeSpecifierList: attr, Token: t}
3468 }
3469
3470 e := p.expression()
3471 var t Token
3472 p.typedefNameEnabled = true
3473 attr := p.attributeSpecifierListOpt()
3474 // if attr != nil {
3475 // trc("%v: ATTRS", attr.Position())
3476 // }
3477 switch p.rune() {
3478 case ';':
3479 t = p.shift()
3480 default:
3481 p.err("expected ;")
3482 }
3483 return &ExpressionStatement{Expression: e, AttributeSpecifierList: attr, Token: t}
3484}
3485
3486// [0], 6.8.4 Selection statements
3487//
3488// selection-statement:
3489// if ( expression ) statement
3490// if ( expression ) statement else statement
3491// switch ( expression ) statement
3492func (p *parser) selectionStatement() *SelectionStatement {
3493 var t, t2, t3, t4 Token
3494 switch p.rune() {
3495 case IF:
3496 p.openScope(false)
3497 t = p.shift()
3498 switch p.rune() {
3499 case '(':
3500 t2 = p.shift()
3501 default:
3502 p.err("expected (")
3503 }
3504 e := p.expression()
3505 switch p.rune() {
3506 case ')':
3507 t3 = p.shift()
3508 default:
3509 p.err("expected )")
3510 }
3511 p.openScope(false)
3512 s := p.statement()
3513 if p.peek(false) != ELSE {
3514 r := &SelectionStatement{Case: SelectionStatementIf, Token: t, Token2: t2, Expression: e, Token3: t3, Statement: s}
3515 p.closeScope()
3516 p.closeScope()
3517 return r
3518 }
3519
3520 p.closeScope()
3521 p.openScope(false)
3522 t4 = p.shift()
3523 r := &SelectionStatement{Case: SelectionStatementIfElse, Token: t, Token2: t2, Expression: e, Token3: t3, Statement: s, Token4: t4, Statement2: p.statement()}
3524 p.closeScope()
3525 p.closeScope()
3526 return r
3527 case SWITCH:
3528 p.switches++
3529 p.openScope(false)
3530 t = p.shift()
3531 switch p.rune() {
3532 case '(':
3533 t2 = p.shift()
3534 default:
3535 p.err("expected (")
3536 }
3537 e := p.expression()
3538 switch p.rune() {
3539 case ')':
3540 t3 = p.shift()
3541 default:
3542 p.err("expected )")
3543 }
3544 p.openScope(false)
3545 s := p.statement()
3546 p.closeScope()
3547 p.closeScope()
3548 p.switches--
3549 return &SelectionStatement{Case: SelectionStatementSwitch, Token: t, Token2: t2, Expression: e, Token3: t3, Statement: s}
3550 default:
3551 p.err("expected selection-statement")
3552 return nil
3553 }
3554}
3555
3556// [0], 6.8.5 Iteration statements
3557//
3558// iteration-statement:
3559// while ( expression ) statement
3560// do statement while ( expression ) ;
3561// for ( expression_opt ; expression_opt ; expression_opt ) statement
3562// for ( declaration expression_opt ; expression_opt ) statement
3563func (p *parser) iterationStatement() (r *IterationStatement) {
3564 var t, t2, t3, t4, t5 Token
3565 var e, e2, e3 *Expression
3566 switch p.rune() {
3567 case WHILE:
3568 p.openScope(false)
3569 t = p.shift()
3570 if p.rune() != '(' {
3571 p.err("expected (")
3572 p.closeScope()
3573 return nil
3574 }
3575
3576 t2 = p.shift()
3577 e = p.expression()
3578 switch p.rune() {
3579 case ')':
3580 t3 = p.shift()
3581 default:
3582 p.err("expected )")
3583 }
3584 p.openScope(false)
3585 r = &IterationStatement{Case: IterationStatementWhile, Token: t, Token2: t2, Expression: e, Token3: t3, Statement: p.statement()}
3586 p.closeScope()
3587 p.closeScope()
3588 return r
3589 case DO:
3590 t := p.shift()
3591 p.openScope(false)
3592 p.openScope(false)
3593 s := p.statement()
3594 p.closeScope()
3595 switch p.rune() {
3596 case WHILE:
3597 t2 = p.shift()
3598 default:
3599 p.err("expected while")
3600 p.closeScope()
3601 return nil
3602 }
3603
3604 if p.rune() != '(' {
3605 p.err("expected (")
3606 p.closeScope()
3607 return nil
3608 }
3609
3610 t3 = p.shift()
3611 e = p.expression()
3612 switch p.rune() {
3613 case ')':
3614 t4 = p.shift()
3615 default:
3616 p.err("expected )")
3617 }
3618 p.typedefNameEnabled = true
3619 switch p.rune() {
3620 case ';':
3621 t5 = p.shift()
3622 default:
3623 p.err("expected ;")
3624 }
3625 r = &IterationStatement{Case: IterationStatementDo, Token: t, Statement: s, Token2: t2, Token3: t3, Expression: e, Token4: t4, Token5: t5}
3626 p.closeScope()
3627 return r
3628 case FOR:
3629 p.openScope(false)
3630 t = p.shift()
3631 if p.rune() != '(' {
3632 p.err("expected (")
3633 p.closeScope()
3634 return nil
3635 }
3636
3637 t2 = p.shift()
3638 var d *Declaration
3639 switch p.rune() {
3640 case TYPEDEF, EXTERN, STATIC, AUTO, REGISTER, THREADLOCAL,
3641 VOID, CHAR, SHORT, INT, INT8, INT16, INT32, INT64, INT128, LONG, FLOAT, FLOAT16, FLOAT80, FLOAT32, FLOAT32X, FLOAT64, FLOAT64X, FLOAT128, DECIMAL32, DECIMAL64, DECIMAL128, FRACT, SAT, ACCUM, DOUBLE, SIGNED, UNSIGNED, BOOL, COMPLEX, STRUCT, UNION, ENUM, TYPEDEFNAME, TYPEOF, ATOMIC,
3642 CONST, RESTRICT, VOLATILE,
3643 ALIGNAS,
3644 INLINE, NORETURN, ATTRIBUTE:
3645 d = p.declaration(nil, nil)
3646 if p.rune() != ';' {
3647 e = p.expression()
3648 }
3649 switch p.rune() {
3650 case ';':
3651 t3 = p.shift()
3652 default:
3653 p.err("expected ;")
3654 }
3655 if p.rune() != ')' {
3656 e2 = p.expression()
3657 }
3658 switch p.rune() {
3659 case ')':
3660 t4 = p.shift()
3661 default:
3662 p.err("expected )")
3663 }
3664 p.openScope(false)
3665 r = &IterationStatement{Case: IterationStatementForDecl, Token: t, Token2: t2, Declaration: d, Expression: e, Token3: t3, Expression2: e2, Token4: t4, Statement: p.statement()}
3666 p.closeScope()
3667 p.closeScope()
3668 return r
3669 default:
3670 if p.rune() != ';' {
3671 e = p.expression()
3672 }
3673 switch p.rune() {
3674 case ';':
3675 t3 = p.shift()
3676 default:
3677 p.err("expected ;")
3678 }
3679 if p.rune() != ';' {
3680 e2 = p.expression()
3681 }
3682 switch p.rune() {
3683 case ';':
3684 t4 = p.shift()
3685 default:
3686 p.err("expected ;")
3687 }
3688 if p.rune() != ')' {
3689 e3 = p.expression()
3690 }
3691 switch p.rune() {
3692 case ')':
3693 t5 = p.shift()
3694 default:
3695 p.err("expected )")
3696 }
3697 p.openScope(false)
3698 r = &IterationStatement{Case: IterationStatementFor, Token: t, Token2: t2, Expression: e, Token3: t3, Expression2: e2, Token4: t4, Expression3: e3, Token5: t5, Statement: p.statement()}
3699 p.closeScope()
3700 p.closeScope()
3701 return r
3702 }
3703 default:
3704 p.err("expected iteration-statement")
3705 return nil
3706 }
3707}
3708
3709// [0], 6.8.6 Jump statements
3710//
3711// jump-statement:
3712// goto identifier ;
3713// goto * expression ;
3714// continue ;
3715// break ;
3716// return expression_opt ;
3717func (p *parser) jumpStatement() *JumpStatement {
3718 var t, t2, t3 Token
3719 var kind JumpStatementCase
3720 switch p.rune() {
3721 case GOTO:
3722 p.typedefNameEnabled = false
3723 t = p.shift()
3724 switch p.rune() {
3725 case IDENTIFIER:
3726 t2 = p.shift()
3727 case '*':
3728 t2 = p.shift()
3729 p.typedefNameEnabled = true
3730 e := p.expression()
3731 switch p.rune() {
3732 case ';':
3733 t3 = p.shift()
3734 default:
3735 p.err("expected ;")
3736 }
3737 return &JumpStatement{Case: JumpStatementGotoExpr, Token: t, Token2: t2, Expression: e, Token3: t3, lexicalScope: p.declScope}
3738 default:
3739 p.err("expected identifier or *")
3740 }
3741 p.typedefNameEnabled = true
3742 switch p.rune() {
3743 case ';':
3744 t3 = p.shift()
3745 default:
3746 p.err("expected ;")
3747 }
3748 return &JumpStatement{Case: JumpStatementGoto, Token: t, Token2: t2, Token3: t3, lexicalScope: p.declScope}
3749 case CONTINUE:
3750 kind = JumpStatementContinue
3751 case BREAK:
3752 kind = JumpStatementBreak
3753 case RETURN:
3754 t = p.shift()
3755 var e *Expression
3756 if p.rune() != ';' {
3757 e = p.expression()
3758 }
3759 p.typedefNameEnabled = true
3760 switch p.rune() {
3761 case ';':
3762 t2 = p.shift()
3763 default:
3764 p.err("expected ;")
3765 }
3766 return &JumpStatement{Case: JumpStatementReturn, Token: t, Expression: e, Token2: t2, lexicalScope: p.declScope}
3767 default:
3768 p.err("expected jump-statement")
3769 return nil
3770 }
3771
3772 t = p.shift()
3773 p.typedefNameEnabled = true
3774 switch p.rune() {
3775 case ';':
3776 t2 = p.shift()
3777 default:
3778 p.err("expected ;")
3779 }
3780 return &JumpStatement{Case: kind, Token: t, Token2: t2, lexicalScope: p.declScope}
3781}
3782
3783// [0], 6.9 External definitions
3784//
3785// translation-unit:
3786// external-declaration
3787// translation-unit external-declaration
3788func (p *parser) translationUnit() (r *TranslationUnit) {
3789 p.typedefNameEnabled = true
3790 var prev *TranslationUnit
3791 for p.rune() >= 0 {
3792 ed := p.externalDeclaration()
3793 if ed == nil {
3794 continue
3795 }
3796
3797 t := &TranslationUnit{ExternalDeclaration: ed}
3798 switch {
3799 case r == nil:
3800 r = t
3801 default:
3802 prev.TranslationUnit = t
3803 }
3804 prev = t
3805 }
3806 if r != nil {
3807 return r
3808 }
3809
3810 return &TranslationUnit{}
3811}
3812
3813// external-declaration:
3814// function-definition
3815// declaration
3816// asm-function-definition
3817// ;
3818func (p *parser) externalDeclaration() *ExternalDeclaration {
3819 var ds *DeclarationSpecifiers
3820 var inline, extern bool
3821 if p.ctx.cfg.SharedFunctionDefinitions != nil {
3822 p.rune()
3823 p.hash.Reset()
3824 p.key = sharedFunctionDefinitionKey{pos: dict.sid(p.tok.Position().String())}
3825 p.hashTok()
3826 }
3827 switch p.rune() {
3828 case TYPEDEF, EXTERN, STATIC, AUTO, REGISTER, THREADLOCAL,
3829 VOID, CHAR, SHORT, INT, INT8, INT16, INT32, INT64, INT128, LONG, FLOAT, FLOAT16, FLOAT80, FLOAT32, FLOAT32X, FLOAT64, FLOAT64X, FLOAT128, DECIMAL32, DECIMAL64, DECIMAL128, FRACT, SAT, ACCUM, DOUBLE, SIGNED, UNSIGNED, BOOL, COMPLEX, STRUCT, UNION, ENUM, TYPEDEFNAME, TYPEOF, ATOMIC,
3830 CONST, RESTRICT, VOLATILE,
3831 INLINE, NORETURN, ATTRIBUTE,
3832 ALIGNAS:
3833 ds = p.declarationSpecifiers(&extern, &inline)
3834 case ';':
3835 if p.ctx.cfg.RejectEmptyDeclarations {
3836 p.err("expected external-declaration")
3837 return nil
3838 }
3839
3840 return &ExternalDeclaration{Case: ExternalDeclarationEmpty, Token: p.shift()}
3841 case ASM:
3842 return &ExternalDeclaration{Case: ExternalDeclarationAsmStmt, AsmStatement: p.asmStatement()}
3843 case PRAGMASTDC:
3844 return &ExternalDeclaration{Case: ExternalDeclarationPragma, PragmaSTDC: p.pragmaSTDC()}
3845 default:
3846 if p.ctx.cfg.RejectMissingDeclarationSpecifiers {
3847 p.err("expected declaration-specifiers")
3848 }
3849 }
3850 if p.rune() == ';' {
3851 return &ExternalDeclaration{Case: ExternalDeclarationDecl, Declaration: p.declaration(ds, nil)}
3852 }
3853
3854 p.rune()
3855 d := p.declarator(false, ds.typedef(), nil)
3856 p.declScope.declare(d.Name(), d)
3857 switch p.rune() {
3858 case ',', ';', '=', ATTRIBUTE:
3859 if ds == nil {
3860 ds = noDeclSpecs
3861 }
3862 r := &ExternalDeclaration{Case: ExternalDeclarationDecl, Declaration: p.declaration(ds, d)}
3863 return r
3864 case ASM:
3865 return &ExternalDeclaration{Case: ExternalDeclarationAsm, AsmFunctionDefinition: p.asmFunctionDefinition(ds, d)}
3866 default:
3867 fd := p.functionDefinition(ds, d)
3868 if sfd := p.ctx.cfg.SharedFunctionDefinitions; sfd != nil {
3869 p.key.nm = d.Name()
3870 p.key.hash = p.hash.Sum64()
3871 if ex := sfd.m[p.key]; ex != nil {
3872 sfd.M[ex] = struct{}{}
3873 d := ex.Declarator
3874 p.declScope.declare(d.Name(), d)
3875 r := &ExternalDeclaration{Case: ExternalDeclarationFuncDef, FunctionDefinition: ex}
3876 return r
3877 }
3878
3879 sfd.m[p.key] = fd
3880 }
3881
3882 r := &ExternalDeclaration{Case: ExternalDeclarationFuncDef, FunctionDefinition: fd}
3883 return r
3884 }
3885}
3886
3887func (p *parser) pragmaSTDC() *PragmaSTDC {
3888 if p.rune() != PRAGMASTDC {
3889 p.err("expected __pragma_stdc")
3890 }
3891
3892 t := p.shift() // _Pragma
3893 t2 := p.shift() // STDC
3894 t3 := p.shift() // FOO
3895 t4 := p.shift() // Bar
3896 return &PragmaSTDC{Token: t, Token2: t2, Token3: t3, Token4: t4}
3897}
3898
3899// [0], 6.9.1 Function definitions
3900//
3901// function-definition:
3902// declaration-specifiers declarator declaration-list_opt compound-statement
3903func (p *parser) functionDefinition(ds *DeclarationSpecifiers, d *Declarator) (r *FunctionDefinition) {
3904 var list *DeclarationList
3905 s := d.ParamScope()
3906 switch {
3907 case p.rune() != '{': // As in: int f(i) int i; { return i; }
3908 list = p.declarationList(s)
3909 case d.DirectDeclarator != nil && d.DirectDeclarator.Case == DirectDeclaratorFuncIdent: // As in: int f(i) { return i; }
3910 d.DirectDeclarator.idListNoDeclList = true
3911 for n := d.DirectDeclarator.IdentifierList; n != nil; n = n.IdentifierList {
3912 tok := n.Token2
3913 if tok.Value == 0 {
3914 tok = n.Token
3915 }
3916 d := &Declarator{
3917 IsParameter: true,
3918 DirectDeclarator: &DirectDeclarator{
3919 Case: DirectDeclaratorIdent,
3920 Token: tok,
3921 },
3922 }
3923 s.declare(tok.Value, d)
3924 if p.ctx.cfg.RejectMissingDeclarationSpecifiers {
3925 p.ctx.errNode(&tok, "expected declaration-specifiers")
3926 }
3927 }
3928 }
3929 p.block = nil
3930 r = &FunctionDefinition{DeclarationSpecifiers: ds, Declarator: d, DeclarationList: list}
3931 sv := p.currFn
3932 p.currFn = r
3933 r.CompoundStatement = p.compoundStatement(d.ParamScope(), p.fn(d.Name()))
3934 p.currFn = sv
3935 return r
3936}
3937
3938func (p *parser) fn(nm StringID) (r []Token) {
3939 if p.ctx.cfg.PreprocessOnly {
3940 return nil
3941 }
3942
3943 pos := p.tok.Position()
3944 toks := []Token{
3945 {Rune: STATIC, Value: idStatic, Src: idStatic},
3946 {Rune: CONST, Value: idConst, Src: idConst},
3947 {Rune: CHAR, Value: idChar, Src: idChar},
3948 {Rune: IDENTIFIER, Value: idFunc, Src: idFunc},
3949 {Rune: '[', Value: idLBracket, Src: idLBracket},
3950 {Rune: ']', Value: idRBracket, Src: idRBracket},
3951 {Rune: '=', Value: idEq, Src: idEq},
3952 {Rune: STRINGLITERAL, Value: nm, Src: nm},
3953 {Rune: ';', Value: idSemicolon, Src: idSemicolon},
3954 }
3955 if p.ctx.cfg.InjectTracingCode {
3956 id := dict.sid(fmt.Sprintf("%s:%s\n", pos, nm.String()))
3957 toks = append(toks, []Token{
3958 {Rune: IDENTIFIER, Value: idFprintf, Src: idFprintf},
3959 {Rune: '(', Value: idLParen, Src: idLParen},
3960 {Rune: IDENTIFIER, Value: idStderr, Src: idStderr},
3961 {Rune: ',', Value: idComma, Src: idComma},
3962 {Rune: STRINGLITERAL, Value: id, Src: id},
3963 {Rune: ')', Value: idRParen, Src: idRParen},
3964 {Rune: ';', Value: idSemicolon, Src: idSemicolon},
3965 {Rune: IDENTIFIER, Value: idFFlush, Src: idFFlush},
3966 {Rune: '(', Value: idLParen, Src: idLParen},
3967 {Rune: IDENTIFIER, Value: idStderr, Src: idStderr},
3968 {Rune: ')', Value: idRParen, Src: idRParen},
3969 {Rune: ';', Value: idSemicolon, Src: idSemicolon},
3970 }...)
3971 }
3972 for _, v := range toks {
3973 v.file = p.tok.file
3974 v.pos = p.tok.pos
3975 v.seq = p.tok.seq
3976 r = append(r, v)
3977 }
3978 return r
3979}
3980
3981// declaration-list:
3982// declaration
3983// declaration-list declaration
3984func (p *parser) declarationList(s Scope) (r *DeclarationList) {
3985 p.declScope = s
3986 p.resolveScope = s
3987 switch ch := p.rune(); ch {
3988 case TYPEDEF, EXTERN, STATIC, AUTO, REGISTER, THREADLOCAL,
3989 VOID, CHAR, SHORT, INT, INT8, INT16, INT32, INT64, INT128, LONG, FLOAT, FLOAT16, FLOAT80, FLOAT32, FLOAT32X, FLOAT64, FLOAT64X, FLOAT128, DECIMAL32, DECIMAL64, DECIMAL128, FRACT, SAT, ACCUM, DOUBLE, SIGNED, UNSIGNED, BOOL, COMPLEX, STRUCT, UNION, ENUM, TYPEDEFNAME, TYPEOF, ATOMIC,
3990 CONST, RESTRICT, VOLATILE,
3991 ALIGNAS,
3992 INLINE, NORETURN, ATTRIBUTE:
3993 r = &DeclarationList{Declaration: p.declaration(nil, nil)}
3994 default:
3995 p.err("expected declaration: %s", tokName(ch))
3996 return nil
3997 }
3998
3999 for prev := r; ; prev = prev.DeclarationList {
4000 switch p.rune() {
4001 case TYPEDEF, EXTERN, STATIC, AUTO, REGISTER, THREADLOCAL,
4002 VOID, CHAR, SHORT, INT, INT8, INT16, INT32, INT64, INT128, LONG, FLOAT, FLOAT16, FLOAT80, FLOAT32, FLOAT32X, FLOAT64, FLOAT64X, FLOAT128, DECIMAL32, DECIMAL64, DECIMAL128, FRACT, SAT, ACCUM, DOUBLE, SIGNED, UNSIGNED, BOOL, COMPLEX, STRUCT, UNION, ENUM, TYPEDEFNAME, TYPEOF, ATOMIC,
4003 CONST, RESTRICT, VOLATILE,
4004 ALIGNAS,
4005 INLINE, NORETURN, ATTRIBUTE:
4006 prev.DeclarationList = &DeclarationList{Declaration: p.declaration(nil, nil)}
4007 default:
4008 return r
4009 }
4010 }
4011}
4012
4013// ----------------------------------------------------------------- Extensions
4014
4015// asm-function-definition:
4016// declaration-specifiers declarator asm-statement
4017func (p *parser) asmFunctionDefinition(ds *DeclarationSpecifiers, d *Declarator) *AsmFunctionDefinition {
4018 return &AsmFunctionDefinition{DeclarationSpecifiers: ds, Declarator: d, AsmStatement: p.asmStatement()}
4019}
4020
4021// asm-statement:
4022// asm attribute-specifier-list_opt ;
4023func (p *parser) asmStatement() *AsmStatement {
4024 a := p.asm()
4025 attr := p.attributeSpecifierListOpt()
4026 // if attr != nil {
4027 // trc("%v: ATTRS", attr.Position())
4028 // }
4029 var t Token
4030 switch p.rune() {
4031 case ';':
4032 p.typedefNameEnabled = true
4033 t = p.shift()
4034 default:
4035 p.err("expected ';'")
4036 }
4037
4038 return &AsmStatement{Asm: a, AttributeSpecifierList: attr, Token: t}
4039}
4040
4041// asm:
4042// asm asm-qualifier-list_opt ( string-literal asm-arg-list_opt )
4043func (p *parser) asm() *Asm {
4044 var t, t2, t3, t4 Token
4045 switch p.rune() {
4046 case ASM:
4047 t = p.shift()
4048 default:
4049 p.err("expected asm")
4050 }
4051
4052 var qlist *AsmQualifierList
4053 switch p.rune() {
4054 case VOLATILE, INLINE, GOTO:
4055 qlist = p.asmQualifierList()
4056 }
4057
4058 switch p.rune() {
4059 case '(':
4060 t2 = p.shift()
4061 default:
4062 p.err("expected (")
4063 }
4064
4065 switch p.rune() {
4066 case STRINGLITERAL:
4067 t3 = p.shift()
4068 default:
4069 p.err("expected string-literal")
4070 }
4071
4072 var argList *AsmArgList
4073 switch p.rune() {
4074 case ':':
4075 argList = p.asmArgList()
4076 }
4077
4078 switch p.rune() {
4079 case ')':
4080 t4 = p.shift()
4081 default:
4082 p.err("expected )")
4083 }
4084
4085 return &Asm{Token: t, AsmQualifierList: qlist, Token2: t2, Token3: t3, AsmArgList: argList, Token4: t4}
4086}
4087
4088// asm-qualifier-list:
4089// asm-qualifier
4090// asm-qualifier-list asm-qualifier
4091func (p *parser) asmQualifierList() (r *AsmQualifierList) {
4092 switch p.rune() {
4093 case VOLATILE, INLINE, GOTO:
4094 r = &AsmQualifierList{AsmQualifier: p.asmQualifier()}
4095 default:
4096 p.err("expected asm-qualifier-list")
4097 return nil
4098 }
4099
4100 for prev := r; ; prev = prev.AsmQualifierList {
4101 switch p.rune() {
4102 case VOLATILE, INLINE, GOTO:
4103 prev.AsmQualifierList = &AsmQualifierList{AsmQualifier: p.asmQualifier()}
4104 default:
4105 return r
4106 }
4107 }
4108}
4109
4110// asm-qualifier:
4111// volatile
4112// inline
4113// goto"
4114func (p *parser) asmQualifier() *AsmQualifier {
4115 switch p.rune() {
4116 case VOLATILE:
4117 return &AsmQualifier{Case: AsmQualifierVolatile, Token: p.shift()}
4118 case INLINE:
4119 return &AsmQualifier{Case: AsmQualifierInline, Token: p.shift()}
4120 case GOTO:
4121 return &AsmQualifier{Case: AsmQualifierGoto, Token: p.shift()}
4122 default:
4123 p.err("expected asm-qualifier")
4124 return nil
4125 }
4126}
4127
4128// asm-arg-list:
4129// : ExpressionListOpt
4130// asm-arg-list : expression-list_opt
4131func (p *parser) asmArgList() (r *AsmArgList) {
4132 if p.rune() != ':' {
4133 p.err("expected :")
4134 return nil
4135 }
4136
4137 t := p.shift()
4138 var list *AsmExpressionList
4139 switch p.rune() {
4140 case ':', ')':
4141 default:
4142 list = p.asmExpressionList()
4143 }
4144 r = &AsmArgList{Token: t, AsmExpressionList: list}
4145 for prev := r; p.rune() == ':'; prev = prev.AsmArgList {
4146 t := p.shift()
4147 switch p.rune() {
4148 case ':', ')':
4149 default:
4150 list = p.asmExpressionList()
4151 }
4152 prev.AsmArgList = &AsmArgList{Token: t, AsmExpressionList: list}
4153 }
4154 return r
4155}
4156
4157// asm-expression-list:
4158// asm-index_opt assignment-expression
4159// asm-expression-list , asm-index_opt assignment-expression
4160func (p *parser) asmExpressionList() (r *AsmExpressionList) {
4161 var x *AsmIndex
4162 if p.rune() == '[' {
4163 x = p.asmIndex()
4164 }
4165
4166 r = &AsmExpressionList{AsmIndex: x, AssignmentExpression: p.assignmentExpression()}
4167 for prev := r; p.rune() == ','; prev = prev.AsmExpressionList {
4168 t := p.shift()
4169 if p.rune() == '[' {
4170 x = p.asmIndex()
4171 }
4172 prev.AsmExpressionList = &AsmExpressionList{Token: t, AsmIndex: x, AssignmentExpression: p.assignmentExpression()}
4173 }
4174 return r
4175}
4176
4177// asm-index:
4178// [ expression ]
4179func (p *parser) asmIndex() *AsmIndex {
4180 if p.rune() != '[' {
4181 p.err("expected [")
4182 return nil
4183 }
4184
4185 t := p.shift()
4186 e := p.expression()
4187 var t2 Token
4188 switch p.rune() {
4189 case ']':
4190 t2 = p.shift()
4191 default:
4192 p.err("expected ]")
4193 }
4194 return &AsmIndex{Token: t, Expression: e, Token2: t2}
4195}
4196
4197// attribute-specifier-list:
4198// attribute-specifier
4199// attribute-specifier-list attribute-specifier
4200func (p *parser) attributeSpecifierList() (r *AttributeSpecifierList) {
4201 if p.rune() != ATTRIBUTE {
4202 p.err("expected __attribute__")
4203 return nil
4204 }
4205
4206 r = &AttributeSpecifierList{AttributeSpecifier: p.attributeSpecifier()}
4207 for prev := r; p.rune() == ATTRIBUTE; prev = r.AttributeSpecifierList {
4208 prev.AttributeSpecifierList = &AttributeSpecifierList{AttributeSpecifier: p.attributeSpecifier()}
4209 }
4210 return r
4211}
4212
4213// attribute-specifier:
4214// __attribute__ (( attribute-value-list_opt ))
4215func (p *parser) attributeSpecifier() (r *AttributeSpecifier) {
4216 if p.rune() != ATTRIBUTE {
4217 p.err("expected __attribute__")
4218 return nil
4219 }
4220
4221 en := p.typedefNameEnabled
4222 t := p.shift()
4223 var t2, t3, t4, t5 Token
4224 p.ignoreKeywords = true
4225 switch p.rune() {
4226 case '(':
4227 t2 = p.shift()
4228 default:
4229 p.err("expected (")
4230 }
4231 switch p.rune() {
4232 case '(':
4233 t3 = p.shift()
4234 default:
4235 p.err("expected (")
4236 }
4237 var list *AttributeValueList
4238 if p.rune() != ')' {
4239 list = p.attributeValueList()
4240 }
4241 p.ignoreKeywords = false
4242 p.typedefNameEnabled = en
4243 switch p.rune() {
4244 case ')':
4245 t4 = p.shift()
4246 default:
4247 p.err("expected )")
4248 }
4249 switch p.rune() {
4250 case ')':
4251 t5 = p.shift()
4252 default:
4253 p.err("expected )")
4254 }
4255 return &AttributeSpecifier{Token: t, Token2: t2, Token3: t3, AttributeValueList: list, Token4: t4, Token5: t5}
4256}
4257
4258// attribute-value-list:
4259// attribute-value
4260// attribute-value-list , attribute-value
4261func (p *parser) attributeValueList() (r *AttributeValueList) {
4262 r = &AttributeValueList{AttributeValue: p.attributeValue()}
4263 for prev := r; p.rune() == ','; prev = prev.AttributeValueList {
4264 t := p.shift()
4265 prev.AttributeValueList = &AttributeValueList{Token: t, AttributeValue: p.attributeValue()}
4266 }
4267 return r
4268}
4269
4270// attribute-value:
4271// identifier
4272// identifier ( expression-list_opt )
4273func (p *parser) attributeValue() *AttributeValue {
4274 if p.rune() != IDENTIFIER {
4275 p.err("expected identifier")
4276 return nil
4277 }
4278
4279 t := p.shift()
4280 if p.rune() != '(' {
4281 return &AttributeValue{Case: AttributeValueIdent, Token: t, lexicalScope: p.declScope}
4282 }
4283
4284 p.ignoreKeywords = false
4285 t2 := p.shift()
4286 var list *ExpressionList
4287 if p.rune() != ')' {
4288 list = p.expressionList()
4289 }
4290 p.ignoreKeywords = true
4291 var t3 Token
4292 switch p.rune() {
4293 case ')':
4294 t3 = p.shift()
4295 default:
4296 p.err("expected )")
4297 }
4298 return &AttributeValue{Case: AttributeValueExpr, Token: t, Token2: t2, ExpressionList: list, Token3: t3, lexicalScope: p.declScope}
4299}
4300
4301// expression-list:
4302// assignment-expression
4303// expression-list , assignment-expression
4304func (p *parser) expressionList() (r *ExpressionList) {
4305 r = &ExpressionList{AssignmentExpression: p.assignmentExpression()}
4306 for prev := r; p.rune() == ','; prev = prev.ExpressionList {
4307 t := p.shift()
4308 prev.ExpressionList = &ExpressionList{Token: t, AssignmentExpression: p.assignmentExpression()}
4309 }
4310 return r
4311}
Note: See TracBrowser for help on using the repository browser.