mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
The LICENSE has changed from a single license (Apache2) to a dual license (Apache2 or MIT, at your option). If you've previously used Wuffs under the Apache2 license, you are able to keep doing so. No further action required by you. The two files listed below (previous releases) are exceptions, as they are older snapshots, frozen in time. Their license has not changed: release/c/wuffs-v0.2.c release/c/wuffs-v0.3.c Every name in the AUTHORS file, other than Google Inc., has signed Google's CLA (Contributor License Agreement).
647 lines
17 KiB
Go
647 lines
17 KiB
Go
// Copyright 2017 The Wuffs Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
package cgen
|
|
|
|
import (
|
|
"fmt"
|
|
"math/big"
|
|
"strconv"
|
|
|
|
a "github.com/google/wuffs/lang/ast"
|
|
t "github.com/google/wuffs/lang/token"
|
|
)
|
|
|
|
type funk struct {
|
|
bPrologue buffer
|
|
bBodyResume buffer
|
|
bBody buffer
|
|
bBodySuspend buffer
|
|
bEpilogue buffer
|
|
|
|
astFunc *a.Func
|
|
cName string
|
|
coroID uint32
|
|
returnsStatus bool
|
|
|
|
varList []*a.Var
|
|
varResumables map[t.ID]bool
|
|
derivedVars map[t.ID]struct{}
|
|
jumpTargets map[a.Loop]string
|
|
activeLoops a.LoopStack
|
|
coroSuspPoint uint32
|
|
ioManips uint32
|
|
tempW uint32
|
|
tempR uint32
|
|
usesEmptyIOBuffer bool
|
|
usesScratch bool
|
|
hasGotoOK bool
|
|
}
|
|
|
|
func (k *funk) jumpTarget(tm *t.Map, n a.Loop) (string, error) {
|
|
if label := n.Label(); label != 0 {
|
|
return label.Str(tm), nil
|
|
}
|
|
if k.jumpTargets == nil {
|
|
k.jumpTargets = map[a.Loop]string{}
|
|
}
|
|
if jt, ok := k.jumpTargets[n]; ok {
|
|
return jt, nil
|
|
}
|
|
jtInt := len(k.jumpTargets)
|
|
if jtInt == 1000000 {
|
|
return "", fmt.Errorf("too many jump targets")
|
|
}
|
|
jt := strconv.Itoa(jtInt)
|
|
k.jumpTargets[n] = jt
|
|
return jt, nil
|
|
}
|
|
|
|
func (g *gen) funcCName(n *a.Func) string {
|
|
if r := n.Receiver(); !r.IsZero() {
|
|
// TODO: this isn't right if r[0] != 0, i.e. the receiver is from a
|
|
// used package. There might be similar cases elsewhere in this
|
|
// package.
|
|
return g.pkgPrefix + r[1].Str(g.tm) + "__" + n.FuncName().Str(g.tm)
|
|
}
|
|
return g.pkgPrefix + n.FuncName().Str(g.tm)
|
|
}
|
|
|
|
// writeFunctionSignature modes.
|
|
const (
|
|
wfsCDecl = 0
|
|
wfsCDeclChoosy = 1
|
|
wfsCppDecl = 2
|
|
wfsCFuncPtrField = 3
|
|
wfsCFuncPtrFieldChoosy = 4
|
|
wfsCFuncPtrType = 5
|
|
)
|
|
|
|
func (g *gen) writeFuncSignature(b *buffer, n *a.Func, wfs uint32) error {
|
|
switch wfs {
|
|
case wfsCDecl:
|
|
b.writes("WUFFS_BASE__GENERATED_C_CODE\n")
|
|
if n.Public() {
|
|
b.writes("WUFFS_BASE__MAYBE_STATIC ")
|
|
} else {
|
|
b.writes("static ")
|
|
}
|
|
|
|
case wfsCDeclChoosy:
|
|
b.writes("WUFFS_BASE__GENERATED_C_CODE\n")
|
|
b.writes("static ")
|
|
|
|
case wfsCppDecl:
|
|
b.writes(" inline ")
|
|
|
|
case wfsCFuncPtrField, wfsCFuncPtrFieldChoosy, wfsCFuncPtrType:
|
|
// No-op.
|
|
}
|
|
|
|
// TODO: write n's return values.
|
|
if n.Effect().Coroutine() {
|
|
b.writes("wuffs_base__status")
|
|
} else if out := n.Out(); out == nil {
|
|
b.writes("wuffs_base__empty_struct")
|
|
// TODO: does writeCTypeName generate the right C if out is an array?
|
|
} else if err := g.writeCTypeName(b, out, "", ""); err != nil {
|
|
return err
|
|
}
|
|
|
|
switch wfs {
|
|
case wfsCDecl, wfsCDeclChoosy:
|
|
b.writes("\n")
|
|
case wfsCppDecl:
|
|
b.writes("\n ")
|
|
case wfsCFuncPtrField, wfsCFuncPtrFieldChoosy:
|
|
b.writes(" ")
|
|
}
|
|
|
|
comma := false
|
|
switch wfs {
|
|
case wfsCDecl, wfsCDeclChoosy:
|
|
b.writes(g.funcCName(n))
|
|
if wfs == wfsCDeclChoosy {
|
|
b.writes("__choosy_default")
|
|
}
|
|
b.writeb('(')
|
|
if r := n.Receiver(); !r.IsZero() {
|
|
b.writes("\n ")
|
|
if n.Effect().Pure() {
|
|
b.writes("const ")
|
|
}
|
|
b.printf("%s%s* self", g.pkgPrefix, r[1].Str(g.tm))
|
|
comma = true
|
|
}
|
|
|
|
case wfsCppDecl:
|
|
b.writes(n.FuncName().Str(g.tm))
|
|
b.writeb('(')
|
|
if len(n.In().Fields()) > 0 {
|
|
b.writes("\n ")
|
|
}
|
|
|
|
case wfsCFuncPtrField, wfsCFuncPtrFieldChoosy, wfsCFuncPtrType:
|
|
b.writes("(*")
|
|
if wfs == wfsCFuncPtrField {
|
|
b.writes(n.FuncName().Str(g.tm))
|
|
b.writes(")(\n ")
|
|
} else if wfs == wfsCFuncPtrFieldChoosy {
|
|
b.writes("choosy_")
|
|
b.writes(n.FuncName().Str(g.tm))
|
|
b.writes(")(\n ")
|
|
} else {
|
|
b.writes(")(")
|
|
}
|
|
|
|
if n.Effect().Pure() {
|
|
b.writes("const ")
|
|
}
|
|
|
|
if wfs == wfsCFuncPtrField {
|
|
b.writes("void* self")
|
|
} else if wfs == wfsCFuncPtrFieldChoosy {
|
|
b.printf("%s%s* self", g.pkgPrefix, n.Receiver()[1].Str(g.tm))
|
|
} else {
|
|
b.writes("void*")
|
|
}
|
|
comma = true
|
|
}
|
|
|
|
for _, o := range n.In().Fields() {
|
|
if comma {
|
|
b.writes(",\n ")
|
|
if wfs == wfsCppDecl {
|
|
b.writes(" ")
|
|
}
|
|
}
|
|
comma = true
|
|
o := o.AsField()
|
|
varNamePrefix, varName := "", ""
|
|
if wfs != wfsCFuncPtrType {
|
|
varNamePrefix, varName = aPrefix, o.Name().Str(g.tm)
|
|
}
|
|
if err := g.writeCTypeName(b, o.XType(), varNamePrefix, varName); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
b.printf(")")
|
|
if (wfs == wfsCppDecl) && !n.Receiver().IsZero() && n.Effect().Pure() {
|
|
b.writes(" const")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (g *gen) writeFuncPrototype(b *buffer, n *a.Func) error {
|
|
caMacro, _, _, err := cpuArchCNames(n.Asserts())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if caMacro != "" {
|
|
b.printf("#if defined(WUFFS_BASE__CPU_ARCH__%s)\n", caMacro)
|
|
}
|
|
if err := g.writeFuncSignature(b, n, wfsCDecl); err != nil {
|
|
return err
|
|
}
|
|
b.writes(";\n")
|
|
if caMacro != "" {
|
|
b.printf("#endif // defined(WUFFS_BASE__CPU_ARCH__%s)\n", caMacro)
|
|
}
|
|
b.writes("\n")
|
|
if n.Choosy() {
|
|
if err := g.writeFuncSignature(b, n, wfsCDeclChoosy); err != nil {
|
|
return err
|
|
}
|
|
b.writes(";\n\n")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (g *gen) writeFuncImpl(b *buffer, n *a.Func) error {
|
|
k := g.funks[n.QQID()]
|
|
|
|
caMacro, caName, caAttribute, err := cpuArchCNames(n.Asserts())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if caName != "" {
|
|
b.printf("// ‼ WUFFS MULTI-FILE SECTION +%s\n", caName)
|
|
}
|
|
b.printf("// -------- func %s.%s\n\n", g.pkgName, n.QQID().Str(g.tm))
|
|
if caMacro != "" {
|
|
b.printf("#if defined(WUFFS_BASE__CPU_ARCH__%s)\n", caMacro)
|
|
}
|
|
if caAttribute != "" {
|
|
b.printf("%s\n", caAttribute)
|
|
}
|
|
|
|
if err := g.writeFuncSignature(b, n, wfsCDecl); err != nil {
|
|
return err
|
|
}
|
|
b.writes(" {\n")
|
|
|
|
if n.Choosy() {
|
|
b.printf("return (*self->private_impl.choosy_%s)(self", n.FuncName().Str(g.tm))
|
|
for _, o := range n.In().Fields() {
|
|
b.printf(", %s%s", aPrefix, o.AsField().Name().Str(g.tm))
|
|
}
|
|
b.writes(");\n}\n\n")
|
|
|
|
if err := g.writeFuncSignature(b, n, wfsCDeclChoosy); err != nil {
|
|
return err
|
|
}
|
|
b.writes(" {\n")
|
|
}
|
|
|
|
if (len(n.Body()) != 0) || n.Effect().Coroutine() || (n.Out() != nil) {
|
|
b.writex(k.bPrologue)
|
|
if n.Effect().Coroutine() {
|
|
b.writex(k.bBodyResume)
|
|
}
|
|
b.writex(k.bBody)
|
|
if n.Effect().Coroutine() {
|
|
b.writex(k.bBodySuspend)
|
|
} else if k.hasGotoOK {
|
|
b.writes("\nok:\n")
|
|
}
|
|
}
|
|
|
|
b.writex(k.bEpilogue)
|
|
b.writes("}\n")
|
|
if caMacro != "" {
|
|
b.printf("#endif // defined(WUFFS_BASE__CPU_ARCH__%s)\n", caMacro)
|
|
}
|
|
if caName != "" {
|
|
b.printf("// ‼ WUFFS MULTI-FILE SECTION -%s\n", caName)
|
|
}
|
|
b.writes("\n")
|
|
return nil
|
|
}
|
|
|
|
func (g *gen) gatherFuncImpl(_ *buffer, n *a.Func) error {
|
|
coroID := uint32(0)
|
|
if n.Public() && n.Effect().Coroutine() {
|
|
g.numPublicCoroutines[n.Receiver()]++
|
|
coroID = g.numPublicCoroutines[n.Receiver()]
|
|
if coroID >= 0x8000 {
|
|
return fmt.Errorf("too many coroutines for %q", n.Receiver().Str(g.tm))
|
|
}
|
|
}
|
|
|
|
g.currFunk = funk{
|
|
astFunc: n,
|
|
cName: g.funcCName(n),
|
|
coroID: coroID,
|
|
|
|
returnsStatus: n.Effect().Coroutine() ||
|
|
((n.Out() != nil) && n.Out().IsStatus()),
|
|
}
|
|
|
|
if err := g.findVars(); err != nil {
|
|
return err
|
|
}
|
|
g.findDerivedVars()
|
|
|
|
if err := g.writeFuncImplBody(&g.currFunk.bBody); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := g.writeFuncImplPrologue(&g.currFunk.bPrologue); err != nil {
|
|
return err
|
|
}
|
|
if err := g.writeFuncImplBodyResume(&g.currFunk.bBodyResume); err != nil {
|
|
return err
|
|
}
|
|
if err := g.writeFuncImplBodySuspend(&g.currFunk.bBodySuspend); err != nil {
|
|
return err
|
|
}
|
|
if err := g.writeFuncImplEpilogue(&g.currFunk.bEpilogue); 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.QQID()] = g.currFunk
|
|
return nil
|
|
}
|
|
|
|
func writeOutParamZeroValue(b *buffer, tm *t.Map, typ *a.TypeExpr) error {
|
|
if typ == nil {
|
|
b.writes("wuffs_base__make_empty_struct()")
|
|
return nil
|
|
} else if typ.IsNumType() {
|
|
b.writes("0")
|
|
return nil
|
|
} else if typ.IsEitherSliceType() {
|
|
if inner := typ.Inner(); (inner.Decorator() == 0) && (inner.QID() == t.QID{t.IDBase, t.IDU8}) {
|
|
b.writes("wuffs_base__make_slice_u8(NULL, 0)")
|
|
return nil
|
|
}
|
|
} else if (typ.Decorator() == 0) && (typ.QID()[0] == t.IDBase) {
|
|
switch typ.QID()[1] {
|
|
case t.IDRangeIEU32:
|
|
b.writes("wuffs_base__utility__empty_range_ie_u32()")
|
|
return nil
|
|
case t.IDRangeIIU32:
|
|
b.writes("wuffs_base__utility__empty_range_ii_u32()")
|
|
return nil
|
|
case t.IDRangeIEU64:
|
|
b.writes("wuffs_base__utility__empty_range_ie_u64()")
|
|
return nil
|
|
case t.IDRangeIIU64:
|
|
b.writes("wuffs_base__utility__empty_range_ii_u64()")
|
|
return nil
|
|
case t.IDRectIEU32:
|
|
b.writes("wuffs_base__utility__empty_rect_ie_u32()")
|
|
return nil
|
|
case t.IDRectIIU32:
|
|
b.writes("wuffs_base__utility__empty_rect_ii_u32()")
|
|
return nil
|
|
}
|
|
}
|
|
return fmt.Errorf("internal error: cannot write the zero value of type %q", typ.Str(tm))
|
|
}
|
|
|
|
func writeFuncImplSelfMagicCheck(b *buffer, tm *t.Map, f *a.Func) error {
|
|
returnsStatus := f.Effect().Coroutine() ||
|
|
((f.Out() != nil) && f.Out().IsStatus())
|
|
|
|
b.writes(" if (!self) {\n return ")
|
|
if returnsStatus {
|
|
b.writes("wuffs_base__make_status(wuffs_base__error__bad_receiver)")
|
|
} else if err := writeOutParamZeroValue(b, tm, f.Out()); err != nil {
|
|
return err
|
|
}
|
|
b.writes(";\n }\n")
|
|
|
|
if f.Effect().Pure() {
|
|
b.writes(" if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&\n")
|
|
b.writes(" (self->private_impl.magic != WUFFS_BASE__DISABLED)) {\n")
|
|
} else {
|
|
b.writes(" if (self->private_impl.magic != WUFFS_BASE__MAGIC) {\n")
|
|
}
|
|
b.writes(" return ")
|
|
if returnsStatus {
|
|
b.writes("wuffs_base__make_status(\n" +
|
|
" (self->private_impl.magic == WUFFS_BASE__DISABLED)\n" +
|
|
" ? wuffs_base__error__disabled_by_previous_error\n" +
|
|
" : wuffs_base__error__initialize_not_called)")
|
|
} else if err := writeOutParamZeroValue(b, tm, f.Out()); err != nil {
|
|
return err
|
|
}
|
|
|
|
b.writes(";\n }\n")
|
|
return nil
|
|
}
|
|
|
|
func (g *gen) writeFuncImplPrologue(b *buffer) error {
|
|
oldLenB := len(*b)
|
|
|
|
// Check the initialized/disabled state and the "self" arg.
|
|
if g.currFunk.astFunc.Public() && !g.currFunk.astFunc.Receiver().IsZero() {
|
|
if err := writeFuncImplSelfMagicCheck(b, g.tm, g.currFunk.astFunc); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// 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.astFunc.Public() {
|
|
if err := g.writeFuncImplArgChecks(b, g.currFunk.astFunc); err != nil {
|
|
return err
|
|
}
|
|
|
|
// For public coroutines, check that we are not suspended in an active
|
|
// coroutine.
|
|
if g.currFunk.astFunc.Effect().Coroutine() {
|
|
b.printf("if ((self->private_impl.active_coroutine != 0) &&\n"+
|
|
"(self->private_impl.active_coroutine != %d)) {\n", g.currFunk.coroID)
|
|
b.writes("self->private_impl.magic = WUFFS_BASE__DISABLED;\n")
|
|
b.writes("return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);\n")
|
|
b.writes("}\n")
|
|
b.writes("self->private_impl.active_coroutine = 0;\n")
|
|
}
|
|
}
|
|
|
|
if g.currFunk.astFunc.Effect().Coroutine() ||
|
|
(g.currFunk.returnsStatus && (len(g.currFunk.derivedVars) > 0)) {
|
|
// TODO: rename the "status" variable to "ret"?
|
|
b.printf("wuffs_base__status status = wuffs_base__make_status(NULL);\n")
|
|
}
|
|
|
|
if oldLenB != len(*b) {
|
|
b.writes("\n")
|
|
}
|
|
|
|
// Generate the local variables.
|
|
oldLenB = len(*b)
|
|
if err := g.writeVars(b, &g.currFunk, false); err != nil {
|
|
return err
|
|
}
|
|
if oldLenB != len(*b) {
|
|
b.writes("\n")
|
|
}
|
|
|
|
if g.currFunk.derivedVars != nil {
|
|
for _, o := range g.currFunk.astFunc.In().Fields() {
|
|
o := o.AsField()
|
|
if _, ok := g.currFunk.derivedVars[o.Name()]; ok {
|
|
if err := g.writeInitialLoadDerivedVar(b, o); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
b.writes("\n")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (g *gen) writeFuncImplBodyResume(b *buffer) error {
|
|
if g.currFunk.coroSuspPoint > 0 {
|
|
// TODO: don't hard-code [0], and allow recursive coroutines.
|
|
b.printf("uint32_t coro_susp_point = self->private_impl.%s%s[0];\n",
|
|
pPrefix, g.currFunk.astFunc.FuncName().Str(g.tm))
|
|
|
|
resumeBuffer := buffer{}
|
|
if err := g.writeResumeSuspend(&resumeBuffer, &g.currFunk, false); err != nil {
|
|
return err
|
|
}
|
|
if len(resumeBuffer) > 0 {
|
|
b.writes("if (coro_susp_point) {\n")
|
|
b.writex(resumeBuffer)
|
|
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) {\nWUFFS_BASE__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.coroSuspPoint > 0) || g.currFunk.astFunc.Effect().Coroutine() {
|
|
if !g.currFunk.hasGotoOK {
|
|
b.writes("\ngoto ok;") // Avoid the "unused label" warning.
|
|
}
|
|
b.writes("\nok:\n")
|
|
}
|
|
|
|
if g.currFunk.coroSuspPoint > 0 {
|
|
// 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] = 0;\n",
|
|
pPrefix, g.currFunk.astFunc.FuncName().Str(g.tm))
|
|
b.writes("goto exit;\n}\n\n") // Close the coroutine switch.
|
|
|
|
b.writes("goto suspend;\nsuspend:\n") // The goto avoids the "unused label" warning.
|
|
|
|
b.printf("self->private_impl.%s%s[0] = "+
|
|
"wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;\n",
|
|
pPrefix, g.currFunk.astFunc.FuncName().Str(g.tm))
|
|
if g.currFunk.astFunc.Public() {
|
|
b.printf("self->private_impl.active_coroutine = "+
|
|
"wuffs_base__status__is_suspension(&status) ? %d : 0;\n", g.currFunk.coroID)
|
|
}
|
|
if err := g.writeResumeSuspend(b, &g.currFunk, true); err != nil {
|
|
return err
|
|
}
|
|
b.writes("\n")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (g *gen) writeFuncImplEpilogue(b *buffer) error {
|
|
epilogue := ""
|
|
if g.currFunk.astFunc.Effect().Coroutine() ||
|
|
(g.currFunk.returnsStatus && (len(g.currFunk.derivedVars) > 0)) {
|
|
|
|
b.writes("goto exit;\nexit:\n") // The goto avoids the "unused label" warning.
|
|
|
|
if g.currFunk.astFunc.Public() {
|
|
epilogue = "if (wuffs_base__status__is_error(&status)) {\n" +
|
|
"self->private_impl.magic = WUFFS_BASE__DISABLED;\n}\n" +
|
|
"return status;\n"
|
|
} else {
|
|
epilogue = "return status;\n"
|
|
}
|
|
} else if g.currFunk.astFunc.Out() == nil {
|
|
epilogue = "return wuffs_base__make_empty_struct();\n"
|
|
}
|
|
|
|
if (epilogue == "") && g.currFunk.astFunc.BodyEndsWithReturn() {
|
|
// No-op.
|
|
} else if g.currFunk.derivedVars != nil {
|
|
for _, o := range g.currFunk.astFunc.In().Fields() {
|
|
o := o.AsField()
|
|
if _, ok := g.currFunk.derivedVars[o.Name()]; ok {
|
|
if err := g.writeFinalSaveDerivedVar(b, o); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
b.writes("\n")
|
|
}
|
|
|
|
b.writes(epilogue)
|
|
return nil
|
|
}
|
|
|
|
func (g *gen) writeFuncImplArgChecks(b *buffer, n *a.Func) error {
|
|
checks := []string(nil)
|
|
|
|
for _, o := range n.In().Fields() {
|
|
o := o.AsField()
|
|
oTyp := o.XType()
|
|
|
|
// TODO: Also check elements, for array-typed arguments.
|
|
switch {
|
|
case oTyp.IsIOTokenType() || (oTyp.Decorator() == t.IDPtr):
|
|
checks = append(checks, fmt.Sprintf("!%s%s", aPrefix, o.Name().Str(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 qid := oTyp.QID(); qid[0] == t.IDBase {
|
|
if key := qid[1]; key < t.ID(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().Str(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(") {\n")
|
|
b.writes("self->private_impl.magic = WUFFS_BASE__DISABLED;\n")
|
|
if g.currFunk.astFunc.Effect().Coroutine() {
|
|
b.writes("return wuffs_base__make_status(wuffs_base__error__bad_argument);\n")
|
|
} else {
|
|
// TODO: don't assume that the return type is empty.
|
|
b.printf("return wuffs_base__make_empty_struct();\n")
|
|
}
|
|
b.writes("}\n")
|
|
return nil
|
|
}
|
|
|
|
var numTypeBounds = [...][2]*big.Int{
|
|
t.IDI8: {big.NewInt(-1 << 7), big.NewInt(1<<7 - 1)},
|
|
t.IDI16: {big.NewInt(-1 << 15), big.NewInt(1<<15 - 1)},
|
|
t.IDI32: {big.NewInt(-1 << 31), big.NewInt(1<<31 - 1)},
|
|
t.IDI64: {big.NewInt(-1 << 63), big.NewInt(1<<63 - 1)},
|
|
t.IDU8: {zero, big.NewInt(0).SetUint64(1<<8 - 1)},
|
|
t.IDU16: {zero, big.NewInt(0).SetUint64(1<<16 - 1)},
|
|
t.IDU32: {zero, big.NewInt(0).SetUint64(1<<32 - 1)},
|
|
t.IDU64: {zero, big.NewInt(0).SetUint64(1<<64 - 1)},
|
|
t.IDBool: {zero, one},
|
|
}
|