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

// Code generated by goyacc -p logic -v logic.out -o logic.go logic.y. DO NOT EDIT.

//line logic.y:26

package interpreter

import __yyfmt__ "fmt"

//line logic.y:27

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

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
}

//line logic.y:152
type logicSymType struct {
	yys         int
	string_type string
	bool_type   bool
	int_type    int64
	float_type  float64
	expr_type   exprtype
}

const EQ = 57346
const LS = 57347
const LE = 57348
const GT = 57349
const GE = 57350
const AND = 57351
const OR = 57352
const NOT = 57353
const GET = 57354
const SET = 57355
const DATA = 57356
const RAND = 57357
const VARIABLE = 57358

var logicToknames = [...]string{
	"$end",
	"error",
	"$unk",
	"'='",
	"';'",
	"'+'",
	"'-'",
	"EQ",
	"LS",
	"LE",
	"GT",
	"GE",
	"AND",
	"OR",
	"NOT",
	"'('",
	"')'",
	"GET",
	"SET",
	"'*'",
	"'/'",
	"DATA",
	"RAND",
	"VARIABLE",
}

var logicStatenames = [...]string{}

const logicEofCode = 1
const logicErrCode = 2
const logicInitialStackSize = 16

//line logic.y:620

// 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
}

//line yacctab:1
var logicExca = [...]int8{
	-1, 1,
	1, -1,
	-2, 0,
}

const logicPrivate = 57344

const logicLast = 70

var logicAct = [...]int8{
	7, 9, 10, 33, 34, 12, 51, 49, 14, 48,
	11, 14, 32, 4, 16, 15, 30, 16, 15, 6,
	9, 10, 36, 41, 42, 43, 44, 45, 50, 11,
	14, 9, 10, 46, 47, 5, 16, 15, 30, 3,
	11, 14, 19, 20, 18, 13, 17, 16, 15, 6,
	26, 22, 23, 24, 25, 38, 39, 37, 8, 21,
	35, 40, 27, 28, 2, 1, 0, 0, 29, 31,
}

var logicPact = [...]int16{
	-5, -1000, 41, -1000, 25, 29, 55, 42, 56, -8,
	-8, 14, -17, -1000, -8, 0, -1000, 25, -1000, 14,
	14, 25, 14, 14, 14, 14, 14, -8, -8, 56,
	-1000, 56, 42, -13, -15, 11, -16, -1000, -1000, -1000,
	-1000, -1000, -1000, -1000, -1000, -1000, -17, -17, -1000, -1000,
	-1000, -1000,
}

var logicPgo = [...]int8{
	0, 65, 64, 39, 35, 0, 58, 5, 45,
}

var logicR1 = [...]int8{
	0, 1, 2, 2, 2, 3, 3, 4, 4, 4,
	5, 5, 5, 5, 5, 5, 5, 5, 5, 6,
	6, 6, 7, 7, 7, 8, 8, 8, 8, 8,
}

var logicR2 = [...]int8{
	0, 1, 1, 3, 2, 1, 3, 1, 3, 3,
	1, 2, 2, 2, 3, 3, 3, 3, 3, 1,
	3, 3, 1, 3, 3, 3, 1, 1, 3, 1,
}

var logicChk = [...]int16{
	-1000, -1, -2, -3, 18, -4, 24, -5, -6, 6,
	7, 15, -7, -8, 16, 23, 22, 5, -3, 13,
	14, 4, 9, 10, 11, 12, 8, 6, 7, -6,
	24, -6, -5, 20, 21, -8, 22, -3, -4, -4,
	-3, -5, -5, -5, -5, -5, -7, -7, 22, 22,
	17, 22,
}

var logicDef = [...]int8{
	0, -2, 1, 2, 0, 5, 26, 7, 10, 0,
	0, 0, 19, 22, 0, 27, 29, 0, 4, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 11,
	26, 12, 13, 0, 0, 0, 0, 3, 8, 9,
	6, 14, 15, 16, 17, 18, 20, 21, 23, 24,
	25, 28,
}

