") {
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 // %v:", name, src, p.pos(m)))
}
}
return nil
}
func evalMacro(m *cc.Macro, ast *cc.AST) (cc.Value, string) {
toks := m.ReplacementTokens()
if len(toks) != 1 {
return evalMacro2(m, ast)
}
src := strings.TrimSpace(toks[0].Src.String())
if len(src) == 0 {
return nil, ""
}
neg := ""
switch src[0] {
case '"':
if _, err := strconv.Unquote(src); err == nil {
return cc.StringValue(cc.String(src)), src
}
case '-':
neg = "-"
src = src[1:]
fallthrough
default:
src = strings.TrimRight(src, "lLuU")
if u64, err := strconv.ParseUint(src, 0, 64); err == nil {
switch {
case neg == "":
return cc.Uint64Value(u64), src
default:
return cc.Int64Value(-u64), neg + src
}
}
src = strings.TrimRight(src, "fF")
if f64, err := strconv.ParseFloat(src, 64); err == nil {
return cc.Float64Value(f64), neg + src
}
}
return evalMacro2(m, ast)
}
func evalMacro2(m *cc.Macro, ast *cc.AST) (cc.Value, string) {
op, err := ast.Eval(m)
if err != nil {
return nil, ""
}
switch x := op.Value().(type) {
case cc.Int64Value:
return op.Value(), fmt.Sprintf("%d", int64(x))
case cc.Uint64Value:
return op.Value(), fmt.Sprintf("%d", uint64(x))
default:
panic(todo("", pos(m)))
}
}
func (p *project) layoutEnums() error {
var t0 time.Time
if p.task.traceTranslationUnits {
fmt.Printf("processing enum values ... ")
t0 = time.Now()
defer func() { fmt.Println(time.Since(t0)) }()
}
export := doNotChange
if p.task.exportEnumsValid {
switch {
case p.task.exportEnums != "":
export = exportPrefix
default:
export = exportCapitalize
}
} else if p.task.defaultUnExport {
export = doNotExport
}
var enumList []*cc.EnumSpecifier
for _, v := range p.task.asts {
for list := v.TranslationUnit; list != nil; list = list.TranslationUnit {
decl := list.ExternalDeclaration
switch decl.Case {
case cc.ExternalDeclarationDecl: // Declaration
// ok
default:
continue
}
cc.Inspect(decl.Declaration.DeclarationSpecifiers, func(n cc.Node, entry bool) bool {
if !entry {
return true
}
x, ok := n.(*cc.EnumSpecifier)
if !ok || x.Case != cc.EnumSpecifierDef {
return true
}
if _, ok := p.enumSpecs[x]; !ok {
enumList = append(enumList, x)
p.enumSpecs[x] = &enumSpec{decl: decl.Declaration, spec: x}
}
return true
})
}
}
vals := map[cc.StringID]interface{}{}
for _, v := range enumList {
for list := v.EnumeratorList; list != nil; list = list.EnumeratorList {
en := list.Enumerator
nm := en.Token.Value
var val int64
switch x := en.Operand.Value().(type) {
case cc.Int64Value:
val = int64(x)
case cc.Uint64Value:
val = int64(x)
default:
panic(todo(""))
}
switch ex, ok := vals[nm]; {
case ok:
switch {
case ex == nil: //
continue
case ex == val: // same name and same value
continue
default: // same name, different value
vals[nm] = nil
}
default:
vals[nm] = val
}
p.enumConsts[nm] = ""
}
}
var a []cc.StringID
for nm := range p.enumConsts {
if val, ok := vals[nm]; ok && val == nil {
delete(p.enumConsts, nm)
continue
}
a = append(a, nm)
}
sort.Slice(a, func(i, j int) bool { return a[i].String() < a[j].String() })
for _, nm := range a {
name := nm.String()
switch export {
case doNotExport:
name = unCapitalize(name)
case doNotChange:
// nop
case exportCapitalize:
name = capitalize(name)
case exportPrefix:
name = p.task.exportEnums + name
}
name = p.scope.take(cc.String(name))
p.enumConsts[nm] = name
}
return nil
}
func (p *project) layoutStaticLocals() error {
var t0 time.Time
if p.task.traceTranslationUnits {
fmt.Printf("processing static local declarations ... ")
t0 = time.Now()
defer func() { fmt.Println(time.Since(t0)) }()
}
for _, v := range p.task.asts {
for list := v.TranslationUnit; list != nil; list = list.TranslationUnit {
decl := list.ExternalDeclaration
switch decl.Case {
case cc.ExternalDeclarationFuncDef: // FunctionDefinition
// ok
default:
continue
}
cc.Inspect(decl.FunctionDefinition.CompoundStatement, func(n cc.Node, entry bool) bool {
switch x := n.(type) {
case *cc.Declarator:
if !entry || !x.IsStatic() || x.Read == 0 || x.IsParameter {
break
}
nm := x.Name()
if s := p.task.staticLocalsPrefix; s != "" {
nm = cc.String(s + nm.String())
}
p.tlds[x] = &tld{name: p.scope.take(nm)}
}
return true
})
}
}
return nil
}
func (p *project) layoutStructs() error {
var t0 time.Time
if p.task.traceTranslationUnits {
fmt.Printf("processing struct/union types ... ")
t0 = time.Now()
defer func() { fmt.Println(time.Since(t0)) }()
}
export := doNotChange
if p.task.exportStructsValid {
switch {
case p.task.exportStructs != "":
export = exportPrefix
default:
export = exportCapitalize
}
} else if p.task.defaultUnExport {
export = doNotExport
}
m := map[cc.StringID]*taggedStruct{}
var tags []cc.StringID
for _, v := range p.task.asts {
cc.Inspect(v.TranslationUnit, func(n cc.Node, entry bool) bool {
if entry {
switch x := n.(type) {
case *cc.Declarator:
if nm := x.Name().String(); strings.HasPrefix(nm, "_") {
break
}
p.captureStructTags(x, x.Type(), m, &tags)
case *cc.Declaration:
cc.Inspect(x.DeclarationSpecifiers, func(nn cc.Node, entry bool) bool {
switch y := nn.(type) {
case *cc.StructOrUnionSpecifier:
if tag := y.Token.Value; tag != 0 {
p.captureStructTags(y, y.Type(), m, &tags)
}
}
return true
})
}
}
return true
})
}
sort.Slice(tags, func(i, j int) bool { return tags[i].String() < tags[j].String() })
for _, k := range tags {
v := m[k]
//TODO rename conflicts
if v.conflicts {
delete(m, k)
continue
}
name := k.String()
switch export {
case doNotExport:
name = unCapitalize(name)
case doNotChange:
// nop
case exportCapitalize:
name = capitalize(name)
case exportPrefix:
name = p.task.exportStructs + name
}
v.name = p.scope.take(cc.String(name))
}
for _, k := range tags {
v := m[k]
if v != nil {
v.gotyp = p.structType(nil, v.ctyp)
}
}
p.structs = m
return nil
}
func (p *project) captureStructTags(n cc.Node, t cc.Type, m map[cc.StringID]*taggedStruct, tags *[]cc.StringID) {
if t == nil {
return
}
t = t.Alias()
for t.Kind() == cc.Ptr {
t = t.Alias().Elem().Alias()
}
if t.Kind() == cc.Invalid || t.IsIncomplete() {
return
}
switch t.Kind() {
case cc.Struct, cc.Union:
tag := t.Tag()
if tag == 0 {
return
}
ex := m[tag]
if ex != nil {
ts := p.typeSignature(n, t)
exs := p.typeSignature(n, ex.ctyp)
if ts != exs {
ex.conflicts = true
}
return
}
nf := t.NumField()
m[tag] = &taggedStruct{ctyp: t, node: n}
for idx := []int{0}; idx[0] < nf; idx[0]++ {
p.captureStructTags(n, t.FieldByIndex(idx).Type(), m, tags)
}
*tags = append(*tags, tag)
case cc.Array:
p.captureStructTags(n, t.Elem(), m, tags)
}
}
func (p *project) typeSignature(n cc.Node, t cc.Type) (r uint64) {
p.typeSigHash.Reset()
p.typeSignature2(n, &p.typeSigHash, t)
return p.typeSigHash.Sum64()
}
func (p *project) typeSignature2(n cc.Node, b *maphash.Hash, t cc.Type) {
t = t.Alias()
if t.IsIntegerType() {
if !t.IsSignedType() {
b.WriteByte('u')
}
fmt.Fprintf(b, "int%d", t.Size()*8)
return
}
if t.IsArithmeticType() {
b.WriteString(t.Kind().String())
return
}
structOrUnion := "struct"
switch t.Kind() {
case cc.Ptr:
fmt.Fprintf(b, "*%s", t.Elem())
case cc.Array:
if t.IsVLA() {
// trc("VLA")
p.err(n, "variable length arrays not supported: %v", t)
}
fmt.Fprintf(b, "[%d]%s", t.Len(), t.Elem())
case cc.Vector:
fmt.Fprintf(b, "[%d]%s", t.Len(), t.Elem())
case cc.Union:
structOrUnion = "union"
fallthrough
case cc.Struct:
b.WriteString(structOrUnion)
nf := t.NumField()
fmt.Fprintf(b, " %d{", nf)
b.WriteByte('{')
for idx := []int{0}; idx[0] < nf; idx[0]++ {
f := t.FieldByIndex(idx)
fmt.Fprintf(b, "%s:%d:%d:%v:%d:%d:",
f.Name(), f.BitFieldOffset(), f.BitFieldWidth(), f.IsBitField(), f.Offset(), f.Padding(),
)
p.typeSignature2(f.Declarator(), b, f.Type())
b.WriteByte(';')
}
b.WriteByte('}')
case cc.Void:
b.WriteString("void")
case cc.Invalid:
b.WriteString("invalid") //TODO fix cc/v3
default:
panic(todo("", p.pos(n), t, t.Kind()))
}
}
func (p *project) structType(n cc.Node, t cc.Type) string {
switch t.Kind() {
case cc.Struct, cc.Union:
tag := t.Tag()
if tag != 0 && p.structs != nil {
s := p.structs[tag]
if s == nil {
return p.structLiteral(n, t)
}
if s.gotyp == "" {
s.gotyp = p.structLiteral(n, t)
}
return s.gotyp
}
return p.structLiteral(n, t)
default:
panic(todo("internal error: %v", t.Kind()))
}
}
func (p *project) padName(n *int) string {
if !p.task.exportFieldsValid {
return "_"
}
*n++
return fmt.Sprintf("%s__ccgo_pad%d", p.task.exportFields, *n)
}
func (p *project) structLiteral(n cc.Node, t cc.Type) string {
var npad int
b := bytesBufferPool.Get().(*bytes.Buffer)
defer func() { b.Reset(); bytesBufferPool.Put(b) }()
switch t.Kind() {
case cc.Struct:
info := cc.NewStructLayout(t)
// trc("%v: %q\n%s", p.pos(n), t.Tag(), info)
b.WriteString("struct {")
if info.NeedExplicitAlign {
fmt.Fprintf(b, "%s [0]uint%d;", p.padName(&npad), 8*p.align(n, t))
}
var max uintptr
for _, off := range info.Offsets {
flds := info.OffsetToFields[off]
if off < max {
var a []string
var nmf cc.Field
for _, f := range flds {
if f.Name() != 0 && nmf == nil {
nmf = f
}
if !f.IsBitField() {
panic(todo("internal error %q, off %v max %v\n%s", f.Name(), off, max, info))
}
a = append(a, fmt.Sprintf("%s %s: %d", f.Type(), f.Name(), f.BitFieldWidth()))
}
fmt.Fprintf(b, "/* %s */", strings.Join(a, ", "))
continue
}
f := flds[0]
switch pad := info.PaddingsBefore[f]; {
case pad < 0:
continue
case pad > 0:
fmt.Fprintf(b, "%s [%d]byte;", p.padName(&npad), pad)
}
switch {
case f.IsBitField():
max += uintptr(f.BitFieldBlockWidth()) >> 3
var a []string
var nmf cc.Field
for _, f := range flds {
if f.Name() != 0 && nmf == nil {
nmf = f
}
if !f.IsBitField() {
panic(todo("internal error %q\n%s", f.Name(), info))
}
a = append(a, fmt.Sprintf("%s %s: %d", f.Type(), f.Name(), f.BitFieldWidth()))
}
if nmf == nil {
nmf = f
}
fmt.Fprintf(b, "%s uint%d /* %s */;", p.bitFieldName(n, nmf), f.BitFieldBlockWidth(), strings.Join(a, ", "))
default:
ft := f.Type()
if ft.Kind() == cc.Array && ft.IsIncomplete() || ft.Size() == 0 {
break
}
max += ft.Size()
fmt.Fprintf(b, "%s %s;", p.fieldName2(n, f), p.typ(n, ft))
}
}
if info.PaddingAfter != 0 {
fmt.Fprintf(b, "%s [%d]byte;", p.padName(&npad), info.PaddingAfter)
}
b.WriteByte('}')
case cc.Union:
b.WriteString("struct {")
info := cc.NewStructLayout(t)
if info.NeedExplicitAlign {
fmt.Fprintf(b, "%s [0]uint%d;", p.padName(&npad), 8*p.align(n, t))
}
al := uintptr(t.Align())
sz := t.Size()
if al > sz {
panic(todo("", p.pos(n)))
}
f := t.FieldByIndex([]int{0})
ft := f.Type()
al0 := ft.Align()
if f.IsBitField() {
al0 = f.BitFieldBlockWidth() >> 3
}
if al != uintptr(al0) {
fmt.Fprintf(b, "%s [0]uint%d;", p.padName(&npad), 8*al)
}
fsz := ft.Size()
switch {
case f.IsBitField():
fmt.Fprintf(b, "%s ", p.fieldName2(n, f))
fmt.Fprintf(b, "uint%d;", f.BitFieldBlockWidth())
fsz = uintptr(f.BitFieldBlockWidth()) >> 3
default:
fmt.Fprintf(b, "%s %s;", p.fieldName2(n, f), p.typ(n, ft))
}
if pad := sz - fsz; pad != 0 {
fmt.Fprintf(b, "%s [%d]byte;", p.padName(&npad), pad)
}
b.WriteByte('}')
default:
panic(todo("internal error: %v", t.Kind()))
}
r := b.String()
if p.task.verifyStructs {
if _, ok := p.verifyStructs[r]; !ok {
p.verifyStructs[r] = t
}
}
return r
}
func (p *project) align(nd cc.Node, t cc.Type) int {
switch n := t.Align(); {
case n <= 1:
return 1
case n <= 2:
return 2
case n <= 4:
return 4
case n <= 8:
return 8
default:
if !p.task.ignoreUnsupportedAligment {
p.err(nd, "unsupported alignment of type %s: %v", t, n)
}
return 8
}
}
func (p *project) bitFieldName(n cc.Node, f cc.Field) string {
if id := f.Name(); id != 0 {
return p.fieldName(n, id)
}
return fmt.Sprintf("__%d", f.Offset())
}
func (p *project) fieldName2(n cc.Node, f cc.Field) string {
if f.Name() != 0 {
return p.fieldName(n, f.Name())
}
return p.fieldName(n, cc.String(fmt.Sprintf("__%d", f.Offset())))
}
func (p *project) fieldName(n cc.Node, id cc.StringID) string {
if id == 0 {
panic(todo("", p.pos(n)))
}
if !p.task.exportFieldsValid {
s := id.String()
if p.task.defaultUnExport {
s = unCapitalize(s)
}
if !reservedNames[s] {
return s
}
return "__" + s
}
if s := p.task.exportFields; s != "" {
return s + id.String()
}
return capitalize(id.String())
}
func (p *project) dtyp(d *cc.Declarator) (r string) {
t := d.Type()
if t.IsIncomplete() {
if t.Kind() == cc.Array && d.IsParameter {
return "uintptr"
}
panic(todo(""))
}
return p.typ(d, t)
}
func (p *project) typ(nd cc.Node, t cc.Type) (r string) {
if t.IsIncomplete() {
panic(todo("", p.pos(nd), t))
}
if t.IsAliasType() {
if tld := p.tlds[t.AliasDeclarator()]; tld != nil {
return tld.name
}
}
b := bytesBufferPool.Get().(*bytes.Buffer)
defer func() { b.Reset(); bytesBufferPool.Put(b) }()
if t.IsIntegerType() {
switch t.Kind() {
case cc.Int128:
fmt.Fprintf(b, "%sInt128", p.task.crt)
return b.String()
case cc.UInt128:
fmt.Fprintf(b, "%sUint128", p.task.crt)
return b.String()
}
if !t.IsSignedType() {
b.WriteByte('u')
}
if t.Size() > 8 {
p.err(nd, "unsupported C type: %v", t)
}
fmt.Fprintf(b, "int%d", 8*t.Size())
return b.String()
}
switch t.Kind() {
case cc.Ptr, cc.Function:
return "uintptr"
case cc.Double:
return "float64"
case cc.Float:
return "float32"
case cc.Array:
n := t.Len()
switch {
case t.IsVLA():
fmt.Fprintf(b, "uintptr")
default:
fmt.Fprintf(b, "[%d]%s", n, p.typ(nd, t.Elem()))
}
return b.String()
case cc.Vector:
n := t.Len()
fmt.Fprintf(b, "[%d]%s", n, p.typ(nd, t.Elem()))
return b.String()
case cc.Struct, cc.Union:
if tag := t.Tag(); tag != 0 {
if s := p.structs[tag]; s != nil {
if s.name == "" {
panic(todo("internal error %q", tag))
}
return s.name
}
}
return p.structType(nd, t)
}
panic(todo("", p.pos(nd), t.Kind(), t))
}
func isScalarKind(k cc.Kind) bool {
switch k {
case
cc.Char, cc.SChar, cc.UChar,
cc.Short, cc.UShort,
cc.Int, cc.UInt,
cc.Long, cc.ULong,
cc.LongLong, cc.ULongLong,
cc.Float, cc.Double,
cc.Ptr:
return true
}
return false
}
func (p *project) layoutTLDs() error {
var t0 time.Time
if p.task.traceTranslationUnits {
fmt.Printf("processing file scope declarations ... ")
t0 = time.Now()
defer func() { fmt.Println(time.Since(t0)) }()
}
exportExtern, exportTypedef := doNotChange, doNotChange
if p.task.exportExternsValid {
switch {
case p.task.exportExterns != "":
exportExtern = exportPrefix
default:
exportExtern = exportCapitalize
}
} else if p.task.defaultUnExport {
exportExtern = doNotExport
}
if p.task.exportTypedefsValid {
switch {
case p.task.exportTypedefs != "":
exportTypedef = exportPrefix
default:
exportTypedef = exportCapitalize
}
} else if p.task.defaultUnExport {
exportTypedef = doNotExport
}
var a []*cc.Declarator
if p.task.pkgName == "" || p.task.pkgName == "main" {
out:
for _, ast := range p.task.asts {
if a := ast.Scope[idMain]; len(a) != 0 {
switch x := a[0].(type) {
case *cc.Declarator:
if x.Linkage == cc.External {
p.isMain = true
p.scope.take(idMain)
break out
}
}
}
}
}
sharedFns := map[*cc.FunctionDefinition]struct{}{}
for _, ast := range p.task.asts {
a = a[:0]
for d := range ast.TLD {
if d.IsFunctionPrototype() {
continue
}
// https://gcc.gnu.org/onlinedocs/gcc/Inline.html
//
// If you specify both inline and extern in the function definition, then the
// definition is used only for inlining. In no case is the function compiled on
// its own, not even if you refer to its address explicitly. Such an address
// becomes an external reference, as if you had only declared the function, and
// had not defined it.
//
// This combination of inline and extern has almost the effect of a macro. The
// way to use it is to put a function definition in a header file with these
// keywords, and put another copy of the definition (lacking inline and extern)
// in a library file. The definition in the header file causes most calls to
// the function to be inlined. If any uses of the function remain, they refer
// to the single copy in the library.
if d.IsExtern() && d.Type().Inline() {
continue
}
if fn := d.FunctionDefinition(); fn != nil {
if _, ok := p.sharedFns[fn]; ok {
if _, ok := sharedFns[fn]; ok {
continue
}
sharedFns[fn] = struct{}{}
}
}
a = append(a, d)
p.wanted[d] = struct{}{}
}
sort.Slice(a, func(i, j int) bool {
return a[i].NameTok().Seq() < a[j].NameTok().Seq()
})
for _, d := range a {
switch d.Type().Kind() {
case cc.Struct, cc.Union:
p.checkAttributes(d.Type())
}
nm := d.Name()
name := nm.String()
switch d.Linkage {
case cc.External:
if ex := p.externs[nm]; ex != nil {
if _, ok := p.task.hide[name]; ok {
break
}
if d.Type().Kind() != cc.Function {
break
}
p.err(d, "redeclared: %s", d.Name())
break
}
isMain := p.isMain && nm == idMain
switch exportExtern {
case doNotExport:
name = unCapitalize(name)
case doNotChange:
// nop
case exportCapitalize:
name = capitalize(name)
case exportPrefix:
name = p.task.exportExterns + name
}
name = p.scope.take(cc.String(name))
if isMain {
p.mainName = name
d.Read++
}
tld := &tld{name: name}
p.externs[nm] = tld
for _, v := range ast.Scope[nm] {
if d, ok := v.(*cc.Declarator); ok {
p.tlds[d] = tld
}
}
if !isMain {
p.capi = append(p.capi, d.Name().String())
}
case cc.Internal:
if token.IsExported(name) && !p.isMain && p.task.exportExternsValid {
name = "s" + name
}
tld := &tld{name: p.scope.take(cc.String(name))}
for _, v := range ast.Scope[nm] {
if d, ok := v.(*cc.Declarator); ok {
p.tlds[d] = tld
}
}
case cc.None:
if d.IsTypedefName {
if d.Type().IsIncomplete() {
break
}
if exportTypedef == doNotChange && strings.HasPrefix(name, "__") {
break
}
ex, ok := p.typedefTypes[d.Name()]
if ok {
sig := p.typeSignature(d, d.Type())
if ex.sig == sig {
tld := ex.tld
for _, v := range ast.Scope[nm] {
if d, ok := v.(*cc.Declarator); ok {
p.tlds[d] = tld
}
}
break
}
}
switch exportTypedef {
case doNotExport:
name = unCapitalize(name)
case doNotChange:
// nop
case exportCapitalize:
name = capitalize(name)
case exportPrefix:
name = p.task.exportTypedefs + name
}
tld := &tld{name: p.scope.take(cc.String(name))}
p.typedefTypes[d.Name()] = &typedef{p.typeSignature(d, d.Type()), tld}
for _, v := range ast.Scope[nm] {
if d, ok := v.(*cc.Declarator); ok {
p.tlds[d] = tld
}
}
}
default:
panic(todo("", p.pos(d), nm, d.Linkage))
}
}
}
for _, ast := range p.task.asts {
for list := ast.TranslationUnit; list != nil; list = list.TranslationUnit {
decl := list.ExternalDeclaration
switch decl.Case {
case cc.ExternalDeclarationFuncDef: // FunctionDefinition
// ok
default:
continue
}
cc.Inspect(decl.FunctionDefinition.CompoundStatement, func(n cc.Node, entry bool) bool {
switch x := n.(type) {
case *cc.Declarator:
if x.IsFunctionPrototype() {
nm := x.Name()
if extern := p.externs[nm]; extern != nil {
break
}
tld := &tld{name: nm.String()}
for _, nd := range ast.Scope[nm] {
if d, ok := nd.(*cc.Declarator); ok {
p.tlds[d] = tld
}
}
}
}
return true
})
}
}
return nil
}
func (p *project) checkAttributes(t cc.Type) (r bool) {
r = true
for _, v := range t.Attributes() {
cc.Inspect(v, func(n cc.Node, entry bool) bool {
if !entry {
return true
}
switch x := n.(type) {
case *cc.AttributeValue:
if x.Token.Value != idAligned {
break
}
//TODO switch v := x.ExpressionList.AssignmentExpression.Operand.Value().(type) {
//TODO default:
//TODO panic(todo("%T(%v)", v, v))
//TODO }
}
return true
})
}
switch t.Kind() {
case cc.Struct, cc.Union:
for i := []int{0}; i[0] < t.NumField(); i[0]++ {
f := t.FieldByIndex(i)
if !p.checkAttributes(f.Type()) {
return false
}
sd := f.Declarator()
if sd == nil {
continue
}
cc.Inspect(sd.StructDeclaration().SpecifierQualifierList, func(n cc.Node, entry bool) bool {
if !entry {
return true
}
switch x := n.(type) {
case *cc.AttributeValue:
if x.Token.Value == idPacked {
p.err(sd, "unsupported attribute: packed")
r = false
return false
}
if x.Token.Value != idAligned {
break
}
switch v := x.ExpressionList.AssignmentExpression.Operand.Value().(type) {
case cc.Int64Value:
if int(v) != t.Align() {
p.err(sd, "unsupported attribute: alignment")
r = false
return false
}
default:
panic(todo("%T(%v)", v, v))
}
}
return true
})
if !r {
return false
}
}
}
return r
}
func unCapitalize(s string) string {
if strings.HasPrefix(s, "_") {
return s
}
a := []rune(s)
return strings.ToLower(string(a[0])) + string(a[1:])
}
func capitalize(s string) string {
if strings.HasPrefix(s, "_") {
s = "X" + s
}
a := []rune(s)
return strings.ToUpper(string(a[0])) + string(a[1:])
}
func (p *project) main() error {
targs := append([]string(nil), p.task.args...)
for i, v := range targs {
if v == "" {
targs[i] = `""`
}
}
p.o(`// Code generated by '%s %s', DO NOT EDIT.
package %s
`,
filepath.Base(p.task.args[0]),
strings.Join(targs[1:], " "),
p.task.pkgName,
)
if len(p.defineLines) != 0 {
p.w("\nconst (")
p.w("%s", strings.Join(p.defineLines, "\n"))
p.w("\n)\n\n")
}
var a []*enumSpec
for _, es := range p.enumSpecs {
if es.spec.LexicalScope().Parent() == nil && !es.emitted {
a = append(a, es)
}
}
sort.Slice(a, func(i, j int) bool {
return a[i].decl.Position().String() < a[j].decl.Position().String()
})
for _, es := range a {
es.emit(p)
}
for i, v := range p.task.asts {
var t0 time.Time
if p.task.traceTranslationUnits {
fmt.Printf("Go back end %v/%v: %s ... ", i+1, len(p.task.asts), filepath.Base(p.task.sources[i].Name))
t0 = time.Now()
}
p.oneAST(v)
if p.task.traceTranslationUnits {
fmt.Println(time.Since(t0))
}
p.task.asts[i] = nil
memGuard(i, p.task.isScripted)
}
sort.Slice(p.task.imported, func(i, j int) bool { return p.task.imported[i].path < p.task.imported[j].path })
p.o(`import (
"math"
"reflect"
"sync/atomic"
"unsafe"
`)
if len(p.verifyStructs) != 0 {
p.o("\t\"fmt\"\n")
}
first := true
libc := false
for _, v := range p.task.imported {
if v.used {
if v.path == p.task.crtImportPath {
libc = true
}
if first {
p.o("\n")
first = false
}
p.o("\t%q\n", v.path)
}
}
if p.task.crtImportPath != "" {
if !libc {
p.o("\t%q\n", p.task.crtImportPath)
}
p.o("\t%q\n", p.task.crtImportPath+"/sys/types")
}
p.o(`)
var _ = math.Pi
var _ reflect.Kind
var _ atomic.Value
var _ unsafe.Pointer
`)
if p.task.crtImportPath != "" {
if libc {
p.o("var _ *libc.TLS\n")
}
p.o("var _ types.Size_t\n")
}
if p.isMain {
p.o(`
func main() { %sStart(%s) }`, p.task.crt, p.mainName)
}
p.flushStructs()
p.initPatches()
p.flushTS()
if !p.task.noCapi {
p.flushCAPI()
}
p.doVerifyStructs()
if err := p.Err(); err != nil {
return err
}
if _, err := p.buf.WriteTo(p.task.out); err != nil {
return err
}
return p.Err()
}
func (p *project) doVerifyStructs() {
if len(p.verifyStructs) == 0 {
return
}
var a []string
for k := range p.verifyStructs {
a = append(a, k)
}
sort.Strings(a)
p.w("\n\nfunc init() {")
n := 0
for _, k := range a {
t := p.verifyStructs[k]
p.w("\nvar v%d %s", n, k)
p.w("\nif g, e := unsafe.Sizeof(v%d), uintptr(%d); g != e { panic(fmt.Sprintf(`invalid struct/union size, got %%v, expected %%v`, g, e))}", n, t.Size())
nf := t.NumField()
for idx := []int{0}; idx[0] < nf; idx[0]++ {
f := t.FieldByIndex(idx)
if f.IsFlexible() {
break
}
if f.IsBitField() || f.Type().Size() == 0 {
continue
}
nm := p.fieldName2(f.Declarator(), f)
switch {
case t.Kind() == cc.Union:
if f.Offset() != 0 {
panic(todo(""))
}
if idx[0] != 0 {
break
}
fallthrough
default:
p.w("\nif g, e := unsafe.Offsetof(v%d.%s), uintptr(%d); g != e { panic(fmt.Sprintf(`invalid struct/union field offset, got %%v, expected %%v`, g, e))}", n, nm, f.Offset())
p.w("\nif g, e := unsafe.Sizeof(v%d.%s), uintptr(%d); g != e { panic(fmt.Sprintf(`invalid struct/union field size, got %%v, expected %%v`, g, e))}", n, nm, f.Type().Size())
}
}
n++
}
p.w("\n}\n")
}
func (p *project) flushCAPI() {
if p.isMain {
return
}
b := bytes.NewBuffer(nil)
fmt.Fprintf(b, `// Code generated by '%s %s', DO NOT EDIT.
package %s
`,
filepath.Base(p.task.args[0]),
strings.Join(p.task.args[1:], " "),
p.task.pkgName,
)
fmt.Fprintf(b, "\n\nvar CAPI = map[string]struct{}{")
sort.Strings(p.capi)
for _, nm := range p.capi {
fmt.Fprintf(b, "\n%q: {},", nm)
}
fmt.Fprintf(b, "\n}\n")
if err := ioutil.WriteFile(p.task.capif, b.Bytes(), 0644); err != nil {
p.err(nil, "%v", err)
return
}
if out, err := exec.Command("gofmt", "-r", "(x) -> x", "-l", "-s", "-w", p.task.capif).CombinedOutput(); err != nil {
p.err(nil, "%s: %v", out, err)
}
if out, err := exec.Command("gofmt", "-l", "-s", "-w", p.task.capif).CombinedOutput(); err != nil {
p.err(nil, "%s: %v", out, err)
}
}
func (p *project) initPatches() {
var tlds []*tld
for _, tld := range p.tlds {
if len(tld.patches) != 0 {
tlds = append(tlds, tld)
}
}
if len(tlds) == 0 {
return
}
sort.Slice(tlds, func(i, j int) bool { return tlds[i].name < tlds[j].name })
p.w("\n\nfunc init() {")
for _, tld := range tlds {
for _, patch := range tld.patches {
var fld string
if patch.fld != nil {
fld = fmt.Sprintf("/* .%s */", patch.fld.Name())
}
init := patch.init
expr := init.AssignmentExpression
d := expr.Declarator()
switch {
case d != nil && d.Type().Kind() == cc.Function:
p.w("\n*(*")
p.functionSignature(d, nil, d.Type(), "")
p.w(")(unsafe.Pointer(uintptr(unsafe.Pointer(&%s))+%d%s)) = ", tld.name, init.Offset, fld)
p.declarator(init, nil, d, d.Type(), exprFunc, 0)
default:
p.w("\n*(*%s)(unsafe.Pointer(uintptr(unsafe.Pointer(&%s))+%d%s)) = ", p.typ(init, patch.t), tld.name, init.Offset, fld)
p.assignmentExpression(nil, expr, patch.t, exprValue, 0)
}
p.w("// %s:", p.pos(init))
}
}
p.w("\n}\n")
}
func (p *project) Err() error {
if len(p.errors) == 0 {
return nil
}
var lpos token.Position
w := 0
for _, v := range p.errors {
if lpos.Filename != "" {
if v.Pos.Filename == lpos.Filename && v.Pos.Line == lpos.Line && !strings.HasPrefix(v.Msg, tooManyErrors) {
continue
}
}
p.errors[w] = v
w++
lpos = v.Pos
}
p.errors = p.errors[:w]
sort.Slice(p.errors, func(i, j int) bool {
a := p.errors[i]
if a.Msg == tooManyErrors {
return false
}
b := p.errors[j]
if b.Msg == tooManyErrors {
return true
}
if !a.Pos.IsValid() && b.Pos.IsValid() {
return true
}
if a.Pos.IsValid() && !b.Pos.IsValid() {
return false
}
if a.Pos.Filename < b.Pos.Filename {
return true
}
if a.Pos.Filename > b.Pos.Filename {
return false
}
if a.Pos.Line < b.Pos.Line {
return true
}
if a.Pos.Line > b.Pos.Line {
return false
}
return a.Pos.Column < b.Pos.Column
})
a := make([]string, 0, len(p.errors))
for _, v := range p.errors {
a = append(a, v.Error())
}
return fmt.Errorf("%s", strings.Join(a, "\n"))
}
func (p *project) flushTS() {
b := p.ts.Bytes()
if len(b) != 0 {
p.w("\n\n")
//TODO add cmd line option for this
//TODO s := strings.TrimSpace(hex.Dump(b))
//TODO a := strings.Split(s, "\n")
//TODO p.w("// %s\n", strings.Join(a, "\n// "))
p.w("var %s = %q\n", p.tsName, b)
p.w("var %s = (*reflect.StringHeader)(unsafe.Pointer(&%s)).Data\n", p.tsNameP, p.tsName)
}
if len(p.tsW) != 0 {
p.w("var %s = [...]%s{", p.tsWName, p.typ(nil, p.ast.WideCharType))
for _, v := range p.tsW {
p.w("%d, ", v)
}
p.w("}\n")
p.w("var %s = uintptr(unsafe.Pointer(&%s[0]))\n", p.tsWNameP, p.tsWName)
}
}
func (p *project) flushStructs() {
var a []*taggedStruct
for _, v := range p.structs {
if !v.emitted {
a = append(a, v)
}
}
sort.Slice(a, func(i, j int) bool { return a[i].name < a[j].name })
for _, v := range a {
v.emit(p, nil)
}
}
func (p *project) oneAST(ast *cc.AST) {
p.ast = ast
for list := ast.TranslationUnit; list != nil; list = list.TranslationUnit {
p.externalDeclaration(list.ExternalDeclaration)
}
p.w("%s", tidyCommentString(ast.TrailingSeperator.String()))
}
func (p *project) externalDeclaration(n *cc.ExternalDeclaration) {
switch n.Case {
case cc.ExternalDeclarationFuncDef: // FunctionDefinition
p.functionDefinition(n.FunctionDefinition)
case cc.ExternalDeclarationDecl: // Declaration
p.declaration(nil, n.Declaration, false)
case cc.ExternalDeclarationAsm: // AsmFunctionDefinition
// nop
case cc.ExternalDeclarationAsmStmt: // AsmStatement
panic(todo("", p.pos(n)))
case cc.ExternalDeclarationEmpty: // ';'
// nop
case cc.ExternalDeclarationPragma: // PragmaSTDC
panic(todo("", p.pos(n)))
default:
panic(todo("%v: internal error: %v", n.Position(), n.Case))
}
}
func (p *project) declaration(f *function, n *cc.Declaration, topDecl bool) {
cc.Inspect(n.DeclarationSpecifiers, func(m cc.Node, entry bool) bool {
switch x := m.(type) {
case *cc.EnumSpecifier:
if f == nil {
p.enumSpecs[x].emit(p)
}
case *cc.StructOrUnionSpecifier:
if tag := x.Token.Value; tag != 0 {
switch {
case f == nil:
p.structs[tag].emit(p, n.DeclarationSpecifiers)
default:
p.localTaggedStructs = append(p.localTaggedStructs, func() {
p.structs[tag].emit(p, n.DeclarationSpecifiers)
})
}
}
}
return true
})
if n.InitDeclaratorList == nil {
return
}
// DeclarationSpecifiers InitDeclaratorList ';'
sep := tidyComment("\n", n) //TODO repeats
for list := n.InitDeclaratorList; list != nil; list = list.InitDeclaratorList {
p.initDeclarator(f, list.InitDeclarator, sep, topDecl)
sep = "\n"
}
}
func (p *project) initDeclarator(f *function, n *cc.InitDeclarator, sep string, topDecl bool) {
if f == nil {
p.tld(f, n, sep, false)
return
}
d := n.Declarator
if d.IsExtern() || d.IsTypedefName {
return
}
if tld := p.tlds[d]; tld != nil && !topDecl { // static local
if !p.pass1 {
p.staticQueue = append(p.staticQueue, n)
}
return
}
local := f.locals[d]
if local == nil { // Dead declaration.
return
}
block := f.block
t := d.Type()
vla := t.Kind() == cc.Array && t.IsVLA()
if vla && p.pass1 {
f.vlas[d] = struct{}{}
return
}
switch n.Case {
case cc.InitDeclaratorDecl: // Declarator AttributeSpecifierList
if block.noDecl || block.topDecl && !topDecl {
return
}
switch {
case vla:
p.initDeclaratorDeclVLA(f, n, sep)
default:
p.initDeclaratorDecl(f, n, sep)
}
case cc.InitDeclaratorInit: // Declarator AttributeSpecifierList '=' Initializer
if vla {
panic(todo(""))
}
if f.block.topDecl {
switch {
case topDecl:
p.initDeclaratorDecl(f, n, sep)
if local.forceRead && !local.isPinned {
p.w("_ = %s;", local.name)
}
default:
sv := f.condInitPrefix
f.condInitPrefix = func() {
p.declarator(d, f, d, d.Type(), exprLValue, 0)
p.w(" = ")
}
switch {
case p.isConditionalInitializer(n.Initializer):
p.assignmentExpression(f, n.Initializer.AssignmentExpression, d.Type(), exprCondInit, 0)
default:
f.condInitPrefix()
p.initializer(f, n.Initializer, d.Type(), d.StorageClass, nil)
}
f.condInitPrefix = sv
p.w(";")
}
return
}
p.w("%s", sep)
switch {
case local.isPinned:
sv := f.condInitPrefix
f.condInitPrefix = func() {
//TODO- p.declarator(d, f, d, d.Type(), exprLValue, 0)
//TODO- p.w(" = ")
p.w("*(*%s)(unsafe.Pointer(%s%s/* %s */)) = ", p.typ(n, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name)
}
switch {
case p.isConditionalInitializer(n.Initializer):
p.assignmentExpression(f, n.Initializer.AssignmentExpression, d.Type(), exprCondInit, 0)
default:
f.condInitPrefix()
p.initializer(f, n.Initializer, d.Type(), d.StorageClass, nil)
p.w(";")
}
f.condInitPrefix = sv
p.w(";")
default:
var semi string
switch {
case block.noDecl:
semi = ""
default:
p.w("var %s ", local.name)
if !isAggregateTypeOrUnion(d.Type()) {
p.w("%s ", p.typ(n, d.Type()))
}
semi = ";"
}
switch {
case p.isConditionalInitializer(n.Initializer):
p.w("%s", semi)
sv := f.condInitPrefix
f.condInitPrefix = func() { p.w("%s = ", local.name) }
p.assignmentExpression(f, n.Initializer.AssignmentExpression, d.Type(), exprCondInit, 0)
f.condInitPrefix = sv
default:
if block.noDecl {
p.w("%s", local.name)
}
p.w(" = ")
p.initializer(f, n.Initializer, d.Type(), d.StorageClass, nil)
}
p.w(";")
}
default:
panic(todo("%v: internal error: %v", n.Position(), n.Case))
}
if !block.noDecl && local.forceRead && !local.isPinned {
p.w("_ = %s;", local.name)
}
}
func (p *project) isConditionalInitializer(n *cc.Initializer) bool {
return n.Case == cc.InitializerExpr && p.isConditionalAssignmentExpr(n.AssignmentExpression)
}
func (p *project) isConditionalAssignmentExpr(n *cc.AssignmentExpression) bool {
return n.Case == cc.AssignmentExpressionCond &&
n.ConditionalExpression.Case == cc.ConditionalExpressionCond
}
func (p *project) initDeclaratorDeclVLA(f *function, n *cc.InitDeclarator, sep string) {
d := n.Declarator
local := f.locals[d]
if strings.TrimSpace(sep) == "" {
sep = "\n"
}
if local.isPinned {
panic(todo(""))
p.w("%s// var %s %s at %s%s, %d\n", sep, local.name, p.typ(n, d.Type()), f.bpName, nonZeroUintptr(local.off), d.Type().Size())
return
}
p.w("%s%s = %sXrealloc(%s, %s, types.Size_t(", sep, local.name, p.task.crt, f.tlsName, local.name)
e := d.Type().LenExpr()
p.assignmentExpression(f, e, e.Operand.Type(), exprValue, 0)
if sz := d.Type().Elem().Size(); sz != 1 {
p.w("*%d", sz)
}
p.w("));")
}
func (p *project) initDeclaratorDecl(f *function, n *cc.InitDeclarator, sep string) {
d := n.Declarator
local := f.locals[d]
if strings.TrimSpace(sep) == "" {
sep = "\n"
}
if local.isPinned {
p.w("%s// var %s %s at %s%s, %d\n", sep, local.name, p.typ(n, d.Type()), f.bpName, nonZeroUintptr(local.off), d.Type().Size())
return
}
p.w("%svar %s %s;", sep, local.name, p.typ(n, d.Type()))
}
func (p *project) declarator(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
switch mode {
case exprLValue:
p.declaratorLValue(n, f, d, t, mode, flags)
case exprFunc:
p.declaratorFunc(n, f, d, t, mode, flags)
case exprValue:
p.declaratorValue(n, f, d, t, mode, flags)
case exprAddrOf:
p.declaratorAddrOf(n, f, d, t, flags)
case exprSelect:
p.declaratorSelect(n, f, d)
case exprDecay:
p.declaratorDecay(n, f, d, t, mode, flags)
default:
panic(todo("", mode))
}
}
func (p *project) declaratorDecay(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
if d.Type().Kind() != cc.Array {
panic(todo("", n.Position(), p.pos(d)))
}
if f != nil {
if local := f.locals[d]; local != nil {
if d.Type().IsVLA() {
switch {
case local.isPinned:
panic(todo(""))
default:
p.w("%s", local.name)
return
}
}
if d.IsParameter {
p.w("%s", local.name)
return
}
if p.pass1 {
if !d.Type().IsVLA() {
f.pin(n, d)
}
return
}
if !local.isPinned {
p.err(n, "%v: %v: missed pinning", n.Position(), d.Position(), d.Name())
}
p.w("(%s%s)/* &%s[0] */", f.bpName, nonZeroUintptr(local.off), local.name)
return
}
}
if x := p.tlds[d]; x != nil && d.IsStatic() {
p.w("uintptr(unsafe.Pointer(&%s))", x.name)
return
}
switch x := p.symtab[d.Name().String()].(type) {
case *tld:
p.w("uintptr(unsafe.Pointer(&%s))", x.name)
case *imported:
x.used = true
p.w("uintptr(unsafe.Pointer(&%sX%s))", x.qualifier, d.Name())
default:
panic(todo("%v: %v: %q %T", n.Position(), p.pos(d), d.Name(), x))
}
}
func (p *project) declaratorValue(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
switch k := p.declaratorKind(d); k {
case opNormal:
p.declaratorValueNormal(n, f, d, t, mode, flags)
case opArray:
p.declaratorValueArray(n, f, d, t, mode, flags)
case opFunction:
p.declarator(n, f, d, t, exprAddrOf, flags)
case opUnion:
p.declaratorValueUnion(n, f, d, t, mode, flags)
case opArrayParameter:
p.declaratorValueArrayParameter(n, f, d, t, mode, flags)
default:
panic(todo("", d.Position(), k))
}
}
func (p *project) declaratorValueArrayParameter(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
if d.Type().IsScalarType() {
defer p.w("%s", p.convertType(n, d.Type(), t, flags))
}
local := f.locals[d]
if local.isPinned {
p.w("*(*%s)(unsafe.Pointer(%s%s/* %s */))", p.typ(n, paramTypeDecay(d)), f.bpName, nonZeroUintptr(local.off), local.name)
return
}
p.w("%s", local.name)
}
func (p *project) declaratorValueUnion(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
if d.Type().IsScalarType() {
defer p.w("%s", p.convertType(n, d.Type(), t, flags))
}
if f != nil {
if local := f.locals[d]; local != nil {
if local.isPinned {
p.w("*(*%s)(unsafe.Pointer(%s%s/* %s */))", p.typ(d, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name)
return
}
p.w("%s", local.name)
return
}
}
p.declaratorDefault(n, d)
}
func (p *project) isVolatileOrAtomic(d *cc.Declarator) bool {
if d.Type().IsVolatile() || d.Type().IsAtomic() {
return true
}
_, ok := p.task.volatiles[d.Name()]
return ok
}
func (p *project) declaratorDefault(n cc.Node, d *cc.Declarator) {
if x := p.tlds[d]; x != nil && d.IsStatic() {
if p.isVolatileOrAtomic(d) {
p.atomicLoadNamedAddr(n, d.Type(), x.name)
return
}
p.w("%s", x.name)
return
}
switch x := p.symtab[d.Name().String()].(type) {
case *tld:
if p.isVolatileOrAtomic(d) {
p.atomicLoadNamedAddr(n, d.Type(), x.name)
return
}
p.w("%s", x.name)
case *imported:
x.used = true
if p.isVolatileOrAtomic(d) {
p.atomicLoadNamedAddr(n, d.Type(), fmt.Sprintf("%sX%s", x.qualifier, d.Name()))
return
}
p.w("%sX%s", x.qualifier, d.Name())
default:
if d.IsExtern() {
switch d.Name() {
case idEnviron:
if d.Type().String() == "pointer to pointer to char" {
p.w("%sEnviron()", p.task.crt)
return
}
}
}
if d.Linkage == cc.External && p.task.nostdlib {
p.w("X%s", d.Name())
return
}
id := fmt.Sprintf("__builtin_%s", d.Name())
switch x := p.symtab[id].(type) {
case *imported:
x.used = true
p.w("%sX%s", x.qualifier, d.Name())
return
}
if !d.IsImplicit() {
nm := d.Name()
name := nm.String()
switch d.Linkage {
case cc.External:
name = p.task.exportExterns + name
tld := &tld{name: name}
p.externs[nm] = tld
p.w("%s", name)
return
case cc.Internal:
if token.IsExported(name) {
name = "s" + name
}
tld := &tld{name: p.scope.take(cc.String(name))}
for _, v := range p.ast.Scope[nm] {
if d, ok := v.(*cc.Declarator); ok {
p.tlds[d] = tld
}
}
p.w("%s", name)
return
}
}
p.err(n, "back-end: undefined: %s", d.Name())
}
}
func (p *project) declaratorValueArray(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
if t.IsIntegerType() {
defer p.w("%s", p.convertType(n, nil, t, flags))
}
if f != nil {
if local := f.locals[d]; local != nil {
if local.isPinned {
p.w("(%s%s)/* %s */", f.bpName, nonZeroUintptr(local.off), local.name)
return
}
p.w("%s", local.name)
return
}
}
p.declaratorDefault(n, d)
}
func (p *project) declaratorValueNormal(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
if d.Type().IsScalarType() {
defer p.w("%s", p.convertType(n, d.Type(), t, flags))
}
if f != nil {
if local := f.locals[d]; local != nil {
if local.isPinned {
if p.isVolatileOrAtomic(d) && d.IsParameter && d.Write != 0 {
p.w("%sAtomicLoadP%s(%s%s/* %s */)", p.task.crt, p.helperType(n, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name)
return
}
p.w("*(*%s)(unsafe.Pointer(%s%s/* %s */))", p.typ(d, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name)
return
}
if p.isVolatileOrAtomic(d) && d.IsParameter && d.Write != 0 {
p.atomicLoadNamedAddr(n, d.Type(), local.name)
return
}
p.w("%s", local.name)
return
}
}
p.declaratorDefault(n, d)
}
func (p *project) declaratorFunc(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
switch k := p.declaratorKind(d); k {
case opFunction:
p.declaratorFuncFunc(n, f, d, t, exprValue, flags)
case opNormal:
p.declaratorFuncNormal(n, f, d, t, exprValue, flags)
default:
panic(todo("", d.Position(), k))
}
}
func (p *project) declaratorFuncNormal(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
u := d.Type()
if u.Kind() == cc.Ptr {
u = u.Elem()
}
switch u.Kind() {
case cc.Function:
if local := f.locals[d]; local != nil {
if local.isPinned {
p.w("(*(*")
p.functionSignature(n, f, u, "")
p.w(")(unsafe.Pointer(%s%s)))", f.bpName, nonZeroUintptr(local.off))
return
}
if d.IsParameter {
p.w("(*(*")
p.functionSignature(n, f, u, "")
p.w(")(unsafe.Pointer(&%s)))", local.name)
return
}
panic(todo("", p.pos(d)))
}
if x := p.tlds[d]; x != nil && d.IsStatic() {
p.w("(*(*")
p.functionSignature(n, f, u, "")
p.w(")(unsafe.Pointer(&%s)))", x.name)
return
}
switch x := p.symtab[d.Name().String()].(type) {
case *tld:
p.w("(*(*")
p.functionSignature(n, f, u, "")
p.w(")(unsafe.Pointer(&%s)))", x.name)
case *imported:
x.used = true
p.w("uintptr(unsafe.Pointer(&%sX%s))", x.qualifier, d.Name())
default:
panic(todo("%v: %v: %q", n.Position(), p.pos(d), d.Name()))
}
default:
panic(todo("", p.pos(d), u))
}
}
func (p *project) declaratorFuncFunc(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
switch d.Type().Kind() {
case cc.Function:
// ok
default:
panic(todo("", p.pos(d), d.Type(), d.Type().Kind()))
}
if f != nil {
if local := f.locals[d]; local != nil {
if local.isPinned {
panic(todo(""))
}
p.w(" %s", local.name)
return
}
}
p.declaratorDefault(n, d)
}
func (p *project) declaratorLValue(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
switch k := p.declaratorKind(d); k {
case opNormal, opArrayParameter, opUnion:
p.declaratorLValueNormal(n, f, d, t, mode, flags)
case opArray:
p.declaratorLValueArray(n, f, d, t, mode, flags)
default:
panic(todo("", d.Position(), k))
}
}
func (p *project) declaratorLValueArray(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
if f != nil {
if local := f.locals[d]; local != nil {
if local.isPinned {
p.w("*(*%s)(unsafe.Pointer(%s%s/* %s */))", p.typ(d, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name)
return
}
p.w("%s", local.name)
return
}
}
p.declaratorDefault(n, d)
}
func (p *project) declaratorLValueNormal(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
if p.isVolatileOrAtomic(d) {
panic(todo("", n.Position(), d.Position()))
}
if d.Type().IsScalarType() {
defer p.w("%s", p.convertType(n, d.Type(), t, flags))
}
if f != nil {
if local := f.locals[d]; local != nil {
if local.isPinned {
p.w("*(*%s)(unsafe.Pointer(%s%s/* %s */))", p.dtyp(d), f.bpName, nonZeroUintptr(local.off), local.name)
return
}
p.w("%s", local.name)
return
}
}
p.declaratorLValueDefault(n, d)
}
func (p *project) declaratorLValueDefault(n cc.Node, d *cc.Declarator) {
if x := p.tlds[d]; x != nil && d.IsStatic() {
p.w("%s", x.name)
return
}
switch x := p.symtab[d.Name().String()].(type) {
case *tld:
p.w("%s", x.name)
case *imported:
x.used = true
p.w("%sX%s", x.qualifier, d.Name())
default:
if d.IsExtern() {
switch d.Name() {
case idEnviron:
if d.Type().String() == "pointer to pointer to char" {
p.w("*(*uintptr)(unsafe.Pointer(%sEnvironP()))", p.task.crt)
return
}
}
}
panic(todo("%v: %v: %q", n.Position(), p.pos(d), d.Name()))
}
}
func (p *project) declaratorKind(d *cc.Declarator) opKind {
switch {
case p.isArrayParameterDeclarator(d):
return opArrayParameter
case !p.pass1 && p.isArrayDeclarator(d):
return opArray
case d.Type().Kind() == cc.Function && !d.IsParameter:
return opFunction
case d.Type().Kind() == cc.Union:
return opUnion
default:
return opNormal
}
}
func (p *project) declaratorSelect(n cc.Node, f *function, d *cc.Declarator) {
switch k := p.declaratorKind(d); k {
case opNormal:
p.declaratorSelectNormal(n, f, d)
case opArray:
p.declaratorSelectArray(n, f, d)
default:
panic(todo("", d.Position(), k))
}
}
func (p *project) declaratorSelectArray(n cc.Node, f *function, d *cc.Declarator) {
if local := f.locals[d]; local != nil {
if local.isPinned {
panic(todo("", p.pos(n)))
//TODO type error
p.w("(*%s)(unsafe.Pointer(%s%s/* &%s */))", p.typ(d, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name)
return
}
p.w("%s", local.name)
return
}
p.declaratorDefault(n, d)
}
func (p *project) declaratorSelectNormal(n cc.Node, f *function, d *cc.Declarator) {
if local := f.locals[d]; local != nil {
if local.isPinned {
p.w("(*%s)(unsafe.Pointer(%s%s/* &%s */))", p.typ(d, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name)
return
}
p.w("%s", local.name)
return
}
p.declaratorDefault(n, d)
}
func (p *project) declaratorAddrOf(n cc.Node, f *function, d *cc.Declarator, t cc.Type, flags flags) {
switch k := p.declaratorKind(d); k {
case opArray:
p.declaratorAddrOfArray(n, f, d)
case opNormal:
p.declaratorAddrOfNormal(n, f, d, flags)
case opUnion:
p.declaratorAddrOfUnion(n, f, d)
case opFunction:
p.declaratorAddrOfFunction(n, f, d)
case opArrayParameter:
p.declaratorAddrOfArrayParameter(n, f, d)
default:
panic(todo("", d.Position(), k))
}
}
func (p *project) declaratorAddrOfArrayParameter(n cc.Node, f *function, d *cc.Declarator) {
if p.pass1 {
f.pin(n, d)
return
}
local := f.locals[d]
p.w("(%s%s)/* &%s */", f.bpName, nonZeroUintptr(local.off), local.name)
}
func (p *project) declaratorAddrOfFunction(n cc.Node, f *function, d *cc.Declarator) {
if d.Type().Kind() != cc.Function {
panic(todo("", p.pos(n)))
}
if x := p.tlds[d]; x != nil && d.IsStatic() {
p.w("*(*uintptr)(unsafe.Pointer(&struct{f ")
p.functionSignature(n, f, d.Type(), "")
p.w("}{%s}))", x.name)
return
}
switch x := p.symtab[d.Name().String()].(type) {
case *tld:
p.w("*(*uintptr)(unsafe.Pointer(&struct{f ")
p.functionSignature(n, f, d.Type(), "")
p.w("}{%s}))", x.name)
case *imported:
x.used = true
p.w("*(*uintptr)(unsafe.Pointer(&struct{f ")
p.functionSignature(n, f, d.Type(), "")
p.w("}{%sX%s}))", x.qualifier, d.Name())
default:
p.err(d, "back-end: undefined: %s", d.Name())
}
}
func (p *project) declaratorAddrOfUnion(n cc.Node, f *function, d *cc.Declarator) {
if f != nil {
if local := f.locals[d]; local != nil {
if p.pass1 {
f.pin(n, d)
return
}
if local.isPinned {
p.w("(%s%s)/* &%s */", f.bpName, nonZeroUintptr(local.off), local.name)
return
}
panic(todo("", p.pos(n)))
}
}
if x := p.tlds[d]; x != nil && d.IsStatic() {
p.w("uintptr(unsafe.Pointer(&%s))", x.name)
return
}
switch x := p.symtab[d.Name().String()].(type) {
case *tld:
p.w("uintptr(unsafe.Pointer(&%s))", x.name)
case *imported:
x.used = true
p.w("uintptr(unsafe.Pointer(&%sX%s))", x.qualifier, d.Name())
default:
panic(todo("%v: %v: %q", n.Position(), p.pos(d), d.Name()))
}
}
func (p *project) declaratorAddrOfNormal(n cc.Node, f *function, d *cc.Declarator, flags flags) {
if f != nil {
if local := f.locals[d]; local != nil {
if p.pass1 && flags&fAddrOfFuncPtrOk == 0 {
f.pin(n, d)
return
}
if local.isPinned {
p.w("(%s%s)/* &%s */", f.bpName, nonZeroUintptr(local.off), local.name)
return
}
if flags&fAddrOfFuncPtrOk != 0 {
if dt := d.Type(); dt.Kind() == cc.Ptr {
if elem := dt.Elem(); elem.Kind() == cc.Function || elem.Kind() == cc.Ptr && elem.Elem().Kind() == cc.Function {
p.w("&%s", local.name)
return
}
}
}
panic(todo("", p.pos(n), p.pos(d), d.Name(), d.Type(), d.IsParameter, d.AddressTaken, flags&fAddrOfFuncPtrOk != 0))
}
}
if x := p.tlds[d]; x != nil && d.IsStatic() {
p.w("uintptr(unsafe.Pointer(&%s))", x.name)
return
}
switch x := p.symtab[d.Name().String()].(type) {
case *tld:
p.w("uintptr(unsafe.Pointer(&%s))", x.name)
case *imported:
x.used = true
p.w("uintptr(unsafe.Pointer(&%sX%s))", x.qualifier, d.Name())
default:
p.err(n, "undefined: %s", d.Name())
}
}
func (p *project) declaratorAddrOfArray(n cc.Node, f *function, d *cc.Declarator) {
if f != nil {
if local := f.locals[d]; local != nil {
if p.pass1 {
f.pin(n, d)
return
}
if local.isPinned {
p.w("(%s%s)/* &%s */", f.bpName, nonZeroUintptr(local.off), local.name)
return
}
panic(todo("", p.pos(d), d.Name(), d.Type(), d.IsParameter))
}
}
if x := p.tlds[d]; x != nil && d.IsStatic() {
p.w("uintptr(unsafe.Pointer(&%s))", x.name)
return
}
switch x := p.symtab[d.Name().String()].(type) {
case *tld:
p.w("uintptr(unsafe.Pointer(&%s))", x.name)
case *imported:
x.used = true
p.w("uintptr(unsafe.Pointer(&%sX%s))", x.qualifier, d.Name())
default:
panic(todo("%v: %v: %q", n.Position(), p.pos(d), d.Name()))
}
}
func (p *project) convertType(n cc.Node, from, to cc.Type, flags flags) string {
// trc("%v: %v: %v -> %v %v", n.Position(), origin(1), from, to, flags) //TODO- DBG
if from != nil {
switch from.Kind() {
case cc.Int128:
return p.convertTypeFromInt128(n, to, flags)
case cc.UInt128:
return p.convertTypeFromUint128(n, to, flags)
}
}
switch to.Kind() {
case cc.Int128:
return p.convertTypeToInt128(n, from, flags)
case cc.UInt128:
return p.convertTypeToUint128(n, from, flags)
}
// trc("%v: %v -> %v\n%s", p.pos(n), from, to, debug.Stack()[:600]) //TODO-
force := flags&fForceConv != 0
if from == nil {
p.w("%s(", p.typ(n, to))
return ")"
}
if from.IsScalarType() {
switch {
case force:
p.w("%s(", p.helperType2(n, from, to))
return ")"
case from.Kind() == to.Kind():
return ""
default:
p.w("%s(", p.typ(n, to))
return ")"
}
}
switch from.Kind() {
case cc.Function, cc.Struct, cc.Union, cc.Ptr, cc.Array:
if from.Kind() == to.Kind() {
return ""
}
panic(todo("", n.Position(), from, to, from.Alias(), to.Alias()))
case cc.Double, cc.Float:
p.w("%s(", p.typ(n, to))
return ")"
}
panic(todo("", n.Position(), from, to, from.Alias(), to.Alias()))
}
func (p *project) convertTypeFromInt128(n cc.Node, to cc.Type, flags flags) string {
switch k := to.Kind(); {
case k == cc.Float, k == cc.Double:
p.w("(")
return fmt.Sprintf(").Float%d()", to.Size()*8)
case k == cc.Int128:
return ""
case k == cc.UInt128:
p.w("%sUint128FromInt128(", p.task.crt)
return ")"
case to.IsIntegerType() && to.IsSignedType():
p.w("int%d((", to.Size()*8)
return ").Lo)"
case to.IsIntegerType() && !to.IsSignedType():
p.w("uint%d((", to.Size()*8)
return ").Lo)"
default:
panic(todo("", n.Position(), to, to.Alias()))
}
}
func (p *project) convertTypeFromUint128(n cc.Node, to cc.Type, flags flags) string {
switch k := to.Kind(); {
case k == cc.Float, k == cc.Double:
p.w("(")
return fmt.Sprintf(").Float%d()", to.Size()*8)
case k == cc.Int128:
p.w("(")
return ").Int128()"
case k == cc.UInt128:
return ""
case to.IsIntegerType() && to.IsSignedType():
p.w("int%d((", to.Size()*8)
return ").Lo)"
case to.IsIntegerType() && !to.IsSignedType():
p.w("uint%d((", to.Size()*8)
return ").Lo)"
default:
panic(todo("", n.Position(), to, to.Alias()))
}
}
func (p *project) convertTypeToInt128(n cc.Node, from cc.Type, flags flags) string {
switch k := from.Kind(); {
case k == cc.Float, k == cc.Double:
p.w("%sInt128FromFloat%d(", p.task.crt, from.Size()*8)
return ")"
case k == cc.Int128:
return ""
case k == cc.UInt128:
p.w("%sInt128FromUint128(", p.task.crt)
return ")"
case from.IsIntegerType() && from.IsSignedType():
p.w("%sInt128FromInt%d(", p.task.crt, from.Size()*8)
return ")"
case from.IsIntegerType() && !from.IsSignedType():
p.w("%sInt128FromUint%d(", p.task.crt, from.Size()*8)
return ")"
default:
panic(todo("", n.Position(), from, from.Alias()))
}
}
func (p *project) convertTypeToUint128(n cc.Node, from cc.Type, flags flags) string {
switch k := from.Kind(); {
case k == cc.Float, k == cc.Double:
p.w("%sUint128FromFloat%d(", p.task.crt, from.Size()*8)
return ")"
case k == cc.Int128:
p.w("(")
return ").Uint128()"
case k == cc.UInt128:
return ""
case from.IsIntegerType() && from.IsSignedType():
p.w("%sUint128FromInt%d(", p.task.crt, from.Size()*8)
return ")"
case from.IsIntegerType() && !from.IsSignedType():
p.w("%sUint128FromUint%d(", p.task.crt, from.Size()*8)
return ")"
default:
panic(todo("", n.Position(), from, from.Alias()))
}
}
func (p *project) convertFromInt128(n cc.Node, op cc.Operand, to cc.Type, flags flags) string {
switch k := to.Kind(); {
case k == cc.Float, k == cc.Double:
p.w("(")
return fmt.Sprintf(").Float%d()", to.Size()*8)
case k == cc.Int128:
return ""
case k == cc.UInt128:
p.w("(")
return ").Uint128()"
case to.IsIntegerType() && to.IsSignedType():
p.w("%sInt%d(", p.task.crt, to.Size()*8)
return ")"
case to.IsIntegerType() && !to.IsSignedType():
p.w("%sUint%d(", p.task.crt, to.Size()*8)
return ")"
default:
panic(todo("", n.Position(), to, to.Alias()))
}
}
func (p *project) convertFromUint128(n cc.Node, op cc.Operand, to cc.Type, flags flags) string {
switch k := to.Kind(); {
case k == cc.Float, k == cc.Double:
p.w("%sUint128FromFloat%d(", p.task.crt, to.Size()*8)
return ")"
case k == cc.Int128:
p.w("(")
return ").Int128()"
case k == cc.UInt128:
return ""
case to.IsIntegerType() && to.IsSignedType():
p.w("%sInt%d(", p.task.crt, to.Size()*8)
return ")"
case to.IsIntegerType() && !to.IsSignedType():
p.w("%sUint%d(", p.task.crt, to.Size()*8)
return ")"
default:
panic(todo("", n.Position(), to, to.Alias()))
}
}
func (p *project) convertToInt128(n cc.Node, op cc.Operand, to cc.Type, flags flags) string {
from := op.Type()
switch k := from.Kind(); {
case k == cc.Float, k == cc.Double:
p.w("%sInt128FromFloat%d(", p.task.crt, from.Size()*8)
return ")"
case k == cc.Int128:
return ""
case k == cc.UInt128:
p.w("(")
return ").Int128()"
case from.IsIntegerType() && from.IsSignedType():
p.w("%sInt128FromInt%d(", p.task.crt, from.Size()*8)
return ")"
case from.IsIntegerType() && !from.IsSignedType():
p.w("%sInt128FromUint%d(", p.task.crt, from.Size()*8)
return ")"
default:
panic(todo("", n.Position(), from, from.Alias()))
}
}
func (p *project) convertToUint128(n cc.Node, op cc.Operand, to cc.Type, flags flags) string {
from := op.Type()
switch k := from.Kind(); {
case k == cc.Float, k == cc.Double:
p.w("%sUint128FromFloat%d(", p.task.crt, from.Size()*8)
return ")"
case k == cc.Int128:
p.w("(")
return ").Uint128()"
case k == cc.UInt128:
return ""
case from.IsIntegerType() && from.IsSignedType():
p.w("%sUint128FromInt%d(", p.task.crt, from.Size()*8)
return ")"
case from.IsIntegerType() && !from.IsSignedType():
p.w("%sUint128FromUint%d(", p.task.crt, from.Size()*8)
return ")"
default:
panic(todo("", n.Position(), from, from.Alias()))
}
}
func (p *project) convertNil(n cc.Node, to cc.Type, flags flags) string {
switch to.Kind() {
case cc.Int128:
panic(todo("", 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))
}
}