gitee.com/KyleChenSource/lib-robot@v1.0.2/robottest/common/interpreter/logic.y

// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This is an example of a goyacc program.
// To build it:
// goyacc -p "expr" expr.y (produces y.go)
// go build -o expr y.go
// expr
// > <type an expression>
// https://zhuanlan.zhihu.com/p/260180638
/*
1. Length判断
2. Value判断 （None： Value==nil）
3. 支持<, <=, ==, >, >=
4. 支持&&, ||, !

5. 进行类型自适应 Number, String, Bool
6. 支持数值运算 +-x/()
7. 支持函数调用 Rand [min, max]
8. 支持变量设置和获取 = Name
类型
*/

%{

package interpreter

import (
	"bytes"
	"fmt"
	"log"
	"unicode/utf8"
	"strconv"
	"math/rand"
)

var (
	LogDebug = func(string, ...any){}
	LogInfo = func(string, ...any){}
	LogError = func(string, ...any){}
)

type exprtype int8
const (
	EXPR_TYPE_STRING exprtype = iota 
	EXPR_TYPE_BOOL
	EXPR_TYPE_INT
	EXPR_TYPE_FLOAT
	EXPR_TYPE_NIL
	EXPR_TYPE_CNT
)

func exprGet(v *logicSymType, info string) (any, error) {
	switch v.expr_type {
	case EXPR_TYPE_STRING:
		return v.string_type, nil
	case EXPR_TYPE_BOOL:
		return v.bool_type, nil
	case EXPR_TYPE_INT:
		return v.int_type, nil
	case EXPR_TYPE_FLOAT:
		return v.float_type, nil
	case EXPR_TYPE_NIL:
		return nil, nil
	}
	
	return nil, fmt.Errorf("%s type:%d", info, v.expr_type)	
}

func exprSet(s *logicSymType, d *logicSymType, info string) (err error) {
	d.expr_type = s.expr_type

	switch s.expr_type {
	case EXPR_TYPE_STRING:
		d.string_type = s.string_type
	case EXPR_TYPE_BOOL:
		d.bool_type = s.bool_type
	case EXPR_TYPE_INT:
		d.int_type = s.int_type
	case EXPR_TYPE_FLOAT:
		d.float_type = s.float_type
	case EXPR_TYPE_NIL:	
	default:
		err = fmt.Errorf("%s type:%d", info, s.expr_type)
	}
	
	return	
}

func exprBool(s *logicSymType) bool {
	switch s.expr_type {
		case EXPR_TYPE_STRING:
			return len(s.string_type) > 0
		case EXPR_TYPE_BOOL:
			return s.bool_type
		case EXPR_TYPE_INT:
			return s.int_type != 0
		case EXPR_TYPE_FLOAT:
			return s.float_type != 0
	}
	return false
}

func typeGo2Script(v any, s *logicSymType) error {
	switch v.(type) {
	case nil:
		s.expr_type = EXPR_TYPE_NIL
	case int:
		s.expr_type = EXPR_TYPE_INT
		s.int_type = int64(v.(int))		
	case int8:
		s.expr_type = EXPR_TYPE_INT
		s.int_type = int64(v.(int8))
	case int16:
		s.expr_type = EXPR_TYPE_INT
		s.int_type = int64(v.(int16))
	case int32:
		s.expr_type = EXPR_TYPE_INT
		s.int_type = int64(v.(int32))
	case int64:
		s.expr_type = EXPR_TYPE_INT
		s.int_type = v.(int64)
	case uint8:
		s.expr_type = EXPR_TYPE_INT
		s.int_type = int64(v.(uint8))
	case uint16:
		s.expr_type = EXPR_TYPE_INT
		s.int_type = int64(v.(uint16))
	case uint32:
		s.expr_type = EXPR_TYPE_INT
		s.int_type = int64(v.(uint32))
	case uint64:
		s.expr_type = EXPR_TYPE_INT
		s.int_type = int64(v.(uint64))																	
	case float32:
		s.expr_type = EXPR_TYPE_FLOAT
		s.float_type = float64(v.(float32))
	case float64:
		s.expr_type = EXPR_TYPE_FLOAT
		s.float_type = v.(float64)			
	case string:
		s.expr_type = EXPR_TYPE_STRING
		s.string_type = v.(string)
	default:
		return fmt.Errorf("unrecognized Value %v type:%T", v, v)
	}
	return nil	
}
%}