var logicTok1 = [...]int8{
	1, 3, 3, 3, 3, 3, 3, 3, 3, 3,
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
	16, 17, 20, 6, 3, 7, 3, 21, 3, 3,
	3, 3, 3, 3, 3, 3, 3, 3, 3, 5,
	3, 4,
}

var logicTok2 = [...]int8{
	2, 3, 8, 9, 10, 11, 12, 13, 14, 15,
	18, 19, 22, 23, 24,
}

var logicTok3 = [...]int8{
	0,
}

var logicErrorMessages = [...]struct {
	state int
	token int
	msg   string
}{}

//line yaccpar:1

/*	parser for yacc output	*/

var (
	logicDebug        = 0
	logicErrorVerbose = false
)

type logicLexer interface {
	Lex(lval *logicSymType) int
	Error(s string)
}

type logicParser interface {
	Parse(logicLexer) int
	Lookahead() int
}

type logicParserImpl struct {
	lval  logicSymType
	stack [logicInitialStackSize]logicSymType
	char  int
}

func (p *logicParserImpl) Lookahead() int {
	return p.char
}

func logicNewParser() logicParser {
	return &logicParserImpl{}
}

const logicFlag = -1000

func logicTokname(c int) string {
	if c >= 1 && c-1 < len(logicToknames) {
		if logicToknames[c-1] != "" {
			return logicToknames[c-1]
		}
	}
	return __yyfmt__.Sprintf("tok-%v", c)
}

func logicStatname(s int) string {
	if s >= 0 && s < len(logicStatenames) {
		if logicStatenames[s] != "" {
			return logicStatenames[s]
		}
	}
	return __yyfmt__.Sprintf("state-%v", s)
}

func logicErrorMessage(state, lookAhead int) string {
	const TOKSTART = 4

	if !logicErrorVerbose {
		return "syntax error"
	}

	for _, e := range logicErrorMessages {
		if e.state == state && e.token == lookAhead {
			return "syntax error: " + e.msg
		}
	}

	res := "syntax error: unexpected " + logicTokname(lookAhead)

	// To match Bison, suggest at most four expected tokens.
	expected := make([]int, 0, 4)

	// Look for shiftable tokens.
	base := int(logicPact[state])
	for tok := TOKSTART; tok-1 < len(logicToknames); tok++ {
		if n := base + tok; n >= 0 && n < logicLast && int(logicChk[int(logicAct[n])]) == tok {
			if len(expected) == cap(expected) {
				return res
			}
			expected = append(expected, tok)
		}
	}

	if logicDef[state] == -2 {
		i := 0
		for logicExca[i] != -1 || int(logicExca[i+1]) != state {
			i += 2
		}

		// Look for tokens that we accept or reduce.
		for i += 2; logicExca[i] >= 0; i += 2 {
			tok := int(logicExca[i])
			if tok < TOKSTART || logicExca[i+1] == 0 {
				continue
			}
			if len(expected) == cap(expected) {
				return res
			}
			expected = append(expected, tok)
		}

		// If the default action is to accept or reduce, give up.
		if logicExca[i+1] != 0 {
			return res
		}
	}

	for i, tok := range expected {
		if i == 0 {
			res += ", expecting "
		} else {
			res += " or "
		}
		res += logicTokname(tok)
	}
	return res
}

func logiclex1(lex logicLexer, lval *logicSymType) (char, token int) {
	token = 0
	char = lex.Lex(lval)
	if char <= 0 {
		token = int(logicTok1[0])
		goto out
	}
	if char < len(logicTok1) {
		token = int(logicTok1[char])
		goto out
	}
	if char >= logicPrivate {
		if char < logicPrivate+len(logicTok2) {
			token = int(logicTok2[char-logicPrivate])
			goto out
		}
	}
	for i := 0; i < len(logicTok3); i += 2 {
		token = int(logicTok3[i+0])
		if token == char {
			token = int(logicTok3[i+1])
			goto out
		}
	}

out:
	if token == 0 {
		token = int(logicTok2[1]) /* unknown char */
	}
	if logicDebug >= 3 {
		__yyfmt__.Printf("lex %s(%d)\n", logicTokname(token), uint(char))
	}
	return char, token
}

