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
Download Patch File Download Diff File Expand all files Collapse all files
operator-assign.go
+8 -93
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,32 +79,18 @@ 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 {
v=nil
v = nil
}
return
}