Added all source files

2024-03-26 07:00:53 +01:00
parent 737696b71e
commit 522b880ca3
24 changed files with 2361 additions and 0 deletions
@@ -0,0 +1,220 @@
+// operator-rel.go
+package expr
+
+//-------- equal term
+
+func newEqualTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		class:    classOperator,
+		kind:     kindBool,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priRelational,
+		evalFunc: evalEqual,
+	}
+}
+
+func evalEqual(ctx exprContext, self *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+		return
+	}
+
+	if isNumber(leftValue) && isNumber(rightValue) {
+		if isInteger(leftValue) && isInteger(rightValue) {
+			li, _ := leftValue.(int64)
+			ri, _ := rightValue.(int64)
+			v = li == ri
+		} else {
+			v = numAsFloat(leftValue) == numAsFloat(rightValue)
+		}
+	} else if isString(leftValue) && isString(rightValue) {
+		ls, _ := leftValue.(string)
+		rs, _ := rightValue.(string)
+		v = ls == rs
+	} else {
+		err = self.errIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
+//-------- not equal term
+
+func newNotEqualTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		class:    classOperator,
+		kind:     kindBool,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priRelational,
+		evalFunc: evalNotEqual,
+	}
+}
+
+func evalNotEqual(ctx exprContext, self *term) (v any, err error) {
+	if v, err = evalEqual(ctx, self); err == nil {
+		b, _ := toBool(v)
+		v = !b
+	}
+	return
+}
+
+// func evalNotEqual(ctx exprContext, self *term) (v any, err error) {
+// 	var leftValue, rightValue any
+
+// 	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+// 		return
+// 	}
+
+// 	if isNumber(leftValue) && isNumber(rightValue) {
+// 		if isInteger(leftValue) && isInteger(rightValue) {
+// 			li, _ := leftValue.(int64)
+// 			ri, _ := rightValue.(int64)
+// 			v = li != ri
+// 		} else {
+// 			v = numAsFloat(leftValue) != numAsFloat(rightValue)
+// 		}
+// 	} else if isString(leftValue) && isString(rightValue) {
+// 		ls, _ := leftValue.(string)
+// 		rs, _ := rightValue.(string)
+// 		v = ls != rs
+// 	} else {
+// 		err = self.errIncompatibleTypes(leftValue, rightValue)
+// 	}
+// 	return
+// }
+
+//-------- less term
+
+func newLessTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		class:    classOperator,
+		kind:     kindBool,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priRelational,
+		evalFunc: evalLess,
+	}
+}
+
+func evalLess(ctx exprContext, self *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+		return
+	}
+
+	if isNumber(leftValue) && isNumber(rightValue) {
+		if isInteger(leftValue) && isInteger(rightValue) {
+			li, _ := leftValue.(int64)
+			ri, _ := rightValue.(int64)
+			v = li < ri
+		} else {
+			v = numAsFloat(leftValue) < numAsFloat(rightValue)
+		}
+	} else if isString(leftValue) && isString(rightValue) {
+		ls, _ := leftValue.(string)
+		rs, _ := rightValue.(string)
+		v = ls < rs
+	} else {
+		err = self.errIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
+//-------- less or equal term
+
+func newLessEqualTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		class:    classOperator,
+		kind:     kindUnknown,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priRelational,
+		evalFunc: evalLessEqual,
+	}
+}
+
+func evalLessEqual(ctx exprContext, self *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+		return
+	}
+
+	if isNumber(leftValue) && isNumber(rightValue) {
+		if isInteger(leftValue) && isInteger(rightValue) {
+			li, _ := leftValue.(int64)
+			ri, _ := rightValue.(int64)
+			v = li <= ri
+		} else {
+			v = numAsFloat(leftValue) <= numAsFloat(rightValue)
+		}
+	} else if isString(leftValue) && isString(rightValue) {
+		ls, _ := leftValue.(string)
+		rs, _ := rightValue.(string)
+		v = ls <= rs
+	} else {
+		err = self.errIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
+//-------- greater term
+
+func newGreaterTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		class:    classOperator,
+		kind:     kindBool,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priRelational,
+		evalFunc: evalGreater,
+	}
+}
+
+func evalGreater(ctx exprContext, self *term) (v any, err error) {
+	if v, err = evalLessEqual(ctx, self); err == nil {
+		b, _ := toBool(v)
+		v = !b
+	}
+	return
+}
+
+//-------- greater or equal term
+
+func newGreaterEqualTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		class:    classOperator,
+		kind:     kindBool,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priRelational,
+		evalFunc: evalGreaterEqual,
+	}
+}
+
+func evalGreaterEqual(ctx exprContext, self *term) (v any, err error) {
+	if v, err = evalLess(ctx, self); err == nil {
+		b, _ := toBool(v)
+		v = !b
+	}
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymDoubleEqual, newEqualTerm)
+	registerTermConstructor(SymNotEqual, newNotEqualTerm)
+	registerTermConstructor(SymLess, newLessTerm)
+	registerTermConstructor(SymLessOrEqual, newLessEqualTerm)
+	registerTermConstructor(SymGreater, newGreaterTerm)
+	registerTermConstructor(SymGreaterOrEqual, newGreaterEqualTerm)
+}