func logicParse(logiclex logicLexer) int {
	return logicNewParser().Parse(logiclex)
}

func (logicrcvr *logicParserImpl) Parse(logiclex logicLexer) int {
	var logicn int
	var logicVAL logicSymType
	var logicDollar []logicSymType
	_ = logicDollar // silence set and not used
	logicS := logicrcvr.stack[:]

	Nerrs := 0   /* number of errors */
	Errflag := 0 /* error recovery flag */
	logicstate := 0
	logicrcvr.char = -1
	logictoken := -1 // logicrcvr.char translated into internal numbering
	defer func() {
		// Make sure we report no lookahead when not parsing.
		logicstate = -1
		logicrcvr.char = -1
		logictoken = -1
	}()
	logicp := -1
	goto logicstack

ret0:
	return 0

ret1:
	return 1

logicstack:
	/* put a state and value onto the stack */
	if logicDebug >= 4 {
		__yyfmt__.Printf("char %v in %v\n", logicTokname(logictoken), logicStatname(logicstate))
	}

	logicp++
	if logicp >= len(logicS) {
		nyys := make([]logicSymType, len(logicS)*2)
		copy(nyys, logicS)
		logicS = nyys
	}
	logicS[logicp] = logicVAL
	logicS[logicp].yys = logicstate

logicnewstate:
	logicn = int(logicPact[logicstate])
	if logicn <= logicFlag {
		goto logicdefault /* simple state */
	}
	if logicrcvr.char < 0 {
		logicrcvr.char, logictoken = logiclex1(logiclex, &logicrcvr.lval)
	}
	logicn += logictoken
	if logicn < 0 || logicn >= logicLast {
		goto logicdefault
	}
	logicn = int(logicAct[logicn])
	if int(logicChk[logicn]) == logictoken { /* valid shift */
		logicrcvr.char = -1
		logictoken = -1
		logicVAL = logicrcvr.lval
		logicstate = logicn
		if Errflag > 0 {
			Errflag--
		}
		goto logicstack
	}

logicdefault:
	/* default state action */
	logicn = int(logicDef[logicstate])
	if logicn == -2 {
		if logicrcvr.char < 0 {
			logicrcvr.char, logictoken = logiclex1(logiclex, &logicrcvr.lval)
		}

		/* look through exception table */
		xi := 0
		for {
			if logicExca[xi+0] == -1 && int(logicExca[xi+1]) == logicstate {
				break
			}
			xi += 2
		}
		for xi += 2; ; xi += 2 {
			logicn = int(logicExca[xi+0])
			if logicn < 0 || logicn == logictoken {
				break
			}
		}
		logicn = int(logicExca[xi+1])
		if logicn < 0 {
			goto ret0
		}
	}
	if logicn == 0 {
		/* error ... attempt to resume parsing */
		switch Errflag {
		case 0: /* brand new error */
			logiclex.Error(logicErrorMessage(logicstate, logictoken))
			Nerrs++
			if logicDebug >= 1 {
				__yyfmt__.Printf("%s", logicStatname(logicstate))
				__yyfmt__.Printf(" saw %s\n", logicTokname(logictoken))
			}
			fallthrough

		case 1, 2: /* incompletely recovered error ... try again */
			Errflag = 3

			/* find a state where "error" is a legal shift action */
			for logicp >= 0 {
				logicn = int(logicPact[logicS[logicp].yys]) + logicErrCode
				if logicn >= 0 && logicn < logicLast {
					logicstate = int(logicAct[logicn]) /* simulate a shift of "error" */
					if int(logicChk[logicstate]) == logicErrCode {
						goto logicstack
					}
				}

				/* the current p has no shift on "error", pop stack */
				if logicDebug >= 2 {
					__yyfmt__.Printf("error recovery pops state %d\n", logicS[logicp].yys)
				}
				logicp--
			}
			/* there is no state on the stack with an error shift ... abort */
			goto ret1

		case 3: /* no shift yet; clobber input char */
			if logicDebug >= 2 {
				__yyfmt__.Printf("error recovery discards %s\n", logicTokname(logictoken))
			}
			if logictoken == logicEofCode {
				goto ret1
			}
			logicrcvr.char = -1
			logictoken = -1
			goto logicnewstate /* try again in the same state */
		}
	}

	/* reduction by production logicn */
	if logicDebug >= 2 {
		__yyfmt__.Printf("reduce %v in:\n\t%v\n", logicn, logicStatname(logicstate))
	}

	logicnt := logicn
	logicpt := logicp
	_ = logicpt // guard against "declared and not used"

	logicp -= int(logicR2[logicn])
	// logicp is now the index of $0. Perform the default action. Iff the
	// reduced production is ε, $1 is possibly out of range.
	if logicp+1 >= len(logicS) {
		nyys := make([]logicSymType, len(logicS)*2)
		copy(nyys, logicS)
		logicS = nyys
	}
	logicVAL = logicS[logicp+1]

	/* consult goto table to find next state */
	logicn = int(logicR1[logicn])
	logicg := int(logicPgo[logicn])
	logicj := logicg + logicS[logicp].yys + 1

	if logicj >= logicLast {
		logicstate = int(logicAct[logicg])
	} else {
		logicstate = int(logicAct[logicj])
		if int(logicChk[logicstate]) != -logicn {
			logicstate = int(logicAct[logicg])
		}
	}
	// dummy call; replaced with literal code
	switch logicnt {

	case 1:
		logicDollar = logicS[logicpt-1 : logicpt+1]
//line logic.y:187
		{
			LogDebug("expr.expr0")
			var err error
			logiclex.(*logicLex).result, err = exprGet(&logicDollar[1], "expr.expr0")
			if err != nil {
				logiclex.(*logicLex).Error(err.Error())
			}
		}
	case 2:
		logicDollar = logicS[logicpt-1 : logicpt+1]
//line logic.y:197
		{
			LogDebug("expr0.expr1")
			err := exprSet(&logicDollar[1], &logicVAL, "expr0.expr1")
			if err != nil {
				logiclex.(*logicLex).Error(err.Error())
			}
		}
	case 3:
		logicDollar = logicS[logicpt-3 : logicpt+1]
//line logic.y:205
		{
			LogDebug("expr0.expr0 ';' expr1")
			err := exprSet(&logicDollar[3], &logicVAL, "expr0.expr0 ';' expr1")
			if err != nil {
				logiclex.(*logicLex).Error(err.Error())
			}
		}
	case 4:
		logicDollar = logicS[logicpt-2 : logicpt+1]
//line logic.y:213
		{
			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()))
					}
				}
			}
		}
	case 5:
		logicDollar = logicS[logicpt-1 : logicpt+1]
