mirror of
https://github.com/WiiLink24/wfc-server.git
synced 2026-05-06 13:40:04 -05:00
399 lines
8.3 KiB
Go
399 lines
8.3 KiB
Go
// Modified from github.com/zdebeer99/goexpression
|
|
package filter
|
|
|
|
import (
|
|
"errors"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
type expression struct {
|
|
ast *TreeNode
|
|
context map[string]string
|
|
queryGame string
|
|
}
|
|
|
|
// Bug(zdebeer): functions is eval from right to left instead from left to right.
|
|
func Eval(basenode *TreeNode, context map[string]string, queryGame string) (value int64, err error) {
|
|
defer func() {
|
|
if str := recover(); str != nil {
|
|
value = 0
|
|
err = errors.New(str.(string))
|
|
}
|
|
}()
|
|
|
|
e := &expression{basenode, context, queryGame}
|
|
return e.eval(basenode), nil
|
|
}
|
|
|
|
func (e *expression) eval(basenode *TreeNode) int64 {
|
|
for _, node := range basenode.items {
|
|
switch node.Value.Category() {
|
|
case CatFunction:
|
|
return e.switchFunction(node)
|
|
|
|
case CatValue:
|
|
return e.getNumber(node)
|
|
|
|
case CatOther:
|
|
return e.switchOther(node)
|
|
}
|
|
}
|
|
panic("eval failed")
|
|
}
|
|
|
|
func (e *expression) switchOther(node *TreeNode) int64 {
|
|
switch v1 := node.Value.(type) {
|
|
case *GroupToken:
|
|
if v1.GroupType == "()" {
|
|
return e.eval(node)
|
|
}
|
|
}
|
|
panic("invalid node " + node.String())
|
|
}
|
|
|
|
func (e *expression) switchFunction(node *TreeNode) int64 {
|
|
val1 := node.Value.(*OperatorToken)
|
|
switch strings.ToLower(val1.Operator) {
|
|
case "=":
|
|
return e.evalEquals(node.Items())
|
|
case "==":
|
|
return e.evalEquals(node.Items())
|
|
case "!=":
|
|
return e.evalNotEquals(node.Items())
|
|
|
|
case ">":
|
|
return e.evalMathOperator(e.evalMathGreater, node.Items())
|
|
case "<":
|
|
return e.evalMathOperator(e.evalMathLess, node.Items())
|
|
case ">=":
|
|
return e.evalMathOperator(e.evalMathGreaterOrEqual, node.Items())
|
|
case "<=":
|
|
return e.evalMathOperator(e.evalMathLessOrEqual, node.Items())
|
|
case "+":
|
|
return e.evalMathOperator(e.evalMathPlus, node.Items())
|
|
case "-":
|
|
return e.evalMathOperator(e.evalMathMinus, node.Items())
|
|
case "&":
|
|
return e.evalMathOperator(e.evalMathAnd, node.Items())
|
|
case "|":
|
|
return e.evalMathOperator(e.evalMathOr, node.Items())
|
|
case "^":
|
|
return e.evalMathOperator(e.evalMathXor, node.Items())
|
|
case "<<":
|
|
return e.evalMathOperator(e.evalMathLShift, node.Items())
|
|
case ">>":
|
|
return e.evalMathOperator(e.evalMathRShift, node.Items())
|
|
|
|
case "and":
|
|
return e.evalAnd(node.Items())
|
|
case "or":
|
|
return e.evalOr(node.Items())
|
|
case "&&":
|
|
return e.evalAnd(node.Items())
|
|
case "||":
|
|
return e.evalOr(node.Items())
|
|
|
|
case "like":
|
|
return e.evalLike(node.Items())
|
|
|
|
default:
|
|
panic("function not supported: " + val1.Operator)
|
|
}
|
|
|
|
}
|
|
|
|
func (e *expression) getString(node *TreeNode) string {
|
|
switch v := node.Value.(type) {
|
|
case *NumberToken:
|
|
return strconv.FormatInt(v.Value, 10)
|
|
case *IdentityToken:
|
|
return e.getValue(v)
|
|
case *OperatorToken:
|
|
return strconv.FormatInt(e.switchFunction(node), 10)
|
|
case *GroupToken:
|
|
if v.GroupType == "()" {
|
|
return strconv.FormatInt(e.eval(node), 10)
|
|
}
|
|
panic("unexpected grouping type: " + node.String())
|
|
case *TextToken:
|
|
return node.Value.(*TextToken).Text
|
|
|
|
default:
|
|
panic("unexpected value: " + node.String())
|
|
}
|
|
}
|
|
|
|
func (e *expression) evalEquals(args []*TreeNode) int64 {
|
|
cnt := len(args)
|
|
switch {
|
|
case cnt < 2:
|
|
panic("operator missing arguments")
|
|
case cnt == 2:
|
|
if n, ok := args[0].Value.(*IdentityToken); ok {
|
|
if n.Name == "rk" && e.queryGame == "mariokartwii" {
|
|
return e.evalEqualsRK(e.getString(args[1]))
|
|
}
|
|
}
|
|
|
|
if e.getString(args[0]) == e.getString(args[1]) {
|
|
return 1
|
|
}
|
|
return 0
|
|
default:
|
|
arg := e.getString(args[0])
|
|
for i := 1; i < cnt; i++ {
|
|
if arg != e.getString(args[i]) {
|
|
return 0
|
|
}
|
|
}
|
|
return 1
|
|
}
|
|
}
|
|
|
|
// Operator override
|
|
func (e *expression) evalEqualsRK(value string) int64 {
|
|
rk := e.context["rk"]
|
|
// Check and remove regional searches due to the limited player count
|
|
// China (ID 6) gets a pass because it was never released
|
|
if len(rk) == 4 && (strings.HasPrefix(rk, "vs_") || strings.HasPrefix(rk, "bt_")) && rk[3] >= '0' && rk[3] < '6' {
|
|
rk = rk[:2]
|
|
}
|
|
|
|
if len(value) == 4 && (strings.HasPrefix(value, "vs_") || strings.HasPrefix(value, "bt_")) && value[3] >= '0' && value[3] < '6' {
|
|
value = value[:2]
|
|
}
|
|
|
|
if rk == value {
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (e *expression) evalNotEquals(args []*TreeNode) int64 {
|
|
cnt := len(args)
|
|
switch {
|
|
case cnt < 2:
|
|
panic("operator missing arguments")
|
|
case cnt == 2:
|
|
if e.getString(args[0]) != e.getString(args[1]) {
|
|
return 1
|
|
}
|
|
return 0
|
|
default:
|
|
arg := e.getString(args[0])
|
|
for i := 1; i < cnt; i++ {
|
|
if arg == e.getString(args[i]) {
|
|
return 0
|
|
}
|
|
}
|
|
return 1
|
|
}
|
|
}
|
|
|
|
func (e *expression) evalAnd(args []*TreeNode) int64 {
|
|
cnt := len(args)
|
|
if cnt < 2 {
|
|
panic("operator missing arguments")
|
|
}
|
|
|
|
for i := 0; i < cnt; i++ {
|
|
if e.getString(args[i]) == "0" {
|
|
return 0
|
|
}
|
|
}
|
|
return 1
|
|
}
|
|
|
|
func (e *expression) evalOr(args []*TreeNode) int64 {
|
|
cnt := len(args)
|
|
if cnt < 2 {
|
|
panic("operator missing arguments")
|
|
}
|
|
|
|
for i := 0; i < cnt; i++ {
|
|
if e.getString(args[i]) != "0" {
|
|
return 1
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (e *expression) getNumber(node *TreeNode) int64 {
|
|
switch v := node.Value.(type) {
|
|
case *NumberToken:
|
|
return v.Value
|
|
case *IdentityToken:
|
|
r1 := e.getValue(v)
|
|
return e.toInt64(r1)
|
|
case *OperatorToken:
|
|
return e.switchFunction(node)
|
|
case *GroupToken:
|
|
if v.GroupType == "()" {
|
|
return e.eval(node)
|
|
}
|
|
panic("unexpected grouping type: " + node.String())
|
|
case *TextToken:
|
|
return e.toInt64(node.Value.(*TextToken).Text)
|
|
|
|
default:
|
|
panic("unexpected value: " + node.String())
|
|
}
|
|
}
|
|
|
|
func (e *expression) evalMathOperator(fn func(int64, int64) int64, args []*TreeNode) int64 {
|
|
cnt := len(args)
|
|
switch {
|
|
case cnt < 2:
|
|
panic("operator missing arguments")
|
|
case cnt == 2:
|
|
if n, ok := args[0].Value.(*IdentityToken); ok {
|
|
// Remove VR search due to the limited player count
|
|
if (n.Name == "ev" || n.Name == "eb") && e.queryGame == "mariokartwii" {
|
|
return 1
|
|
}
|
|
}
|
|
|
|
return fn(e.getNumber(args[0]), e.getNumber(args[1]))
|
|
default:
|
|
answ := fn(e.getNumber(args[0]), e.getNumber(args[1]))
|
|
for i := 2; i < cnt; i++ {
|
|
answ = fn(answ, e.getNumber(args[i]))
|
|
}
|
|
return answ
|
|
}
|
|
}
|
|
|
|
func (e *expression) evalMathPlus(val1, val2 int64) int64 {
|
|
return val1 + val2
|
|
}
|
|
|
|
func (e *expression) evalMathMinus(val1, val2 int64) int64 {
|
|
return val1 - val2
|
|
}
|
|
|
|
func (e *expression) evalMathGreater(val1, val2 int64) int64 {
|
|
if val1 > val2 {
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (e *expression) evalMathLess(val1, val2 int64) int64 {
|
|
if val1 < val2 {
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (e *expression) evalMathGreaterOrEqual(val1, val2 int64) int64 {
|
|
if val1 >= val2 {
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (e *expression) evalMathLessOrEqual(val1, val2 int64) int64 {
|
|
if val1 <= val2 {
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (e *expression) evalMathAnd(val1, val2 int64) int64 {
|
|
return val1 & val2
|
|
}
|
|
|
|
func (e *expression) evalMathOr(val1, val2 int64) int64 {
|
|
return val1 | val2
|
|
}
|
|
|
|
func (e *expression) evalMathXor(val1, val2 int64) int64 {
|
|
return val1 ^ val2
|
|
}
|
|
|
|
func (e *expression) evalMathLShift(val1, val2 int64) int64 {
|
|
return val1 << val2
|
|
}
|
|
|
|
func (e *expression) evalMathRShift(val1, val2 int64) int64 {
|
|
return val1 >> val2
|
|
}
|
|
|
|
func (e *expression) evalLike(args []*TreeNode) int64 {
|
|
cnt := len(args)
|
|
switch {
|
|
case cnt < 2:
|
|
panic("operator missing arguments")
|
|
case cnt == 2:
|
|
return e.evalLikeSingle(args[0], args[1])
|
|
default:
|
|
panic("operator LIKE does not support multiple arguments")
|
|
}
|
|
}
|
|
|
|
func (e *expression) evalLikeSingle(arg1, arg2 *TreeNode) int64 {
|
|
val1 := e.getString(arg1)
|
|
val2 := e.getString(arg2)
|
|
|
|
allowedCharacters := `abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_%\`
|
|
|
|
regexString := "^"
|
|
|
|
// Convert SQL LIKE pattern to regex
|
|
for i, c := range val2 {
|
|
if !strings.ContainsRune(allowedCharacters, c) {
|
|
panic("invalid character in LIKE pattern: " + string(c))
|
|
}
|
|
|
|
if i != 0 && val2[i-1] == '\\' {
|
|
if c == '\\' {
|
|
regexString += "\\\\"
|
|
continue
|
|
}
|
|
|
|
regexString += string(c)
|
|
continue
|
|
}
|
|
|
|
switch c {
|
|
case '%':
|
|
regexString += ".*"
|
|
|
|
case '_':
|
|
regexString += "."
|
|
|
|
case '\\':
|
|
// Do nothing
|
|
|
|
default:
|
|
regexString += string(c)
|
|
}
|
|
}
|
|
|
|
regexString += "$"
|
|
|
|
if matched, err := regexp.MatchString(regexString, val1); err != nil {
|
|
panic(err)
|
|
} else if matched {
|
|
return 1
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
// Get a value from the context.
|
|
func (e *expression) getValue(token *IdentityToken) string {
|
|
return e.context[token.Name]
|
|
}
|
|
|
|
func (e *expression) toInt64(value string) int64 {
|
|
val, err := strconv.ParseInt(value, 10, 64)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
return val
|
|
}
|