%union {
	string_type string
	bool_type bool
	int_type int64
	float_type float64
	expr_type exprtype
}

%type <expr_type> expr expr0 expr1
%type <expr_type> logic logic1
%type <expr_type> calc1 calc2 calc3

%token '='
%token ';'
%token '+' '-' EQ LS LE GT GE AND OR NOT '(' ')' GET SET
%token '*' '/'

%token <expr_type> DATA RAND
// %token <string_type> STRING
// %token <bool_type> BOOL
// %token <int_type> NUM
// %token <float_type> FLOAT
%token <string_type> VARIABLE

%right '='
%left ';'
%right NOT
%left AND OR
%left EQ LS LE GT GE
%left '+' '-'
%left '*' '/'

%%
expr:
	expr0
	{
		LogDebug("expr.expr0")
		var err error
		logiclex.(*logicLex).result, err = exprGet(&logicDollar[1], "expr.expr0")
		if err != nil {
			logiclex.(*logicLex).Error(err.Error())
		}
	}	
expr0:
	expr1
	{
		LogDebug("expr0.expr1")
		err := exprSet(&logicDollar[1], &logicVAL, "expr0.expr1")
		if err != nil {
			logiclex.(*logicLex).Error(err.Error())
		}
	}
| 	expr0 ';' expr1
	{
		LogDebug("expr0.expr0 ';' expr1")
		err := exprSet(&logicDollar[3], &logicVAL, "expr0.expr0 ';' expr1")
		if err != nil {
			logiclex.(*logicLex).Error(err.Error())
		}
	}
|	GET expr1
	{
		LogDebug("expr0.GET expr1")
		if logicDollar[2].expr_type != EXPR_TYPE_STRING {
			logiclex.(*logicLex).Error(fmt.Sprintf("expr0.GET expr1 $2:%d string need", logicDollar[2].expr_type))
		} else {
			r, ok := logiclex.(*logicLex).ctx.Get(logicDollar[2].string_type)
			if !ok {
				logicVAL.expr_type = EXPR_TYPE_NIL
			} else {
				err := typeGo2Script(r, &logicVAL)
				if err != nil {
					logiclex.(*logicLex).Error(fmt.Sprintf("expr0.GET expr1 typeGo2Script err:%s", err.Error()))
				}
			}	
		}	
	}	
expr1:
	logic
	{
		LogDebug("expr1.logic")
		err := exprSet(&logicDollar[1], &logicVAL, "expr1.logic")
		if err != nil {
			logiclex.(*logicLex).Error(err.Error())
		}
	}
|	VARIABLE '=' expr1
	{
		LogDebug("expr0.VARIABLE '=' expr1 v:%s", logicDollar[1].string_type)
		v, err := exprGet(&logicDollar[3], "expr1.VARIABLE '=' expr1")
		if err != nil {
			logiclex.(*logicLex).Error(err.Error())
		} else {
			logiclex.(*logicLex).ctx.Set(logicDollar[1].string_type, v)
			exprSet(&logicDollar[3], &logicVAL, "expr1.VARIABLE '=' expr1")
		}		
	}	
logic:
	logic1
	{
		LogDebug("logic.logic1")
		err := exprSet(&logicDollar[1], &logicVAL, "logic.logic1")
		if err != nil {
			logiclex.(*logicLex).Error(err.Error())
		}
	}	
|	logic AND logic
	{
		LogDebug("%v AND %v\n", $1, $3)
		logicVAL.expr_type = EXPR_TYPE_BOOL
		logicVAL.bool_type = exprBool(&logicDollar[1]) && exprBool(&logicDollar[3])
	}
|	logic OR logic
	{
		LogDebug("%v AND %v\n", $1, $3)
		logicVAL.expr_type = EXPR_TYPE_BOOL
		logicVAL.bool_type = exprBool(&logicDollar[1]) || exprBool(&logicDollar[3])
	}
logic1:
	calc1
	{
		LogDebug("logic1.calc1")
		err := exprSet(&logicDollar[1], &logicVAL, "logic1.calc1")
		if err != nil {
			logiclex.(*logicLex).Error(err.Error())
		}
	}	
