go-pkg/expr
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

removed unused commented code

Browse Source
This commit is contained in:
Celestino Amoroso 2024-06-05 05:53:02 +02:00
parent 9c29392389
commit 847d85605e
4 changed files with 8 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
fraction-type.go
View File

@ -33,52 +33,10 @@ func float64ToFraction(f float64) (fract *FractionType, err error) {
}
dec := fmt.Sprintf("%.12f", decPart)
s := fmt.Sprintf("%s%.f%s", sign, intPart, dec[1:])
// fmt.Printf("S: '%s'\n",s)
return makeGeneratingFraction(s)
}
// Based on https://cs.opensource.google/go/go/+/refs/tags/go1.22.3:src/math/big/rat.go;l=39
/*
func _float64ToFraction(f float64) (num, den int64, err error) {
const expMask = 1<<11 - 1
bits := math.Float64bits(f)
mantissa := bits & (1<<52 - 1)
exp := int((bits >> 52) & expMask)
switch exp {
case expMask: // non-finite
err = errors.New("infite")
return
case 0: // denormal
exp -= 1022
default: // normal
mantissa |= 1 << 52
exp -= 1023
}
shift := 52 - exp
// Optimization (?): partially pre-normalise.
for mantissa&1 == 0 && shift > 0 {
mantissa >>= 1
shift--
}
if f < 0 {
num = -int64(mantissa)
} else {
num = int64(mantissa)
}
den = int64(1)
if shift > 0 {
den = den << shift
} else {
num = num << (-shift)
}
return
}
*/
func makeGeneratingFraction(s string) (f *FractionType, err error) {
var num, den int64
var sign int64 = 1

16
operand-func.go
View File

@ -40,7 +40,6 @@ func checkFunctionCall(ctx ExprContext, name string, varParams *[]any) (err erro
err = errTooMuchParams(name, info.MaxArgs(), len(*varParams))
}
if err == nil && owner != ctx {
// ctx.RegisterFunc(name, info.Functor(), info.MinArgs(), info.MaxArgs())
ctx.RegisterFuncInfo(info)
}
} else {
@ -52,7 +51,6 @@ func checkFunctionCall(ctx ExprContext, name string, varParams *[]any) (err erro
func evalFuncCall(parentCtx ExprContext, self *term) (v any, err error) {
ctx := cloneContext(parentCtx)
name, _ := self.tk.Value.(string)
// fmt.Printf("Call %s(), context: %p\n", name, ctx)
params := make([]any, len(self.children), len(self.children)+5)
for i, tree := range self.children {
var param any
@ -85,20 +83,6 @@ func newFuncDefTerm(tk *Token, args []*term) *term {
}
// -------- eval func def
// func _evalFuncDef(ctx ExprContext, self *term) (v any, err error) {
// bodySpec := self.value()
// if expr, ok := bodySpec.(*ast); ok {
// paramList := make([]string, 0, len(self.children))
// for _, param := range self.children {
// paramList = append(paramList, param.source())
// }
// v = newExprFunctor(expr, paramList, ctx)
// } else {
// err = errors.New("invalid function definition: the body specification must be an expression")
// }
// return
// }
func evalFuncDef(ctx ExprContext, self *term) (v any, err error) {
bodySpec := self.value()
if expr, ok := bodySpec.(*ast); ok {

99
operator-assign.go
View File

@ -16,10 +16,6 @@ func newAssignTerm(tk *Token) (inst *term) {
}
}
func assignListItem(list *ListType, index int64, value any) (err error) {
return list.setItem(index, value)
}
func assignCollectionItem(ctx ExprContext, collectionTerm, keyListTerm *term, value any) (err error) {
var collectionValue, keyListValue, keyValue any
var keyList *ListType
@ -35,17 +31,20 @@ func assignCollectionItem(ctx ExprContext, collectionTerm, keyListTerm *term, va
err = keyListTerm.Errorf("index/key specification expected, got %v [%s]", keyListValue, typeName(keyListValue))
return
}
keyValue = (*keyList)[0]
if keyValue = (*keyList)[0]; keyValue == nil {
err = keyListTerm.Errorf("index/key is nil")
return
}
switch collection := collectionValue.(type) {
case *ListType:
if index, ok := keyValue.(int64); ok {
err = assignListItem(collection, index, value)
err = collection.setItem(index, value)
} else {
err = keyListTerm.Errorf("integer expected, got %v [%s]", keyValue, typeName(keyValue))
}
case *DictType:
collection.setItem(keyValue, value)
err = collection.setItem(keyValue, value)
default:
err = collectionTerm.Errorf("collection expected")
}
@ -61,40 +60,6 @@ func assignValue(ctx ExprContext, leftTerm *term, v any) (err error) {
return
}
func _assignValue(ctx ExprContext, leftTerm *term, v any) (err error) {
if leftTerm.symbol() == SymIndex {
var collection, indexListAny any
var list *ListType
var index int64
if collection, err = leftTerm.children[0].compute(ctx); err != nil {
return
} else if IsList(collection) {
list, _ = collection.(*ListType)
} else {
err = leftTerm.children[0].Errorf("expected collection")
return
}
if indexListAny, err = leftTerm.children[1].compute(ctx); err != nil {
return
} else if indexList, ok := indexListAny.(*ListType); ok && len(*indexList) == 1 {
if indexAny := (*indexList)[0]; IsInteger(indexAny) {
index, _ = indexAny.(int64)
} else {
err = leftTerm.children[1].Errorf("expected integer, got %v [%T]", indexAny, indexAny)
}
} else {
err = leftTerm.children[1].Errorf("expected index spec, got %v [%T]", indexListAny, indexListAny)
return
}
list.setItem(index, v)
} else {
ctx.UnsafeSetVar(leftTerm.source(), v)
}
return
}
/*
func evalAssign(ctx ExprContext, self *term) (v any, err error) {
if err = self.checkOperands(); err != nil {
return
@ -103,43 +68,7 @@ func evalAssign(ctx ExprContext, self *term) (v any, err error) {
leftTerm := self.children[0]
leftSym := leftTerm.symbol()
if leftSym != SymVariable && leftSym != SymIndex {
err = leftTerm.tk.Errorf("left operand of %q must be a variable", self.tk.source)
return
}
rightChild := self.children[1]
if v, err = rightChild.compute(ctx); err == nil {
if functor, ok := v.(Functor); ok {
funcName := rightChild.source()
if info, exists, _ := GetFuncInfo(ctx, funcName); exists {
// ctx.RegisterFuncInfo(info)
ctx.RegisterFunc(leftTerm.source(), info.Functor(), info.ReturnType(), info.Params())
} else if funcDef, ok := functor.(*exprFunctor); ok {
// paramSpecs := ForAll(funcDef.params, newFuncParam)
paramSpecs := ForAll(funcDef.params, func(p ExprFuncParam) ExprFuncParam { return p })
ctx.RegisterFunc(leftTerm.source(), functor, typeAny, paramSpecs)
} else {
err = self.Errorf("unknown function %s()", funcName)
}
} else {
ctx.UnsafeSetVar(leftTerm.source(), v)
}
}
return
}
*/
func evalAssign(ctx ExprContext, self *term) (v any, err error) {
if err = self.checkOperands(); err != nil {
return
}
leftTerm := self.children[0]
leftSym := leftTerm.symbol()
if leftSym != SymVariable && leftSym != SymIndex {
err = leftTerm.tk.Errorf("left operand of %q must be a variable", self.tk.source)
err = leftTerm.tk.Errorf("left operand of %q must be a variable or a collection's item", self.tk.source)
return
}
@ -150,28 +79,14 @@ func evalAssign(ctx ExprContext, self *term) (v any, err error) {
if info := functor.GetFunc(); info != nil {
ctx.RegisterFunc(leftTerm.source(), info.Functor(), info.ReturnType(), info.Params())
} else if funcDef, ok := functor.(*exprFunctor); ok {
// paramSpecs := ForAll(funcDef.params, newFuncParam)
paramSpecs := ForAll(funcDef.params, func(p ExprFuncParam) ExprFuncParam { return p })
ctx.RegisterFunc(leftTerm.source(), functor, typeAny, paramSpecs)
/*
}
funcName := rightChild.source()
if info, exists, _ := GetFuncInfo(ctx, funcName); exists {
// ctx.RegisterFuncInfo(info)
ctx.RegisterFunc(leftTerm.source(), info.Functor(), info.ReturnType(), info.Params())
} else if funcDef, ok := functor.(*exprFunctor); ok {
// paramSpecs := ForAll(funcDef.params, newFuncParam)
paramSpecs := ForAll(funcDef.params, func(p ExprFuncParam) ExprFuncParam { return p })
ctx.RegisterFunc(leftTerm.source(), functor, typeAny, paramSpecs)
*/
} else {
err = self.Errorf("unknown function %s()", rightChild.source())
}
} else {
err = assignValue(ctx, leftTerm, v)
//ctx.UnsafeSetVar(leftTerm.source(), v)
}
}
if err != nil {

1
simple-store.go
View File

@ -173,7 +173,6 @@ func (ctx *SimpleStore) EnumFuncs(acceptor func(name string) (accept bool)) (fun
func (ctx *SimpleStore) Call(name string, args []any) (result any, err error) {
if info, exists := GetLocalFuncInfo(ctx, name); exists {
// if info, exists := ctx.funcStore[name]; exists {
functor := info.Functor()
result, err = functor.Invoke(ctx, name, args)
} else {