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

New operator %=

Browse Source
This commit is contained in:
Celestino Amoroso 2024-12-19 15:14:30 +01:00
parent 6ee21e10af
commit 8e5550bfa7
7 changed files with 21 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
go.sum Normal file
View File

@ -0,0 +1,4 @@
github.com/yqylovy/goimportdot v0.0.0-20170519021755-eb181a7eeabe h1:bWYrKmmfv37uNgXTdwkLSKYiYPJ1yfWmjBnvtMyAYzk=
github.com/yqylovy/goimportdot v0.0.0-20170519021755-eb181a7eeabe/go.mod h1:alTKUpAJ/zbp17qvZwcFNwzufrb5DljMDY4mgJlIHao=
golang.org/x/exp v0.0.0-20241204233417-43b7b7cde48d h1:0olWaB5pg3+oychR51GUVCEsGkeCU/2JxjBgIo4f3M0=
golang.org/x/exp v0.0.0-20241204233417-43b7b7cde48d/go.mod h1:qj5a5QZpwLU2NLQudwIN5koi3beDhSAlJwa67PuM98c=

2
operator-assign.go
View File

@ -181,6 +181,8 @@ func evalOpAssign(ctx ExprContext, opTerm *term) (v any, err error) {
v, err = mulValues(opTerm, leftValue, rightValue)
case SymSlashEqual:
v, err = divValues(opTerm, leftValue, rightValue)
case SymPercEqual:
v, err = remainderValues(opTerm, leftValue, rightValue)
default:
err = opTerm.Errorf("unsupported assign operator %q", opTerm.source())
}

63
operator-prod.go
View File

@ -50,24 +50,6 @@ func evalMultiply(ctx ExprContext, prodTerm *term) (v any, err error) {
}
return mulValues(prodTerm, leftValue, rightValue)
// if IsString(leftValue) && IsInteger(rightValue) {
// s, _ := leftValue.(string)
// n, _ := rightValue.(int64)
// v = strings.Repeat(s, int(n))
// } else if isNumOrFract(leftValue) && isNumOrFract(rightValue) {
// if IsFloat(leftValue) || IsFloat(rightValue) {
// v = numAsFloat(leftValue) * numAsFloat(rightValue)
// } else if isFraction(leftValue) || isFraction(rightValue) {
// v, err = mulAnyFract(leftValue, rightValue)
// } else {
// leftInt, _ := leftValue.(int64)
// rightInt, _ := rightValue.(int64)
// v = leftInt * rightInt
// }
// } else {
// err = prodTerm.errIncompatibleTypes(leftValue, rightValue)
// }
// return
}
//-------- divide term
@ -115,28 +97,6 @@ func evalDivide(ctx ExprContext, opTerm *term) (v any, err error) {
}
return divValues(opTerm, leftValue, rightValue)
// if isNumOrFract(leftValue) && isNumOrFract(rightValue) {
// if IsFloat(leftValue) || IsFloat(rightValue) {
// d := numAsFloat(rightValue)
// if d == 0.0 {
// err = errors.New("division by zero")
// } else {
// v = numAsFloat(leftValue) / d
// }
// } else if isFraction(leftValue) || isFraction(rightValue) {
// v, err = divAnyFract(leftValue, rightValue)
// } else {
// leftInt, _ := leftValue.(int64)
// if rightInt, _ := rightValue.(int64); rightInt == 0 {
// err = errors.New("division by zero")
// } else {
// v = leftInt / rightInt
// }
// }
// } else {
// err = opTerm.errIncompatibleTypes(leftValue, rightValue)
// }
// return
}
//-------- divide as float term
@ -179,17 +139,10 @@ func newRemainderTerm(tk *Token) (inst *term) {
children: make([]*term, 0, 2),
position: posInfix,
priority: priProduct,
evalFunc: evalReminder,
evalFunc: evalRemainder,
}
}
func evalReminder(ctx ExprContext, ramainderTerm *term) (v any, err error) {
var leftValue, rightValue any
if leftValue, rightValue, err = ramainderTerm.evalInfix(ctx); err != nil {
return
}
func remainderValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
if IsInteger(leftValue) && IsInteger(rightValue) {
rightInt, _ := rightValue.(int64)
if rightInt == 0 {
@ -199,11 +152,21 @@ func evalReminder(ctx ExprContext, ramainderTerm *term) (v any, err error) {
v = leftInt % rightInt
}
} else {
err = ramainderTerm.errIncompatibleTypes(leftValue, rightValue)
err = opTerm.errIncompatibleTypes(leftValue, rightValue)
}
return
}
func evalRemainder(ctx ExprContext, remainderTerm *term) (v any, err error) {
var leftValue, rightValue any
if leftValue, rightValue, err = remainderTerm.evalInfix(ctx); err != nil {
return
}
return remainderValues(remainderTerm, leftValue, rightValue)
}
// init
func init() {
registerTermConstructor(SymStar, newMultiplyTerm)

59
operator-sum.go
View File

@ -67,41 +67,6 @@ func evalPlus(ctx ExprContext, plusTerm *term) (v any, err error) {
}
return sumValues(plusTerm, leftValue, rightValue)
// if (IsString(leftValue) && isNumberString(rightValue)) || (IsString(rightValue) && isNumberString(leftValue)) {
// v = fmt.Sprintf("%v%v", leftValue, rightValue)
// } else if IsNumber(leftValue) && IsNumber(rightValue) {
// if IsFloat(leftValue) || IsFloat(rightValue) {
// v = numAsFloat(leftValue) + numAsFloat(rightValue)
// } else {
// leftInt, _ := leftValue.(int64)
// rightInt, _ := rightValue.(int64)
// v = leftInt + rightInt
// }
// } else if IsList(leftValue) && IsList(rightValue) {
// var leftList, rightList *ListType
// leftList, _ = leftValue.(*ListType)
// rightList, _ = rightValue.(*ListType)
// sumList := make(ListType, 0, len(*leftList)+len(*rightList))
// sumList = append(sumList, *leftList...)
// sumList = append(sumList, *rightList...)
// v = &sumList
// } else if (isFraction(leftValue) && IsNumber(rightValue)) || (isFraction(rightValue) && IsNumber(leftValue)) {
// if IsFloat(leftValue) || IsFloat(rightValue) {
// v = numAsFloat(leftValue) + numAsFloat(rightValue)
// } else {
// v, err = sumAnyFract(leftValue, rightValue)
// }
// } else if IsDict(leftValue) && IsDict(rightValue) {
// leftDict, _ := leftValue.(*DictType)
// rightDict, _ := rightValue.(*DictType)
// c := leftDict.clone()
// c.merge(rightDict)
// v = c
// } else {
// err = plusTerm.errIncompatibleTypes(leftValue, rightValue)
// }
// return
}
//-------- minus term
@ -151,30 +116,6 @@ func evalMinus(ctx ExprContext, minusTerm *term) (v any, err error) {
}
return diffValues(minusTerm, leftValue, rightValue)
// if isNumOrFract(leftValue) && isNumOrFract(rightValue) {
// if IsFloat(leftValue) || IsFloat(rightValue) {
// v = numAsFloat(leftValue) - numAsFloat(rightValue)
// } else if isFraction(leftValue) || isFraction(rightValue) {
// v, err = subAnyFract(leftValue, rightValue)
// } else {
// leftInt, _ := leftValue.(int64)
// rightInt, _ := rightValue.(int64)
// v = leftInt - rightInt
// }
// } else if IsList(leftValue) && IsList(rightValue) {
// leftList, _ := leftValue.(*ListType)
// rightList, _ := rightValue.(*ListType)
// diffList := make(ListType, 0, len(*leftList)-len(*rightList))
// for _, item := range *leftList {
// if slices.Index(*rightList, item) < 0 {
// diffList = append(diffList, item)
// }
// }
// v = &diffList
// } else {
// err = minusTerm.errIncompatibleTypes(leftValue, rightValue)
// }
// return
}
// init