|	'+' calc1
	{
		switch logicDollar[1].expr_type {
		case EXPR_TYPE_INT:
			logicVAL.expr_type = logicDollar[1].expr_type
			logicVAL.int_type = logicDollar[1].int_type
		case EXPR_TYPE_FLOAT:
			logicVAL.expr_type = logicDollar[1].expr_type
			logicVAL.float_type = logicDollar[1].float_type	
		default:
			logiclex.(*logicLex).Error(fmt.Sprintf("logic1.'+' calc1 type:%d", logicDollar[1].expr_type))
		}
	}
|	'-' calc1
	{
		switch logicDollar[1].expr_type {
		case EXPR_TYPE_INT:
			logicVAL.expr_type = logicDollar[1].expr_type
			logicVAL.int_type = - logicDollar[1].int_type
		case EXPR_TYPE_FLOAT:
			logicVAL.expr_type = logicDollar[1].expr_type
			logicVAL.float_type = - logicDollar[1].float_type	
		default:
			logiclex.(*logicLex).Error(fmt.Sprintf("logic1.'-' calc1 type:%d", logicDollar[1].expr_type))	
		}
	}
|	NOT logic1	
	{
		LogDebug("NOT %v\n", $2)
		logicVAL.expr_type = EXPR_TYPE_BOOL
		logicVAL.bool_type = !exprBool(&logicDollar[2])
	}
|	logic1 LS logic1
	{
		LogDebug("LS NUM\n")

		logicVAL.expr_type = EXPR_TYPE_BOOL	
		if logicDollar[1].expr_type == EXPR_TYPE_INT {
			if logicDollar[3].expr_type == EXPR_TYPE_INT {
				logicVAL.bool_type = logicDollar[1].int_type < logicDollar[3].int_type
			}
			if logicDollar[3].expr_type == EXPR_TYPE_FLOAT {
				logicVAL.bool_type = float64(logicDollar[1].int_type) < logicDollar[3].float_type
			}
		} else if logicDollar[1].expr_type == EXPR_TYPE_FLOAT {
			if logicDollar[3].expr_type == EXPR_TYPE_INT {
				logicVAL.bool_type = logicDollar[1].float_type < float64(logicDollar[3].int_type)
			}
			if logicDollar[3].expr_type == EXPR_TYPE_FLOAT {
				logicVAL.bool_type = logicDollar[1].float_type < logicDollar[3].float_type
			}
		} else {
			logicVAL.expr_type = EXPR_TYPE_NIL
			logiclex.(*logicLex).Error(fmt.Sprintf("logic1.logic1 LS logic1 type:%d - %d", logicDollar[1].expr_type, logicDollar[3].expr_type))
		}
	}
|	logic1 LE logic1
	{
		LogDebug("LE NUM\n")
		logicVAL.expr_type = EXPR_TYPE_BOOL	
		if logicDollar[1].expr_type == EXPR_TYPE_INT {
			if logicDollar[3].expr_type == EXPR_TYPE_INT {
				logicVAL.bool_type = logicDollar[1].int_type <= logicDollar[3].int_type
			}
			if logicDollar[3].expr_type == EXPR_TYPE_FLOAT {
				logicVAL.bool_type = float64(logicDollar[1].int_type) <= logicDollar[3].float_type
			}
		} else if logicDollar[1].expr_type == EXPR_TYPE_FLOAT {
			if logicDollar[3].expr_type == EXPR_TYPE_INT {
				logicVAL.bool_type = logicDollar[1].float_type <= float64(logicDollar[3].int_type)
			}
			if logicDollar[3].expr_type == EXPR_TYPE_FLOAT {
				logicVAL.bool_type = logicDollar[1].float_type <= logicDollar[3].float_type
			}
		} else {
			logicVAL.expr_type = EXPR_TYPE_NIL
			logiclex.(*logicLex).Error(fmt.Sprintf("logic1.logic1 LE logic1 type:%d - %d", logicDollar[1].expr_type, logicDollar[3].expr_type))
		}
	}
