mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 08:32:11 +01:00
701 lines
21 KiB
Go
701 lines
21 KiB
Go
// Copyright 2017 The Puffs Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package cgen
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
|
|
"github.com/google/puffs/lang/builtin"
|
|
|
|
a "github.com/google/puffs/lang/ast"
|
|
t "github.com/google/puffs/lang/token"
|
|
)
|
|
|
|
func (g *gen) writeStatement(b *buffer, n *a.Node, depth uint32) error {
|
|
if depth > a.MaxBodyDepth {
|
|
return fmt.Errorf("body recursion depth too large")
|
|
}
|
|
depth++
|
|
|
|
switch n.Kind() {
|
|
case a.KAssert:
|
|
// Assertions only apply at compile-time.
|
|
return nil
|
|
|
|
case a.KAssign:
|
|
n := n.Assign()
|
|
if err := g.writeSuspendibles(b, n.LHS(), depth); err != nil {
|
|
return err
|
|
}
|
|
if err := g.writeSuspendibles(b, n.RHS(), depth); err != nil {
|
|
return err
|
|
}
|
|
if err := g.writeExpr(b, n.LHS(), replaceCallSuspendibles, parenthesesMandatory, depth); err != nil {
|
|
return err
|
|
}
|
|
// TODO: does KeyAmpHatEq need special consideration?
|
|
b.writes(cOpNames[0xFF&n.Operator().Key()])
|
|
if err := g.writeExpr(b, n.RHS(), replaceCallSuspendibles, parenthesesMandatory, depth); err != nil {
|
|
return err
|
|
}
|
|
b.writes(";\n")
|
|
return nil
|
|
|
|
case a.KExpr:
|
|
n := n.Expr()
|
|
if err := g.writeSuspendibles(b, n, depth); err != nil {
|
|
return err
|
|
}
|
|
if n.CallSuspendible() {
|
|
return nil
|
|
}
|
|
if err := g.writeExpr(b, n, replaceCallSuspendibles, parenthesesMandatory, depth); err != nil {
|
|
return err
|
|
}
|
|
b.writes(";\n")
|
|
return nil
|
|
|
|
case a.KIf:
|
|
// TODO: for writeSuspendibles, make sure that we get order of
|
|
// sub-expression evaluation correct.
|
|
n, nCloseCurly := n.If(), 1
|
|
for first := true; ; first = false {
|
|
if n.Condition().Suspendible() {
|
|
if !first {
|
|
b.writeb('{')
|
|
const maxCloseCurly = 1000
|
|
if nCloseCurly == maxCloseCurly {
|
|
return fmt.Errorf("too many nested if's")
|
|
}
|
|
nCloseCurly++
|
|
}
|
|
if err := g.writeSuspendibles(b, n.Condition(), depth); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
b.writes("if (")
|
|
if err := g.writeExpr(b, n.Condition(), replaceCallSuspendibles, parenthesesOptional, 0); err != nil {
|
|
return err
|
|
}
|
|
b.writes(") {\n")
|
|
for _, o := range n.BodyIfTrue() {
|
|
if err := g.writeStatement(b, o, depth); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if bif := n.BodyIfFalse(); len(bif) > 0 {
|
|
b.writes("} else {")
|
|
for _, o := range bif {
|
|
if err := g.writeStatement(b, o, depth); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
break
|
|
}
|
|
n = n.ElseIf()
|
|
if n == nil {
|
|
break
|
|
}
|
|
b.writes("} else ")
|
|
}
|
|
for ; nCloseCurly > 0; nCloseCurly-- {
|
|
b.writes("}\n")
|
|
}
|
|
return nil
|
|
|
|
case a.KJump:
|
|
n := n.Jump()
|
|
jt, err := g.currFunk.jumpTarget(n.JumpTarget())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
keyword := "continue"
|
|
if n.Keyword().Key() == t.KeyBreak {
|
|
keyword = "break"
|
|
}
|
|
b.printf("goto label_%d_%s;\n", jt, keyword)
|
|
return nil
|
|
|
|
case a.KReturn:
|
|
n := n.Return()
|
|
ret := status{}
|
|
retExpr := (*a.Expr)(nil)
|
|
if n.Keyword() != 0 {
|
|
ret = g.statusMap[n.Message()]
|
|
if ret.name == "" {
|
|
msg := builtin.TrimQuotes(n.Message().String(g.tm))
|
|
z := builtin.StatusMap[msg]
|
|
if z.Message == "" {
|
|
return fmt.Errorf("no status code for %q", msg)
|
|
}
|
|
ret.name = strings.ToUpper(g.cName(z.String()))
|
|
ret.keyword = z.Keyword
|
|
}
|
|
} else if retExpr = n.Value(); retExpr == nil {
|
|
ret.name = g.PKGPREFIX + "STATUS_OK"
|
|
}
|
|
|
|
if g.currFunk.suspendible {
|
|
b.writes("status = ")
|
|
if retExpr == nil {
|
|
b.writes(ret.name)
|
|
// TODO: check that retExpr has no call-suspendibles.
|
|
} else if err := g.writeExpr(
|
|
b, retExpr, replaceCallSuspendibles, parenthesesMandatory, depth); err != nil {
|
|
return err
|
|
}
|
|
b.writes(";")
|
|
if retExpr == nil {
|
|
switch ret.keyword.Key() {
|
|
case 0:
|
|
b.writes("goto ok;")
|
|
return nil
|
|
case t.KeyError:
|
|
b.writes("goto exit;")
|
|
return nil
|
|
case t.KeySuspension:
|
|
// No-op.
|
|
}
|
|
}
|
|
return g.writeCoroSuspPoint(b, true)
|
|
}
|
|
|
|
b.writes("return ")
|
|
if len(g.currFunk.astFunc.Out().Fields()) == 0 {
|
|
if retExpr != nil {
|
|
return fmt.Errorf("return expression %q incompatible with empty return type", retExpr.String(g.tm))
|
|
}
|
|
} else if retExpr == nil {
|
|
// TODO: should a bare "return" imply "return out"?
|
|
return fmt.Errorf("empty return expression incompatible with non-empty return type")
|
|
} else if err := g.writeExpr(b, retExpr, replaceCallSuspendibles, parenthesesMandatory, depth); err != nil {
|
|
return err
|
|
}
|
|
b.writeb(';')
|
|
return nil
|
|
|
|
case a.KVar:
|
|
n := n.Var()
|
|
if v := n.Value(); v != nil {
|
|
if err := g.writeSuspendibles(b, v, depth); err != nil {
|
|
return err
|
|
}
|
|
if v.ID0().Key() == t.KeyLimit {
|
|
g.currFunk.limitVarName = n.Name().String(g.tm)
|
|
b.printf("%s%s =", lPrefix, g.currFunk.limitVarName)
|
|
if err := g.writeExpr(
|
|
b, v.LHS().Expr(), replaceCallSuspendibles, parenthesesMandatory, depth); err != nil {
|
|
return err
|
|
}
|
|
b.writes(";\n")
|
|
}
|
|
}
|
|
switch n.XType().Decorator().Key() {
|
|
case t.KeyOpenBracket:
|
|
if n.Value() != nil {
|
|
// TODO: something like:
|
|
// cv := n.XType().ArrayLength().ConstValue()
|
|
// // TODO: check that cv is within size_t's range.
|
|
// g.printf("{ size_t i; for (i = 0; i < %d; i++) { %s%s[i] = $DEFAULT_VALUE; }}\n",
|
|
// cv, vPrefix, n.Name().String(g.tm))
|
|
return fmt.Errorf("TODO: array initializers for non-zero default values")
|
|
}
|
|
// TODO: arrays of arrays.
|
|
name := n.Name().String(g.tm)
|
|
b.printf("memset(%s%s, 0, sizeof(%s%s));\n", vPrefix, name, vPrefix, name)
|
|
|
|
default:
|
|
b.printf("%s%s = ", vPrefix, n.Name().String(g.tm))
|
|
if v := n.Value(); v != nil {
|
|
if err := g.writeExpr(b, v, replaceCallSuspendibles, parenthesesMandatory, 0); err != nil {
|
|
return err
|
|
}
|
|
} else if n.XType().Decorator().Key() == t.KeyColon {
|
|
// TODO: don't assume that the slice is a slice of u8.
|
|
b.printf("((puffs_base_slice_u8){})")
|
|
} else {
|
|
b.writeb('0')
|
|
}
|
|
b.writes(";\n")
|
|
}
|
|
return nil
|
|
|
|
case a.KIterate:
|
|
n := n.Iterate()
|
|
vars := n.Variables()
|
|
if len(vars) == 0 {
|
|
return nil
|
|
}
|
|
if len(vars) != 1 {
|
|
return fmt.Errorf("TODO: iterate over more than one variable")
|
|
}
|
|
v := vars[0].Var()
|
|
name := v.Name().String(g.tm)
|
|
b.writes("{\n")
|
|
|
|
// TODO: don't assume that the slice is a slice of u8. In particular,
|
|
// the code gen can be subtle if the slice element type has zero size,
|
|
// such as the empty struct.
|
|
b.printf("puffs_base_slice_u8 %sslice_%s =", iPrefix, name)
|
|
if err := g.writeExpr(b, v.Value(), replaceCallSuspendibles, parenthesesOptional, 0); err != nil {
|
|
return err
|
|
}
|
|
b.writes(";\n")
|
|
b.printf("uint8_t* %s%s = %sslice_%s.ptr;\n", vPrefix, name, iPrefix, name)
|
|
b.printf("uint8_t* %send_%s = %sslice_%s.ptr + %sslice_%s.len;\n",
|
|
iPrefix, name, iPrefix, name, iPrefix, name)
|
|
b.printf("while (%s%s < %send_%s) {\n", vPrefix, name, iPrefix, name)
|
|
for _, o := range n.Body() {
|
|
if err := g.writeStatement(b, o, depth); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
b.printf("%s%s++;\n}\n", vPrefix, name)
|
|
|
|
b.writes("}\n")
|
|
return nil
|
|
|
|
case a.KWhile:
|
|
n := n.While()
|
|
// TODO: consider suspendible calls.
|
|
|
|
if n.HasContinue() {
|
|
jt, err := g.currFunk.jumpTarget(n)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
b.printf("label_%d_continue:;\n", jt)
|
|
}
|
|
b.writes("while (")
|
|
if err := g.writeExpr(b, n.Condition(), replaceCallSuspendibles, parenthesesOptional, 0); err != nil {
|
|
return err
|
|
}
|
|
b.writes(") {\n")
|
|
for _, o := range n.Body() {
|
|
if err := g.writeStatement(b, o, depth); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
b.writes("}\n")
|
|
if n.HasBreak() {
|
|
jt, err := g.currFunk.jumpTarget(n)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
b.printf("label_%d_break:;\n", jt)
|
|
}
|
|
return nil
|
|
|
|
}
|
|
return fmt.Errorf("unrecognized ast.Kind (%s) for writeStatement", n.Kind())
|
|
}
|
|
|
|
func (g *gen) writeCoroSuspPoint(b *buffer, maybeSuspend bool) error {
|
|
const maxCoroSuspPoint = 0xFFFFFFFF
|
|
g.currFunk.coroSuspPoint++
|
|
if g.currFunk.coroSuspPoint == maxCoroSuspPoint {
|
|
return fmt.Errorf("too many coroutine suspension points required")
|
|
}
|
|
|
|
macro := ""
|
|
if maybeSuspend {
|
|
macro = "_MAYBE_SUSPEND"
|
|
}
|
|
b.printf("PUFFS_COROUTINE_SUSPENSION_POINT%s(%d);\n", macro, g.currFunk.coroSuspPoint)
|
|
return nil
|
|
}
|
|
|
|
func (g *gen) writeSuspendibles(b *buffer, n *a.Expr, depth uint32) error {
|
|
if !n.Suspendible() {
|
|
return nil
|
|
}
|
|
if err := g.writeCoroSuspPoint(b, false); err != nil {
|
|
return err
|
|
}
|
|
return g.writeCallSuspendibles(b, n, depth)
|
|
}
|
|
|
|
func (g *gen) writeCallSuspendibles(b *buffer, n *a.Expr, depth uint32) error {
|
|
if depth > a.MaxExprDepth {
|
|
return fmt.Errorf("expression recursion depth too large")
|
|
}
|
|
depth++
|
|
|
|
// The evaluation order for suspendible calls (which can have side effects)
|
|
// is important here: LHS, MHS, RHS, Args and finally the node itself.
|
|
if !n.CallSuspendible() {
|
|
for _, o := range n.Node().Raw().SubNodes() {
|
|
if o != nil && o.Kind() == a.KExpr {
|
|
if err := g.writeCallSuspendibles(b, o.Expr(), depth); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
for _, o := range n.Args() {
|
|
if o != nil && o.Kind() == a.KExpr {
|
|
if err := g.writeCallSuspendibles(b, o.Expr(), depth); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
if err := g.writeSaveExprDerivedVars(b, n); err != nil {
|
|
return err
|
|
}
|
|
|
|
// TODO: delete these hacks that only matches "in.src.read_u8?()" etc.
|
|
//
|
|
// TODO: check reader1.buf and writer1.buf is non-NULL.
|
|
if isInSrc(g.tm, n, t.KeyReadU8, 0) {
|
|
if g.currFunk.tempW > maxTemp {
|
|
return fmt.Errorf("too many temporary variables required")
|
|
}
|
|
temp := g.currFunk.tempW
|
|
g.currFunk.tempW++
|
|
|
|
b.printf("if (PUFFS_UNLIKELY(%srptr_src == %srend_src)) { goto short_read_src; }", bPrefix, bPrefix)
|
|
g.currFunk.shortReads = append(g.currFunk.shortReads, "src")
|
|
// TODO: watch for passing an array type to writeCTypeName? In C, an
|
|
// array type can decay into a pointer.
|
|
if err := g.writeCTypeName(b, n.MType(), tPrefix, fmt.Sprint(temp)); err != nil {
|
|
return err
|
|
}
|
|
b.printf(" = *%srptr_src++;\n", bPrefix)
|
|
|
|
} else if isInSrc(g.tm, n, t.KeyReadU16BE, 0) {
|
|
return g.writeReadUXX(b, n, "src", 16, "be")
|
|
|
|
} else if isInSrc(g.tm, n, t.KeyReadU16LE, 0) {
|
|
return g.writeReadUXX(b, n, "src", 16, "le")
|
|
|
|
} else if isInSrc(g.tm, n, t.KeyReadU32BE, 0) {
|
|
return g.writeReadUXX(b, n, "src", 32, "be")
|
|
|
|
} else if isInSrc(g.tm, n, t.KeyReadU32LE, 0) {
|
|
return g.writeReadUXX(b, n, "src", 32, "le")
|
|
|
|
} else if isInSrc(g.tm, n, t.KeySkip32, 1) {
|
|
g.currFunk.usesScratch = true
|
|
// TODO: don't hard-code [0], and allow recursive coroutines.
|
|
scratchName := fmt.Sprintf("self->private_impl.%s%s[0].scratch",
|
|
cPrefix, g.currFunk.astFunc.Name().String(g.tm))
|
|
|
|
b.printf("%s = ", scratchName)
|
|
x := n.Args()[0].Arg().Value()
|
|
if err := g.writeExpr(b, x, replaceCallSuspendibles, parenthesesMandatory, depth); err != nil {
|
|
return err
|
|
}
|
|
b.writes(";\n")
|
|
|
|
// TODO: the CSP prior to this is probably unnecessary.
|
|
if err := g.writeCoroSuspPoint(b, false); err != nil {
|
|
return err
|
|
}
|
|
|
|
b.printf("if (%s > %srend_src - %srptr_src) {\n", scratchName, bPrefix, bPrefix)
|
|
b.printf("%s -= %srend_src - %srptr_src;\n", scratchName, bPrefix, bPrefix)
|
|
b.printf("%srptr_src = %srend_src;\n", bPrefix, bPrefix)
|
|
|
|
b.writes("goto short_read_src; }\n")
|
|
g.currFunk.shortReads = append(g.currFunk.shortReads, "src")
|
|
b.printf("%srptr_src += %s;\n", bPrefix, scratchName)
|
|
|
|
} else if isInDst(g.tm, n, t.KeyWriteU8, 1) {
|
|
b.printf("if (%swptr_dst == %swend_dst) { status = %sSUSPENSION_SHORT_WRITE;",
|
|
bPrefix, bPrefix, g.PKGPREFIX)
|
|
b.writes("goto suspend;")
|
|
b.writes("}\n")
|
|
b.printf("*%swptr_dst++ = ", bPrefix)
|
|
x := n.Args()[0].Arg().Value()
|
|
if err := g.writeExpr(b, x, replaceCallSuspendibles, parenthesesMandatory, depth); err != nil {
|
|
return err
|
|
}
|
|
b.writes(";\n")
|
|
|
|
} else if isThisMethod(g.tm, n, "decode_header", 1) {
|
|
b.printf("status = %s%s_decode_header(self, %ssrc);\n",
|
|
g.pkgPrefix, g.currFunk.astFunc.Receiver().String(g.tm), aPrefix)
|
|
if err := g.writeLoadExprDerivedVars(b, n); err != nil {
|
|
return err
|
|
}
|
|
b.writes("if (status) { goto suspend; }\n")
|
|
|
|
} else if isThisMethod(g.tm, n, "decode_lsd", 1) {
|
|
b.printf("status = %s%s_decode_lsd(self, %ssrc);\n",
|
|
g.pkgPrefix, g.currFunk.astFunc.Receiver().String(g.tm), aPrefix)
|
|
if err := g.writeLoadExprDerivedVars(b, n); err != nil {
|
|
return err
|
|
}
|
|
b.writes("if (status) { goto suspend; }\n")
|
|
|
|
} else if isThisMethod(g.tm, n, "decode_extension", 1) {
|
|
b.printf("status = %s%s_decode_extension(self, %ssrc);\n",
|
|
g.pkgPrefix, g.currFunk.astFunc.Receiver().String(g.tm), aPrefix)
|
|
if err := g.writeLoadExprDerivedVars(b, n); err != nil {
|
|
return err
|
|
}
|
|
b.writes("if (status) { goto suspend; }\n")
|
|
|
|
} else if isThisMethod(g.tm, n, "decode_id", 2) {
|
|
b.printf("status = %s%s_decode_id(self, %sdst, %ssrc);\n",
|
|
g.pkgPrefix, g.currFunk.astFunc.Receiver().String(g.tm), aPrefix, aPrefix)
|
|
if err := g.writeLoadExprDerivedVars(b, n); err != nil {
|
|
return err
|
|
}
|
|
b.writes("if (status) { goto suspend; }\n")
|
|
|
|
} else if isThisMethod(g.tm, n, "decode_blocks", 2) {
|
|
// TODO: don't hard code being inside a try call.
|
|
if g.currFunk.tempW > maxTemp {
|
|
return fmt.Errorf("too many temporary variables required")
|
|
}
|
|
temp := g.currFunk.tempW
|
|
g.currFunk.tempW++
|
|
|
|
b.printf("%sstatus %s%d = %s%s_decode_blocks(self, %sdst, %ssrc);\n",
|
|
g.pkgPrefix, tPrefix, temp,
|
|
g.pkgPrefix, g.currFunk.astFunc.Receiver().String(g.tm), aPrefix, aPrefix)
|
|
if err := g.writeLoadExprDerivedVars(b, n); err != nil {
|
|
return err
|
|
}
|
|
|
|
} else if isThisMethod(g.tm, n, "decode_uncompressed", 2) {
|
|
b.printf("status = %s%s_decode_uncompressed(self, %sdst, %ssrc);\n",
|
|
g.pkgPrefix, g.currFunk.astFunc.Receiver().String(g.tm), aPrefix, aPrefix)
|
|
if err := g.writeLoadExprDerivedVars(b, n); err != nil {
|
|
return err
|
|
}
|
|
b.writes("if (status) { goto suspend; }\n")
|
|
|
|
} else if isThisMethod(g.tm, n, "decode_huffman", 2) {
|
|
b.printf("status = %s%s_decode_huffman(self, %sdst, %ssrc);\n",
|
|
g.pkgPrefix, g.currFunk.astFunc.Receiver().String(g.tm), aPrefix, aPrefix)
|
|
if err := g.writeLoadExprDerivedVars(b, n); err != nil {
|
|
return err
|
|
}
|
|
b.writes("if (status) { goto suspend; }\n")
|
|
|
|
} else if isThisMethod(g.tm, n, "init_fixed_huffman", 0) {
|
|
b.printf("status = %s%s_init_fixed_huffman(self);\n",
|
|
g.pkgPrefix, g.currFunk.astFunc.Receiver().String(g.tm))
|
|
if err := g.writeLoadExprDerivedVars(b, n); err != nil {
|
|
return err
|
|
}
|
|
b.writes("if (status) { goto suspend; }\n")
|
|
|
|
} else if isThisMethod(g.tm, n, "init_dynamic_huffman", 1) {
|
|
b.printf("status = %s%s_init_dynamic_huffman(self, %ssrc);\n",
|
|
g.pkgPrefix, g.currFunk.astFunc.Receiver().String(g.tm), aPrefix)
|
|
if err := g.writeLoadExprDerivedVars(b, n); err != nil {
|
|
return err
|
|
}
|
|
b.writes("if (status) { goto suspend; }\n")
|
|
|
|
} else if isThisMethod(g.tm, n, "init_huff", 4) {
|
|
b.printf("status = %s%s_init_huff(self,",
|
|
g.pkgPrefix, g.currFunk.astFunc.Receiver().String(g.tm))
|
|
for i, o := range n.Args() {
|
|
if i != 0 {
|
|
b.writes(",")
|
|
}
|
|
if err := g.writeExpr(b, o.Arg().Value(), replaceNothing, parenthesesMandatory, depth); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
b.writes(");\n")
|
|
if err := g.writeLoadExprDerivedVars(b, n); err != nil {
|
|
return err
|
|
}
|
|
b.writes("if (status) { goto suspend; }\n")
|
|
|
|
} else if isThatMethod(g.tm, n, g.tm.ByName("decode").Key(), 2) {
|
|
switch g.pkgName {
|
|
case "flate":
|
|
b.printf("status = %sdecoder_decode(&self->private_impl.f_dec, %sdst, %ssrc);\n",
|
|
g.pkgPrefix, aPrefix, aPrefix)
|
|
if err := g.writeLoadExprDerivedVars(b, n); err != nil {
|
|
return err
|
|
}
|
|
b.writes("if (status) { goto suspend; }\n")
|
|
case "gif":
|
|
b.printf("status = %slzw_decoder_decode(&self->private_impl.f_lzw, %sdst, %s%s);\n",
|
|
g.pkgPrefix, aPrefix, vPrefix, n.Args()[1].Arg().Value().String(g.tm))
|
|
if err := g.writeLoadExprDerivedVars(b, n); err != nil {
|
|
return err
|
|
}
|
|
// TODO: be principled with "if (l_lzw_src && etc)".
|
|
b.writes("if (l_lzw_src && status) { goto suspend; }\n")
|
|
default:
|
|
return fmt.Errorf("cannot convert Puffs call %q to C", n.String(g.tm))
|
|
}
|
|
|
|
} else {
|
|
// TODO: fix this.
|
|
//
|
|
// This might involve calling g.writeExpr with replaceNothing??
|
|
return fmt.Errorf("cannot convert Puffs call %q to C", n.String(g.tm))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (g *gen) writeReadUXX(b *buffer, n *a.Expr, name string, size uint32, endianness string) error {
|
|
if size != 16 && size != 32 {
|
|
return fmt.Errorf("internal error: bad writeReadUXX size %d", size)
|
|
}
|
|
if endianness != "be" && endianness != "le" {
|
|
return fmt.Errorf("internal error: bad writeReadUXX endianness %q", endianness)
|
|
}
|
|
|
|
if g.currFunk.tempW > maxTemp-1 {
|
|
return fmt.Errorf("too many temporary variables required")
|
|
}
|
|
// temp0 is read by code generated in this function. temp1 is read elsewhere.
|
|
temp0 := g.currFunk.tempW + 0
|
|
temp1 := g.currFunk.tempW + 1
|
|
g.currFunk.tempW += 2
|
|
g.currFunk.tempR += 1
|
|
|
|
if err := g.writeCTypeName(b, n.MType(), tPrefix, fmt.Sprint(temp1)); err != nil {
|
|
return err
|
|
}
|
|
b.writes(";")
|
|
|
|
g.currFunk.usesScratch = true
|
|
// TODO: don't hard-code [0], and allow recursive coroutines.
|
|
scratchName := fmt.Sprintf("self->private_impl.%s%s[0].scratch",
|
|
cPrefix, g.currFunk.astFunc.Name().String(g.tm))
|
|
|
|
b.printf("if (PUFFS_LIKELY(%srend_src - %srptr_src >= %d)) {", bPrefix, bPrefix, size/8)
|
|
b.printf("%s%d = puffs_base_load_u%d%s(%srptr_src);\n", tPrefix, temp1, size, endianness, bPrefix)
|
|
b.printf("%srptr_src += %d;\n", bPrefix, size/8)
|
|
b.printf("} else {")
|
|
b.printf("%s = 0;\n", scratchName)
|
|
if err := g.writeCoroSuspPoint(b, false); err != nil {
|
|
return err
|
|
}
|
|
b.printf("while (true) {")
|
|
|
|
b.printf("if (PUFFS_UNLIKELY(%srptr_%s == %srend_%s)) { goto short_read_%s; }",
|
|
bPrefix, name, bPrefix, name, name)
|
|
g.currFunk.shortReads = append(g.currFunk.shortReads, name)
|
|
|
|
b.printf("uint32_t %s%d = %s", tPrefix, temp0, scratchName)
|
|
switch endianness {
|
|
case "be":
|
|
b.printf("& 0xFF;")
|
|
b.printf("%s >>= 8;", scratchName)
|
|
b.printf("%s <<= 8;", scratchName)
|
|
b.printf("%s |= ((uint64_t)(*%srptr_%s++)) << (64 - %s%d);",
|
|
scratchName, bPrefix, name, tPrefix, temp0)
|
|
case "le":
|
|
b.printf(">> 56;")
|
|
b.printf("%s <<= 8;", scratchName)
|
|
b.printf("%s >>= 8;", scratchName)
|
|
b.printf("%s |= ((uint64_t)(*%srptr_%s++)) << %s%d;",
|
|
scratchName, bPrefix, name, tPrefix, temp0)
|
|
}
|
|
|
|
b.printf("if (%s%d == %d) {", tPrefix, temp0, size-8)
|
|
switch endianness {
|
|
case "be":
|
|
b.printf("%s%d = %s >> (64 - %d);", tPrefix, temp1, scratchName, size)
|
|
case "le":
|
|
b.printf("%s%d = %s;", tPrefix, temp1, scratchName)
|
|
}
|
|
b.printf("break;")
|
|
b.printf("}")
|
|
|
|
b.printf("%s%d += 8;", tPrefix, temp0)
|
|
switch endianness {
|
|
case "be":
|
|
b.printf("%s |= ((uint64_t)(%s%d));", scratchName, tPrefix, temp0)
|
|
case "le":
|
|
b.printf("%s |= ((uint64_t)(%s%d)) << 56;", scratchName, tPrefix, temp0)
|
|
}
|
|
|
|
b.writes("}}\n")
|
|
return nil
|
|
}
|
|
|
|
func isInSrc(tm *t.Map, n *a.Expr, methodName t.Key, nArgs int) bool {
|
|
if n.ID0().Key() != t.KeyOpenParen || !n.CallSuspendible() || len(n.Args()) != nArgs {
|
|
return false
|
|
}
|
|
n = n.LHS().Expr()
|
|
if n.ID0().Key() != t.KeyDot || n.ID1().Key() != methodName {
|
|
return false
|
|
}
|
|
n = n.LHS().Expr()
|
|
if n.ID0().Key() != t.KeyDot || n.ID1() != tm.ByName("src") {
|
|
return false
|
|
}
|
|
n = n.LHS().Expr()
|
|
return n.ID0() == 0 && n.ID1().Key() == t.KeyIn
|
|
}
|
|
|
|
func isInDst(tm *t.Map, n *a.Expr, methodName t.Key, nArgs int) bool {
|
|
callSuspendible := methodName != t.KeyCopyFromReader32 &&
|
|
methodName != t.KeyCopyFromHistory32 &&
|
|
methodName != t.KeyCopyFromSlice32 &&
|
|
methodName != t.KeyCopyFromSlice &&
|
|
methodName != t.KeySlice
|
|
// TODO: check that n.Args() is "(x:bar)".
|
|
if n.ID0().Key() != t.KeyOpenParen || n.CallSuspendible() != callSuspendible || len(n.Args()) != nArgs {
|
|
return false
|
|
}
|
|
n = n.LHS().Expr()
|
|
if n.ID0().Key() != t.KeyDot || n.ID1().Key() != methodName {
|
|
return false
|
|
}
|
|
n = n.LHS().Expr()
|
|
if n.ID0().Key() != t.KeyDot || n.ID1() != tm.ByName("dst") {
|
|
return false
|
|
}
|
|
n = n.LHS().Expr()
|
|
return n.ID0() == 0 && n.ID1().Key() == t.KeyIn
|
|
}
|
|
|
|
func isThisMethod(tm *t.Map, n *a.Expr, methodName string, nArgs int) bool {
|
|
// TODO: check that n.Args() is "(src:in.src)".
|
|
if k := n.ID0().Key(); k != t.KeyOpenParen && k != t.KeyTry {
|
|
return false
|
|
}
|
|
if len(n.Args()) != nArgs {
|
|
return false
|
|
}
|
|
n = n.LHS().Expr()
|
|
if n.ID0().Key() != t.KeyDot || n.ID1() != tm.ByName(methodName) {
|
|
return false
|
|
}
|
|
n = n.LHS().Expr()
|
|
return n.ID0() == 0 && n.ID1().Key() == t.KeyThis
|
|
}
|
|
|
|
// isThatMethod is like isThisMethod but for foo.bar(etc), not this.bar(etc).
|
|
func isThatMethod(tm *t.Map, n *a.Expr, methodName t.Key, nArgs int) bool {
|
|
if k := n.ID0().Key(); k != t.KeyOpenParen && k != t.KeyTry {
|
|
return false
|
|
}
|
|
if len(n.Args()) != nArgs {
|
|
return false
|
|
}
|
|
n = n.LHS().Expr()
|
|
return n.ID0().Key() == t.KeyDot && n.ID1().Key() == methodName
|
|
}
|