//line logic.y:231
		{
			LogDebug("expr1.logic")
			err := exprSet(&logicDollar[1], &logicVAL, "expr1.logic")
			if err != nil {
				logiclex.(*logicLex).Error(err.Error())
			}
		}
	case 6:
		logicDollar = logicS[logicpt-3 : logicpt+1]
//line logic.y:239
		{
			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")
			}
		}
	case 7:
		logicDollar = logicS[logicpt-1 : logicpt+1]
//line logic.y:251
		{
			LogDebug("logic.logic1")
			err := exprSet(&logicDollar[1], &logicVAL, "logic.logic1")
			if err != nil {
				logiclex.(*logicLex).Error(err.Error())
			}
		}
	case 8:
		logicDollar = logicS[logicpt-3 : logicpt+1]
//line logic.y:259
		{
			LogDebug("%v AND %v\n", logicDollar[1].expr_type, logicDollar[3].expr_type)
			logicVAL.expr_type = EXPR_TYPE_BOOL
			logicVAL.bool_type = exprBool(&logicDollar[1]) && exprBool(&logicDollar[3])
		}
	case 9:
		logicDollar = logicS[logicpt-3 : logicpt+1]
//line logic.y:265
		{
			LogDebug("%v AND %v\n", logicDollar[1].expr_type, logicDollar[3].expr_type)
			logicVAL.expr_type = EXPR_TYPE_BOOL
			logicVAL.bool_type = exprBool(&logicDollar[1]) || exprBool(&logicDollar[3])
		}
	case 10:
		logicDollar = logicS[logicpt-1 : logicpt+1]