|	logic1 GT logic1
	{
		LogDebug("GT NUM\n")
		logicVAL.expr_type = EXPR_TYPE_BOOL	
		if logicDollar[1].expr_type == EXPR_TYPE_INT {
			if logicDollar[3].expr_type == EXPR_TYPE_INT {
				logicVAL.bool_type = logicDollar[1].int_type > logicDollar[3].int_type
			}
			if logicDollar[3].expr_type == EXPR_TYPE_FLOAT {
				logicVAL.bool_type = float64(logicDollar[1].int_type) > logicDollar[3].float_type
			}
		} else if logicDollar[1].expr_type == EXPR_TYPE_FLOAT {
			if logicDollar[3].expr_type == EXPR_TYPE_INT {
				logicVAL.bool_type = logicDollar[1].float_type > float64(logicDollar[3].int_type)
			}
			if logicDollar[3].expr_type == EXPR_TYPE_FLOAT {
				logicVAL.bool_type = logicDollar[1].float_type > logicDollar[3].float_type
			}
		} else {
			logicVAL.expr_type = EXPR_TYPE_NIL
			logiclex.(*logicLex).Error(fmt.Sprintf("logic1.logic1 GT logic1 type:%d - %d", logicDollar[1].expr_type, logicDollar[3].expr_type))
		}
	}
|	logic1 GE logic1
	{
		LogDebug("GE NUM\n")
		logicVAL.expr_type = EXPR_TYPE_BOOL	
		if logicDollar[1].expr_type == EXPR_TYPE_INT {
			if logicDollar[3].expr_type == EXPR_TYPE_INT {
				logicVAL.bool_type = logicDollar[1].int_type >= logicDollar[3].int_type
			}
			if logicDollar[3].expr_type == EXPR_TYPE_FLOAT {
				logicVAL.bool_type = float64(logicDollar[1].int_type) >= logicDollar[3].float_type
			}
		} else if logicDollar[1].expr_type == EXPR_TYPE_FLOAT {
			if logicDollar[3].expr_type == EXPR_TYPE_INT {
				logicVAL.bool_type = logicDollar[1].float_type >= float64(logicDollar[3].int_type)
			}
			if logicDollar[3].expr_type == EXPR_TYPE_FLOAT {
				logicVAL.bool_type = logicDollar[1].float_type >= logicDollar[3].float_type
			}
		} else {
			logicVAL.expr_type = EXPR_TYPE_NIL
			logiclex.(*logicLex).Error(fmt.Sprintf("logic1.logic1 GE logic1 type:%d - %d", logicDollar[1].expr_type, logicDollar[3].expr_type))
		}
	}
|	logic1 EQ logic1
	{
		LogDebug("EQ NUM\n")
		logicVAL.expr_type = EXPR_TYPE_BOOL	
		if logicDollar[1].expr_type == EXPR_TYPE_INT {
			if logicDollar[3].expr_type == EXPR_TYPE_INT {
				logicVAL.bool_type = logicDollar[1].int_type == logicDollar[3].int_type
			}
			if logicDollar[3].expr_type == EXPR_TYPE_FLOAT {
				logicVAL.bool_type = float64(logicDollar[1].int_type) == logicDollar[3].float_type
			}
		} else if logicDollar[1].expr_type == EXPR_TYPE_FLOAT {
			if logicDollar[3].expr_type == EXPR_TYPE_INT {
				logicVAL.bool_type = logicDollar[1].float_type == float64(logicDollar[3].int_type)
			}
			if logicDollar[3].expr_type == EXPR_TYPE_FLOAT {
				logicVAL.bool_type = logicDollar[1].float_type == logicDollar[3].float_type
			}
		} else if logicDollar[1].expr_type == EXPR_TYPE_BOOL && logicDollar[3].expr_type == EXPR_TYPE_BOOL {
			logicVAL.bool_type = logicDollar[1].bool_type == logicDollar[3].bool_type
		} else if  logicDollar[1].expr_type == EXPR_TYPE_STRING && logicDollar[3].expr_type == EXPR_TYPE_STRING {
			logicVAL.bool_type = logicDollar[1].string_type == logicDollar[3].string_type
		} else {
			logicVAL.expr_type = EXPR_TYPE_NIL
			logiclex.(*logicLex).Error(fmt.Sprintf("logic1.logic1 EQ logic1 type:%d - %d", logicDollar[1].expr_type, logicDollar[3].expr_type))	
		}	
	}
