diff options
Diffstat (limited to 'vendor/modernc.org/ccgo/v3/lib/go.go')
| -rw-r--r-- | vendor/modernc.org/ccgo/v3/lib/go.go | 13164 |
1 files changed, 0 insertions, 13164 deletions
diff --git a/vendor/modernc.org/ccgo/v3/lib/go.go b/vendor/modernc.org/ccgo/v3/lib/go.go deleted file mode 100644 index 6238d0c98..000000000 --- a/vendor/modernc.org/ccgo/v3/lib/go.go +++ /dev/null @@ -1,13164 +0,0 @@ -// Copyright 2020 The CCGO Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package ccgo // import "modernc.org/ccgo/v3/lib" - -import ( - "bytes" - "fmt" - "go/scanner" - "go/token" - "hash/maphash" - "io/ioutil" - "math" - "math/big" - "os" - "os/exec" - "path/filepath" - "runtime" - "sort" - "strconv" - "strings" - "sync" - "time" - - "modernc.org/cc/v3" - "modernc.org/mathutil" -) - -var ( - idAddOverflow = cc.String("__builtin_add_overflow") // bool __builtin_add_overflow (type1 a, type2 b, type3 *res) - idAlias = cc.String("alias") - idAligned = cc.String("aligned") // int __attribute__ ((aligned (8))) foo; - idAtomicLoadN = cc.String("__atomic_load_n") // type __atomic_load_n (type *ptr, int memorder) - idAtomicStoreN = cc.String("__atomic_store_n") // void __atomic_store_n (type *ptr, type val, int memorder) - idBp = cc.String("bp") - idBuiltinConstantPImpl = cc.String("__builtin_constant_p_impl") - idCAPI = cc.String("CAPI") - idChooseExpr = cc.String("__builtin_choose_expr") - idEnviron = cc.String("environ") - idMain = cc.String("main") - idMulOverflow = cc.String("__builtin_mul_overflow") // bool __builtin_mul_overflow (type1 a, type2 b, type3 *res) - idPacked = cc.String("packed") // __attribute__((packed)) - idSubOverflow = cc.String("__builtin_sub_overflow") // bool __builtin_sub_overflow (type1 a, type2 b, type3 *res) - idTls = cc.String("tls") - idTransparentUnion = cc.String("__transparent_union__") - idTs = cc.String("ts") - idVa = cc.String("va") - idVaArg = cc.String("__ccgo_va_arg") - idVaEnd = cc.String("__ccgo_va_end") - idVaList = cc.String("va_list") - idVaStart = cc.String("__ccgo_va_start") - idWcharT = cc.String("wchar_t") - idWinWchar = cc.String("WCHAR") - idWtext = cc.String("wtext") - - bytesBufferPool = sync.Pool{New: func() interface{} { return &bytes.Buffer{} }} - - oTraceG bool - oTraceW bool - oTracePin bool -) - -type exprMode int - -const ( - doNotExport = iota - doNotChange - exportCapitalize - exportPrefix -) - -const ( - _ exprMode = iota - exprAddrOf // &foo as uinptr (must be static/pinned) - exprBool // foo in foo != 0 - exprCondInit // foo or bar in int i = x ? foo : bar; - exprCondReturn // foo or bar in return x ? foo : bar; - exprDecay // &foo[0] in foo for array foo. - exprFunc // foo in foo(bar) - exprLValue // foo in foo = bar - exprPSelect // foo in foo->bar - exprSelect // foo in foo.bar - exprValue // foo in bar = foo - exprVoid // - exprGoPtr -) - -const ( - tooManyErrors = "too many errors" -) - -type opKind int - -const ( - opNormal opKind = iota - opArray - opArrayParameter - opFunction - opUnion - opBitfield - opStruct -) - -type flags byte - -const ( - fForceConv flags = 1 << iota - fForceNoConv - fForceRuntimeConv - fNoCondAssignment - fAddrOfFuncPtrOk -) - -type imported struct { - path string // Eg. "example.com/user/foo". - name string // Eg. "foo" from "package foo". - qualifier string // Eg. "foo." or "foo2." if renamed due to name conflict. - exports map[string]struct{} // Eg. {"New": {}, "Close": {}, ...}. - - used bool -} - -type taggedStruct struct { - ctyp cc.Type - gotyp string - name string - node cc.Node - - conflicts bool - emitted bool -} - -func (s *taggedStruct) emit(p *project, ds *cc.DeclarationSpecifiers) { - if s == nil || s.emitted { - return - } - - s.emitted = true - p.w("%stype %s = %s; /* %v */\n\n", tidyComment("\n", ds), s.name, s.gotyp, p.pos(s.node)) -} - -// Return first non empty token separator within n or dflt otherwise. -func comment(dflt string, n cc.Node) string { - if s := tokenSeparator(n); s != "" { - return s - } - - return dflt -} - -// tidyComment is like comment but makes comment more Go-like. -func tidyComment(dflt string, n cc.Node) (r string) { return tidyCommentString(comment(dflt, n)) } - -func tidyCommentString(s string) (r string) { - defer func() { - if !strings.Contains(r, "// <blockquote><pre>") { - return - } - - a := strings.Split(r, "\n") - in := false - for i, v := range a { - switch { - case in: - if strings.HasPrefix(v, "// </pre></blockquote>") { - in = false - a[i] = "//" - break - } - - a[i] = fmt.Sprintf("//\t%s", v[3:]) - default: - if strings.HasPrefix(v, "// <blockquote><pre>") { - a[i] = "//" - in = true - } - } - } - r = strings.Join(a, "\n") - }() - - s = strings.ReplaceAll(s, "\f", "") - b := bytesBufferPool.Get().(*bytes.Buffer) - defer func() { b.Reset(); bytesBufferPool.Put(b) }() - for len(s) != 0 { - c := s[0] - s = s[1:] - if len(s) == 0 { - b.WriteByte(c) - break - } - - if c != '/' { - b.WriteByte(c) - continue - } - - c2 := s[0] - s = s[1:] - switch c2 { - case '/': // line comment start - b.WriteByte(c) - b.WriteByte(c2) - for { - c := s[0] - s = s[1:] - b.WriteByte(c) - if c == '\n' { - break - } - } - case '*': // block comment start - b2 := bytesBufferPool.Get().(*bytes.Buffer) - defer func() { b2.Reset(); bytesBufferPool.Put(b2) }() - for { - c := s[0] - s = s[1:] - if c != '*' { - b2.WriteByte(c) - continue - } - - more: - c2 := s[0] - s = s[1:] - if c2 == '*' { - b2.WriteByte(c) - goto more - } - - if c2 != '/' { - b2.WriteByte(c) - b2.WriteByte(c2) - continue - } - - break - } - s2 := b2.String() // comment sans /* prefix and */ suffix - a := strings.Split(s2, "\n") - nl := len(s) != 0 && s[0] == '\n' - if len(a) == 1 { // /* foo */ form - if nl { - s = s[1:] - fmt.Fprintf(b, "//%s\n", s2) - break - } - - fmt.Fprintf(b, "/*%s*/", s2) - break - } - - if !nl { - fmt.Fprintf(b, "/*%s*/", s2) - break - } - - // Block comment followed by a newline can be safely replaced by a sequence of - // line comments. Try to enhance the comment. - if commentForm1(b, a) || - commentForm2(b, a) || - commentForm3(b, a) { - break - } - - // No enhancement posibilities detected, use the default form. - if a[len(a)-1] == "" { - a = a[:len(a)-1] - } - fmt.Fprintf(b, "//%s", a[0]) - for _, v := range a[1:] { - fmt.Fprintf(b, "\n// %s", v) - } - default: - b.WriteByte(c) - b.WriteByte(c2) - } - } - return b.String() -} - -func commentForm1(b *bytes.Buffer, a []string) bool { - // Example - // - // /* - // ** Initialize this module. - // ** - // ** This Tcl module contains only a single new Tcl command named "sqlite". - // ** (Hence there is no namespace. There is no point in using a namespace - // ** if the extension only supplies one new name!) The "sqlite" command is - // ** used to open a new SQLite database. See the DbMain() routine above - // ** for additional information. - // ** - // ** The EXTERN macros are required by TCL in order to work on windows. - // */ - if strings.TrimSpace(a[0]) != "" { - return false - } - - if strings.TrimSpace(a[len(a)-1]) != "" { - return false - } - - a = a[1 : len(a)-1] - if len(a) == 0 { - return false - } - - for i, v := range a { - v = strings.TrimSpace(v) - if !strings.HasPrefix(v, "*") { - return false - } - - a[i] = strings.TrimLeft(v, "*") - } - - fmt.Fprintf(b, "//%s", a[0]) - for _, v := range a[1:] { - fmt.Fprintf(b, "\n//%s", v) - } - return true -} - -func commentForm2(b *bytes.Buffer, a []string) bool { - // Example - // - // /**************************** sqlite3_column_ ******************************* - // ** The following routines are used to access elements of the current row - // ** in the result set. - // */ - if strings.TrimSpace(a[len(a)-1]) != "" { - return false - } - - a = a[:len(a)-1] - if len(a) == 0 { - return false - } - - for i, v := range a[1:] { - v = strings.TrimSpace(v) - if !strings.HasPrefix(v, "*") { - return false - } - - a[i+1] = strings.TrimLeft(v, "*") - } - - fmt.Fprintf(b, "// %s", strings.TrimSpace(a[0])) - if strings.HasPrefix(a[0], "**") && strings.HasSuffix(a[0], "**") { - fmt.Fprintf(b, "\n//") - } - for _, v := range a[1:] { - fmt.Fprintf(b, "\n//%s", v) - } - return true -} - -func commentForm3(b *bytes.Buffer, a []string) bool { - // Example - // - // /* Call sqlite3_shutdown() once before doing anything else. This is to - // ** test that sqlite3_shutdown() can be safely called by a process before - // ** sqlite3_initialize() is. */ - for i, v := range a[1:] { - v = strings.TrimSpace(v) - if !strings.HasPrefix(v, "*") { - return false - } - - a[i+1] = strings.TrimLeft(v, "*") - } - - fmt.Fprintf(b, "// %s", strings.TrimSpace(a[0])) - if strings.HasPrefix(a[0], "**") && strings.HasSuffix(a[0], "**") { - fmt.Fprintf(b, "\n//") - } - for _, v := range a[1:] { - fmt.Fprintf(b, "\n//%s", v) - } - return true -} - -// Return the preceding white space, including any comments, of the first token -// of n. -func tokenSeparator(n cc.Node) (r string) { - if n == nil { - return "" - } - - var tok cc.Token - cc.Inspect(n, func(n cc.Node, _ bool) bool { - if x, ok := n.(*cc.Token); ok { - if a, b := tok.Seq(), x.Seq(); a == 0 || a > x.Seq() && b != 0 { - tok = *x - } - } - return true - }) - return tok.Sep.String() -} - -func source(n ...cc.Node) (r string) { - if len(n) == 0 { - return "<nil>" - } - - var a []*cc.Token - for _, v := range n { - cc.Inspect(v, func(n cc.Node, _ bool) bool { - if x, ok := n.(*cc.Token); ok && x.Seq() != 0 { - a = append(a, x) - } - return true - }) - } - sort.Slice(a, func(i, j int) bool { - return a[i].Seq() < a[j].Seq() - }) - w := 0 - seq := -1 - for _, v := range a { - if n := v.Seq(); n != seq { - seq = n - a[w] = v - w++ - } - } - a = a[:w] - var b strings.Builder - for _, v := range a { - b.WriteString(v.Sep.String()) - b.WriteString(v.Src.String()) - } - return b.String() -} - -type initPatch struct { - t cc.Type - init *cc.Initializer - fld cc.Field -} - -type tld struct { - name string // Can differ from the original one. - patches []initPatch -} - -type block struct { - block *cc.CompoundStatement - decls []*cc.Declaration // What to declare in this block. - params []*cc.Parameter - parent *block - scope scope - - noDecl bool // Locals declared in one of the parent scopes. - topDecl bool // Declare locals at block start to avoid "jumps over declaration". -} - -func newBlock(parent *block, n *cc.CompoundStatement, decls []*cc.Declaration, params []*cc.Parameter, scope scope, topDecl bool) *block { - return &block{ - block: n, - decls: decls, - params: params, - parent: parent, - scope: scope, - topDecl: topDecl, - } -} - -type local struct { - name string - off uintptr // If isPinned: bp+off - - forceRead bool // Possibly never read. - isPinned bool // Prevent this local from being placed in Go movable stack. -} - -type switchState int - -const ( - _ switchState = iota // Not in switch. - inSwitchFirst // Before seeing "case/default". - inSwitchCase // Seen "case/default". - inSwitchSeenBreak // In switch "case/default" and seen "break/return". - inSwitchFlat -) - -type function struct { - block *block - blocks map[*cc.CompoundStatement]*block - bpName string - breakCtx int //TODO merge with continueCtx - complits map[*cc.PostfixExpression]uintptr - condInitPrefix func() - continueCtx int - flatLabels int - flatSwitchLabels map[*cc.LabeledStatement]int - fndef *cc.FunctionDefinition - gen *project - ifCtx cc.Node - ignore map[*cc.Declarator]bool // Pseudo declarators - labelNames map[cc.StringID]string - labels scope - locals map[*cc.Declarator]*local - off uintptr // bp+off allocs - params []*cc.Parameter // May differ from what fndef says - project *project - rt cc.Type // May differ from what fndef says - scope scope - switchCtx switchState - tlsName string - top *block - unusedLabels map[cc.StringID]struct{} - vaLists map[*cc.PostfixExpression]uintptr - vaName string - vaType cc.Type - vlas map[*cc.Declarator]struct{} - - hasJumps bool - mainSignatureForced bool -} - -func newFunction(p *project, n *cc.FunctionDefinition) *function { - d := n.Declarator - t := d.Type() - rt := t.Result() - params := t.Parameters() - var mainSignatureForced bool - var ignore map[*cc.Declarator]bool - if d.Name() == idMain && d.Linkage == cc.External { - if rt.Kind() != cc.Int { - rt = p.task.cfg.ABI.Type(cc.Int) - } - if len(params) != 2 { - mainSignatureForced = true - d1 := newDeclarator("argc") - t1 := p.task.cfg.ABI.Type(cc.Int) - d2 := newDeclarator("argv") - t2 := p.task.cfg.ABI.Ptr(n, p.task.cfg.ABI.Type(cc.Void)) - params = []*cc.Parameter{ - cc.NewParameter(d1, t1), - cc.NewParameter(d2, t2), - } - ignore = map[*cc.Declarator]bool{d1: true, d2: true} - } - } - f := &function{ - blocks: map[*cc.CompoundStatement]*block{}, - complits: map[*cc.PostfixExpression]uintptr{}, - fndef: n, - gen: p, - hasJumps: n.CompoundStatement.IsJumpTarget(), - ignore: ignore, - locals: map[*cc.Declarator]*local{}, - mainSignatureForced: mainSignatureForced, - params: params, - project: p, - rt: rt, - scope: p.newScope(), - unusedLabels: map[cc.StringID]struct{}{}, - vaLists: map[*cc.PostfixExpression]uintptr{}, - vlas: map[*cc.Declarator]struct{}{}, - } - f.tlsName = f.scope.take(idTls) - if t.IsVariadic() { - f.vaName = f.scope.take(idVa) - } - f.layoutLocals(nil, n.CompoundStatement, params) - var extern []cc.StringID - for _, v := range n.CompoundStatements() { // testdata/gcc-9.1.0/gcc/testsuite/gcc.c-torture/execute/scope-1.c - for _, v := range v.Declarations() { - for list := v.InitDeclaratorList; list != nil; list = list.InitDeclaratorList { - if d := list.InitDeclarator.Declarator; d != nil && d.IsExtern() { - extern = append(extern, d.Name()) - } - } - } - } - for _, v := range n.CompoundStatements() { - block := f.blocks[v] - for _, v := range extern { - if tld := f.project.externs[v]; tld != nil { - block.scope.take(cc.String(tld.name)) - } - } - } - for _, v := range n.CompoundStatements() { - f.layoutBlocks(v) - } - f.renameLabels() - f.staticAllocsAndPinned(n.CompoundStatement) - return f -} - -func (f *function) flatLabel() int { - if f.project.pass1 { - return 1 - } - - f.flatLabels++ - return f.flatLabels -} - -func (f *function) renameLabels() { - var a []cc.StringID - for _, v := range f.fndef.Labels { - if v.Case != cc.LabeledStatementLabel { - continue - } - - a = append(a, v.Token.Value) - f.unusedLabels[v.Token.Value] = struct{}{} - } - for _, v := range f.fndef.Gotos { - delete(f.unusedLabels, v.Token2.Value) - } - if len(a) == 0 { - return - } - sort.Slice(a, func(i, j int) bool { return a[i].String() < a[j].String() }) - f.labels = newScope() - f.labelNames = map[cc.StringID]string{} - for _, id := range a { - f.labelNames[id] = f.labels.take(id) - } -} - -func (f *function) staticAllocsAndPinned(n *cc.CompoundStatement) { - for _, v := range f.params { - switch { - case v.Type().Kind() == cc.Array && v.Type().IsVLA(): - // trc("VLA") - f.project.err(f.fndef, "variable length arrays not supported") - } - } - - //TODO use pass1 for this - cc.Inspect(n, func(n cc.Node, entry bool) bool { - if !entry { - return true - } - - switch x := n.(type) { - case *cc.CastExpression: - switch x.Case { - case cc.CastExpressionCast: // '(' TypeName ')' CastExpression - if t := x.TypeName.Type(); t != nil && t.Kind() != cc.Void { - break - } - - if d := x.CastExpression.Declarator(); d != nil { - if local := f.locals[d]; local != nil { - local.forceRead = true - } - } - } - } - - x, ok := n.(*cc.PostfixExpression) - if !ok || x.Case != cc.PostfixExpressionCall { - return true - } - - if x.PostfixExpression == nil || x.PostfixExpression.Operand == nil || x.PostfixExpression.Operand.Type() == nil { - return true - } - - ft := funcType(x.PostfixExpression.Operand.Type()) - if ft.Kind() != cc.Function { - return true - } - - if !ft.IsVariadic() { - return true - } - - fixedParams := len(ft.Parameters()) - iArg := 0 - var need uintptr - for list := x.ArgumentExpressionList; list != nil; list, iArg = list.ArgumentExpressionList, iArg+1 { - if iArg < fixedParams { - continue - } - - t := list.AssignmentExpression.Operand.Type() - if t.IsIntegerType() { - need += 8 - continue - } - - switch t.Kind() { - case cc.Array, cc.Ptr, cc.Double, cc.Float, cc.Function: - need += 8 - default: - panic(todo("", f.project.pos(x), t, t.Kind())) - } - } - if need != 0 { - //TODO- if f.project.task.mingw { - //TODO- need += 8 // On windows the va list is prefixed with its length - //TODO- } - va := roundup(f.off, 8) - f.vaLists[x] = va - f.off = va + need - } - return true - }) -} - -func funcType(t cc.Type) cc.Type { - if t.Kind() == cc.Ptr { - t = t.Elem() - } - return t -} - -type declarator interface { - Declarator() *cc.Declarator - cc.Node -} - -func (p *project) isArrayParameterDeclarator(d *cc.Declarator) bool { - if d.Type().Kind() == cc.Array { - if d.Type().IsVLA() { - return false - } - - return d.IsParameter - } - - return false -} - -func (p *project) isArrayDeclarator(d *cc.Declarator) bool { - if d.Type().Kind() == cc.Array { - if d.Type().IsVLA() { - return false - } - - return !d.IsParameter - } - - return false -} - -func (p *project) isArrayParameter(n declarator, t cc.Type) bool { - if t.Kind() != cc.Array { - return false - } - - if t.IsVLA() { - return false - } - - if d := n.Declarator(); d != nil { - return d.IsParameter - } - - return false -} - -func (p *project) isArrayOrPinnedArray(f *function, n declarator, t cc.Type) (r bool) { - if t.Kind() != cc.Array { - return false - } - - if t.IsVLA() { - return false - } - - if d := n.Declarator(); d != nil { - return !d.IsParameter - } - - return p.detectArray(f, n.(cc.Node), true, true, nil) -} - -func (p *project) detectArray(f *function, n cc.Node, pinnedOk, recursiveOk bool, out **cc.Declarator) bool { - switch x := n.(type) { - case *cc.AssignmentExpression: - switch x.Case { - case cc.AssignmentExpressionCond: // ConditionalExpression - return p.detectArray(f, x.ConditionalExpression, pinnedOk, recursiveOk, out) - case cc.AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression - return p.detectArray(f, x.UnaryExpression, pinnedOk, recursiveOk, out) - default: - return false - } - case *cc.ConditionalExpression: - switch x.Case { - case cc.ConditionalExpressionLOr: // LogicalOrExpression - return p.detectArray(f, x.LogicalOrExpression, pinnedOk, recursiveOk, out) - case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression - return p.detectArray(f, x.LogicalOrExpression, pinnedOk, recursiveOk, out) || - p.detectArray(f, x.Expression, pinnedOk, recursiveOk, out) || - p.detectArray(f, x.ConditionalExpression, pinnedOk, recursiveOk, out) - default: - panic(todo("", p.pos(x), x.Case)) - } - case *cc.LogicalOrExpression: - switch x.Case { - case cc.LogicalOrExpressionLAnd: // LogicalAndExpression - return p.detectArray(f, x.LogicalAndExpression, pinnedOk, recursiveOk, out) - default: - return false - } - case *cc.LogicalAndExpression: - switch x.Case { - case cc.LogicalAndExpressionOr: // InclusiveOrExpression - return p.detectArray(f, x.InclusiveOrExpression, pinnedOk, recursiveOk, out) - default: - return false - } - case *cc.InclusiveOrExpression: - switch x.Case { - case cc.InclusiveOrExpressionXor: // ExclusiveOrExpression - return p.detectArray(f, x.ExclusiveOrExpression, pinnedOk, recursiveOk, out) - default: - return false - } - case *cc.ExclusiveOrExpression: - switch x.Case { - case cc.ExclusiveOrExpressionAnd: // AndExpression - return p.detectArray(f, x.AndExpression, pinnedOk, recursiveOk, out) - default: - return false - } - case *cc.AndExpression: - switch x.Case { - case cc.AndExpressionEq: // EqualityExpression - return p.detectArray(f, x.EqualityExpression, pinnedOk, recursiveOk, out) - default: - return false - } - case *cc.EqualityExpression: - switch x.Case { - case cc.EqualityExpressionRel: // RelationalExpression - return p.detectArray(f, x.RelationalExpression, pinnedOk, recursiveOk, out) - default: - return false - } - case *cc.RelationalExpression: - switch x.Case { - case cc.RelationalExpressionShift: // ShiftExpression - return p.detectArray(f, x.ShiftExpression, pinnedOk, recursiveOk, out) - default: - return false - } - case *cc.ShiftExpression: - switch x.Case { - case cc.ShiftExpressionAdd: // AdditiveExpression - return p.detectArray(f, x.AdditiveExpression, pinnedOk, recursiveOk, out) - default: - return false - } - case *cc.AdditiveExpression: - switch x.Case { - case cc.AdditiveExpressionMul: // MultiplicativeExpression - return p.detectArray(f, x.MultiplicativeExpression, pinnedOk, recursiveOk, out) - case - cc.AdditiveExpressionSub, // AdditiveExpression '-' MultiplicativeExpression - cc.AdditiveExpressionAdd: // AdditiveExpression '+' MultiplicativeExpression - - return p.detectArray(f, x.AdditiveExpression, pinnedOk, recursiveOk, out) || p.detectArray(f, x.MultiplicativeExpression, pinnedOk, recursiveOk, out) - default: - panic(todo("", p.pos(x), x.Case)) - } - case *cc.MultiplicativeExpression: - switch x.Case { - case cc.MultiplicativeExpressionCast: // CastExpression - return p.detectArray(f, x.CastExpression, pinnedOk, recursiveOk, out) - default: - return false - } - case *cc.CastExpression: - switch x.Case { - case cc.CastExpressionUnary: // UnaryExpression - return p.detectArray(f, x.UnaryExpression, pinnedOk, recursiveOk, out) - case cc.CastExpressionCast: // '(' TypeName ')' CastExpression - return p.detectArray(f, x.CastExpression, pinnedOk, recursiveOk, out) - default: - panic(todo("", p.pos(x), x.Case)) - } - case *cc.UnaryExpression: - switch x.Case { - case cc.UnaryExpressionPostfix: // PostfixExpression - return p.detectArray(f, x.PostfixExpression, pinnedOk, recursiveOk, out) - case - cc.UnaryExpressionDeref, // '*' CastExpression - cc.UnaryExpressionAddrof: // '&' CastExpression - - return p.detectArray(f, x.CastExpression, pinnedOk, recursiveOk, out) - case - cc.UnaryExpressionSizeofExpr, // "sizeof" UnaryExpression - cc.UnaryExpressionSizeofType, // "sizeof" '(' TypeName ')' - cc.UnaryExpressionMinus, // '-' CastExpression - cc.UnaryExpressionCpl, // '~' CastExpression - cc.UnaryExpressionAlignofExpr, // "_Alignof" UnaryExpression - cc.UnaryExpressionAlignofType, // "_Alignof" '(' TypeName ')' - cc.UnaryExpressionNot, // '!' CastExpression - cc.UnaryExpressionInc, // "++" UnaryExpression - cc.UnaryExpressionDec, // "--" UnaryExpression - cc.UnaryExpressionPlus: // '+' CastExpression - - return false - default: - panic(todo("", p.pos(x), x.Case)) - } - case *cc.PostfixExpression: - switch x.Case { - case cc.PostfixExpressionPrimary: // PrimaryExpression - return p.detectArray(f, x.PrimaryExpression, pinnedOk, recursiveOk, out) - case cc.PostfixExpressionIndex: // PostfixExpression '[' Expression ']' - return recursiveOk && p.detectArray(f, x.PostfixExpression, pinnedOk, recursiveOk, out) - case - cc.PostfixExpressionSelect, // PostfixExpression '.' IDENTIFIER - cc.PostfixExpressionDec, // PostfixExpression "--" - cc.PostfixExpressionInc, // PostfixExpression "++" - cc.PostfixExpressionCall, // PostfixExpression '(' ArgumentExpressionList ')' - cc.PostfixExpressionComplit, // '(' TypeName ')' '{' InitializerList ',' '}' - cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER - - return false - default: - panic(todo("", p.pos(x), x.Case)) - } - case *cc.PrimaryExpression: - switch x.Case { - case - cc.PrimaryExpressionString, // STRINGLITERAL - cc.PrimaryExpressionEnum, // ENUMCONST - cc.PrimaryExpressionChar, // CHARCONST - cc.PrimaryExpressionLChar, // LONGCHARCONST - cc.PrimaryExpressionLString, // LONGSTRINGLITERAL - cc.PrimaryExpressionFloat, // FLOATCONST - cc.PrimaryExpressionInt: // INTCONST - - return false - case cc.PrimaryExpressionIdent: // IDENTIFIER - d := x.Declarator() - if d == nil || d.IsParameter { - return false - } - - if d.Type().Kind() != cc.Array { - return false - } - - if d.Type().IsVLA() { - return false - } - - if pinnedOk { - if out != nil { - *out = d - } - return true - } - - local := f.locals[d] - if local == nil || local.isPinned { - return false - } - - if out != nil { - *out = d - } - return true - case cc.PrimaryExpressionExpr: // '(' Expression ')' - return p.detectArray(f, x.Expression, pinnedOk, recursiveOk, out) - case cc.PrimaryExpressionStmt: // '(' CompoundStatement ')' - p.err(x, "statement expressions not supported") - return false - default: - panic(todo("", p.pos(x), x.Case)) - } - case *cc.Expression: - switch x.Case { - case cc.ExpressionAssign: // AssignmentExpression - return p.detectArray(f, x.AssignmentExpression, pinnedOk, recursiveOk, out) - case cc.ExpressionComma: // Expression ',' AssignmentExpression - return p.detectArray(f, x.Expression, pinnedOk, recursiveOk, out) || p.detectArray(f, x.AssignmentExpression, pinnedOk, recursiveOk, out) - default: - panic(todo("", p.pos(x), x.Case)) - } - default: - panic(todo("%T", x)) - } -} - -func (p *project) isArray(f *function, n declarator, t cc.Type) (r bool) { - if t.Kind() != cc.Array { - return false - } - - if t.IsVLA() { - return false - } - - if f == nil { - return true - } - - if d := n.Declarator(); d != nil { - local := f.locals[d] - return !d.IsParameter && (local == nil || !local.isPinned) - } - - return p.detectArray(f, n.(cc.Node), false, true, nil) -} - -var home = os.Getenv("HOME") - -// Return n's position with path reduced to baseName(path) unless -// p.task.fullPathComments is true. -func (p *project) pos(n cc.Node) (r token.Position) { - if n == nil { - return r - } - - if r = token.Position(n.Position()); r.IsValid() { - switch { - case p.task.fullPathComments: - if strings.HasPrefix(r.Filename, home) { - r.Filename = "$HOME" + r.Filename[len(home):] - } - default: - r.Filename = filepath.Base(r.Filename) - } - } - return r -} - -// Return n's position with path reduced to baseName(path). -func pos(n cc.Node) (r token.Position) { - if n == nil { - return r - } - - r = token.Position(n.Position()) - if r.IsValid() { - r.Filename = filepath.Base(r.Filename) - } - return r -} - -func roundup(n, to uintptr) uintptr { - if r := n % to; r != 0 { - return n + to - r - } - - return n -} - -func (f *function) pin(n cc.Node, d *cc.Declarator) { - local := f.locals[d] - if local == nil || local.isPinned { - return - } - - local.isPinned = true - if oTracePin || f.project.task.tracePinning { - fmt.Printf("%v: %s at %v: is pinned (%v)\n", n.Position(), d.Name(), d.Position(), origin(2)) - } - local.off = roundup(f.off, uintptr(d.Type().Align())) - f.off = local.off + paramTypeDecay(d).Size() -} - -func paramTypeDecay(d *cc.Declarator) (r cc.Type) { - r = d.Type() - if d.IsParameter && r.Kind() == cc.Array { - r = r.Decay() - } - return r -} - -func (f *function) layoutBlocks(n *cc.CompoundStatement) { - block := f.blocks[n] - type item struct { - ds *cc.DeclarationSpecifiers - d *cc.Declarator - } - var work []item - for _, v := range block.params { - if v.Type().Kind() == cc.Void { - break - } - - work = append(work, item{nil, v.Declarator()}) - } - for _, decl := range block.decls { - ds := decl.DeclarationSpecifiers - for list := decl.InitDeclaratorList; list != nil; list = list.InitDeclaratorList { - work = append(work, item{ds, list.InitDeclarator.Declarator}) - } - } - block.scope.take(cc.String(f.tlsName)) - if f.vaName != "" { - block.scope.take(cc.String(f.vaName)) - } - for _, item := range work { - d := item.d - if f.ignore[d] { - continue - } - - if !f.ignore[d] && d.IsStatic() { - continue - } - - if d.IsFunctionPrototype() || d.IsExtern() { - continue - } - - local := &local{forceRead: d.Read == 0} - if t := d.Type(); t != nil && t.Name() == idVaList { - local.forceRead = true - } - f.locals[d] = local - local.name = block.scope.take(d.Name()) - } -} - -func (f *function) layoutLocals(parent *block, n *cc.CompoundStatement, params []*cc.Parameter) { - block := newBlock(parent, n, n.Declarations(), params, f.project.newScope(), n.IsJumpTarget()) - f.blocks[n] = block - if parent == nil { - f.top = block - f.top.topDecl = f.hasJumps - } - for _, ch := range n.Children() { - f.layoutLocals(block, ch, nil) - if f.hasJumps { - chb := f.blocks[ch] - chb.noDecl = true - f.top.decls = append(f.top.decls, chb.decls...) - chb.decls = nil - } - } -} - -func newDeclarator(name string) *cc.Declarator { - return &cc.Declarator{ - DirectDeclarator: &cc.DirectDeclarator{ - Case: cc.DirectDeclaratorIdent, - Token: cc.Token{Rune: cc.IDENTIFIER, Value: cc.String(name)}, - }, - } -} - -type enumSpec struct { - decl *cc.Declaration - spec *cc.EnumSpecifier - - emitted bool -} - -func (n *enumSpec) emit(p *project) { - if n == nil || p.pass1 || n.emitted { - return - } - - n.emitted = true - ok := false - for list := n.spec.EnumeratorList; list != nil; list = list.EnumeratorList { - nm := list.Enumerator.Token.Value - if _, ok2 := p.emitedEnums[nm]; !ok2 && p.enumConsts[nm] != "" { - ok = true - break - } - } - if !ok { - return - } - - p.w("%s", tidyComment("\n", n.decl)) - p.w("const ( /* %v: */", p.pos(n.decl)) - for list := n.spec.EnumeratorList; list != nil; list = list.EnumeratorList { - en := list.Enumerator - nm := en.Token.Value - if _, ok := p.emitedEnums[nm]; ok || p.enumConsts[nm] == "" { - continue - } - - p.emitedEnums[nm] = struct{}{} - p.w("%s%s = ", tidyComment("\n", en), p.enumConsts[nm]) - p.intConst(en, "", en.Operand, en.Operand.Type(), fForceNoConv) - p.w(";") - } - p.w(");") -} - -type typedef struct { - sig uint64 - tld *tld -} - -type define struct { - name string - value cc.Value -} - -type project struct { - ast *cc.AST - buf bytes.Buffer - capi []string - defines map[cc.StringID]define - defineLines []string - emitedEnums map[cc.StringID]struct{} - enumConsts map[cc.StringID]string - enumSpecs map[*cc.EnumSpecifier]*enumSpec - errors scanner.ErrorList - externs map[cc.StringID]*tld - fn string - imports map[string]*imported // C name: import info - intType cc.Type - localTaggedStructs []func() - mainName string - ptrSize uintptr - ptrType cc.Type - scope scope - sharedFns map[*cc.FunctionDefinition]struct{} - sharedFnsEmitted map[*cc.FunctionDefinition]struct{} - staticQueue []*cc.InitDeclarator - structs map[cc.StringID]*taggedStruct // key: C tag - symtab map[string]interface{} // *tld or *imported - task *Task - tldScope scope - tlds map[*cc.Declarator]*tld - ts bytes.Buffer // Text segment - tsName string - tsNameP string - tsOffs map[cc.StringID]uintptr - tsW []rune // Text segment, wchar_t - tsWName string - tsWNameP string - tsWOffs map[cc.StringID]uintptr - typeSigHash maphash.Hash - typedefTypes map[cc.StringID]*typedef - typedefsEmited map[string]struct{} - verifyStructs map[string]cc.Type - wanted map[*cc.Declarator]struct{} - wcharSize uintptr - - isMain bool - pass1 bool - pauseCodegen bool -} - -func newProject(t *Task) (*project, error) { - voidType := t.cfg.ABI.Type(cc.Void) - ptrType := t.cfg.ABI.Ptr(nil, voidType) - intType := t.cfg.ABI.Type(cc.Int) - if intType.Size() != 4 { // We're assuming wchar_t is int32. - return nil, fmt.Errorf("unsupported C int size: %d", intType.Size()) - } - - if n := t.cfg.ABI.Types[cc.UChar].Size; n != 1 { - return nil, fmt.Errorf("unsupported C unsigned char size: %d", n) - } - - if n := t.cfg.ABI.Types[cc.UShort].Size; n != 2 { - return nil, fmt.Errorf("unsupported C unsigned short size: %d", n) - } - - if n := t.cfg.ABI.Types[cc.UInt].Size; n != 4 { - return nil, fmt.Errorf("unsupported C unsigned int size: %d", n) - } - - if n := t.cfg.ABI.Types[cc.ULongLong].Size; n != 8 { - return nil, fmt.Errorf("unsupported C unsigned long long size: %d", n) - } - - p := &project{ - defines: map[cc.StringID]define{}, - emitedEnums: map[cc.StringID]struct{}{}, - enumConsts: map[cc.StringID]string{}, - enumSpecs: map[*cc.EnumSpecifier]*enumSpec{}, - externs: map[cc.StringID]*tld{}, - imports: map[string]*imported{}, - intType: intType, - ptrSize: t.cfg.ABI.Types[cc.Ptr].Size, - ptrType: ptrType, - scope: newScope(), - sharedFns: t.cfg.SharedFunctionDefinitions.M, - sharedFnsEmitted: map[*cc.FunctionDefinition]struct{}{}, - symtab: map[string]interface{}{}, - task: t, - tlds: map[*cc.Declarator]*tld{}, - tsWOffs: map[cc.StringID]uintptr{}, - tsOffs: map[cc.StringID]uintptr{}, - typedefTypes: map[cc.StringID]*typedef{}, - typedefsEmited: map[string]struct{}{}, - verifyStructs: map[string]cc.Type{}, - wanted: map[*cc.Declarator]struct{}{}, - wcharSize: t.asts[0].WideCharType.Size(), - } - p.tldScope = p.scope - p.scope.take(idCAPI) - for _, v := range t.imported { - var err error - if v.name, v.exports, err = t.capi(v.path); err != nil { - return nil, err - } - - v.qualifier = p.scope.take(cc.String(v.name)) + "." - for k := range v.exports { - if p.imports[k] == nil { - p.imports[k] = v - } - } - } - p.tsNameP = p.scope.take(idTs) - p.tsName = p.scope.take(idTs) - p.tsWNameP = p.scope.take(idWtext) - p.tsWName = p.scope.take(idWtext) - if err := p.layout(); err != nil { - return nil, err - } - - return p, nil -} - -func (p *project) newScope() scope { - s := newScope() - var a []cc.StringID - for k := range p.structs { - a = append(a, k) - } - sort.Slice(a, func(i, j int) bool { return a[i].String() < a[j].String() }) - for _, k := range a { - s.take(cc.String(p.structs[k].name)) - } - return s -} - -func (p *project) err(n cc.Node, s string, args ...interface{}) { - if p.task.errTrace || strings.Contains(s, "internal error") { - s = s + "(" + origin(2) + ")" - } - if p.task.traceTranslationUnits { - trc("%v: error: %s (%v)", pos(n), fmt.Sprintf(s, args...), origin(2)) - } - if !p.task.allErrors && len(p.errors) >= 10 { - return - } - - switch { - case n == nil: - p.errors.Add(token.Position{}, fmt.Sprintf(s, args...)) - default: - p.errors.Add(token.Position(n.Position()), fmt.Sprintf(s, args...)) - if !p.task.allErrors && len(p.errors) == 10 { - p.errors.Add(token.Position(n.Position()), tooManyErrors) - } - } -} - -func (p *project) o(s string, args ...interface{}) { - if oTraceG { - fmt.Printf(s, args...) - } - fmt.Fprintf(p.task.out, s, args...) -} - -func (p *project) w(s string, args ...interface{}) { - if p.pass1 || p.pauseCodegen { - return - } - - if coverExperiment { - pc, _, _, ok := runtime.Caller(1) - if ok { - coverMap[pc] = struct{}{} - } - } - if oTraceW { - fmt.Printf(s, args...) - } - //fmt.Fprintf(&p.buf, "/* %s */", origin(2)) //TODO- - fmt.Fprintf(&p.buf, s, args...) -} - -func (p *project) layout() error { - if err := p.layoutTLDs(); err != nil { - return err - } - - if err := p.layoutSymtab(); err != nil { - return err - } - - if err := p.layoutStructs(); err != nil { - return err - } - - if err := p.layoutEnums(); err != nil { - return err - } - - if err := p.layoutDefines(); err != nil { - return err - } - - return p.layoutStaticLocals() -} - -func (p *project) layoutSymtab() error { - var t0 time.Time - if p.task.traceTranslationUnits { - fmt.Printf("processing symbol table ... ") - t0 = time.Now() - defer func() { fmt.Println(time.Since(t0)) }() - } - - for _, i := range p.task.symSearchOrder { - switch { - case i < 0: - imported := p.task.imported[-i-1] - for nm := range imported.exports { - if _, ok := p.symtab[nm]; !ok { - p.symtab[nm] = imported - } - } - default: - ast := p.task.asts[i] - for d := range ast.TLD { - if d.IsFunctionPrototype() || d.Linkage != cc.External { - continue - } - - nm := d.Name() - name := nm.String() - if _, ok := p.symtab[name]; !ok { - tld := p.externs[nm] - if tld == nil { - if d.Type().Kind() != cc.Function && !p.task.header { - p.err(d, "back-end: undefined: %s %v %v", d.Name(), d.Type(), d.Type().Kind()) - } - continue - } - - p.symtab[name] = tld - } - } - } - } - return nil -} - -func (p *project) layoutDefines() error { - if !p.task.exportDefinesValid { - return nil - } - - var t0 time.Time - if p.task.traceTranslationUnits { - fmt.Printf("processing #defines ... ") - t0 = time.Now() - defer func() { fmt.Println(time.Since(t0)) }() - } - - var prefix = p.task.exportDefines - taken := map[cc.StringID]struct{}{} - for _, ast := range p.task.asts { - var a []cc.StringID - for nm, m := range ast.Macros { - if m.IsFnLike() { - continue - } - - if strings.HasPrefix(nm.String(), "__") { - continue - } - - if _, ok := taken[nm]; ok { - continue - } - - taken[nm] = struct{}{} - a = append(a, nm) - } - sort.Slice(a, func(i, j int) bool { return a[i].String() < a[j].String() }) - for _, nm := range a { - m := ast.Macros[nm] - val, src := evalMacro(m, ast) - if src == "" { - continue - } - - name := nm.String() - switch { - case prefix == "": - name = capitalize(name) - default: - name = prefix + name - } - name = p.scope.take(cc.String(name)) - p.defines[nm] = define{name, val} - p.defineLines = append(p.defineLines, fmt.Sprintf("%s = %s // %v:", name, src, p.pos(m))) - } - } - return nil -} - -func evalMacro(m *cc.Macro, ast *cc.AST) (cc.Value, string) { - toks := m.ReplacementTokens() - if len(toks) != 1 { - return evalMacro2(m, ast) - } - - src := strings.TrimSpace(toks[0].Src.String()) - if len(src) == 0 { - return nil, "" - } - - neg := "" - switch src[0] { - case '"': - if _, err := strconv.Unquote(src); err == nil { - return cc.StringValue(cc.String(src)), src - } - case '-': - neg = "-" - src = src[1:] - fallthrough - default: - src = strings.TrimRight(src, "lLuU") - if u64, err := strconv.ParseUint(src, 0, 64); err == nil { - switch { - case neg == "": - return cc.Uint64Value(u64), src - default: - return cc.Int64Value(-u64), neg + src - } - } - - src = strings.TrimRight(src, "fF") - if f64, err := strconv.ParseFloat(src, 64); err == nil { - return cc.Float64Value(f64), neg + src - } - } - - return evalMacro2(m, ast) -} - -func evalMacro2(m *cc.Macro, ast *cc.AST) (cc.Value, string) { - op, err := ast.Eval(m) - if err != nil { - return nil, "" - } - - switch x := op.Value().(type) { - case cc.Int64Value: - return op.Value(), fmt.Sprintf("%d", int64(x)) - case cc.Uint64Value: - return op.Value(), fmt.Sprintf("%d", uint64(x)) - default: - panic(todo("", pos(m))) - } -} - -func (p *project) layoutEnums() error { - var t0 time.Time - if p.task.traceTranslationUnits { - fmt.Printf("processing enum values ... ") - t0 = time.Now() - defer func() { fmt.Println(time.Since(t0)) }() - } - - export := doNotChange - if p.task.exportEnumsValid { - switch { - case p.task.exportEnums != "": - export = exportPrefix - default: - export = exportCapitalize - } - } else if p.task.defaultUnExport { - export = doNotExport - } - - var enumList []*cc.EnumSpecifier - for _, v := range p.task.asts { - for list := v.TranslationUnit; list != nil; list = list.TranslationUnit { - decl := list.ExternalDeclaration - switch decl.Case { - case cc.ExternalDeclarationDecl: // Declaration - // ok - default: - continue - } - - cc.Inspect(decl.Declaration.DeclarationSpecifiers, func(n cc.Node, entry bool) bool { - if !entry { - return true - } - - x, ok := n.(*cc.EnumSpecifier) - if !ok || x.Case != cc.EnumSpecifierDef { - return true - } - - if _, ok := p.enumSpecs[x]; !ok { - enumList = append(enumList, x) - p.enumSpecs[x] = &enumSpec{decl: decl.Declaration, spec: x} - } - return true - }) - } - } - - vals := map[cc.StringID]interface{}{} - for _, v := range enumList { - for list := v.EnumeratorList; list != nil; list = list.EnumeratorList { - en := list.Enumerator - nm := en.Token.Value - var val int64 - switch x := en.Operand.Value().(type) { - case cc.Int64Value: - val = int64(x) - case cc.Uint64Value: - val = int64(x) - default: - panic(todo("")) - } - switch ex, ok := vals[nm]; { - case ok: - switch { - case ex == nil: // - continue - case ex == val: // same name and same value - continue - default: // same name, different value - vals[nm] = nil - } - default: - vals[nm] = val - } - p.enumConsts[nm] = "" - } - } - var a []cc.StringID - for nm := range p.enumConsts { - if val, ok := vals[nm]; ok && val == nil { - delete(p.enumConsts, nm) - continue - } - - a = append(a, nm) - } - sort.Slice(a, func(i, j int) bool { return a[i].String() < a[j].String() }) - for _, nm := range a { - name := nm.String() - switch export { - case doNotExport: - name = unCapitalize(name) - case doNotChange: - // nop - case exportCapitalize: - name = capitalize(name) - case exportPrefix: - name = p.task.exportEnums + name - } - name = p.scope.take(cc.String(name)) - p.enumConsts[nm] = name - } - return nil -} - -func (p *project) layoutStaticLocals() error { - var t0 time.Time - if p.task.traceTranslationUnits { - fmt.Printf("processing static local declarations ... ") - t0 = time.Now() - defer func() { fmt.Println(time.Since(t0)) }() - } - for _, v := range p.task.asts { - for list := v.TranslationUnit; list != nil; list = list.TranslationUnit { - decl := list.ExternalDeclaration - switch decl.Case { - case cc.ExternalDeclarationFuncDef: // FunctionDefinition - // ok - default: - continue - } - - cc.Inspect(decl.FunctionDefinition.CompoundStatement, func(n cc.Node, entry bool) bool { - switch x := n.(type) { - case *cc.Declarator: - if !entry || !x.IsStatic() || x.Read == 0 || x.IsParameter { - break - } - - nm := x.Name() - if s := p.task.staticLocalsPrefix; s != "" { - nm = cc.String(s + nm.String()) - } - p.tlds[x] = &tld{name: p.scope.take(nm)} - } - return true - }) - } - } - return nil -} - -func (p *project) layoutStructs() error { - var t0 time.Time - if p.task.traceTranslationUnits { - fmt.Printf("processing struct/union types ... ") - t0 = time.Now() - defer func() { fmt.Println(time.Since(t0)) }() - } - - export := doNotChange - if p.task.exportStructsValid { - switch { - case p.task.exportStructs != "": - export = exportPrefix - default: - export = exportCapitalize - } - } else if p.task.defaultUnExport { - export = doNotExport - } - - m := map[cc.StringID]*taggedStruct{} - var tags []cc.StringID - for _, v := range p.task.asts { - cc.Inspect(v.TranslationUnit, func(n cc.Node, entry bool) bool { - if entry { - switch x := n.(type) { - case *cc.Declarator: - if nm := x.Name().String(); strings.HasPrefix(nm, "_") { - break - } - - p.captureStructTags(x, x.Type(), m, &tags) - case *cc.Declaration: - cc.Inspect(x.DeclarationSpecifiers, func(nn cc.Node, entry bool) bool { - switch y := nn.(type) { - case *cc.StructOrUnionSpecifier: - if tag := y.Token.Value; tag != 0 { - p.captureStructTags(y, y.Type(), m, &tags) - } - } - return true - }) - } - } - return true - }) - } - sort.Slice(tags, func(i, j int) bool { return tags[i].String() < tags[j].String() }) - for _, k := range tags { - v := m[k] - //TODO rename conflicts - if v.conflicts { - delete(m, k) - continue - } - - name := k.String() - switch export { - case doNotExport: - name = unCapitalize(name) - case doNotChange: - // nop - case exportCapitalize: - name = capitalize(name) - case exportPrefix: - name = p.task.exportStructs + name - } - v.name = p.scope.take(cc.String(name)) - } - for _, k := range tags { - v := m[k] - if v != nil { - v.gotyp = p.structType(nil, v.ctyp) - } - } - p.structs = m - return nil -} - -func (p *project) captureStructTags(n cc.Node, t cc.Type, m map[cc.StringID]*taggedStruct, tags *[]cc.StringID) { - if t == nil { - return - } - - t = t.Alias() - for t.Kind() == cc.Ptr { - t = t.Alias().Elem().Alias() - } - if t.Kind() == cc.Invalid || t.IsIncomplete() { - return - } - - switch t.Kind() { - case cc.Struct, cc.Union: - tag := t.Tag() - if tag == 0 { - return - } - - ex := m[tag] - if ex != nil { - ts := p.typeSignature(n, t) - exs := p.typeSignature(n, ex.ctyp) - if ts != exs { - ex.conflicts = true - } - return - } - - nf := t.NumField() - m[tag] = &taggedStruct{ctyp: t, node: n} - for idx := []int{0}; idx[0] < nf; idx[0]++ { - p.captureStructTags(n, t.FieldByIndex(idx).Type(), m, tags) - } - *tags = append(*tags, tag) - case cc.Array: - p.captureStructTags(n, t.Elem(), m, tags) - } -} - -func (p *project) typeSignature(n cc.Node, t cc.Type) (r uint64) { - p.typeSigHash.Reset() - p.typeSignature2(n, &p.typeSigHash, t) - return p.typeSigHash.Sum64() -} - -func (p *project) typeSignature2(n cc.Node, b *maphash.Hash, t cc.Type) { - t = t.Alias() - if t.IsIntegerType() { - if !t.IsSignedType() { - b.WriteByte('u') - } - fmt.Fprintf(b, "int%d", t.Size()*8) - return - } - - if t.IsArithmeticType() { - b.WriteString(t.Kind().String()) - return - } - - structOrUnion := "struct" - switch t.Kind() { - case cc.Ptr: - fmt.Fprintf(b, "*%s", t.Elem()) - case cc.Array: - if t.IsVLA() { - // trc("VLA") - p.err(n, "variable length arrays not supported: %v", t) - } - - fmt.Fprintf(b, "[%d]%s", t.Len(), t.Elem()) - case cc.Vector: - fmt.Fprintf(b, "[%d]%s", t.Len(), t.Elem()) - case cc.Union: - structOrUnion = "union" - fallthrough - case cc.Struct: - b.WriteString(structOrUnion) - nf := t.NumField() - fmt.Fprintf(b, " %d{", nf) - b.WriteByte('{') - for idx := []int{0}; idx[0] < nf; idx[0]++ { - f := t.FieldByIndex(idx) - fmt.Fprintf(b, "%s:%d:%d:%v:%d:%d:", - f.Name(), f.BitFieldOffset(), f.BitFieldWidth(), f.IsBitField(), f.Offset(), f.Padding(), - ) - p.typeSignature2(f.Declarator(), b, f.Type()) - b.WriteByte(';') - } - b.WriteByte('}') - case cc.Void: - b.WriteString("void") - case cc.Invalid: - b.WriteString("invalid") //TODO fix cc/v3 - default: - panic(todo("", p.pos(n), t, t.Kind())) - } -} - -func (p *project) structType(n cc.Node, t cc.Type) string { - switch t.Kind() { - case cc.Struct, cc.Union: - tag := t.Tag() - if tag != 0 && p.structs != nil { - s := p.structs[tag] - if s == nil { - return p.structLiteral(n, t) - } - - if s.gotyp == "" { - s.gotyp = p.structLiteral(n, t) - } - return s.gotyp - } - - return p.structLiteral(n, t) - default: - panic(todo("internal error: %v", t.Kind())) - } -} - -func (p *project) padName(n *int) string { - if !p.task.exportFieldsValid { - return "_" - } - - *n++ - return fmt.Sprintf("%s__ccgo_pad%d", p.task.exportFields, *n) -} - -func (p *project) structLiteral(n cc.Node, t cc.Type) string { - var npad int - b := bytesBufferPool.Get().(*bytes.Buffer) - defer func() { b.Reset(); bytesBufferPool.Put(b) }() - switch t.Kind() { - case cc.Struct: - info := cc.NewStructLayout(t) - // trc("%v: %q\n%s", p.pos(n), t.Tag(), info) - b.WriteString("struct {") - if info.NeedExplicitAlign { - fmt.Fprintf(b, "%s [0]uint%d;", p.padName(&npad), 8*p.align(n, t)) - } - var max uintptr - for _, off := range info.Offsets { - flds := info.OffsetToFields[off] - if off < max { - var a []string - var nmf cc.Field - for _, f := range flds { - if f.Name() != 0 && nmf == nil { - nmf = f - } - if !f.IsBitField() { - panic(todo("internal error %q, off %v max %v\n%s", f.Name(), off, max, info)) - } - a = append(a, fmt.Sprintf("%s %s: %d", f.Type(), f.Name(), f.BitFieldWidth())) - } - fmt.Fprintf(b, "/* %s */", strings.Join(a, ", ")) - continue - } - - f := flds[0] - switch pad := info.PaddingsBefore[f]; { - case pad < 0: - continue - case pad > 0: - fmt.Fprintf(b, "%s [%d]byte;", p.padName(&npad), pad) - } - switch { - case f.IsBitField(): - max += uintptr(f.BitFieldBlockWidth()) >> 3 - var a []string - var nmf cc.Field - for _, f := range flds { - if f.Name() != 0 && nmf == nil { - nmf = f - } - if !f.IsBitField() { - panic(todo("internal error %q\n%s", f.Name(), info)) - } - a = append(a, fmt.Sprintf("%s %s: %d", f.Type(), f.Name(), f.BitFieldWidth())) - } - if nmf == nil { - nmf = f - } - fmt.Fprintf(b, "%s uint%d /* %s */;", p.bitFieldName(n, nmf), f.BitFieldBlockWidth(), strings.Join(a, ", ")) - default: - ft := f.Type() - if ft.Kind() == cc.Array && ft.IsIncomplete() || ft.Size() == 0 { - break - } - - max += ft.Size() - fmt.Fprintf(b, "%s %s;", p.fieldName2(n, f), p.typ(n, ft)) - } - } - if info.PaddingAfter != 0 { - fmt.Fprintf(b, "%s [%d]byte;", p.padName(&npad), info.PaddingAfter) - } - b.WriteByte('}') - case cc.Union: - b.WriteString("struct {") - info := cc.NewStructLayout(t) - if info.NeedExplicitAlign { - fmt.Fprintf(b, "%s [0]uint%d;", p.padName(&npad), 8*p.align(n, t)) - } - al := uintptr(t.Align()) - sz := t.Size() - if al > sz { - panic(todo("", p.pos(n))) - } - - f := t.FieldByIndex([]int{0}) - ft := f.Type() - al0 := ft.Align() - if f.IsBitField() { - al0 = f.BitFieldBlockWidth() >> 3 - } - if al != uintptr(al0) { - fmt.Fprintf(b, "%s [0]uint%d;", p.padName(&npad), 8*al) - } - fsz := ft.Size() - switch { - case f.IsBitField(): - fmt.Fprintf(b, "%s ", p.fieldName2(n, f)) - fmt.Fprintf(b, "uint%d;", f.BitFieldBlockWidth()) - fsz = uintptr(f.BitFieldBlockWidth()) >> 3 - default: - fmt.Fprintf(b, "%s %s;", p.fieldName2(n, f), p.typ(n, ft)) - } - if pad := sz - fsz; pad != 0 { - fmt.Fprintf(b, "%s [%d]byte;", p.padName(&npad), pad) - } - b.WriteByte('}') - default: - panic(todo("internal error: %v", t.Kind())) - } - r := b.String() - if p.task.verifyStructs { - if _, ok := p.verifyStructs[r]; !ok { - p.verifyStructs[r] = t - } - } - return r -} - -func (p *project) align(nd cc.Node, t cc.Type) int { - switch n := t.Align(); { - case n <= 1: - return 1 - case n <= 2: - return 2 - case n <= 4: - return 4 - case n <= 8: - return 8 - default: - if !p.task.ignoreUnsupportedAligment { - p.err(nd, "unsupported alignment of type %s: %v", t, n) - } - return 8 - } -} - -func (p *project) bitFieldName(n cc.Node, f cc.Field) string { - if id := f.Name(); id != 0 { - return p.fieldName(n, id) - } - - return fmt.Sprintf("__%d", f.Offset()) -} - -func (p *project) fieldName2(n cc.Node, f cc.Field) string { - if f.Name() != 0 { - return p.fieldName(n, f.Name()) - } - - return p.fieldName(n, cc.String(fmt.Sprintf("__%d", f.Offset()))) -} - -func (p *project) fieldName(n cc.Node, id cc.StringID) string { - if id == 0 { - panic(todo("", p.pos(n))) - } - - if !p.task.exportFieldsValid { - s := id.String() - if p.task.defaultUnExport { - s = unCapitalize(s) - } - - if !reservedNames[s] { - return s - } - - return "__" + s - } - - if s := p.task.exportFields; s != "" { - return s + id.String() - } - - return capitalize(id.String()) -} - -func (p *project) dtyp(d *cc.Declarator) (r string) { - t := d.Type() - if t.IsIncomplete() { - if t.Kind() == cc.Array && d.IsParameter { - return "uintptr" - } - - panic(todo("")) - } - - return p.typ(d, t) -} - -func (p *project) typ(nd cc.Node, t cc.Type) (r string) { - if t.IsIncomplete() { - panic(todo("", p.pos(nd), t)) - } - - if t.IsAliasType() { - if tld := p.tlds[t.AliasDeclarator()]; tld != nil { - return tld.name - } - } - - b := bytesBufferPool.Get().(*bytes.Buffer) - defer func() { b.Reset(); bytesBufferPool.Put(b) }() - if t.IsIntegerType() { - switch t.Kind() { - case cc.Int128: - fmt.Fprintf(b, "%sInt128", p.task.crt) - return b.String() - case cc.UInt128: - fmt.Fprintf(b, "%sUint128", p.task.crt) - return b.String() - } - - if !t.IsSignedType() { - b.WriteByte('u') - } - if t.Size() > 8 { - p.err(nd, "unsupported C type: %v", t) - } - fmt.Fprintf(b, "int%d", 8*t.Size()) - return b.String() - } - - switch t.Kind() { - case cc.Ptr, cc.Function: - return "uintptr" - case cc.Double: - return "float64" - case cc.Float: - return "float32" - case cc.Array: - n := t.Len() - switch { - case t.IsVLA(): - fmt.Fprintf(b, "uintptr") - default: - fmt.Fprintf(b, "[%d]%s", n, p.typ(nd, t.Elem())) - } - return b.String() - case cc.Vector: - n := t.Len() - fmt.Fprintf(b, "[%d]%s", n, p.typ(nd, t.Elem())) - return b.String() - case cc.Struct, cc.Union: - if tag := t.Tag(); tag != 0 { - if s := p.structs[tag]; s != nil { - if s.name == "" { - panic(todo("internal error %q", tag)) - } - - return s.name - } - } - - return p.structType(nd, t) - } - - panic(todo("", p.pos(nd), t.Kind(), t)) -} - -func isScalarKind(k cc.Kind) bool { - switch k { - case - cc.Char, cc.SChar, cc.UChar, - cc.Short, cc.UShort, - cc.Int, cc.UInt, - cc.Long, cc.ULong, - cc.LongLong, cc.ULongLong, - cc.Float, cc.Double, - cc.Ptr: - - return true - } - - return false -} - -func (p *project) layoutTLDs() error { - var t0 time.Time - if p.task.traceTranslationUnits { - fmt.Printf("processing file scope declarations ... ") - t0 = time.Now() - defer func() { fmt.Println(time.Since(t0)) }() - } - - exportExtern, exportTypedef := doNotChange, doNotChange - if p.task.exportExternsValid { - switch { - case p.task.exportExterns != "": - exportExtern = exportPrefix - default: - exportExtern = exportCapitalize - } - } else if p.task.defaultUnExport { - exportExtern = doNotExport - } - - if p.task.exportTypedefsValid { - switch { - case p.task.exportTypedefs != "": - exportTypedef = exportPrefix - default: - exportTypedef = exportCapitalize - } - } else if p.task.defaultUnExport { - exportTypedef = doNotExport - } - - var a []*cc.Declarator - if p.task.pkgName == "" || p.task.pkgName == "main" { - out: - for _, ast := range p.task.asts { - if a := ast.Scope[idMain]; len(a) != 0 { - switch x := a[0].(type) { - case *cc.Declarator: - if x.Linkage == cc.External { - p.isMain = true - p.scope.take(idMain) - break out - } - } - } - } - } - sharedFns := map[*cc.FunctionDefinition]struct{}{} - for _, ast := range p.task.asts { - a = a[:0] - for d := range ast.TLD { - if d.IsFunctionPrototype() { - continue - } - - // https://gcc.gnu.org/onlinedocs/gcc/Inline.html - // - // If you specify both inline and extern in the function definition, then the - // definition is used only for inlining. In no case is the function compiled on - // its own, not even if you refer to its address explicitly. Such an address - // becomes an external reference, as if you had only declared the function, and - // had not defined it. - // - // This combination of inline and extern has almost the effect of a macro. The - // way to use it is to put a function definition in a header file with these - // keywords, and put another copy of the definition (lacking inline and extern) - // in a library file. The definition in the header file causes most calls to - // the function to be inlined. If any uses of the function remain, they refer - // to the single copy in the library. - if d.IsExtern() && d.Type().Inline() { - continue - } - - if fn := d.FunctionDefinition(); fn != nil { - if _, ok := p.sharedFns[fn]; ok { - if _, ok := sharedFns[fn]; ok { - continue - } - - sharedFns[fn] = struct{}{} - } - } - - a = append(a, d) - p.wanted[d] = struct{}{} - } - sort.Slice(a, func(i, j int) bool { - return a[i].NameTok().Seq() < a[j].NameTok().Seq() - }) - for _, d := range a { - switch d.Type().Kind() { - case cc.Struct, cc.Union: - p.checkAttributes(d.Type()) - } - nm := d.Name() - name := nm.String() - - switch d.Linkage { - case cc.External: - if ex := p.externs[nm]; ex != nil { - if _, ok := p.task.hide[name]; ok { - break - } - - if d.Type().Kind() != cc.Function { - break - } - - p.err(d, "redeclared: %s", d.Name()) - break - } - - isMain := p.isMain && nm == idMain - switch exportExtern { - case doNotExport: - name = unCapitalize(name) - case doNotChange: - // nop - case exportCapitalize: - name = capitalize(name) - case exportPrefix: - name = p.task.exportExterns + name - } - name = p.scope.take(cc.String(name)) - if isMain { - p.mainName = name - d.Read++ - } - tld := &tld{name: name} - p.externs[nm] = tld - for _, v := range ast.Scope[nm] { - if d, ok := v.(*cc.Declarator); ok { - p.tlds[d] = tld - } - } - if !isMain { - p.capi = append(p.capi, d.Name().String()) - } - case cc.Internal: - if token.IsExported(name) && !p.isMain && p.task.exportExternsValid { - name = "s" + name - } - tld := &tld{name: p.scope.take(cc.String(name))} - for _, v := range ast.Scope[nm] { - if d, ok := v.(*cc.Declarator); ok { - p.tlds[d] = tld - } - } - case cc.None: - if d.IsTypedefName { - if d.Type().IsIncomplete() { - break - } - - if exportTypedef == doNotChange && strings.HasPrefix(name, "__") { - break - } - - ex, ok := p.typedefTypes[d.Name()] - if ok { - sig := p.typeSignature(d, d.Type()) - if ex.sig == sig { - tld := ex.tld - for _, v := range ast.Scope[nm] { - if d, ok := v.(*cc.Declarator); ok { - p.tlds[d] = tld - } - } - break - } - } - - switch exportTypedef { - case doNotExport: - name = unCapitalize(name) - case doNotChange: - // nop - case exportCapitalize: - name = capitalize(name) - case exportPrefix: - name = p.task.exportTypedefs + name - } - - tld := &tld{name: p.scope.take(cc.String(name))} - p.typedefTypes[d.Name()] = &typedef{p.typeSignature(d, d.Type()), tld} - for _, v := range ast.Scope[nm] { - if d, ok := v.(*cc.Declarator); ok { - p.tlds[d] = tld - } - } - } - default: - panic(todo("", p.pos(d), nm, d.Linkage)) - } - } - } - for _, ast := range p.task.asts { - for list := ast.TranslationUnit; list != nil; list = list.TranslationUnit { - decl := list.ExternalDeclaration - switch decl.Case { - case cc.ExternalDeclarationFuncDef: // FunctionDefinition - // ok - default: - continue - } - - cc.Inspect(decl.FunctionDefinition.CompoundStatement, func(n cc.Node, entry bool) bool { - switch x := n.(type) { - case *cc.Declarator: - if x.IsFunctionPrototype() { - nm := x.Name() - if extern := p.externs[nm]; extern != nil { - break - } - - tld := &tld{name: nm.String()} - for _, nd := range ast.Scope[nm] { - if d, ok := nd.(*cc.Declarator); ok { - p.tlds[d] = tld - } - } - } - - } - return true - }) - } - } - return nil -} - -func (p *project) checkAttributes(t cc.Type) (r bool) { - r = true - for _, v := range t.Attributes() { - cc.Inspect(v, func(n cc.Node, entry bool) bool { - if !entry { - return true - } - - switch x := n.(type) { - case *cc.AttributeValue: - if x.Token.Value != idAligned { - break - } - - //TODO switch v := x.ExpressionList.AssignmentExpression.Operand.Value().(type) { - //TODO default: - //TODO panic(todo("%T(%v)", v, v)) - //TODO } - } - return true - }) - } - switch t.Kind() { - case cc.Struct, cc.Union: - for i := []int{0}; i[0] < t.NumField(); i[0]++ { - f := t.FieldByIndex(i) - if !p.checkAttributes(f.Type()) { - return false - } - - sd := f.Declarator() - if sd == nil { - continue - } - - cc.Inspect(sd.StructDeclaration().SpecifierQualifierList, func(n cc.Node, entry bool) bool { - if !entry { - return true - } - - switch x := n.(type) { - case *cc.AttributeValue: - if x.Token.Value == idPacked { - p.err(sd, "unsupported attribute: packed") - r = false - return false - } - - if x.Token.Value != idAligned { - break - } - - switch v := x.ExpressionList.AssignmentExpression.Operand.Value().(type) { - case cc.Int64Value: - if int(v) != t.Align() { - p.err(sd, "unsupported attribute: alignment") - r = false - return false - } - default: - panic(todo("%T(%v)", v, v)) - } - } - return true - }) - if !r { - return false - } - } - } - return r -} - -func unCapitalize(s string) string { - if strings.HasPrefix(s, "_") { - return s - } - a := []rune(s) - return strings.ToLower(string(a[0])) + string(a[1:]) -} - -func capitalize(s string) string { - if strings.HasPrefix(s, "_") { - s = "X" + s - } - a := []rune(s) - return strings.ToUpper(string(a[0])) + string(a[1:]) -} - -func (p *project) main() error { - targs := append([]string(nil), p.task.args...) - for i, v := range targs { - if v == "" { - targs[i] = `""` - } - } - p.o(`// Code generated by '%s %s', DO NOT EDIT. - -package %s - -`, - filepath.Base(p.task.args[0]), - strings.Join(targs[1:], " "), - p.task.pkgName, - ) - if len(p.defineLines) != 0 { - p.w("\nconst (") - p.w("%s", strings.Join(p.defineLines, "\n")) - p.w("\n)\n\n") - } - var a []*enumSpec - for _, es := range p.enumSpecs { - if es.spec.LexicalScope().Parent() == nil && !es.emitted { - a = append(a, es) - } - } - sort.Slice(a, func(i, j int) bool { - return a[i].decl.Position().String() < a[j].decl.Position().String() - }) - for _, es := range a { - es.emit(p) - } - for i, v := range p.task.asts { - var t0 time.Time - if p.task.traceTranslationUnits { - fmt.Printf("Go back end %v/%v: %s ... ", i+1, len(p.task.asts), filepath.Base(p.task.sources[i].Name)) - t0 = time.Now() - } - p.oneAST(v) - if p.task.traceTranslationUnits { - fmt.Println(time.Since(t0)) - } - p.task.asts[i] = nil - memGuard(i, p.task.isScripted) - } - sort.Slice(p.task.imported, func(i, j int) bool { return p.task.imported[i].path < p.task.imported[j].path }) - p.o(`import ( - "math" - "reflect" - "sync/atomic" - "unsafe" -`) - if len(p.verifyStructs) != 0 { - p.o("\t\"fmt\"\n") - } - first := true - libc := false - for _, v := range p.task.imported { - if v.used { - if v.path == p.task.crtImportPath { - libc = true - } - if first { - p.o("\n") - first = false - } - p.o("\t%q\n", v.path) - } - } - if p.task.crtImportPath != "" { - if !libc { - p.o("\t%q\n", p.task.crtImportPath) - } - p.o("\t%q\n", p.task.crtImportPath+"/sys/types") - } - p.o(`) - -var _ = math.Pi -var _ reflect.Kind -var _ atomic.Value -var _ unsafe.Pointer -`) - if p.task.crtImportPath != "" { - if libc { - p.o("var _ *libc.TLS\n") - } - p.o("var _ types.Size_t\n") - } - if p.isMain { - p.o(` -func main() { %sStart(%s) }`, p.task.crt, p.mainName) - } - p.flushStructs() - p.initPatches() - p.flushTS() - if !p.task.noCapi { - p.flushCAPI() - } - p.doVerifyStructs() - if err := p.Err(); err != nil { - return err - } - - if _, err := p.buf.WriteTo(p.task.out); err != nil { - return err - } - - return p.Err() -} - -func (p *project) doVerifyStructs() { - if len(p.verifyStructs) == 0 { - return - } - - var a []string - for k := range p.verifyStructs { - a = append(a, k) - } - sort.Strings(a) - p.w("\n\nfunc init() {") - n := 0 - for _, k := range a { - t := p.verifyStructs[k] - p.w("\nvar v%d %s", n, k) - p.w("\nif g, e := unsafe.Sizeof(v%d), uintptr(%d); g != e { panic(fmt.Sprintf(`invalid struct/union size, got %%v, expected %%v`, g, e))}", n, t.Size()) - nf := t.NumField() - for idx := []int{0}; idx[0] < nf; idx[0]++ { - f := t.FieldByIndex(idx) - if f.IsFlexible() { - break - } - - if f.IsBitField() || f.Type().Size() == 0 { - continue - } - - nm := p.fieldName2(f.Declarator(), f) - switch { - case t.Kind() == cc.Union: - if f.Offset() != 0 { - panic(todo("")) - } - - if idx[0] != 0 { - break - } - - fallthrough - default: - p.w("\nif g, e := unsafe.Offsetof(v%d.%s), uintptr(%d); g != e { panic(fmt.Sprintf(`invalid struct/union field offset, got %%v, expected %%v`, g, e))}", n, nm, f.Offset()) - p.w("\nif g, e := unsafe.Sizeof(v%d.%s), uintptr(%d); g != e { panic(fmt.Sprintf(`invalid struct/union field size, got %%v, expected %%v`, g, e))}", n, nm, f.Type().Size()) - } - } - n++ - } - p.w("\n}\n") -} - -func (p *project) flushCAPI() { - if p.isMain { - return - } - - b := bytes.NewBuffer(nil) - fmt.Fprintf(b, `// Code generated by '%s %s', DO NOT EDIT. - -package %s - -`, - filepath.Base(p.task.args[0]), - strings.Join(p.task.args[1:], " "), - p.task.pkgName, - ) - fmt.Fprintf(b, "\n\nvar CAPI = map[string]struct{}{") - sort.Strings(p.capi) - for _, nm := range p.capi { - fmt.Fprintf(b, "\n%q: {},", nm) - } - fmt.Fprintf(b, "\n}\n") - if err := ioutil.WriteFile(p.task.capif, b.Bytes(), 0644); err != nil { - p.err(nil, "%v", err) - return - } - - if out, err := exec.Command("gofmt", "-r", "(x) -> x", "-l", "-s", "-w", p.task.capif).CombinedOutput(); err != nil { - p.err(nil, "%s: %v", out, err) - } - - if out, err := exec.Command("gofmt", "-l", "-s", "-w", p.task.capif).CombinedOutput(); err != nil { - p.err(nil, "%s: %v", out, err) - } -} - -func (p *project) initPatches() { - var tlds []*tld - for _, tld := range p.tlds { - if len(tld.patches) != 0 { - tlds = append(tlds, tld) - } - } - if len(tlds) == 0 { - return - } - - sort.Slice(tlds, func(i, j int) bool { return tlds[i].name < tlds[j].name }) - p.w("\n\nfunc init() {") - for _, tld := range tlds { - for _, patch := range tld.patches { - var fld string - if patch.fld != nil { - fld = fmt.Sprintf("/* .%s */", patch.fld.Name()) - } - init := patch.init - expr := init.AssignmentExpression - d := expr.Declarator() - switch { - case d != nil && d.Type().Kind() == cc.Function: - p.w("\n*(*") - p.functionSignature(d, nil, d.Type(), "") - p.w(")(unsafe.Pointer(uintptr(unsafe.Pointer(&%s))+%d%s)) = ", tld.name, init.Offset, fld) - p.declarator(init, nil, d, d.Type(), exprFunc, 0) - default: - p.w("\n*(*%s)(unsafe.Pointer(uintptr(unsafe.Pointer(&%s))+%d%s)) = ", p.typ(init, patch.t), tld.name, init.Offset, fld) - p.assignmentExpression(nil, expr, patch.t, exprValue, 0) - } - p.w("// %s:", p.pos(init)) - } - } - p.w("\n}\n") -} - -func (p *project) Err() error { - if len(p.errors) == 0 { - return nil - } - - var lpos token.Position - w := 0 - for _, v := range p.errors { - if lpos.Filename != "" { - if v.Pos.Filename == lpos.Filename && v.Pos.Line == lpos.Line && !strings.HasPrefix(v.Msg, tooManyErrors) { - continue - } - } - - p.errors[w] = v - w++ - lpos = v.Pos - } - p.errors = p.errors[:w] - sort.Slice(p.errors, func(i, j int) bool { - a := p.errors[i] - if a.Msg == tooManyErrors { - return false - } - - b := p.errors[j] - if b.Msg == tooManyErrors { - return true - } - - if !a.Pos.IsValid() && b.Pos.IsValid() { - return true - } - - if a.Pos.IsValid() && !b.Pos.IsValid() { - return false - } - - if a.Pos.Filename < b.Pos.Filename { - return true - } - - if a.Pos.Filename > b.Pos.Filename { - return false - } - - if a.Pos.Line < b.Pos.Line { - return true - } - - if a.Pos.Line > b.Pos.Line { - return false - } - - return a.Pos.Column < b.Pos.Column - }) - a := make([]string, 0, len(p.errors)) - for _, v := range p.errors { - a = append(a, v.Error()) - } - return fmt.Errorf("%s", strings.Join(a, "\n")) -} - -func (p *project) flushTS() { - b := p.ts.Bytes() - if len(b) != 0 { - p.w("\n\n") - //TODO add cmd line option for this - //TODO s := strings.TrimSpace(hex.Dump(b)) - //TODO a := strings.Split(s, "\n") - //TODO p.w("// %s\n", strings.Join(a, "\n// ")) - p.w("var %s = %q\n", p.tsName, b) - p.w("var %s = (*reflect.StringHeader)(unsafe.Pointer(&%s)).Data\n", p.tsNameP, p.tsName) - } - if len(p.tsW) != 0 { - p.w("var %s = [...]%s{", p.tsWName, p.typ(nil, p.ast.WideCharType)) - for _, v := range p.tsW { - p.w("%d, ", v) - } - p.w("}\n") - p.w("var %s = uintptr(unsafe.Pointer(&%s[0]))\n", p.tsWNameP, p.tsWName) - } -} - -func (p *project) flushStructs() { - var a []*taggedStruct - for _, v := range p.structs { - if !v.emitted { - a = append(a, v) - } - } - sort.Slice(a, func(i, j int) bool { return a[i].name < a[j].name }) - for _, v := range a { - v.emit(p, nil) - } -} - -func (p *project) oneAST(ast *cc.AST) { - p.ast = ast - for list := ast.TranslationUnit; list != nil; list = list.TranslationUnit { - p.externalDeclaration(list.ExternalDeclaration) - } - p.w("%s", tidyCommentString(ast.TrailingSeperator.String())) -} - -func (p *project) externalDeclaration(n *cc.ExternalDeclaration) { - switch n.Case { - case cc.ExternalDeclarationFuncDef: // FunctionDefinition - p.functionDefinition(n.FunctionDefinition) - case cc.ExternalDeclarationDecl: // Declaration - p.declaration(nil, n.Declaration, false) - case cc.ExternalDeclarationAsm: // AsmFunctionDefinition - // nop - case cc.ExternalDeclarationAsmStmt: // AsmStatement - panic(todo("", p.pos(n))) - case cc.ExternalDeclarationEmpty: // ';' - // nop - case cc.ExternalDeclarationPragma: // PragmaSTDC - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) declaration(f *function, n *cc.Declaration, topDecl bool) { - cc.Inspect(n.DeclarationSpecifiers, func(m cc.Node, entry bool) bool { - switch x := m.(type) { - case *cc.EnumSpecifier: - if f == nil { - p.enumSpecs[x].emit(p) - } - case *cc.StructOrUnionSpecifier: - if tag := x.Token.Value; tag != 0 { - switch { - case f == nil: - p.structs[tag].emit(p, n.DeclarationSpecifiers) - default: - p.localTaggedStructs = append(p.localTaggedStructs, func() { - p.structs[tag].emit(p, n.DeclarationSpecifiers) - }) - } - } - } - return true - }) - - if n.InitDeclaratorList == nil { - return - } - - // DeclarationSpecifiers InitDeclaratorList ';' - sep := tidyComment("\n", n) //TODO repeats - for list := n.InitDeclaratorList; list != nil; list = list.InitDeclaratorList { - p.initDeclarator(f, list.InitDeclarator, sep, topDecl) - sep = "\n" - } -} - -func (p *project) initDeclarator(f *function, n *cc.InitDeclarator, sep string, topDecl bool) { - if f == nil { - p.tld(f, n, sep, false) - return - } - - d := n.Declarator - if d.IsExtern() || d.IsTypedefName { - return - } - - if tld := p.tlds[d]; tld != nil && !topDecl { // static local - if !p.pass1 { - p.staticQueue = append(p.staticQueue, n) - } - return - } - - local := f.locals[d] - if local == nil { // Dead declaration. - return - } - - block := f.block - t := d.Type() - vla := t.Kind() == cc.Array && t.IsVLA() - if vla && p.pass1 { - f.vlas[d] = struct{}{} - return - } - - switch n.Case { - case cc.InitDeclaratorDecl: // Declarator AttributeSpecifierList - if block.noDecl || block.topDecl && !topDecl { - return - } - - switch { - case vla: - p.initDeclaratorDeclVLA(f, n, sep) - default: - p.initDeclaratorDecl(f, n, sep) - } - case cc.InitDeclaratorInit: // Declarator AttributeSpecifierList '=' Initializer - if vla { - panic(todo("")) - } - - if f.block.topDecl { - switch { - case topDecl: - p.initDeclaratorDecl(f, n, sep) - if local.forceRead && !local.isPinned { - p.w("_ = %s;", local.name) - } - default: - sv := f.condInitPrefix - f.condInitPrefix = func() { - p.declarator(d, f, d, d.Type(), exprLValue, 0) - p.w(" = ") - } - switch { - case p.isConditionalInitializer(n.Initializer): - p.assignmentExpression(f, n.Initializer.AssignmentExpression, d.Type(), exprCondInit, 0) - default: - f.condInitPrefix() - p.initializer(f, n.Initializer, d.Type(), d.StorageClass, nil) - } - f.condInitPrefix = sv - p.w(";") - } - return - } - - p.w("%s", sep) - switch { - case local.isPinned: - sv := f.condInitPrefix - f.condInitPrefix = func() { - //TODO- p.declarator(d, f, d, d.Type(), exprLValue, 0) - //TODO- p.w(" = ") - p.w("*(*%s)(unsafe.Pointer(%s%s/* %s */)) = ", p.typ(n, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name) - } - switch { - case p.isConditionalInitializer(n.Initializer): - p.assignmentExpression(f, n.Initializer.AssignmentExpression, d.Type(), exprCondInit, 0) - default: - f.condInitPrefix() - p.initializer(f, n.Initializer, d.Type(), d.StorageClass, nil) - p.w(";") - } - f.condInitPrefix = sv - p.w(";") - default: - var semi string - switch { - case block.noDecl: - semi = "" - default: - p.w("var %s ", local.name) - if !isAggregateTypeOrUnion(d.Type()) { - p.w("%s ", p.typ(n, d.Type())) - } - semi = ";" - } - switch { - case p.isConditionalInitializer(n.Initializer): - p.w("%s", semi) - sv := f.condInitPrefix - f.condInitPrefix = func() { p.w("%s = ", local.name) } - p.assignmentExpression(f, n.Initializer.AssignmentExpression, d.Type(), exprCondInit, 0) - f.condInitPrefix = sv - default: - if block.noDecl { - p.w("%s", local.name) - } - p.w(" = ") - p.initializer(f, n.Initializer, d.Type(), d.StorageClass, nil) - } - p.w(";") - } - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } - if !block.noDecl && local.forceRead && !local.isPinned { - p.w("_ = %s;", local.name) - } -} - -func (p *project) isConditionalInitializer(n *cc.Initializer) bool { - return n.Case == cc.InitializerExpr && p.isConditionalAssignmentExpr(n.AssignmentExpression) -} - -func (p *project) isConditionalAssignmentExpr(n *cc.AssignmentExpression) bool { - return n.Case == cc.AssignmentExpressionCond && - n.ConditionalExpression.Case == cc.ConditionalExpressionCond -} - -func (p *project) initDeclaratorDeclVLA(f *function, n *cc.InitDeclarator, sep string) { - d := n.Declarator - local := f.locals[d] - if strings.TrimSpace(sep) == "" { - sep = "\n" - } - if local.isPinned { - panic(todo("")) - p.w("%s// var %s %s at %s%s, %d\n", sep, local.name, p.typ(n, d.Type()), f.bpName, nonZeroUintptr(local.off), d.Type().Size()) - return - } - - p.w("%s%s = %sXrealloc(%s, %s, types.Size_t(", sep, local.name, p.task.crt, f.tlsName, local.name) - e := d.Type().LenExpr() - p.assignmentExpression(f, e, e.Operand.Type(), exprValue, 0) - if sz := d.Type().Elem().Size(); sz != 1 { - p.w("*%d", sz) - } - p.w("));") -} - -func (p *project) initDeclaratorDecl(f *function, n *cc.InitDeclarator, sep string) { - d := n.Declarator - local := f.locals[d] - if strings.TrimSpace(sep) == "" { - sep = "\n" - } - if local.isPinned { - p.w("%s// var %s %s at %s%s, %d\n", sep, local.name, p.typ(n, d.Type()), f.bpName, nonZeroUintptr(local.off), d.Type().Size()) - return - } - - p.w("%svar %s %s;", sep, local.name, p.typ(n, d.Type())) -} - -func (p *project) declarator(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprLValue: - p.declaratorLValue(n, f, d, t, mode, flags) - case exprFunc: - p.declaratorFunc(n, f, d, t, mode, flags) - case exprValue: - p.declaratorValue(n, f, d, t, mode, flags) - case exprAddrOf: - p.declaratorAddrOf(n, f, d, t, flags) - case exprSelect: - p.declaratorSelect(n, f, d) - case exprDecay: - p.declaratorDecay(n, f, d, t, mode, flags) - default: - panic(todo("", mode)) - } -} - -func (p *project) declaratorDecay(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) { - if d.Type().Kind() != cc.Array { - panic(todo("", n.Position(), p.pos(d))) - } - - if f != nil { - if local := f.locals[d]; local != nil { - if d.Type().IsVLA() { - switch { - case local.isPinned: - panic(todo("")) - default: - p.w("%s", local.name) - return - } - } - - if d.IsParameter { - p.w("%s", local.name) - return - } - - if p.pass1 { - if !d.Type().IsVLA() { - f.pin(n, d) - } - return - } - - if !local.isPinned { - p.err(n, "%v: %v: missed pinning", n.Position(), d.Position(), d.Name()) - } - p.w("(%s%s)/* &%s[0] */", f.bpName, nonZeroUintptr(local.off), local.name) - return - } - } - - if x := p.tlds[d]; x != nil && d.IsStatic() { - p.w("uintptr(unsafe.Pointer(&%s))", x.name) - return - } - - switch x := p.symtab[d.Name().String()].(type) { - case *tld: - p.w("uintptr(unsafe.Pointer(&%s))", x.name) - case *imported: - x.used = true - p.w("uintptr(unsafe.Pointer(&%sX%s))", x.qualifier, d.Name()) - default: - panic(todo("%v: %v: %q %T", n.Position(), p.pos(d), d.Name(), x)) - } -} - -func (p *project) declaratorValue(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) { - switch k := p.declaratorKind(d); k { - case opNormal: - p.declaratorValueNormal(n, f, d, t, mode, flags) - case opArray: - p.declaratorValueArray(n, f, d, t, mode, flags) - case opFunction: - p.declarator(n, f, d, t, exprAddrOf, flags) - case opUnion: - p.declaratorValueUnion(n, f, d, t, mode, flags) - case opArrayParameter: - p.declaratorValueArrayParameter(n, f, d, t, mode, flags) - default: - panic(todo("", d.Position(), k)) - } -} - -func (p *project) declaratorValueArrayParameter(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) { - if d.Type().IsScalarType() { - defer p.w("%s", p.convertType(n, d.Type(), t, flags)) - } - local := f.locals[d] - if local.isPinned { - p.w("*(*%s)(unsafe.Pointer(%s%s/* %s */))", p.typ(n, paramTypeDecay(d)), f.bpName, nonZeroUintptr(local.off), local.name) - return - } - - p.w("%s", local.name) -} - -func (p *project) declaratorValueUnion(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) { - if d.Type().IsScalarType() { - defer p.w("%s", p.convertType(n, d.Type(), t, flags)) - } - if f != nil { - if local := f.locals[d]; local != nil { - if local.isPinned { - p.w("*(*%s)(unsafe.Pointer(%s%s/* %s */))", p.typ(d, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name) - return - } - - p.w("%s", local.name) - return - } - } - - p.declaratorDefault(n, d) -} - -func (p *project) isVolatileOrAtomic(d *cc.Declarator) bool { - if d.Type().IsVolatile() || d.Type().IsAtomic() { - return true - } - - _, ok := p.task.volatiles[d.Name()] - return ok -} - -func (p *project) declaratorDefault(n cc.Node, d *cc.Declarator) { - if x := p.tlds[d]; x != nil && d.IsStatic() { - if p.isVolatileOrAtomic(d) { - p.atomicLoadNamedAddr(n, d.Type(), x.name) - return - } - - p.w("%s", x.name) - return - } - - switch x := p.symtab[d.Name().String()].(type) { - case *tld: - if p.isVolatileOrAtomic(d) { - p.atomicLoadNamedAddr(n, d.Type(), x.name) - return - } - - p.w("%s", x.name) - case *imported: - x.used = true - if p.isVolatileOrAtomic(d) { - p.atomicLoadNamedAddr(n, d.Type(), fmt.Sprintf("%sX%s", x.qualifier, d.Name())) - return - } - - p.w("%sX%s", x.qualifier, d.Name()) - default: - if d.IsExtern() { - switch d.Name() { - case idEnviron: - if d.Type().String() == "pointer to pointer to char" { - p.w("%sEnviron()", p.task.crt) - return - } - } - } - - if d.Linkage == cc.External && p.task.nostdlib { - p.w("X%s", d.Name()) - return - } - - id := fmt.Sprintf("__builtin_%s", d.Name()) - switch x := p.symtab[id].(type) { - case *imported: - x.used = true - p.w("%sX%s", x.qualifier, d.Name()) - return - } - - if !d.IsImplicit() { - nm := d.Name() - name := nm.String() - switch d.Linkage { - case cc.External: - name = p.task.exportExterns + name - tld := &tld{name: name} - p.externs[nm] = tld - p.w("%s", name) - return - case cc.Internal: - if token.IsExported(name) { - name = "s" + name - } - tld := &tld{name: p.scope.take(cc.String(name))} - for _, v := range p.ast.Scope[nm] { - if d, ok := v.(*cc.Declarator); ok { - p.tlds[d] = tld - } - } - p.w("%s", name) - return - } - } - - p.err(n, "back-end: undefined: %s", d.Name()) - } -} - -func (p *project) declaratorValueArray(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) { - if t.IsIntegerType() { - defer p.w("%s", p.convertType(n, nil, t, flags)) - } - if f != nil { - if local := f.locals[d]; local != nil { - if local.isPinned { - p.w("(%s%s)/* %s */", f.bpName, nonZeroUintptr(local.off), local.name) - return - } - - p.w("%s", local.name) - return - } - } - - p.declaratorDefault(n, d) -} - -func (p *project) declaratorValueNormal(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) { - if d.Type().IsScalarType() { - defer p.w("%s", p.convertType(n, d.Type(), t, flags)) - } - if f != nil { - if local := f.locals[d]; local != nil { - if local.isPinned { - if p.isVolatileOrAtomic(d) && d.IsParameter && d.Write != 0 { - p.w("%sAtomicLoadP%s(%s%s/* %s */)", p.task.crt, p.helperType(n, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name) - return - } - - p.w("*(*%s)(unsafe.Pointer(%s%s/* %s */))", p.typ(d, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name) - return - } - - if p.isVolatileOrAtomic(d) && d.IsParameter && d.Write != 0 { - p.atomicLoadNamedAddr(n, d.Type(), local.name) - return - } - - p.w("%s", local.name) - return - } - } - - p.declaratorDefault(n, d) -} - -func (p *project) declaratorFunc(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) { - switch k := p.declaratorKind(d); k { - case opFunction: - p.declaratorFuncFunc(n, f, d, t, exprValue, flags) - case opNormal: - p.declaratorFuncNormal(n, f, d, t, exprValue, flags) - default: - panic(todo("", d.Position(), k)) - } -} - -func (p *project) declaratorFuncNormal(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) { - u := d.Type() - if u.Kind() == cc.Ptr { - u = u.Elem() - } - switch u.Kind() { - case cc.Function: - if local := f.locals[d]; local != nil { - if local.isPinned { - p.w("(*(*") - p.functionSignature(n, f, u, "") - p.w(")(unsafe.Pointer(%s%s)))", f.bpName, nonZeroUintptr(local.off)) - return - } - - if d.IsParameter { - p.w("(*(*") - p.functionSignature(n, f, u, "") - p.w(")(unsafe.Pointer(&%s)))", local.name) - return - } - - panic(todo("", p.pos(d))) - } - - if x := p.tlds[d]; x != nil && d.IsStatic() { - p.w("(*(*") - p.functionSignature(n, f, u, "") - p.w(")(unsafe.Pointer(&%s)))", x.name) - return - } - - switch x := p.symtab[d.Name().String()].(type) { - case *tld: - p.w("(*(*") - p.functionSignature(n, f, u, "") - p.w(")(unsafe.Pointer(&%s)))", x.name) - case *imported: - x.used = true - p.w("uintptr(unsafe.Pointer(&%sX%s))", x.qualifier, d.Name()) - default: - panic(todo("%v: %v: %q", n.Position(), p.pos(d), d.Name())) - } - default: - panic(todo("", p.pos(d), u)) - } -} - -func (p *project) declaratorFuncFunc(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) { - switch d.Type().Kind() { - case cc.Function: - // ok - default: - panic(todo("", p.pos(d), d.Type(), d.Type().Kind())) - } - - if f != nil { - if local := f.locals[d]; local != nil { - if local.isPinned { - panic(todo("")) - } - - p.w(" %s", local.name) - return - } - } - - p.declaratorDefault(n, d) -} - -func (p *project) declaratorLValue(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) { - switch k := p.declaratorKind(d); k { - case opNormal, opArrayParameter, opUnion: - p.declaratorLValueNormal(n, f, d, t, mode, flags) - case opArray: - p.declaratorLValueArray(n, f, d, t, mode, flags) - default: - panic(todo("", d.Position(), k)) - } -} - -func (p *project) declaratorLValueArray(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) { - if f != nil { - if local := f.locals[d]; local != nil { - if local.isPinned { - p.w("*(*%s)(unsafe.Pointer(%s%s/* %s */))", p.typ(d, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name) - return - } - - p.w("%s", local.name) - return - } - } - - p.declaratorDefault(n, d) -} - -func (p *project) declaratorLValueNormal(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) { - if p.isVolatileOrAtomic(d) { - panic(todo("", n.Position(), d.Position())) - } - - if d.Type().IsScalarType() { - defer p.w("%s", p.convertType(n, d.Type(), t, flags)) - } - if f != nil { - if local := f.locals[d]; local != nil { - if local.isPinned { - p.w("*(*%s)(unsafe.Pointer(%s%s/* %s */))", p.dtyp(d), f.bpName, nonZeroUintptr(local.off), local.name) - return - } - - p.w("%s", local.name) - return - } - } - - p.declaratorLValueDefault(n, d) -} - -func (p *project) declaratorLValueDefault(n cc.Node, d *cc.Declarator) { - if x := p.tlds[d]; x != nil && d.IsStatic() { - p.w("%s", x.name) - return - } - - switch x := p.symtab[d.Name().String()].(type) { - case *tld: - p.w("%s", x.name) - case *imported: - x.used = true - p.w("%sX%s", x.qualifier, d.Name()) - default: - if d.IsExtern() { - switch d.Name() { - case idEnviron: - if d.Type().String() == "pointer to pointer to char" { - p.w("*(*uintptr)(unsafe.Pointer(%sEnvironP()))", p.task.crt) - return - } - } - } - - panic(todo("%v: %v: %q", n.Position(), p.pos(d), d.Name())) - } -} - -func (p *project) declaratorKind(d *cc.Declarator) opKind { - switch { - case p.isArrayParameterDeclarator(d): - return opArrayParameter - case !p.pass1 && p.isArrayDeclarator(d): - return opArray - case d.Type().Kind() == cc.Function && !d.IsParameter: - return opFunction - case d.Type().Kind() == cc.Union: - return opUnion - default: - return opNormal - } -} - -func (p *project) declaratorSelect(n cc.Node, f *function, d *cc.Declarator) { - switch k := p.declaratorKind(d); k { - case opNormal: - p.declaratorSelectNormal(n, f, d) - case opArray: - p.declaratorSelectArray(n, f, d) - default: - panic(todo("", d.Position(), k)) - } -} - -func (p *project) declaratorSelectArray(n cc.Node, f *function, d *cc.Declarator) { - if local := f.locals[d]; local != nil { - if local.isPinned { - panic(todo("", p.pos(n))) - //TODO type error - p.w("(*%s)(unsafe.Pointer(%s%s/* &%s */))", p.typ(d, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name) - return - } - - p.w("%s", local.name) - return - } - - p.declaratorDefault(n, d) -} - -func (p *project) declaratorSelectNormal(n cc.Node, f *function, d *cc.Declarator) { - if local := f.locals[d]; local != nil { - if local.isPinned { - p.w("(*%s)(unsafe.Pointer(%s%s/* &%s */))", p.typ(d, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name) - return - } - - p.w("%s", local.name) - return - } - - p.declaratorDefault(n, d) -} - -func (p *project) declaratorAddrOf(n cc.Node, f *function, d *cc.Declarator, t cc.Type, flags flags) { - switch k := p.declaratorKind(d); k { - case opArray: - p.declaratorAddrOfArray(n, f, d) - case opNormal: - p.declaratorAddrOfNormal(n, f, d, flags) - case opUnion: - p.declaratorAddrOfUnion(n, f, d) - case opFunction: - p.declaratorAddrOfFunction(n, f, d) - case opArrayParameter: - p.declaratorAddrOfArrayParameter(n, f, d) - default: - panic(todo("", d.Position(), k)) - } -} - -func (p *project) declaratorAddrOfArrayParameter(n cc.Node, f *function, d *cc.Declarator) { - if p.pass1 { - f.pin(n, d) - return - } - - local := f.locals[d] - p.w("(%s%s)/* &%s */", f.bpName, nonZeroUintptr(local.off), local.name) -} - -func (p *project) declaratorAddrOfFunction(n cc.Node, f *function, d *cc.Declarator) { - if d.Type().Kind() != cc.Function { - panic(todo("", p.pos(n))) - } - - if x := p.tlds[d]; x != nil && d.IsStatic() { - p.w("*(*uintptr)(unsafe.Pointer(&struct{f ") - p.functionSignature(n, f, d.Type(), "") - p.w("}{%s}))", x.name) - return - } - - switch x := p.symtab[d.Name().String()].(type) { - case *tld: - p.w("*(*uintptr)(unsafe.Pointer(&struct{f ") - p.functionSignature(n, f, d.Type(), "") - p.w("}{%s}))", x.name) - case *imported: - x.used = true - p.w("*(*uintptr)(unsafe.Pointer(&struct{f ") - p.functionSignature(n, f, d.Type(), "") - p.w("}{%sX%s}))", x.qualifier, d.Name()) - default: - p.err(d, "back-end: undefined: %s", d.Name()) - } -} - -func (p *project) declaratorAddrOfUnion(n cc.Node, f *function, d *cc.Declarator) { - if f != nil { - if local := f.locals[d]; local != nil { - if p.pass1 { - f.pin(n, d) - return - } - - if local.isPinned { - p.w("(%s%s)/* &%s */", f.bpName, nonZeroUintptr(local.off), local.name) - return - } - - panic(todo("", p.pos(n))) - } - } - - if x := p.tlds[d]; x != nil && d.IsStatic() { - p.w("uintptr(unsafe.Pointer(&%s))", x.name) - return - } - - switch x := p.symtab[d.Name().String()].(type) { - case *tld: - p.w("uintptr(unsafe.Pointer(&%s))", x.name) - case *imported: - x.used = true - p.w("uintptr(unsafe.Pointer(&%sX%s))", x.qualifier, d.Name()) - default: - panic(todo("%v: %v: %q", n.Position(), p.pos(d), d.Name())) - } -} - -func (p *project) declaratorAddrOfNormal(n cc.Node, f *function, d *cc.Declarator, flags flags) { - if f != nil { - if local := f.locals[d]; local != nil { - if p.pass1 && flags&fAddrOfFuncPtrOk == 0 { - f.pin(n, d) - return - } - - if local.isPinned { - p.w("(%s%s)/* &%s */", f.bpName, nonZeroUintptr(local.off), local.name) - return - } - - if flags&fAddrOfFuncPtrOk != 0 { - if dt := d.Type(); dt.Kind() == cc.Ptr { - if elem := dt.Elem(); elem.Kind() == cc.Function || elem.Kind() == cc.Ptr && elem.Elem().Kind() == cc.Function { - p.w("&%s", local.name) - return - } - } - } - - panic(todo("", p.pos(n), p.pos(d), d.Name(), d.Type(), d.IsParameter, d.AddressTaken, flags&fAddrOfFuncPtrOk != 0)) - } - } - - if x := p.tlds[d]; x != nil && d.IsStatic() { - p.w("uintptr(unsafe.Pointer(&%s))", x.name) - return - } - - switch x := p.symtab[d.Name().String()].(type) { - case *tld: - p.w("uintptr(unsafe.Pointer(&%s))", x.name) - case *imported: - x.used = true - p.w("uintptr(unsafe.Pointer(&%sX%s))", x.qualifier, d.Name()) - default: - p.err(n, "undefined: %s", d.Name()) - } -} - -func (p *project) declaratorAddrOfArray(n cc.Node, f *function, d *cc.Declarator) { - if f != nil { - if local := f.locals[d]; local != nil { - if p.pass1 { - f.pin(n, d) - return - } - - if local.isPinned { - p.w("(%s%s)/* &%s */", f.bpName, nonZeroUintptr(local.off), local.name) - return - } - - panic(todo("", p.pos(d), d.Name(), d.Type(), d.IsParameter)) - } - } - - if x := p.tlds[d]; x != nil && d.IsStatic() { - p.w("uintptr(unsafe.Pointer(&%s))", x.name) - return - } - - switch x := p.symtab[d.Name().String()].(type) { - case *tld: - p.w("uintptr(unsafe.Pointer(&%s))", x.name) - case *imported: - x.used = true - p.w("uintptr(unsafe.Pointer(&%sX%s))", x.qualifier, d.Name()) - default: - panic(todo("%v: %v: %q", n.Position(), p.pos(d), d.Name())) - } -} - -func (p *project) convertType(n cc.Node, from, to cc.Type, flags flags) string { - // trc("%v: %v: %v -> %v %v", n.Position(), origin(1), from, to, flags) //TODO- DBG - if from != nil { - switch from.Kind() { - case cc.Int128: - return p.convertTypeFromInt128(n, to, flags) - case cc.UInt128: - return p.convertTypeFromUint128(n, to, flags) - } - } - - switch to.Kind() { - case cc.Int128: - return p.convertTypeToInt128(n, from, flags) - case cc.UInt128: - return p.convertTypeToUint128(n, from, flags) - } - - // trc("%v: %v -> %v\n%s", p.pos(n), from, to, debug.Stack()[:600]) //TODO- - force := flags&fForceConv != 0 - if from == nil { - p.w("%s(", p.typ(n, to)) - return ")" - } - - if from.IsScalarType() { - switch { - case force: - p.w("%s(", p.helperType2(n, from, to)) - return ")" - case from.Kind() == to.Kind(): - return "" - default: - p.w("%s(", p.typ(n, to)) - return ")" - } - } - - switch from.Kind() { - case cc.Function, cc.Struct, cc.Union, cc.Ptr, cc.Array: - if from.Kind() == to.Kind() { - return "" - } - - panic(todo("", n.Position(), from, to, from.Alias(), to.Alias())) - case cc.Double, cc.Float: - p.w("%s(", p.typ(n, to)) - return ")" - } - - panic(todo("", n.Position(), from, to, from.Alias(), to.Alias())) -} - -func (p *project) convertTypeFromInt128(n cc.Node, to cc.Type, flags flags) string { - switch k := to.Kind(); { - case k == cc.Float, k == cc.Double: - p.w("(") - return fmt.Sprintf(").Float%d()", to.Size()*8) - case k == cc.Int128: - return "" - case k == cc.UInt128: - p.w("%sUint128FromInt128(", p.task.crt) - return ")" - case to.IsIntegerType() && to.IsSignedType(): - p.w("int%d((", to.Size()*8) - return ").Lo)" - case to.IsIntegerType() && !to.IsSignedType(): - p.w("uint%d((", to.Size()*8) - return ").Lo)" - default: - panic(todo("", n.Position(), to, to.Alias())) - } -} - -func (p *project) convertTypeFromUint128(n cc.Node, to cc.Type, flags flags) string { - switch k := to.Kind(); { - case k == cc.Float, k == cc.Double: - p.w("(") - return fmt.Sprintf(").Float%d()", to.Size()*8) - case k == cc.Int128: - p.w("(") - return ").Int128()" - case k == cc.UInt128: - return "" - case to.IsIntegerType() && to.IsSignedType(): - p.w("int%d((", to.Size()*8) - return ").Lo)" - case to.IsIntegerType() && !to.IsSignedType(): - p.w("uint%d((", to.Size()*8) - return ").Lo)" - default: - panic(todo("", n.Position(), to, to.Alias())) - } -} - -func (p *project) convertTypeToInt128(n cc.Node, from cc.Type, flags flags) string { - switch k := from.Kind(); { - case k == cc.Float, k == cc.Double: - p.w("%sInt128FromFloat%d(", p.task.crt, from.Size()*8) - return ")" - case k == cc.Int128: - return "" - case k == cc.UInt128: - p.w("%sInt128FromUint128(", p.task.crt) - return ")" - case from.IsIntegerType() && from.IsSignedType(): - p.w("%sInt128FromInt%d(", p.task.crt, from.Size()*8) - return ")" - case from.IsIntegerType() && !from.IsSignedType(): - p.w("%sInt128FromUint%d(", p.task.crt, from.Size()*8) - return ")" - default: - panic(todo("", n.Position(), from, from.Alias())) - } -} - -func (p *project) convertTypeToUint128(n cc.Node, from cc.Type, flags flags) string { - switch k := from.Kind(); { - case k == cc.Float, k == cc.Double: - p.w("%sUint128FromFloat%d(", p.task.crt, from.Size()*8) - return ")" - case k == cc.Int128: - p.w("(") - return ").Uint128()" - case k == cc.UInt128: - return "" - case from.IsIntegerType() && from.IsSignedType(): - p.w("%sUint128FromInt%d(", p.task.crt, from.Size()*8) - return ")" - case from.IsIntegerType() && !from.IsSignedType(): - p.w("%sUint128FromUint%d(", p.task.crt, from.Size()*8) - return ")" - default: - panic(todo("", n.Position(), from, from.Alias())) - } -} - -func (p *project) convertFromInt128(n cc.Node, op cc.Operand, to cc.Type, flags flags) string { - switch k := to.Kind(); { - case k == cc.Float, k == cc.Double: - p.w("(") - return fmt.Sprintf(").Float%d()", to.Size()*8) - case k == cc.Int128: - return "" - case k == cc.UInt128: - p.w("(") - return ").Uint128()" - case to.IsIntegerType() && to.IsSignedType(): - p.w("%sInt%d(", p.task.crt, to.Size()*8) - return ")" - case to.IsIntegerType() && !to.IsSignedType(): - p.w("%sUint%d(", p.task.crt, to.Size()*8) - return ")" - default: - panic(todo("", n.Position(), to, to.Alias())) - } -} - -func (p *project) convertFromUint128(n cc.Node, op cc.Operand, to cc.Type, flags flags) string { - switch k := to.Kind(); { - case k == cc.Float, k == cc.Double: - p.w("%sUint128FromFloat%d(", p.task.crt, to.Size()*8) - return ")" - case k == cc.Int128: - p.w("(") - return ").Int128()" - case k == cc.UInt128: - return "" - case to.IsIntegerType() && to.IsSignedType(): - p.w("%sInt%d(", p.task.crt, to.Size()*8) - return ")" - case to.IsIntegerType() && !to.IsSignedType(): - p.w("%sUint%d(", p.task.crt, to.Size()*8) - return ")" - default: - panic(todo("", n.Position(), to, to.Alias())) - } -} - -func (p *project) convertToInt128(n cc.Node, op cc.Operand, to cc.Type, flags flags) string { - from := op.Type() - switch k := from.Kind(); { - case k == cc.Float, k == cc.Double: - p.w("%sInt128FromFloat%d(", p.task.crt, from.Size()*8) - return ")" - case k == cc.Int128: - return "" - case k == cc.UInt128: - p.w("(") - return ").Int128()" - case from.IsIntegerType() && from.IsSignedType(): - p.w("%sInt128FromInt%d(", p.task.crt, from.Size()*8) - return ")" - case from.IsIntegerType() && !from.IsSignedType(): - p.w("%sInt128FromUint%d(", p.task.crt, from.Size()*8) - return ")" - default: - panic(todo("", n.Position(), from, from.Alias())) - } -} - -func (p *project) convertToUint128(n cc.Node, op cc.Operand, to cc.Type, flags flags) string { - from := op.Type() - switch k := from.Kind(); { - case k == cc.Float, k == cc.Double: - p.w("%sUint128FromFloat%d(", p.task.crt, from.Size()*8) - return ")" - case k == cc.Int128: - p.w("(") - return ").Uint128()" - case k == cc.UInt128: - return "" - case from.IsIntegerType() && from.IsSignedType(): - p.w("%sUint128FromInt%d(", p.task.crt, from.Size()*8) - return ")" - case from.IsIntegerType() && !from.IsSignedType(): - p.w("%sUint128FromUint%d(", p.task.crt, from.Size()*8) - return ")" - default: - panic(todo("", n.Position(), from, from.Alias())) - } -} - -func (p *project) convertNil(n cc.Node, to cc.Type, flags flags) string { - switch to.Kind() { - case cc.Int128: - panic(todo("", p.pos(n))) - case cc.UInt128: - panic(todo("", p.pos(n))) - } - - p.w("%s(", p.typ(n, to)) - return ")" -} - -func (p *project) convert(n cc.Node, op cc.Operand, to cc.Type, flags flags) string { - if op == nil { - panic(todo("internal error")) - } - - from := op.Type() - switch from.Kind() { - case cc.Int128: - return p.convertFromInt128(n, op, to, flags) - case cc.UInt128: - return p.convertFromUint128(n, op, to, flags) - } - switch to.Kind() { - case cc.Int128: - return p.convertToInt128(n, op, to, flags) - case cc.UInt128: - return p.convertToUint128(n, op, to, flags) - } - - if flags&fForceRuntimeConv != 0 { - flags |= fForceConv - } - force := flags&fForceConv != 0 - if !force && from.IsScalarType() && from.Kind() == to.Kind() { - return "" - } - - if from.IsIntegerType() { - return p.convertInt(n, op, to, flags) - } - - if from == to { - return "" - } - - switch from.Kind() { - case cc.Ptr: - if !force && from.Kind() == to.Kind() { - return "" - } - - if to.IsIntegerType() { - p.w("%s(", p.typ(n, to)) - return ")" - } - - if to.Kind() == cc.Ptr { - return "" - } - - panic(todo("%v: force %v, %q %v -> %q %v", p.pos(n), force, from, from.Kind(), to, to.Kind())) - case cc.Function, cc.Struct, cc.Union: - if !force && from.Kind() == to.Kind() { - return "" - } - - trc("%p %p", from, to) - panic(todo("%q %v -> %q %v", from, from.Kind(), to, to.Kind())) - case cc.Double, cc.Float: - switch { - case to.IsIntegerType(): - p.w("%s(", p.helperType2(n, from, to)) - return ")" - default: - p.w("%s(", p.typ(n, to)) - return ")" - } - case cc.Array: - if from.Kind() == to.Kind() { - return "" - } - - switch to.Kind() { - case cc.Ptr: - return "" - } - - panic(todo("%q, %v -> %q, %v", from, from.Kind(), to.Kind())) - } - - panic(todo("%q -> %q", from, to)) -} - -func (p *project) convertInt(n cc.Node, op cc.Operand, to cc.Type, flags flags) string { - from := op.Type() - switch from.Kind() { - case cc.Int128: - panic(todo("", p.pos(n))) - case cc.UInt128: - panic(todo("", p.pos(n))) - } - switch to.Kind() { - case cc.Int128: - panic(todo("", p.pos(n))) - case cc.UInt128: - panic(todo("", p.pos(n))) - } - - force := flags&fForceConv != 0 - value := op.Value() - if value == nil || !to.IsIntegerType() { - if to.IsScalarType() { - p.w("%s(", p.typ(n, to)) - return ")" - } - - panic(todo("", op.Type(), to)) - } - - if flags&fForceRuntimeConv != 0 { - p.w("%s(", p.helperType2(n, op.Type(), to)) - return ")" - } - - switch { - case from.IsSignedType(): - switch { - case to.IsSignedType(): - switch x := value.(type) { - case cc.Int64Value: - switch to.Size() { - case 1: - if x >= math.MinInt8 && x <= math.MaxInt8 { - switch { - case !force && from.Size() == to.Size(): - return "" - default: - p.w("int8(") - return ")" - } - } - - p.w("%sInt8FromInt%d(", p.task.crt, from.Size()*8) - return ")" - case 2: - if x >= math.MinInt16 && x <= math.MaxInt16 { - switch { - case !force && from.Size() == to.Size(): - return "" - default: - p.w("int16(") - return ")" - } - } - - p.w("%sInt16FromInt%d(", p.task.crt, from.Size()*8) - return ")" - case 4: - if x >= math.MinInt32 && x <= math.MaxInt32 { - switch { - case !force && from.Size() == to.Size(): - return "" - default: - p.w("int32(") - return ")" - } - } - - p.w("%sInt32FromInt%d(", p.task.crt, from.Size()*8) - return ")" - case 8: - switch { - case !force && from.Size() == to.Size(): - return "" - default: - p.w("int64(") - return ")" - } - default: - panic(todo("%T(%v) %v -> %v", x, op.Value(), from, to)) - } - default: - panic(todo("%T(%v) %v -> %v", x, op.Value(), from, to)) - } - default: // to is unsigned - switch x := value.(type) { - case cc.Int64Value: - switch to.Size() { - case 1: - if x >= 0 && x <= math.MaxUint8 { - p.w("%s(", p.typ(n, to)) - return ")" - } - - p.w("%sUint8FromInt%d(", p.task.crt, from.Size()*8) - return ")" - case 2: - if x >= 0 && x <= math.MaxUint16 { - p.w("%s(", p.typ(n, to)) - return ")" - } - - p.w("%sUint16FromInt%d(", p.task.crt, from.Size()*8) - return ")" - case 4: - if x >= 0 && x <= math.MaxUint32 { - p.w("%s(", p.typ(n, to)) - return ")" - } - - p.w("%sUint32FromInt%d(", p.task.crt, from.Size()*8) - return ")" - case 8: - if x >= 0 { - p.w("uint64(") - return ")" - } - - p.w("%sUint64FromInt%d(", p.task.crt, from.Size()*8) - return ")" - default: - panic(todo("%T(%v) %v -> %v", x, op.Value(), from, to)) - } - case cc.Uint64Value: - switch to.Size() { - case 1: - if x <= math.MaxUint8 { - p.w("%s(", p.typ(n, to)) - return ")" - } - - p.w("%sUint8FromUint%d(", p.task.crt, from.Size()*8) - return ")" - case 2: - if x <= math.MaxUint16 { - p.w("%s(", p.typ(n, to)) - return ")" - } - - p.w("%sUint16FromUint%d(", p.task.crt, from.Size()*8) - return ")" - case 4: - if x <= math.MaxUint32 { - p.w("%s(", p.typ(n, to)) - return ")" - } - - p.w("%sUint32FromUint%d(", p.task.crt, from.Size()*8) - return ")" - case 8: - p.w("uint64(") - return ")" - default: - panic(todo("%T(%v) %v -> %v", x, op.Value(), from, to)) - } - default: - panic(todo("%T(%v) %v -> %v", x, op.Value(), from, to)) - } - } - default: // from is unsigned - switch { - case to.IsSignedType(): - switch x := value.(type) { - case cc.Uint64Value: - switch to.Size() { - case 1: - if x <= math.MaxInt8 { - p.w("int8(") - return ")" - } - - p.w("%sInt8FromUint%d(", p.task.crt, from.Size()*8) - return ")" - case 2: - if x <= math.MaxInt16 { - p.w("int16(") - return ")" - } - - p.w("%sInt16FromUint%d(", p.task.crt, from.Size()*8) - return ")" - case 4: - if x <= math.MaxInt32 { - p.w("int32(") - return ")" - } - - p.w("%sInt32FromUint%d(", p.task.crt, from.Size()*8) - return ")" - case 8: - if x <= math.MaxInt64 { - p.w("int64(") - return ")" - } - - p.w("%sInt64FromUint%d(", p.task.crt, from.Size()*8) - return ")" - default: - panic(todo("%T(%v) %v -> %v", x, op.Value(), from, to)) - } - default: - panic(todo("%T(%v) %v -> %v", x, op.Value(), from, to)) - } - default: // to is unsigned - switch x := value.(type) { - case cc.Uint64Value: - switch to.Size() { - case 1: - if x <= math.MaxUint8 { - switch { - case !force && from.Size() == 1: - return "" - default: - p.w("uint8(") - return ")" - } - } - - p.w("%sUint8FromUint%d(", p.task.crt, from.Size()*8) - return ")" - case 2: - if x <= math.MaxUint16 { - switch { - case !force && from.Size() == 2: - return "" - default: - p.w("uint16(") - return ")" - } - } - - p.w("%sUint16FromUint%d(", p.task.crt, from.Size()*8) - return ")" - case 4: - if x <= math.MaxUint32 { - switch { - case !force && from.Size() == 4: - return "" - default: - p.w("uint32(") - return ")" - } - } - - p.w("%sUint32FromUint%d(", p.task.crt, from.Size()*8) - return ")" - case 8: - switch { - case !force && from.Size() == 8: - return "" - default: - p.w("uint64(") - return ")" - } - default: - panic(todo("%T(%v) %v -> %v", x, op.Value(), from, to)) - } - default: - panic(todo("%T(%v) %v -> %v", x, op.Value(), from, to)) - } - } - } -} - -func nonZeroUintptr(n uintptr) string { - if n == 0 { - return "" - } - - return fmt.Sprintf("%+d", n) -} - -func alias(attr []*cc.AttributeSpecifier) (r cc.StringID) { - for _, v := range attr { - cc.Inspect(v, func(n cc.Node, entry bool) bool { - if !entry { - return true - } - - if x, ok := n.(*cc.AttributeValue); ok && x.Token.Value == idAlias { - switch y := x.ExpressionList.AssignmentExpression.Operand.Value().(type) { - case cc.StringValue: - r = cc.StringID(y) - return false - } - } - return true - }) - if r != 0 { - return r - } - } - return 0 -} - -func (p *project) tld(f *function, n *cc.InitDeclarator, sep string, staticLocal bool) { - d := n.Declarator - if d.IsExtern() && d.Linkage == cc.External && !d.IsTypedefName { - if alias := alias(attrs(d.Type())); alias != 0 { - p.capi = append(p.capi, d.Name().String()) - p.w("\n\nvar %s%s = %s\t// %v:\n", p.task.exportExterns, d.Name(), p.externs[alias].name, p.pos(d)) - return - } - } - - if _, ok := p.wanted[d]; !ok && !staticLocal { - isFn := d.Type().Kind() == cc.Function - if isFn && p.task.header && p.task.funcSig { - if nm := d.Name().String(); !strings.HasPrefix(nm, "__") { - p.w("\n\n") - t := p.tlds[d] - if t == nil { - t = &tld{} - t.name = p.tldScope.take(d.Name()) - } - p.functionSignature2(n, nil, d.Type(), t.name) - } - } - return - } - - tld := p.tlds[d] - if tld == nil { // Dead declaration. - return - } - - t := d.Type() - if d.IsTypedefName { - p.checkAttributes(t) - if _, ok := p.typedefsEmited[tld.name]; ok { - return - } - - p.typedefsEmited[tld.name] = struct{}{} - if t.Kind() != cc.Void { - p.w("%stype %s = %s; /* %v */", sep, tld.name, p.typ(n, t), p.pos(d)) - } - return - } - - switch n.Case { - case cc.InitDeclaratorDecl: // Declarator AttributeSpecifierList - p.w("%svar %s %s\t/* %v: */", sep, tld.name, p.typ(n, t), p.pos(n)) - switch t.Kind() { - case cc.Struct, cc.Union: - p.structs[t.Tag()].emit(p, nil) - } - case cc.InitDeclaratorInit: // Declarator AttributeSpecifierList '=' Initializer - if d.IsStatic() && d.Read == 0 && d.Write == 1 && n.Initializer.IsConst() { // Initialized with no side effects and unused. - break - } - - p.w("%svar %s ", sep, tld.name) - if !isAggregateTypeOrUnion(d.Type()) { - p.w("%s ", p.typ(n, d.Type())) - } - p.w("= ") - p.initializer(f, n.Initializer, d.Type(), d.StorageClass, tld) - p.w("; /* %v */", p.pos(d)) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) functionDefinition(n *cc.FunctionDefinition) { - // DeclarationSpecifiers Declarator DeclarationList CompoundStatement - if p.task.header && !p.task.funcSig { - return - } - - if _, ok := p.sharedFns[n]; ok { - if _, ok := p.sharedFnsEmitted[n]; ok { - return - } - - p.sharedFnsEmitted[n] = struct{}{} - } - - d := n.Declarator - if d.IsExtern() && d.Type().Inline() { - // https://gcc.gnu.org/onlinedocs/gcc/Inline.html - // - // If you specify both inline and extern in the function definition, then the - // definition is used only for inlining. In no case is the function compiled on - // its own, not even if you refer to its address explicitly. Such an address - // becomes an external reference, as if you had only declared the function, and - // had not defined it. - // - // This combination of inline and extern has almost the effect of a macro. The - // way to use it is to put a function definition in a header file with these - // keywords, and put another copy of the definition (lacking inline and extern) - // in a library file. The definition in the header file causes most calls to - // the function to be inlined. If any uses of the function remain, they refer - // to the single copy in the library. - return - } - - name := d.Name().String() - if _, ok := p.task.hide[name]; ok { - return - } - - if p.isMain && d.Linkage == cc.External && d.Read == 0 && !d.AddressTaken && len(p.task.asts) == 1 { - return - } - - if d.Linkage == cc.Internal && d.Read == 0 && !d.AddressTaken /*TODO- && strings.HasPrefix(name, "__") */ { - return - } - - tld := p.tlds[d] - if tld == nil { - return - } - - p.fn = name - - defer func() { p.fn = "" }() - - f := newFunction(p, n) - p.pass1 = true - p.compoundStatement(f, n.CompoundStatement, "", false, false, 0) - p.pass1 = false - p.w("\n\n") - p.functionDefinitionSignature(n, f, tld) - if p.task.header && p.task.funcSig { - return - } - - p.w(" ") - comment := fmt.Sprintf("/* %v: */", p.pos(d)) - if p.task.panicStubs { - p.w("%s{ panic(%q) }", comment, tld.name) - return - } - - brace := "{" - if need := f.off; need != 0 { - scope := f.blocks[n.CompoundStatement].scope - f.bpName = scope.take(idBp) - p.w("{%s\n%s := %s.Alloc(%d)\n", comment, f.bpName, f.tlsName, need) - p.w("defer %s.Free(%d)\n", f.tlsName, need) - for _, v := range d.Type().Parameters() { - if local := f.locals[v.Declarator()]; local != nil && local.isPinned { // Pin it. - p.w("*(*%s)(unsafe.Pointer(%s%s)) = %s\n", p.typ(v.Declarator(), paramTypeDecay(v.Declarator())), f.bpName, nonZeroUintptr(local.off), local.name) - } - } - comment = "" - brace = "" - } - if len(f.vlas) != 0 { - p.w("%s%s\n", brace, comment) - var vlas []*cc.Declarator - for k := range f.vlas { - vlas = append(vlas, k) - } - sort.Slice(vlas, func(i, j int) bool { - return vlas[i].NameTok().Seq() < vlas[j].NameTok().Seq() - }) - for _, v := range vlas { - local := f.locals[v] - switch { - case local.isPinned: - panic(todo("", v.Position())) - default: - p.w("var %s uintptr // %v: %v\n", local.name, p.pos(v), v.Type()) - } - } - switch { - case len(vlas) == 1: - p.w("defer %sXfree(%s, %s)\n", p.task.crt, f.tlsName, f.locals[vlas[0]].name) - default: - p.w("defer func() {\n") - for _, v := range vlas { - p.w("%sXfree(%s, %s)\n", p.task.crt, f.tlsName, f.locals[v].name) - } - p.w("\n}()\n") - } - } - p.compoundStatement(f, n.CompoundStatement, comment, false, true, 0) - p.w(";") - p.flushLocalTaggesStructs() - p.flushStaticTLDs() -} - -func (p *project) flushLocalTaggesStructs() { - for _, v := range p.localTaggedStructs { - v() - } - p.localTaggedStructs = nil -} - -func (p *project) flushStaticTLDs() { - for _, v := range p.staticQueue { - p.tld(nil, v, "\n", true) - } - p.staticQueue = nil -} - -func (p *project) compoundStatement(f *function, n *cc.CompoundStatement, scomment string, forceNoBraces, fnBody bool, mode exprMode) { - if p.task.panicStubs { - return - } - - // '{' BlockItemList '}' - brace := (!n.IsJumpTarget() || n.Parent() == nil) && !forceNoBraces - if brace && len(f.vlas) == 0 && (n.Parent() != nil || f.off == 0) { - p.w("{%s", scomment) - } - if fnBody { - p.instrument(n) - } - sv := f.block - f.block = f.blocks[n] - if f.block.topDecl { - for _, v := range f.block.decls { - p.declaration(f, v, true) - } - } - var r *cc.JumpStatement - for list := n.BlockItemList; list != nil; list = list.BlockItemList { - m := mode - if list.BlockItemList != nil { - m = 0 - } - r = p.blockItem(f, list.BlockItem, m) - } - if n.Parent() == nil && r == nil && f.rt.Kind() != cc.Void { - p.w("\nreturn ") - p.zeroValue(n, f.rt) - } - s := tidyComment("\n", &n.Token2) - p.w("%s", s) - if brace { - if !strings.HasSuffix(s, "\n") { - p.w("\n") - } - p.w("}") - } - f.block = sv -} - -func (p *project) zeroValue(n cc.Node, t cc.Type) { - if t.IsScalarType() { - p.w("%s(0)", p.typ(n, t)) - return - } - - switch t.Kind() { - case cc.Struct, cc.Union: - p.w("%s{}", p.typ(n, t)) - default: - panic(todo("", t, t.Kind())) - } -} - -func (p *project) blockItem(f *function, n *cc.BlockItem, mode exprMode) (r *cc.JumpStatement) { - switch n.Case { - case cc.BlockItemDecl: // Declaration - p.declaration(f, n.Declaration, false) - case cc.BlockItemStmt: // Statement - r = p.statement(f, n.Statement, false, false, false, mode) - p.w(";") - if r == nil { - p.instrument(n) - } - case cc.BlockItemLabel: // LabelDeclaration - panic(todo("", p.pos(n))) - p.w(";") - case cc.BlockItemFuncDef: // DeclarationSpecifiers Declarator CompoundStatement - p.err(n, "nested functions not supported") - p.w(";") - case cc.BlockItemPragma: // PragmaSTDC - panic(todo("", p.pos(n))) - p.w(";") - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } - return r -} - -func (p *project) instrument(n cc.Node) { - if p.task.cover { - p.w("%sCover();", p.task.crt) - } - if p.task.coverC { - p.w("%sCoverC(%q);", p.task.crt, p.pos(n).String()+" "+p.fn) - } - if p.task.watch { - p.w("%sWatch();", p.task.crt) - } -} - -var dummyJumpStatement = &cc.JumpStatement{} - -func (p *project) statement(f *function, n *cc.Statement, forceCompoundStmtBrace, forceNoBraces, switchBlock bool, mode exprMode) (r *cc.JumpStatement) { - if forceCompoundStmtBrace { - if f.switchCtx == inSwitchFirst && p.pauseCodegen { - p.pauseCodegen = false - p.w(" {") - p.pauseCodegen = true - } - p.w(" {") - if !switchBlock { - p.instrument(n) - } - } - switch n.Case { - case cc.StatementLabeled: // LabeledStatement - r = p.labeledStatement(f, n.LabeledStatement) - case cc.StatementCompound: // CompoundStatement - if !forceCompoundStmtBrace { - p.w("%s", n.CompoundStatement.Token.Sep) - } - if f.hasJumps { - forceNoBraces = true - } - p.compoundStatement(f, n.CompoundStatement, "", forceCompoundStmtBrace || forceNoBraces, false, 0) - case cc.StatementExpr: // ExpressionStatement - if mode != 0 { - p.w("return ") - e := n.ExpressionStatement.Expression - p.expression(f, e, e.Operand.Type(), exprValue, 0) - r = dummyJumpStatement - break - } - - p.expressionStatement(f, n.ExpressionStatement) - case cc.StatementSelection: // SelectionStatement - p.selectionStatement(f, n.SelectionStatement) - case cc.StatementIteration: // IterationStatement - p.iterationStatement(f, n.IterationStatement) - case cc.StatementJump: // JumpStatement - r = p.jumpStatement(f, n.JumpStatement) - case cc.StatementAsm: // AsmStatement - // AsmStatement: - // Asm AttributeSpecifierList ';' - // Asm: - // "__asm__" AsmQualifierList '(' STRINGLITERAL AsmArgList ')' - if n.AsmStatement.Asm.Token3.Value == 0 && n.AsmStatement.Asm.AsmArgList == nil { - break - } - - p.w("panic(`%s: assembler statements not supported`)", n.Position()) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } - if forceCompoundStmtBrace { - // We need to do this, to guarantee that we always close the brace is we opened it - if f.switchCtx == inSwitchFirst && p.pauseCodegen { - p.pauseCodegen = false - p.w("}") - p.pauseCodegen = true - } - p.w("}") - } - return r -} - -func (p *project) jumpStatement(f *function, n *cc.JumpStatement) (r *cc.JumpStatement) { - p.w("%s", tidyComment("\n", n)) - if _, ok := n.Context().(*cc.SelectionStatement); ok && f.ifCtx == nil { - switch f.switchCtx { - case inSwitchCase: - f.switchCtx = inSwitchSeenBreak - case inSwitchSeenBreak: - // nop but TODO - case inSwitchFlat: - // ok - default: - panic(todo("", n.Position(), f.switchCtx)) - } - } - - switch n.Case { - case cc.JumpStatementGoto: // "goto" IDENTIFIER ';' - p.w("goto %s", f.labelNames[n.Token2.Value]) - case cc.JumpStatementGotoExpr: // "goto" '*' Expression ';' - panic(todo("", p.pos(n))) - case cc.JumpStatementContinue: // "continue" ';' - switch { - case f.continueCtx != 0: - p.w("goto __%d", f.continueCtx) - default: - p.w("continue") - } - case cc.JumpStatementBreak: // "break" ';' - switch { - case f.breakCtx != 0: - p.w("goto __%d", f.breakCtx) - default: - p.w("break") - } - case cc.JumpStatementReturn: // "return" Expression ';' - r = n - switch { - case f.rt != nil && f.rt.Kind() == cc.Void: - if n.Expression != nil { - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, 0) - p.w(";") - } - p.w("return") - case f.rt != nil && f.rt.Kind() != cc.Void: - if n.Expression != nil { - p.expression(f, n.Expression, f.rt, exprCondReturn, 0) - break - } - - p.w("return ") - p.zeroValue(n, f.rt) - default: - if n.Expression != nil { - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, 0) - p.w(";") - } - p.w("return") - } - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } - return r -} - -func (p *project) expression(f *function, n *cc.Expression, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprVoid: - p.expressionVoid(f, n, t, mode, flags) - case exprValue, exprCondReturn, exprCondInit: - p.expressionValue(f, n, t, mode, flags) - case exprBool: - p.expressionBool(f, n, t, mode, flags) - case exprAddrOf: - p.expressionAddrOf(f, n, t, mode, flags) - case exprPSelect: - p.expressionPSelect(f, n, t, mode, flags) - case exprLValue: - p.expressionLValue(f, n, t, mode, flags) - case exprFunc: - p.expressionFunc(f, n, t, mode, flags) - case exprSelect: - p.expressionSelect(f, n, t, mode, flags) - case exprDecay: - p.expressionDecay(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) expressionDecay(f *function, n *cc.Expression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ExpressionAssign: // AssignmentExpression - p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags) - case cc.ExpressionComma: // Expression ',' AssignmentExpression - p.w("func() uintptr {") - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, flags) - p.w("; return ") - p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags) - p.w("}()") - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) expressionSelect(f *function, n *cc.Expression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ExpressionAssign: // AssignmentExpression - p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags) - case cc.ExpressionComma: // Expression ',' AssignmentExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) expressionFunc(f *function, n *cc.Expression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ExpressionAssign: // AssignmentExpression - p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags) - case cc.ExpressionComma: // Expression ',' AssignmentExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) expressionLValue(f *function, n *cc.Expression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ExpressionAssign: // AssignmentExpression - p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags) - case cc.ExpressionComma: // Expression ',' AssignmentExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) expressionPSelect(f *function, n *cc.Expression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ExpressionAssign: // AssignmentExpression - p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags) - case cc.ExpressionComma: // Expression ',' AssignmentExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) expressionAddrOf(f *function, n *cc.Expression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ExpressionAssign: // AssignmentExpression - p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags) - case cc.ExpressionComma: // Expression ',' AssignmentExpression - p.w(" func() uintptr {") - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, flags) - p.w("; return ") - p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags) - p.w("}()") - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) expressionBool(f *function, n *cc.Expression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ExpressionAssign: // AssignmentExpression - p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags) - case cc.ExpressionComma: // Expression ',' AssignmentExpression - p.w("func() bool {") - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, flags) - p.w("; return ") - p.assignmentExpression(f, n.AssignmentExpression, n.AssignmentExpression.Operand.Type(), mode, flags) - p.w("}()") - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) expressionValue(f *function, n *cc.Expression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ExpressionAssign: // AssignmentExpression - p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags) - case cc.ExpressionComma: // Expression ',' AssignmentExpression - if mode == exprCondReturn { - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, flags) - p.w("; return ") - p.assignmentExpression(f, n.AssignmentExpression, n.AssignmentExpression.Operand.Type(), exprValue, flags) - return - } - - switch { - case n.AssignmentExpression.Operand.Type().Kind() == cc.Array: - p.expressionDecay(f, n, t, exprDecay, flags) - default: - defer p.w("%s", p.convertType(n, n.Operand.Type(), t, flags)) - p.w("func() %v {", p.typ(n, n.AssignmentExpression.Operand.Type())) - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, flags) - p.w("; return ") - p.assignmentExpression(f, n.AssignmentExpression, n.AssignmentExpression.Operand.Type(), exprValue, flags) - p.w("}()") - } - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) expressionVoid(f *function, n *cc.Expression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ExpressionAssign: // AssignmentExpression - p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags) - case cc.ExpressionComma: // Expression ',' AssignmentExpression - p.expression(f, n.Expression, t, mode, flags) - p.w(";") - p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) opKind(f *function, d declarator, t cc.Type) opKind { - switch { - case p.isArrayParameter(d, t): - return opArrayParameter - case !p.pass1 && p.isArray(f, d, t): - return opArray - case t.Kind() == cc.Union: - return opUnion - case t.Kind() == cc.Struct: - return opStruct - case t.IsBitFieldType(): - return opBitfield - case t.Kind() == cc.Function: - return opFunction - default: - return opNormal - } -} - -func (p *project) assignmentExpression(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprVoid: - p.assignmentExpressionVoid(f, n, t, mode, flags) - case exprValue, exprCondReturn, exprCondInit: - p.assignmentExpressionValue(f, n, t, mode, flags) - case exprAddrOf: - p.assignmentExpressionAddrOf(f, n, t, mode, flags) - case exprBool: - p.assignmentExpressionBool(f, n, t, mode, flags) - case exprLValue: - p.assignmentExpressionLValue(f, n, t, mode, flags) - case exprPSelect: - p.assignmentExpressionPSelect(f, n, t, mode, flags) - case exprFunc: - p.assignmentExpressionFunc(f, n, t, mode, flags) - case exprSelect: - p.assignmentExpressionSelect(f, n, t, mode, flags) - case exprDecay: - p.assignmentExpressionDecay(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) assignmentExpressionDecay(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AssignmentExpressionCond: // ConditionalExpression - p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags) - case cc.AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionMul: // UnaryExpression "*=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionDiv: // UnaryExpression "/=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionMod: // UnaryExpression "%=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionAdd: // UnaryExpression "+=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionSub: // UnaryExpression "-=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionLsh: // UnaryExpression "<<= AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionRsh: // UnaryExpression ">>=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionAnd: // UnaryExpression "&=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionXor: // UnaryExpression "^=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionOr: // UnaryExpression "|=" AssignmentExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) assignmentExpressionSelect(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AssignmentExpressionCond: // ConditionalExpression - p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags) - case cc.AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionMul: // UnaryExpression "*=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionDiv: // UnaryExpression "/=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionMod: // UnaryExpression "%=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionAdd: // UnaryExpression "+=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionSub: // UnaryExpression "-=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionLsh: // UnaryExpression "<<=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionRsh: // UnaryExpression ">>=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionAnd: // UnaryExpression "&=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionXor: // UnaryExpression "^=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionOr: // UnaryExpression "|=" AssignmentExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) assignmentExpressionFunc(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AssignmentExpressionCond: // ConditionalExpression - p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags) - case cc.AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionMul: // UnaryExpression "*=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionDiv: // UnaryExpression "/=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionMod: // UnaryExpression "%=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionAdd: // UnaryExpression "+=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionSub: // UnaryExpression "-=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionLsh: // UnaryExpremode, ssion "<<= - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionRsh: // UnaryExpression ">>=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionAnd: // UnaryExpression "&=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionXor: // UnaryExpression "^=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionOr: // UnaryExpression "|=" AssignmentExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) assignmentExpressionPSelect(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AssignmentExpressionCond: // ConditionalExpression - p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags) - case cc.AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression - p.w("(*%s)(unsafe.Pointer(", p.typ(n, n.AssignmentExpression.Operand.Type().Elem())) - p.assignmentExpression(f, n, t, exprValue, flags) - p.w("))") - case cc.AssignmentExpressionMul: // UnaryExpression "*=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionDiv: // UnaryExpression "/=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionMod: // UnaryExpression "%=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionAdd: // UnaryExpression "+=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionSub: // UnaryExpression "-=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionLsh: // UnaryExpression "<<=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionRsh: // UnaryExpression ">>=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionAnd: // UnaryExpression "&=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionXor: // UnaryExpression "^=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionOr: // UnaryExpression "|=" AssignmentExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) assignmentExpressionLValue(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AssignmentExpressionCond: // ConditionalExpression - p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags) - case cc.AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionMul: // UnaryExpression "*=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionDiv: // UnaryExpression "/=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionMod: // UnaryExpression "%=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionAdd: // UnaryExpression "+=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionSub: // UnaryExpression "-=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionLsh: // UnaryExpression "<<=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionRsh: // UnaryExpression ">>=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionAnd: // UnaryExpression "&=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionXor: // UnaryExpression "^=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionOr: // UnaryExpression "|=" AssignmentExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) assignmentExpressionBool(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AssignmentExpressionCond: // ConditionalExpression - p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags) - default: - // case cc.AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression - // case cc.AssignmentExpressionMul: // UnaryExpression "*=" AssignmentExpression - // case cc.AssignmentExpressionDiv: // UnaryExpression "/=" AssignmentExpression - // case cc.AssignmentExpressionMod: // UnaryExpression "%=" AssignmentExpression - // case cc.AssignmentExpressionAdd: // UnaryExpression "+=" AssignmentExpression - // case cc.AssignmentExpressionSub: // UnaryExpression "-=" AssignmentExpression - // case cc.AssignmentExpressionLsh: // UnaryExpression "<<=" AssignmentExpression - // case cc.AssignmentExpressionRsh: // UnaryExpression ">>=" AssignmentExpression - // case cc.AssignmentExpressionAnd: // UnaryExpression "&=" AssignmentExpression - // case cc.AssignmentExpressionXor: // UnaryExpression "^=" AssignmentExpression - // case cc.AssignmentExpressionOr: // UnaryExpression "|=" AssignmentExpression - p.w("(") - defer p.w(")") - defer p.w(" != 0 ") - p.assignmentExpression(f, n, t, exprValue, flags) - } -} - -func (p *project) assignmentExpressionAddrOf(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AssignmentExpressionCond: // ConditionalExpression - p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags) - case cc.AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression - p.assignmentExpressionValueAddrOf(f, n, t, mode, flags) - case cc.AssignmentExpressionMul: // UnaryExpression "*=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionDiv: // UnaryExpression "/=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionMod: // UnaryExpression "%=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionAdd: // UnaryExpression "+=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionSub: // UnaryExpression "-=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionLsh: // UnaryExpression "<<=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionRsh: // UnaryExpression ">>=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionAnd: // UnaryExpression "&=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionXor: // UnaryExpression "^=" AssignmentExpression - panic(todo("", p.pos(n))) - case cc.AssignmentExpressionOr: // UnaryExpression "|=" AssignmentExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) assignmentExpressionValueAddrOf(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) { - // UnaryExpression '=' AssignmentExpression - if mode == exprCondReturn { - panic(todo("", p.pos(n))) - } - - lhs := n.UnaryExpression - switch k := p.opKind(f, lhs, lhs.Operand.Type()); k { - case opStruct, opUnion: - p.assignmentExpressionValueAssignStructAddrof(f, n, n.Operand.Type(), mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) assignmentExpressionValueAssignStructAddrof(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) { - // UnaryExpression '=' AssignmentExpression - lhs := n.UnaryExpression.Operand.Type() - rhs := n.AssignmentExpression.Operand.Type() - if lhs.Kind() == cc.Array || rhs.Kind() == cc.Array { - panic(todo("", p.pos(n))) - } - - if d := n.UnaryExpression.Declarator(); d != nil { - if local := f.locals[d]; local != nil { - if local.isPinned { - if !p.pass1 { - p.w("%sXmemmove(tls, ", p.task.crt) - p.unaryExpression(f, n.UnaryExpression, lhs, exprAddrOf, flags) - p.w(", ") - p.assignmentExpression(f, n.AssignmentExpression, rhs, exprAddrOf, flags) - p.w(", %d)", lhs.Size()) - return - } - } - - if !p.pass1 { - panic(todo("", p.pos(n))) - } - } - } - - p.w("%sXmemmove(tls, ", p.task.crt) - p.unaryExpression(f, n.UnaryExpression, lhs, exprAddrOf, flags) - p.w(", ") - p.assignmentExpression(f, n.AssignmentExpression, rhs, exprAddrOf, flags) - p.w(", %d)", lhs.Size()) -} - -func (p *project) assignmentExpressionValue(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AssignmentExpressionCond: // ConditionalExpression - p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags) - case cc.AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression - p.assignmentExpressionValueAssign(f, n, t, mode, flags) - case cc.AssignmentExpressionMul: // UnaryExpression "*=" AssignmentExpression - p.assignOp(f, n, t, mode, "*", "Mul", flags) - case cc.AssignmentExpressionDiv: // UnaryExpression "/=" AssignmentExpression - p.assignOp(f, n, t, mode, "/", "Div", flags) - case cc.AssignmentExpressionMod: // UnaryExpression "%=" AssignmentExpression - p.assignOp(f, n, t, mode, "%", "Rem", flags) - case cc.AssignmentExpressionAdd: // UnaryExpression "+=" AssignmentExpression - p.assignOp(f, n, t, mode, "+", "Add", flags) - case cc.AssignmentExpressionSub: // UnaryExpression "-=" AssignmentExpression - p.assignOp(f, n, t, mode, "-", "Sub", flags) - case cc.AssignmentExpressionLsh: // UnaryExpremode, ssion "<<= - p.assignOp(f, n, t, mode, "<<", "Shl", flags) - case cc.AssignmentExpressionRsh: // UnaryExpression ">>=" AssignmentExpression - p.assignOp(f, n, t, mode, ">>", "Shr", flags) - case cc.AssignmentExpressionAnd: // UnaryExpression "&=" AssignmentExpression - p.assignOp(f, n, t, mode, "&", "And", flags) - case cc.AssignmentExpressionXor: // UnaryExpression "^=" AssignmentExpression - p.assignOp(f, n, t, mode, "^", "Xor", flags) - case cc.AssignmentExpressionOr: // UnaryExpression "|=" AssignmentExpression - p.assignOp(f, n, t, mode, "|", "Or", flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) assignmentExpressionValueAssign(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) { - // UnaryExpression '=' AssignmentExpression - if mode == exprCondReturn { - p.w("return ") - } - lhs := n.UnaryExpression - switch k := p.opKind(f, lhs, lhs.Operand.Type()); k { - case opNormal: - p.assignmentExpressionValueAssignNormal(f, n, t, mode, flags) - case opBitfield: - p.assignmentExpressionValueAssignBitfield(f, n, t, mode, flags) - case opStruct, opUnion: - p.assignmentExpressionValueAssignStruct(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) assignmentExpressionValueAssignStruct(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) { - // UnaryExpression '=' AssignmentExpression - lhs := n.UnaryExpression.Operand.Type() - rhs := n.AssignmentExpression.Operand.Type() - if lhs.Kind() == cc.Array || rhs.Kind() == cc.Array { - panic(todo("", p.pos(n))) - } - - p.w(" func() %s { __v := ", p.typ(n, lhs)) - p.assignmentExpression(f, n.AssignmentExpression, rhs, exprValue, flags) - p.w(";") - p.unaryExpression(f, n.UnaryExpression, lhs, exprLValue, flags) - p.w(" = __v; return __v}()") -} - -func (p *project) assignmentExpressionValueAssignBitfield(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) { - if d := n.UnaryExpression.Declarator(); d != nil { - panic(todo("", p.pos(n))) - } - - lhs := n.UnaryExpression - lt := lhs.Operand.Type() - bf := lt.BitField() - defer p.w("%s", p.convertType(n, lt, t, flags)) - p.w("%sAssignBitFieldPtr%d%s(", p.task.crt, bf.BitFieldBlockWidth(), p.bfHelperType(lt)) - p.unaryExpression(f, lhs, lt, exprAddrOf, flags) - p.w(", ") - p.assignmentExpression(f, n.AssignmentExpression, lt, exprValue, flags) - p.w(", %d, %d, %#x)", bf.BitFieldWidth(), bf.BitFieldOffset(), bf.Mask()) -} - -func (p *project) assignmentExpressionValueAssignNormal(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) { - if d := n.UnaryExpression.Declarator(); d != nil { - if !d.Type().IsScalarType() { - panic(todo("", p.pos(n))) - } - - if local := f.locals[d]; local != nil { - if local.isPinned { - defer p.w(")%s", p.convertType(n, d.Type(), t, flags)) - p.w("%sAssignPtr%s(", p.task.crt, p.helperType(d, d.Type())) - p.w("%s%s /* %s */", f.bpName, nonZeroUintptr(local.off), local.name) - p.w(", ") - p.assignmentExpression(f, n.AssignmentExpression, n.UnaryExpression.Operand.Type(), exprValue, flags) - return - } - - defer p.w(")%s", p.convertType(n, d.Type(), t, flags)) - p.w("%sAssign%s(&%s, ", p.task.crt, p.helperType(n, d.Type()), local.name) - p.assignmentExpression(f, n.AssignmentExpression, n.UnaryExpression.Operand.Type(), exprValue, flags) - return - } - } - - defer p.w(")%s", p.convertType(n, n.UnaryExpression.Operand.Type(), t, flags)) - p.w("%sAssignPtr%s(", p.task.crt, p.helperType(n, n.UnaryExpression.Operand.Type())) - p.unaryExpression(f, n.UnaryExpression, n.UnaryExpression.Operand.Type(), exprAddrOf, flags) - p.w(", ") - p.assignmentExpression(f, n.AssignmentExpression, n.UnaryExpression.Operand.Type(), exprValue, flags) -} - -func (p *project) assignmentExpressionVoid(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AssignmentExpressionCond: // ConditionalExpression - p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags) - case cc.AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression - d := n.UnaryExpression.Declarator() - lhs := n.UnaryExpression - lt := lhs.Operand.Type() - sv := f.condInitPrefix - switch k := p.opKind(f, lhs, lt); k { - case opArrayParameter: - lt = lt.Decay() - fallthrough - case opNormal, opStruct: - mode = exprValue - if p.isArrayOrPinnedArray(f, n.AssignmentExpression, n.AssignmentExpression.Operand.Type()) { - mode = exprDecay - } - switch { - case flags&fNoCondAssignment == 0 && mode == exprValue && n.UnaryExpression.Declarator() != nil && p.isConditionalAssignmentExpr(n.AssignmentExpression): - f.condInitPrefix = func() { - p.unaryExpression(f, lhs, lt, exprLValue, flags) - p.w(" = ") - } - p.assignmentExpression(f, n.AssignmentExpression, lt, exprCondInit, flags) - p.w(";") - default: - if d != nil && p.isVolatileOrAtomic(d) { - p.setVolatileDeclarator(d, f, n.AssignmentExpression, lt, mode, flags) - return - } - - p.unaryExpression(f, lhs, lt, exprLValue, flags) - p.w(" = ") - p.assignmentExpression(f, n.AssignmentExpression, lt, mode, flags) - } - case opBitfield: - bf := lt.BitField() - p.w("%sSetBitFieldPtr%d%s(", p.task.crt, bf.BitFieldBlockWidth(), p.bfHelperType(lt)) - p.unaryExpression(f, lhs, lt, exprAddrOf, flags) - p.w(", ") - p.assignmentExpression(f, n.AssignmentExpression, lt, exprValue, flags) - p.w(", %d, %#x)", bf.BitFieldOffset(), bf.Mask()) - case opUnion: - p.unaryExpression(f, lhs, lt, exprLValue, flags) - p.w(" = ") - p.assignmentExpression(f, n.AssignmentExpression, lt, exprValue, flags) - default: - panic(todo("", n.Position(), k)) - } - f.condInitPrefix = sv - case cc.AssignmentExpressionMul: // UnaryExpression "*=" AssignmentExpression - p.assignOp(f, n, t, mode, "*", "Mul", flags) - case cc.AssignmentExpressionDiv: // UnaryExpression "/=" AssignmentExpression - p.assignOp(f, n, t, mode, "/", "Div", flags) - case cc.AssignmentExpressionMod: // UnaryExpression "%=" AssignmentExpression - p.assignOp(f, n, t, mode, "%", "Mod", flags) - case cc.AssignmentExpressionAdd: // UnaryExpression "+=" AssignmentExpression - p.assignOp(f, n, t, mode, "+", "Add", flags) - case cc.AssignmentExpressionSub: // UnaryExpression "-=" AssignmentExpression - p.assignOp(f, n, t, mode, "-", "Sub", flags) - case cc.AssignmentExpressionLsh: // UnaryExpression "<<=" AssignmentExpression - p.assignShiftOp(f, n, t, mode, "<<", "Shl", flags) - case cc.AssignmentExpressionRsh: // UnaryExpression ">>=" AssignmentExpression - p.assignShiftOp(f, n, t, mode, ">>", "Shr", flags) - case cc.AssignmentExpressionAnd: // UnaryExpression "&=" AssignmentExpression - p.assignOp(f, n, t, mode, "&", "And", flags) - case cc.AssignmentExpressionXor: // UnaryExpression "^=" AssignmentExpression - p.assignOp(f, n, t, mode, "^", "Xor", flags) - case cc.AssignmentExpressionOr: // UnaryExpression "|=" AssignmentExpression - p.assignOp(f, n, t, mode, "|", "Or", flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) setVolatileDeclarator(d *cc.Declarator, f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) { - sz := d.Type().Size() - switch sz { - case 4, 8: - // ok - default: - p.err(d, "unsupported volatile declarator size: %v", sz) - return - } - - if local := f.locals[d]; local != nil { - if local.isPinned { - p.w("%sAtomicStoreP%s(%s%s /* %s */, ", p.task.crt, p.helperType(n, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name) - p.assignmentExpression(f, n, t, mode, flags) - p.w(")") - return - } - - p.atomicStoreNamedAddr(n, d.Type(), local.name, n, f, mode, flags) - return - } - - if tld := p.tlds[d]; tld != nil { - p.atomicStoreNamedAddr(n, d.Type(), tld.name, n, f, mode, flags) - return - } - - if imp := p.imports[d.Name().String()]; imp != nil { - p.atomicStoreNamedAddr(n, d.Type(), fmt.Sprintf("%sX%s", imp.qualifier, d.Name()), n, f, mode, flags) - return - } - - panic(todo("", n.Position(), d.Position(), d.Name())) -} - -func (p *project) atomicStoreNamedAddr(n cc.Node, t cc.Type, nm string, expr *cc.AssignmentExpression, f *function, mode exprMode, flags flags) { - sz := t.Size() - switch sz { - case 4, 8: - // ok - default: - p.err(n, "unsupported volatile declarator size: %v", sz) - return - } - - var ht string - switch { - case t.IsScalarType(): - ht = p.helperType(n, t) - default: - p.err(n, "unsupported volatile declarator type: %v", t) - return - } - - p.w("%sAtomicStore%s(&%s, %s(", p.task.crt, ht, nm, p.typ(n, t)) - p.assignmentExpression(f, expr, t, mode, flags) - p.w("))") -} - -func (p *project) atomicLoadNamedAddr(n cc.Node, t cc.Type, nm string) { - sz := t.Size() - switch sz { - case 4, 8: - // ok - default: - p.err(n, "unsupported volatile declarator size: %v", sz) - return - } - - var ht string - switch { - case t.IsScalarType(): - ht = p.helperType(n, t) - default: - p.err(n, "unsupported volatile declarator type: %v", t) - return - } - - p.w("%sAtomicLoad%s(&%s)", p.task.crt, ht, nm) -} - -func isRealType(op cc.Operand) bool { - switch op.Type().Kind() { - case cc.Float, cc.Double: - return true - default: - return false - } -} - -func (p *project) bfHelperType(t cc.Type) string { - switch { - case t.IsSignedType(): - return fmt.Sprintf("Int%d", t.Size()*8) - default: - return fmt.Sprintf("Uint%d", t.Size()*8) - } -} - -func (p *project) helperType(n cc.Node, t cc.Type) string { - for t.IsAliasType() { - if t2 := t.Alias(); t2 != t { //TODO HDF5 H5O.c - t = t2 - continue - } - - break - } - switch t.Kind() { - case cc.Int128: - return "Int128" - case cc.UInt128: - return "Uint128" - } - - s := p.typ(n, t) - return strings.ToUpper(s[:1]) + s[1:] -} - -func (p *project) helperType2(n cc.Node, from, to cc.Type) string { - if from.Kind() == to.Kind() { - return fmt.Sprintf("%s%s", p.task.crt, p.helperType(n, from)) - } - - return fmt.Sprintf("%s%sFrom%s", p.task.crt, p.helperType(n, to), p.helperType(n, from)) -} - -func (p *project) conditionalExpression(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprValue: - p.conditionalExpressionValue(f, n, t, mode, flags) - case exprVoid: - p.conditionalExpressionVoid(f, n, t, mode, flags) - case exprAddrOf: - p.conditionalExpressionAddrOf(f, n, t, mode, flags) - case exprBool: - p.conditionalExpressionBool(f, n, t, mode, flags) - case exprLValue: - p.conditionalExpressionLValue(f, n, t, mode, flags) - case exprPSelect: - p.conditionalExpressionPSelect(f, n, t, mode, flags) - case exprFunc: - p.conditionalExpressionFunc(f, n, t, mode, flags) - case exprSelect: - p.conditionalExpressionSelect(f, n, t, mode, flags) - case exprCondReturn: - p.conditionalExpressionReturn(f, n, t, mode, flags) - case exprCondInit: - p.conditionalExpressionInit(f, n, t, mode, flags) - case exprDecay: - p.conditionalExpressionDecay(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) conditionalExpressionDecay(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ConditionalExpressionLOr: // LogicalOrExpression - p.logicalOrExpression(f, n.LogicalOrExpression, t, mode, flags) - case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression - t = t.Decay() - p.w(" func() %s { if ", p.typ(n, t)) - p.logicalOrExpression(f, n.LogicalOrExpression, n.LogicalOrExpression.Operand.Type(), exprBool, flags) - p.w(" { return ") - switch n.Expression.Operand.Type().Kind() { - case cc.Array: - p.expression(f, n.Expression, t, exprDecay, flags) - case cc.Ptr: - panic(todo("", n.Expression.Position(), n.Expression.Operand.Type())) - default: - panic(todo("", n.Expression.Position(), n.Expression.Operand.Type())) - } - p.w("}; return ") - switch n.ConditionalExpression.Operand.Type().Kind() { - case cc.Array: - p.conditionalExpression(f, n.ConditionalExpression, t, exprDecay, flags) - default: - p.conditionalExpression(f, n.ConditionalExpression, t, exprValue, flags) - } - p.w("}()") - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) conditionalExpressionInit(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ConditionalExpressionLOr: // LogicalOrExpression - f.condInitPrefix() - p.logicalOrExpression(f, n.LogicalOrExpression, t, exprValue, flags) - case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression - t = t.Decay() - p.w("if ") - p.logicalOrExpression(f, n.LogicalOrExpression, n.LogicalOrExpression.Operand.Type(), exprBool, flags) - p.w(" {") - p.expression(f, n.Expression, t, mode, flags) - p.w("} else { ") - p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags) - p.w("}") - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) conditionalExpressionReturn(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ConditionalExpressionLOr: // LogicalOrExpression - p.w("return ") - p.logicalOrExpression(f, n.LogicalOrExpression, t, exprValue, flags) - case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression - t = t.Decay() - p.w("if ") - p.logicalOrExpression(f, n.LogicalOrExpression, n.LogicalOrExpression.Operand.Type(), exprBool, flags) - p.w(" {") - p.expression(f, n.Expression, t, mode, flags) - p.w("}; ") - p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) conditionalExpressionSelect(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ConditionalExpressionLOr: // LogicalOrExpression - p.logicalOrExpression(f, n.LogicalOrExpression, t, mode, flags) - case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) conditionalExpressionFunc(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ConditionalExpressionLOr: // LogicalOrExpression - p.logicalOrExpression(f, n.LogicalOrExpression, t, mode, flags) - case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression - switch ot := n.Operand.Type(); ot.Kind() { - case cc.Function: - if t.Kind() != cc.Function { - panic(todo("", n.Position())) - } - default: - panic(todo("", ot.Kind())) - } - - p.w(" func() ") - p.functionSignature(n, f, t, "") - p.w("{ if ") - p.logicalOrExpression(f, n.LogicalOrExpression, n.LogicalOrExpression.Operand.Type(), exprBool, flags) - p.w(" { return ") - switch d := n.Expression.Declarator(); { - case d != nil: - p.declaratorDefault(n, d) - default: - panic(todo("", n.Position())) - } - p.w("}; return ") - switch d := n.ConditionalExpression.Declarator(); { - case d != nil: - p.declaratorDefault(n, d) - default: - panic(todo("", n.Position())) - } - p.w("}()") - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) conditionalExpressionPSelect(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ConditionalExpressionLOr: // LogicalOrExpression - p.logicalOrExpression(f, n.LogicalOrExpression, t, mode, flags) - case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression - p.w("(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type().Elem())) - p.conditionalExpression(f, n, t, exprValue, flags) - p.w("))") - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) conditionalExpressionLValue(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ConditionalExpressionLOr: // LogicalOrExpression - p.logicalOrExpression(f, n.LogicalOrExpression, t, mode, flags) - case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) conditionalExpressionBool(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ConditionalExpressionLOr: // LogicalOrExpression - p.logicalOrExpression(f, n.LogicalOrExpression, t, mode, flags) - case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression - p.w("(") - defer p.w(")") - defer p.w(" != 0 ") - p.conditionalExpression(f, n, t, exprValue, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) conditionalExpressionAddrOf(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ConditionalExpressionLOr: // LogicalOrExpression - p.logicalOrExpression(f, n.LogicalOrExpression, t, mode, flags) - case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression - t = t.Decay() - p.w(" func() %s { if ", p.typ(n, t)) - p.logicalOrExpression(f, n.LogicalOrExpression, n.LogicalOrExpression.Operand.Type(), exprBool, flags) - p.w(" { return ") - p.expression(f, n.Expression, t, exprValue, flags) - p.w("}; return ") - p.conditionalExpression(f, n.ConditionalExpression, t, exprValue, flags) - p.w("}()") - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) conditionalExpressionVoid(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ConditionalExpressionLOr: // LogicalOrExpression - p.logicalOrExpression(f, n.LogicalOrExpression, t, mode, flags) - case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression - switch { - case n.Expression.IsSideEffectsFree: - p.w("if !(") - p.logicalOrExpression(f, n.LogicalOrExpression, n.LogicalOrExpression.Operand.Type(), exprBool, flags) - p.w(") {") - p.conditionalExpression(f, n.ConditionalExpression, n.ConditionalExpression.Operand.Type(), mode, flags) - p.w("}") - default: - p.w("if ") - p.logicalOrExpression(f, n.LogicalOrExpression, n.LogicalOrExpression.Operand.Type(), exprBool, flags) - p.w(" {") - p.expression(f, n.Expression, n.Expression.Operand.Type(), mode, flags) - p.w("} else {") - p.conditionalExpression(f, n.ConditionalExpression, n.ConditionalExpression.Operand.Type(), mode, flags) - p.w("}") - } - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) conditionalExpressionValue(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ConditionalExpressionLOr: // LogicalOrExpression - p.logicalOrExpression(f, n.LogicalOrExpression, t, exprValue, flags) - case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression - t = t.Decay() - p.w(" func() %s { if ", p.typ(n, t)) - p.logicalOrExpression(f, n.LogicalOrExpression, n.LogicalOrExpression.Operand.Type(), exprBool, flags) - p.w(" { return ") - p.expression(f, n.Expression, t, exprValue, flags) - p.w("}; return ") - p.conditionalExpression(f, n.ConditionalExpression, t, exprValue, flags) - p.w("}()") - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) logicalOrExpression(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprValue: - p.logicalOrExpressionValue(f, n, t, mode, flags) - case exprVoid: - p.logicalOrExpressionVoid(f, n, t, mode, flags) - case exprAddrOf: - p.logicalOrExpressionAddrOf(f, n, t, mode, flags) - case exprBool: - p.logicalOrExpressionBool(f, n, t, mode, flags) - case exprLValue: - p.logicalOrExpressionLValue(f, n, t, mode, flags) - case exprPSelect: - p.logicalOrExpressionPSelect(f, n, t, mode, flags) - case exprFunc: - p.logicalOrExpressionFunc(f, n, t, mode, flags) - case exprSelect: - p.logicalOrExpressionSelect(f, n, t, mode, flags) - case exprDecay: - p.logicalOrExpressionDecay(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) logicalOrExpressionDecay(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.LogicalOrExpressionLAnd: // LogicalAndExpression - p.logicalAndExpression(f, n.LogicalAndExpression, t, mode, flags) - case cc.LogicalOrExpressionLOr: // LogicalOrExpression "||" LogicalAndExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) logicalOrExpressionSelect(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.LogicalOrExpressionLAnd: // LogicalAndExpression - p.logicalAndExpression(f, n.LogicalAndExpression, t, mode, flags) - case cc.LogicalOrExpressionLOr: // LogicalOrExpression "||" LogicalAndExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) logicalOrExpressionFunc(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.LogicalOrExpressionLAnd: // LogicalAndExpression - p.logicalAndExpression(f, n.LogicalAndExpression, t, mode, flags) - case cc.LogicalOrExpressionLOr: // LogicalOrExpression "||" LogicalAndExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) logicalOrExpressionPSelect(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.LogicalOrExpressionLAnd: // LogicalAndExpression - p.logicalAndExpression(f, n.LogicalAndExpression, t, mode, flags) - case cc.LogicalOrExpressionLOr: // LogicalOrExpression "||" LogicalAndExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) logicalOrExpressionLValue(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.LogicalOrExpressionLAnd: // LogicalAndExpression - p.logicalAndExpression(f, n.LogicalAndExpression, t, mode, flags) - case cc.LogicalOrExpressionLOr: // LogicalOrExpression "||" LogicalAndExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) logicalOrExpressionBool(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.LogicalOrExpressionLAnd: // LogicalAndExpression - p.logicalAndExpression(f, n.LogicalAndExpression, t, mode, flags) - case cc.LogicalOrExpressionLOr: // LogicalOrExpression "||" LogicalAndExpression - p.binaryLogicalOrExpression(f, n, t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) logicalOrExpressionAddrOf(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.LogicalOrExpressionLAnd: // LogicalAndExpression - p.logicalAndExpression(f, n.LogicalAndExpression, t, mode, flags) - case cc.LogicalOrExpressionLOr: // LogicalOrExpression "||" LogicalAndExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) logicalOrExpressionVoid(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.LogicalOrExpressionLAnd: // LogicalAndExpression - p.logicalAndExpression(f, n.LogicalAndExpression, t, mode, flags) - case cc.LogicalOrExpressionLOr: // LogicalOrExpression "||" LogicalAndExpression - p.w("_ = ") - p.logicalOrExpression(f, n, n.Operand.Type(), exprValue, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) logicalOrExpressionValue(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.LogicalOrExpressionLAnd: // LogicalAndExpression - p.logicalAndExpression(f, n.LogicalAndExpression, t, mode, flags) - case cc.LogicalOrExpressionLOr: // LogicalOrExpression "||" LogicalAndExpression - p.binaryLogicalOrExpression(f, n, t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) binaryLogicalOrExpression(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprValue: - p.binaryLogicalOrExpressionValue(f, n, t, mode, flags) - case exprBool: - p.binaryLogicalOrExpressionBool(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) binaryLogicalOrExpressionBool(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) { - defer p.w("%s", p.booleanBinaryExpression(n, n.Operand, n.Operand.Type(), &mode, flags)) - p.logicalOrExpression(f, n.LogicalOrExpression, n.LogicalOrExpression.Operand.Type(), exprBool, flags) - p.w(" ||%s", tidyComment(" ", &n.Token)) - p.logicalAndExpression(f, n.LogicalAndExpression, n.LogicalAndExpression.Operand.Type(), exprBool, flags) -} - -func (p *project) binaryLogicalOrExpressionValue(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) { - defer p.w("%s", p.booleanBinaryExpression(n, n.Operand, t, &mode, flags)) - p.logicalOrExpression(f, n.LogicalOrExpression, n.LogicalOrExpression.Operand.Type(), exprBool, flags) - p.w(" ||%s", tidyComment(" ", &n.Token)) - p.logicalAndExpression(f, n.LogicalAndExpression, n.LogicalAndExpression.Operand.Type(), exprBool, flags) -} - -func (p *project) booleanBinaryExpression(n cc.Node, from cc.Operand, to cc.Type, mode *exprMode, flags flags) (r string) { - p.w("(") - r = ")" - switch *mode { - case exprBool: - *mode = exprValue - default: - r = p.convert(n, from, to, flags) + r - p.w("%sBool32(", p.task.crt) - r = ")" + r - } - return r -} - -func (p *project) logicalAndExpression(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprValue: - p.logicalAndExpressionValue(f, n, t, mode, flags) - case exprVoid: - p.logicalAndExpressionVoid(f, n, t, mode, flags) - case exprAddrOf: - p.logicalAndExpressionAddrOf(f, n, t, mode, flags) - case exprBool: - p.logicalAndExpressionBool(f, n, t, mode, flags) - case exprLValue: - p.logicalAndExpressionLValue(f, n, t, mode, flags) - case exprPSelect: - p.logicalAndExpressionPSelect(f, n, t, mode, flags) - case exprFunc: - p.logicalAndExpressionFunc(f, n, t, mode, flags) - case exprSelect: - p.logicalAndExpressionSelect(f, n, t, mode, flags) - case exprDecay: - p.logicalAndExpressionDecay(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) logicalAndExpressionDecay(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.LogicalAndExpressionOr: // InclusiveOrExpression - p.inclusiveOrExpression(f, n.InclusiveOrExpression, t, mode, flags) - case cc.LogicalAndExpressionLAnd: // LogicalAndExpression "&&" InclusiveOrExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) logicalAndExpressionSelect(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.LogicalAndExpressionOr: // InclusiveOrExpression - p.inclusiveOrExpression(f, n.InclusiveOrExpression, t, mode, flags) - case cc.LogicalAndExpressionLAnd: // LogicalAndExpression "&&" InclusiveOrExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) logicalAndExpressionFunc(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.LogicalAndExpressionOr: // InclusiveOrExpression - p.inclusiveOrExpression(f, n.InclusiveOrExpression, t, mode, flags) - case cc.LogicalAndExpressionLAnd: // LogicalAndExpression "&&" InclusiveOrExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) logicalAndExpressionPSelect(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.LogicalAndExpressionOr: // InclusiveOrExpression - p.inclusiveOrExpression(f, n.InclusiveOrExpression, t, mode, flags) - case cc.LogicalAndExpressionLAnd: // LogicalAndExpression "&&" InclusiveOrExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) logicalAndExpressionLValue(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.LogicalAndExpressionOr: // InclusiveOrExpression - p.inclusiveOrExpression(f, n.InclusiveOrExpression, t, mode, flags) - case cc.LogicalAndExpressionLAnd: // LogicalAndExpression "&&" InclusiveOrExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) logicalAndExpressionBool(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.LogicalAndExpressionOr: // InclusiveOrExpression - p.inclusiveOrExpression(f, n.InclusiveOrExpression, t, mode, flags) - case cc.LogicalAndExpressionLAnd: // LogicalAndExpression "&&" InclusiveOrExpression - p.binaryLogicalAndExpression(f, n, t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) logicalAndExpressionAddrOf(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.LogicalAndExpressionOr: // InclusiveOrExpression - p.inclusiveOrExpression(f, n.InclusiveOrExpression, t, mode, flags) - case cc.LogicalAndExpressionLAnd: // LogicalAndExpression "&&" InclusiveOrExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) logicalAndExpressionVoid(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.LogicalAndExpressionOr: // InclusiveOrExpression - p.inclusiveOrExpression(f, n.InclusiveOrExpression, t, mode, flags) - case cc.LogicalAndExpressionLAnd: // LogicalAndExpression "&&" InclusiveOrExpression - p.binaryLogicalAndExpressionValue(f, n, t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) logicalAndExpressionValue(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.LogicalAndExpressionOr: // InclusiveOrExpression - p.inclusiveOrExpression(f, n.InclusiveOrExpression, t, mode, flags) - case cc.LogicalAndExpressionLAnd: // LogicalAndExpression "&&" InclusiveOrExpression - p.binaryLogicalAndExpression(f, n, t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) binaryLogicalAndExpression(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprBool: - p.binaryLogicalAndExpressionBool(f, n, t, mode, flags) - case exprValue: - p.binaryLogicalAndExpressionValue(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) binaryLogicalAndExpressionValue(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) { - defer p.w("%s", p.booleanBinaryExpression(n, n.Operand, t, &mode, flags)) - p.logicalAndExpression(f, n.LogicalAndExpression, n.LogicalAndExpression.Operand.Type(), exprBool, flags) - p.w(" &&%s", tidyComment(" ", &n.Token)) - p.inclusiveOrExpression(f, n.InclusiveOrExpression, n.InclusiveOrExpression.Operand.Type(), exprBool, flags) -} - -func (p *project) binaryLogicalAndExpressionBool(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) { - defer p.w("%s", p.booleanBinaryExpression(n, n.Operand, t, &mode, flags)) - p.logicalAndExpression(f, n.LogicalAndExpression, n.LogicalAndExpression.Operand.Type(), exprBool, flags) - p.w(" &&%s", tidyComment(" ", &n.Token)) - p.inclusiveOrExpression(f, n.InclusiveOrExpression, n.InclusiveOrExpression.Operand.Type(), exprBool, flags) -} - -func (p *project) inclusiveOrExpression(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprValue: - p.inclusiveOrExpressionValue(f, n, t, mode, flags) - case exprVoid: - p.inclusiveOrExpressionVoid(f, n, t, mode, flags) - case exprAddrOf: - p.inclusiveOrExpressionAddrof(f, n, t, mode, flags) - case exprBool: - p.inclusiveOrExpressionBool(f, n, t, mode, flags) - case exprLValue: - p.inclusiveOrExpressionLValue(f, n, t, mode, flags) - case exprPSelect: - p.inclusiveOrExpressionPSelect(f, n, t, mode, flags) - case exprFunc: - p.inclusiveOrExpressionFunc(f, n, t, mode, flags) - case exprSelect: - p.inclusiveOrExpressionSelect(f, n, t, mode, flags) - case exprDecay: - p.inclusiveOrExpressionDecay(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) inclusiveOrExpressionDecay(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.InclusiveOrExpressionXor: // ExclusiveOrExpression - p.exclusiveOrExpression(f, n.ExclusiveOrExpression, t, mode, flags) - case cc.InclusiveOrExpressionOr: // InclusiveOrExpression '|' ExclusiveOrExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) inclusiveOrExpressionSelect(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.InclusiveOrExpressionXor: // ExclusiveOrExpression - p.exclusiveOrExpression(f, n.ExclusiveOrExpression, t, mode, flags) - case cc.InclusiveOrExpressionOr: // InclusiveOrExpression '|' ExclusiveOrExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) inclusiveOrExpressionFunc(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.InclusiveOrExpressionXor: // ExclusiveOrExpression - p.exclusiveOrExpression(f, n.ExclusiveOrExpression, t, mode, flags) - case cc.InclusiveOrExpressionOr: // InclusiveOrExpression '|' ExclusiveOrExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) inclusiveOrExpressionPSelect(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.InclusiveOrExpressionXor: // ExclusiveOrExpression - p.exclusiveOrExpression(f, n.ExclusiveOrExpression, t, mode, flags) - case cc.InclusiveOrExpressionOr: // InclusiveOrExpression '|' ExclusiveOrExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) inclusiveOrExpressionLValue(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.InclusiveOrExpressionXor: // ExclusiveOrExpression - p.exclusiveOrExpression(f, n.ExclusiveOrExpression, t, mode, flags) - case cc.InclusiveOrExpressionOr: // InclusiveOrExpression '|' ExclusiveOrExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) inclusiveOrExpressionBool(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.InclusiveOrExpressionXor: // ExclusiveOrExpression - p.exclusiveOrExpression(f, n.ExclusiveOrExpression, t, mode, flags) - case cc.InclusiveOrExpressionOr: // InclusiveOrExpression '|' ExclusiveOrExpression - p.binaryInclusiveOrExpression(f, n, t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) inclusiveOrExpressionAddrof(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.InclusiveOrExpressionXor: // ExclusiveOrExpression - p.exclusiveOrExpression(f, n.ExclusiveOrExpression, t, mode, flags) - case cc.InclusiveOrExpressionOr: // InclusiveOrExpression '|' ExclusiveOrExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) inclusiveOrExpressionVoid(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.InclusiveOrExpressionXor: // ExclusiveOrExpression - p.exclusiveOrExpression(f, n.ExclusiveOrExpression, t, mode, flags) - case cc.InclusiveOrExpressionOr: // InclusiveOrExpression '|' ExclusiveOrExpression - p.w("_ = ") - p.inclusiveOrExpression(f, n, n.Operand.Type(), exprValue, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) inclusiveOrExpressionValue(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.InclusiveOrExpressionXor: // ExclusiveOrExpression - p.exclusiveOrExpression(f, n.ExclusiveOrExpression, t, mode, flags) - case cc.InclusiveOrExpressionOr: // InclusiveOrExpression '|' ExclusiveOrExpression - p.binaryInclusiveOrExpression(f, n, t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) binaryInclusiveOrExpression(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - // InclusiveOrExpression '|' ExclusiveOrExpression - switch mode { - case exprBool: - p.binaryInclusiveOrExpressionBool(f, n, t, mode, flags) - case exprValue: - p.binaryInclusiveOrExpressionValue(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) binaryInclusiveOrExpressionValue(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - // InclusiveOrExpression '|' ExclusiveOrExpression - - lt := n.InclusiveOrExpression.Operand.Type() - rt := n.ExclusiveOrExpression.Operand.Type() - switch lk, rk := lt.Kind(), rt.Kind(); { - case - lk == cc.UInt128 || rk == cc.UInt128, - lk == cc.Int128 || rk == cc.Int128: - - p.binaryOrExpressionUint128(f, n, t, mode, flags) - return - } - - defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags)) - switch { - case orOverflows(n.InclusiveOrExpression.Operand, n.ExclusiveOrExpression.Operand, n.Promote()): - p.inclusiveOrExpression(f, n.InclusiveOrExpression, n.Promote(), exprValue, flags) - p.w(" |%s", tidyComment(" ", &n.Token)) - p.exclusiveOrExpression(f, n.ExclusiveOrExpression, n.Promote(), exprValue, flags|fForceRuntimeConv) - default: - p.inclusiveOrExpression(f, n.InclusiveOrExpression, n.Promote(), exprValue, flags) - p.w(" |%s", tidyComment(" ", &n.Token)) - p.exclusiveOrExpression(f, n.ExclusiveOrExpression, n.Promote(), exprValue, flags) - } -} - -func (p *project) binaryOrExpressionUint128(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - // InclusiveOrExpression '|' ExclusiveOrExpression - defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags)) - p.inclusiveOrExpression(f, n.InclusiveOrExpression, n.Promote(), exprValue, flags) - p.w(".Or(") - p.exclusiveOrExpression(f, n.ExclusiveOrExpression, n.Promote(), exprValue, flags) - p.w(")") -} - -func (p *project) binaryInclusiveOrExpressionBool(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags)) - switch { - case orOverflows(n.InclusiveOrExpression.Operand, n.ExclusiveOrExpression.Operand, n.Promote()): - p.inclusiveOrExpression(f, n.InclusiveOrExpression, n.Promote(), exprValue, flags) - p.w(" |%s", tidyComment(" ", &n.Token)) - p.exclusiveOrExpression(f, n.ExclusiveOrExpression, n.Promote(), exprValue, flags|fForceRuntimeConv) - default: - p.inclusiveOrExpression(f, n.InclusiveOrExpression, n.Promote(), exprValue, flags) - p.w(" |%s", tidyComment(" ", &n.Token)) - p.exclusiveOrExpression(f, n.ExclusiveOrExpression, n.Promote(), exprValue, flags) - } -} - -func orOverflows(lo, ro cc.Operand, promote cc.Type) bool { - a, b, ok := getIntOperands(lo, ro) - if !ok { - return false - } - - return overflows(a.Or(a, b), promote) -} - -func (p *project) artithmeticBinaryExpression(n cc.Node, from cc.Operand, to cc.Type, mode *exprMode, flags flags) (r string) { - p.w("(") - r = ")" - switch *mode { - case exprBool: - p.w("(") - r = ") != 0" + r - *mode = exprValue - default: - switch fk, tk := from.Type().Kind(), to.Kind(); { - case fk != tk && fk == cc.Int128: - return fmt.Sprintf(".%s()%s", p.helperType(n, to), r) - case fk != tk && fk == cc.UInt128: - return fmt.Sprintf(".%s()%s", p.helperType(n, to), r) - default: - r = p.convert(n, from, to, flags) + r - } - } - return r -} - -func (p *project) exclusiveOrExpression(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprValue: - p.exclusiveOrExpressionValue(f, n, t, mode, flags) - case exprVoid: - p.exclusiveOrExpressionVoid(f, n, t, mode, flags) - case exprAddrOf: - p.exclusiveOrExpressionAddrOf(f, n, t, mode, flags) - case exprBool: - p.exclusiveOrExpressionBool(f, n, t, mode, flags) - case exprLValue: - p.exclusiveOrExpressionLValue(f, n, t, mode, flags) - case exprPSelect: - p.exclusiveOrExpressionPSelect(f, n, t, mode, flags) - case exprFunc: - p.exclusiveOrExpressionFunc(f, n, t, mode, flags) - case exprSelect: - p.exclusiveOrExpressionSelect(f, n, t, mode, flags) - case exprDecay: - p.exclusiveOrExpressionDecay(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) exclusiveOrExpressionDecay(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ExclusiveOrExpressionAnd: // AndExpression - p.andExpression(f, n.AndExpression, t, mode, flags) - case cc.ExclusiveOrExpressionXor: // ExclusiveOrExpression '^' AndExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) exclusiveOrExpressionSelect(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ExclusiveOrExpressionAnd: // AndExpression - p.andExpression(f, n.AndExpression, t, mode, flags) - case cc.ExclusiveOrExpressionXor: // ExclusiveOrExpression '^' AndExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) exclusiveOrExpressionFunc(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ExclusiveOrExpressionAnd: // AndExpression - p.andExpression(f, n.AndExpression, t, mode, flags) - case cc.ExclusiveOrExpressionXor: // ExclusiveOrExpression '^' AndExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) exclusiveOrExpressionPSelect(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ExclusiveOrExpressionAnd: // AndExpression - p.andExpression(f, n.AndExpression, t, mode, flags) - case cc.ExclusiveOrExpressionXor: // ExclusiveOrExpression '^' AndExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) exclusiveOrExpressionLValue(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ExclusiveOrExpressionAnd: // AndExpression - p.andExpression(f, n.AndExpression, t, mode, flags) - case cc.ExclusiveOrExpressionXor: // ExclusiveOrExpression '^' AndExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) exclusiveOrExpressionBool(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ExclusiveOrExpressionAnd: // AndExpression - p.andExpression(f, n.AndExpression, t, mode, flags) - case cc.ExclusiveOrExpressionXor: // ExclusiveOrExpression '^' AndExpression - p.binaryExclusiveOrExpression(f, n, t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) exclusiveOrExpressionAddrOf(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ExclusiveOrExpressionAnd: // AndExpression - p.andExpression(f, n.AndExpression, t, mode, flags) - case cc.ExclusiveOrExpressionXor: // ExclusiveOrExpression '^' AndExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) exclusiveOrExpressionVoid(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ExclusiveOrExpressionAnd: // AndExpression - p.andExpression(f, n.AndExpression, t, mode, flags) - case cc.ExclusiveOrExpressionXor: // ExclusiveOrExpression '^' AndExpression - p.w("_ = ") - p.exclusiveOrExpression(f, n, n.Operand.Type(), exprValue, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) exclusiveOrExpressionValue(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ExclusiveOrExpressionAnd: // AndExpression - p.andExpression(f, n.AndExpression, t, mode, flags) - case cc.ExclusiveOrExpressionXor: // ExclusiveOrExpression '^' AndExpression - p.binaryExclusiveOrExpression(f, n, t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) binaryExclusiveOrExpression(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - // ExclusiveOrExpression '^' AndExpression - switch mode { - case exprValue, exprBool: - p.binaryExclusiveOrExpressionValue(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) binaryExclusiveOrExpressionValue(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - // ExclusiveOrExpression '^' AndExpression - - lt := n.ExclusiveOrExpression.Operand.Type() - rt := n.AndExpression.Operand.Type() - switch lk, rk := lt.Kind(), rt.Kind(); { - case - lk == cc.UInt128 || rk == cc.UInt128, - lk == cc.Int128 || rk == cc.Int128: - - p.binaryExclusiveOrExpressionUint128(f, n, t, mode, flags) - return - } - - defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags)) - switch { - case xorOverflows(n.ExclusiveOrExpression.Operand, n.AndExpression.Operand, n.Promote()): - p.exclusiveOrExpression(f, n.ExclusiveOrExpression, n.Promote(), exprValue, flags) - p.w(" ^%s", tidyComment(" ", &n.Token)) - p.andExpression(f, n.AndExpression, n.Promote(), exprValue, flags|fForceRuntimeConv) - default: - p.exclusiveOrExpression(f, n.ExclusiveOrExpression, n.Promote(), exprValue, flags) - p.w(" ^%s", tidyComment(" ", &n.Token)) - p.andExpression(f, n.AndExpression, n.Promote(), exprValue, flags) - } -} - -func (p *project) binaryExclusiveOrExpressionUint128(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) { - // ExclusiveOrExpression '^' AndExpression - defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags)) - p.exclusiveOrExpression(f, n.ExclusiveOrExpression, n.Promote(), exprValue, flags) - p.w(".Xor(") - p.andExpression(f, n.AndExpression, n.Promote(), exprValue, flags) - p.w(")") -} - -func xorOverflows(lo, ro cc.Operand, promote cc.Type) bool { - a, b, ok := getIntOperands(lo, ro) - if !ok { - return false - } - - return !lo.Type().IsSignedType() && a.Sign() == 0 || - !ro.Type().IsSignedType() && b.Sign() == 0 || - overflows(a.Xor(a, b), promote) -} - -func (p *project) andExpression(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprValue: - p.andExpressionValue(f, n, t, mode, flags) - case exprVoid: - p.andExpressionVoid(f, n, t, mode, flags) - case exprAddrOf: - p.andExpressionAddrof(f, n, t, mode, flags) - case exprBool: - p.andExpressionBool(f, n, t, mode, flags) - case exprLValue: - p.andExpressionLValue(f, n, t, mode, flags) - case exprPSelect: - p.andExpressionPSelect(f, n, t, mode, flags) - case exprFunc: - p.andExpressionFunc(f, n, t, mode, flags) - case exprSelect: - p.andExpressionSelect(f, n, t, mode, flags) - case exprDecay: - p.andExpressionDecay(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) andExpressionDecay(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AndExpressionEq: // EqualityExpression - p.equalityExpression(f, n.EqualityExpression, t, mode, flags) - case cc.AndExpressionAnd: // AndExpression '&' EqualityExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) andExpressionSelect(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AndExpressionEq: // EqualityExpression - p.equalityExpression(f, n.EqualityExpression, t, mode, flags) - case cc.AndExpressionAnd: // AndExpression '&' EqualityExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) andExpressionFunc(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AndExpressionEq: // EqualityExpression - p.equalityExpression(f, n.EqualityExpression, t, mode, flags) - case cc.AndExpressionAnd: // AndExpression '&' EqualityExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) andExpressionPSelect(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AndExpressionEq: // EqualityExpression - p.equalityExpression(f, n.EqualityExpression, t, mode, flags) - case cc.AndExpressionAnd: // AndExpression '&' EqualityExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) andExpressionLValue(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AndExpressionEq: // EqualityExpression - p.equalityExpression(f, n.EqualityExpression, t, mode, flags) - case cc.AndExpressionAnd: // AndExpression '&' EqualityExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) andExpressionBool(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AndExpressionEq: // EqualityExpression - p.equalityExpression(f, n.EqualityExpression, t, mode, flags) - case cc.AndExpressionAnd: // AndExpression '&' EqualityExpression - p.binaryAndExpression(f, n, t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) andExpressionAddrof(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AndExpressionEq: // EqualityExpression - p.equalityExpression(f, n.EqualityExpression, t, mode, flags) - case cc.AndExpressionAnd: // AndExpression '&' EqualityExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) andExpressionVoid(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AndExpressionEq: // EqualityExpression - p.equalityExpression(f, n.EqualityExpression, t, mode, flags) - case cc.AndExpressionAnd: // AndExpression '&' EqualityExpression - p.w("_ = ") - p.andExpression(f, n, n.Operand.Type(), exprValue, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) andExpressionValue(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AndExpressionEq: // EqualityExpression - p.equalityExpression(f, n.EqualityExpression, t, mode, flags) - case cc.AndExpressionAnd: // AndExpression '&' EqualityExpression - p.binaryAndExpression(f, n, t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) binaryAndExpression(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) { - // AndExpression '&' EqualityExpression - switch mode { - case exprValue: - p.binaryAndExpressionValue(f, n, t, mode, flags) - case exprBool: - p.binaryAndExpressionBool(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) binaryAndExpressionBool(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) { - defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, n.Operand.Type(), &mode, flags)) - switch { - case andOverflows(n.AndExpression.Operand, n.EqualityExpression.Operand, n.Promote()): - p.andExpression(f, n.AndExpression, n.Promote(), exprValue, flags) - p.w(" &%s", tidyComment(" ", &n.Token)) - p.equalityExpression(f, n.EqualityExpression, n.Promote(), exprValue, flags|fForceRuntimeConv) - default: - p.andExpression(f, n.AndExpression, n.Promote(), exprValue, flags) - p.w(" &%s", tidyComment(" ", &n.Token)) - p.equalityExpression(f, n.EqualityExpression, n.Promote(), exprValue, flags) - } -} - -func (p *project) binaryAndExpressionValue(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) { - // AndExpression '&' EqualityExpression - - lt := n.AndExpression.Operand.Type() - rt := n.EqualityExpression.Operand.Type() - switch lk, rk := lt.Kind(), rt.Kind(); { - case - lk == cc.UInt128 || rk == cc.UInt128, - lk == cc.Int128 || rk == cc.Int128: - - p.binaryAndExpressionUint128(f, n, t, mode, flags) - return - } - - defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags)) - switch { - case andOverflows(n.AndExpression.Operand, n.EqualityExpression.Operand, n.Promote()): - p.andExpression(f, n.AndExpression, n.Promote(), exprValue, flags) - p.w(" &%s", tidyComment(" ", &n.Token)) - p.equalityExpression(f, n.EqualityExpression, n.Promote(), exprValue, flags|fForceRuntimeConv) - default: - p.andExpression(f, n.AndExpression, n.Promote(), exprValue, flags) - p.w(" &%s", tidyComment(" ", &n.Token)) - p.equalityExpression(f, n.EqualityExpression, n.Promote(), exprValue, flags) - } -} - -func (p *project) binaryAndExpressionUint128(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) { - // AndExpression '&' EqualityExpression - defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags)) - p.andExpression(f, n.AndExpression, n.Promote(), exprValue, flags) - p.w(".And(") - p.equalityExpression(f, n.EqualityExpression, n.Promote(), exprValue, flags) - p.w(")") -} - -func andOverflows(lo, ro cc.Operand, promote cc.Type) bool { - a, b, ok := getIntOperands(lo, ro) - if !ok { - return false - } - - return overflows(a.And(a, b), promote) -} - -func (p *project) equalityExpression(f *function, n *cc.EqualityExpression, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprValue: - p.equalityExpressionValue(f, n, t, mode, flags) - case exprVoid: - p.equalityExpressionVoid(f, n, t, mode, flags) - case exprAddrOf: - p.equalityExpressionAddrOf(f, n, t, mode, flags) - case exprBool: - p.equalityExpressionBool(f, n, t, mode, flags) - case exprLValue: - p.equalityExpressionLValue(f, n, t, mode, flags) - case exprPSelect: - p.equalityExpressionPSelect(f, n, t, mode, flags) - case exprFunc: - p.equalityExpressionFunc(f, n, t, mode, flags) - case exprSelect: - p.equalityExpressionSelect(f, n, t, mode, flags) - case exprDecay: - p.equalityExpressionDecay(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) equalityExpressionDecay(f *function, n *cc.EqualityExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.EqualityExpressionRel: // RelationalExpression - p.relationalExpression(f, n.RelationalExpression, t, mode, flags) - case cc.EqualityExpressionEq: // EqualityExpression "==" RelationalExpression - panic(todo("", p.pos(n))) - case cc.EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) equalityExpressionSelect(f *function, n *cc.EqualityExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.EqualityExpressionRel: // RelationalExpression - p.relationalExpression(f, n.RelationalExpression, t, mode, flags) - case cc.EqualityExpressionEq: // EqualityExpression "==" RelationalExpression - panic(todo("", p.pos(n))) - case cc.EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) equalityExpressionFunc(f *function, n *cc.EqualityExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.EqualityExpressionRel: // RelationalExpression - p.relationalExpression(f, n.RelationalExpression, t, mode, flags) - case cc.EqualityExpressionEq: // EqualityExpression "==" RelationalExpression - panic(todo("", p.pos(n))) - case cc.EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) equalityExpressionPSelect(f *function, n *cc.EqualityExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.EqualityExpressionRel: // RelationalExpression - p.relationalExpression(f, n.RelationalExpression, t, mode, flags) - case cc.EqualityExpressionEq: // EqualityExpression "==" RelationalExpression - panic(todo("", p.pos(n))) - case cc.EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) equalityExpressionLValue(f *function, n *cc.EqualityExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.EqualityExpressionRel: // RelationalExpression - p.relationalExpression(f, n.RelationalExpression, t, mode, flags) - case cc.EqualityExpressionEq: // EqualityExpression "==" RelationalExpression - panic(todo("", p.pos(n))) - case cc.EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) equalityExpressionBool(f *function, n *cc.EqualityExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.EqualityExpressionRel: // RelationalExpression - p.relationalExpression(f, n.RelationalExpression, t, mode, flags) - case cc.EqualityExpressionEq: // EqualityExpression "==" RelationalExpression - p.binaryEqualityExpression(f, n, " == ", t, mode, flags) - case cc.EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression - p.binaryEqualityExpression(f, n, " != ", t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) equalityExpressionAddrOf(f *function, n *cc.EqualityExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.EqualityExpressionRel: // RelationalExpression - p.relationalExpression(f, n.RelationalExpression, t, mode, flags) - case cc.EqualityExpressionEq: // EqualityExpression "==" RelationalExpression - panic(todo("", p.pos(n))) - case cc.EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) equalityExpressionVoid(f *function, n *cc.EqualityExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.EqualityExpressionRel: // RelationalExpression - p.relationalExpression(f, n.RelationalExpression, t, mode, flags) - default: - // case cc.EqualityExpressionEq: // EqualityExpression "==" RelationalExpression - // case cc.EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression - p.w("_ = ") - p.equalityExpression(f, n, n.Operand.Type(), exprValue, flags) - } -} - -func (p *project) equalityExpressionValue(f *function, n *cc.EqualityExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.EqualityExpressionRel: // RelationalExpression - p.relationalExpression(f, n.RelationalExpression, t, mode, flags) - case cc.EqualityExpressionEq: // EqualityExpression "==" RelationalExpression - p.binaryEqualityExpression(f, n, " == ", t, mode, flags) - case cc.EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression - p.binaryEqualityExpression(f, n, " != ", t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) binaryEqualityExpression(f *function, n *cc.EqualityExpression, oper string, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprValue: - p.binaryEqualityExpressionValue(f, n, oper, t, mode, flags) - case exprBool: - p.binaryEqualityExpressionBool(f, n, oper, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) binaryEqualityExpressionBool(f *function, n *cc.EqualityExpression, oper string, t cc.Type, mode exprMode, flags flags) { - defer p.w("%s", p.booleanBinaryExpression(n, n.Operand, t, &mode, flags)) - p.equalityExpression(f, n.EqualityExpression, n.Promote(), exprValue, flags) - p.w(" %s%s", oper, tidyComment(" ", &n.Token)) - p.relationalExpression(f, n.RelationalExpression, n.Promote(), exprValue, flags) -} - -func (p *project) binaryEqualityExpressionValue(f *function, n *cc.EqualityExpression, oper string, t cc.Type, mode exprMode, flags flags) { - defer p.w("%s", p.booleanBinaryExpression(n, n.Operand, t, &mode, flags)) - p.equalityExpression(f, n.EqualityExpression, n.Promote(), exprValue, flags) - p.w(" %s%s", oper, tidyComment(" ", &n.Token)) - p.relationalExpression(f, n.RelationalExpression, n.Promote(), exprValue, flags) -} - -func (p *project) relationalExpression(f *function, n *cc.RelationalExpression, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprValue: - p.relationalExpressionValue(f, n, t, mode, flags) - case exprVoid: - p.relationalExpressionVoid(f, n, t, mode, flags) - case exprAddrOf: - p.relationalExpressionAddrOf(f, n, t, mode, flags) - case exprBool: - p.relationalExpressionBool(f, n, t, mode, flags) - case exprLValue: - p.relationalExpressionLValue(f, n, t, mode, flags) - case exprPSelect: - p.relationalExpressionPSelect(f, n, t, mode, flags) - case exprFunc: - p.relationalExpressionFunc(f, n, t, mode, flags) - case exprSelect: - p.relationalExpressionSelect(f, n, t, mode, flags) - case exprDecay: - p.relationalExpressionDecay(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) relationalExpressionDecay(f *function, n *cc.RelationalExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.RelationalExpressionShift: // ShiftExpression - p.shiftExpression(f, n.ShiftExpression, t, mode, flags) - case cc.RelationalExpressionLt: // RelationalExpression '<' ShiftExpression - panic(todo("", p.pos(n))) - case cc.RelationalExpressionGt: // RelationalExpression '>' ShiftExpression - panic(todo("", p.pos(n))) - case cc.RelationalExpressionLeq: // RelationalExpression "<=" ShiftExpression - panic(todo("", p.pos(n))) - case cc.RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) relationalExpressionSelect(f *function, n *cc.RelationalExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.RelationalExpressionShift: // ShiftExpression - p.shiftExpression(f, n.ShiftExpression, t, mode, flags) - case cc.RelationalExpressionLt: // RelationalExpression '<' ShiftExpression - panic(todo("", p.pos(n))) - case cc.RelationalExpressionGt: // RelationalExpression '>' ShiftExpression - panic(todo("", p.pos(n))) - case cc.RelationalExpressionLeq: // RelationalExpression "<=" ShiftExpression - panic(todo("", p.pos(n))) - case cc.RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) relationalExpressionFunc(f *function, n *cc.RelationalExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.RelationalExpressionShift: // ShiftExpression - p.shiftExpression(f, n.ShiftExpression, t, mode, flags) - case cc.RelationalExpressionLt: // RelationalExpression '<' ShiftExpression - panic(todo("", p.pos(n))) - case cc.RelationalExpressionGt: // RelationalExpression '>' ShiftExpression - panic(todo("", p.pos(n))) - case cc.RelationalExpressionLeq: // RelationalExpression "<=" ShiftExpression - panic(todo("", p.pos(n))) - case cc.RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) relationalExpressionPSelect(f *function, n *cc.RelationalExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.RelationalExpressionShift: // ShiftExpression - p.shiftExpression(f, n.ShiftExpression, t, mode, flags) - case cc.RelationalExpressionLt: // RelationalExpression '<' ShiftExpression - panic(todo("", p.pos(n))) - case cc.RelationalExpressionGt: // RelationalExpression '>' ShiftExpression - panic(todo("", p.pos(n))) - case cc.RelationalExpressionLeq: // RelationalExpression "<=" ShiftExpression - panic(todo("", p.pos(n))) - case cc.RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) relationalExpressionLValue(f *function, n *cc.RelationalExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.RelationalExpressionShift: // ShiftExpression - p.shiftExpression(f, n.ShiftExpression, t, mode, flags) - case cc.RelationalExpressionLt: // RelationalExpression '<' ShiftExpression - panic(todo("", p.pos(n))) - case cc.RelationalExpressionGt: // RelationalExpression '>' ShiftExpression - panic(todo("", p.pos(n))) - case cc.RelationalExpressionLeq: // RelationalExpression "<=" ShiftExpression - panic(todo("", p.pos(n))) - case cc.RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) relationalExpressionBool(f *function, n *cc.RelationalExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.RelationalExpressionShift: // ShiftExpression - p.shiftExpression(f, n.ShiftExpression, t, mode, flags) - case cc.RelationalExpressionLt: // RelationalExpression '<' ShiftExpression - p.binaryRelationalExpression(f, n, " < ", t, mode, flags) - case cc.RelationalExpressionGt: // RelationalExpression '>' ShiftExpression - p.binaryRelationalExpression(f, n, " > ", t, mode, flags) - case cc.RelationalExpressionLeq: // RelationalExpression "<=" ShiftExpression - p.binaryRelationalExpression(f, n, " <= ", t, mode, flags) - case cc.RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression - p.binaryRelationalExpression(f, n, " >= ", t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) relationalExpressionAddrOf(f *function, n *cc.RelationalExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.RelationalExpressionShift: // ShiftExpression - p.shiftExpression(f, n.ShiftExpression, t, mode, flags) - case cc.RelationalExpressionLt: // RelationalExpression '<' ShiftExpression - panic(todo("", p.pos(n))) - case cc.RelationalExpressionGt: // RelationalExpression '>' ShiftExpression - panic(todo("", p.pos(n))) - case cc.RelationalExpressionLeq: // RelationalExpression "<=" ShiftExpression - panic(todo("", p.pos(n))) - case cc.RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) relationalExpressionVoid(f *function, n *cc.RelationalExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.RelationalExpressionShift: // ShiftExpression - p.shiftExpression(f, n.ShiftExpression, t, mode, flags) - default: - // case cc.RelationalExpressionLt: // RelationalExpression '<' ShiftExpression - // case cc.RelationalExpressionGt: // RelationalExpression '>' ShiftExpression - // case cc.RelationalExpressionLeq: // RelationalExpression "<=" ShiftExpression - // case cc.RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression - p.w("_ = ") - p.relationalExpression(f, n, n.Operand.Type(), exprValue, flags) - } -} - -func (p *project) relationalExpressionValue(f *function, n *cc.RelationalExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.RelationalExpressionShift: // ShiftExpression - p.shiftExpression(f, n.ShiftExpression, t, mode, flags) - case cc.RelationalExpressionLt: // RelationalExpression '<' ShiftExpression - p.binaryRelationalExpression(f, n, " < ", t, mode, flags) - case cc.RelationalExpressionGt: // RelationalExpression '>' ShiftExpression - p.binaryRelationalExpression(f, n, " > ", t, mode, flags) - case cc.RelationalExpressionLeq: // RelationalExpression "<=" ShiftExpression - p.binaryRelationalExpression(f, n, " <= ", t, mode, flags) - case cc.RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression - p.binaryRelationalExpression(f, n, " >= ", t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) binaryRelationalExpression(f *function, n *cc.RelationalExpression, oper string, t cc.Type, mode exprMode, flags flags) { - // RelationalExpression "<=" ShiftExpression - lt := n.RelationalExpression.Operand.Type() - rt := n.ShiftExpression.Operand.Type() - switch lk, rk := lt.Kind(), rt.Kind(); { - case - lk == cc.UInt128 || rk == cc.UInt128, - lk == cc.Int128 || rk == cc.Int128: - - p.binaryRelationalExpressionInt128(f, n, oper, t, mode, flags) - return - } - - defer p.w("%s", p.booleanBinaryExpression(n, n.Operand, t, &mode, flags)) - p.relationalExpression(f, n.RelationalExpression, n.Promote(), exprValue, flags) - p.w(" %s%s", oper, tidyComment(" ", &n.Token)) - p.shiftExpression(f, n.ShiftExpression, n.Promote(), exprValue, flags) -} - -func (p *project) binaryRelationalExpressionInt128(f *function, n *cc.RelationalExpression, oper string, t cc.Type, mode exprMode, flags flags) { - // RelationalExpression "<=" ShiftExpression - defer p.w("%s", p.booleanBinaryExpression(n, n.Operand, t, &mode, flags)) - p.relationalExpression(f, n.RelationalExpression, n.Promote(), exprValue, flags) - p.w(".Cmp(") - p.shiftExpression(f, n.ShiftExpression, n.Promote(), exprValue, flags) - p.w(") %s 0", oper) -} - -func (p *project) shiftExpression(f *function, n *cc.ShiftExpression, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprValue: - p.shiftExpressionValue(f, n, t, mode, flags) - case exprVoid: - p.shiftExpressionVoid(f, n, t, mode, flags) - case exprAddrOf: - p.shiftExpressionAddrOf(f, n, t, mode, flags) - case exprBool: - p.shiftExpressionBool(f, n, t, mode, flags) - case exprLValue: - p.shiftExpressionLValue(f, n, t, mode, flags) - case exprPSelect: - p.shiftExpressionPSelect(f, n, t, mode, flags) - case exprFunc: - p.shiftExpressionFunc(f, n, t, mode, flags) - case exprSelect: - p.shiftExpressionSelect(f, n, t, mode, flags) - case exprDecay: - p.shiftExpressionDecay(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) shiftExpressionDecay(f *function, n *cc.ShiftExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ShiftExpressionAdd: // AdditiveExpression - p.additiveExpression(f, n.AdditiveExpression, t, mode, flags) - case cc.ShiftExpressionLsh: // ShiftExpression "<<" AdditiveExpression - panic(todo("", p.pos(n))) - case cc.ShiftExpressionRsh: // ShiftExpression ">>" AdditiveExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) shiftExpressionSelect(f *function, n *cc.ShiftExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ShiftExpressionAdd: // AdditiveExpression - p.additiveExpression(f, n.AdditiveExpression, t, mode, flags) - case cc.ShiftExpressionLsh: // ShiftExpression "<<" AdditiveExpression - panic(todo("", p.pos(n))) - case cc.ShiftExpressionRsh: // ShiftExpression ">>" AdditiveExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) shiftExpressionFunc(f *function, n *cc.ShiftExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ShiftExpressionAdd: // AdditiveExpression - p.additiveExpression(f, n.AdditiveExpression, t, mode, flags) - case cc.ShiftExpressionLsh: // ShiftExpression "<<" AdditiveExpression - panic(todo("", p.pos(n))) - case cc.ShiftExpressionRsh: // ShiftExpression ">>" AdditiveExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) shiftExpressionPSelect(f *function, n *cc.ShiftExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ShiftExpressionAdd: // AdditiveExpression - p.additiveExpression(f, n.AdditiveExpression, t, mode, flags) - case cc.ShiftExpressionLsh: // ShiftExpression "<<" AdditiveExpression - panic(todo("", p.pos(n))) - case cc.ShiftExpressionRsh: // ShiftExpression ">>" AdditiveExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) shiftExpressionLValue(f *function, n *cc.ShiftExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ShiftExpressionAdd: // AdditiveExpression - p.additiveExpression(f, n.AdditiveExpression, t, mode, flags) - case cc.ShiftExpressionLsh: // ShiftExpression "<<" AdditiveExpression - panic(todo("", p.pos(n))) - case cc.ShiftExpressionRsh: // ShiftExpression ">>" AdditiveExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) shiftExpressionBool(f *function, n *cc.ShiftExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ShiftExpressionAdd: // AdditiveExpression - p.additiveExpression(f, n.AdditiveExpression, t, mode, flags) - case cc.ShiftExpressionLsh: // ShiftExpression "<<" AdditiveExpression - p.binaryShiftExpression(f, n, "<<", t, mode, flags) - case cc.ShiftExpressionRsh: // ShiftExpression ">>" AdditiveExpression - p.binaryShiftExpression(f, n, ">>", t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) shiftExpressionAddrOf(f *function, n *cc.ShiftExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ShiftExpressionAdd: // AdditiveExpression - p.additiveExpression(f, n.AdditiveExpression, t, mode, flags) - case cc.ShiftExpressionLsh: // ShiftExpression "<<" AdditiveExpression - panic(todo("", p.pos(n))) - case cc.ShiftExpressionRsh: // ShiftExpression ">>" AdditiveExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) shiftExpressionVoid(f *function, n *cc.ShiftExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ShiftExpressionAdd: // AdditiveExpression - p.additiveExpression(f, n.AdditiveExpression, t, mode, flags) - case cc.ShiftExpressionLsh: // ShiftExpression "<<" AdditiveExpression - panic(todo("", p.pos(n))) - case cc.ShiftExpressionRsh: // ShiftExpression ">>" AdditiveExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) shiftExpressionValue(f *function, n *cc.ShiftExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.ShiftExpressionAdd: // AdditiveExpression - p.additiveExpression(f, n.AdditiveExpression, t, mode, flags) - case cc.ShiftExpressionLsh: // ShiftExpression "<<" AdditiveExpression - p.binaryShiftExpression(f, n, "<<", t, mode, flags) - case cc.ShiftExpressionRsh: // ShiftExpression ">>" AdditiveExpression - p.binaryShiftExpression(f, n, ">>", t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) binaryShiftExpression(f *function, n *cc.ShiftExpression, oper string, t cc.Type, mode exprMode, flags flags) { - // ShiftExpression "<<" AdditiveExpression - switch mode { - case exprValue: - p.binaryShiftExpressionValue(f, n, oper, t, mode, flags) - case exprBool: - p.binaryShiftExpressionBool(f, n, oper, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) todo(n cc.Node, t cc.Type) { - p.w("func() %s { panic(`%v: TODO (%v)`)}()", p.typ(n, t), n.Position(), origin(2)) -} - -func (p *project) binaryShiftExpressionBool(f *function, n *cc.ShiftExpression, oper string, t cc.Type, mode exprMode, flags flags) { - defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, n.Operand.Type(), &mode, flags)) - switch { - case n.ShiftExpression.Operand.Type().IsBitFieldType(): - p.w("(") - p.shiftExpression(f, n.ShiftExpression, n.Operand.Type(), exprValue, flags) - p.w(" %s%s", oper, tidyComment(" ", &n.Token)) - p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags) - p.w(")&%#x", bfValueMask(n.ShiftExpression.Operand.Type().BitField())) - case shiftOverflows(n, n.ShiftExpression.Operand, n.AdditiveExpression.Operand, oper, n.Operand.Type()): - p.shiftExpression(f, n.ShiftExpression, n.Operand.Type(), exprValue, flags|fForceRuntimeConv) - p.w(" %s%s", oper, tidyComment(" ", &n.Token)) - p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags) - case isConstInteger(n.ShiftExpression.Operand): - s := p.convertNil(n, n.Operand.Type(), 0) - p.shiftExpression(f, n.ShiftExpression, n.Operand.Type(), exprValue, flags) - p.w("%s %s%s", s, oper, tidyComment(" ", &n.Token)) - p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags) - default: - p.shiftExpression(f, n.ShiftExpression, n.Operand.Type(), exprValue, flags) - p.w(" %s%s", oper, tidyComment(" ", &n.Token)) - p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags) - } -} - -func shiftOp(s string) string { - switch s { - case "<<": - return "Shl" - case ">>": - return "Shr" - default: - panic(todo("%q", s)) - } -} - -func bfValueMask(bf cc.Field) uint64 { - return uint64(1)<<bf.BitFieldWidth() - 1 -} - -func (p *project) binaryShiftExpressionValue(f *function, n *cc.ShiftExpression, oper string, t cc.Type, mode exprMode, flags flags) { - // ShiftExpression "<<" AdditiveExpression - defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags)) - switch k := n.ShiftExpression.Operand.Type().Kind(); { - case k == cc.Int128, k == cc.UInt128: - p.w("(") - p.shiftExpression(f, n.ShiftExpression, n.Operand.Type(), exprValue, flags) - p.w(").%s(", shiftOp(oper)) - p.additiveExpression(f, n.AdditiveExpression, p.intType, exprValue, flags) - p.w(")") - case n.ShiftExpression.Operand.Type().IsBitFieldType(): - p.w("(") - p.shiftExpression(f, n.ShiftExpression, n.Operand.Type(), exprValue, flags) - p.w(" %s%s", oper, tidyComment(" ", &n.Token)) - p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags) - p.w(")&%#x", bfValueMask(n.ShiftExpression.Operand.Type().BitField())) - case shiftOverflows(n, n.ShiftExpression.Operand, n.AdditiveExpression.Operand, oper, n.Operand.Type()): - p.shiftExpression(f, n.ShiftExpression, n.Operand.Type(), exprValue, flags|fForceRuntimeConv) - p.w(" %s%s", oper, tidyComment(" ", &n.Token)) - p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags) - case isConstInteger(n.ShiftExpression.Operand): - s := p.convertNil(n, n.Operand.Type(), 0) - p.shiftExpression(f, n.ShiftExpression, n.Operand.Type(), exprValue, flags) - p.w("%s %s%s", s, oper, tidyComment(" ", &n.Token)) - p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags) - default: - p.shiftExpression(f, n.ShiftExpression, n.Operand.Type(), exprValue, flags) - p.w(" %s%s", oper, tidyComment(" ", &n.Token)) - p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags) - } -} - -func shiftOverflows(n cc.Node, lo, ro cc.Operand, oper string, result cc.Type) bool { - a, b, ok := getIntOperands(lo, ro) - if !ok { - return false - } - - if !b.IsUint64() { - return true - } - - bits := b.Uint64() - if bits > mathutil.MaxUint { - return true - } - - switch oper { - case "<<": - return overflows(a.Lsh(a, uint(bits)), result) - case ">>": - return overflows(a.Rsh(a, uint(bits)), result) - default: - panic(todo("", pos(n))) - } -} - -func (p *project) additiveExpression(f *function, n *cc.AdditiveExpression, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprValue: - p.additiveExpressionValue(f, n, t, mode, flags) - case exprVoid: - p.additiveExpressionVoid(f, n, t, mode, flags) - case exprAddrOf: - p.additiveExpressionAddrOf(f, n, t, mode, flags) - case exprBool: - p.additiveExpressionBool(f, n, t, mode, flags) - case exprLValue: - p.additiveExpressionLValue(f, n, t, mode, flags) - case exprPSelect: - p.additiveExpressionPSelect(f, n, t, mode, flags) - case exprFunc: - p.additiveExpressionFunc(f, n, t, mode, flags) - case exprSelect: - p.additiveExpressionSelect(f, n, t, mode, flags) - case exprDecay: - p.additiveExpressionDecay(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) additiveExpressionDecay(f *function, n *cc.AdditiveExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AdditiveExpressionMul: // MultiplicativeExpression - p.multiplicativeExpression(f, n.MultiplicativeExpression, t, mode, flags) - case cc.AdditiveExpressionAdd: // AdditiveExpression '+' MultiplicativeExpression - panic(todo("", p.pos(n))) - case cc.AdditiveExpressionSub: // AdditiveExpression '-' MultiplicativeExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) additiveExpressionSelect(f *function, n *cc.AdditiveExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AdditiveExpressionMul: // MultiplicativeExpression - p.multiplicativeExpression(f, n.MultiplicativeExpression, t, mode, flags) - case cc.AdditiveExpressionAdd: // AdditiveExpression '+' MultiplicativeExpression - panic(todo("", p.pos(n))) - case cc.AdditiveExpressionSub: // AdditiveExpression '-' MultiplicativeExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) additiveExpressionFunc(f *function, n *cc.AdditiveExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AdditiveExpressionMul: // MultiplicativeExpression - p.multiplicativeExpression(f, n.MultiplicativeExpression, t, mode, flags) - case cc.AdditiveExpressionAdd: // AdditiveExpression '+' MultiplicativeExpression - panic(todo("", p.pos(n))) - case cc.AdditiveExpressionSub: // AdditiveExpression '-' MultiplicativeExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) additiveExpressionPSelect(f *function, n *cc.AdditiveExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AdditiveExpressionMul: // MultiplicativeExpression - p.multiplicativeExpression(f, n.MultiplicativeExpression, t, mode, flags) - case cc.AdditiveExpressionAdd: // AdditiveExpression '+' MultiplicativeExpression - p.w("(*%s)(unsafe.Pointer(", p.typ(n, t.Elem())) - p.additiveExpression(f, n, t, exprValue, flags) - p.w("))") - case cc.AdditiveExpressionSub: // AdditiveExpression '-' MultiplicativeExpression - p.w("(*%s)(unsafe.Pointer(", p.typ(n, t.Elem())) - p.additiveExpression(f, n, t, exprValue, flags) - - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) additiveExpressionLValue(f *function, n *cc.AdditiveExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AdditiveExpressionMul: // MultiplicativeExpression - p.multiplicativeExpression(f, n.MultiplicativeExpression, t, mode, flags) - case cc.AdditiveExpressionAdd: // AdditiveExpression '+' MultiplicativeExpression - panic(todo("", p.pos(n))) - case cc.AdditiveExpressionSub: // AdditiveExpression '-' MultiplicativeExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) additiveExpressionBool(f *function, n *cc.AdditiveExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AdditiveExpressionMul: // MultiplicativeExpression - p.multiplicativeExpression(f, n.MultiplicativeExpression, t, mode, flags) - case cc.AdditiveExpressionAdd: // AdditiveExpression '+' MultiplicativeExpression - p.binaryAdditiveExpression(f, n, "+", t, mode, flags) - case cc.AdditiveExpressionSub: // AdditiveExpression '-' MultiplicativeExpression - p.binaryAdditiveExpression(f, n, "-", t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) additiveExpressionAddrOf(f *function, n *cc.AdditiveExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AdditiveExpressionMul: // MultiplicativeExpression - p.multiplicativeExpression(f, n.MultiplicativeExpression, t, mode, flags) - case cc.AdditiveExpressionAdd: // AdditiveExpression '+' MultiplicativeExpression - panic(todo("", p.pos(n))) - case cc.AdditiveExpressionSub: // AdditiveExpression '-' MultiplicativeExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) additiveExpressionVoid(f *function, n *cc.AdditiveExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AdditiveExpressionMul: // MultiplicativeExpression - p.multiplicativeExpression(f, n.MultiplicativeExpression, t, mode, flags) - case - cc.AdditiveExpressionAdd, // AdditiveExpression '+' MultiplicativeExpression - cc.AdditiveExpressionSub: // AdditiveExpression '-' MultiplicativeExpression - - p.w("_ = ") - p.additiveExpression(f, n, n.Operand.Type(), exprValue, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) additiveExpressionValue(f *function, n *cc.AdditiveExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.AdditiveExpressionMul: // MultiplicativeExpression - p.multiplicativeExpression(f, n.MultiplicativeExpression, t, mode, flags) - case cc.AdditiveExpressionAdd: // AdditiveExpression '+' MultiplicativeExpression - p.binaryAdditiveExpression(f, n, "+", t, mode, flags) - case cc.AdditiveExpressionSub: // AdditiveExpression '-' MultiplicativeExpression - p.binaryAdditiveExpression(f, n, "-", t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) binaryAdditiveExpression(f *function, n *cc.AdditiveExpression, oper string, t cc.Type, mode exprMode, flags flags) { - // AdditiveExpression '+' MultiplicativeExpression - switch mode { - case exprValue: - p.binaryAdditiveExpressionValue(f, n, oper, t, mode, flags) - case exprBool: - p.binaryAdditiveExpressionBool(f, n, oper, t, mode, flags) - default: - panic(todo("", mode)) - } -} - -func (p *project) binaryAdditiveExpressionBool(f *function, n *cc.AdditiveExpression, oper string, t cc.Type, mode exprMode, flags flags) { - // AdditiveExpression '+' MultiplicativeExpression - defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, n.Operand.Type(), &mode, flags)) - lo := n.AdditiveExpression.Operand - ro := n.MultiplicativeExpression.Operand - lt := lo.Type() - rt := ro.Type() - switch { - case lt.Kind() == cc.Ptr && rt.Kind() == cc.Ptr && oper == "-": - p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags) - p.w(" %s%s", oper, tidyComment(" ", &n.Token)) - p.multiplicativeExpression(f, n.MultiplicativeExpression, n.Promote(), exprValue, flags) - case lt.IsArithmeticType() && rt.IsArithmeticType(): // x +- y - defer p.w("%s", p.bitFieldPatch2(n, lo, ro, n.Promote())) //TODO bit field big endian - switch { - case intAddOverflows(n, lo, ro, oper, n.Promote()): // i +- j - p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags) - p.w(" %s%s", oper, tidyComment(" ", &n.Token)) - p.multiplicativeExpression(f, n.MultiplicativeExpression, n.Promote(), exprValue, flags|fForceRuntimeConv) - default: - var s string - if isRealType(n.Operand) && n.Operand.Value() != nil { - s = p.convertNil(n, n.Promote(), flags) - } - p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags) - p.w("%s %s%s", s, oper, tidyComment(" ", &n.Token)) - p.multiplicativeExpression(f, n.MultiplicativeExpression, n.Promote(), exprValue, flags) - } - default: - panic(todo("", n.Position(), lt, rt, oper)) - } -} - -func (p *project) binaryAdditiveExpressionValue(f *function, n *cc.AdditiveExpression, oper string, t cc.Type, mode exprMode, flags flags) { - // AdditiveExpression '+' MultiplicativeExpression - - lt := n.AdditiveExpression.Operand.Type() - rt := n.MultiplicativeExpression.Operand.Type() - switch lk, rk := lt.Kind(), rt.Kind(); { - case - lk == cc.UInt128 || rk == cc.UInt128, - lk == cc.Int128 || rk == cc.Int128: - - p.binaryAdditiveExpressionUint128(f, n, oper, t, mode, flags) - return - } - - defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags)) - lo := n.AdditiveExpression.Operand - ro := n.MultiplicativeExpression.Operand - switch { - case lt.IsArithmeticType() && rt.IsArithmeticType(): // x +- y - defer p.w("%s", p.bitFieldPatch2(n, lo, ro, n.Promote())) //TODO bit field big endian - switch { - case intAddOverflows(n, lo, ro, oper, n.Promote()): // i +- j - p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags) - p.w(" %s%s", oper, tidyComment(" ", &n.Token)) - p.multiplicativeExpression(f, n.MultiplicativeExpression, n.Promote(), exprValue, flags|fForceRuntimeConv) - default: - var s string - if isRealType(n.Operand) && n.Operand.Value() != nil { - s = p.convertNil(n, n.Promote(), flags) - } - p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags) - p.w("%s %s%s", s, oper, tidyComment(" ", &n.Token)) - p.multiplicativeExpression(f, n.MultiplicativeExpression, n.Promote(), exprValue, flags) - } - case lt.Kind() == cc.Ptr && rt.IsIntegerType(): // p +- i - p.additiveExpression(f, n.AdditiveExpression, lt, exprValue, flags) - p.w(" %s%s uintptr(", oper, tidyComment(" ", &n.Token)) - p.multiplicativeExpression(f, n.MultiplicativeExpression, rt, exprValue, flags) - p.w(")") - if sz := lt.Elem().Size(); sz != 1 { - p.w("*%d", sz) - } - case lt.Kind() == cc.Array && rt.IsIntegerType(): // p +- i - p.additiveExpression(f, n.AdditiveExpression, lt, exprDecay, flags) - p.w(" %s%s uintptr(", oper, tidyComment(" ", &n.Token)) - p.multiplicativeExpression(f, n.MultiplicativeExpression, rt, exprValue, flags) - p.w(")") - if sz := lt.Elem().Size(); sz != 1 { - p.w("*%d", sz) - } - case lt.IsIntegerType() && rt.Kind() == cc.Ptr: // i +- p - p.w("uintptr(") - p.additiveExpression(f, n.AdditiveExpression, lt, exprValue, flags) - p.w(")") - if sz := rt.Elem().Size(); sz != 1 { - p.w("*%d", sz) - } - p.w(" %s%s ", oper, tidyComment(" ", &n.Token)) - p.multiplicativeExpression(f, n.MultiplicativeExpression, rt, exprValue, flags) - case lt.IsIntegerType() && rt.Kind() == cc.Array: // i +- p - panic(todo("", p.pos(n))) - case lt.Kind() == cc.Ptr && rt.Kind() == cc.Ptr && oper == "-": // p - q - p.w("(") - p.additiveExpression(f, n.AdditiveExpression, n.Operand.Type(), exprValue, flags) - p.w(" %s%s", oper, tidyComment(" ", &n.Token)) - p.multiplicativeExpression(f, n.MultiplicativeExpression, n.Operand.Type(), exprValue, flags) - p.w(")/%d", lt.Elem().Size()) - case lt.Kind() == cc.Ptr && rt.Kind() == cc.Array && oper == "-": // p - q - defer p.w("%s", p.convertType(n, nil, n.Operand.Type(), 0)) - p.w("(") - p.additiveExpression(f, n.AdditiveExpression, lt, exprValue, flags) - p.w(" %s%s", oper, tidyComment(" ", &n.Token)) - p.multiplicativeExpression(f, n.MultiplicativeExpression, rt.Decay(), exprDecay, flags) - p.w(")/%d", lt.Elem().Size()) - case lt.Kind() == cc.Array && rt.Kind() == cc.Ptr && oper == "-": // p - q - panic(todo("", p.pos(n))) - case lt.Kind() == cc.Array && rt.Kind() == cc.Array && oper == "-": // p - q - panic(todo("", p.pos(n))) - default: - panic(todo("", n.Position(), lt, rt, oper)) - } -} - -func (p *project) binaryAdditiveExpressionUint128(f *function, n *cc.AdditiveExpression, oper string, t cc.Type, mode exprMode, flags flags) { - // AdditiveExpression '+' MultiplicativeExpression - defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags)) - p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags) - switch oper { - case "+": - p.w(".Add(") - case "-": - p.w(".Sub(") - default: - panic(todo("%q", oper)) - } - p.multiplicativeExpression(f, n.MultiplicativeExpression, n.Promote(), exprValue, flags) - p.w(")") -} - -func (p *project) bitFieldPatch2(n cc.Node, a, b cc.Operand, promote cc.Type) string { - //TODO bit field big endian - var m uint64 - var w int - switch { - case a.Type().IsBitFieldType(): - bf := a.Type().BitField() - w = bf.BitFieldWidth() - m = bf.Mask() >> bf.BitFieldOffset() - if b.Type().IsBitFieldType() { - bf = b.Type().BitField() - w2 := bf.BitFieldWidth() - if w2 != w { - panic(todo("", p.pos(n))) - } - } - case b.Type().IsBitFieldType(): - bf := b.Type().BitField() - w = bf.BitFieldWidth() - m = bf.Mask() >> bf.BitFieldOffset() - default: - return "" - } - - p.w("((") - switch { - case promote.IsSignedType(): - n := int(promote.Size())*8 - w - var s string - switch promote.Size() { - case 4: - s = fmt.Sprintf(")&%#x", int32(m)) - default: - s = fmt.Sprintf(")&%#x", m) - } - if n != 0 { - s += fmt.Sprintf("<<%d>>%[1]d", n) - } - return ")" + s - default: - return fmt.Sprintf(")&%#x)", m) - } -} - -func intAddOverflows(n cc.Node, lo, ro cc.Operand, oper string, promote cc.Type) bool { - a, b, ok := getIntOperands(lo, ro) - if !ok { - return false - } - - switch oper { - case "+": - return overflows(a.Add(a, b), promote) - case "-": - return overflows(a.Sub(a, b), promote) - default: - panic(todo("", pos(n))) - } -} - -func getIntOperands(a, b cc.Operand) (x, y *big.Int, ok bool) { - switch n := a.Value().(type) { - case cc.Int64Value: - x = big.NewInt(int64(n)) - case cc.Uint64Value: - x = big.NewInt(0).SetUint64(uint64(n)) - default: - return nil, nil, false - } - - switch n := b.Value().(type) { - case cc.Int64Value: - return x, big.NewInt(int64(n)), true - case cc.Uint64Value: - return x, big.NewInt(0).SetUint64(uint64(n)), true - default: - return nil, nil, false - } -} - -func overflows(n *big.Int, promote cc.Type) bool { - switch k := promote.Kind(); { - case k == cc.Int128, k == cc.UInt128: - return false - case isSigned(promote): - switch promote.Size() { - case 4: - return n.Cmp(minInt32) < 0 || n.Cmp(maxInt32) > 0 - case 8: - return n.Cmp(minInt64) < 0 || n.Cmp(maxInt64) > 0 - } - default: - switch promote.Size() { - case 4: - return n.Sign() < 0 || n.Cmp(maxUint32) > 0 - case 8: - return n.Sign() < 0 || n.Cmp(maxUint64) > 0 - } - } - panic(todo("", promote.Size(), promote)) -} - -func (p *project) multiplicativeExpression(f *function, n *cc.MultiplicativeExpression, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprValue: - p.multiplicativeExpressionValue(f, n, t, mode, flags) - case exprVoid: - p.multiplicativeExpressionVoid(f, n, t, mode, flags) - case exprAddrOf: - p.multiplicativeExpressionAddrOf(f, n, t, mode, flags) - case exprBool: - p.multiplicativeExpressionBool(f, n, t, mode, flags) - case exprLValue: - p.multiplicativeExpressionLValue(f, n, t, mode, flags) - case exprPSelect: - p.multiplicativeExpressionPSelect(f, n, t, mode, flags) - case exprFunc: - p.multiplicativeExpressionFunc(f, n, t, mode, flags) - case exprSelect: - p.multiplicativeExpressionSelect(f, n, t, mode, flags) - case exprDecay: - p.multiplicativeExpressionDecay(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) multiplicativeExpressionDecay(f *function, n *cc.MultiplicativeExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.MultiplicativeExpressionCast: // CastExpression - p.castExpression(f, n.CastExpression, t, mode, flags) - case cc.MultiplicativeExpressionMul: // MultiplicativeExpression '*' CastExpression - panic(todo("", p.pos(n))) - case cc.MultiplicativeExpressionDiv: // MultiplicativeExpression '/' CastExpression - panic(todo("", p.pos(n))) - case cc.MultiplicativeExpressionMod: // MultiplicativeExpression '%' CastExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) multiplicativeExpressionSelect(f *function, n *cc.MultiplicativeExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.MultiplicativeExpressionCast: // CastExpression - p.castExpression(f, n.CastExpression, t, mode, flags) - case cc.MultiplicativeExpressionMul: // MultiplicativeExpression '*' CastExpression - panic(todo("", p.pos(n))) - case cc.MultiplicativeExpressionDiv: // MultiplicativeExpression '/' CastExpression - panic(todo("", p.pos(n))) - case cc.MultiplicativeExpressionMod: // MultiplicativeExpression '%' CastExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) multiplicativeExpressionFunc(f *function, n *cc.MultiplicativeExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.MultiplicativeExpressionCast: // CastExpression - p.castExpression(f, n.CastExpression, t, mode, flags) - case cc.MultiplicativeExpressionMul: // MultiplicativeExpression '*' CastExpression - panic(todo("", p.pos(n))) - case cc.MultiplicativeExpressionDiv: // MultiplicativeExpression '/' CastExpression - panic(todo("", p.pos(n))) - case cc.MultiplicativeExpressionMod: // MultiplicativeExpression '%' CastExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) multiplicativeExpressionPSelect(f *function, n *cc.MultiplicativeExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.MultiplicativeExpressionCast: // CastExpression - p.castExpression(f, n.CastExpression, t, mode, flags) - case cc.MultiplicativeExpressionMul: // MultiplicativeExpression '*' CastExpression - panic(todo("", p.pos(n))) - case cc.MultiplicativeExpressionDiv: // MultiplicativeExpression '/' CastExpression - panic(todo("", p.pos(n))) - case cc.MultiplicativeExpressionMod: // MultiplicativeExpression '%' CastExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) multiplicativeExpressionLValue(f *function, n *cc.MultiplicativeExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.MultiplicativeExpressionCast: // CastExpression - p.castExpression(f, n.CastExpression, t, mode, flags) - case cc.MultiplicativeExpressionMul: // MultiplicativeExpression '*' CastExpression - panic(todo("", p.pos(n))) - case cc.MultiplicativeExpressionDiv: // MultiplicativeExpression '/' CastExpression - panic(todo("", p.pos(n))) - case cc.MultiplicativeExpressionMod: // MultiplicativeExpression '%' CastExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) multiplicativeExpressionBool(f *function, n *cc.MultiplicativeExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.MultiplicativeExpressionCast: // CastExpression - p.castExpression(f, n.CastExpression, t, mode, flags) - case - cc.MultiplicativeExpressionMul, // MultiplicativeExpression '*' CastExpression - cc.MultiplicativeExpressionDiv, // MultiplicativeExpression '/' CastExpression - cc.MultiplicativeExpressionMod: // MultiplicativeExpression '%' CastExpression - - p.w("(") - defer p.w(")") - defer p.w(" != 0 ") - p.multiplicativeExpression(f, n, t, exprValue, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) multiplicativeExpressionAddrOf(f *function, n *cc.MultiplicativeExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.MultiplicativeExpressionCast: // CastExpression - p.castExpression(f, n.CastExpression, t, mode, flags) - case cc.MultiplicativeExpressionMul: // MultiplicativeExpression '*' CastExpression - panic(todo("", p.pos(n))) - case cc.MultiplicativeExpressionDiv: // MultiplicativeExpression '/' CastExpression - panic(todo("", p.pos(n))) - case cc.MultiplicativeExpressionMod: // MultiplicativeExpression '%' CastExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) multiplicativeExpressionVoid(f *function, n *cc.MultiplicativeExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.MultiplicativeExpressionCast: // CastExpression - p.castExpression(f, n.CastExpression, t, mode, flags) - case cc.MultiplicativeExpressionMul: // MultiplicativeExpression '*' CastExpression - panic(todo("", p.pos(n))) - case cc.MultiplicativeExpressionDiv: // MultiplicativeExpression '/' CastExpression - panic(todo("", p.pos(n))) - case cc.MultiplicativeExpressionMod: // MultiplicativeExpression '%' CastExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) multiplicativeExpressionValue(f *function, n *cc.MultiplicativeExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.MultiplicativeExpressionCast: // CastExpression - p.castExpression(f, n.CastExpression, t, mode, flags) - case cc.MultiplicativeExpressionMul: // MultiplicativeExpression '*' CastExpression - p.binaryMultiplicativeExpression(f, n, "*", t, mode, flags) - case cc.MultiplicativeExpressionDiv: // MultiplicativeExpression '/' CastExpression - p.binaryMultiplicativeExpression(f, n, "/", t, mode, flags) - case cc.MultiplicativeExpressionMod: // MultiplicativeExpression '%' CastExpression - p.binaryMultiplicativeExpression(f, n, "%", t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) binaryMultiplicativeExpression(f *function, n *cc.MultiplicativeExpression, oper string, t cc.Type, mode exprMode, flags flags) { - // MultiplicativeExpression '*' CastExpression - switch mode { - case exprValue: - p.binaryMultiplicativeExpressionValue(f, n, oper, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) binaryMultiplicativeExpressionValue(f *function, n *cc.MultiplicativeExpression, oper string, t cc.Type, mode exprMode, flags flags) { - // MultiplicativeExpression '*' CastExpression - - lt := n.MultiplicativeExpression.Operand.Type() - rt := n.CastExpression.Operand.Type() - switch lk, rk := lt.Kind(), rt.Kind(); { - case - lk == cc.UInt128 || rk == cc.UInt128, - lk == cc.Int128 || rk == cc.Int128: - - p.binaryMultiplicativeExpressionUint128(f, n, oper, t, mode, flags) - return - } - - defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags)) - switch { - case intMulOverflows(n, n.Operand, n.MultiplicativeExpression.Operand, n.CastExpression.Operand, oper, n.Promote()): - p.multiplicativeExpression(f, n.MultiplicativeExpression, n.Promote(), exprValue, flags|fForceRuntimeConv) - p.w(" %s%s", oper, tidyComment(" ", &n.Token)) - p.castExpression(f, n.CastExpression, n.Promote(), exprValue, flags|fForceRuntimeConv) - default: - defer p.w("%s", p.bitFieldPatch2(n, n.MultiplicativeExpression.Operand, n.CastExpression.Operand, n.Promote())) //TODO bit field big endian - var s string - if isRealType(n.Operand) && n.Operand.Value() != nil { - s = p.convertNil(n, n.Promote(), flags) - } - p.multiplicativeExpression(f, n.MultiplicativeExpression, n.Promote(), exprValue, flags) - p.w("%s %s%s", s, oper, tidyComment(" ", &n.Token)) - if (oper == "/" || oper == "%") && (isZeroReal(n.MultiplicativeExpression.Operand) || isZeroReal(n.CastExpression.Operand)) { - p.w("%s%sFrom%[2]s(", p.task.crt, p.helperType(n, n.Promote())) - defer p.w(")") - } - p.castExpression(f, n.CastExpression, n.Promote(), exprValue, flags) - } -} - -func (p *project) binaryMultiplicativeExpressionUint128(f *function, n *cc.MultiplicativeExpression, oper string, t cc.Type, mode exprMode, flags flags) { - // MultiplicativeExpression '*' CastExpression - defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags)) - p.multiplicativeExpression(f, n.MultiplicativeExpression, n.Promote(), exprValue, flags) - switch oper { - case "*": - p.w(".Mul(") - case "/": - p.w(".Div(") - case "%": - p.w(".Mod(") - default: - panic(todo("%q", oper)) - } - p.castExpression(f, n.CastExpression, n.Promote(), exprValue, flags) - p.w(")") -} - -func isZeroReal(op cc.Operand) bool { - switch x := op.Value().(type) { - case cc.Float32Value: - return x == 0 - case cc.Float64Value: - return x == 0 - default: - return false - } -} - -func intMulOverflows(n cc.Node, r, lo, ro cc.Operand, oper string, promote cc.Type) bool { - if (isReal(lo) && !isInf(lo) || isReal(ro) && !isInf(ro)) && isInf(r) { - return true - } - - a, b, ok := getIntOperands(lo, ro) - if !ok { - return false - } - - switch oper { - case "*": - return overflows(a.Mul(a, b), promote) - case "/": - if b.Sign() == 0 { - return true - } - - return overflows(a.Div(a, b), promote) - case "%": - if b.Sign() == 0 { - return true - } - - return overflows(a.Mod(a, b), promote) - default: - panic(todo("", pos(n))) - } -} - -func isReal(op cc.Operand) bool { - switch op.Value().(type) { - case cc.Float32Value, cc.Float64Value: - return true - default: - return false - } -} - -func isInf(op cc.Operand) bool { - switch x := op.Value().(type) { - case cc.Float32Value: - return math.IsInf(float64(x), 0) - case cc.Float64Value: - return math.IsInf(float64(x), 0) - default: - return false - } -} - -func (p *project) castExpression(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) { - if n.Case == cc.CastExpressionCast { - if f != nil && n.CastExpression.Operand.Type().Kind() == cc.Ptr { // void *__ccgo_va_arg(__builtin_va_list ap); - sv := f.vaType - f.vaType = n.TypeName.Type() - defer func() { f.vaType = sv }() - } - } - switch mode { - case exprValue: - p.castExpressionValue(f, n, t, mode, flags) - case exprVoid: - p.castExpressionVoid(f, n, t, mode, flags) - case exprAddrOf: - p.castExpressionAddrOf(f, n, t, mode, flags) - case exprBool: - p.castExpressionBool(f, n, t, mode, flags) - case exprLValue: - p.castExpressionLValue(f, n, t, mode, flags) - case exprPSelect: - p.castExpressionPSelect(f, n, t, mode, flags) - case exprFunc: - p.castExpressionFunc(f, n, t, mode, flags) - case exprSelect: - p.castExpressionSelect(f, n, t, mode, flags) - case exprDecay: - p.castExpressionDecay(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) castExpressionDecay(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.CastExpressionUnary: // UnaryExpression - p.unaryExpression(f, n.UnaryExpression, t, mode, flags) - case cc.CastExpressionCast: // '(' TypeName ')' CastExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) castExpressionSelect(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.CastExpressionUnary: // UnaryExpression - p.unaryExpression(f, n.UnaryExpression, t, mode, flags) - case cc.CastExpressionCast: // '(' TypeName ')' CastExpression - p.castExpression(f, n.CastExpression, n.TypeName.Type(), mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) castExpressionFunc(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.CastExpressionUnary: // UnaryExpression - p.unaryExpression(f, n.UnaryExpression, t, mode, flags) - case cc.CastExpressionCast: // '(' TypeName ')' CastExpression - ot := n.CastExpression.Operand.Type() - tn := n.TypeName.Type() - var ft cc.Type - switch tn.Kind() { - case cc.Ptr: - switch et := ot.Elem(); et.Kind() { - case cc.Function, cc.Void: - // ok - default: - panic(todo("", p.pos(n), et, et.Kind())) - } - default: - panic(todo("%v: %v, %v -> %v, %v -> %v, %v", p.pos(n), ot, ot.Kind(), tn, tn.Kind(), t, t.Kind())) - } - switch t.Kind() { - case cc.Ptr: - switch et := t.Elem(); et.Kind() { - case cc.Function: - ft = et - default: - panic(todo("", p.pos(n), et, et.Kind())) - } - default: - panic(todo("%v: %v, %v -> %v, %v -> %v, %v", p.pos(n), ot, ot.Kind(), tn, tn.Kind(), t, t.Kind())) - } - switch ot.Kind() { - case cc.Ptr: - switch et := ot.Elem(); et.Kind() { - case cc.Function, cc.Void: - p.w("(*(*") - p.functionSignature(n, f, ft, "") - p.w(")(unsafe.Pointer(") - p.castExpression(f, n.CastExpression, ot, exprAddrOf, flags) - p.w(")))") - default: - panic(todo("", p.pos(n), et, et.Kind())) - } - default: - panic(todo("%v: %v, %v -> %v, %v -> %v, %v", p.pos(n), ot, ot.Kind(), tn, tn.Kind(), t, t.Kind())) - } - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) castExpressionPSelect(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.CastExpressionUnary: // UnaryExpression - p.unaryExpression(f, n.UnaryExpression, t, mode, flags) - case cc.CastExpressionCast: // '(' TypeName ')' CastExpression - p.castExpression(f, n.CastExpression, n.TypeName.Type(), mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) castExpressionLValue(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.CastExpressionUnary: // UnaryExpression - p.unaryExpression(f, n.UnaryExpression, t, mode, flags) - case cc.CastExpressionCast: // '(' TypeName ')' CastExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) castExpressionBool(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.CastExpressionUnary: // UnaryExpression - p.unaryExpression(f, n.UnaryExpression, t, mode, flags) - case cc.CastExpressionCast: // '(' TypeName ')' CastExpression - p.w("(") - defer p.w(")") - defer p.w(" != 0 ") - p.castExpression(f, n, n.Operand.Type(), exprValue, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) castExpressionAddrOf(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.CastExpressionUnary: // UnaryExpression - p.unaryExpression(f, n.UnaryExpression, t, mode, flags) - case cc.CastExpressionCast: // '(' TypeName ')' CastExpression - p.castExpressionAddrOf(f, n.CastExpression, t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) castExpressionVoid(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.CastExpressionUnary: // UnaryExpression - p.unaryExpression(f, n.UnaryExpression, t, mode, flags) - case cc.CastExpressionCast: // '(' TypeName ')' CastExpression - p.castExpression(f, n.CastExpression, t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) castExpressionValue(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.CastExpressionUnary: // UnaryExpression - p.unaryExpression(f, n.UnaryExpression, t, mode, flags) - case cc.CastExpressionCast: // '(' TypeName ')' CastExpression - if f != nil && p.pass1 && n.TypeName.Type().IsIntegerType() && n.CastExpression.Operand.Type().Kind() == cc.Array { - if d := n.CastExpression.Declarator(); d != nil { - f.pin(n, d) - } - } - switch k := p.opKind(f, n.CastExpression, n.CastExpression.Operand.Type()); k { - case opNormal, opBitfield: - p.castExpressionValueNormal(f, n, t, mode, flags) - case opArray: - p.castExpressionValueArray(f, n, t, mode, flags) - case opFunction: - p.castExpressionValueFunction(f, n, t, mode, flags) - case opArrayParameter: - p.castExpressionValueNormal(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), k)) - } - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) castExpressionValueArrayParameter(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) { - // '(' TypeName ')' CastExpression - tn := n.TypeName.Type() - defer p.w("%s", p.convertType(n, tn, t, flags)) - p.castExpression(f, n.CastExpression, tn, mode, flags) -} - -func (p *project) castExpressionValueFunction(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) { - // '(' TypeName ')' CastExpression - op := n.CastExpression.Operand - tn := n.TypeName.Type() - switch { - case op.Type().Kind() == cc.Function: - switch { - case tn.Kind() == cc.Ptr && t.Kind() == cc.Ptr: - p.castExpression(f, n.CastExpression, op.Type(), exprValue, flags) - case tn.IsIntegerType(): - p.w("%s(", p.typ(n, tn)) - p.castExpression(f, n.CastExpression, op.Type(), exprValue, flags) - p.w(")") - default: - panic(todo("%v: tn %v expr %v", n.Position(), tn, op.Type())) - } - default: - panic(todo("%v: %v -> %v -> %v", p.pos(n), op.Type(), tn, t)) - } -} - -func (p *project) castExpressionValueArray(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) { - // '(' TypeName ')' CastExpression - tn := n.TypeName.Type() - switch { - case tn.IsScalarType(): - defer p.w("%s", p.convertType(n, nil, t, flags)) - p.castExpression(f, n.CastExpression, tn, exprDecay, flags) - default: - panic(todo("", p.pos(n))) - } -} - -func (p *project) castExpressionValueNormal(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) { - // '(' TypeName ')' CastExpression - op := n.CastExpression.Operand - tn := n.TypeName.Type() - switch { - case op.Type().Kind() == cc.Ptr && tn.IsArithmeticType(): - defer p.w("%s", p.convertType(n, nil, t, flags|fForceConv)) - p.castExpression(f, n.CastExpression, op.Type(), mode, flags) - case tn.IsArithmeticType(): - switch { - case (tn.Kind() == cc.Float || tn.Kind() == cc.Double) && op.Type().IsIntegerType() && op.Value() != nil && t.IsIntegerType(): - panic(todo("", p.pos(n))) - case isNegativeInt(op) && isUnsigned(t): - defer p.w("%s", p.convertType(n, tn, t, flags|fForceConv)) - p.castExpression(f, n.CastExpression, tn, exprValue, flags) - default: - defer p.w("%s", p.convertType(n, tn, t, flags)) - p.castExpression(f, n.CastExpression, tn, exprValue, flags) - } - default: - switch tn.Kind() { - case cc.Ptr: - switch { - case t.Kind() == cc.Ptr && isNegativeInt(op): - p.w("%s(", p.helperType2(n, op.Type(), tn)) - defer p.w(")") - p.castExpression(f, n.CastExpression, op.Type(), mode, flags) - default: - defer p.w("%s", p.convertType(n, tn, t, flags)) - p.castExpression(f, n.CastExpression, tn, mode, flags) - } - case cc.Void: - p.castExpression(f, n.CastExpression, tn, exprVoid, flags) - default: - panic(todo("%s: %s %s -> %s %s -> %s %s", n.Position(), op.Type(), op.Type().Kind(), tn, tn.Kind(), t, t.Kind())) - } - } -} - -func (p *project) unaryExpression(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprLValue: - p.unaryExpressionLValue(f, n, t, mode, flags) - case exprValue: - p.unaryExpressionValue(f, n, t, mode, flags) - case exprVoid: - p.unaryExpressionVoid(f, n, t, mode, flags) - case exprAddrOf: - p.unaryExpressionAddrOf(f, n, t, mode, flags) - case exprBool: - p.unaryExpressionBool(f, n, t, mode, flags) - case exprPSelect: - p.unaryExpressionPSelect(f, n, t, mode, flags) - case exprFunc: - p.unaryExpressionFunc(f, n, t, mode, flags) - case exprSelect: - p.unaryExpressionSelect(f, n, t, mode, flags) - case exprDecay: - p.unaryExpressionDecay(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) unaryExpressionDecay(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.UnaryExpressionPostfix: // PostfixExpression - p.postfixExpression(f, n.PostfixExpression, t, mode, flags) - case cc.UnaryExpressionInc: // "++" UnaryExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionDec: // "--" UnaryExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionAddrof: // '&' CastExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionDeref: // '*' CastExpression - p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags) - case cc.UnaryExpressionPlus: // '+' CastExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionMinus: // '-' CastExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionCpl: // '~' CastExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionNot: // '!' CastExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionSizeofExpr: // "sizeof" UnaryExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionSizeofType: // "sizeof" '(' TypeName ')' - panic(todo("", p.pos(n))) - case cc.UnaryExpressionLabelAddr: // "&&" IDENTIFIER - panic(todo("", p.pos(n))) - case cc.UnaryExpressionAlignofExpr: // "_Alignof" UnaryExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionAlignofType: // "_Alignof" '(' TypeName ')' - panic(todo("", p.pos(n))) - case cc.UnaryExpressionImag: // "__imag__" UnaryExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionReal: // "__real__" UnaryExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) unaryExpressionSelect(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.UnaryExpressionPostfix: // PostfixExpression - p.postfixExpression(f, n.PostfixExpression, t, mode, flags) - case cc.UnaryExpressionInc: // "++" UnaryExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionDec: // "--" UnaryExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionAddrof: // '&' CastExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionDeref: // '*' CastExpression - ot := n.CastExpression.Operand.Type() - switch ot.Kind() { - case cc.Ptr: - switch et := ot.Elem(); et.Kind() { - case - cc.Struct, - cc.Union: - - p.w("(*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type())) - p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags) - p.w(")))") - default: - panic(todo("", p.pos(n), et, et.Kind())) - } - case cc.Array: - p.w("(*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type())) - p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprAddrOf, flags) - p.w(")))") - default: - panic(todo("", p.pos(n), ot, ot.Kind())) - } - case cc.UnaryExpressionPlus: // '+' CastExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionMinus: // '-' CastExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionCpl: // '~' CastExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionNot: // '!' CastExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionSizeofExpr: // "sizeof" UnaryExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionSizeofType: // "sizeof" '(' TypeName ')' - panic(todo("", p.pos(n))) - case cc.UnaryExpressionLabelAddr: // "&&" IDENTIFIER - panic(todo("", p.pos(n))) - case cc.UnaryExpressionAlignofExpr: // "_Alignof" UnaryExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionAlignofType: // "_Alignof" '(' TypeName ')' - panic(todo("", p.pos(n))) - case cc.UnaryExpressionImag: // "__imag__" UnaryExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionReal: // "__real__" UnaryExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) unaryExpressionFunc(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.UnaryExpressionPostfix: // PostfixExpression - p.postfixExpression(f, n.PostfixExpression, t, mode, flags) - case cc.UnaryExpressionInc: // "++" UnaryExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionDec: // "--" UnaryExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionAddrof: // '&' CastExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionDeref: // '*' CastExpression - ot := n.CastExpression.Operand.Type() - switch ot.Kind() { - case cc.Ptr: - switch et := ot.Elem(); et.Kind() { - case cc.Function: - p.castExpression(f, n.CastExpression, ot, mode, flags|fAddrOfFuncPtrOk) - case cc.Ptr: - switch et2 := et.Elem(); et2.Kind() { - case cc.Function: - // C: (**)() - p.fnVal(n, f, func() { p.castExpression(f, n.CastExpression, p.ptrType, exprValue, flags|fAddrOfFuncPtrOk) }, n.CastExpression.Declarator(), n.CastExpression.Operand.Type(), 1, mode, flags) - default: - panic(todo("", p.pos(n), et2, et2.Kind())) - } - default: - panic(todo("", p.pos(n), et, et.Kind())) - } - case cc.Function: - p.castExpression(f, n.CastExpression, ot, mode, flags|fAddrOfFuncPtrOk) - default: - panic(todo("", p.pos(n), ot, ot.Kind(), mode)) - } - case cc.UnaryExpressionPlus: // '+' CastExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionMinus: // '-' CastExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionCpl: // '~' CastExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionNot: // '!' CastExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionSizeofExpr: // "sizeof" UnaryExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionSizeofType: // "sizeof" '(' TypeName ')' - panic(todo("", p.pos(n))) - case cc.UnaryExpressionLabelAddr: // "&&" IDENTIFIER - panic(todo("", p.pos(n))) - case cc.UnaryExpressionAlignofExpr: // "_Alignof" UnaryExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionAlignofType: // "_Alignof" '(' TypeName ')' - panic(todo("", p.pos(n))) - case cc.UnaryExpressionImag: // "__imag__" UnaryExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionReal: // "__real__" UnaryExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) unaryExpressionPSelect(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.UnaryExpressionPostfix: // PostfixExpression - p.postfixExpression(f, n.PostfixExpression, t, mode, flags) - case cc.UnaryExpressionInc: // "++" UnaryExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionDec: // "--" UnaryExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionAddrof: // '&' CastExpression - panic(todo("", n.Position())) - //TODO- p.w("(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type().Elem())) - //TODO- p.unaryExpression(f, n, t, exprValue, flags) - //TODO- p.w("))") - case cc.UnaryExpressionDeref: // '*' CastExpression - panic(todo("", n.Position())) - //TODO- ot := n.CastExpression.Operand.Type() - //TODO- switch ot.Kind() { - //TODO- case cc.Ptr: - //TODO- switch et := ot.Elem(); { - //TODO- case et.Kind() == cc.Ptr: - //TODO- switch et2 := et.Elem(); et2.Kind() { - //TODO- case cc.Struct: - //TODO- if et2.IsIncomplete() { - //TODO- p.w("(*(**uintptr)(unsafe.Pointer(") - //TODO- p.castExpression(f, n.CastExpression, t, exprValue, flags) - //TODO- p.w(")))") - //TODO- break - //TODO- } - - //TODO- p.w("(*(**%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type().Elem())) - //TODO- p.castExpression(f, n.CastExpression, t, exprValue, flags) - //TODO- p.w(")))") - //TODO- default: - //TODO- panic(todo("", p.pos(n), et2, et2.Kind())) - //TODO- } - //TODO- default: - //TODO- panic(todo("", p.pos(n), et, et.Kind())) - //TODO- } - //TODO- default: - //TODO- panic(todo("", p.pos(n), ot, ot.Kind())) - //TODO- } - case cc.UnaryExpressionPlus: // '+' CastExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionMinus: // '-' CastExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionCpl: // '~' CastExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionNot: // '!' CastExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionSizeofExpr: // "sizeof" UnaryExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionSizeofType: // "sizeof" '(' TypeName ')' - panic(todo("", p.pos(n))) - case cc.UnaryExpressionLabelAddr: // "&&" IDENTIFIER - panic(todo("", p.pos(n))) - case cc.UnaryExpressionAlignofExpr: // "_Alignof" UnaryExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionAlignofType: // "_Alignof" '(' TypeName ')' - panic(todo("", p.pos(n))) - case cc.UnaryExpressionImag: // "__imag__" UnaryExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionReal: // "__real__" UnaryExpression - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) unaryExpressionBool(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.UnaryExpressionPostfix: // PostfixExpression - p.postfixExpression(f, n.PostfixExpression, t, mode, flags) - case cc.UnaryExpressionNot: // '!' CastExpression - p.w("!(") - p.castExpression(f, n.CastExpression, t, mode, flags) - p.w(")") - default: - p.w("(") - defer p.w(")") - defer p.w(" != 0 ") - p.unaryExpression(f, n, t, exprValue, flags) - } -} - -func (p *project) unaryExpressionAddrOf(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.UnaryExpressionPostfix: // PostfixExpression - p.postfixExpression(f, n.PostfixExpression, t, mode, flags) - case cc.UnaryExpressionInc: // "++" UnaryExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionDec: // "--" UnaryExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionAddrof: // '&' CastExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionDeref: // '*' CastExpression - ot := n.CastExpression.Operand.Type() - switch ot.Kind() { - case cc.Ptr: - switch et := ot.Elem(); { - case - et.IsScalarType(), - et.Kind() == cc.Struct, - et.Kind() == cc.Union, - et.Kind() == cc.Array: - - p.unaryExpressionDeref(f, n, t, mode, flags) - default: - panic(todo("", p.pos(n), et, et.Kind())) - } - default: - panic(todo("", p.pos(n), ot, ot.Kind())) - } - case cc.UnaryExpressionPlus: // '+' CastExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionMinus: // '-' CastExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionCpl: // '~' CastExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionNot: // '!' CastExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionSizeofExpr: // "sizeof" UnaryExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionSizeofType: // "sizeof" '(' TypeName ')' - panic(todo("", n.Position())) - case cc.UnaryExpressionLabelAddr: // "&&" IDENTIFIER - panic(todo("", n.Position())) - case cc.UnaryExpressionAlignofExpr: // "_Alignof" UnaryExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionAlignofType: // "_Alignof" '(' TypeName ')' - panic(todo("", n.Position())) - case cc.UnaryExpressionImag: // "__imag__" UnaryExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionReal: // "__real__" UnaryExpression - panic(todo("", n.Position())) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) unaryExpressionVoid(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.UnaryExpressionPostfix: // PostfixExpression - p.postfixExpression(f, n.PostfixExpression, t, mode, flags) - case cc.UnaryExpressionInc: // "++" UnaryExpression - p.unaryExpressionPreIncDec(f, n, "++", "+=", t, mode, flags) - case cc.UnaryExpressionDec: // "--" UnaryExpression - p.unaryExpressionPreIncDec(f, n, "--", "-=", t, mode, flags) - case cc.UnaryExpressionAddrof: // '&' CastExpression - p.w("_ = ") - switch { - case n.CastExpression.Operand.Type().Kind() == cc.Array: - panic(todo("", p.pos(n))) - default: - p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprAddrOf, flags) - } - case cc.UnaryExpressionDeref: // '*' CastExpression - p.w("_ = *(*byte)(unsafe.Pointer(") - p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags) - p.w("))") - case - cc.UnaryExpressionPlus, // '+' CastExpression - cc.UnaryExpressionMinus, // '-' CastExpression - cc.UnaryExpressionNot, // '!' CastExpression - cc.UnaryExpressionCpl: // '~' CastExpression - - p.w("_ = ") - defer p.w("%s", p.convert(n, n.CastExpression.Operand, p.intType, flags)) - p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags) - case cc.UnaryExpressionSizeofExpr: // "sizeof" UnaryExpression - // nop - case cc.UnaryExpressionSizeofType: // "sizeof" '(' TypeName ')' - // nop - case cc.UnaryExpressionLabelAddr: // "&&" IDENTIFIER - panic(todo("", n.Position())) - case cc.UnaryExpressionAlignofExpr: // "_Alignof" UnaryExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionAlignofType: // "_Alignof" '(' TypeName ')' - panic(todo("", n.Position())) - case cc.UnaryExpressionImag: // "__imag__" UnaryExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionReal: // "__real__" UnaryExpression - panic(todo("", n.Position())) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) unaryExpressionValue(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.UnaryExpressionPostfix: // PostfixExpression - p.postfixExpression(f, n.PostfixExpression, t, mode, flags) - case cc.UnaryExpressionInc: // "++" UnaryExpression - p.unaryExpressionPreIncDec(f, n, "++", "+=", t, mode, flags) - case cc.UnaryExpressionDec: // "--" UnaryExpression - p.unaryExpressionPreIncDec(f, n, "--", "-=", t, mode, flags) - case cc.UnaryExpressionAddrof: // '&' CastExpression - if t.Kind() != cc.Ptr { - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - } - switch { - case n.CastExpression.Operand.Type().Kind() == cc.Array: - panic(todo("", p.pos(n))) - default: - p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprAddrOf, flags) - } - case cc.UnaryExpressionDeref: // '*' CastExpression - ot := n.CastExpression.Operand.Type() - switch ot.Kind() { - case cc.Ptr, cc.Array: - switch et := ot.Elem(); { - case - et.IsScalarType(), - et.Kind() == cc.Array, - et.Kind() == cc.Struct, - et.Kind() == cc.Union: - - p.unaryExpressionDeref(f, n, t, mode, flags) - case et.Kind() == cc.Function: - p.castExpression(f, n.CastExpression, t, mode, flags) - default: - panic(todo("", p.pos(n), et, et.Kind())) - } - default: - panic(todo("", p.pos(n), ot, ot.Kind())) - } - case cc.UnaryExpressionPlus: // '+' CastExpression - p.w(" +") - p.castExpression(f, n.CastExpression, t, mode, flags) - case cc.UnaryExpressionMinus: // '-' CastExpression - switch { - case isNonNegativeInt(n.CastExpression.Operand) && t.Kind() == cc.Ptr: - p.w(" -%sUintptr(", p.task.crt) - p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags) - p.w(")") - case isZeroReal(n.CastExpression.Operand): - p.w(" -") - defer p.w("%s", p.convert(n, n.CastExpression.Operand, t, flags)) - p.w("%s%sFrom%[2]s(", p.task.crt, p.helperType(n, n.CastExpression.Operand.Type())) - p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags) - p.w(")") - case isNonNegativeInt(n.CastExpression.Operand) && isUnsigned(n.Operand.Type()): - defer p.w("%s", p.convert(n, n.CastExpression.Operand, t, flags)) - p.w("%sNeg%s(", p.task.crt, p.helperType(n, n.CastExpression.Operand.Type())) - p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags) - p.w(")") - default: - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.w(" -") - p.castExpression(f, n.CastExpression, n.Operand.Type(), exprValue, flags) - } - case cc.UnaryExpressionCpl: // '~' CastExpression - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - switch { - case n.CastExpression.Operand.Value() != nil: - switch { - case !t.IsIntegerType(): - p.w(" ^") - p.castExpression(f, n.CastExpression, n.Operand.Type(), exprValue, flags|fForceRuntimeConv) - default: - p.w("%sCpl%s(", p.task.crt, p.helperType(n, n.Operand.Type())) - p.castExpression(f, n.CastExpression, n.Operand.Type(), exprValue, flags) - p.w(")") - } - default: - p.w(" ^") - p.castExpression(f, n.CastExpression, n.Operand.Type(), exprValue, flags) - } - case cc.UnaryExpressionNot: // '!' CastExpression - p.w("%sBool%s(!(", p.task.crt, p.helperType(n, t)) - p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprBool, flags) - p.w("))") - case cc.UnaryExpressionSizeofExpr: // "sizeof" UnaryExpression - p.checkSizeof(n.UnaryExpression, n.UnaryExpression.Operand.Type()) - defer p.w("%s", p.convertNil(n, t, flags)) - if d := n.UnaryExpression.Declarator(); d != nil { - var isLocal bool - if f != nil { - if local := f.locals[d]; local != nil { - isLocal = true - if !local.isPinned { - p.w("unsafe.Sizeof(%s)", local.name) - return - } - } - } - - if !isLocal { - if tld := p.tlds[d]; tld != nil { - p.w("unsafe.Sizeof(%s)", tld.name) - break - } - - nm := d.Name().String() - if imp := p.imports[nm]; imp != nil { - imp.used = true - p.w("unsafe.Sizeof(%sX%s)", imp.qualifier, nm) - break - } - } - } - - t := n.UnaryExpression.Operand.Type() - if p.isArray(f, n.UnaryExpression, t) { - p.w("%d", t.Len()*t.Elem().Size()) - break - } - - s := "(0)" - if !t.IsArithmeticType() { - switch t.Kind() { - case cc.Ptr: - // ok - case cc.Struct, cc.Union, cc.Array: - s = "{}" - default: - panic(todo("", t.Kind())) - } - } - switch t.Kind() { - case cc.Int128, cc.UInt128: - s = "{}" - } - p.w("unsafe.Sizeof(%s%s)", p.typ(n, t), s) - case cc.UnaryExpressionSizeofType: // "sizeof" '(' TypeName ')' - defer p.w("%s", p.convertNil(n, t, flags)) - t := n.TypeName.Type() - p.checkSizeof(n.TypeName, t) - if t.Kind() == cc.Array { - p.w("%d", t.Len()*t.Elem().Size()) - break - } - - s := "(0)" - if !t.IsArithmeticType() { - switch t.Kind() { - case cc.Ptr: - // ok - case cc.Struct, cc.Union: - s = "{}" - default: - panic(todo("", t.Kind())) - } - } - switch t.Kind() { - case cc.Int128, cc.UInt128: - s = "{}" - } - p.w("unsafe.Sizeof(%s%s)", p.typ(n, t), s) - case cc.UnaryExpressionLabelAddr: // "&&" IDENTIFIER - panic(todo("", n.Position())) - case cc.UnaryExpressionAlignofExpr: // "_Alignof" UnaryExpression - if n.TypeName.Type().Kind() == cc.Void { - p.intConst(n, "", n.Operand, t, flags) - break - } - - defer p.w("%s", p.convertNil(n, t, flags)) - t := n.UnaryExpression.Operand.Type() - if p.isArray(f, n.UnaryExpression, t) { - p.w("%d", t.Len()*t.Elem().Size()) - break - } - - s := "(0)" - if !t.IsArithmeticType() { - switch t.Kind() { - case cc.Ptr: - // ok - case cc.Struct, cc.Union: - s = "{}" - default: - panic(todo("", t.Kind())) - } - } - p.w("unsafe.Alignof(%s%s)", p.typ(n, t), s) - case cc.UnaryExpressionAlignofType: // "_Alignof" '(' TypeName ')' - if n.TypeName.Type().Kind() == cc.Void { - p.intConst(n, "", n.Operand, t, flags) - break - } - - defer p.w("%s", p.convertNil(n, t, flags)) - t := n.TypeName.Type() - if t.Kind() == cc.Array { - p.w("%d", t.Len()*t.Elem().Size()) - break - } - - s := "(0)" - if !t.IsArithmeticType() { - switch t.Kind() { - case cc.Ptr: - // ok - case cc.Struct, cc.Union: - s = "{}" - default: - panic(todo("", t.Kind())) - } - } - p.w("unsafe.Alignof(%s%s)", p.typ(n, t), s) - case cc.UnaryExpressionImag: // "__imag__" UnaryExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionReal: // "__real__" UnaryExpression - panic(todo("", n.Position())) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) checkSizeof(n cc.Node, t cc.Type) { - if !p.checkSizeof0(n, t) { - p.err(n, "sizeof type %s: not supported", t.Alias()) - } -} - -func (p *project) checkSizeof0(n cc.Node, t cc.Type) (ok bool) { - switch t.Kind() { - case cc.Array: - return !t.IsVLA() - case cc.Struct, cc.Union: - nf := t.NumField() - for i := []int{0}; i[0] < nf; i[0]++ { - if !p.checkSizeof0(n, t.FieldByIndex(i).Type()) { - return false - } - } - } - return true -} - -func (p *project) unaryExpressionLValue(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.UnaryExpressionPostfix: // PostfixExpression - p.postfixExpression(f, n.PostfixExpression, t, mode, flags) - case cc.UnaryExpressionInc: // "++" UnaryExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionDec: // "--" UnaryExpression - panic(todo("", p.pos(n))) - case cc.UnaryExpressionAddrof: // '&' CastExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionDeref: // '*' CastExpression - ot := n.CastExpression.Operand.Type() - switch ot.Kind() { - case cc.Ptr, cc.Array: - switch et := ot.Elem(); { - case - et.IsScalarType(), - et.Kind() == cc.Struct, - et.Kind() == cc.Union: - - p.unaryExpressionDeref(f, n, t, mode, flags) - default: - panic(todo("", p.pos(n), et, et.Kind())) - } - default: - panic(todo("", p.pos(n), ot, ot.Kind())) - } - case cc.UnaryExpressionPlus: // '+' CastExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionMinus: // '-' CastExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionCpl: // '~' CastExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionNot: // '!' CastExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionSizeofExpr: // "sizeof" UnaryExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionSizeofType: // "sizeof" '(' TypeName ')' - panic(todo("", n.Position())) - case cc.UnaryExpressionLabelAddr: // "&&" IDENTIFIER - panic(todo("", n.Position())) - case cc.UnaryExpressionAlignofExpr: // "_Alignof" UnaryExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionAlignofType: // "_Alignof" '(' TypeName ')' - panic(todo("", n.Position())) - case cc.UnaryExpressionImag: // "__imag__" UnaryExpression - panic(todo("", n.Position())) - case cc.UnaryExpressionReal: // "__real__" UnaryExpression - panic(todo("", n.Position())) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func isSigned(t cc.Type) bool { return t.IsIntegerType() && t.IsSignedType() } -func isUnsigned(t cc.Type) bool { return t.IsIntegerType() && !t.IsSignedType() } - -func isConstInteger(op cc.Operand) bool { - switch op.Value().(type) { - case cc.Int64Value, cc.Uint64Value: - return true - default: - return false - } -} - -func isNegativeInt(op cc.Operand) bool { - switch x := op.Value().(type) { - case cc.Int64Value: - return x < 0 - default: - return false - } -} - -func isNonNegativeInt(op cc.Operand) bool { - switch x := op.Value().(type) { - case cc.Int64Value: - return x >= 0 - case cc.Uint64Value: - return true - default: - return false - } -} - -func (p *project) unaryExpressionPreIncDec(f *function, n *cc.UnaryExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) { - // "++" UnaryExpression etc. - switch mode { - case exprValue: - p.unaryExpressionPreIncDecValue(f, n, oper, oper2, t, mode, flags) - case exprVoid: - p.unaryExpressionPreIncDecVoid(f, n, oper, oper2, t, mode, flags) - default: - panic(todo("", p.pos(n), mode)) - } -} - -func (p *project) unaryExpressionPreIncDecVoid(f *function, n *cc.UnaryExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) { - // "++" UnaryExpression etc. - switch n.UnaryExpression.Operand.Type().Kind() { - case cc.Int128, cc.UInt128: - p.unaryExpressionLValue(f, n.UnaryExpression, n.UnaryExpression.Operand.Type(), exprLValue, 0) - switch oper { - case "++": - p.w(".LValueInc()") - case "--": - p.w(".LValueDec()") - default: - panic(todo("internal error: %q", oper)) - } - return - } - - // "++" UnaryExpression etc. - switch k := p.opKind(f, n.UnaryExpression, n.UnaryExpression.Operand.Type()); k { - case opNormal: - p.unaryExpressionPreIncDecVoidNormal(f, n, oper, oper2, t, mode, flags) - case opArrayParameter: - p.unaryExpressionPreIncDecVoidArrayParameter(f, n, oper, oper2, t, mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) unaryExpressionPreIncDecVoidArrayParameter(f *function, n *cc.UnaryExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) { - // "++" UnaryExpression etc. - ut := n.UnaryExpression.Operand.Type() - p.unaryExpression(f, n.UnaryExpression, n.UnaryExpression.Operand.Type(), exprLValue, flags) - switch d := p.incDelta(n, ut); d { - case 1: - p.w("%s", oper) - default: - p.w("%s %d", oper2, d) - } -} - -func (p *project) unaryExpressionPreIncDecVoidNormal(f *function, n *cc.UnaryExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) { - // "++" UnaryExpression etc. - ut := n.UnaryExpression.Operand.Type() - if d := n.UnaryExpression.Declarator(); d != nil && p.isVolatileOrAtomic(d) { - x := "Dec" - if oper == "++" { - x = "Inc" - } - p.w("%sPre%sAtomic%s(&", p.task.crt, x, p.helperType(n, d.Type())) - switch local, tld := f.locals[d], p.tlds[d]; { - case local != nil: - p.w("%s", local.name) - case tld != nil: - p.w("%s", tld.name) - default: - panic(todo("")) - } - p.w(", %d)", p.incDelta(n.PostfixExpression, ut)) - return - } - - p.unaryExpression(f, n.UnaryExpression, n.UnaryExpression.Operand.Type(), exprLValue, flags) - if ut.IsIntegerType() || ut.Kind() == cc.Ptr && p.incDelta(n, ut) == 1 { - p.w("%s", oper) - return - } - - switch ut.Kind() { - case cc.Ptr, cc.Double, cc.Float: - p.w("%s %d", oper2, p.incDelta(n, ut)) - return - } - - panic(todo("", p.pos(n))) -} - -func (p *project) unaryExpressionPreIncDecValue(f *function, n *cc.UnaryExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) { - // "++" UnaryExpression etc. - switch k := p.opKind(f, n.UnaryExpression, n.UnaryExpression.Operand.Type()); k { - case opNormal: - p.unaryExpressionPreIncDecValueNormal(f, n, oper, oper2, t, mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) unaryExpressionPreIncDecValueNormal(f *function, n *cc.UnaryExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) { - // "++" UnaryExpression etc. - defer p.w("%s", p.convert(n, n.UnaryExpression.Operand, t, flags)) - x := "Dec" - if oper == "++" { - x = "Inc" - } - ut := n.UnaryExpression.Operand.Type() - p.w("%sPre%s%s(&", p.task.crt, x, p.helperType(n, ut)) - p.unaryExpression(f, n.UnaryExpression, ut, exprLValue, flags) - p.w(", %d)", p.incDelta(n.PostfixExpression, ut)) -} - -func (p *project) unaryExpressionDeref(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) { - // '*' CastExpression - switch mode { - case exprValue: - p.unaryExpressionDerefValue(f, n, t, mode, flags) - case exprLValue: - p.unaryExpressionDerefLValue(f, n, t, mode, flags) - case exprAddrOf: - p.unaryExpressionDerefAddrOf(f, n, t, mode, flags) - case exprBool: - p.unaryExpressionDerefBool(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) unaryExpressionDerefBool(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) { - // '*' CastExpression - p.w("(") - defer p.w(")") - p.w("*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type())) - p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags) - p.w(")) != 0") -} - -func (p *project) unaryExpressionDerefAddrOf(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) { - // '*' CastExpression - p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags) -} - -func (p *project) unaryExpressionDerefLValue(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) { - // '*' CastExpression - switch k := p.opKind(f, n.CastExpression, n.CastExpression.Operand.Type()); k { - case opNormal: - p.unaryExpressionDerefLValueNormal(f, n, t, mode, flags) - case opArray: - panic(todo("", p.pos(n))) - p.unaryExpressionDerefLValueArray(f, n, t, mode, flags) - case opArrayParameter: - p.unaryExpressionDerefLValueNormal(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) unaryExpressionDerefLValueArray(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) { - defer p.w("))%s", p.convertType(n, n.CastExpression.Operand.Type().Elem(), t, flags)) - p.w("*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type())) - p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags) -} - -func (p *project) unaryExpressionDerefLValueNormal(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) { - defer p.w("))%s", p.convertType(n, n.CastExpression.Operand.Type().Elem(), t, flags)) - p.w("*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type())) - p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags) -} - -func (p *project) unaryExpressionDerefValue(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) { - // '*' CastExpression - switch k := p.opKind(f, n.CastExpression, n.CastExpression.Operand.Type()); k { - case opNormal, opArrayParameter: - p.unaryExpressionDerefValueNormal(f, n, t, mode, flags) - case opArray: - p.unaryExpressionDerefValueArray(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) unaryExpressionDerefValueArray(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) { - defer p.w("%s", p.convertType(n, n.CastExpression.Operand.Type().Elem(), t, flags)) - p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags) - p.w("[0]") -} - -func (p *project) unaryExpressionDerefValueNormal(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) { - // '*' CastExpression - switch op := n.Operand.Type(); { - case op.Kind() == cc.Array: - p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), mode, flags) - default: - defer p.w("))%s", p.convertType(n, n.CastExpression.Operand.Type().Elem(), t, flags)) - p.w("*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type())) - p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), mode, flags) - } -} - -func (p *project) postfixExpression(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprLValue: - p.postfixExpressionLValue(f, n, t, mode, flags) - case exprValue: - p.postfixExpressionValue(f, n, t, mode, flags) - case exprVoid: - p.postfixExpressionVoid(f, n, t, mode, flags) - case exprFunc: - p.postfixExpressionFunc(f, n, t, mode, flags) - case exprAddrOf: - p.postfixExpressionAddrOf(f, n, t, mode, flags) - case exprSelect: - p.postfixExpressionSelect(f, n, t, mode, flags) - case exprPSelect: - p.postfixExpressionPSelect(f, n, t, mode, flags) - case exprBool: - p.postfixExpressionBool(f, n, t, mode, flags) - case exprDecay: - p.postfixExpressionDecay(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) postfixExpressionDecay(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.PostfixExpressionPrimary: // PrimaryExpression - p.primaryExpression(f, n.PrimaryExpression, t, mode, flags) - case cc.PostfixExpressionIndex: // PostfixExpression '[' Expression ']' - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - pe := n.PostfixExpression.Operand.Type() - p.w("(") - switch { - case pe.Kind() == cc.Array: - p.postfixExpression(f, n.PostfixExpression, pe, exprDecay, flags) - case pe.Kind() == cc.Ptr: - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - default: - panic(todo("", p.pos(n))) - } - if !n.Expression.Operand.IsZero() { - p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand) - if sz := pe.Elem().Size(); sz != 1 { - p.w("*%d", sz) - } - } - p.w(")") - case cc.PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')' - panic(todo("", p.pos(n))) - case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER - p.postfixExpression(f, n, t, exprAddrOf, flags) - case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER - p.postfixExpression(f, n, t, exprAddrOf, flags) - case cc.PostfixExpressionInc: // PostfixExpression "++" - panic(todo("", p.pos(n))) - case cc.PostfixExpressionDec: // PostfixExpression "--" - panic(todo("", p.pos(n))) - case cc.PostfixExpressionComplit: // '(' TypeName ')' '{' InitializerList ',' '}' - panic(todo("", p.pos(n))) - case cc.PostfixExpressionTypeCmp: // "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')' - panic(todo("", p.pos(n))) - case cc.PostfixExpressionChooseExpr: - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) postfixExpressionBool(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.PostfixExpressionPrimary: // PrimaryExpression - p.primaryExpression(f, n.PrimaryExpression, t, mode, flags) - case cc.PostfixExpressionIndex: // PostfixExpression '[' Expression ']' - p.w("(") - defer p.w(")") - defer p.w(" != 0") - p.postfixExpression(f, n, t, exprValue, flags) - case cc.PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')' - p.postfixExpressionCall(f, n, t, mode, flags) - case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER - p.w("(") - defer p.w(")") - defer p.w(" != 0") - p.postfixExpression(f, n, t, exprValue, flags) - case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER - p.w("(") - defer p.w(")") - defer p.w(" != 0") - p.postfixExpression(f, n, t, exprValue, flags) - case cc.PostfixExpressionInc: // PostfixExpression "++" - p.w("(") - defer p.w(")") - defer p.w(" != 0") - p.postfixExpression(f, n, t, exprValue, flags) - case cc.PostfixExpressionDec: // PostfixExpression "--" - p.w("(") - defer p.w(")") - defer p.w(" != 0") - p.postfixExpression(f, n, t, exprValue, flags) - case cc.PostfixExpressionComplit: // '(' TypeName ')' '{' InitializerList ',' '}' - panic(todo("", p.pos(n))) - case cc.PostfixExpressionTypeCmp: // "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')' - panic(todo("", p.pos(n))) - case cc.PostfixExpressionChooseExpr: - p.w("(") - defer p.w(")") - defer p.w(" != 0") - p.postfixExpression(f, n, t, exprValue, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) postfixExpressionPSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression "->" IDENTIFIER - switch n.Case { - case cc.PostfixExpressionPrimary: // PrimaryExpression - p.primaryExpression(f, n.PrimaryExpression, t, mode, flags) - case cc.PostfixExpressionIndex: // PostfixExpression '[' Expression ']' - p.postfixExpressionPSelectIndex(f, n, t, mode, flags) - case cc.PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')' - p.postfixExpressionPSelectCall(f, n, t, mode, flags) - case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER - p.postfixExpressionPSelectSelect(f, n, t, mode, flags) - case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER - p.postfixExpressionPSelectPSelect(f, n, t, mode, flags) - case cc.PostfixExpressionInc: // PostfixExpression "++" - panic(todo("", p.pos(n))) - case cc.PostfixExpressionDec: // PostfixExpression "--" - panic(todo("", p.pos(n))) - case cc.PostfixExpressionComplit: // '(' TypeName ')' '{' InitializerList ',' '}' - panic(todo("", p.pos(n))) - case cc.PostfixExpressionTypeCmp: // "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')' - panic(todo("", p.pos(n))) - case cc.PostfixExpressionChooseExpr: - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) postfixExpressionPSelectSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '.' IDENTIFIER - switch k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type()); k { - case opStruct: - p.postfixExpressionPSelectSelectStruct(f, n, t, mode, flags) - case opUnion: - p.postfixExpressionPSelectSelectUnion(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) postfixExpressionPSelectSelectUnion(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '.' IDENTIFIER - fld := n.Field - if fld.Offset() != 0 { - p.err(&n.Token2, "internal error, union field with non-zero offset: %s %v", n.Token2.Value, fld.Offset()) - } - switch { - case n.Operand.Type().IsBitFieldType(): - panic(todo("", p.pos(n))) - default: - if fld.IsBitField() { - p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value) - } - pe := n.PostfixExpression.Operand.Type() - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.w("(*(**%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type().Elem())) - p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags) - p.w("/* .%s */", p.fieldName(n, n.Token2.Value)) - p.w(")))") - } -} - -func (p *project) postfixExpressionPSelectSelectStruct(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '.' IDENTIFIER - fld := n.Field - switch { - case n.Operand.Type().IsBitFieldType(): - panic(todo("", p.pos(n))) - default: - if fld.IsBitField() { - p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value) - } - pe := n.PostfixExpression.Operand.Type() - p.w("(*%s)(unsafe.Pointer(", p.typ(n, t.Elem())) - p.postfixExpression(f, n.PostfixExpression, pe, exprSelect, flags) - p.w(".%s", p.fieldName(n, n.Token2.Value)) - p.w("))") - - } -} - -func (p *project) postfixExpressionPSelectCall(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - p.w("(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type().Elem())) - p.postfixExpressionCall(f, n, t, exprValue, flags) - p.w("))") -} - -func (p *project) postfixExpressionPSelectIndex(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '[' Expression ']' - switch k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type()); k { - // case opArray: - // p.postfixExpressionSelectIndexArray(f, n, t, mode, flags) - case opNormal: - p.postfixExpressionPSelectIndexNormal(f, n, t, mode, flags) - case opArrayParameter: - p.postfixExpressionSelectIndexArrayParamater(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) postfixExpressionPSelectIndexNormal(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - pe := n.PostfixExpression.Operand.Type() - // PostfixExpression '[' Expression ']' - switch { - case n.Operand.Type().IsBitFieldType(): - panic(todo("", p.pos(n))) - case n.Operand.Type().Kind() == cc.Array: - panic(todo("", p.pos(n))) - case pe.Kind() == cc.Array: - p.w("(") - defer p.w(")") - p.w("(*(**%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type().Elem())) - p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags) - if !n.Expression.Operand.IsZero() { - p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand) - if sz := pe.Decay().Elem().Size(); sz != 1 { - p.w("*%d", sz) - } - } - p.w(")))") - default: - p.w("(") - defer p.w(")") - p.w("(*(**%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type().Elem())) - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - if !n.Expression.Operand.IsZero() { - p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand) - if sz := pe.Decay().Elem().Size(); sz != 1 { - p.w("*%d", sz) - } - } - p.w(")))") - } -} - -func (p *project) postfixExpressionSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '.' IDENTIFIER - switch n.Case { - case cc.PostfixExpressionPrimary: // PrimaryExpression - p.primaryExpression(f, n.PrimaryExpression, t, mode, flags) - case cc.PostfixExpressionIndex: // PostfixExpression '[' Expression ']' - p.postfixExpressionSelectIndex(f, n, t, mode, flags) - case cc.PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')' - p.postfixExpression(f, n, t, exprValue, flags) - case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER - p.postfixExpressionSelectSelect(f, n, t, mode, flags) - case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER - p.postfixExpressionSelectPSelect(f, n, t, mode, flags) - case cc.PostfixExpressionInc: // PostfixExpression "++" - panic(todo("", p.pos(n))) - case cc.PostfixExpressionDec: // PostfixExpression "--" - panic(todo("", p.pos(n))) - case cc.PostfixExpressionComplit: // '(' TypeName ')' '{' InitializerList ',' '}' - panic(todo("", p.pos(n))) - case cc.PostfixExpressionTypeCmp: // "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')' - panic(todo("", p.pos(n))) - case cc.PostfixExpressionChooseExpr: - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) postfixExpressionPSelectPSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression "->" IDENTIFIER - switch k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type().Elem()); k { - case opStruct: - p.postfixExpressionPSelectPSelectStruct(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) postfixExpressionPSelectPSelectStruct(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression "->" IDENTIFIER - fld := n.Field - switch { - case n.Operand.Type().IsBitFieldType(): - panic(todo("", p.pos(n))) - default: - if fld.IsBitField() { - p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value) - } - pe := n.PostfixExpression.Operand.Type() - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.w("(*%s)(unsafe.Pointer(", p.typ(n, t.Elem())) - p.postfixExpression(f, n.PostfixExpression, pe, exprPSelect, flags) - p.w(".%s", p.fieldName(n, n.Token2.Value)) - p.w("))") - } -} - -func (p *project) postfixExpressionSelectPSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression "->" IDENTIFIER - switch k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type().Elem()); k { - case opStruct: - p.postfixExpressionSelectPSelectStruct(f, n, t, mode, flags) - case opUnion: - p.postfixExpressionSelectPSelectUnion(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) postfixExpressionSelectPSelectUnion(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression "->" IDENTIFIER - fld := n.Field - if fld.Offset() != 0 { - p.err(&n.Token2, "internal error, union field with non-zero offset: %s %v", n.Token2.Value, fld.Offset()) - } - switch { - case n.Operand.Type().IsBitFieldType(): - panic(todo("", p.pos(n))) - case n.Operand.Type().Kind() == cc.Array: - panic(todo("", p.pos(n))) - default: - if fld.IsBitField() { - p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value) - } - pe := n.PostfixExpression.Operand.Type() - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.w("(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type())) - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - p.w("))") - } -} - -func (p *project) postfixExpressionSelectPSelectStruct(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression "->" IDENTIFIER - fld := n.Field - switch { - case n.Operand.Type().IsBitFieldType(): - panic(todo("", p.pos(n))) - default: - if fld.IsBitField() { - p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value) - } - pe := n.PostfixExpression.Operand.Type() - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - et := n.PostfixExpression.Operand.Type().Elem() - fld, path, ok := et.FieldByName2(n.Token2.Value) - switch { - case !ok: - panic(todo("", n.Token.Position())) - case fld.InUnion(): - p.w("(*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type())) - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - p.w("%s)))", nonZeroUintptr(pathOff(et, path))) - case len(path) != 1: - panic(todo("", n.Token.Position())) - default: - p.w("(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem())) - switch { - case pe.Kind() == cc.Array: - p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags) - default: - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - } - p.w(")).%s", p.fieldName(n, n.Token2.Value)) - } - } -} - -func (p *project) postfixExpressionSelectSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '.' IDENTIFIER - switch k := p.structOrUnion(n); k { - case opUnion: - p.postfixExpressionSelectSelectUnion(f, n, t, mode, flags) - case opStruct: - p.postfixExpressionSelectSelectStruct(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) structOrUnion(n *cc.PostfixExpression) opKind { - t := n.PostfixExpression.Operand.Type() - switch n.Case { - case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER - // ok - case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER - if t.Kind() == cc.Ptr { - t = t.Elem() - break - } - - p.err(n, "expected pointer type: %s", t) - return opStruct - } - f, path, ok := t.FieldByName2(n.Token2.Src) - if !ok { - p.err(&n.Token, "unknown field: %s", n.Token2) - return opStruct - } - - for len(path) > 1 { - f = t.FieldByIndex(path[:1]) - path = path[1:] - t = f.Type() - } - if t.Kind() == cc.Union { - // trc("%v: %q %v", n.Token2.Position(), n.Token2.Src, opUnion) - return opUnion - } - - // trc("%v: %q %v", n.Token2.Position(), n.Token2.Src, opStruct) - return opStruct -} - -func (p *project) postfixExpressionSelectSelectStruct(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '.' IDENTIFIER - fld := n.Field - switch { - case n.Operand.Type().IsBitFieldType(): - panic(todo("", p.pos(n))) - case n.Operand.Type().Kind() == cc.Array: - panic(todo("", p.pos(n))) - default: - if fld.IsBitField() { - p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value) - } - pe := n.PostfixExpression.Operand.Type() - p.postfixExpression(f, n.PostfixExpression, pe, exprSelect, flags) - p.w(".%s", p.fieldName(n, n.Token2.Value)) - } -} - -func (p *project) postfixExpressionSelectSelectUnion(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '.' IDENTIFIER - fld := n.Field - if fld.Offset() != 0 { - p.err(&n.Token2, "internal error, union field with non-zero offset: %s %v", n.Token2.Value, fld.Offset()) - } - switch { - case n.Operand.Type().IsBitFieldType(): - panic(todo("", p.pos(n))) - case n.Operand.Type().Kind() == cc.Array: - panic(todo("", p.pos(n))) - default: - if fld.IsBitField() { - p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value) - } - pe := n.PostfixExpression.Operand.Type() - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.w("(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type())) - p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags) - p.w("))") - } -} - -func (p *project) postfixExpressionSelectIndex(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '[' Expression ']' - switch k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type()); k { - case opArray: - p.postfixExpressionSelectIndexArray(f, n, t, mode, flags) - case opNormal: - p.postfixExpressionSelectIndexNormal(f, n, t, mode, flags) - case opArrayParameter: - p.postfixExpressionSelectIndexArrayParamater(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) postfixExpressionSelectIndexArrayParamater(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - pe := n.PostfixExpression.Operand.Type() - // PostfixExpression '[' Expression ']' - switch { - case n.Operand.Type().IsBitFieldType(): - panic(todo("", p.pos(n))) - case n.Operand.Type().Kind() == cc.Array: - panic(todo("", p.pos(n))) - default: - p.w("(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem())) - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - if !n.Expression.Operand.IsZero() { - p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand) - if sz := pe.Decay().Elem().Size(); sz != 1 { - p.w("*%d", sz) - } - } - p.w("))") - } -} - -func (p *project) postfixExpressionSelectIndexNormal(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - pe := n.PostfixExpression.Operand.Type() - // PostfixExpression '[' Expression ']' - switch { - case n.Operand.Type().IsBitFieldType(): - panic(todo("", p.pos(n))) - case n.Operand.Type().Kind() == cc.Array: - panic(todo("", p.pos(n))) - case pe.Kind() != cc.Ptr: - p.w("(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem())) - p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags) - if !n.Expression.Operand.IsZero() { - p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand) - if sz := pe.Decay().Elem().Size(); sz != 1 { - p.w("*%d", sz) - } - } - p.w("))") - default: - p.w("(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem())) - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - if !n.Expression.Operand.IsZero() { - p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand) - if sz := pe.Decay().Elem().Size(); sz != 1 { - p.w("*%d", sz) - } - } - p.w("))") - } -} - -func (p *project) postfixExpressionSelectIndexArray(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '[' Expression ']' - switch { - case n.Operand.Type().IsBitFieldType(): - panic(todo("", p.pos(n))) - case n.Operand.Type().Kind() == cc.Array: - panic(todo("", p.pos(n))) - default: - pe := n.PostfixExpression.Operand.Type() - p.postfixExpression(f, n.PostfixExpression, pe, mode, flags) - p.w("[") - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) - p.w("]") - } -} - -func (p *project) postfixExpressionAddrOf(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.PostfixExpressionPrimary: // PrimaryExpression - p.primaryExpression(f, n.PrimaryExpression, t, mode, flags) - case cc.PostfixExpressionIndex: // PostfixExpression '[' Expression ']' - p.postfixExpressionAddrOfIndex(f, n, t, mode, flags) - case cc.PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')' - ot := n.Operand.Type() - switch ot.Kind() { - case cc.Struct, cc.Union: - // ok - default: - p.err(n, "cannot take address of value of type %v", n.Operand.Type()) - return - } - - if p.pass1 { - off := roundup(f.off, uintptr(ot.Align())) - f.complits[n] = off - f.off += ot.Size() - return - } - - off := f.complits[n] - p.w("func() uintptr { *(*%s)(unsafe.Pointer(%s%s)) = ", p.typ(n, ot), f.bpName, nonZeroUintptr(off)) - p.postfixExpressionValue(f, n, ot, exprValue, flags) - p.w("; return %s%s }()", f.bpName, nonZeroUintptr(off)) - case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER - p.postfixExpressionAddrOfSelect(f, n, t, mode, flags) - case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER - p.postfixExpressionAddrOfPSelect(f, n, t, mode, flags) - case cc.PostfixExpressionInc: // PostfixExpression "++" - p.postfixExpressionIncDec(f, n, "++", "+=", t, exprLValue, flags) - case cc.PostfixExpressionDec: // PostfixExpression "--" - panic(todo("", p.pos(n))) - case cc.PostfixExpressionComplit: // '(' TypeName ')' '{' InitializerList ',' '}' - tn := n.TypeName.Type() - switch tn.Decay().Kind() { - case cc.Ptr: - switch tn.Kind() { - case cc.Array: - switch { - case p.pass1: - off := roundup(f.off, uintptr(tn.Elem().Align())) - f.complits[n] = off - f.off += tn.Size() - default: - off := f.complits[n] - p.w(" func() uintptr { *(*%s)(unsafe.Pointer(%s%s)) = ", p.typ(n, tn), f.bpName, nonZeroUintptr(off)) - p.initializer(f, &cc.Initializer{Case: cc.InitializerInitList, InitializerList: n.InitializerList}, tn, cc.Automatic, nil) - p.w("; return %s%s }()", f.bpName, nonZeroUintptr(off)) - } - default: - panic(todo("%v: %v", n.Position(), tn)) - } - default: - switch { - case p.pass1: - off := roundup(f.off, uintptr(tn.Align())) - f.complits[n] = off - f.off += tn.Size() - default: - off := f.complits[n] - p.w(" func() uintptr { *(*%s)(unsafe.Pointer(%s%s)) = ", p.typ(n, tn), f.bpName, nonZeroUintptr(off)) - p.initializer(f, &cc.Initializer{Case: cc.InitializerInitList, InitializerList: n.InitializerList}, tn, cc.Automatic, nil) - p.w("; return %s%s }()", f.bpName, nonZeroUintptr(off)) - } - } - case cc.PostfixExpressionTypeCmp: // "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')' - panic(todo("", p.pos(n))) - case cc.PostfixExpressionChooseExpr: - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) postfixExpressionAddrOfPSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression "->" IDENTIFIER - p.w("(") - defer p.w(")") - pe := n.PostfixExpression.Operand.Type() - switch { - case n.Operand.Type().IsBitFieldType(): - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - p.bitFldOff(pe.Elem(), n.Token2) - case pe.Kind() == cc.Array: - p.postfixExpression(f, n.PostfixExpression, pe, exprDecay, flags) - p.fldOff(pe.Elem(), n.Token2) - default: - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - p.fldOff(pe.Elem(), n.Token2) - } -} - -func (p *project) postfixExpressionAddrOfIndex(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '[' Expression ']' - p.w("(") - defer p.w(")") - switch { - case n.Operand.Type().Kind() == cc.Array: - fallthrough - default: - pe := n.PostfixExpression.Operand.Type() - d := n.PostfixExpression.Declarator() - switch { - case pe.Kind() == cc.Ptr: - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - case pe.Kind() == cc.Array && d != nil && d.IsParameter: - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - default: - p.postfixExpression(f, n.PostfixExpression, pe, mode, flags) - } - if !n.Expression.Operand.IsZero() { - p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand) - if sz := pe.Decay().Elem().Size(); sz != 1 { - p.w("*%d", sz) - } - } - } -} - -func (p *project) postfixExpressionAddrOfSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '.' IDENTIFIER - p.w("(") - defer p.w(")") - switch { - case n.Operand.Type().IsBitFieldType(): - pe := n.PostfixExpression.Operand.Type() - p.postfixExpression(f, n.PostfixExpression, nil, mode, flags) - p.bitFldOff(pe, n.Token2) - case n.Operand.Type().Kind() == cc.Array: - fallthrough - default: - pe := n.PostfixExpression.Operand.Type() - p.postfixExpression(f, n.PostfixExpression, nil, mode, flags) - p.fldOff(pe, n.Token2) - } -} - -func (p *project) postfixExpressionFunc(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.PostfixExpressionPrimary: // PrimaryExpression - p.primaryExpression(f, n.PrimaryExpression, t, mode, flags) - case cc.PostfixExpressionIndex: // PostfixExpression '[' Expression ']' - switch n.Operand.Type().Kind() { - case cc.Ptr: - switch et := n.Operand.Type().Elem(); et.Kind() { - case cc.Function: - p.fnVal(n, f, func() { - p.postfixExpression(f, n, n.Operand.Type(), exprValue, flags) - }, nil, n.Operand.Type(), 0, mode, flags) - default: - panic(todo("", p.pos(n), et, et.Kind())) - } - default: - panic(todo("", n.Position(), n.Operand.Type())) - } - case cc.PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')' - switch n.Operand.Type().Kind() { - case cc.Ptr: - switch et := n.Operand.Type().Elem(); et.Kind() { - case cc.Function: - p.fnVal(n, f, func() { - p.postfixExpressionCall(f, n, t, exprValue, flags) - }, nil, n.Operand.Type(), 0, mode, flags) - default: - panic(todo("", p.pos(n), et, et.Kind())) - } - default: - panic(todo("", n.Position(), n.Operand.Type())) - } - case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER - switch n.Operand.Type().Kind() { - case cc.Ptr: - switch n.Operand.Type().Kind() { - case cc.Ptr: - switch et := n.Operand.Type().Elem(); et.Kind() { - case cc.Function: - p.fnVal(n, f, func() { p.postfixExpression(f, n, p.ptrType, exprValue, flags) }, nil, n.Operand.Type(), 0, mode, flags) - default: - panic(todo("", p.pos(n), et, et.Kind())) - } - default: - panic(todo("", p.pos(n), n.Operand.Type(), n.Operand.Type().Kind())) - } - default: - panic(todo("", n.Position(), n.Operand.Type())) - } - case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER - p.fnVal(n, f, func() { p.postfixExpression(f, n, p.ptrType, exprValue, flags) }, nil, n.Operand.Type(), 0, mode, flags) - case cc.PostfixExpressionInc: // PostfixExpression "++" - panic(todo("", p.pos(n))) - case cc.PostfixExpressionDec: // PostfixExpression "--" - panic(todo("", p.pos(n))) - case cc.PostfixExpressionComplit: // '(' TypeName ')' '{' InitializerList ',' '}' - panic(todo("", p.pos(n))) - case cc.PostfixExpressionTypeCmp: // "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')' - panic(todo("", p.pos(n))) - case cc.PostfixExpressionChooseExpr: - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) postfixExpressionVoid(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.PostfixExpressionPrimary: // PrimaryExpression - p.primaryExpression(f, n.PrimaryExpression, t, mode, flags) - case cc.PostfixExpressionIndex: // PostfixExpression '[' Expression ']' - p.w("_ = ") - p.postfixExpression(f, n, n.Operand.Type(), exprValue, flags) - case cc.PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')' - p.postfixExpressionCall(f, n, n.Operand.Type(), mode, flags) - case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER - p.w("_ = ") - p.postfixExpression(f, n, n.Operand.Type(), exprValue, flags) - case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER - p.w("_ = ") - p.postfixExpression(f, n, n.Operand.Type(), exprValue, flags) - case cc.PostfixExpressionInc: // PostfixExpression "++" - p.postfixExpressionIncDec(f, n, "++", "+=", t, mode, flags) - case cc.PostfixExpressionDec: // PostfixExpression "--" - p.postfixExpressionIncDec(f, n, "--", "-=", t, mode, flags) - case cc.PostfixExpressionComplit: // '(' TypeName ')' '{' InitializerList ',' '}' - tn := n.TypeName.Type() - switch tn.Decay().Kind() { - case cc.Ptr: - switch tn.Kind() { - case cc.Array: - switch { - case p.pass1: - off := roundup(f.off, uintptr(tn.Elem().Align())) - f.complits[n] = off - f.off += tn.Size() - default: - off := f.complits[n] - p.w("*(*%s)(unsafe.Pointer(%s%s)) = ", p.typ(n, tn), f.bpName, nonZeroUintptr(off)) - p.initializer(f, &cc.Initializer{Case: cc.InitializerInitList, InitializerList: n.InitializerList}, tn, cc.Automatic, nil) - } - return - default: - panic(todo("%v: %v", n.Position(), tn)) - } - } - - defer p.w("%s", p.convertType(n, tn, t, flags)) - p.w("_ = ") - p.initializer(f, &cc.Initializer{Case: cc.InitializerInitList, InitializerList: n.InitializerList}, tn, cc.Automatic, nil) - case cc.PostfixExpressionTypeCmp: // "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')' - panic(todo("", p.pos(n))) - case cc.PostfixExpressionChooseExpr: - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) postfixExpressionValue(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.PostfixExpressionPrimary: // PrimaryExpression - if p.isArray(f, n.PrimaryExpression, n.Operand.Type()) && t.Kind() == cc.Ptr { - mode = exprDecay - } - p.primaryExpression(f, n.PrimaryExpression, t, mode, flags) - case cc.PostfixExpressionIndex: // PostfixExpression '[' Expression ']' - p.postfixExpressionValueIndex(f, n, t, mode, flags) - case cc.PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')' - p.postfixExpressionCall(f, n, t, mode, flags) - case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER - p.postfixExpressionValueSelect(f, n, t, mode, flags) - case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER - p.postfixExpressionValuePSelect(f, n, t, mode, flags) - case cc.PostfixExpressionInc: // PostfixExpression "++" - p.postfixExpressionIncDec(f, n, "++", "+=", t, mode, flags) - case cc.PostfixExpressionDec: // PostfixExpression "--" - p.postfixExpressionIncDec(f, n, "--", "-=", t, mode, flags) - case cc.PostfixExpressionComplit: // '(' TypeName ')' '{' InitializerList ',' '}' - tn := n.TypeName.Type() - switch tn.Decay().Kind() { - case cc.Ptr: - switch tn.Kind() { - case cc.Array: - switch { - case p.pass1: - off := roundup(f.off, uintptr(tn.Elem().Align())) - f.complits[n] = off - f.off += tn.Size() - default: - off := f.complits[n] - p.w(" func() uintptr { *(*%s)(unsafe.Pointer(%s%s)) = ", p.typ(n, tn), f.bpName, nonZeroUintptr(off)) - p.initializer(f, &cc.Initializer{Case: cc.InitializerInitList, InitializerList: n.InitializerList}, tn, cc.Automatic, nil) - p.w("; return %s%s }()", f.bpName, nonZeroUintptr(off)) - } - return - default: - panic(todo("%v: %v", n.Position(), tn)) - } - } - - defer p.w("%s", p.convertType(n, tn, t, flags)) - p.initializer(f, &cc.Initializer{Case: cc.InitializerInitList, InitializerList: n.InitializerList}, tn, cc.Automatic, nil) - case cc.PostfixExpressionTypeCmp: // "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')' - // Built-in Function: int __builtin_types_compatible_p (type1, type2) You can - // use the built-in function __builtin_types_compatible_p to determine whether - // two types are the same. - // - // This built-in function returns 1 if the unqualified versions of the types - // type1 and type2 (which are types, not expressions) are compatible, 0 - // otherwise. The result of this built-in function can be used in integer - // constant expressions. - // - // This built-in function ignores top level qualifiers (e.g., const, volatile). - // For example, int is equivalent to const int. - // - // The type int[] and int[5] are compatible. On the other hand, int and char * - // are not compatible, even if the size of their types, on the particular - // architecture are the same. Also, the amount of pointer indirection is taken - // into account when determining similarity. Consequently, short * is not - // similar to short **. Furthermore, two types that are typedefed are - // considered compatible if their underlying types are compatible. - // - // An enum type is not considered to be compatible with another enum type even - // if both are compatible with the same integer type; this is what the C - // standard specifies. For example, enum {foo, bar} is not similar to enum - // {hot, dog}. - // - // You typically use this function in code whose execution varies depending on - // the arguments’ types. For example: - // - // #define foo(x) \ - // ({ \ - // typeof (x) tmp = (x); \ - // if (__builtin_types_compatible_p (typeof (x), long double)) \ - // tmp = foo_long_double (tmp); \ - // else if (__builtin_types_compatible_p (typeof (x), double)) \ - // tmp = foo_double (tmp); \ - // else if (__builtin_types_compatible_p (typeof (x), float)) \ - // tmp = foo_float (tmp); \ - // else \ - // abort (); \ - // tmp; \ - // }) - // - // Note: This construct is only available for C. - p.w(" %d ", n.Operand.Value()) - case cc.PostfixExpressionChooseExpr: // "__builtin_choose_expr" '(' AssignmentExpression ',' AssignmentExpression ',' AssignmentExpression ')' - // You can use the built-in function __builtin_choose_expr to evaluate code - // depending on the value of a constant expression. This built-in function - // returns exp1 if const_exp, which is an integer constant expression, is - // nonzero. Otherwise it returns exp2. - // - // This built-in function is analogous to the ‘? :’ operator in C, except that - // the expression returned has its type unaltered by promotion rules. Also, the - // built-in function does not evaluate the expression that is not chosen. For - // example, if const_exp evaluates to true, exp2 is not evaluated even if it - // has side effects. - // - // This built-in function can return an lvalue if the chosen argument is an - // lvalue. - // - // If exp1 is returned, the return type is the same as exp1’s type. Similarly, - // if exp2 is returned, its return type is the same as exp2. - // - // Example: - // - // #define foo(x) \ - // __builtin_choose_expr ( \ - // __builtin_types_compatible_p (typeof (x), double), \ - // foo_double (x), \ - // __builtin_choose_expr ( \ - // __builtin_types_compatible_p (typeof (x), float), \ - // foo_float (x), \ - // /* The void expression results in a compile-time error \ - // when assigning the result to something. */ \ - // (void)0)) - // - // Note: This construct is only available for C. Furthermore, the unused - // expression (exp1 or exp2 depending on the value of const_exp) may still - // generate syntax errors. This may change in future revisions. - switch op := n.AssignmentExpression.Operand; { - case op.IsNonZero(): - p.assignmentExpression(f, n.AssignmentExpression2, t, mode, flags) - case op.IsZero(): - p.assignmentExpression(f, n.AssignmentExpression3, t, mode, flags) - default: - panic(todo("")) - } - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) postfixExpressionValuePSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression "->" IDENTIFIER - switch k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type().Elem()); k { - case opStruct: - p.postfixExpressionValuePSelectStruct(f, n, t, mode, flags) - case opUnion: - p.postfixExpressionValuePSelectUnion(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) postfixExpressionValuePSelectUnion(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression "->" IDENTIFIER - fld := n.Field - if fld.Offset() != 0 { - p.err(&n.Token2, "internal error, union field with non-zero offset: %s %v", n.Token2.Value, fld.Offset()) - } - pe := n.PostfixExpression.Operand.Type() - switch { - case n.Operand.Type().IsBitFieldType(): - panic(todo("", p.pos(n))) - case n.Operand.Type().Kind() == cc.Array: - panic(todo("", p.pos(n))) - default: - if fld.IsBitField() { - p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value) - } - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.w("*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type())) - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - p.w("/* .%s */", p.fieldName(n, n.Token2.Value)) - p.w("))") - } -} - -func (p *project) postfixExpressionValuePSelectStruct(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression "->" IDENTIFIER - fld := n.Field - pe := n.PostfixExpression.Operand.Type() - k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type()) - switch { - case n.Operand.Type().IsBitFieldType(): - p.w("(") - defer p.w(")") - fld := n.Field - defer p.w("%s", p.convertType(n, fld.Promote(), t, flags)) - switch pe.Kind() { - case cc.Array: - x := p.convertType(n, nil, fld.Promote(), flags) - p.w("*(*uint%d)(unsafe.Pointer(", fld.BitFieldBlockWidth()) - p.postfixExpression(f, n.PostfixExpression, pe, exprDecay, flags) - p.bitFldOff(pe.Elem(), n.Token2) - p.w("))") - p.w("&%#x>>%d%s", fld.Mask(), fld.BitFieldOffset(), x) - if fld.Type().IsSignedType() { - panic(todo("")) - p.w("<<%d>>%[1]d", int(fld.Promote().Size()*8)-fld.BitFieldWidth()) - } - default: - x := p.convertType(n, nil, fld.Promote(), flags) - p.w("*(*uint%d)(unsafe.Pointer(", fld.BitFieldBlockWidth()) - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - p.bitFldOff(pe.Elem(), n.Token2) - p.w("))&%#x>>%d%s", fld.Mask(), fld.BitFieldOffset(), x) - if fld.Type().IsSignedType() { - p.w("<<%d>>%[1]d", int(fld.Promote().Size()*8)-fld.BitFieldWidth()) - } - } - case n.Operand.Type().Kind() == cc.Array: - defer p.w("%s", p.convertType(n, n.Operand.Type().Decay(), t.Decay(), flags)) - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - p.fldOff(n.PostfixExpression.Operand.Type().Elem(), n.Token2) - case k == opArray: - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - p.w("[0].%s", p.fieldName(n, n.Token2.Value)) - default: - if fld.IsBitField() { - p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value) - } - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - et := pe.Elem() - fld, path, ok := et.FieldByName2(n.Token2.Value) - switch { - case !ok: - panic(todo("")) - case fld.InUnion(): - p.w("*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type())) - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - p.w("%s))", nonZeroUintptr(pathOff(et, path))) - case len(path) != 1: - panic(todo("")) - default: - p.w("(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem())) - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - p.w(")).%s", p.fieldName(n, n.Token2.Value)) - } - } -} - -func pathOff(t cc.Type, path []int) (r uintptr) { - for len(path) != 0 { - f := t.FieldByIndex(path[:1]) - r += f.Offset() - path = path[1:] - t = f.Type() - } - return r -} - -func (p *project) postfixExpressionValueIndex(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '[' Expression ']' - switch k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type()); k { - case opArray: - p.postfixExpressionValueIndexArray(f, n, t, mode, flags) - case opNormal: - p.postfixExpressionValueIndexNormal(f, n, t, mode, flags) - case opArrayParameter: - p.postfixExpressionValueIndexArrayParameter(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} -func (p *project) postfixExpressionValueIndexArrayParameter(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '[' Expression ']' - pe := n.PostfixExpression.Operand.Type() - switch { - case n.Operand.Type().Kind() == cc.Array: - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.w("(") - defer p.w(")") - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - if !n.Expression.Operand.IsZero() { - p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand) - if sz := pe.Elem().Size(); sz != 1 { - p.w("*%d", sz) - } - } - default: - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.w("*(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem())) - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - if !n.Expression.Operand.IsZero() { - p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand) - if sz := pe.Elem().Size(); sz != 1 { - p.w("*%d", sz) - } - } - p.w("))") - } -} - -func (p *project) postfixExpressionValueIndexNormal(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '[' Expression ']' - switch { - case n.Operand.Type().Kind() == cc.Array: - p.w("(") - defer p.w(")") - pe := n.PostfixExpression.Operand.Type() - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - if !n.Expression.Operand.IsZero() { - p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand) - if sz := pe.Elem().Size(); sz != 1 { - p.w("*%d", sz) - } - } - default: - switch pe := n.PostfixExpression.Operand.Type(); pe.Kind() { - case cc.Ptr: - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.w("*(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem())) - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - if !n.Expression.Operand.IsZero() { - p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand) - if sz := pe.Elem().Size(); sz != 1 { - p.w("*%d", sz) - } - } - p.w("))") - case cc.Array: - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.w("*(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem())) - p.postfixExpression(f, n.PostfixExpression, pe, exprDecay, flags) - if !n.Expression.Operand.IsZero() { - p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand) - if sz := pe.Elem().Size(); sz != 1 { - p.w("*%d", sz) - } - } - p.w("))") - default: - panic(todo("", p.pos(n), pe, pe.Kind())) - } - } -} - -func (p *project) postfixExpressionValueIndexArray(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '[' Expression ']' - pe := n.PostfixExpression.Operand.Type() - switch n.Operand.Type().Kind() { - case cc.Array: - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.w("(") - defer p.w(")") - p.postfixExpression(f, n.PostfixExpression, pe, exprDecay, flags) - if !n.Expression.Operand.IsZero() { - p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand) - if sz := pe.Elem().Size(); sz != 1 { - p.w("*%d", sz) - } - } - default: - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.postfixExpression(f, n.PostfixExpression, pe, mode, flags) - p.w("[") - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) - p.w("]") - } -} - -func (p *project) postfixExpressionValueSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '.' IDENTIFIER - switch k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type()); k { - case opStruct: - p.postfixExpressionValueSelectStruct(f, n, t, mode, flags) - case opUnion: - p.postfixExpressionValueSelectUnion(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) postfixExpressionValueSelectUnion(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '.' IDENTIFIER - pe := n.PostfixExpression.Operand.Type() - fld := n.Field - switch { - case n.Operand.Type().IsBitFieldType(): - p.w("(") - defer p.w("%s)", p.convertType(n, fld.Promote(), t, flags)) - x := p.convertType(n, nil, fld.Promote(), flags) - p.w("*(*uint%d)(unsafe.Pointer(", fld.BitFieldBlockWidth()) - p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags) - p.bitFldOff(pe, n.Token2) - p.w("))&%#x>>%d%s", fld.Mask(), fld.BitFieldOffset(), x) - if fld.Type().IsSignedType() { - p.w("<<%d>>%[1]d", int(fld.Promote().Size()*8)-fld.BitFieldWidth()) - } - case n.Operand.Type().Kind() == cc.Array: - p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags) - default: - if fld.IsBitField() { - p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value) - } - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.w("*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type())) - p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags) - p.w("))") - } -} - -func (p *project) postfixExpressionValueSelectStruct(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '.' IDENTIFIER - pe := n.PostfixExpression.Operand.Type() - fld := n.Field - switch { - case n.Operand.Type().IsBitFieldType(): - p.w("(") - defer p.w("%s)", p.convertType(n, fld.Promote(), t, flags)) - x := p.convertType(n, nil, fld.Promote(), flags) - p.w("*(*uint%d)(unsafe.Pointer(", fld.BitFieldBlockWidth()) - p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags) - p.bitFldOff(pe, n.Token2) - p.w("))&%#x>>%d%s", fld.Mask(), fld.BitFieldOffset(), x) - if fld.Type().IsSignedType() { - p.w("<<%d>>%[1]d", int(fld.Promote().Size()*8)-fld.BitFieldWidth()) - } - case n.Operand.Type().Kind() == cc.Array: - p.postfixExpression(f, n, t, exprDecay, flags) - case fld.InUnion(): - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.w("*(*%s)(unsafe.Pointer(", p.typ(n, fld.Type())) - p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags) - p.fldOff(pe, n.Token2) - p.w("))") - default: - if fld.IsBitField() { - p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value) - } - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.postfixExpression(f, n.PostfixExpression, pe, exprSelect, flags) - p.w(".%s", p.fieldName(n, n.Token2.Value)) - } -} - -func (p *project) postfixExpressionLValue(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.PostfixExpressionPrimary: // PrimaryExpression - p.primaryExpression(f, n.PrimaryExpression, t, mode, flags) - case cc.PostfixExpressionIndex: // PostfixExpression '[' Expression ']' - p.postfixExpressionLValueIndex(f, n, t, mode, flags) - case cc.PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')' - panic(todo("", p.pos(n))) - case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER - p.postfixExpressionLValueSelect(f, n, t, mode, flags) - case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER - p.postfixExpressionLValuePSelect(f, n, t, mode, flags) - case cc.PostfixExpressionInc: // PostfixExpression "++" - p.postfixExpressionIncDec(f, n, "++", "+=", t, mode, flags) - case cc.PostfixExpressionDec: // PostfixExpression "--" - p.postfixExpressionIncDec(f, n, "--", "-=", t, mode, flags) - case cc.PostfixExpressionComplit: // '(' TypeName ')' '{' InitializerList ',' '}' - panic(todo("", p.pos(n))) - case cc.PostfixExpressionTypeCmp: // "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')' - panic(todo("", p.pos(n))) - case cc.PostfixExpressionChooseExpr: - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) postfixExpressionLValuePSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression "->" IDENTIFIER - pe := n.PostfixExpression - switch k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type().Elem()); k { - case opStruct: - if !p.inUnion(n, pe.Operand.Type().Elem(), n.Token2.Value) { - p.postfixExpressionLValuePSelectStruct(f, n, t, mode, flags) - break - } - - p.w("*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type())) - p.postfixExpression(f, pe, pe.Operand.Type(), exprValue, flags) - p.fldOff(pe.Operand.Type().Elem(), n.Token2) - p.w("))") - case opUnion: - p.postfixExpressionLValuePSelectUnion(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) postfixExpressionLValuePSelectUnion(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression "->" IDENTIFIER - fld := n.Field - if fld.Offset() != 0 { - p.err(&n.Token2, "internal error, union field with non-zero offset: %s %v", n.Token2.Value, fld.Offset()) - } - switch { - case n.Operand.Type().IsBitFieldType(): - panic(todo("", p.pos(n))) - default: - if fld.IsBitField() { - p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value) - } - pe := n.PostfixExpression.Operand.Type() - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.w("(*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type())) - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - p.w("/* .%s */", p.fieldName(n, n.Token2.Value)) - p.w(")))") - } -} - -func (p *project) postfixExpressionLValuePSelectStruct(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression "->" IDENTIFIER - fld := n.Field - pe := n.PostfixExpression.Operand.Type() - k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type()) - switch { - case n.Operand.Type().IsBitFieldType(): - panic(todo("", p.pos(n))) - case k == opArray: - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - p.w("[0].%s", p.fieldName(n, n.Token2.Value)) - default: - if fld.IsBitField() { - p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value) - } - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.w("(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem())) - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - p.w(")).%s", p.fieldName(n, n.Token2.Value)) - } -} - -func (p *project) postfixExpressionLValueIndex(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '[' Expression ']' - switch k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type()); k { - case opArray: - p.postfixExpressionLValueIndexArray(f, n, t, mode, flags) - case opNormal: - p.postfixExpressionLValueIndexNormal(f, n, t, mode, flags) - case opArrayParameter: - p.postfixExpressionLValueIndexArrayParameter(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) postfixExpressionLValueIndexArrayParameter(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '[' Expression ']' - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - pe := n.PostfixExpression.Operand.Type() - p.w("*(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem())) - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - if !n.Expression.Operand.IsZero() { - p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand) - if sz := pe.Elem().Size(); sz != 1 { - p.w("*%d", sz) - } - } - p.w("))") -} - -func (p *project) postfixExpressionLValueIndexNormal(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '[' Expression ']' - switch { - case n.Operand.Type().Kind() == cc.Array: - panic(todo("", p.pos(n))) - default: - switch pe := n.PostfixExpression.Operand.Type(); pe.Kind() { - case cc.Ptr: - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.w("*(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem())) - p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags) - if !n.Expression.Operand.IsZero() { - p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand) - if sz := pe.Elem().Size(); sz != 1 { - p.w("*%d", sz) - } - } - p.w("))") - case cc.Array: - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.w("*(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem())) - p.postfixExpression(f, n.PostfixExpression, pe, exprDecay, flags) - if !n.Expression.Operand.IsZero() { - p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand) - if sz := pe.Elem().Size(); sz != 1 { - p.w("*%d", sz) - } - } - p.w("))") - default: - panic(todo("", p.pos(n), pe)) - } - } -} - -func (p *project) postfixExpressionLValueIndexArray(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '[' Expression ']' - pe := n.PostfixExpression.Operand.Type() - p.postfixExpression(f, n.PostfixExpression, pe, mode, flags) - p.w("[") - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) - p.w("]") -} - -func (p *project) postfixExpressionLValueSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '.' IDENTIFIER - pe := n.PostfixExpression - switch k := p.opKind(f, pe, pe.Operand.Type()); k { - case opStruct: - if !p.inUnion(n, pe.Operand.Type(), n.Token2.Value) { - p.postfixExpressionLValueSelectStruct(f, n, t, mode, flags) - break - } - - p.w("*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type())) - p.postfixExpression(f, pe, pe.Operand.Type(), exprAddrOf, flags) - p.fldOff(pe.Operand.Type(), n.Token2) - p.w("))") - case opUnion: - p.postfixExpressionLValueSelectUnion(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) inUnion(n cc.Node, t cc.Type, fname cc.StringID) bool { - f, ok := t.FieldByName(fname) - if !ok { - p.err(n, "unknown field: %s", fname) - return false - } - - return f.InUnion() -} - -func (p *project) postfixExpressionLValueSelectUnion(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - fld := n.Field - pe := n.PostfixExpression.Operand.Type() - switch { - case pe.Kind() == cc.Array: - panic(todo("", p.pos(n))) - case n.Operand.Type().IsBitFieldType(): - panic(todo("", p.pos(n))) - default: - if fld.IsBitField() { - p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value) - } - p.w("*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type())) - p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags) - nonZeroUintptr(fld.Offset()) - p.w("))") - } -} - -func (p *project) postfixExpressionLValueSelectStruct(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '.' IDENTIFIER - fld := n.Field - switch { - case n.Operand.Type().IsBitFieldType(): - panic(todo("", p.pos(n))) - default: - if fld.IsBitField() { - p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value) - } - pe := n.PostfixExpression.Operand.Type() - p.postfixExpression(f, n.PostfixExpression, pe, exprSelect, flags) - p.w(".%s", p.fieldName(n, n.Token2.Value)) - } -} - -func (p *project) postfixExpressionIncDec(f *function, n *cc.PostfixExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprVoid: - p.postfixExpressionIncDecVoid(f, n, oper, oper2, t, mode, flags) - case exprLValue: - p.postfixExpressionIncDecLValue(f, n, oper, oper2, t, mode, flags) - case exprValue: - p.postfixExpressionIncDecValue(f, n, oper, oper2, t, mode, flags) - default: - panic(todo("", mode)) - } -} - -func (p *project) postfixExpressionIncDecValue(f *function, n *cc.PostfixExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression "++" - pe := n.PostfixExpression.Operand.Type() - switch k := p.opKind(f, n.PostfixExpression, pe); k { - case opNormal: - p.postfixExpressionIncDecValueNormal(f, n, oper, oper2, t, mode, flags) - case opBitfield: - p.postfixExpressionIncDecValueBitfield(f, n, oper, oper2, t, mode, flags) - case opArrayParameter: - p.postfixExpressionIncDecValueArrayParameter(f, n, oper, oper2, t, mode, flags) - default: - panic(todo("", n.Position(), pe, pe.Kind(), k)) - } -} - -func (p *project) postfixExpressionIncDecValueArrayParameter(f *function, n *cc.PostfixExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression "++" - pe := n.PostfixExpression.Operand.Type() - defer p.w("%s", p.convert(n, n.PostfixExpression.Operand, t, flags)) - x := "Dec" - if oper == "++" { - x = "Inc" - } - p.w("%sPost%s%s(&", p.task.crt, x, p.helperType(n, pe.Decay())) - p.postfixExpression(f, n.PostfixExpression, pe, exprLValue, flags) - p.w(", %d)", p.incDelta(n.PostfixExpression, pe)) -} - -func (p *project) postfixExpressionIncDecValueBitfield(f *function, n *cc.PostfixExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression "++" - pe := n.PostfixExpression.Operand.Type() - defer p.w("%s", p.convert(n, n.PostfixExpression.Operand, t, flags)) - x := "Dec" - if oper == "++" { - x = "Inc" - } - bf := pe.BitField() - p.w("%sPost%sBitFieldPtr%d%s(", p.task.crt, x, bf.BitFieldBlockWidth(), p.bfHelperType(pe)) - p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags) - p.w(", %d, %d, %d, %#x)", p.incDelta(n.PostfixExpression, pe), bf.BitFieldBlockWidth(), bf.BitFieldOffset(), bf.Mask()) -} - -func (p *project) postfixExpressionIncDecValueNormal(f *function, n *cc.PostfixExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression "++" - pe := n.PostfixExpression.Operand.Type() - defer p.w("%s", p.convert(n, n.PostfixExpression.Operand, t, flags)) - x := "Dec" - if oper == "++" { - x = "Inc" - } - if d := n.PostfixExpression.Declarator(); d != nil && p.isVolatileOrAtomic(d) { - p.w("%sPost%sAtomic%s(&", p.task.crt, x, p.helperType(n, pe)) - var local *local - var tld *tld - if f != nil { - local = f.locals[d] - } - if local == nil { - tld = p.tlds[d] - } - switch { - case local != nil: - p.w("%s", local.name) - case tld != nil: - p.w("%s", tld.name) - default: - panic(todo("")) - } - p.w(", %d)", p.incDelta(n.PostfixExpression, pe)) - return - } - - p.w("%sPost%s%s(&", p.task.crt, x, p.helperType(n, pe)) - p.postfixExpression(f, n.PostfixExpression, pe, exprLValue, flags) - p.w(", %d)", p.incDelta(n.PostfixExpression, pe)) -} - -func (p *project) postfixExpressionIncDecLValue(f *function, n *cc.PostfixExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) { - switch k := p.opKind(f, n, n.Operand.Type()); k { - case opNormal: - p.postfixExpressionIncDecLValueNormal(f, n, oper, oper2, t, mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) postfixExpressionIncDecLValueNormal(f *function, n *cc.PostfixExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) { - pe := n.PostfixExpression.Operand.Type() - defer p.w("%s", p.convert(n, n.PostfixExpression.Operand, t, flags)) - x := "Dec" - if oper == "++" { - x = "Inc" - } - p.w("%sPost%s%s(&", p.task.crt, x, p.helperType(n, pe)) - p.postfixExpression(f, n.PostfixExpression, pe, exprLValue, flags) - p.w(", %d)", p.incDelta(n.PostfixExpression, pe)) -} - -func (p *project) postfixExpressionIncDecVoid(f *function, n *cc.PostfixExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) { - switch k := p.opKind(f, n, n.Operand.Type()); k { - case opNormal: - p.postfixExpressionIncDecVoidNormal(f, n, oper, oper2, t, mode, flags) - case opBitfield: - p.postfixExpressionIncDec(f, n, oper, oper2, t, exprValue, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) postfixExpressionIncDecVoidNormal(f *function, n *cc.PostfixExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) { - if d := n.PostfixExpression.Declarator(); d != nil && p.isVolatileOrAtomic(d) { - switch d.Type().Size() { - case 4, 8: - if !d.Type().IsIntegerType() { - p.err(n, "unsupported volatile declarator type: %v", d.Type()) - return - } - - if f != nil { - if local := f.locals[d]; local != nil { - if local.isPinned { - panic(todo("")) - } - - p.w("atomic.Add%s(&%s, ", p.helperType(n, d.Type()), local.name) - switch oper { - case "++": - // ok - case "--": - p.w("-") - default: - p.err(n, "unsupported volatile declarator operation: %v", oper) - } - p.w("%d)", p.incDelta(n, d.Type())) - return - } - } - - if tld := p.tlds[d]; tld != nil { - p.w("atomic.Add%s(&%s, ", p.helperType(n, d.Type()), tld.name) - switch oper { - case "++": - // ok - case "--": - p.w("-") - default: - p.err(n, "unsupported volatile declarator operation: %v", oper) - } - p.w("%d)", p.incDelta(n, d.Type())) - return - } - - panic(todo("", n.Position(), d.Position())) - default: - p.err(n, "unsupported volatile declarator size: %v", d.Type().Size()) - return - } - } - - pe := n.PostfixExpression.Operand.Type().Decay() - p.postfixExpression(f, n.PostfixExpression, pe, exprLValue, flags) - if pe.IsIntegerType() || pe.Kind() == cc.Ptr && p.incDelta(n, pe) == 1 { - p.w("%s", oper) - return - } - - switch pe.Kind() { - case cc.Ptr, cc.Float, cc.Double: - p.w("%s %d", oper2, p.incDelta(n, pe)) - return - } - - panic(todo("", n.Position(), pe, pe.Kind())) -} - -func (p *project) incDelta(n cc.Node, t cc.Type) uintptr { - if t.IsArithmeticType() { - return 1 - } - - if t.Kind() == cc.Ptr || t.Kind() == cc.Array { - return t.Elem().Size() - } - - panic(todo("", n.Position(), t.Kind())) -} - -func (p *project) bitFldOff(t cc.Type, tok cc.Token) { - var off uintptr - fld, ok := t.FieldByName(tok.Value) - switch { - case ok && !fld.IsBitField(): - panic(todo("%v: internal error: bitFdlOff must not be used with non bit fields", origin(2))) - case !ok: - p.err(&tok, "uknown field: %s", tok.Value) - default: - off = fld.BitFieldBlockFirst().Offset() - } - if off != 0 { - p.w("+%d", off) - } - p.w("/* &.%s */", tok.Value) -} - -func (p *project) fldOff(t cc.Type, tok cc.Token) { - if t.Kind() == cc.Ptr { - t = t.Elem() - } - var off uintptr - fld, ok := t.FieldByName(tok.Value) - switch { - case ok && fld.IsBitField(): - panic(todo("%v: internal error: fdlOff must not be used with bit fields", origin(2))) - case !ok: - p.err(&tok, "uknown field: %s", tok.Value) - default: - off = fld.Offset() - } - if off != 0 { - p.w("+%d", off) - } - p.w("/* &.%s */", tok.Value) -} - -func (p *project) postfixExpressionCall(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '(' ArgumentExpressionList ')' - switch mode { - case exprVoid: - p.postfixExpressionCallVoid(f, n, t, mode, flags) - case exprValue: - p.postfixExpressionCallValue(f, n, t, mode, flags) - case exprBool: - p.postfixExpressionCallBool(f, n, t, mode, flags) - default: - panic(todo("", mode)) - } -} - -func (p *project) postfixExpressionCallBool(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '(' ArgumentExpressionList ')' - p.w("(") - defer p.w(")") - defer p.w(" != 0") - if d := n.PostfixExpression.Declarator(); d != nil { - switch d.Name() { - case idVaArg: - if !f.vaType.IsScalarType() { - panic(todo("", f.vaType)) - } - - lhs := n.ArgumentExpressionList.AssignmentExpression - p.w("%sVa%s(&", p.task.crt, p.helperType(n, f.vaType)) - p.assignmentExpression(f, lhs, lhs.Operand.Type(), exprLValue, flags) - p.w(")") - return - case idAtomicLoadN: - p.atomicLoadN(f, n, t, mode, flags) - return - case idBuiltinConstantPImpl: - p.w("%v", n.Operand.Value()) - return - } - } - - var va uintptr - if f != nil { - va = f.vaLists[n] - } - p.postfixExpression(f, n.PostfixExpression, n.PostfixExpression.Operand.Type(), exprFunc, flags) - p.argumentExpressionList(f, n.PostfixExpression, n.ArgumentExpressionList, va) -} - -func (p *project) postfixExpressionCallValue(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '(' ArgumentExpressionList ')' - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - if d := n.PostfixExpression.Declarator(); d != nil { - switch d.Name() { - case idVaEnd: - p.w("_ = ") - arg := n.ArgumentExpressionList.AssignmentExpression - p.assignmentExpression(f, arg, arg.Operand.Type(), exprValue, flags) - return - case idVaStart: - lhs := n.ArgumentExpressionList.AssignmentExpression - p.assignmentExpression(f, lhs, lhs.Operand.Type(), exprLValue, flags) - p.w(" = %s", f.vaName) - return - case idVaArg: - if !f.vaType.IsScalarType() { - panic(todo("", f.vaType)) - } - - lhs := n.ArgumentExpressionList.AssignmentExpression - p.w("%sVa%s(&", p.task.crt, p.helperType(n, f.vaType)) - p.assignmentExpression(f, lhs, lhs.Operand.Type(), exprLValue, flags) - p.w(")") - return - case idAtomicLoadN: - p.atomicLoadN(f, n, t, mode, flags) - return - case idAddOverflow: - p.addOverflow(f, n, t, mode, flags) - return - case idSubOverflow: - p.subOverflow(f, n, t, mode, flags) - return - case idMulOverflow: - p.mulOverflow(f, n, t, mode, flags) - return - case idBuiltinConstantPImpl: - p.w("%v", n.Operand.Value()) - return - } - } - var va uintptr - if f != nil { - va = f.vaLists[n] - } - p.postfixExpression(f, n.PostfixExpression, n.PostfixExpression.Operand.Type(), exprFunc, flags) - p.argumentExpressionList(f, n.PostfixExpression, n.ArgumentExpressionList, va) -} - -// bool __builtin_mul_overflow (type1 a, type2 b, type3 *res) -func (p *project) mulOverflow(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - args := p.argList(n.ArgumentExpressionList) - if len(args) != 3 { - p.err(n, "expected 3 arguments in call to __builtin_mul_overflow") - return - } - - pt := args[2].Operand.Type() - if pt.Kind() != cc.Ptr { - p.err(n, "invalid argument of __builtin_mul_overflow (expected pointer): %s", pt) - return - } - - vt := pt.Elem() - switch { - case vt.IsIntegerType(): - switch vt.Size() { - case 1, 2, 4, 8, 16: - p.w("%sX__builtin_mul_overflow%s", p.task.crt, p.helperType(n, vt)) - default: - p.err(n, "invalid argument of __builtin_mul_overflow: %v, elem kind %v", pt, vt.Kind()) - return - } - p.w("(%s", f.tlsName) - types := []cc.Type{vt, vt, pt} - for i, v := range args[:3] { - p.w(", ") - p.assignmentExpression(f, v, types[i], exprValue, flags) - } - p.w(")") - return - } - - p.err(n, "invalid arguments of __builtin_mul_overflow: (%v, %v, %v)", args[0].Operand.Type(), args[1].Operand.Type(), args[2].Operand.Type()) -} - -// bool __builtin_sub_overflow (type1 a, type2 b, type3 *res) -func (p *project) subOverflow(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - args := p.argList(n.ArgumentExpressionList) - if len(args) != 3 { - p.err(n, "expected 3 arguments in call to __builtin_sub_overflow") - return - } - - pt := args[2].Operand.Type() - if pt.Kind() != cc.Ptr { - p.err(n, "invalid argument of __builtin_sub_overflow (expected pointer): %s", pt) - return - } - - vt := pt.Elem() - switch { - case vt.IsIntegerType(): - switch vt.Size() { - case 1, 2, 4, 8: - p.w("%sX__builtin_sub_overflow%s", p.task.crt, p.helperType(n, vt)) - default: - p.err(n, "invalid argument of __builtin_sub_overflow: %v, elem kind %v", pt, vt.Kind()) - return - } - p.w("(%s", f.tlsName) - types := []cc.Type{vt, vt, pt} - for i, v := range args[:3] { - p.w(", ") - p.assignmentExpression(f, v, types[i], exprValue, flags) - } - p.w(")") - return - } - - p.err(n, "invalid arguments of __builtin_sub_overflow: (%v, %v, %v)", args[0].Operand.Type(), args[1].Operand.Type(), args[2].Operand.Type()) -} - -// bool __builtin_add_overflow (type1 a, type2 b, type3 *res) -func (p *project) addOverflow(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - args := p.argList(n.ArgumentExpressionList) - if len(args) != 3 { - p.err(n, "expected 3 arguments in call to __builtin_add_overflow") - return - } - - pt := args[2].Operand.Type() - if pt.Kind() != cc.Ptr { - p.err(n, "invalid argument of __builtin_add_overflow (expected pointer): %s", pt) - return - } - - vt := pt.Elem() - switch { - case vt.IsIntegerType(): - switch vt.Size() { - case 1, 2, 4, 8: - p.w("%sX__builtin_add_overflow%s", p.task.crt, p.helperType(n, vt)) - default: - p.err(n, "invalid argument of __builtin_add_overflow: %v, elem kind %v", pt, vt.Kind()) - return - } - p.w("(%s", f.tlsName) - types := []cc.Type{vt, vt, pt} - for i, v := range args[:3] { - p.w(", ") - p.assignmentExpression(f, v, types[i], exprValue, flags) - } - p.w(")") - return - } - - p.err(n, "invalid arguments of __builtin_add_overflow: (%v, %v, %v)", args[0].Operand.Type(), args[1].Operand.Type(), args[2].Operand.Type()) -} - -// type __atomic_load_n (type *ptr, int memorder) -func (p *project) atomicLoadN(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - args := p.argList(n.ArgumentExpressionList) - if len(args) != 2 { - p.err(n, "expected 2 arguments in call to __atomic_load_n") - return - } - - pt := args[0].Operand.Type() - if pt.Kind() != cc.Ptr { - p.err(n, "invalid argument of __atomic_load_n (expected pointer): %s", pt) - return - } - - vt := pt.Elem() - switch { - case vt.IsIntegerType(): - var s string - switch { - case vt.IsSignedType(): - s = "Int" - default: - s = "Uint" - } - switch vt.Size() { - case 2, 4, 8: - p.w("%sAtomicLoadN%s%d", p.task.crt, s, 8*vt.Size()) - default: - p.err(n, "invalid argument of __atomic_load_n: %v, elem kind %v", pt, vt.Kind()) - return - } - types := []cc.Type{pt, p.intType} - p.w("(") - for i, v := range args[:2] { - if i != 0 { - p.w(", ") - } - p.assignmentExpression(f, v, types[i], exprValue, flags) - } - p.w(")") - return - case vt.Kind() == cc.Ptr: - panic(todo("", pt, vt)) - } - - p.err(n, "invalid first argument of __atomic_load_n: %v, elem kind %v", pt, vt.Kind()) -} - -func (p *project) postfixExpressionCallVoid(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - // PostfixExpression '(' ArgumentExpressionList ')' - if d := n.PostfixExpression.Declarator(); d != nil { - switch d.Name() { - case idVaEnd: - p.w("_ = ") - arg := n.ArgumentExpressionList.AssignmentExpression - p.assignmentExpression(f, arg, arg.Operand.Type(), exprValue, flags) - return - case idVaStart: - lhs := n.ArgumentExpressionList.AssignmentExpression - p.assignmentExpression(f, lhs, lhs.Operand.Type(), exprLValue, flags) - p.w(" = %s", f.vaName) - return - case idVaArg: - if !f.vaType.IsScalarType() { - panic(todo("", f.vaType)) - } - - lhs := n.ArgumentExpressionList.AssignmentExpression - p.w("%sVa%s(&", p.task.crt, p.helperType(n, f.vaType)) - p.assignmentExpression(f, lhs, lhs.Operand.Type(), exprLValue, flags) - p.w(")") - return - case idAtomicStoreN: - p.atomicStoreN(f, n, t, mode, flags) - return - case idMulOverflow: - p.mulOverflow(f, n, t, mode, flags) - return - } - } - var va uintptr - if f != nil { - va = f.vaLists[n] - } - p.postfixExpression(f, n.PostfixExpression, n.PostfixExpression.Operand.Type(), exprFunc, flags) - p.argumentExpressionList(f, n.PostfixExpression, n.ArgumentExpressionList, va) -} - -// void __atomic_store_n (type *ptr, type val, int memorder) -func (p *project) atomicStoreN(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) { - args := p.argList(n.ArgumentExpressionList) - if len(args) != 3 { - p.err(n, "expected 3 arguments in call to __atomic_store_n") - return - } - - pt := args[0].Operand.Type() - if pt.Kind() != cc.Ptr { - p.err(n, "invalid first argument of __atomic_store_n (expected pointer): %s", pt) - return - } - - vt := args[1].Operand.Type() - switch { - case vt.IsIntegerType(): - var s string - switch { - case vt.IsSignedType(): - s = "Int" - default: - s = "Uint" - } - switch vt.Size() { - case 2, 4, 8: - p.w("%sAtomicStoreN%s%d", p.task.crt, s, 8*vt.Size()) - default: - p.err(n, "invalid arguments of __atomic_store_n: (%v, %v), element kind %v", pt, vt, vt.Kind()) - return - } - p.w("(") - types := []cc.Type{pt, vt, p.intType} - for i, v := range args[:3] { - if i != 0 { - p.w(", ") - } - if i == 1 { - p.w("%s(", strings.ToLower(p.helperType(n, vt))) - } - p.assignmentExpression(f, v, types[i], exprValue, flags) - if i == 1 { - p.w(")") - } - } - p.w(")") - return - case vt.Kind() == cc.Ptr: - panic(todo("", pt, vt)) - } - - p.err(n, "invalid arguments of __atomic_store_n: (%v, %v), element kind %v", pt, vt, vt.Kind()) -} - -func (p *project) argList(n *cc.ArgumentExpressionList) (r []*cc.AssignmentExpression) { - for ; n != nil; n = n.ArgumentExpressionList { - r = append(r, n.AssignmentExpression) - } - return r -} - -func (p *project) argumentExpressionList(f *function, pe *cc.PostfixExpression, n *cc.ArgumentExpressionList, bpOff uintptr) { - switch { - case f == nil: - p.w("(nil") - default: - p.w("(%s", f.tlsName) - } - ft := funcType(pe.Operand.Type()) - isVariadic := ft.IsVariadic() - params := ft.Parameters() - if len(params) == 1 && params[0].Type().Kind() == cc.Void { - params = nil - } - var args []*cc.AssignmentExpression - for ; n != nil; n = n.ArgumentExpressionList { - args = append(args, n.AssignmentExpression) - } - if len(args) < len(params) { - panic(todo("", p.pos(n))) - } - - va := true - if len(args) > len(params) && !isVariadic { - var a []string - for _, v := range args { - a = append(a, v.Operand.Type().String()) - } - sargs := strings.Join(a, ",") - switch d := pe.Declarator(); { - case d == nil: - p.err(pe, "too many arguments (%s) in call to %s", sargs, ft) - default: - p.err(pe, "too many arguments (%s) in call to %s of type %s", sargs, d.Name(), ft) - } - va = false - } - - paren := "" - for i, arg := range args { - p.w(",%s", tidyComment(" ", arg)) - mode := exprValue - if at := arg.Operand.Type(); at.Kind() == cc.Array { - mode = exprDecay - } - switch { - case i < len(params): - switch pt := params[i].Type(); { - case isTransparentUnion(params[i].Type()): - p.callArgTransparentUnion(f, arg, pt) - default: - p.assignmentExpression(f, arg, arg.Promote(), mode, 0) - } - case va && i == len(params): - p.w("%sVaList(%s%s, ", p.task.crt, f.bpName, nonZeroUintptr(bpOff)) - paren = ")" - fallthrough - default: - var flags flags - if arg.Promote().IsIntegerType() { - switch x := arg.Operand.Value().(type) { - case cc.Int64Value: - if x < mathutil.MinInt || x > mathutil.MaxInt { - flags |= fForceConv - } - case cc.Uint64Value: - if x > mathutil.MaxInt { - flags |= fForceConv - } - } - } - p.assignmentExpression(f, arg, arg.Promote(), mode, flags) - } - } - if isVariadic && len(args) == len(params) { - p.w(", 0") - } - p.w("%s)", paren) -} - -// https://gcc.gnu.org/onlinedocs/gcc-3.3/gcc/Type-Attributes.html -// -// transparent_union -// -// This attribute, attached to a union type definition, indicates that any -// function parameter having that union type causes calls to that function to -// be treated in a special way. -// -// First, the argument corresponding to a transparent union type can be of any -// type in the union; no cast is required. Also, if the union contains a -// pointer type, the corresponding argument can be a null pointer constant or a -// void pointer expression; and if the union contains a void pointer type, the -// corresponding argument can be any pointer expression. If the union member -// type is a pointer, qualifiers like const on the referenced type must be -// respected, just as with normal pointer conversions. -// -// Second, the argument is passed to the function using the calling conventions -// of first member of the transparent union, not the calling conventions of the -// union itself. All members of the union must have the same machine -// representation; this is necessary for this argument passing to work -// properly. -// -// Transparent unions are designed for library functions that have multiple -// interfaces for compatibility reasons. For example, suppose the wait function -// must accept either a value of type int * to comply with Posix, or a value of -// type union wait * to comply with the 4.1BSD interface. If wait's parameter -// were void *, wait would accept both kinds of arguments, but it would also -// accept any other pointer type and this would make argument type checking -// less useful. Instead, <sys/wait.h> might define the interface as follows: -// -// typedef union -// { -// int *__ip; -// union wait *__up; -// } wait_status_ptr_t __attribute__ ((__transparent_union__)); -// -// pid_t wait (wait_status_ptr_t); -// -// This interface allows either int * or union wait * arguments to be passed, -// using the int * calling convention. The program can call wait with arguments -// of either type: -// -// int w1 () { int w; return wait (&w); } -// int w2 () { union wait w; return wait (&w); } -// -// With this interface, wait's implementation might look like this: -// -// pid_t wait (wait_status_ptr_t p) -// { -// return waitpid (-1, p.__ip, 0); -// } -func (p *project) callArgTransparentUnion(f *function, n *cc.AssignmentExpression, pt cc.Type) { - if pt.Kind() != cc.Union { - panic(todo("internal error")) - } - - ot := n.Operand.Type() - switch k := pt.UnionCommon(); k { - case cc.Ptr: - if ot.Kind() != k { - panic(todo("", n.Position(), k, pt)) - } - - p.assignmentExpression(f, n, ot, exprValue, 0) - default: - panic(todo("", n.Position(), k, pt)) - } -} - -func isTransparentUnion(t cc.Type) (r bool) { - for _, v := range attrs(t) { - cc.Inspect(v, func(n cc.Node, _ bool) bool { - if x, ok := n.(*cc.AttributeValue); ok && x.Token.Value == idTransparentUnion { - r = true - return false - } - - return true - }) - } - return r -} - -func attrs(t cc.Type) []*cc.AttributeSpecifier { - if a := t.Attributes(); len(a) != 0 { - return a - } - - if t.IsAliasType() { - if a := t.Alias().Attributes(); len(a) != 0 { - return a - } - - return t.AliasDeclarator().Type().Attributes() - } - - return nil -} - -func (p *project) nzUintptr(n cc.Node, f func(), op cc.Operand) { - if op.Type().IsIntegerType() { - switch { - case op.IsZero(): - return - case op.Value() != nil: - switch x := op.Value().(type) { - case cc.Int64Value: - if x > 0 && uint64(x) <= 1<<(8*p.ptrSize)-1 { - p.w("+%d", x) - return - } - case cc.Uint64Value: - if uint64(x) <= 1<<(8*p.ptrSize)-1 { - p.w("+%d", x) - return - } - } - - p.w(" +%sUintptrFrom%s(", p.task.crt, p.helperType(n, op.Type())) - default: - p.w(" +uintptr(") - } - - f() - p.w(")") - return - } - - panic(todo("", p.pos(n))) -} - -func (p *project) primaryExpression(f *function, n *cc.PrimaryExpression, t cc.Type, mode exprMode, flags flags) { - switch mode { - case exprLValue: - p.primaryExpressionLValue(f, n, t, mode, flags) - case exprValue: - p.primaryExpressionValue(f, n, t, mode, flags) - case exprFunc: - p.primaryExpressionFunc(f, n, t, mode, flags) - case exprAddrOf: - p.primaryExpressionAddrOf(f, n, t, mode, flags) - case exprSelect: - p.primaryExpressionSelect(f, n, t, mode, flags) - case exprPSelect: - p.primaryExpressionPSelect(f, n, t, mode, flags) - case exprBool: - p.primaryExpressionBool(f, n, t, mode, flags) - case exprVoid: - p.primaryExpressionVoid(f, n, t, mode, flags) - case exprDecay: - p.primaryExpressionDecay(f, n, t, mode, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) primaryExpressionDecay(f *function, n *cc.PrimaryExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.PrimaryExpressionIdent: // IDENTIFIER - switch d := n.Declarator(); { - case d != nil: - p.declarator(n, f, d, t, mode, flags) - default: - panic(todo("", p.pos(n))) - } - case cc.PrimaryExpressionInt: // INTCONST - p.intConst(n, n.Token.Src.String(), n.Operand, t, flags) - case cc.PrimaryExpressionFloat: // FLOATCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionEnum: // ENUMCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionChar: // CHARCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionLChar: // LONGCHARCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionString: // STRINGLITERAL - p.w("%s", p.stringLiteral(n.Operand.Value())) - case cc.PrimaryExpressionLString: // LONGSTRINGLITERAL - p.w("%s", p.wideStringLiteral(n.Operand.Value(), 0)) - case cc.PrimaryExpressionExpr: // '(' Expression ')' - p.expression(f, n.Expression, t, mode, flags) - case cc.PrimaryExpressionStmt: // '(' CompoundStatement ')' - p.err(n, "statement expressions not supported") - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) primaryExpressionVoid(f *function, n *cc.PrimaryExpression, t cc.Type, mode exprMode, flags flags) { - - switch n.Case { - case cc.PrimaryExpressionIdent: // IDENTIFIER - p.w("_ = ") - p.primaryExpression(f, n, n.Operand.Type(), exprValue, flags) - case cc.PrimaryExpressionInt, // INTCONST - cc.PrimaryExpressionFloat, // FLOATCONST - cc.PrimaryExpressionEnum, // ENUMCONST - cc.PrimaryExpressionChar, // CHARCONST - cc.PrimaryExpressionLChar, // LONGCHARCONST - cc.PrimaryExpressionString, // STRINGLITERAL - cc.PrimaryExpressionLString: // LONGSTRINGLITERAL - - // nop - case cc.PrimaryExpressionExpr: // '(' Expression ')' - p.expression(f, n.Expression, n.Expression.Operand.Type(), mode, flags) - case cc.PrimaryExpressionStmt: // '(' CompoundStatement ')' - p.compoundStatement(f, n.CompoundStatement, "", true, false, 0) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) primaryExpressionBool(f *function, n *cc.PrimaryExpression, t cc.Type, mode exprMode, flags flags) { - if n.Case != cc.PrimaryExpressionExpr { - p.w("(") - defer p.w(")") - } - - if n.Case != cc.PrimaryExpressionExpr { - defer p.w(" != 0") - } - switch n.Case { - case cc.PrimaryExpressionIdent: // IDENTIFIER - switch d := n.Declarator(); { - case d != nil: - p.declarator(n, f, d, d.Type(), exprValue, flags) - default: - panic(todo("", p.pos(n))) - } - case cc.PrimaryExpressionInt: // INTCONST - p.intConst(n, n.Token.Src.String(), n.Operand, n.Operand.Type(), flags) - case cc.PrimaryExpressionFloat: // FLOATCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionEnum: // ENUMCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionChar: // CHARCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionLChar: // LONGCHARCONST - p.charConst(n, n.Token.Src.String(), n.Operand, t, flags) - case cc.PrimaryExpressionString: // STRINGLITERAL - p.w(" 1 ") - case cc.PrimaryExpressionLString: // LONGSTRINGLITERAL - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionExpr: // '(' Expression ')' - p.w("(") - defer p.w(")") - p.expression(f, n.Expression, t, mode, flags) - case cc.PrimaryExpressionStmt: // '(' CompoundStatement ')' - p.w("func() %v {", p.typ(n, n.CompoundStatement.Operand.Type())) - p.compoundStatement(f, n.CompoundStatement, "", true, false, exprValue) - p.w("}()") - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) primaryExpressionPSelect(f *function, n *cc.PrimaryExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.PrimaryExpressionIdent: // IDENTIFIER - switch d := n.Declarator(); { - case d != nil: - switch k := p.declaratorKind(d); k { - case opArray: - panic(todo("", p.pos(n))) - p.primaryExpression(f, n, t, exprDecay, flags) - default: - p.declarator(n, f, d, t, mode, flags) - } - default: - panic(todo("", p.pos(n))) - } - case cc.PrimaryExpressionInt: // INTCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionFloat: // FLOATCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionEnum: // ENUMCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionChar: // CHARCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionLChar: // LONGCHARCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionString: // STRINGLITERAL - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionLString: // LONGSTRINGLITERAL - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionExpr: // '(' Expression ')' - p.expression(f, n.Expression, t, mode, flags) - case cc.PrimaryExpressionStmt: // '(' CompoundStatement ')' - p.err(n, "statement expressions not supported") - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) primaryExpressionSelect(f *function, n *cc.PrimaryExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.PrimaryExpressionIdent: // IDENTIFIER - switch d := n.Declarator(); { - case d != nil: - p.declarator(n, f, d, t, mode, flags) - default: - panic(todo("", p.pos(n))) - } - case cc.PrimaryExpressionInt: // INTCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionFloat: // FLOATCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionEnum: // ENUMCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionChar: // CHARCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionLChar: // LONGCHARCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionString: // STRINGLITERAL - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionLString: // LONGSTRINGLITERAL - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionExpr: // '(' Expression ')' - p.expression(f, n.Expression, t, mode, flags) - case cc.PrimaryExpressionStmt: // '(' CompoundStatement ')' - p.err(n, "statement expressions not supported") - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) primaryExpressionAddrOf(f *function, n *cc.PrimaryExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.PrimaryExpressionIdent: // IDENTIFIER - switch d := n.Declarator(); { - case d != nil: - p.declarator(n, f, d, t, mode, flags) - default: - panic(todo("", p.pos(n))) - } - case cc.PrimaryExpressionInt: // INTCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionFloat: // FLOATCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionEnum: // ENUMCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionChar: // CHARCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionLChar: // LONGCHARCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionString: // STRINGLITERAL - p.w("%s", p.stringLiteral(n.Operand.Value())) - case cc.PrimaryExpressionLString: // LONGSTRINGLITERAL - p.w("%s", p.wideStringLiteral(n.Operand.Value(), 0)) - case cc.PrimaryExpressionExpr: // '(' Expression ')' - p.expression(f, n.Expression, t, mode, flags) - case cc.PrimaryExpressionStmt: // '(' CompoundStatement ')' - p.err(n, "statement expressions not supported") - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) primaryExpressionFunc(f *function, n *cc.PrimaryExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.PrimaryExpressionIdent: // IDENTIFIER - p.fnVal(n, f, func() { p.primaryExpression(f, n, n.Operand.Type(), exprValue, flags) }, n.Declarator(), n.Operand.Type(), 0, mode, flags) - case cc.PrimaryExpressionInt: // INTCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionFloat: // FLOATCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionEnum: // ENUMCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionChar: // CHARCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionLChar: // LONGCHARCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionString: // STRINGLITERAL - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionLString: // LONGSTRINGLITERAL - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionExpr: // '(' Expression ')' - p.expression(f, n.Expression, t, mode, flags) - case cc.PrimaryExpressionStmt: // '(' CompoundStatement ')' - p.err(n, "statement expressions not supported") - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func cmpNormalizeValue(v cc.Value) cc.Value { - switch x := v.(type) { - case cc.Int64Value: - if x >= 0 { - return cc.Uint64Value(x) - } - } - return v -} - -func (p *project) primaryExpressionValue(f *function, n *cc.PrimaryExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.PrimaryExpressionIdent: // IDENTIFIER - switch d := n.Declarator(); { - case d != nil: - p.declarator(n, f, d, t, mode, flags) - default: - panic(todo("", p.pos(n))) - } - case cc.PrimaryExpressionInt: // INTCONST - if m := n.Token.Macro(); m != 0 { - if d := p.defines[m]; d.name != "" { - if cmpNormalizeValue(n.Operand.Value()) == cmpNormalizeValue(d.value) { - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.w(" %s ", d.name) - break - } - - p.w("/* %s */", m) - } - } - - p.intConst(n, n.Token.Src.String(), n.Operand, t, flags) - case cc.PrimaryExpressionFloat: // FLOATCONST - //TODO use #define - p.floatConst(n, n.Token.Src.String(), n.Operand, t, flags) - case cc.PrimaryExpressionEnum: // ENUMCONST - en := n.ResolvedTo().(*cc.Enumerator) - if n.ResolvedIn().Parent() == nil { - if nm := p.enumConsts[en.Token.Value]; nm != "" { - p.w(" %s ", nm) - break - } - } - - p.intConst(n, "", n.Operand, t, flags) - p.w("/* %s */", en.Token.Value) - case cc.PrimaryExpressionChar: // CHARCONST - p.charConst(n, n.Token.Src.String(), n.Operand, t, flags) - case cc.PrimaryExpressionLChar: // LONGCHARCONST - p.charConst(n, n.Token.Src.String(), n.Operand, t, flags) - case cc.PrimaryExpressionString: // STRINGLITERAL - p.w("%s", p.stringLiteral(n.Operand.Value())) - case cc.PrimaryExpressionLString: // LONGSTRINGLITERAL - p.w("%s", p.wideStringLiteral(n.Operand.Value(), 0)) - case cc.PrimaryExpressionExpr: // '(' Expression ')' - p.w("(") - defer p.w(")") - p.expression(f, n.Expression, t, mode, flags) - case cc.PrimaryExpressionStmt: // '(' CompoundStatement ')' - p.statementExpression(f, n.CompoundStatement, t, mode, flags) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) statementExpression(f *function, n *cc.CompoundStatement, t cc.Type, mode exprMode, flags flags) { - defer p.w("%s", p.convert(n, n.Operand, t, flags)) - p.w(" func() %v {", p.typ(n, n.Operand.Type())) - p.compoundStatement(f, n, "", true, false, mode) - p.w("}()") -} - -func (p *project) primaryExpressionLValue(f *function, n *cc.PrimaryExpression, t cc.Type, mode exprMode, flags flags) { - switch n.Case { - case cc.PrimaryExpressionIdent: // IDENTIFIER - switch d := n.Declarator(); { - case d != nil: - p.declarator(n, f, d, t, mode, flags) - default: - panic(todo("", p.pos(n))) - } - case cc.PrimaryExpressionInt: // INTCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionFloat: // FLOATCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionEnum: // ENUMCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionChar: // CHARCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionLChar: // LONGCHARCONST - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionString: // STRINGLITERAL - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionLString: // LONGSTRINGLITERAL - panic(todo("", p.pos(n))) - case cc.PrimaryExpressionExpr: // '(' Expression ')' - p.w("(") - defer p.w(")") - p.expression(f, n.Expression, t, mode, flags) - case cc.PrimaryExpressionStmt: // '(' CompoundStatement ')' - p.err(n, "statement expressions not supported") - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) stringLiteralString(s string) string { - if p.pass1 { - return "" - } - - id := cc.String(s) - off, ok := p.tsOffs[id] - if !ok { - off = uintptr(p.ts.Len()) - p.ts.WriteString(s) - p.ts.WriteByte(0) - p.tsOffs[id] = off - } - return fmt.Sprintf("(%s%s)%s", p.tsNameP, nonZeroUintptr(off), p.stringSnippet(s)) -} - -func (p *project) stringLiteral(v cc.Value) string { - if p.pass1 { - return "" - } - - switch x := v.(type) { - case cc.StringValue: - id := cc.StringID(x) - off, ok := p.tsOffs[id] - s := id.String() - if !ok { - off = uintptr(p.ts.Len()) - p.ts.WriteString(s) - p.ts.WriteByte(0) - p.tsOffs[id] = off - } - return fmt.Sprintf("(%s%s)%s", p.tsNameP, nonZeroUintptr(off), p.stringSnippet(s)) - default: - panic(todo("%T", x)) - } -} - -func (p *project) stringSnippet(s string) string { - s = strings.ReplaceAll(s, "*/", "*\\/") - const max = 16 - switch { - case len(s) <= max: - return fmt.Sprintf("/* %q */", s) - default: - return fmt.Sprintf("/* %q */", s[:16]+"...") - } -} - -func (p *project) wideStringLiteral(v cc.Value, pad int) string { - if p.pass1 { - return "" - } - - switch x := v.(type) { - case cc.WideStringValue: - id := cc.StringID(x) - off, ok := p.tsWOffs[id] - if !ok { - off = p.wcharSize * uintptr(len(p.tsW)) - s := []rune(id.String()) - if pad != 0 { - s = append(s, make([]rune, pad)...) - } - p.tsW = append(p.tsW, s...) - p.tsW = append(p.tsW, 0) - p.tsWOffs[id] = off - } - return fmt.Sprintf("(%s%s)", p.tsWNameP, nonZeroUintptr(off)) - default: - panic(todo("%T", x)) - } -} - -func (p *project) charConst(n cc.Node, src string, op cc.Operand, to cc.Type, flags flags) { - switch { - case to.IsArithmeticType(): - defer p.w("%s", p.convert(n, op, to, flags)) - case to.Kind() == cc.Ptr && op.IsZero(): - p.w(" 0 ") - return - default: - panic(todo("%v: t %v, to %v, to.Alias() %v", n.Position(), op.Type(), to, to.Alias())) - } - - r, mb, _, err := strconv.UnquoteChar(src[1:len(src)-1], '\'') - rValid := !mb && err == nil - var on uint64 - switch x := op.Value().(type) { - case cc.Int64Value: - on = uint64(x) - case cc.Uint64Value: - on = uint64(x) - default: - panic(todo("%T(%v)", x, x)) - } - var mask uint64 - switch { - case !to.IsIntegerType(): - // ok - if rValid { // Prefer original form - p.w("%s", src) - return - } - - p.w("%d", on) - return - case to.IsSignedType(): - var in int64 - var ok bool - switch to.Size() { - case 1: - in = int64(int8(on)) - ok = int8(on) >= 0 - case 2: - in = int64(int16(on)) - ok = int16(on) >= 0 - case 4: - in = int64(int32(on)) - ok = int32(on) >= 0 - case 8: - in = int64(int64(on)) - ok = in >= 0 - default: - panic(todo("", op.Type().Size())) - } - if ok && rValid && uint64(in) == on { // Prefer original form - p.w("%s", src) - return - } - - p.w("%d", in) - default: - switch to.Size() { - case 1: - mask = 0xff - case 2: - mask = 0xffff - case 4: - mask = 0xffffffff - case 8: - mask = 0xffffffffffffffff - default: - panic(todo("", op.Type().Size())) - } - if rValid && uint64(r)&mask == on { // Prefer original form - p.w("%s", src) - return - } - - p.w("%d", on&mask) - } -} - -func (p *project) floatConst(n cc.Node, src string, op cc.Operand, to cc.Type, flags flags) { - if flags&fForceRuntimeConv != 0 { - p.w("%s(", p.helperType2(n, op.Type(), to)) - defer p.w(")") - } - - bits := 64 - switch to.Kind() { - case cc.Float: - bits = 32 - } - src = strings.TrimRight(src, "flFL") - sn, err := strconv.ParseFloat(src, bits) - snValid := err == nil - switch x := op.Value().(type) { - case cc.Float64Value: - switch to.Kind() { - case cc.Double: - if snValid && sn == float64(x) { // Prefer original form. - p.w("%s", src) - return - } - - p.w("math.Float64frombits(%#x)", math.Float64bits(float64(x))) - case cc.Float: - if snValid && float32(sn) == float32(x) { // Prefer original form. - p.w("%s", src) - return - } - - p.w("math.Float32frombits(%#x)", math.Float32bits(float32(x))) - default: - defer p.w("%s", p.convert(n, op, to, 0)) - if snValid && sn == float64(x) { // Prefer original form. - p.w("%s", src) - return - } - - p.w("math.Float64frombits(%#x)", math.Float64bits(float64(x))) - } - case cc.Float32Value: - switch to.Kind() { - case cc.Double: - if snValid && float32(sn) == float32(x) { // Prefer original form. - p.w("%s", src) - return - } - - p.w("math.Float64frombits(%#x)", math.Float64bits(float64(x))) - case cc.Float: - if snValid && float32(sn) == float32(x) { // Prefer original form. - p.w("%s", src) - return - } - - p.w("math.Float32frombits(%#x)", math.Float32bits(float32(x))) - default: - if to.IsIntegerType() { - if s := p.float2Int(n, x, to); s != "" { - defer p.w("%s%s", s, p.convertType(n, op.Type(), to, 0)) - break - } - } - - defer p.w("%s", p.convert(n, op, to, 0)) - if snValid && float32(sn) == float32(x) { // Prefer original form. - p.w("%s", src) - return - } - - p.w("math.Float32frombits(%#x)", math.Float32bits(float32(x))) - } - default: - panic(todo("%T(%v)", x, x)) - } -} - -func (p *project) float2Int(n cc.Node, x cc.Float32Value, to cc.Type) string { - switch { - case to.IsSignedType(): - limits := &signedSaturationLimits[to.Size()] - v := float64(x) - switch { - case math.IsNaN(v): - panic(todo("", p.pos(n))) - case math.IsInf(v, -1): - panic(todo("", p.pos(n))) - case math.IsInf(v, 1): - panic(todo("", p.pos(n))) - case v < limits.fmin: - return fmt.Sprint(limits.min) - case v > limits.fmax: - return fmt.Sprint(limits.max) - } - default: - limits := &unsignedSaturationLimits[to.Size()] - v := float64(x) - switch { - case math.IsNaN(v): - panic(todo("", p.pos(n))) - case math.IsInf(v, -1): - panic(todo("", p.pos(n))) - case math.IsInf(v, 1): - panic(todo("", p.pos(n))) - case v < 0: - return "0" - case v > limits.fmax: - return fmt.Sprint(limits.max) - } - } - return "" -} - -type signedSaturationLimit struct { - fmin, fmax float64 - min, max int64 -} - -type unsignedSaturationLimit struct { - fmax float64 - max uint64 -} - -var ( - signedSaturationLimits = [...]signedSaturationLimit{ - 1: {math.Nextafter(math.MinInt32, 0), math.Nextafter(math.MaxInt32, 0), math.MinInt32, math.MaxInt32}, - 2: {math.Nextafter(math.MinInt32, 0), math.Nextafter(math.MaxInt32, 0), math.MinInt32, math.MaxInt32}, - 4: {math.Nextafter(math.MinInt32, 0), math.Nextafter(math.MaxInt32, 0), math.MinInt32, math.MaxInt32}, - 8: {math.Nextafter(math.MinInt64, 0), math.Nextafter(math.MaxInt64, 0), math.MinInt64, math.MaxInt64}, - } - - unsignedSaturationLimits = [...]unsignedSaturationLimit{ - 1: {math.Nextafter(math.MaxUint32, 0), math.MaxUint32}, - 2: {math.Nextafter(math.MaxUint32, 0), math.MaxUint32}, - 4: {math.Nextafter(math.MaxUint32, 0), math.MaxUint32}, - 8: {math.Nextafter(math.MaxUint64, 0), math.MaxUint64}, - } -) - -func (p *project) intConst(n cc.Node, src string, op cc.Operand, to cc.Type, flags flags) { - ptr := to.Kind() == cc.Ptr - switch { - case to.IsArithmeticType(): - // p.w("/*10568 %T(%#[1]x) %v -> %v */", op.Value(), op.Type(), to) //TODO- - if flags&fForceNoConv != 0 { - break - } - - if !op.Type().IsSignedType() && op.Type().Size() == 8 && op.Value().(cc.Uint64Value) > math.MaxInt64 { - flags |= fForceRuntimeConv - } - defer p.w("%s", p.convert(n, op, to, flags)) - case ptr: - p.w(" uintptr(") - defer p.w(")") - // ok - default: - panic(todo("%v: %v -> %v", p.pos(n), op.Type(), to)) - } - - src = strings.TrimRight(src, "luLU") - sn, err := strconv.ParseUint(src, 0, 64) - snValid := err == nil - var on uint64 - switch x := op.Value().(type) { - case cc.Int64Value: - if x < 0 { - sn, err := strconv.ParseInt(src, 0, 64) - snValid := err == nil - if snValid && sn == int64(x) { // Prefer original form - p.w("%s", src) - return - } - - p.w("%d", x) - return - } - - on = uint64(x) - case cc.Uint64Value: - on = uint64(x) - default: - panic(todo("%T(%v)", x, x)) - } - - if snValid && sn == on { // Prefer original form - p.w("%s", src) - return - } - - p.w("%d", on) -} - -func (p *project) assignShiftOp(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, oper, oper2 string, flags flags) { - // UnaryExpression "<<=" AssignmentExpression etc. - switch mode { - case exprVoid: - p.assignShiftOpVoid(f, n, t, mode, oper, oper2, flags) - default: - panic(todo("", mode)) - } -} - -func (p *project) assignShiftOpVoid(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, oper, oper2 string, flags flags) { - // UnaryExpression "<<=" AssignmentExpression etc. - switch k := p.opKind(f, n.UnaryExpression, n.UnaryExpression.Operand.Type()); k { - case opNormal: - p.assignShiftOpVoidNormal(f, n, t, mode, oper, oper2, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) assignShiftOpVoidNormal(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, oper, oper2 string, flags flags) { - switch { - case n.Operand.Type().IsBitFieldType(): - panic(todo("", p.pos(n))) - default: - if d := n.UnaryExpression.Declarator(); d != nil { - switch d.Type().Kind() { - case cc.Int128, cc.UInt128: - p.declarator(n, f, d, d.Type(), exprLValue, flags) - p.w(".LValue%s(", oper2) - p.assignmentExpression(f, n.AssignmentExpression, p.intType, exprValue, flags) - p.w(")") - return - default: - p.declarator(n, f, d, d.Type(), exprLValue, flags) - p.w(" %s= ", oper) - p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags) - return - } - } - - lhs := n.UnaryExpression - switch { - case lhs.Operand.Type().IsArithmeticType(): - p.w("%sAssign%sPtr%s(", p.task.crt, oper2, p.helperType(n, lhs.Operand.Type())) - p.unaryExpression(f, lhs, lhs.Operand.Type(), exprAddrOf, flags) - p.w(", int(") - p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags) - p.w("))") - default: - panic(todo("", p.pos(n), lhs.Operand.Type())) - } - } -} - -func (p *project) assignOp(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, oper, oper2 string, flags flags) { - // UnaryExpression "*=" AssignmentExpression etc. - switch mode { - case exprVoid: - p.assignOpVoid(f, n, t, mode, oper, oper2, flags) - case exprValue, exprCondReturn: - p.assignOpValue(f, n, t, mode, oper, oper2, flags) - default: - panic(todo("", n.Position(), mode)) - } -} - -func (p *project) assignOpValue(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, oper, oper2 string, flags flags) { - // UnaryExpression "*=" AssignmentExpression etc. - switch k := p.opKind(f, n.UnaryExpression, n.UnaryExpression.Operand.Type()); k { - case opNormal: - p.assignOpValueNormal(f, n, t, oper, oper2, mode, flags) - case opBitfield: - p.assignOpValueBitfield(f, n, t, oper, oper2, mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) assignOpValueBitfield(f *function, n *cc.AssignmentExpression, t cc.Type, oper, oper2 string, mode exprMode, flags flags) { - // UnaryExpression "*=" AssignmentExpression etc. - - asInt := oper2 == "Shl" || oper2 == "Shr" - if asInt { - panic(todo("")) - } - - ot := n.Operand.Type() - lhs := n.UnaryExpression - bf := lhs.Operand.Type().BitField() - defer p.w("%s", p.convertType(n, ot, t, flags)) - p.w(" func() %v {", p.typ(n, ot)) - switch lhs.Case { - case cc.UnaryExpressionPostfix: // PostfixExpression - pe := n.UnaryExpression.PostfixExpression - switch pe.Case { - case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER - p.w("__p := ") - p.postfixExpression(f, pe, pe.Operand.Type(), exprAddrOf, flags) - p.w("; __v := ") - p.readBitfield(lhs, "__p", bf, ot) - p.w(" %s (", oper) - p.assignmentExpression(f, n.AssignmentExpression, ot, exprValue, flags) - p.w("); return %sAssignBitFieldPtr%d%s(__p, __v, %d, %d, %#x)", p.task.crt, bf.BitFieldBlockWidth(), p.bfHelperType(ot), bf.BitFieldWidth(), bf.BitFieldOffset(), bf.Mask()) - case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER - panic(todo("", p.pos(n))) - default: - panic(todo("", n.Position(), pe.Case)) - } - default: - panic(todo("", n.Position(), lhs.Case)) - } - p.w("}()") -} - -func (p *project) readBitfield(n cc.Node, ptr string, bf cc.Field, promote cc.Type) { - bw := bf.BitFieldBlockWidth() - m := bf.Mask() - o := bf.BitFieldOffset() - w := bf.BitFieldWidth() - p.w("(%s(*(*uint%d)(unsafe.Pointer(%s))&%#x)", p.typ(n, promote), bw, ptr, m) - switch { - case bf.Type().IsSignedType(): - bits := int(promote.Size()) * 8 - p.w("<<%d>>%d)", bits-w-o, bits-w) - default: - p.w(">>%d)", o) - } -} - -func (p *project) assignOpValueNormal(f *function, n *cc.AssignmentExpression, t cc.Type, oper, oper2 string, mode exprMode, flags flags) { - if mode == exprCondReturn { - p.w("return ") - } - asInt := oper2 == "Shl" || oper2 == "Shr" - lhs := n.UnaryExpression - // UnaryExpression "*=" AssignmentExpression etc. - if d := lhs.Declarator(); d != nil { - if local := f.locals[d]; local != nil && local.isPinned { - switch { - case lhs.Operand.Type().IsArithmeticType(): - defer p.w("%s", p.convertType(n, lhs.Operand.Type(), t, flags)) - p.w("%sAssign%sPtr%s(", p.task.crt, oper2, p.helperType(n, lhs.Operand.Type())) - p.unaryExpression(f, lhs, lhs.Operand.Type(), exprAddrOf, flags) - p.w(", ") - if asInt { - p.w("int(") - } - p.assignmentExpression(f, n.AssignmentExpression, lhs.Operand.Type(), exprValue, flags) - if asInt { - p.w(")") - } - p.w(")") - default: - panic(todo("", lhs.Operand.Type())) - } - return - } - - switch { - case d.Type().Kind() == cc.Ptr: - defer p.w("%s", p.convertType(n, d.Type(), t, flags)) - p.w("%sAssign%s%s(&", p.task.crt, oper2, p.helperType(n, d.Type())) - p.declarator(n, f, d, d.Type(), exprLValue, flags) - p.w(", ") - if dd := p.incDelta(d, d.Type()); dd != 1 { - p.w("%d*(", dd) - defer p.w(")") - } - p.assignmentExpression(f, n.AssignmentExpression, d.Type(), exprValue, flags) - p.w(")") - case d.Type().IsArithmeticType(): - defer p.w("%s", p.convertType(n, d.Type(), t, flags)) - p.w("%sAssign%s%s(&", p.task.crt, oper2, p.helperType(n, d.Type())) - p.declarator(n, f, d, d.Type(), exprLValue, flags) - p.w(", ") - if asInt { - p.w("int(") - } - p.assignmentExpression(f, n.AssignmentExpression, d.Type(), exprValue, flags) - p.w(")") - if asInt { - p.w(")") - } - default: - panic(todo("", p.pos(n), p.pos(d), d.Name())) - } - return - } - - switch { - case lhs.Operand.Type().IsArithmeticType(): - defer p.w("%s", p.convertType(n, lhs.Operand.Type(), t, flags)) - p.w("%sAssign%sPtr%s(", p.task.crt, oper2, p.helperType(n, lhs.Operand.Type())) - p.unaryExpression(f, lhs, lhs.Operand.Type(), exprAddrOf, flags) - p.w(", ") - if asInt { - p.w("int(") - } - p.assignmentExpression(f, n.AssignmentExpression, lhs.Operand.Type(), exprValue, flags) - if asInt { - p.w(")") - } - p.w(")") - default: - panic(todo("", lhs.Operand.Type())) - } -} - -func (p *project) assignOpVoid(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, oper, oper2 string, flags flags) { - // UnaryExpression "*=" AssignmentExpression etc. - switch k := p.opKind(f, n.UnaryExpression, n.UnaryExpression.Operand.Type()); k { - case opNormal: - p.assignOpVoidNormal(f, n, t, oper, oper2, mode, flags) - case opBitfield: - p.assignOpVoidBitfield(f, n, t, oper, oper2, mode, flags) - case opArrayParameter: - p.assignOpVoidArrayParameter(f, n, t, oper, oper2, mode, flags) - default: - panic(todo("", n.Position(), k)) - } -} - -func (p *project) assignOpVoidArrayParameter(f *function, n *cc.AssignmentExpression, t cc.Type, oper, oper2 string, mode exprMode, flags flags) { - // UnaryExpression "*=" AssignmentExpression etc. - if oper != "+" && oper != "-" { - panic(todo("", p.pos(n))) - } - - d := n.UnaryExpression.Declarator() - switch local := f.locals[d]; { - case local != nil && local.isPinned: - p.w("*(*uintptr)(unsafe.Pointer(%s%s))", f.bpName, nonZeroUintptr(local.off)) - default: - p.declarator(n, f, d, d.Type(), exprLValue, flags) - } - - p.w(" %s= ", oper) - if dd := p.incDelta(d, d.Type()); dd != 1 { - p.w("%d*", dd) - } - p.w("uintptr(") - p.assignmentExpression(f, n.AssignmentExpression, n.AssignmentExpression.Operand.Type(), exprValue, flags) - p.w(")") -} - -func (p *project) assignOpVoidBitfield(f *function, n *cc.AssignmentExpression, t cc.Type, oper, oper2 string, mode exprMode, flags flags) { - // UnaryExpression "*=" AssignmentExpression etc. - lhs := n.UnaryExpression - lt := lhs.Operand.Type() - switch lhs.Case { - case cc.UnaryExpressionPostfix: // PostfixExpression - pe := n.UnaryExpression.PostfixExpression - switch pe.Case { - case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER - bf := lt.BitField() - p.w("%sSetBitFieldPtr%d%s(", p.task.crt, bf.BitFieldBlockWidth(), p.bfHelperType(n.Promote())) - p.unaryExpression(f, lhs, lt, exprAddrOf, flags) - p.w(", (") - s := p.convertType(n, lt, n.Promote(), flags) - p.unaryExpression(f, lhs, lt, exprValue, flags) - p.w(")%s %s ", s, oper) - s = p.convertType(n, lt, n.Promote(), flags) - p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags) - p.w("%s", s) - p.w(", %d, %#x)", bf.BitFieldOffset(), bf.Mask()) - case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER - switch d := pe.PostfixExpression.Declarator(); { - case d != nil: - panic(todo("", p.pos(n))) - default: - panic(todo("", p.pos(n))) - } - default: - panic(todo("", n.Position(), pe.Case)) - } - default: - panic(todo("", n.Position(), lhs.Case)) - } -} - -func (p *project) assignOpVoidNormal(f *function, n *cc.AssignmentExpression, t cc.Type, oper, oper2 string, mode exprMode, flags flags) { - // UnaryExpression "*=" AssignmentExpression etc. - rop := n.AssignmentExpression.Operand - if d := n.UnaryExpression.Declarator(); d != nil { - if local := f.locals[d]; local != nil && local.isPinned { - if p.isVolatileOrAtomic(d) { - panic(todo("")) - } - - p.declarator(n, f, d, d.Type(), exprLValue, flags) - switch { - case d.Type().Kind() == cc.Ptr: - p.w(" %s= ", oper) - if dd := p.incDelta(d, d.Type()); dd != 1 { - p.w("%d*(", dd) - defer p.w(")") - } - defer p.w("%s", p.convert(n, rop.ConvertTo(n.Promote()), d.Type(), flags)) - p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags) - case d.Type().IsArithmeticType(): - p.w(" %s= ", oper) - defer p.w("%s", p.convert(n, rop.ConvertTo(n.Promote()), d.Type(), flags)) - p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags) - default: - panic(todo("", n.Position(), d.Type().Kind())) - } - return - } - - if p.isVolatileOrAtomic(d) { - var local *local - var tld *tld - var nm string - if f != nil { - if local = f.locals[d]; local != nil { - nm = local.name - } - } - - if local == nil { - if tld = p.tlds[d]; tld == nil { - p.err(n, "%v: internal error (%v: %v)", n.Position(), d.Position(), d.Name()) - return - } - - nm = tld.name - } - var sign string - switch oper { - case "-": - sign = oper - fallthrough - case "+": - sz := d.Type().Size() - var ht string - switch sz { - case 4, 8: - if !d.Type().IsScalarType() { - p.err(n, "unsupported volatile declarator type: %v", d.Type()) - break - } - - ht = p.helperType(n, d.Type()) - default: - p.err(n, "unsupported volatile declarator size: %v", sz) - return - } - - if local != nil { - if local.isPinned { - panic(todo("")) - } - } - - p.w("%sAtomicAdd%s(&%s, %s%s(", p.task.crt, ht, nm, sign, p.typ(n, d.Type())) - p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags) - p.w("))") - return - default: - p.warn(n, "unsupported volatile declarator operation: %v", oper) - p.w("%s = ", nm) - defer p.w("%s", p.convert(n, rop.ConvertTo(n.Promote()), d.Type(), flags)) - p.declarator(n, f, d, n.Promote(), exprValue, flags) - p.w(" %s (", oper) - p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags) - p.w(")") - return - } - } - - p.declarator(n, f, d, d.Type(), exprLValue, flags) - switch d.Type().Kind() { - case cc.Ptr: - if oper != "+" && oper != "-" { - panic(todo("", p.pos(n))) - } - - p.w(" %s= ", oper) - if dd := p.incDelta(d, d.Type()); dd != 1 { - p.w("%d*(", dd) - defer p.w(")") - } - defer p.w("%s", p.convert(n, rop.ConvertTo(n.Promote()), d.Type(), flags)) - p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags) - case cc.Int128, cc.UInt128: - p.w(" = ") - p.declarator(n, f, d, n.Promote(), exprValue, flags) - p.w(".%s(", oper2) - p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags) - p.w(")") - default: - p.w(" = ") - defer p.w("%s", p.convert(n, rop.ConvertTo(n.Promote()), d.Type(), flags)) - p.declarator(n, f, d, n.Promote(), exprValue, flags) - p.w(" %s (", oper) - p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags) - p.w(")") - } - return - } - - lhs := n.UnaryExpression - switch { - case lhs.Operand.Type().IsArithmeticType(): - p.w("*(*%s)(unsafe.Pointer(", p.typ(n, lhs.Operand.Type())) - p.unaryExpression(f, lhs, lhs.Operand.Type(), exprAddrOf, flags) - p.w(")) %s= ", oper) - defer p.w("%s", p.convert(n, rop.ConvertTo(n.Promote()), lhs.Operand.Type(), flags)) - p.w("(") - p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags) - p.w(")") - case lhs.Operand.Type().Kind() == cc.Ptr: - p.w("*(*%s)(unsafe.Pointer(", p.typ(n, lhs.Operand.Type())) - p.unaryExpression(f, lhs, lhs.Operand.Type(), exprAddrOf, flags) - p.w(")) %s= (", oper) - p.assignmentExpression(f, n.AssignmentExpression, lhs.Operand.Type(), exprValue, flags) - p.w(")") - if dd := p.incDelta(n, lhs.Operand.Type()); dd != 1 { - p.w("*%d", dd) - } - default: - panic(todo("", lhs.Operand.Type())) - } -} - -func (p *project) warn(n cc.Node, s string, args ...interface{}) { - s = fmt.Sprintf(s, args...) - s = strings.TrimRight(s, "\t\n\r") - fmt.Fprintf(os.Stderr, "%v: warning: %s\n", n.Position(), s) -} - -func (p *project) iterationStatement(f *function, n *cc.IterationStatement) { - sv := f.switchCtx - sv2 := f.continueCtx - sv3 := f.breakCtx - f.switchCtx = 0 - f.continueCtx = 0 - f.breakCtx = 0 - defer func() { - f.breakCtx = sv3 - f.continueCtx = sv2 - f.switchCtx = sv - }() - p.w("%s", tidyComment("\n", n)) - switch n.Case { - case cc.IterationStatementWhile: // "while" '(' Expression ')' Statement - if f.hasJumps { - // a: if !expr goto b - // stmt - // goto a - // b: - a := f.flatLabel() - b := f.flatLabel() - f.continueCtx = a - f.breakCtx = b - p.w("__%d: if !(", a) - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprBool, 0) - p.w(") { goto __%d };", b) - p.statement(f, n.Statement, false, false, false, 0) - p.w("; goto __%d; __%d:", a, b) - break - } - - p.w("for ") - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprBool, 0) - p.statement(f, n.Statement, true, false, false, 0) - case cc.IterationStatementDo: // "do" Statement "while" '(' Expression ')' ';' - if f.hasJumps { - // a: stmt - // b: if expr goto a // b is the continue label - // c: - a := f.flatLabel() - b := f.flatLabel() - c := f.flatLabel() - f.continueCtx = b - f.breakCtx = c - p.w("__%d:", a) - p.statement(f, n.Statement, false, false, false, 0) - p.w(";goto __%d; __%[1]d: if ", b) - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprBool, 0) - p.w("{goto __%d};goto __%d;__%[2]d:", a, c) - break - } - - v := "__ccgo" - if !p.pass1 { - v = f.scope.take(cc.String(v)) - } - p.w("for %v := true; %[1]v; %[1]v = ", v) - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprBool, 0) - p.statement(f, n.Statement, true, false, false, 0) - case cc.IterationStatementFor: // "for" '(' Expression ';' Expression ';' Expression ')' Statement - if f.hasJumps || n.Expression3 != nil && n.Expression3.Case == cc.ExpressionComma { - // expr - // a: if !expr2 goto c - // stmt - // b: expr3 // label for continue - // goto a - // c: - a := f.flatLabel() - b := f.flatLabel() - f.continueCtx = b - c := f.flatLabel() - f.breakCtx = c - if n.Expression != nil { - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, fNoCondAssignment) - } - semi := "" - if n.Expression != nil || n.Expression2 != nil || n.Expression3 != nil { - semi = ";" - } - p.w("%s__%d:", semi, a) - if n.Expression2 != nil { - p.w("if !(") - p.expression(f, n.Expression2, n.Expression2.Operand.Type(), exprBool, 0) - p.w(") { goto __%d }", c) - } - p.w("%s", semi) - p.statement(f, n.Statement, false, false, false, 0) - p.w(";goto __%d; __%[1]d:", b) - if n.Expression3 != nil { - p.expression(f, n.Expression3, n.Expression3.Operand.Type(), exprVoid, fNoCondAssignment) - } - p.w("%sgoto __%d; goto __%d;__%[3]d:", semi, a, c) - break - } - - expr := true - if n.Expression != nil && n.Expression.Case == cc.ExpressionComma { - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, 0) - p.w(";") - expr = false - } - p.w("for ") - if expr && n.Expression != nil { - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, fNoCondAssignment) - } - p.w("; ") - if n.Expression2 != nil { - p.expression(f, n.Expression2, n.Expression2.Operand.Type(), exprBool, 0) - } - p.w("; ") - if n.Expression3 != nil { - p.expression(f, n.Expression3, n.Expression3.Operand.Type(), exprVoid, fNoCondAssignment) - } - p.statement(f, n.Statement, true, false, false, 0) - case cc.IterationStatementForDecl: // "for" '(' Declaration Expression ';' Expression ')' Statement - if !(f.hasJumps || n.Expression2 != nil && n.Expression2.Case == cc.ExpressionComma) { - p.w("{") - p.declaration(f, n.Declaration, false) - p.w("for ;") - if n.Expression != nil { - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprBool, 0) - } - p.w(";") - if n.Expression2 != nil { - p.expression(f, n.Expression2, n.Expression2.Operand.Type(), exprVoid, fNoCondAssignment) - } - p.w("{") - p.statement(f, n.Statement, false, true, false, 0) - p.w("}};") - break - } - - var ids []*cc.InitDeclarator - for list := n.Declaration.InitDeclaratorList; list != nil; list = list.InitDeclaratorList { - ids = append(ids, list.InitDeclarator) - } - - // declaration - // a: if !expr goto c - // stmt - // b: expr2 // label for continue - // goto a - // c: - a := f.flatLabel() - b := f.flatLabel() - f.continueCtx = b - c := f.flatLabel() - f.breakCtx = c - p.w("{") - p.declaration(f, n.Declaration, false) - p.w(";") - p.w("__%d:", a) - if n.Expression != nil { - p.w("if !(") - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprBool, 0) - p.w(") { goto __%d }", c) - } - p.w(";") - p.statement(f, n.Statement, false, false, false, 0) - p.w(";goto __%d; __%[1]d:", b) - if n.Expression2 != nil { - p.expression(f, n.Expression2, n.Expression2.Operand.Type(), exprVoid, fNoCondAssignment) - } - p.w("; goto __%d; goto __%d;__%[2]d:\n}", a, c) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) selectionStatement(f *function, n *cc.SelectionStatement) { - p.w("%s", tidyComment("\n", n)) - switch n.Case { - case cc.SelectionStatementIf: // "if" '(' Expression ')' Statement - sv := f.ifCtx - f.ifCtx = n - defer func() { f.ifCtx = sv }() - if f.hasJumps { - // if !expr goto a - // stmt - // a: - f.ifCtx = n - a := f.flatLabel() - p.w("if !(") - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprBool, 0) - p.w(") { goto __%d };", a) - p.statement(f, n.Statement, false, false, false, 0) - p.w(";__%d: ", a) - break - } - - p.w("if ") - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprBool, 0) - p.statement(f, n.Statement, true, false, false, 0) - case cc.SelectionStatementIfElse: // "if" '(' Expression ')' Statement "else" Statement - sv := f.ifCtx - f.ifCtx = n - defer func() { f.ifCtx = sv }() - if f.hasJumps { - // if !expr goto a - // stmt - // goto b - // a: - // stmt2 - // b: - a := f.flatLabel() - b := f.flatLabel() - p.w("if !(") - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprBool, 0) - p.w(") { goto __%d };", a) - p.statement(f, n.Statement, false, false, false, 0) - p.w(";goto __%d; __%d:", b, a) - p.statement(f, n.Statement2, false, false, false, 0) - p.w(";__%d:", b) - break - } - - p.w("if ") - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprBool, 0) - p.statement(f, n.Statement, true, false, false, 0) - p.w(" else ") - switch { - case p.isIfStmt(n.Statement2): - p.statement(f, n.Statement2, false, true, false, 0) - default: - p.statement(f, n.Statement2, true, false, false, 0) - } - case cc.SelectionStatementSwitch: // "switch" '(' Expression ')' Statement - // just dont generate in this case - if f.switchCtx == inSwitchFirst { - break - } - sv := f.switchCtx - sb := f.block - sc := p.pauseCodegen - svBreakCtx := f.breakCtx - f.breakCtx = 0 - f.block = f.blocks[n.Statement.CompoundStatement] - - defer func() { - f.block = sb - f.switchCtx = sv - f.breakCtx = svBreakCtx - p.pauseCodegen = sc - }() - if f.hasJumps { - f.switchCtx = inSwitchFlat - p.flatSwitch(f, n) - break - } - - f.switchCtx = inSwitchFirst - // fmt.Println(f.block.decls) - if len(f.block.decls) != 0 { - f.block.topDecl = true - // fmt.Printf("%p:%tf\n", f.block, f.block.topDecl) - p.w("{") - for _, v := range f.block.decls { - // fmt.Printf("%p:%tf\n", f.block, f.block.topDecl) - p.declaration(f, v, true) - // fmt.Println("done!") - } - } - - p.w("switch ") - p.expression(f, n.Expression, n.Promote(), exprValue, 0) - p.pauseCodegen = true - p.statement(f, n.Statement, true, false, true, 0) - p.pauseCodegen = false - if len(f.block.decls) != 0 { - p.w("}") - } - - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } -} - -func (p *project) isIfStmt(n *cc.Statement) bool { - if n.Case != cc.StatementSelection { - return false - } - - switch n.SelectionStatement.Case { - case cc.SelectionStatementIf, cc.SelectionStatementIfElse: - return true - } - - return false -} - -func (p *project) flatSwitch(f *function, n *cc.SelectionStatement) { - if n.Statement.Case != cc.StatementCompound { - panic(todo("", p.pos(n))) - } - - sv := f.block - f.block = f.blocks[n.Statement.CompoundStatement] - defer func() { f.block = sv }() - // "switch" '(' Expression ')' Statement - cases := n.Cases() - labels := map[*cc.LabeledStatement]int{} - svBreakCtx := f.breakCtx - f.breakCtx = f.flatLabel() - p.w("switch ") - p.expression(f, n.Expression, n.Promote(), exprValue, 0) - p.w("{") - for _, ls := range cases { - switch ls.Case { - case cc.LabeledStatementLabel: // IDENTIFIER ':' AttributeSpecifierList Statement - continue - case cc.LabeledStatementCaseLabel: // "case" ConstantExpression ':' Statement - p.w("%scase ", tidyComment("\n", ls)) - p.constantExpression(f, ls.ConstantExpression, ls.ConstantExpression.Operand.Type(), exprValue, 0) - p.w(":") - case cc.LabeledStatementDefault: // "default" ':' Statement - p.w("%sdefault:", tidyComment("\n", ls)) - case cc.LabeledStatementRange: // "case" ConstantExpression "..." ConstantExpression ':' Statement - panic(todo("", p.pos(n))) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } - label := f.flatLabel() - labels[ls] = label - p.w("goto __%d;", label) - } - p.w("}; goto __%d;", f.breakCtx) - svLabels := f.flatSwitchLabels - f.flatSwitchLabels = labels - p.statement(f, n.Statement, false, true, false, 0) - f.flatSwitchLabels = svLabels - p.w("__%d:", f.breakCtx) - f.breakCtx = svBreakCtx -} - -func (p *project) expressionStatement(f *function, n *cc.ExpressionStatement) { - p.w("%s", tidyComment("\n", n)) - // Expression AttributeSpecifierList ';' - if n.Expression == nil { - return - } - - p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, 0) -} - -func (p *project) labeledStatement(f *function, n *cc.LabeledStatement) (r *cc.JumpStatement) { - if f.hasJumps { //TODO merge with ...Flat below - return p.labeledStatementFlat(f, n) - } - - switch n.Case { - case cc.LabeledStatementLabel: // IDENTIFIER ':' AttributeSpecifierList Statement - if _, ok := f.unusedLabels[n.Token.Value]; ok { - p.w("goto %s;", f.labelNames[n.Token.Value]) - } - p.w("%s%s:", comment("\n", n), f.labelNames[n.Token.Value]) - r = p.statement(f, n.Statement, false, false, false, 0) - case - cc.LabeledStatementCaseLabel, // "case" ConstantExpression ':' Statement - cc.LabeledStatementDefault: // "default" ':' Statement - - p.labeledStatementCase(f, n) - case cc.LabeledStatementRange: // "case" ConstantExpression "..." ConstantExpression ':' Statement - panic(todo("", n.Position(), n.Case)) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } - return r -} - -func (p *project) labeledStatementFlat(f *function, n *cc.LabeledStatement) (r *cc.JumpStatement) { - switch n.Case { - case cc.LabeledStatementLabel: // IDENTIFIER ':' AttributeSpecifierList Statement - if _, ok := f.unusedLabels[n.Token.Value]; ok { - p.w("goto %s;", f.labelNames[n.Token.Value]) - } - p.w("%s%s:", tidyComment("\n", n), f.labelNames[n.Token.Value]) - r = p.statement(f, n.Statement, false, false, false, 0) - case - cc.LabeledStatementCaseLabel, // "case" ConstantExpression ':' Statement - cc.LabeledStatementDefault: // "default" ':' Statement - - p.labeledStatementCase(f, n) - case cc.LabeledStatementRange: // "case" ConstantExpression "..." ConstantExpression ':' Statement - panic(todo("", n.Position(), n.Case)) - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } - return r -} - -func (p *project) labeledStatementCase(f *function, n *cc.LabeledStatement) { - switch f.switchCtx { - case inSwitchFirst: - f.switchCtx = inSwitchCase - p.pauseCodegen = false - case inSwitchCase: - p.w("\nfallthrough;") - case inSwitchSeenBreak: - f.switchCtx = inSwitchCase - case inSwitchFlat: - // ok - default: - panic(todo("", n.Position(), f.switchCtx)) - } - switch n.Case { - case cc.LabeledStatementCaseLabel: // "case" ConstantExpression ':' Statement - switch { - case f.switchCtx == inSwitchFlat: - p.w("%s__%d:", tidyComment("\n", n), f.flatSwitchLabels[n]) - default: - p.w("%scase ", tidyComment("\n", n)) - p.constantExpression(f, n.ConstantExpression, n.ConstantExpression.Operand.Type(), exprValue, 0) - p.w(":") - } - case cc.LabeledStatementDefault: // "default" ':' Statement - switch { - case f.switchCtx == inSwitchFlat: - p.w("%s__%d:", tidyComment("\n", n), f.flatSwitchLabels[n]) - default: - p.w("%sdefault:", tidyComment("\n", n)) - } - default: - panic(todo("%v: internal error: %v", n.Position(), n.Case)) - } - p.statement(f, n.Statement, false, false, false, 0) -} - -func (p *project) constantExpression(f *function, n *cc.ConstantExpression, t cc.Type, mode exprMode, flags flags) { - // ConditionalExpression - p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags) -} - -func (p *project) functionDefinitionSignature(n cc.Node, f *function, tld *tld) { - switch { - case f.mainSignatureForced: - p.w("%sfunc %s(%s *%sTLS, _ int32, _ uintptr) int32", tidyComment("\n", f.fndef), tld.name, f.tlsName, p.task.crt) - default: - p.w("%s", tidyComment("\n", f.fndef)) - p.functionSignature(n, f, f.fndef.Declarator.Type(), tld.name) - } -} - -func (p *project) functionSignature2(n cc.Node, f *function, t cc.Type, nm string) { - p.w("func %s", nm) - p.w("(_ *%sTLS", p.task.crt) - suffix := 1 - for _, v := range t.Parameters() { - if v.Type().Kind() == cc.Void { - break - } - - pn := "_" - if d := v.Declarator(); d != nil { - pn = d.Name().String() - if _, ok := reservedNames[pn]; ok { - pn += strconv.Itoa(suffix) - suffix++ - } - } - p.w(", %s %s", pn, p.paramTyp(v.Declarator(), v.Type())) - } - if t.IsVariadic() { - p.w(", _ /* va_list */ uintptr") - } - p.w(")") - if rt := t.Result(); rt != nil && rt.Kind() != cc.Void { - p.w(" %s", p.typ(n, rt)) - } -} - -func (p *project) functionSignature(n cc.Node, f *function, t cc.Type, nm string) { - p.w("func") - if nm != "" { - p.w(" %s", nm) - } - switch { - case f == nil || nm == "": - p.w("(*%sTLS", p.task.crt) - default: - p.w("(%s *%sTLS", f.tlsName, p.task.crt) - } - for _, v := range t.Parameters() { - if v.Type().Kind() == cc.Void { - break - } - - var pn string - if f != nil && nm != "" { - pn = "_" - if d := v.Declarator(); d != nil { - if local := f.locals[d]; local != nil { - pn = local.name - } - } - } - p.w(", %s %s", pn, p.paramTyp(v.Declarator(), v.Type())) - } - if t.IsVariadic() { - switch { - case f == nil || nm == "": - p.w(", uintptr") - default: - p.w(", %s uintptr", f.vaName) - } - } - p.w(")") - if rt := t.Result(); rt != nil && rt.Kind() != cc.Void { - p.w(" %s", p.typ(n, rt)) - } -} - -func (p *project) paramTyp(n cc.Node, t cc.Type) string { - if t.Kind() == cc.Array { - return "uintptr" - } - - if isTransparentUnion(t) { - switch k := t.UnionCommon(); k { - case cc.Ptr: - return "uintptr" - default: - panic(todo("%v: %v %k", n, t, k)) - } - } - - return p.typ(n, t) -} - -func (p *project) dbg(a ...interface{}) { - p.w("/*DBG.%v %v */", a, origin(2)) -} - -func (p *project) fnVal(n cc.Node, f *function, expr func(), exprDecl *cc.Declarator, exprType cc.Type, deref int, mode exprMode, flags flags) { - // C type Go type - // fn N/A: produce name from exprDecl - // (*)() func() - // (**)() *func() - - if deref < 0 || deref > 1 { - panic(todo("")) - } - - switch exprType.Kind() { - case cc.Function: - // C: fn - switch deref { - case 0: - p.declarator(n, f, exprDecl, exprType, mode, flags) - default: - panic(todo("", n.Position())) - } - case cc.Ptr: - switch et := exprType.Elem(); et.Kind() { - case cc.Function: - // C: (*)() - switch deref { - case 0: - // (*struct{ f func()})(unsafe.Pointer(&struct{uintptr}{fprintfptr})).f() - p.w("(*struct{ f ") - p.functionSignature(n, f, et, "") - p.w("})(unsafe.Pointer(&struct{uintptr}{") - expr() - p.w("})).f") - default: - p.declarator(n, f, exprDecl, et, mode, flags) - } - case cc.Ptr: - switch et2 := et.Elem(); et2.Kind() { - case cc.Function: - // C: (**)() - switch deref { - case 0: - panic(todo("", n.Position())) - default: - // (*struct{ f func()})(unsafe.Pointer(&struct{uintptr}{fprintfptr})).f() - p.w("(*(**struct{ f ") - p.functionSignature(n, f, et2, "") - p.w("})(unsafe.Pointer(&struct{uintptr}{") - expr() - p.w("}))).f") - } - default: - panic(todo("", n.Position(), et2.Kind(), deref)) - } - default: - panic(todo("", n.Position(), et.Kind(), deref)) - } - default: - panic(todo("", n.Position(), exprType.Kind(), deref)) - } -} |