Files
wuffs/cmd/puffs-c/internal/cgen/var.go
T
Nigel Tao d4372cb5b8 Change license to Apache 2.
Also remove explicit PATENTS file. The new LICENSE file already
discusses patents.

Note that the Puffs project has not yet been publicly released.
2017-10-12 11:17:41 +11:00

336 lines
9.3 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 (
"errors"
"fmt"
a "github.com/google/puffs/lang/ast"
t "github.com/google/puffs/lang/token"
)
var errNeedDerivedVar = errors.New("internal: need derived var")
func (g *gen) needDerivedVar(name t.ID) bool {
for _, o := range g.currFunk.astFunc.Body() {
err := o.Walk(func(p *a.Node) error {
// Look for p matching "in.name.etc(etc)".
if p.Kind() != a.KExpr {
return nil
}
q := p.Expr()
if q.ID0().Key() != t.KeyOpenParen {
return nil
}
q = q.LHS().Expr()
if q.ID0().Key() != t.KeyDot {
return nil
}
q = q.LHS().Expr()
if q.ID0().Key() != t.KeyDot || q.ID1() != name {
return nil
}
q = q.LHS().Expr()
if q.ID0() != 0 || q.ID1().Key() != t.KeyIn {
return nil
}
return errNeedDerivedVar
})
if err == errNeedDerivedVar {
return true
}
}
return false
}
func (g *gen) findDerivedVars() {
for _, o := range g.currFunk.astFunc.In().Fields() {
o := o.Field()
oTyp := o.XType()
if oTyp.Decorator() != 0 {
continue
}
if key := oTyp.Name().Key(); key != t.KeyReader1 && key != t.KeyWriter1 {
continue
}
if !g.needDerivedVar(o.Name()) {
continue
}
if g.currFunk.derivedVars == nil {
g.currFunk.derivedVars = map[t.ID]struct{}{}
}
g.currFunk.derivedVars[o.Name()] = struct{}{}
}
}
func (g *gen) writeLoadDerivedVar(b *buffer, name t.ID, typ *a.TypeExpr, header bool) error {
if g.currFunk.derivedVars == nil {
return nil
}
if _, ok := g.currFunk.derivedVars[name]; !ok {
return nil
}
nameStr := name.String(g.tm)
switch typ.Name().Key() {
case t.KeyReader1:
if header {
b.printf("uint8_t* %srptr_%s = NULL;", bPrefix, nameStr)
b.printf("uint8_t* %srstart_%s = NULL;", bPrefix, nameStr)
b.printf("uint8_t* %srend_%s = NULL;", bPrefix, nameStr)
}
b.printf("if (%s%s.buf) {", aPrefix, nameStr)
b.printf("%srptr_%s = %s%s.buf->ptr + %s%s.buf->ri;",
bPrefix, nameStr, aPrefix, nameStr, aPrefix, nameStr)
if header {
b.printf("%srstart_%s = %srptr_%s;", bPrefix, nameStr, bPrefix, nameStr)
}
b.printf("size_t len = %s%s.buf->wi - %s%s.buf->ri;",
aPrefix, nameStr, aPrefix, nameStr)
b.printf("puffs_base_limit1* lim;")
b.printf("for (lim = &%s%s.limit; lim; lim = lim->next) {", aPrefix, nameStr)
b.printf("if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; }")
b.printf("}")
b.printf("%srend_%s = %srptr_%s + len;", bPrefix, nameStr, bPrefix, nameStr)
b.printf("}\n")
case t.KeyWriter1:
if header {
b.printf("uint8_t* %swptr_%s = NULL;", bPrefix, nameStr)
b.printf("uint8_t* %swstart_%s = NULL;", bPrefix, nameStr)
b.printf("uint8_t* %swend_%s = NULL;", bPrefix, nameStr)
}
b.printf("if (%s%s.buf) {", aPrefix, nameStr)
b.printf("%swptr_%s = %s%s.buf->ptr + %s%s.buf->wi;",
bPrefix, nameStr, aPrefix, nameStr, aPrefix, nameStr)
if header {
b.printf("%swstart_%s = %swptr_%s;", bPrefix, nameStr, bPrefix, nameStr)
}
b.printf("size_t len = %s%s.buf->len - %s%s.buf->wi;",
aPrefix, nameStr, aPrefix, nameStr)
b.printf("puffs_base_limit1* lim;")
b.printf("for (lim = &%s%s.limit; lim; lim = lim->next) {", aPrefix, nameStr)
b.printf("if (lim->ptr_to_len && (len > *lim->ptr_to_len)) { len = *lim->ptr_to_len; }")
b.printf("}")
b.printf("%swend_%s = %swptr_%s + len;", bPrefix, nameStr, bPrefix, nameStr)
b.printf("}\n")
}
return nil
}
func (g *gen) writeSaveDerivedVar(b *buffer, name t.ID, typ *a.TypeExpr, footer bool) error {
if g.currFunk.derivedVars == nil {
return nil
}
if _, ok := g.currFunk.derivedVars[name]; !ok {
return nil
}
nameStr := name.String(g.tm)
switch typ.Name().Key() {
case t.KeyReader1:
b.printf("if (%s%s.buf) {", aPrefix, nameStr)
b.printf("size_t n = %srptr_%s - (%s%s.buf->ptr + %s%s.buf->ri);",
bPrefix, nameStr, aPrefix, nameStr, aPrefix, nameStr)
b.printf("%s%s.buf->ri += n;", aPrefix, nameStr)
b.printf("puffs_base_limit1* lim;")
b.printf("for (lim = &%s%s.limit; lim; lim = lim->next) {", aPrefix, nameStr)
b.printf("if (lim->ptr_to_len) { *lim->ptr_to_len -= n; }")
b.printf("}")
if footer {
b.printf("PUFFS_IGNORE_POTENTIALLY_UNUSED_VARIABLE(%srstart_%s);", bPrefix, nameStr)
b.printf("PUFFS_IGNORE_POTENTIALLY_UNUSED_VARIABLE(%srend_%s);", bPrefix, nameStr)
}
b.printf("}\n")
case t.KeyWriter1:
b.printf("if (%s%s.buf) {", aPrefix, nameStr)
b.printf("size_t n = %swptr_%s - (%s%s.buf->ptr + %s%s.buf->wi);",
bPrefix, nameStr, aPrefix, nameStr, aPrefix, nameStr)
b.printf("%s%s.buf->wi += n;", aPrefix, nameStr)
b.printf("puffs_base_limit1* lim;")
b.printf("for (lim = &%s%s.limit; lim; lim = lim->next) {", aPrefix, nameStr)
b.printf("if (lim->ptr_to_len) { *lim->ptr_to_len -= n; }")
b.printf("}")
if footer {
b.printf("PUFFS_IGNORE_POTENTIALLY_UNUSED_VARIABLE(%swstart_%s);", bPrefix, nameStr)
b.printf("PUFFS_IGNORE_POTENTIALLY_UNUSED_VARIABLE(%swend_%s);", bPrefix, nameStr)
}
b.printf("}\n")
}
return nil
}
func (g *gen) writeLoadExprDerivedVars(b *buffer, n *a.Expr) error {
if g.currFunk.derivedVars == nil {
return nil
}
if k := n.ID0().Key(); k != t.KeyOpenParen && k != t.KeyTry {
return nil
}
for _, o := range n.Args() {
o := o.Arg()
// TODO: don't hard-code these.
if s := o.Value().String(g.tm); s != "in.dst" && s != "in.src" && s != "lzw_src" {
continue
}
if err := g.writeLoadDerivedVar(b, o.Name(), o.Value().MType(), false); err != nil {
return err
}
}
return nil
}
func (g *gen) writeSaveExprDerivedVars(b *buffer, n *a.Expr) error {
if g.currFunk.derivedVars == nil {
return nil
}
if k := n.ID0().Key(); k != t.KeyOpenParen && k != t.KeyTry {
return nil
}
for _, o := range n.Args() {
o := o.Arg()
// TODO: don't hard-code these.
if s := o.Value().String(g.tm); s != "in.dst" && s != "in.src" && s != "lzw_src" {
continue
}
if err := g.writeSaveDerivedVar(b, o.Name(), o.Value().MType(), false); err != nil {
return err
}
}
return nil
}
func (g *gen) visitVars(b *buffer, block []*a.Node, depth uint32, f func(*gen, *buffer, *a.Var) error) error {
if depth > a.MaxBodyDepth {
return fmt.Errorf("body recursion depth too large")
}
depth++
for _, o := range block {
switch o.Kind() {
case a.KIf:
for o := o.If(); o != nil; o = o.ElseIf() {
if err := g.visitVars(b, o.BodyIfTrue(), depth, f); err != nil {
return err
}
if err := g.visitVars(b, o.BodyIfFalse(), depth, f); err != nil {
return err
}
}
case a.KVar:
if err := f(g, b, o.Var()); err != nil {
return err
}
case a.KWhile:
if err := g.visitVars(b, o.While().Body(), depth, f); err != nil {
return err
}
}
}
return nil
}
func (g *gen) writeResumeSuspend1(b *buffer, n *a.Var, prefix string, suspend bool) error {
local := fmt.Sprintf("%s%s", prefix, n.Name().String(g.tm))
// TODO: explicitly handle prefix == lPrefix?
if typ := n.XType(); prefix == vPrefix && typ.HasPointers() {
if suspend {
return nil
}
rhs := ""
switch typ.Decorator().Key() {
case 0:
if key := typ.Name().Key(); key < t.Key(len(cTypeNames)) {
rhs = cTypeNames[key]
}
case t.KeyColon:
// TODO: don't assume that the slice is a slice of u8.
rhs = "puffs_base_slice_u8"
}
if rhs != "" {
b.printf("%s = ((%s){});\n", local, rhs)
return nil
}
} else {
lhs := local
// TODO: don't hard-code [0], and allow recursive coroutines.
rhs := fmt.Sprintf("self->private_impl.%s%s[0].%s", cPrefix, g.currFunk.astFunc.Name().String(g.tm), lhs)
if suspend {
lhs, rhs = rhs, lhs
}
switch typ.Decorator().Key() {
case 0:
b.printf("%s = %s;\n", lhs, rhs)
return nil
case t.KeyOpenBracket:
inner := typ.Inner()
if inner.Decorator() != 0 {
break
}
switch inner.Name().Key() {
case t.KeyU8, t.KeyU16, t.KeyU32, t.KeyU64:
b.printf("memcpy(%s, %s, sizeof(%s));\n", lhs, rhs, local)
return nil
}
}
}
return fmt.Errorf("cannot resume or suspend a local variable %q of type %q",
n.Name().String(g.tm), n.XType().String(g.tm))
}
func (g *gen) writeResumeSuspend(b *buffer, block []*a.Node, suspend bool) error {
return g.visitVars(b, block, 0, func(g *gen, b *buffer, n *a.Var) error {
if v := n.Value(); v != nil && v.ID0().Key() == t.KeyLimit {
if err := g.writeResumeSuspend1(b, n, lPrefix, suspend); err != nil {
return err
}
}
return g.writeResumeSuspend1(b, n, vPrefix, suspend)
})
}
func (g *gen) writeVars(b *buffer, block []*a.Node, skipPointerTypes bool) error {
return g.visitVars(b, block, 0, func(g *gen, b *buffer, n *a.Var) error {
if v := n.Value(); v != nil && v.ID0().Key() == t.KeyLimit {
b.printf("uint64_t %s%v;\n", lPrefix, n.Name().String(g.tm))
}
if skipPointerTypes && n.XType().HasPointers() {
return nil
}
if err := g.writeCTypeName(b, n.XType(), vPrefix, n.Name().String(g.tm)); err != nil {
return err
}
b.writes(";\n")
return nil
})
}