calc1:
	calc2
	{
		LogDebug("calc1.calc2")
		err := exprSet(&logicDollar[1], &logicVAL, "calc1.calc2")
		if err != nil {
			logiclex.(*logicLex).Error(err.Error())
		}		
	}
|	calc1 '+' calc2
	{
		if logicDollar[1].expr_type == EXPR_TYPE_INT {
			if logicDollar[3].expr_type == EXPR_TYPE_INT {
				logicVAL.expr_type = EXPR_TYPE_INT
				logicVAL.int_type = logicDollar[1].int_type + logicDollar[3].int_type
				LogDebug("calc1.calc1 '+' calc2 int+int %d+%d=%d", logicDollar[1].int_type, logicDollar[3].int_type, logicVAL.int_type)
			}
			if logicDollar[3].expr_type == EXPR_TYPE_FLOAT {
				logicVAL.expr_type = EXPR_TYPE_FLOAT
				logicVAL.float_type = float64(logicDollar[1].int_type) + logicDollar[3].float_type
				LogDebug("calc1.calc1 '+' calc2 int+float %d+%f=%f", logicDollar[1].int_type, logicDollar[3].float_type, logicVAL.float_type)
			}
		} else if logicDollar[1].expr_type == EXPR_TYPE_FLOAT {
			if logicDollar[3].expr_type == EXPR_TYPE_INT {
				logicVAL.expr_type = EXPR_TYPE_FLOAT
				logicVAL.float_type = logicDollar[1].float_type + float64(logicDollar[3].int_type)
				LogDebug("calc1.calc1 '+' calc2 float+int %f+%d=%f", logicDollar[1].float_type, logicDollar[3].int_type, logicVAL.float_type)
			}
			if logicDollar[3].expr_type == EXPR_TYPE_FLOAT {
				logicVAL.expr_type = EXPR_TYPE_FLOAT
				logicVAL.float_type = logicDollar[1].float_type + logicDollar[3].float_type
				LogDebug("calc1.calc1 '+' calc2 float+float %f+%f=%f", logicDollar[1].float_type, logicDollar[3].float_type, logicVAL.float_type)
			}
		} else if  logicDollar[1].expr_type == EXPR_TYPE_STRING && logicDollar[3].expr_type == EXPR_TYPE_STRING {
			logicVAL.expr_type = EXPR_TYPE_STRING
			logicVAL.string_type = logicDollar[1].string_type + logicDollar[3].string_type
			LogDebug("calc1.calc1 '+' calc2 string %s+%s=%s", logicDollar[1].string_type, logicDollar[3].string_type, logicVAL.string_type)
		} else if  logicDollar[1].expr_type == EXPR_TYPE_STRING && logicDollar[3].expr_type == EXPR_TYPE_INT {
			logicVAL.expr_type = EXPR_TYPE_STRING
			logicVAL.string_type = fmt.Sprintf("%s%d", logicDollar[1].string_type, logicDollar[3].int_type)
			LogDebug("calc1.calc1 '+' calc2 string %s+%d=%s", logicDollar[1].string_type, logicDollar[3].int_type, logicVAL.string_type)
		} else if  logicDollar[1].expr_type == EXPR_TYPE_STRING && logicDollar[3].expr_type == EXPR_TYPE_FLOAT {
			logicVAL.expr_type = EXPR_TYPE_STRING
			logicVAL.string_type = fmt.Sprintf("%s%f", logicDollar[1].string_type, logicDollar[3].float_type)
			LogDebug("calc1.calc1 '+' calc2 string %s+%f=%s", logicDollar[1].string_type, logicDollar[3].float_type, logicVAL.string_type)
		} else {
			logicVAL.expr_type = EXPR_TYPE_NIL
			logiclex.(*logicLex).Error(fmt.Sprintf("logic1.calc1 '+' calc2 type:%d - %d", logicDollar[1].expr_type, logicDollar[3].expr_type))	
			LogDebug("calc1.calc1 '+' calc2 type:%d, %d", logicDollar[1].expr_type, logicDollar[3].expr_type)
		}
	}
