mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 08:32:11 +01:00
361 lines
8.8 KiB
Go
361 lines
8.8 KiB
Go
// Use of this source code is governed by a BSD-style license that can be found
|
|
// in the LICENSE file.
|
|
|
|
package cgen
|
|
|
|
import (
|
|
"fmt"
|
|
"math/big"
|
|
|
|
a "github.com/google/puffs/lang/ast"
|
|
t "github.com/google/puffs/lang/token"
|
|
)
|
|
|
|
type funk struct {
|
|
bHeader buffer
|
|
bBodyResume buffer
|
|
bBody buffer
|
|
bBodySuspend buffer
|
|
bFooter buffer
|
|
|
|
astFunc *a.Func
|
|
derivedVars map[t.ID]struct{}
|
|
jumpTargets map[*a.While]uint32
|
|
coroSuspPoint uint32
|
|
tempW uint32
|
|
tempR uint32
|
|
public bool
|
|
suspendible bool
|
|
usesScratch bool
|
|
limitVarName string
|
|
shortReads []string
|
|
}
|
|
|
|
func (k *funk) jumpTarget(n *a.While) (uint32, error) {
|
|
if k.jumpTargets == nil {
|
|
k.jumpTargets = map[*a.While]uint32{}
|
|
}
|
|
if jt, ok := k.jumpTargets[n]; ok {
|
|
return jt, nil
|
|
}
|
|
jt := uint32(len(k.jumpTargets))
|
|
if jt == 1000000 {
|
|
return 0, fmt.Errorf("too many jump targets")
|
|
}
|
|
k.jumpTargets[n] = jt
|
|
return jt, nil
|
|
}
|
|
|
|
func (g *gen) writeFuncSignature(b *buffer, n *a.Func) error {
|
|
// TODO: write n's return values.
|
|
if n.Suspendible() {
|
|
b.printf("%sstatus ", g.pkgPrefix)
|
|
} else {
|
|
b.writes("void ")
|
|
}
|
|
|
|
b.writes(g.pkgPrefix)
|
|
if r := n.Receiver(); r != 0 {
|
|
b.writes(r.String(g.tm))
|
|
b.writeb('_')
|
|
}
|
|
b.printf("%s(", n.Name().String(g.tm))
|
|
|
|
comma := false
|
|
if r := n.Receiver(); r != 0 {
|
|
b.printf("%s%s *self", g.pkgPrefix, r.String(g.tm))
|
|
comma = true
|
|
}
|
|
for _, o := range n.In().Fields() {
|
|
if comma {
|
|
b.writeb(',')
|
|
}
|
|
comma = true
|
|
o := o.Field()
|
|
if err := g.writeCTypeName(b, o.XType(), aPrefix, o.Name().String(g.tm)); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
b.printf(")")
|
|
return nil
|
|
}
|
|
|
|
func (g *gen) writeFuncPrototype(b *buffer, n *a.Func) error {
|
|
if err := g.writeFuncSignature(b, n); err != nil {
|
|
return err
|
|
}
|
|
b.writes(";\n\n")
|
|
return nil
|
|
}
|
|
|
|
func (g *gen) writeFuncImpl(b *buffer, n *a.Func) error {
|
|
k := g.funks[n.QID()]
|
|
|
|
if err := g.writeFuncSignature(b, n); err != nil {
|
|
return err
|
|
}
|
|
b.writes("{\n")
|
|
b.writex(k.bHeader)
|
|
if k.suspendible && k.coroSuspPoint > 0 {
|
|
b.writex(k.bBodyResume)
|
|
}
|
|
b.writex(k.bBody)
|
|
if k.suspendible && k.coroSuspPoint > 0 {
|
|
b.writex(k.bBodySuspend)
|
|
}
|
|
b.writex(k.bFooter)
|
|
b.writes("}\n\n")
|
|
return nil
|
|
}
|
|
|
|
func (g *gen) gatherFuncImpl(_ *buffer, n *a.Func) error {
|
|
g.currFunk = funk{
|
|
astFunc: n,
|
|
public: n.Public(),
|
|
suspendible: n.Suspendible(),
|
|
}
|
|
|
|
if err := g.writeFuncImplHeader(&g.currFunk.bHeader); err != nil {
|
|
return err
|
|
}
|
|
if err := g.writeFuncImplBodyResume(&g.currFunk.bBodyResume); err != nil {
|
|
return err
|
|
}
|
|
if err := g.writeFuncImplBody(&g.currFunk.bBody); err != nil {
|
|
return err
|
|
}
|
|
if err := g.writeFuncImplBodySuspend(&g.currFunk.bBodySuspend); err != nil {
|
|
return err
|
|
}
|
|
if err := g.writeFuncImplFooter(&g.currFunk.bFooter); err != nil {
|
|
return err
|
|
}
|
|
|
|
if g.currFunk.tempW != g.currFunk.tempR {
|
|
return fmt.Errorf("internal error: temporary variable count out of sync")
|
|
}
|
|
g.funks[n.QID()] = g.currFunk
|
|
return nil
|
|
}
|
|
|
|
func (g *gen) writeFuncImplHeader(b *buffer) error {
|
|
// Check the previous status and the "self" arg.
|
|
if g.currFunk.public && g.currFunk.astFunc.Receiver() != 0 {
|
|
b.writes("if (!self) {")
|
|
if g.currFunk.suspendible {
|
|
b.printf("return %sERROR_BAD_RECEIVER;", g.PKGPREFIX)
|
|
} else {
|
|
b.printf("return;")
|
|
}
|
|
b.writes("}")
|
|
|
|
b.printf("if (self->private_impl.magic != PUFFS_MAGIC) {"+
|
|
"self->private_impl.status = %sERROR_CONSTRUCTOR_NOT_CALLED; }", g.PKGPREFIX)
|
|
|
|
b.writes("if (self->private_impl.status < 0) {")
|
|
if g.currFunk.suspendible {
|
|
b.writes("return self->private_impl.status;")
|
|
} else {
|
|
b.writes("return;")
|
|
}
|
|
b.writes("}\n")
|
|
}
|
|
|
|
if g.currFunk.suspendible {
|
|
b.printf("%sstatus status = %sSTATUS_OK;\n", g.pkgPrefix, g.PKGPREFIX)
|
|
}
|
|
|
|
// For public functions, check (at runtime) the other args for bounds and
|
|
// null-ness. For private functions, those checks are done at compile time.
|
|
if g.currFunk.public {
|
|
if err := g.writeFuncImplArgChecks(b, g.currFunk.astFunc); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
b.writes("\n")
|
|
|
|
// Generate the local variables.
|
|
if err := g.writeVars(b, g.currFunk.astFunc.Body()); err != nil {
|
|
return err
|
|
}
|
|
b.writes("\n")
|
|
|
|
if g.currFunk.suspendible {
|
|
g.findDerivedVars()
|
|
for _, o := range g.currFunk.astFunc.In().Fields() {
|
|
o := o.Field()
|
|
if err := g.writeLoadDerivedVar(b, o.Name(), o.XType(), true); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
b.writes("\n")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (g *gen) writeFuncImplBodyResume(b *buffer) error {
|
|
if g.currFunk.suspendible {
|
|
// TODO: don't hard-code [0], and allow recursive coroutines.
|
|
b.printf("uint32_t coro_susp_point = self->private_impl.%s%s[0].coro_susp_point;\n",
|
|
cPrefix, g.currFunk.astFunc.Name().String(g.tm))
|
|
b.printf("if (coro_susp_point) {\n")
|
|
if err := g.writeResumeSuspend(b, g.currFunk.astFunc.Body(), false); err != nil {
|
|
return err
|
|
}
|
|
b.writes("}\n")
|
|
// Generate a coroutine switch similiar to the technique in
|
|
// https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
|
|
//
|
|
// The matching } is written below. See "Close the coroutine switch".
|
|
b.writes("switch (coro_susp_point) {\nPUFFS_COROUTINE_SUSPENSION_POINT(0);\n\n")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (g *gen) writeFuncImplBody(b *buffer) error {
|
|
for _, o := range g.currFunk.astFunc.Body() {
|
|
if err := g.writeStatement(b, o, 0); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (g *gen) writeFuncImplBodySuspend(b *buffer) error {
|
|
if g.currFunk.suspendible {
|
|
// We've reached the end of the function body. Reset the coroutine
|
|
// suspension point so that the next call to this function starts at
|
|
// the top.
|
|
b.printf("self->private_impl.%s%s[0].coro_susp_point = 0;\n",
|
|
cPrefix, g.currFunk.astFunc.Name().String(g.tm))
|
|
b.writes("goto exit; }\n\n") // Close the coroutine switch.
|
|
|
|
b.writes("goto suspend;\n") // Avoid the "unused label" warning.
|
|
b.writes("suspend:\n")
|
|
|
|
b.printf("self->private_impl.%s%s[0].coro_susp_point = coro_susp_point;\n",
|
|
cPrefix, g.currFunk.astFunc.Name().String(g.tm))
|
|
if err := g.writeResumeSuspend(b, g.currFunk.astFunc.Body(), true); err != nil {
|
|
return err
|
|
}
|
|
b.writes("\n")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (g *gen) writeFuncImplFooter(b *buffer) error {
|
|
if g.currFunk.suspendible {
|
|
b.writes("exit:")
|
|
|
|
for _, o := range g.currFunk.astFunc.In().Fields() {
|
|
o := o.Field()
|
|
if err := g.writeSaveDerivedVar(b, o.Name(), o.XType()); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
b.writes("\n")
|
|
|
|
if g.currFunk.public {
|
|
b.writes("self->private_impl.status = status;\n")
|
|
}
|
|
b.writes("return status;\n\n")
|
|
|
|
shortReadsSeen := map[string]struct{}{}
|
|
for _, sr := range g.currFunk.shortReads {
|
|
if _, ok := shortReadsSeen[sr]; ok {
|
|
continue
|
|
}
|
|
shortReadsSeen[sr] = struct{}{}
|
|
if err := template_short_read(b, template_args_short_read{
|
|
PKGPREFIX: g.PKGPREFIX,
|
|
name: sr,
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (g *gen) writeFuncImplArgChecks(b *buffer, n *a.Func) error {
|
|
checks := []string(nil)
|
|
|
|
for _, o := range n.In().Fields() {
|
|
o := o.Field()
|
|
oTyp := o.XType()
|
|
if oTyp.Decorator().Key() != t.KeyPtr && !oTyp.IsRefined() {
|
|
// TODO: Also check elements, for array-typed arguments.
|
|
continue
|
|
}
|
|
|
|
switch {
|
|
case oTyp.Decorator().Key() == t.KeyPtr:
|
|
checks = append(checks, fmt.Sprintf("!%s%s", aPrefix, o.Name().String(g.tm)))
|
|
|
|
case oTyp.IsRefined():
|
|
bounds := [2]*big.Int{}
|
|
for i, bound := range oTyp.Bounds() {
|
|
if bound != nil {
|
|
if cv := bound.ConstValue(); cv != nil {
|
|
bounds[i] = cv
|
|
}
|
|
}
|
|
}
|
|
if key := oTyp.Name().Key(); key < t.Key(len(numTypeBounds)) {
|
|
ntb := numTypeBounds[key]
|
|
for i := 0; i < 2; i++ {
|
|
if bounds[i] != nil && ntb[i] != nil && bounds[i].Cmp(ntb[i]) == 0 {
|
|
bounds[i] = nil
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
for i, bound := range bounds {
|
|
if bound != nil {
|
|
op := '<'
|
|
if i != 0 {
|
|
op = '>'
|
|
}
|
|
checks = append(checks, fmt.Sprintf("%s%s %c %s", aPrefix, o.Name().String(g.tm), op, bound))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(checks) == 0 {
|
|
return nil
|
|
}
|
|
|
|
b.writes("if (")
|
|
for i, c := range checks {
|
|
if i != 0 {
|
|
b.writes(" || ")
|
|
}
|
|
b.writes(c)
|
|
}
|
|
b.writes(") {")
|
|
if g.currFunk.suspendible {
|
|
b.printf("status = %sERROR_BAD_ARGUMENT; goto exit;", g.PKGPREFIX)
|
|
} else if n.Receiver() != 0 {
|
|
b.printf("self->private_impl.status = %sERROR_BAD_ARGUMENT; return;", g.PKGPREFIX)
|
|
} else {
|
|
b.printf("return;")
|
|
}
|
|
b.writes("}\n")
|
|
return nil
|
|
}
|
|
|
|
var numTypeBounds = [256][2]*big.Int{
|
|
t.KeyI8: {big.NewInt(-1 << 7), big.NewInt(1<<7 - 1)},
|
|
t.KeyI16: {big.NewInt(-1 << 15), big.NewInt(1<<15 - 1)},
|
|
t.KeyI32: {big.NewInt(-1 << 31), big.NewInt(1<<31 - 1)},
|
|
t.KeyI64: {big.NewInt(-1 << 63), big.NewInt(1<<63 - 1)},
|
|
t.KeyU8: {zero, big.NewInt(0).SetUint64(1<<8 - 1)},
|
|
t.KeyU16: {zero, big.NewInt(0).SetUint64(1<<16 - 1)},
|
|
t.KeyU32: {zero, big.NewInt(0).SetUint64(1<<32 - 1)},
|
|
t.KeyU64: {zero, big.NewInt(0).SetUint64(1<<64 - 1)},
|
|
t.KeyUsize: {zero, zero},
|
|
t.KeyBool: {zero, one},
|
|
}
|