//line logic.y:272
		{
			LogDebug("logic1.calc1")
			err := exprSet(&logicDollar[1], &logicVAL, "logic1.calc1")
			if err != nil {
				logiclex.(*logicLex).Error(err.Error())
			}
		}
	case 11:
		logicDollar = logicS[logicpt-2 : logicpt+1]
//line logic.y:280
		{
			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))
			}
		}
	case 12:
		logicDollar = logicS[logicpt-2 : logicpt+1]
//line logic.y:293
		{
			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))
			}
		}
	case 13:
		logicDollar = logicS[logicpt-2 : logicpt+1]
//line logic.y:306
		{
			LogDebug("NOT %v\n", logicDollar[2].expr_type)
			logicVAL.expr_type = EXPR_TYPE_BOOL
			logicVAL.bool_type = !exprBool(&logicDollar[2])
		}
	case 14:
		logicDollar = logicS[logicpt-3 : logicpt+1]
//line logic.y:312
		{
			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))
			}
		}
	case 15:
		logicDollar = logicS[logicpt-3 : logicpt+1]
//line logic.y:336
		{
			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))
			}
		}
	case 16:
		logicDollar = logicS[logicpt-3 : logicpt+1]
//line logic.y:359
		{
			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))
			}
		}
	case 17:
		logicDollar = logicS[logicpt-3 : logicpt+1]
//line logic.y:382
		{
			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))
			}
		}
	case 18:
		logicDollar = logicS[logicpt-3 : logicpt+1]
//line logic.y:405
		{
			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))
			}
		}
	case 19:
		logicDollar = logicS[logicpt-1 : logicpt+1]
//line logic.y:433
		{
			LogDebug("calc1.calc2")
			err := exprSet(&logicDollar[1], &logicVAL, "calc1.calc2")
			if err != nil {
				logiclex.(*logicLex).Error(err.Error())
			}
		}
	case 20:
		logicDollar = logicS[logicpt-3 : logicpt+1]
//line logic.y:441
		{
			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)
			}
		}
	case 21:
		logicDollar = logicS[logicpt-3 : logicpt+1]
//line logic.y:483
		{
			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))
			}
		}
	case 22:
		logicDollar = logicS[logicpt-1 : logicpt+1]
//line logic.y:509
		{
			LogDebug("calc2.calc3")
			err := exprSet(&logicDollar[1], &logicVAL, "calc1.calc2")
			if err != nil {
				logiclex.(*logicLex).Error(err.Error())
			}
		}
	case 23:
		logicDollar = logicS[logicpt-3 : logicpt+1]
//line logic.y:517
		{
			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))
			}
		}
	case 24:
		logicDollar = logicS[logicpt-3 : logicpt+1]
//line logic.y:542
		{
			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))
			}
		}
	case 25:
		logicDollar = logicS[logicpt-3 : logicpt+1]
//line logic.y:568
		{
			err := exprSet(&logicDollar[2], &logicVAL, "calc3.'(' calc3 ')'")
			if err != nil {
				logiclex.(*logicLex).Error(err.Error())
			}
		}
	case 26:
		logicDollar = logicS[logicpt-1 : logicpt+1]
//line logic.y:575
		{
			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()))
				}
			}
		}
	case 27:
		logicDollar = logicS[logicpt-1 : logicpt+1]
//line logic.y:588
		{
			LogDebug("calc3.RAND")
			logicVAL.expr_type = EXPR_TYPE_INT
			logicVAL.int_type = rand.Int63()
			LogDebug("RAND:%d\n", logicVAL.int_type)
		}
	case 28:
		logicDollar = logicS[logicpt-3 : logicpt+1]
//line logic.y:595
		{
			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)
		}
	case 29:
		logicDollar = logicS[logicpt-1 : logicpt+1]
//line logic.y:613
		{
			LogDebug("calc3.DATA")
			err := exprSet(&logicDollar[1], &logicVAL, "calc3.DATA")
			if err != nil {
				logiclex.(*logicLex).Error(err.Error())
			}
		}
	}
	goto logicstack /* stack new state and value */
}