|	calc1 '-' calc2
	{
		if logicDollar[1].expr_type == EXPR_TYPE_INT {
			if logicDollar[3].expr_type == EXPR_TYPE_INT {
				logicVAL.expr_type = EXPR_TYPE_INT
				logicVAL.int_type = logicDollar[1].int_type - logicDollar[3].int_type
			}
			if logicDollar[3].expr_type == EXPR_TYPE_FLOAT {
				logicVAL.expr_type = EXPR_TYPE_FLOAT
				logicVAL.float_type = float64(logicDollar[1].int_type) - logicDollar[3].float_type
			}
		} else if logicDollar[1].expr_type == EXPR_TYPE_FLOAT {
			if logicDollar[3].expr_type == EXPR_TYPE_INT {
				logicVAL.expr_type = EXPR_TYPE_FLOAT
				logicVAL.float_type = logicDollar[1].float_type - float64(logicDollar[3].int_type)
			}
			if logicDollar[3].expr_type == EXPR_TYPE_FLOAT {
				logicVAL.expr_type = EXPR_TYPE_FLOAT
				logicVAL.float_type = logicDollar[1].float_type - logicDollar[3].float_type
			}
		} else {
			logicVAL.expr_type = EXPR_TYPE_NIL
			logiclex.(*logicLex).Error(fmt.Sprintf("logic1.calc1 '-' calc2 type:%d - %d", logicDollar[1].expr_type, logicDollar[3].expr_type))
		}
	}
calc2:
	calc3
	{
		LogDebug("calc2.calc3")
		err := exprSet(&logicDollar[1], &logicVAL, "calc1.calc2")
		if err != nil {
			logiclex.(*logicLex).Error(err.Error())
		}			
	}
|	calc2 '*' DATA
	{
		if logicDollar[1].expr_type == EXPR_TYPE_INT {
			if logicDollar[3].expr_type == EXPR_TYPE_INT {
				logicVAL.expr_type = EXPR_TYPE_INT
				logicVAL.int_type = logicDollar[1].int_type * logicDollar[3].int_type
			}
			if logicDollar[3].expr_type == EXPR_TYPE_FLOAT {
				logicVAL.expr_type = EXPR_TYPE_FLOAT
				logicVAL.float_type = float64(logicDollar[1].int_type) * logicDollar[3].float_type
			}
		} else if logicDollar[1].expr_type == EXPR_TYPE_FLOAT {
			if logicDollar[3].expr_type == EXPR_TYPE_INT {
				logicVAL.expr_type = EXPR_TYPE_FLOAT
				logicVAL.float_type = logicDollar[1].float_type * float64(logicDollar[3].int_type)
			}
			if logicDollar[3].expr_type == EXPR_TYPE_FLOAT {
				logicVAL.expr_type = EXPR_TYPE_FLOAT
				logicVAL.float_type = logicDollar[1].float_type * logicDollar[3].float_type
			}
		} else {
			logicVAL.expr_type = EXPR_TYPE_NIL
			logiclex.(*logicLex).Error(fmt.Sprintf("logic1.calc1 '*' calc2 type:%d - %d", logicDollar[1].expr_type, logicDollar[3].expr_type))	
		}
	}
|	calc2 '/' DATA
	{
		if logicDollar[1].expr_type == EXPR_TYPE_INT {
			if logicDollar[3].expr_type == EXPR_TYPE_INT {
				logicVAL.expr_type = EXPR_TYPE_INT
				logicVAL.int_type = logicDollar[1].int_type / logicDollar[3].int_type
			}
			if logicDollar[3].expr_type == EXPR_TYPE_FLOAT {
				logicVAL.expr_type = EXPR_TYPE_FLOAT
				logicVAL.float_type = float64(logicDollar[1].int_type) / logicDollar[3].float_type
			}
		} else if logicDollar[1].expr_type == EXPR_TYPE_FLOAT {
			if logicDollar[3].expr_type == EXPR_TYPE_INT {
				logicVAL.expr_type = EXPR_TYPE_FLOAT
				logicVAL.float_type = logicDollar[1].float_type / float64(logicDollar[3].int_type)
			}
			if logicDollar[3].expr_type == EXPR_TYPE_FLOAT {
				logicVAL.expr_type = EXPR_TYPE_FLOAT
				logicVAL.float_type = logicDollar[1].float_type / logicDollar[3].float_type
			}
		} else {
			logicVAL.expr_type = EXPR_TYPE_NIL
			logiclex.(*logicLex).Error(fmt.Sprintf("logic1.calc1 '/' calc2 type:%d - %d", logicDollar[1].expr_type, logicDollar[3].expr_type))	
		}
	}
