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

self param replaced as opTerm

Browse Source
This commit is contained in:
Celestino Amoroso 2024-07-09 07:50:06 +02:00
parent 867806155e
commit 6b3bfa2a11
31 changed files with 159 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
operand-dict.go
View File

@ -18,8 +18,8 @@ func newDictTerm(args map[any]*term) *term {
}
// -------- dict func
func evalDict(ctx ExprContext, self *term) (v any, err error) {
dict, _ := self.value().(map[any]*term)
func evalDict(ctx ExprContext, opTerm *term) (v any, err error) {
dict, _ := opTerm.value().(map[any]*term)
items := make(DictType, len(dict))
for key, tree := range dict {
var param any

6
operand-expr.go
View File

@ -20,11 +20,11 @@ func newExprTerm(root *term) *term {
}
// -------- eval expr
func evalExpr(ctx ExprContext, self *term) (v any, err error) {
if expr, ok := self.value().(*term); ok {
func evalExpr(ctx ExprContext, opTerm *term) (v any, err error) {
if expr, ok := opTerm.value().(*term); ok {
v, err = expr.compute(ctx)
} else {
err = fmt.Errorf("expression expected, got %T", self.value())
err = fmt.Errorf("expression expected, got %T", opTerm.value())
}
return
}

16
operand-func.go
View File

@ -21,10 +21,10 @@ func newFuncCallTerm(tk *Token, args []*term) *term {
}
// -------- eval func call
func evalFuncCall(ctx ExprContext, self *term) (v any, err error) {
name, _ := self.tk.Value.(string)
params := make([]any, len(self.children), len(self.children)+5)
for i, tree := range self.children {
func evalFuncCall(ctx ExprContext, opTerm *term) (v any, err error) {
name, _ := opTerm.tk.Value.(string)
params := make([]any, len(opTerm.children), len(opTerm.children)+5)
for i, tree := range opTerm.children {
var param any
if param, err = tree.compute(ctx); err != nil {
break
@ -51,11 +51,11 @@ func newFuncDefTerm(tk *Token, args []*term) *term {
}
// -------- eval func def
func evalFuncDef(ctx ExprContext, self *term) (v any, err error) {
bodySpec := self.value()
func evalFuncDef(ctx ExprContext, opTerm *term) (v any, err error) {
bodySpec := opTerm.value()
if expr, ok := bodySpec.(*ast); ok {
paramList := make([]ExprFuncParam, 0, len(self.children))
for _, param := range self.children {
paramList := make([]ExprFuncParam, 0, len(opTerm.children))
for _, param := range opTerm.children {
var defValue any
flags := paramFlags(0)
if len(param.children) > 0 {

14
operand-iterator.go
View File

@ -95,15 +95,15 @@ func getDataSourceDict(iteratorTerm *term, firstChildValue any) (ds map[string]F
return
}
func evalIterator(ctx ExprContext, iteratorTerm *term) (v any, err error) {
func evalIterator(ctx ExprContext, opTerm *term) (v any, err error) {
var firstChildValue any
var ds map[string]Functor
if firstChildValue, err = evalFirstChild(ctx, iteratorTerm); err != nil {
if firstChildValue, err = evalFirstChild(ctx, opTerm); err != nil {
return
}
if ds, err = getDataSourceDict(iteratorTerm, firstChildValue); err != nil {
if ds, err = getDataSourceDict(opTerm, firstChildValue); err != nil {
return
}
@ -111,8 +111,8 @@ func evalIterator(ctx ExprContext, iteratorTerm *term) (v any, err error) {
dc := newDataCursor(ctx, ds)
if initFunc, exists := ds[initName]; exists && initFunc != nil {
var args []any
if len(iteratorTerm.children) > 1 {
if args, err = evalTermArray(ctx, iteratorTerm.children[1:]); err != nil {
if len(opTerm.children) > 1 {
if args, err = evalTermArray(ctx, opTerm.children[1:]); err != nil {
return
}
} else {
@ -134,12 +134,12 @@ func evalIterator(ctx ExprContext, iteratorTerm *term) (v any, err error) {
v = dc
} else if list, ok := firstChildValue.(*ListType); ok {
var args []any
if args, err = evalSibling(ctx, iteratorTerm.children, nil); err == nil {
if args, err = evalSibling(ctx, opTerm.children, nil); err == nil {
v = NewListIterator(list, args)
}
} else {
var list []any
if list, err = evalSibling(ctx, iteratorTerm.children, firstChildValue); err == nil {
if list, err = evalSibling(ctx, opTerm.children, firstChildValue); err == nil {
v = NewArrayIterator(list)
}
}

4
operand-list.go
View File

@ -21,8 +21,8 @@ func newListTerm(row, col int, args []*term) *term {
}
// -------- list func
func evalList(ctx ExprContext, self *term) (v any, err error) {
list, _ := self.value().([]*term)
func evalList(ctx ExprContext, opTerm *term) (v any, err error) {
list, _ := opTerm.value().([]*term)
items := make(ListType, len(list))
for i, tree := range list {
var param any

4
operand-literal.go
View File

@ -17,8 +17,8 @@ func newLiteralTerm(tk *Token) *term {
}
// -------- eval func
func evalLiteral(ctx ExprContext, self *term) (v any, err error) {
v = self.tk.Value
func evalLiteral(ctx ExprContext, opTerm *term) (v any, err error) {
v = opTerm.tk.Value
return
}

6
operand-selector-case.go
View File

@ -41,10 +41,10 @@ func newSelectorCaseTerm(row, col int, filterList *term, caseExpr Expr) *term {
}
// -------- eval selector case
func evalSelectorCase(ctx ExprContext, self *term) (v any, err error) {
func evalSelectorCase(ctx ExprContext, opTerm *term) (v any, err error) {
var ok bool
if v, ok = self.value().(*selectorCase); !ok {
err = fmt.Errorf("selector-case expected, got %T", self.value())
if v, ok = opTerm.value().(*selectorCase); !ok {
err = fmt.Errorf("selector-case expected, got %T", opTerm.value())
}
return
}

4
operand-var.go
View File

@ -21,9 +21,9 @@ func newVarTerm(tk *Token) *term {
}
// -------- eval func
func evalVar(ctx ExprContext, self *term) (v any, err error) {
func evalVar(ctx ExprContext, opTerm *term) (v any, err error) {
var exists bool
name := self.source()
name := opTerm.source()
if v, exists = GetVar(ctx, name); !exists {
if info, exists, _ := GetFuncInfo(ctx, name); exists {
v = info.Functor()

12
operator-assign.go
View File

@ -60,19 +60,19 @@ func assignValue(ctx ExprContext, leftTerm *term, v any) (err error) {
return
}
func evalAssign(ctx ExprContext, self *term) (v any, err error) {
if err = self.checkOperands(); err != nil {
func evalAssign(ctx ExprContext, opTerm *term) (v any, err error) {
if err = opTerm.checkOperands(); err != nil {
return
}
leftTerm := self.children[0]
leftTerm := opTerm.children[0]
leftSym := leftTerm.symbol()
if leftSym != SymVariable && leftSym != SymIndex {
err = leftTerm.tk.Errorf("left operand of %q must be a variable or a collection's item", self.tk.source)
err = leftTerm.tk.Errorf("left operand of %q must be a variable or a collection's item", opTerm.tk.source)
return
}
rightChild := self.children[1]
rightChild := opTerm.children[1]
if v, err = rightChild.compute(ctx); err == nil {
if functor, ok := v.(Functor); ok {
@ -83,7 +83,7 @@ func evalAssign(ctx ExprContext, self *term) (v any, err error) {
ctx.RegisterFunc(leftTerm.source(), functor, TypeAny, paramSpecs)
} else {
err = self.Errorf("unknown function %s()", rightChild.source())
err = opTerm.Errorf("unknown function %s()", rightChild.source())
}
} else {
err = assignValue(ctx, leftTerm, v)

6
operator-bool.go
View File

@ -18,17 +18,17 @@ func newNotTerm(tk *Token) (inst *term) {
}
}
func evalNot(ctx ExprContext, self *term) (v any, err error) {
func evalNot(ctx ExprContext, opTerm *term) (v any, err error) {
var rightValue any
if rightValue, err = self.evalPrefix(ctx); err != nil {
if rightValue, err = opTerm.evalPrefix(ctx); err != nil {
return
}
if b, ok := ToBool(rightValue); ok {
v = !b
} else {
err = self.errIncompatibleType(rightValue)
err = opTerm.errIncompatibleType(rightValue)
}
return
}

8
operator-builtin.go
View File

@ -18,10 +18,10 @@ func newBuiltinTerm(tk *Token) (inst *term) {
}
}
func evalBuiltin(ctx ExprContext, self *term) (v any, err error) {
func evalBuiltin(ctx ExprContext, opTerm *term) (v any, err error) {
var childValue any
if childValue, err = self.evalPrefix(ctx); err != nil {
if childValue, err = opTerm.evalPrefix(ctx); err != nil {
return
}
@ -37,11 +37,11 @@ func evalBuiltin(ctx ExprContext, self *term) (v any, err error) {
if ImportInContext(module) {
count++
} else {
err = self.Errorf("unknown builtin module %q", module)
err = opTerm.Errorf("unknown builtin module %q", module)
break
}
} else {
err = self.Errorf("expected string at item nr %d, got %s", it.Index()+1, TypeName(moduleSpec))
err = opTerm.Errorf("expected string at item nr %d, got %s", it.Index()+1, TypeName(moduleSpec))
break
}
}

4
operator-but.go
View File

@ -16,8 +16,8 @@ func newButTerm(tk *Token) (inst *term) {
}
}
func evalBut(ctx ExprContext, self *term) (v any, err error) {
_, v, err = self.evalInfix(ctx)
func evalBut(ctx ExprContext, opTerm *term) (v any, err error) {
_, v, err = opTerm.evalInfix(ctx)
return
}

10
operator-context.go
View File

@ -16,15 +16,15 @@ func newContextTerm(tk *Token) (inst *term) {
}
}
func evalContextValue(ctx ExprContext, self *term) (v any, err error) {
func evalContextValue(ctx ExprContext, opTerm *term) (v any, err error) {
var childValue any
var sourceCtx ExprContext
if self.children == nil || len(self.children) == 0 {
if opTerm.children == nil || len(opTerm.children) == 0 {
sourceCtx = ctx
} else if self.children[0].symbol() == SymVariable && self.children[0].source() == "global" {
} else if opTerm.children[0].symbol() == SymVariable && opTerm.children[0].source() == "global" {
sourceCtx = globalCtx
} else if childValue, err = self.evalPrefix(ctx); err == nil {
} else if childValue, err = opTerm.evalPrefix(ctx); err == nil {
if dc, ok := childValue.(*dataCursor); ok {
sourceCtx = dc.ctx
}
@ -49,7 +49,7 @@ func evalContextValue(ctx ExprContext, self *term) (v any, err error) {
v = d
}
} else {
err = self.errIncompatibleType(childValue)
err = opTerm.errIncompatibleType(childValue)
}
return
}

2
operator-ctrl.go
View File

@ -16,7 +16,7 @@ func newExportAllTerm(tk *Token) (inst *term) {
}
}
func evalExportAll(ctx ExprContext, self *term) (v any, err error) {
func evalExportAll(ctx ExprContext, opTerm *term) (v any, err error) {
CtrlEnable(ctx, control_export_all)
return
}

30
operator-default.go
View File

@ -16,23 +16,23 @@ func newDefaultTerm(tk *Token) (inst *term) {
}
}
func evalDefault(ctx ExprContext, self *term) (v any, err error) {
func evalDefault(ctx ExprContext, opTerm *term) (v any, err error) {
var rightValue any
if err = self.checkOperands(); err != nil {
if err = opTerm.checkOperands(); err != nil {
return
}
leftTerm := self.children[0]
leftTerm := opTerm.children[0]
if leftTerm.tk.Sym != SymVariable {
// err = leftTerm.Errorf("left operand of %q must be a variable", self.tk.source)
err = ErrLeftOperandMustBeVariable(leftTerm, self)
err = ErrLeftOperandMustBeVariable(leftTerm, opTerm)
return
}
if leftValue, exists := ctx.GetVar(leftTerm.source()); exists {
v = leftValue
} else if rightValue, err = self.children[1].compute(ctx); err == nil {
} else if rightValue, err = opTerm.children[1].compute(ctx); err == nil {
v = rightValue
}
return
@ -50,22 +50,22 @@ func newAlternateTerm(tk *Token) (inst *term) {
}
}
func evalAlternate(ctx ExprContext, self *term) (v any, err error) {
func evalAlternate(ctx ExprContext, opTerm *term) (v any, err error) {
var rightValue any
if err = self.checkOperands(); err != nil {
if err = opTerm.checkOperands(); err != nil {
return
}
leftTerm := self.children[0]
leftTerm := opTerm.children[0]
if leftTerm.tk.Sym != SymVariable {
// err = leftTerm.Errorf("left operand of %q must be a variable", self.tk.source)
err = ErrLeftOperandMustBeVariable(leftTerm, self)
err = ErrLeftOperandMustBeVariable(leftTerm, opTerm)
return
}
if leftValue, exists := ctx.GetVar(leftTerm.source()); exists && leftValue != nil {
if rightValue, err = self.children[1].compute(ctx); err == nil {
if rightValue, err = opTerm.children[1].compute(ctx); err == nil {
v = rightValue
}
} else {
@ -86,23 +86,23 @@ func newDefaultAssignTerm(tk *Token) (inst *term) {
}
}
func evalAssignDefault(ctx ExprContext, self *term) (v any, err error) {
func evalAssignDefault(ctx ExprContext, opTerm *term) (v any, err error) {
var rightValue any
if err = self.checkOperands(); err != nil {
if err = opTerm.checkOperands(); err != nil {
return
}
leftTerm := self.children[0]
leftTerm := opTerm.children[0]
if leftTerm.tk.Sym != SymVariable {
// err = leftTerm.Errorf("left operand of %q must be a variable", self.tk.source)
err = ErrLeftOperandMustBeVariable(leftTerm, self)
err = ErrLeftOperandMustBeVariable(leftTerm, opTerm)
return
}
if leftValue, exists := ctx.GetVar(leftTerm.source()); exists {
v = leftValue
} else if rightValue, err = self.children[1].compute(ctx); err == nil {
} else if rightValue, err = opTerm.children[1].compute(ctx); err == nil {
if functor, ok := rightValue.(Functor); ok {
//ctx.RegisterFunc(leftTerm.source(), functor, 0, -1)
ctx.RegisterFunc(leftTerm.source(), functor, TypeAny, []ExprFuncParam{

12
operator-dot.go
View File

@ -15,17 +15,17 @@ func newDotTerm(tk *Token) (inst *term) {
}
}
func evalDot(ctx ExprContext, self *term) (v any, err error) {
func evalDot(ctx ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any
if err = self.checkOperands(); err != nil {
if err = opTerm.checkOperands(); err != nil {
return
}
if leftValue, err = self.children[0].compute(ctx); err != nil {
if leftValue, err = opTerm.children[0].compute(ctx); err != nil {
return
}
indexTerm := self.children[1]
indexTerm := opTerm.children[1]
switch unboxedValue := leftValue.(type) {
case ExtIterator:
@ -41,8 +41,8 @@ func evalDot(ctx ExprContext, self *term) (v any, err error) {
err = indexTerm.tk.ErrorExpectedGot("identifier")
}
default:
if rightValue, err = self.children[1].compute(ctx); err == nil {
err = self.errIncompatibleTypes(leftValue, rightValue)
if rightValue, err = opTerm.children[1].compute(ctx); err == nil {
err = opTerm.errIncompatibleTypes(leftValue, rightValue)
}
}
return

6
operator-fact.go
View File

@ -18,10 +18,10 @@ func newFactTerm(tk *Token) (inst *term) {
}
}
func evalFact(ctx ExprContext, self *term) (v any, err error) {
func evalFact(ctx ExprContext, opTerm *term) (v any, err error) {
var leftValue any
if leftValue, err = self.evalPrefix(ctx); err != nil {
if leftValue, err = opTerm.evalPrefix(ctx); err != nil {
return
}
@ -36,7 +36,7 @@ func evalFact(ctx ExprContext, self *term) (v any, err error) {
err = fmt.Errorf("factorial of a negative integer (%d) is not allowed", i)
}
} else {
err = self.errIncompatibleType(leftValue)
err = opTerm.errIncompatibleType(leftValue)
}
return
}

4
operator-fraction.go
View File

@ -24,12 +24,12 @@ func newFractionTerm(tk *Token) *term {
}
// -------- eval func
func evalFraction(ctx ExprContext, self *term) (v any, err error) {
func evalFraction(ctx ExprContext, opTerm *term) (v any, err error) {
var numValue, denValue any
var num, den int64
var ok bool
if numValue, denValue, err = self.evalInfix(ctx); err != nil {
if numValue, denValue, err = opTerm.evalInfix(ctx); err != nil {
return
}
if num, ok = numValue.(int64); !ok {

6
operator-in.go
View File

@ -21,10 +21,10 @@ func newInTerm(tk *Token) (inst *term) {
// return
// }
func evalIn(ctx ExprContext, self *term) (v any, err error) {
func evalIn(ctx ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any
if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
return
}
@ -35,7 +35,7 @@ func evalIn(ctx ExprContext, self *term) (v any, err error) {
dict, _ := rightValue.(*DictType)
v = dict.hasKey(leftValue)
} else {
err = self.errIncompatibleTypes(leftValue, rightValue)
err = opTerm.errIncompatibleTypes(leftValue, rightValue)
}
return
}

10
operator-include.go
View File

@ -16,10 +16,10 @@ func newIncludeTerm(tk *Token) (inst *term) {
}
}
func evalInclude(ctx ExprContext, self *term) (v any, err error) {
func evalInclude(ctx ExprContext, opTerm *term) (v any, err error) {
var childValue any
if childValue, err = self.evalPrefix(ctx); err != nil {
if childValue, err = opTerm.evalPrefix(ctx); err != nil {
return
}
@ -31,11 +31,11 @@ func evalInclude(ctx ExprContext, self *term) (v any, err error) {
if v, err = EvalFile(ctx, filePath); err == nil {
count++
} else {
err = self.Errorf("can't load file %q", filePath)
err = opTerm.Errorf("can't load file %q", filePath)
break
}
} else {
err = self.Errorf("expected string at item nr %d, got %T", i+1, filePathSpec)
err = opTerm.Errorf("expected string at item nr %d, got %T", i+1, filePathSpec)
break
}
}
@ -45,7 +45,7 @@ func evalInclude(ctx ExprContext, self *term) (v any, err error) {
count++
}
} else {
err = self.errIncompatibleType(childValue)
err = opTerm.errIncompatibleType(childValue)
}
if err == nil {
v = count

27
operator-index.go
View File

@ -59,18 +59,18 @@ func verifyRange(indexTerm *term, indexList *ListType, maxValue int) (startIndex
return
}
func evalIndex(ctx ExprContext, self *term) (v any, err error) {
func evalIndex(ctx ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any
var indexList *ListType
var ok bool
if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
return
}
indexTerm := self.children[1]
indexTerm := opTerm.children[1]
if indexList, ok = rightValue.(*ListType); !ok {
err = self.Errorf("invalid index expression")
err = opTerm.Errorf("invalid index expression")
return
} else if len(*indexList) != 1 {
err = indexTerm.Errorf("one index only is allowed")
@ -90,16 +90,9 @@ func evalIndex(ctx ExprContext, self *term) (v any, err error) {
v = string(unboxedValue[index])
}
case *DictType:
/* var ok bool
var indexValue any
if indexValue, err = verifyKey(indexTerm, indexList); err == nil {
if v, ok = (*unboxedValue)[indexValue]; !ok {
err = indexTerm.Errorf("key %v does not belong to the dictionary", rightValue)
}
} */
v, err = getDictItem(unboxedValue, indexTerm, indexList, rightValue)
default:
err = self.errIncompatibleTypes(leftValue, rightValue)
err = opTerm.errIncompatibleTypes(leftValue, rightValue)
}
} else if isIntPair((*indexList)[0]) {
switch unboxedValue := leftValue.(type) {
@ -115,18 +108,10 @@ func evalIndex(ctx ExprContext, self *term) (v any, err error) {
v = unboxedValue[start:end]
}
default:
err = self.errIncompatibleTypes(leftValue, rightValue)
err = opTerm.errIncompatibleTypes(leftValue, rightValue)
}
} else if IsDict(leftValue) {
d := leftValue.(*DictType)
/* var ok bool
var indexValue any
if indexValue, err = verifyKey(indexTerm, indexList); err == nil {
if v, ok = (*d)[indexValue]; !ok {
err = indexTerm.Errorf("key %v does not belong to the dictionary", rightValue)
}
}*/
v, err = getDictItem(d, indexTerm, indexList, rightValue)
}
return

20
operator-insert.go
View File

@ -26,10 +26,10 @@ func newAppendTerm(tk *Token) (inst *term) {
}
}
func evalInsert(ctx ExprContext, self *term) (v any, err error) {
func evalInsert(ctx ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any
if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
return
}
@ -37,19 +37,19 @@ func evalInsert(ctx ExprContext, self *term) (v any, err error) {
list, _ := rightValue.(*ListType)
newList := append(ListType{leftValue}, *list...)
v = &newList
if self.children[1].symbol() == SymVariable {
ctx.UnsafeSetVar(self.children[1].source(), v)
if opTerm.children[1].symbol() == SymVariable {
ctx.UnsafeSetVar(opTerm.children[1].source(), v)
}
} else {
err = self.errIncompatibleTypes(leftValue, rightValue)
err = opTerm.errIncompatibleTypes(leftValue, rightValue)
}
return
}
func evalAppend(ctx ExprContext, self *term) (v any, err error) {
func evalAppend(ctx ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any
if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
return
}
@ -57,11 +57,11 @@ func evalAppend(ctx ExprContext, self *term) (v any, err error) {
list, _ := leftValue.(*ListType)
newList := append(*list, rightValue)
v = &newList
if self.children[0].symbol() == SymVariable {
ctx.UnsafeSetVar(self.children[0].source(), v)
if opTerm.children[0].symbol() == SymVariable {
ctx.UnsafeSetVar(opTerm.children[0].source(), v)
}
} else {
err = self.errIncompatibleTypes(leftValue, rightValue)
err = opTerm.errIncompatibleTypes(leftValue, rightValue)
}
return
}

6
operator-iter-value.go
View File

@ -16,17 +16,17 @@ func newIterValueTerm(tk *Token) (inst *term) {
}
}
func evalIterValue(ctx ExprContext, self *term) (v any, err error) {
func evalIterValue(ctx ExprContext, opTerm *term) (v any, err error) {
var childValue any
if childValue, err = self.evalPrefix(ctx); err != nil {
if childValue, err = opTerm.evalPrefix(ctx); err != nil {
return
}
if it, ok := childValue.(Iterator); ok {
v, err = it.Current()
} else {
err = self.errIncompatibleType(childValue)
err = opTerm.errIncompatibleType(childValue)
}
return
}

6
operator-length.go
View File

@ -16,10 +16,10 @@ func newLengthTerm(tk *Token) (inst *term) {
}
}
func evalLength(ctx ExprContext, self *term) (v any, err error) {
func evalLength(ctx ExprContext, opTerm *term) (v any, err error) {
var childValue any
if childValue, err = self.evalPrefix(ctx); err != nil {
if childValue, err = opTerm.evalPrefix(ctx); err != nil {
return
}
@ -41,7 +41,7 @@ func evalLength(ctx ExprContext, self *term) (v any, err error) {
v = int64(it.Index() + 1)
}
} else {
err = self.errIncompatibleType(childValue)
err = opTerm.errIncompatibleType(childValue)
}
return
}

6
operator-plugin.go
View File

@ -20,11 +20,11 @@ func newPluginTerm(tk *Token) (inst *term) {
}
}
func evalPlugin(ctx ExprContext, self *term) (v any, err error) {
func evalPlugin(ctx ExprContext, opTerm *term) (v any, err error) {
var childValue any
var moduleSpec any
if childValue, err = self.evalPrefix(ctx); err != nil {
if childValue, err = opTerm.evalPrefix(ctx); err != nil {
return
}
@ -38,7 +38,7 @@ func evalPlugin(ctx ExprContext, self *term) (v any, err error) {
}
count++
} else {
err = self.Errorf("expected string as item nr %d, got %s", it.Index()+1, TypeName(moduleSpec))
err = opTerm.Errorf("expected string as item nr %d, got %s", it.Index()+1, TypeName(moduleSpec))
break
}
}

10
operator-post-inc.go
View File

@ -17,20 +17,20 @@ func newPostIncTerm(tk *Token) *term {
}
}
func evalPostInc(ctx ExprContext, self *term) (v any, err error) {
func evalPostInc(ctx ExprContext, opTerm *term) (v any, err error) {
var childValue any
if childValue, err = self.evalPrefix(ctx); err != nil {
if childValue, err = opTerm.evalPrefix(ctx); err != nil {
return
}
if it, ok := childValue.(Iterator); ok {
v, err = it.Next()
} else if IsInteger(childValue) && self.children[0].symbol() == SymVariable {
} else if IsInteger(childValue) && opTerm.children[0].symbol() == SymVariable {
v = childValue
i, _ := childValue.(int64)
ctx.SetVar(self.children[0].source(), i+1)
ctx.SetVar(opTerm.children[0].source(), i+1)
} else {
err = self.errIncompatibleType(childValue)
err = opTerm.errIncompatibleType(childValue)
}
return
}

34
operator-prod.go
View File

@ -14,8 +14,6 @@ import (
func newMultiplyTerm(tk *Token) (inst *term) {
return &term{
tk: *tk,
// class: classOperator,
// kind: kindUnknown,
children: make([]*term, 0, 2),
position: posInfix,
priority: priProduct,
@ -23,10 +21,10 @@ func newMultiplyTerm(tk *Token) (inst *term) {
}
}
func evalMultiply(ctx ExprContext, self *term) (v any, err error) {
func evalMultiply(ctx ExprContext, prodTerm *term) (v any, err error) {
var leftValue, rightValue any
if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
if leftValue, rightValue, err = prodTerm.evalInfix(ctx); err != nil {
return
}
@ -45,7 +43,7 @@ func evalMultiply(ctx ExprContext, self *term) (v any, err error) {
v = leftInt * rightInt
}
} else {
err = self.errIncompatibleTypes(leftValue, rightValue)
err = prodTerm.errIncompatibleTypes(leftValue, rightValue)
}
return
}
@ -55,8 +53,6 @@ func evalMultiply(ctx ExprContext, self *term) (v any, err error) {
func newDivideTerm(tk *Token) (inst *term) {
return &term{
tk: *tk,
// class: classOperator,
// kind: kindUnknown,
children: make([]*term, 0, 2),
position: posInfix,
priority: priProduct,
@ -64,10 +60,10 @@ func newDivideTerm(tk *Token) (inst *term) {
}
}
func evalDivide(ctx ExprContext, self *term) (v any, err error) {
func evalDivide(ctx ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any
if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
return
}
@ -90,7 +86,7 @@ func evalDivide(ctx ExprContext, self *term) (v any, err error) {
}
}
} else {
err = self.errIncompatibleTypes(leftValue, rightValue)
err = opTerm.errIncompatibleTypes(leftValue, rightValue)
}
return
}
@ -107,10 +103,10 @@ func newDivideAsFloatTerm(tk *Token) (inst *term) {
}
}
func evalDivideAsFloat(ctx ExprContext, self *term) (v any, err error) {
func evalDivideAsFloat(ctx ExprContext, floatDivTerm *term) (v any, err error) {
var leftValue, rightValue any
if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
if leftValue, rightValue, err = floatDivTerm.evalInfix(ctx); err != nil {
return
}
@ -122,18 +118,16 @@ func evalDivideAsFloat(ctx ExprContext, self *term) (v any, err error) {
v = numAsFloat(leftValue) / d
}
} else {
err = self.errIncompatibleTypes(leftValue, rightValue)
err = floatDivTerm.errIncompatibleTypes(leftValue, rightValue)
}
return
}
//-------- reminder term
func newReminderTerm(tk *Token) (inst *term) {
func newRemainderTerm(tk *Token) (inst *term) {
return &term{
tk: *tk,
// class: classOperator,
// kind: kindUnknown,
children: make([]*term, 0, 2),
position: posInfix,
priority: priProduct,
@ -141,10 +135,10 @@ func newReminderTerm(tk *Token) (inst *term) {
}
}
func evalReminder(ctx ExprContext, self *term) (v any, err error) {
func evalReminder(ctx ExprContext, ramainderTerm *term) (v any, err error) {
var leftValue, rightValue any
if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
if leftValue, rightValue, err = ramainderTerm.evalInfix(ctx); err != nil {
return
}
@ -157,7 +151,7 @@ func evalReminder(ctx ExprContext, self *term) (v any, err error) {
v = leftInt % rightInt
}
} else {
err = self.errIncompatibleTypes(leftValue, rightValue)
err = ramainderTerm.errIncompatibleTypes(leftValue, rightValue)
}
return
}
@ -167,5 +161,5 @@ func init() {
registerTermConstructor(SymStar, newMultiplyTerm)
registerTermConstructor(SymSlash, newDivideTerm)
registerTermConstructor(SymDotSlash, newDivideAsFloatTerm)
registerTermConstructor(SymPercent, newReminderTerm)
registerTermConstructor(SymPercent, newRemainderTerm)
}

12
operator-range.go
View File

@ -34,25 +34,25 @@ func newRangeTerm(tk *Token) (inst *term) {
}
}
func evalRange(ctx ExprContext, self *term) (v any, err error) {
func evalRange(ctx ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any
// if err = self.checkOperands(); err != nil {
// return
// }
if len(self.children) == 0 {
if len(opTerm.children) == 0 {
leftValue = int64(0)
rightValue = int64(-1)
} else if len(self.children) == 1 {
if leftValue, err = self.children[0].compute(ctx); err != nil {
} else if len(opTerm.children) == 1 {
if leftValue, err = opTerm.children[0].compute(ctx); err != nil {
return
}
rightValue = int64(ConstLastIndex)
} else if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
} else if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
return
}
if !(IsInteger(leftValue) && IsInteger(rightValue)) {
err = self.errIncompatibleTypes(leftValue, rightValue)
err = opTerm.errIncompatibleTypes(leftValue, rightValue)
return
}

32
operator-rel.go
View File

@ -45,10 +45,10 @@ func equals(a, b any, deepCmp deepFuncTemplate) (eq bool, err error) {
return
}
func evalEqual(ctx ExprContext, self *term) (v any, err error) {
func evalEqual(ctx ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any
if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
return
}
@ -68,8 +68,8 @@ func newNotEqualTerm(tk *Token) (inst *term) {
}
}
func evalNotEqual(ctx ExprContext, self *term) (v any, err error) {
if v, err = evalEqual(ctx, self); err == nil {
func evalNotEqual(ctx ExprContext, opTerm *term) (v any, err error) {
if v, err = evalEqual(ctx, opTerm); err == nil {
b, _ := ToBool(v)
v = !b
}
@ -119,13 +119,13 @@ func lessThan(self *term, a, b any) (isLess bool, err error) {
return
}
func evalLess(ctx ExprContext, self *term) (v any, err error) {
func evalLess(ctx ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any
if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
return
}
v, err = lessThan(self, leftValue, rightValue)
v, err = lessThan(opTerm, leftValue, rightValue)
return
}
@ -154,14 +154,14 @@ func lessThanOrEqual(self *term, a, b any) (isLessEq bool, err error) {
return
}
func evalLessEqual(ctx ExprContext, self *term) (v any, err error) {
func evalLessEqual(ctx ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any
if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
return
}
v, err = lessThanOrEqual(self, leftValue, rightValue)
v, err = lessThanOrEqual(opTerm, leftValue, rightValue)
return
}
@ -178,14 +178,14 @@ func newGreaterTerm(tk *Token) (inst *term) {
}
}
func evalGreater(ctx ExprContext, self *term) (v any, err error) {
func evalGreater(ctx ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any
if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
return
}
v, err = lessThan(self, rightValue, leftValue)
v, err = lessThan(opTerm, rightValue, leftValue)
return
}
@ -201,14 +201,14 @@ func newGreaterEqualTerm(tk *Token) (inst *term) {
}
}
func evalGreaterEqual(ctx ExprContext, self *term) (v any, err error) {
func evalGreaterEqual(ctx ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any
if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
return
}
v, err = lessThanOrEqual(self, rightValue, leftValue)
v, err = lessThanOrEqual(opTerm, rightValue, leftValue)
return
}

8
operator-selector.go
View File

@ -39,19 +39,19 @@ func trySelectorCase(ctx ExprContext, exprValue, caseSel any, caseIndex int) (ma
return
}
func evalSelector(ctx ExprContext, self *term) (v any, err error) {
func evalSelector(ctx ExprContext, opTerm *term) (v any, err error) {
var exprValue any
var match bool
if err = self.checkOperands(); err != nil {
if err = opTerm.checkOperands(); err != nil {
return
}
exprTerm := self.children[0]
exprTerm := opTerm.children[0]
if exprValue, err = exprTerm.compute(ctx); err != nil {
return
}
caseListTerm := self.children[1]
caseListTerm := opTerm.children[1]
caseList, _ := caseListTerm.value().([]*term)
for i, caseTerm := range caseList {
caseSel := caseTerm.value()

10
operator-sign.go
View File

@ -28,29 +28,29 @@ func newMinusSignTerm(tk *Token) (inst *term) {
}
}
func evalSign(ctx ExprContext, self *term) (v any, err error) {
func evalSign(ctx ExprContext, opTerm *term) (v any, err error) {
var rightValue any
if rightValue, err = self.evalPrefix(ctx); err != nil {
if rightValue, err = opTerm.evalPrefix(ctx); err != nil {
return
}
if IsFloat(rightValue) {
if self.tk.Sym == SymChangeSign {
if opTerm.tk.Sym == SymChangeSign {
f, _ := rightValue.(float64)
v = -f
} else {
v = rightValue
}
} else if IsInteger(rightValue) {
if self.tk.Sym == SymChangeSign {
if opTerm.tk.Sym == SymChangeSign {
i, _ := rightValue.(int64)
v = -i
} else {
v = rightValue
}
} else {
err = self.errIncompatibleType(rightValue)
err = opTerm.errIncompatibleType(rightValue)
}
return
}