mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 08:32:11 +01:00
230 lines
5.8 KiB
Go
230 lines
5.8 KiB
Go
// Use of this source code is governed by a BSD-style license that can be found
|
|
// in the LICENSE file.
|
|
|
|
package check
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"math/big"
|
|
|
|
a "github.com/google/puffs/lang/ast"
|
|
t "github.com/google/puffs/lang/token"
|
|
)
|
|
|
|
// TypeExprFoo is an *ast.Node MType (implicit type) that means that n is a
|
|
// boolean or a ideal numeric constant.
|
|
var (
|
|
TypeExprBoolean = a.NewTypeExpr(0, t.IDBool, nil, nil, nil)
|
|
TypeExprIdealNumber = a.NewTypeExpr(0, t.IDIdeal, nil, nil, nil)
|
|
)
|
|
|
|
func numeric(n *a.TypeExpr) bool { return n == TypeExprIdealNumber || n.IsNumType() }
|
|
|
|
// TypeMap maps from variable names (as token IDs) to types.
|
|
type TypeMap map[t.ID]*a.TypeExpr
|
|
|
|
type Struct struct {
|
|
ID t.ID
|
|
Struct *a.Struct
|
|
}
|
|
|
|
type Func struct {
|
|
QID t.QID
|
|
Func *a.Func
|
|
LocalVars TypeMap
|
|
}
|
|
|
|
func Check(m *t.IDMap, files ...*a.File) (*Checker, error) {
|
|
for _, f := range files {
|
|
if f == nil {
|
|
return nil, errors.New("check: Check given a nil *ast.File")
|
|
}
|
|
}
|
|
|
|
if len(files) > 1 {
|
|
m := map[string]bool{}
|
|
for _, f := range files {
|
|
if m[f.Filename()] {
|
|
return nil, fmt.Errorf("check: Check given duplicate filename %q", f.Filename())
|
|
}
|
|
m[f.Filename()] = true
|
|
}
|
|
}
|
|
|
|
c := &Checker{
|
|
idMap: m,
|
|
structs: map[t.ID]Struct{},
|
|
funcs: map[t.QID]Func{},
|
|
}
|
|
for _, phase := range phases {
|
|
for _, f := range files {
|
|
for _, n := range f.TopLevelDecls() {
|
|
if n.Kind() != phase.kind {
|
|
continue
|
|
}
|
|
if err := phase.check(c, n); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return c, nil
|
|
}
|
|
|
|
var phases = [...]struct {
|
|
kind a.Kind
|
|
check func(*Checker, *a.Node) error
|
|
}{
|
|
{a.KUse, (*Checker).checkUse},
|
|
{a.KStruct, (*Checker).checkStruct},
|
|
{a.KFunc, (*Checker).checkFuncSignature},
|
|
{a.KFunc, (*Checker).checkFuncBody},
|
|
}
|
|
|
|
type Checker struct {
|
|
idMap *t.IDMap
|
|
structs map[t.ID]Struct
|
|
funcs map[t.QID]Func
|
|
}
|
|
|
|
func (c *Checker) Funcs() map[t.QID]Func { return c.funcs }
|
|
|
|
func (c *Checker) checkUse(n *a.Node) error {
|
|
// TODO.
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkFields(fields []*a.Node) error {
|
|
if len(fields) == 0 {
|
|
return nil
|
|
}
|
|
tc := &typeChecker{
|
|
c: c,
|
|
idMap: c.idMap,
|
|
}
|
|
fieldNames := map[t.ID]bool{}
|
|
for _, n := range fields {
|
|
f := n.Field()
|
|
if _, ok := fieldNames[f.Name()]; ok {
|
|
return fmt.Errorf("check: duplicate field %q", c.idMap.ByID(f.Name()))
|
|
}
|
|
if err := tc.checkTypeExpr(f.XType()); err != nil {
|
|
return fmt.Errorf("%v in field %q", err, c.idMap.ByID(f.Name()))
|
|
}
|
|
fieldNames[f.Name()] = true
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkStruct(n *a.Node) error {
|
|
s := n.Struct()
|
|
if err := c.checkFields(s.Fields()); err != nil {
|
|
return fmt.Errorf("%v in struct %q at %s:%d", err, c.idMap.ByID(s.Name()), s.Filename(), s.Line())
|
|
}
|
|
id := s.Name()
|
|
if other, ok := c.structs[id]; ok {
|
|
return fmt.Errorf("check: duplicate struct %q at %s:%d and %s:%d",
|
|
c.idMap.ByID(id), other.Struct.Filename(), other.Struct.Line(), s.Filename(), s.Line())
|
|
}
|
|
c.structs[id] = Struct{
|
|
ID: id,
|
|
Struct: s,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkFuncSignature(n *a.Node) error {
|
|
f := n.Func()
|
|
if err := c.checkFields(f.In().Fields()); err != nil {
|
|
return fmt.Errorf("%v in in-params for func %q at %s:%d",
|
|
err, c.idMap.ByID(f.Name()), f.Filename(), f.Line())
|
|
}
|
|
if err := c.checkFields(f.Out().Fields()); err != nil {
|
|
return fmt.Errorf("%v in out-params for func %q at %s:%d",
|
|
err, c.idMap.ByID(f.Name()), f.Filename(), f.Line())
|
|
}
|
|
qid := f.QID()
|
|
if other, ok := c.funcs[qid]; ok {
|
|
return fmt.Errorf("check: duplicate function %q at %s:%d and %s:%d",
|
|
qid.String(c.idMap), other.Func.Filename(), other.Func.Line(), f.Filename(), f.Line())
|
|
}
|
|
c.funcs[qid] = Func{
|
|
QID: qid,
|
|
Func: f,
|
|
LocalVars: TypeMap{},
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkFuncBody(n *a.Node) error {
|
|
f := n.Func()
|
|
tc := &typeChecker{
|
|
c: c,
|
|
idMap: c.idMap,
|
|
typeMap: c.funcs[f.QID()].LocalVars,
|
|
}
|
|
|
|
// Fill in the TypeMap with all local variables. Note that they have
|
|
// function scope and can be hoisted, JavaScript style, a la
|
|
// https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/var
|
|
for _, m := range f.Body() {
|
|
if err := tc.checkVars(m); err != nil {
|
|
return fmt.Errorf("%v at %s:%d", err, tc.errFilename, tc.errLine)
|
|
}
|
|
}
|
|
|
|
// Assign ConstValue's (if applicable) and MType's to each Expr.
|
|
for _, m := range f.Body() {
|
|
if err := tc.checkStatement(m); err != nil {
|
|
return fmt.Errorf("%v at %s:%d", err, tc.errFilename, tc.errLine)
|
|
}
|
|
}
|
|
if err := f.Node().Walk(func(n *a.Node) error {
|
|
if n.Kind() == a.KExpr {
|
|
e := n.Expr()
|
|
if typ := e.MType(); typ == nil {
|
|
return fmt.Errorf("check: internal error: expression node %q has no (implicit) type",
|
|
e.String(tc.idMap))
|
|
} else if typ == TypeExprIdealNumber && e.ConstValue() == nil {
|
|
return fmt.Errorf("check: internal error: expression node %q has ideal number type "+
|
|
"but no const value", e.String(tc.idMap))
|
|
}
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
|
|
// TODO: bounds and assertion checking.
|
|
|
|
return nil
|
|
}
|
|
|
|
// TODO: use numTypeRanges.
|
|
|
|
var numTypeRanges = [256][2]*big.Int{
|
|
t.IDI8 >> t.KeyShift: {big.NewInt(-1 << 7), big.NewInt(1<<7 - 1)},
|
|
t.IDI16 >> t.KeyShift: {big.NewInt(-1 << 15), big.NewInt(1<<15 - 1)},
|
|
t.IDI32 >> t.KeyShift: {big.NewInt(-1 << 31), big.NewInt(1<<31 - 1)},
|
|
t.IDI64 >> t.KeyShift: {big.NewInt(-1 << 63), big.NewInt(1<<63 - 1)},
|
|
t.IDU8 >> t.KeyShift: {zero, big.NewInt(0).SetUint64(1<<8 - 1)},
|
|
t.IDU16 >> t.KeyShift: {zero, big.NewInt(0).SetUint64(1<<16 - 1)},
|
|
t.IDU32 >> t.KeyShift: {zero, big.NewInt(0).SetUint64(1<<32 - 1)},
|
|
t.IDU64 >> t.KeyShift: {zero, big.NewInt(0).SetUint64(1<<64 - 1)},
|
|
t.IDUsize >> t.KeyShift: {zero, zero},
|
|
}
|
|
|
|
var (
|
|
zero = big.NewInt(0)
|
|
one = big.NewInt(1)
|
|
ffff = big.NewInt(0xFFFF)
|
|
)
|
|
|
|
func btoi(b bool) *big.Int {
|
|
if b {
|
|
return one
|
|
}
|
|
return zero
|
|
}
|