calc3:
	'(' calc3 ')'
	{
		err := exprSet(&logicDollar[2], &logicVAL, "calc3.'(' calc3 ')'")
		if err != nil {
			logiclex.(*logicLex).Error(err.Error())
		}
	}
|	VARIABLE
	{
		LogDebug("calc3.VARIABLE %s", logicDollar[1].string_type)
		r, ok := logiclex.(*logicLex).ctx.Get(logicDollar[1].string_type)
		if !ok {
			logicVAL.expr_type = EXPR_TYPE_NIL
		} else {
			err := typeGo2Script(r, &logicVAL)
			if err != nil {
				logiclex.(*logicLex).Error(fmt.Sprintf("calc3.VARIABLE v:%s err:%s", logicDollar[1].string_type, err.Error()))
			}
		}
	}
|	RAND
	{
		LogDebug("calc3.RAND")
		logicVAL.expr_type = EXPR_TYPE_INT
		logicVAL.int_type = rand.Int63()			
		LogDebug("RAND:%d\n", logicVAL.int_type)
	}
|	RAND DATA DATA
	{
		min := int64(0)
		if logicDollar[2].expr_type == EXPR_TYPE_INT {
			min = logicDollar[2].int_type
		} else {
			min = int64(logicDollar[2].float_type)
		}
		max := int64(0)
		if logicDollar[3].expr_type == EXPR_TYPE_INT {
			max = logicDollar[3].int_type
		} else {
			max = int64(logicDollar[3].float_type)
		}	
		logicVAL.expr_type = EXPR_TYPE_INT
		logicVAL.int_type = rand.Int63n(max-min)+min
		LogDebug("RAND (%d %d):%d\n", min, max, logicVAL.int_type)
	}
|	DATA
	{
		LogDebug("calc3.DATA")
		err := exprSet(&logicDollar[1], &logicVAL, "calc3.DATA")
		if err != nil {
			logiclex.(*logicLex).Error(err.Error())
		}		
	}
%%

// The parser expects the lexer to return 0 on EOF.  Give it a name
// for clarity.
const eof = 0

type DataCtx interface {
	Get(string) (any, bool)
	Set(string, any)	
}
// The parser uses the type <prefix>Lex as a lexer. It must provide
// the methods Lex(*<prefix>SymType) int and Error(string).
type logicLex struct {
	line []byte
	peek rune

	result any // 输出结果
	err error // 错误信息

	ctx DataCtx
	length int32 // 外部传入数据，节点长度
	value any // 外部传入数据，节点数据	
}

// The parser calls this method to get each new token. This
// implementation returns operators and NUM.
func (x *logicLex) Lex(yylval *logicSymType) int {
	for {
		c := x.next()
		LogDebug("c:%q", c)
		switch c {
		case eof:
			return eof
		case '+', '-', '*', '/', '(', ')', ';':
			return int(c)
		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.':
			return x.num(c, yylval)
		case '"':
			return x.string(c, yylval)
		case '<':
			c = x.next()
			if c != '=' {
				x.peek = c
				return LS
			}
			return LE
		case '>':
			c = x.next()
			if c != '=' {
				x.peek = c
				return GT
			}
			return GE
		case '=':
			c = x.next()
			if c != '=' {
				x.peek = c
				return int('=')
			}
			return EQ

		case '&':
			c = x.next()
			if c != '&' {
				x.err = fmt.Errorf("unrecognized character =%q", c)
				return eof
			}
			return AND		
		case '|':
			c = x.next()
			if c != '|' {
				x.err = fmt.Errorf("unrecognized character =%q", c)
				return eof
			}
			return OR		
		case '!':
			return NOT					
		// Recognize Unicode multiplication and division
		// symbols, returning what the parser expects.
		case ' ', '\t', '\n', '\r':
		default:
			if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') {
				return x.variable(c, yylval)
			}

			x.err = fmt.Errorf("unrecognized character %q", c)
			return eof
		}
	}
}