57
parser.go
View File

@ -513,16 +513,6 @@ func (parser *parser) parseGeneral(scanner *scanner, ctx parserContext, termSymb
// Colon outside a selector term acts like a separator
firstToken = true
}
// case SymPlusEqual:
// opTk := NewToken(tk.row, tk.col, SymEqual, "=")
// if _, err = tree.addToken(opTk); err == nil {
// if err = tree.addTerm(tree.root.Clone()); err == nil {
// opTk = NewToken(tk.row, tk.col, SymPlus, "+")
// currentTerm, err = tree.addToken(opTk)
// }
// }
// case SymStarEqual:
// currentTerm, err = parser.expandOpAssign(scanner, tree, tk, ctx, termSymbols)
default:
currentTerm, err = tree.addToken(tk)
}
@ -560,50 +550,3 @@ func (parser *parser) parseGeneral(scanner *scanner, ctx parserContext, termSymb
// }
// return
// }
// func (parser *parser) expandOpAssign(scanner *scanner, tree *ast, tk *Token, ctx parserContext, termSymbols []Symbol) (t *term, err error) {
// var opSym Symbol
// var opString string
// if tree.root != nil {
// switch tk.Sym {
// case SymPlusEqual:
// opString = "+"
// opSym = SymPlus
// case SymMinusEqual:
// opString = "-"
// opSym = SymMinus
// case SymStarEqual:
// opString = "*"
// opSym = SymStar
// default:
// err = tk.Errorf("unsopported operator %q", tk.source)
// return
// }
// leftExpr := tree.root.Clone()
// leftExpr.setParent(nil)
// if t, err = tree.addToken(NewToken(tk.row, tk.col, SymEqual, "=")); err == nil {
// t = leftExpr
// if err = tree.addTerm(leftExpr); err == nil {
// if t, err = tree.addToken(NewToken(tk.row, tk.col, opSym, opString)); err == nil {
// var subTree *ast
// // if subTree, err = parser.parseGeneral(scanner, ctx, SymEos, SymSemiColon, SymClosedRound, SymClosedBrace, SymClosedSquare); err == nil {
// if subTree, err = parser.parseGeneral(scanner, ctx, termSymbols...); err == nil {
// if scanner.Previous().IsOneOfA(SymSemiColon, SymClosedRound, SymClosedBrace, SymClosedSquare) {
// if err = scanner.UnreadToken(); err != nil {
// return
// }
// }
// subTree.root.priority = priValue
// err = tree.addTerm(newExprTerm(subTree.root))
// t = subTree.root
// }
// }
// }
// }
// } else {
// err = tk.Errorf("left operand of %q must be a variable or a variable expression", tk)
// }
// return
// }

1
symbol-map.go
View File

@ -92,6 +92,7 @@ func init() {
SymTripleDot: {"...", symClassOperator}, // 59: '...'
SymStarEqual: {"*=", symClassOperator}, // 60: '*='
SymSlashEqual: {"/=", symClassOperator}, // 61: '/='
SymPercEqual: {"%=", symClassOperator}, // 62: '%='
// SymChangeSign
// SymUnchangeSign
// SymIdentifier

1
symbol.go
View File

@ -70,6 +70,7 @@ const (
SymTripleDot // 59: '...'
SymStarEqual // 60: '*='
SymSlashEqual // 61: '/='
SymPercEqual // 62: '%='
SymChangeSign
SymUnchangeSign
SymIdentifier