From 6b3bfa2a110b6ee2abb9b90f350f61875bbc7c24 Mon Sep 17 00:00:00 2001 From: Celestino Amoroso Date: Tue, 9 Jul 2024 07:50:06 +0200 Subject: [PATCH] self param replaced as opTerm --- operand-dict.go | 4 ++-- operand-expr.go | 6 +++--- operand-func.go | 16 ++++++++-------- operand-iterator.go | 14 +++++++------- operand-list.go | 4 ++-- operand-literal.go | 4 ++-- operand-selector-case.go | 6 +++--- operand-var.go | 4 ++-- operator-assign.go | 12 ++++++------ operator-bool.go | 6 +++--- operator-builtin.go | 8 ++++---- operator-but.go | 4 ++-- operator-context.go | 10 +++++----- operator-ctrl.go | 2 +- operator-default.go | 30 +++++++++++++++--------------- operator-dot.go | 12 ++++++------ operator-fact.go | 6 +++--- operator-fraction.go | 4 ++-- operator-in.go | 6 +++--- operator-include.go | 10 +++++----- operator-index.go | 27 ++++++--------------------- operator-insert.go | 20 ++++++++++---------- operator-iter-value.go | 6 +++--- operator-length.go | 6 +++--- operator-plugin.go | 6 +++--- operator-post-inc.go | 10 +++++----- operator-prod.go | 34 ++++++++++++++-------------------- operator-range.go | 12 ++++++------ operator-rel.go | 32 ++++++++++++++++---------------- operator-selector.go | 8 ++++---- operator-sign.go | 10 +++++----- 31 files changed, 159 insertions(+), 180 deletions(-) diff --git a/operand-dict.go b/operand-dict.go index 95b9463..26ba51c 100644 --- a/operand-dict.go +++ b/operand-dict.go @@ -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 diff --git a/operand-expr.go b/operand-expr.go index 7069fbc..044a22f 100644 --- a/operand-expr.go +++ b/operand-expr.go @@ -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 } diff --git a/operand-func.go b/operand-func.go index a044a0c..3ff3ba4 100644 --- a/operand-func.go +++ b/operand-func.go @@ -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 { diff --git a/operand-iterator.go b/operand-iterator.go index bb9b883..c46294c 100644 --- a/operand-iterator.go +++ b/operand-iterator.go @@ -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) } } diff --git a/operand-list.go b/operand-list.go index 6f10a88..ec292cd 100644 --- a/operand-list.go +++ b/operand-list.go @@ -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 diff --git a/operand-literal.go b/operand-literal.go index 74d2704..439ee15 100644 --- a/operand-literal.go +++ b/operand-literal.go @@ -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 } diff --git a/operand-selector-case.go b/operand-selector-case.go index b4c0ea9..7b48604 100644 --- a/operand-selector-case.go +++ b/operand-selector-case.go @@ -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 } diff --git a/operand-var.go b/operand-var.go index e2d4d9a..33a1fbc 100644 --- a/operand-var.go +++ b/operand-var.go @@ -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() diff --git a/operator-assign.go b/operator-assign.go index f964364..86bcc58 100644 --- a/operator-assign.go +++ b/operator-assign.go @@ -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) diff --git a/operator-bool.go b/operator-bool.go index 3a70f5e..c32dfc4 100644 --- a/operator-bool.go +++ b/operator-bool.go @@ -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 } diff --git a/operator-builtin.go b/operator-builtin.go index c5ab462..8c0eda3 100644 --- a/operator-builtin.go +++ b/operator-builtin.go @@ -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 } } diff --git a/operator-but.go b/operator-but.go index f145aab..0b1044c 100644 --- a/operator-but.go +++ b/operator-but.go @@ -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 } diff --git a/operator-context.go b/operator-context.go index ab126b4..8fd2beb 100644 --- a/operator-context.go +++ b/operator-context.go @@ -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 } diff --git a/operator-ctrl.go b/operator-ctrl.go index a32c41e..50b5f47 100644 --- a/operator-ctrl.go +++ b/operator-ctrl.go @@ -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 } diff --git a/operator-default.go b/operator-default.go index f519566..905f9bd 100644 --- a/operator-default.go +++ b/operator-default.go @@ -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{ diff --git a/operator-dot.go b/operator-dot.go index 5da1d94..ebc849e 100644 --- a/operator-dot.go +++ b/operator-dot.go @@ -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 diff --git a/operator-fact.go b/operator-fact.go index 3f27823..d38215f 100644 --- a/operator-fact.go +++ b/operator-fact.go @@ -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 } diff --git a/operator-fraction.go b/operator-fraction.go index 47e117a..e128557 100644 --- a/operator-fraction.go +++ b/operator-fraction.go @@ -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 { diff --git a/operator-in.go b/operator-in.go index 440daa3..8300426 100644 --- a/operator-in.go +++ b/operator-in.go @@ -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 } diff --git a/operator-include.go b/operator-include.go index 7f8297d..520396e 100644 --- a/operator-include.go +++ b/operator-include.go @@ -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 diff --git a/operator-index.go b/operator-index.go index 17154b5..ec19582 100644 --- a/operator-index.go +++ b/operator-index.go @@ -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 diff --git a/operator-insert.go b/operator-insert.go index d21c1ff..076a3c2 100644 --- a/operator-insert.go +++ b/operator-insert.go @@ -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 } diff --git a/operator-iter-value.go b/operator-iter-value.go index be093b8..2431e98 100644 --- a/operator-iter-value.go +++ b/operator-iter-value.go @@ -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 } diff --git a/operator-length.go b/operator-length.go index 80c9ee6..e3db58d 100644 --- a/operator-length.go +++ b/operator-length.go @@ -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 } diff --git a/operator-plugin.go b/operator-plugin.go index 786bc1a..464fd58 100644 --- a/operator-plugin.go +++ b/operator-plugin.go @@ -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 } } diff --git a/operator-post-inc.go b/operator-post-inc.go index e8f1e0d..b053a43 100644 --- a/operator-post-inc.go +++ b/operator-post-inc.go @@ -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 } diff --git a/operator-prod.go b/operator-prod.go index b4deef4..bd2b71a 100644 --- a/operator-prod.go +++ b/operator-prod.go @@ -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) } diff --git a/operator-range.go b/operator-range.go index 14ee694..1e2a15a 100644 --- a/operator-range.go +++ b/operator-range.go @@ -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 } diff --git a/operator-rel.go b/operator-rel.go index 4544216..4aed27e 100644 --- a/operator-rel.go +++ b/operator-rel.go @@ -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 } diff --git a/operator-selector.go b/operator-selector.go index 684d335..e12bdc5 100644 --- a/operator-selector.go +++ b/operator-selector.go @@ -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() diff --git a/operator-sign.go b/operator-sign.go index 768025b..3dd2e29 100644 --- a/operator-sign.go +++ b/operator-sign.go @@ -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 }