// 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, "//
") { in = false a[i] = "//" break } a[i] = fmt.Sprintf("//\t%s", v[3:]) default: if strings.HasPrefix(v, "//") { return } a := strings.Split(r, "\n") in := false for i, v := range a { switch { case in: if strings.HasPrefix(v, "//
") { 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 "" } 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) } // 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 } r = token.Position(n.Position()) if r.IsValid() && !p.task.fullPathComments { 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 } 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 { 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", name, src)) } } 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("", pos(n))) case cc.UInt128: panic(todo("", 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("", pos(n))) case cc.UInt128: panic(todo("", pos(n))) } switch to.Kind() { case cc.Int128: panic(todo("", pos(n))) case cc.UInt128: panic(todo("", 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 { 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 { 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)< 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.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type()); 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) 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, 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", 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 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 sv := f.switchCtx svBreakCtx := f.breakCtx f.breakCtx = 0 defer func() { f.switchCtx = sv f.breakCtx = svBreakCtx }() if f.hasJumps { f.switchCtx = inSwitchFlat p.flatSwitch(f, n) break } f.switchCtx = inSwitchFirst p.w("switch ") p.expression(f, n.Expression, n.Promote(), exprValue, 0) p.statement(f, n.Statement, true, false, true, 0) 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 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)) } }