// Lex a number.
func (x *logicLex) num(c rune, yylval *logicSymType) int {
	add := func(b *bytes.Buffer, c rune) {
		if _, x.err = b.WriteRune(c); x.err != nil {
			log.Fatalf("WriteRune: %s", x.err)
		}
	}

	bFloat := false
	if c == '.' {
		bFloat = true
	}

	var b bytes.Buffer
	
	add(&b, c)
	L: for {
		c = x.next()
		switch c {
		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'e', 'E':
			add(&b, c)
		case '.':
			add(&b, c)
			if bFloat {
				x.err = fmt.Errorf("%s double .", b.String())
				return eof
			}
			bFloat = true
		default:
			break L
		}
	}
	if c != eof {
		x.peek = c
	}

	if !bFloat {
		var number uint64
		number, x.err = strconv.ParseUint(b.String(), 10, 64)
		yylval.expr_type = EXPR_TYPE_INT
		yylval.int_type = int64(number)
		if x.err != nil {
			x.err = fmt.Errorf("%s ParseInt err:%s", b.String(), x.err.Error())
			return eof
		}
	} else {
		yylval.float_type, x.err = strconv.ParseFloat(b.String(), 64)
		if x.err != nil {
			x.err = fmt.Errorf("%s ParseFloat err:%s", b.String(), x.err.Error())
			return eof
		}
		yylval.expr_type = EXPR_TYPE_FLOAT
	}
	return DATA
}

// Lex a string.
func (x *logicLex) string(c rune, yylval *logicSymType) int {
	add := func(b *bytes.Buffer, c rune) {
		if _, x.err = b.WriteRune(c); x.err != nil {
			log.Fatalf("WriteRune: %s", x.err)
		}
	}

	var b bytes.Buffer
	L: for {
		c = x.next()
		switch c {
		case eof:
			return eof
		case '"':
			break L
		default:
			add(&b, c)
		}
	}

	yylval.expr_type = EXPR_TYPE_STRING
	yylval.string_type = b.String()

	return DATA
}

// Lex a Value or reserve word.
func (x *logicLex) variable(c rune, yylval *logicSymType) int {
	add := func(b *bytes.Buffer, c rune) {
		if _, x.err = b.WriteRune(c); x.err != nil {
			log.Fatalf("value WriteRune: %s", x.err)
		}
	}

	var b bytes.Buffer
	for {
		if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' || ( c >= '0' && c <= '9' ) {
			add(&b, c)
			c = x.next()
		} else {
			x.peek = c
			break
		}
	}

	s := b.String()
	switch s {
	case "Value":
		err := typeGo2Script(x.value, yylval)
		if err != nil {
			x.Error(err.Error())
			return eof
		}
		return DATA
	case "Length":
		yylval.expr_type = EXPR_TYPE_INT
		yylval.int_type = int64(x.length)
		return DATA	
	case "None":
		yylval.expr_type = EXPR_TYPE_BOOL
		yylval.bool_type = x.value == nil
		return DATA	
	case "Rand":
		return RAND	
	case "Get":
		return GET
	}

	yylval.expr_type = EXPR_TYPE_STRING
	yylval.string_type = s
	return VARIABLE
}

// Return the next rune for the lexer.
func (x *logicLex) next() rune {
	if x.peek != eof {
		r := x.peek
		x.peek = eof
		return r
	}
	if len(x.line) == 0 {
		return eof
	}
	c, size := utf8.DecodeRune(x.line)
	x.line = x.line[size:]
	if c == utf8.RuneError && size == 1 {
		x.err = fmt.Errorf("invalid utf8")
		return x.next()
	}
	return c
}

// The parser calls this method on a parse error.
func (x *logicLex) Error(s string) {
	if x.err == nil {
		x.err = fmt.Errorf("Value:%v Length:%d err:%s", x.value, x.length, s)
	} else {
		x.err = fmt.Errorf("%s\nValue:%v Length:%d err:%s", x.err.Error(), x.value, x.length, s)
	}
}

func DoString(in []byte, v any, l int32, ctx DataCtx) (any, error) {
	lex := logicLex{line: in, result:false, value:v, length:l, ctx:ctx}

	a := logicParse(&lex)

	LogDebug("value:%v length:%d in:%s a:%d result:%v err:%v", lex.value, lex.length, string(in), a, lex.result, lex.err)

	return lex.result, lex.err
}