hoteas
7f7b585ffb
- 在应用程序中新增对达梦数据库（DM）的配置和连接支持 - 实现 SetDmDB 函数以配置达梦数据库连接 - 更新数据库操作逻辑，支持达梦特有的 SQL 语法和功能 - 在相关文件中添加达梦数据库的处理逻辑，包括表创建、数据插入和查询 - 更新 go.mod 和 go.sum 文件以引入达梦数据库驱动 - 增强文档，详细说明达梦数据库的配置和使用方法
1207 lines
31 KiB
Go
1207 lines
31 KiB
Go
/*
|
|
* Copyright (c) 2000-2018, 达梦数据库有限公司.
|
|
* All rights reserved.
|
|
*/
|
|
package parser
|
|
|
|
import (
|
|
"io"
|
|
"strconv"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
const (
|
|
YYEOF = -1 /** This character denotes the end of file */
|
|
ZZ_BUFFERSIZE = 16384 /** initial size of the lookahead buffer */
|
|
/** lexical states */
|
|
YYINITIAL = 0
|
|
xc = 2
|
|
xq = 4
|
|
xdq = 6
|
|
xsb = 8
|
|
xbin = 10
|
|
xhex = 12
|
|
xhint = 14
|
|
xq2 = 16
|
|
xq2_2 = 18
|
|
)
|
|
|
|
/**
|
|
* ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l
|
|
* ZZ_LEXSTATE[l+1] is the state in the DFA for the lexical state l
|
|
* at the beginning of a line
|
|
* l is of the form l = 2*k, k a non negative integer
|
|
*/
|
|
var ZZ_LEXSTATE []int = []int{0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 4, 4, 7, 7, 8, 8}
|
|
|
|
/**
|
|
* Translates characters to character classes
|
|
*/
|
|
var ZZ_CMAP_PACKED []rune = []rune{0011, 0000, 0001, 0026, 0001, 0025, 0001, 0030, 0001, 0026, 0001, 0025, 0022, 0000, 0001, 0026, 0001, 0017, 0001, 0002,
|
|
0002, 0012, 0002, 0017, 0001, 0001, 0002, 0017, 0001, 0004, 0001, 0023, 0001, 0017, 0001, 0027, 0001, 0016, 0001, 0003,
|
|
0001, 0020, 0011, 0013, 0001, 0014, 0001, 0017, 0001, 0017, 0001, 0015, 0003, 0017, 0001, 0021, 0001, 0010, 0001, 0021,
|
|
0001, 0024, 0001, 0022, 0001, 0024, 0002, 0012, 0001, 0034, 0002, 0012, 0001, 0033, 0001, 0012, 0001, 0031, 0001, 0036,
|
|
0001, 0012, 0001, 0007, 0001, 0012, 0001, 0035, 0001, 0037, 0001, 0032, 0002, 0012, 0001, 0011, 0002, 0012, 0001, 0005,
|
|
0001, 0000, 0001, 0006, 0001, 0017, 0001, 0012, 0001, 0000, 0001, 0021, 0001, 0010, 0001, 0021, 0001, 0024, 0001, 0022,
|
|
0001, 0024, 0002, 0012, 0001, 0034, 0002, 0012, 0001, 0033, 0001, 0012, 0001, 0031, 0001, 0036, 0001, 0012, 0001, 0007,
|
|
0001, 0012, 0001, 0035, 0001, 0037, 0001, 0032, 0002, 0012, 0001, 0011, 0002, 0012, 0001, 0017, 0001, 0017, 0002, 0017,
|
|
0001, 0000, 0005, 0012, 0001, 0012, 0172, 0012, 0x1f28, 0000, 0001, 0030, 0001, 0030, 0xffff, 0000, 0xffff, 0000, 0xffff, 0000, 0xffff, 0000, 0xffff, 0000, 0xffff, 0000, 0xffff, 0000, 0xffff, 0000, 0xffff, 0000, 0xffff, 0000, 0xffff, 0000, 0xffff, 0000, 0xffff, 0000, 0xffff, 0000, 0xffff, 0000, 0xffff, 0000, 0xdfe6, 0000}
|
|
|
|
/**
|
|
* Translates characters to character classes
|
|
*/
|
|
var ZZ_CMAP = zzUnpackCMap(ZZ_CMAP_PACKED)
|
|
|
|
/**
|
|
* Translates DFA states to action switch labels.
|
|
*/
|
|
var ZZ_ACTION = zzUnpackActionNoParams()
|
|
|
|
var ZZ_ACTION_PACKED_0 []rune = []rune{0011, 0000, 0001, 0001, 0001, 0002, 0001, 0003, 0002, 0004, 0004, 0005, 0001, 0006, 0002, 0004,
|
|
0001, 0006, 0001, 0007, 0001, 0004, 0002, 0005, 0001, 0010, 0002, 0011, 0001, 0012, 0001, 0013,
|
|
0001, 0014, 0001, 0015, 0001, 0016, 0001, 0017, 0001, 0020, 0001, 0021, 0001, 0022, 0001, 0023,
|
|
0001, 0024, 0001, 0025, 0001, 0026, 0001, 0007, 0001, 0027, 0001, 0000, 0001, 0030, 0001, 0031,
|
|
0001, 0032, 0001, 0000, 0001, 0033, 0001, 0034, 0001, 0035, 0001, 0032, 0001, 0036, 0001, 0000,
|
|
0003, 0005, 0001, 0037, 0001, 0040, 0001, 0000, 0001, 0041, 0002, 0000, 0001, 0042, 0004, 0000,
|
|
0001, 0043, 0001, 0044, 0001, 0033, 0001, 0000, 0001, 0045, 0002, 0005, 0003, 0000, 0001, 0046,
|
|
0001, 0047, 0001, 0050, 0001, 0051, 0020, 0000, 0001, 0052, 0001, 0000, 0001, 0053, 0001, 0052,
|
|
0001, 0053}
|
|
|
|
func zzUnpackActionNoParams() []int {
|
|
result := make([]int, 104)
|
|
offset := 0
|
|
offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result)
|
|
return result
|
|
}
|
|
|
|
func zzUnpackAction(packed []rune, offset int, result []int) int {
|
|
i := 0 /* index in packed string */
|
|
j := offset /* index in unpacked array */
|
|
l := len(packed) //130
|
|
for i < l {
|
|
count := packed[i]
|
|
i++
|
|
value := packed[i]
|
|
i++
|
|
result[j] = int(value)
|
|
j++
|
|
count--
|
|
for count > 0 {
|
|
result[j] = int(value)
|
|
j++
|
|
count--
|
|
}
|
|
}
|
|
return j
|
|
}
|
|
|
|
/**
|
|
* Translates a state to a row index in the transition table
|
|
*/
|
|
var ZZ_ROWMAP = zzUnpackRowMapNoParams()
|
|
|
|
var ZZ_ROWMAP_PACKED_0 []rune = []rune{0000, 0000, 0000, 0040, 0000, 0100, 0000, 0140, 0000, 0200, 0000, 0240, 0000, 0300, 0000, 0340,
|
|
0000, 0x0100, 0000, 0200, 0000, 0200, 0000, 0200, 0000, 0x0120, 0000, 0200, 0000, 0x0140, 0000, 0x0160,
|
|
0000, 0x0180, 0000, 0x01a0, 0000, 0x01c0, 0000, 0x01e0, 0000, 0x0200, 0000, 0x0220, 0000, 0200, 0000, 0x0240,
|
|
0000, 0x0260, 0000, 0x0280, 0000, 0x02a0, 0000, 0x02c0, 0000, 0x02e0, 0000, 0x0300, 0000, 0x0320, 0000, 0x0340,
|
|
0000, 0x0360, 0000, 0x0380, 0000, 0x03a0, 0000, 0x03c0, 0000, 0x03e0, 0000, 0x0400, 0000, 0200, 0000, 0200,
|
|
0000, 0200, 0000, 0200, 0000, 0x0420, 0000, 0200, 0000, 0x0440, 0000, 0200, 0000, 0200, 0000, 0x0460,
|
|
0000, 0x0480, 0000, 0200, 0000, 0200, 0000, 0200, 0000, 0x04a0, 0000, 0200, 0000, 0x04c0, 0000, 0x04e0,
|
|
0000, 0x0500, 0000, 0x0520, 0000, 0200, 0000, 0200, 0000, 0x02e0, 0000, 0200, 0000, 0x0540, 0000, 0x0560,
|
|
0000, 0200, 0000, 0x0580, 0000, 0x03a0, 0000, 0x05a0, 0000, 0x03e0, 0000, 0200, 0000, 0200, 0000, 0x05c0,
|
|
0000, 0x05c0, 0000, 0x04c0, 0000, 0x05e0, 0000, 0x0600, 0000, 0x0620, 0000, 0x0640, 0000, 0x0660, 0000, 0200,
|
|
0000, 0200, 0000, 0200, 0000, 0x01a0, 0000, 0x0680, 0000, 0x06a0, 0000, 0x06c0, 0000, 0x06e0, 0000, 0x0700,
|
|
0000, 0x0720, 0000, 0x0740, 0000, 0x0760, 0000, 0x0780, 0000, 0x07a0, 0000, 0x07c0, 0000, 0x07e0, 0000, 0x0800,
|
|
0000, 0x0820, 0000, 0x0840, 0000, 0x0860, 0000, 0200, 0000, 0x0880, 0000, 0200, 0000, 0x06e0, 0000, 0x0720}
|
|
|
|
func zzUnpackRowMapNoParams() []int {
|
|
result := make([]int, 104)
|
|
offset := 0
|
|
offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result)
|
|
return result
|
|
}
|
|
|
|
func zzUnpackRowMap(packed []rune, offset int, result []int) int {
|
|
i := 0 /* index in packed string */
|
|
j := offset /* index in unpacked array */
|
|
l := len(packed) //208
|
|
for i < l {
|
|
high := packed[i] << 16
|
|
i++
|
|
result[j] = int(high | packed[i])
|
|
i++
|
|
j++
|
|
}
|
|
return j
|
|
}
|
|
|
|
/**
|
|
* The transition table of the DFA
|
|
*/
|
|
var ZZ_TRANS []int = zzUnpackTransNoParams()
|
|
|
|
var ZZ_TRANS_PACKED_0 []rune = []rune{0001, 0012, 0001, 0013, 0001, 0014, 0001, 0015, 0003, 0016, 0001, 0017, 0001, 0020, 0001, 0021,
|
|
0001, 0022, 0001, 0023, 0001, 0024, 0001, 0016, 0001, 0025, 0001, 0016, 0001, 0026, 0002, 0022,
|
|
0001, 0016, 0001, 0022, 0002, 0027, 0001, 0030, 0001, 0000, 0001, 0031, 0002, 0022, 0001, 0032,
|
|
0003, 0022, 0003, 0033, 0001, 0034, 0001, 0035, 0033, 0033, 0001, 0036, 0001, 0037, 0036, 0036,
|
|
0002, 0040, 0001, 0041, 0035, 0040, 0040, 0000, 0001, 0042, 0001, 0043, 0036, 0042, 0001, 0044,
|
|
0001, 0045, 0036, 0044, 0006, 0046, 0001, 0047, 0031, 0046, 0001, 0050, 0001, 0051, 0004, 0050,
|
|
0001, 0052, 0031, 0050, 0003, 0000, 0001, 0053, 0001, 0054, 0034, 0000, 0001, 0055, 0005, 0000,
|
|
0005, 0022, 0004, 0000, 0003, 0022, 0001, 0000, 0001, 0022, 0004, 0000, 0007, 0022, 0001, 0000,
|
|
0001, 0056, 0005, 0000, 0005, 0022, 0004, 0000, 0003, 0022, 0001, 0000, 0001, 0022, 0004, 0000,
|
|
0007, 0022, 0001, 0000, 0001, 0057, 0005, 0000, 0005, 0022, 0004, 0000, 0003, 0022, 0001, 0000,
|
|
0001, 0022, 0004, 0000, 0007, 0022, 0007, 0000, 0005, 0022, 0004, 0000, 0003, 0022, 0001, 0000,
|
|
0001, 0022, 0004, 0000, 0007, 0022, 0013, 0000, 0001, 0023, 0002, 0000, 0001, 0060, 0001, 0000,
|
|
0001, 0023, 0001, 0000, 0001, 0061, 0001, 0000, 0001, 0062, 0030, 0000, 0001, 0063, 0026, 0000,
|
|
0001, 0064, 0006, 0000, 0001, 0065, 0002, 0000, 0001, 0066, 0001, 0000, 0001, 0065, 0030, 0000,
|
|
0001, 0067, 0001, 0000, 0001, 0023, 0002, 0000, 0001, 0060, 0001, 0000, 0001, 0023, 0001, 0000,
|
|
0001, 0061, 0001, 0000, 0001, 0062, 0042, 0000, 0001, 0053, 0017, 0000, 0005, 0022, 0004, 0000,
|
|
0003, 0022, 0001, 0000, 0001, 0022, 0004, 0000, 0001, 0022, 0001, 0070, 0003, 0022, 0001, 0071,
|
|
0001, 0022, 0007, 0000, 0005, 0022, 0004, 0000, 0003, 0022, 0001, 0000, 0001, 0022, 0004, 0000,
|
|
0004, 0022, 0001, 0072, 0002, 0022, 0003, 0033, 0002, 0000, 0033, 0033, 0004, 0000, 0001, 0073,
|
|
0036, 0000, 0001, 0074, 0001, 0075, 0033, 0000, 0001, 0036, 0001, 0000, 0036, 0036, 0001, 0000,
|
|
0001, 0076, 0023, 0000, 0001, 0077, 0001, 0100, 0011, 0000, 0002, 0040, 0001, 0000, 0035, 0040,
|
|
0002, 0000, 0001, 0101, 0035, 0000, 0001, 0042, 0001, 0000, 0036, 0042, 0025, 0000, 0001, 0102,
|
|
0001, 0103, 0011, 0000, 0001, 0044, 0001, 0000, 0036, 0044, 0025, 0000, 0001, 0104, 0001, 0105,
|
|
0011, 0000, 0006, 0046, 0001, 0000, 0031, 0046, 0025, 0053, 0001, 0000, 0012, 0053, 0005, 0000,
|
|
0001, 0106, 0045, 0000, 0001, 0065, 0002, 0000, 0001, 0107, 0001, 0000, 0001, 0065, 0001, 0000,
|
|
0001, 0061, 0001, 0000, 0001, 0062, 0026, 0000, 0001, 0110, 0004, 0000, 0001, 0110, 0002, 0000,
|
|
0001, 0111, 0003, 0000, 0001, 0111, 0023, 0000, 0001, 0065, 0004, 0000, 0001, 0065, 0001, 0000,
|
|
0001, 0061, 0001, 0000, 0001, 0062, 0023, 0000, 0001, 0112, 0002, 0000, 0001, 0112, 0004, 0000,
|
|
0003, 0112, 0001, 0000, 0001, 0112, 0022, 0000, 0005, 0022, 0004, 0000, 0003, 0022, 0001, 0000,
|
|
0001, 0022, 0004, 0000, 0002, 0022, 0001, 0113, 0004, 0022, 0007, 0000, 0005, 0022, 0004, 0000,
|
|
0003, 0022, 0001, 0000, 0001, 0022, 0004, 0000, 0006, 0022, 0001, 0114, 0003, 0000, 0001, 0115,
|
|
0003, 0000, 0005, 0022, 0004, 0000, 0003, 0022, 0001, 0000, 0001, 0022, 0002, 0116, 0001, 0117,
|
|
0001, 0000, 0007, 0022, 0001, 0000, 0001, 0120, 0023, 0000, 0002, 0077, 0036, 0000, 0001, 0077,
|
|
0001, 0100, 0012, 0000, 0001, 0121, 0023, 0000, 0002, 0102, 0012, 0000, 0001, 0122, 0023, 0000,
|
|
0002, 0104, 0024, 0000, 0001, 0110, 0004, 0000, 0001, 0110, 0026, 0000, 0005, 0022, 0004, 0000,
|
|
0003, 0022, 0001, 0000, 0001, 0022, 0004, 0000, 0002, 0022, 0001, 0123, 0004, 0022, 0003, 0000,
|
|
0001, 0124, 0003, 0000, 0005, 0022, 0004, 0000, 0003, 0022, 0001, 0000, 0001, 0022, 0002, 0125,
|
|
0001, 0126, 0001, 0000, 0007, 0022, 0003, 0000, 0001, 0127, 0037, 0000, 0001, 0115, 0021, 0000,
|
|
0002, 0116, 0001, 0117, 0001, 0000, 0001, 0130, 0035, 0000, 0001, 0127, 0013, 0000, 0001, 0131,
|
|
0037, 0000, 0001, 0124, 0021, 0000, 0002, 0125, 0001, 0126, 0001, 0000, 0001, 0132, 0035, 0000,
|
|
0001, 0131, 0010, 0000, 0025, 0127, 0001, 0116, 0003, 0127, 0001, 0133, 0006, 0127, 0032, 0000,
|
|
0001, 0134, 0005, 0000, 0025, 0131, 0001, 0125, 0003, 0131, 0001, 0135, 0006, 0131, 0032, 0000,
|
|
0001, 0136, 0005, 0000, 0025, 0127, 0001, 0116, 0003, 0127, 0001, 0133, 0001, 0137, 0005, 0127,
|
|
0033, 0000, 0001, 0140, 0004, 0000, 0025, 0131, 0001, 0125, 0003, 0131, 0001, 0135, 0001, 0141,
|
|
0005, 0131, 0033, 0000, 0001, 0142, 0004, 0000, 0025, 0127, 0001, 0116, 0003, 0127, 0001, 0133,
|
|
0001, 0127, 0001, 0143, 0004, 0127, 0033, 0000, 0001, 0144, 0004, 0000, 0025, 0131, 0001, 0125,
|
|
0003, 0131, 0001, 0135, 0001, 0131, 0001, 0145, 0004, 0131, 0033, 0000, 0001, 0146, 0004, 0000,
|
|
0025, 0127, 0001, 0116, 0003, 0127, 0001, 0133, 0001, 0127, 0001, 0147, 0004, 0127, 0025, 0131,
|
|
0001, 0125, 0003, 0131, 0001, 0135, 0001, 0131, 0001, 0150, 0004, 0131}
|
|
|
|
func zzUnpackTransNoParams() []int {
|
|
result := make([]int, 2208)
|
|
offset := 0
|
|
offset = zzUnpackTrans(ZZ_TRANS_PACKED_0, offset, result)
|
|
return result
|
|
}
|
|
|
|
func zzUnpackTrans(packed []rune, offset int, result []int) int {
|
|
i := 0 /* index in packed string */
|
|
j := offset /* index in unpacked array */
|
|
l := len(packed) //780
|
|
for i < l {
|
|
count := packed[i]
|
|
i++
|
|
value := packed[i]
|
|
i++
|
|
value--
|
|
result[j] = int(value)
|
|
j++
|
|
count--
|
|
for count > 0 {
|
|
result[j] = int(value)
|
|
j++
|
|
count--
|
|
}
|
|
}
|
|
return j
|
|
}
|
|
|
|
/* error codes */
|
|
const (
|
|
ZZ_UNKNOWN_ERROR = 0
|
|
ZZ_NO_MATCH = 1
|
|
ZZ_PUSHBACK_2BIG = 2
|
|
)
|
|
|
|
/* error messages for the codes above */
|
|
var ZZ_ERROR_MSG []string = []string{
|
|
"Unknown internal scanner error",
|
|
"Error: could not match input",
|
|
"Error: pushback Value was too large"}
|
|
|
|
/**
|
|
* ZZ_ATTRIBUTE[aState] contains the attributes of state <code>aState</code>
|
|
*/
|
|
var ZZ_ATTRIBUTE []int = zzUnpackAttributeNoParams()
|
|
|
|
var ZZ_ATTRIBUTE_PACKED_0 []rune = []rune{0004, 0000, 0001, 0010, 0004, 0000, 0003, 0011, 0001, 0001, 0001, 0011, 0010, 0001, 0001, 0011,
|
|
0017, 0001, 0004, 0011, 0001, 0001, 0001, 0011, 0001, 0000, 0002, 0011, 0001, 0001, 0001, 0000,
|
|
0003, 0011, 0001, 0001, 0001, 0011, 0001, 0000, 0003, 0001, 0002, 0011, 0001, 0000, 0001, 0011,
|
|
0002, 0000, 0001, 0011, 0004, 0000, 0002, 0011, 0001, 0001, 0001, 0000, 0003, 0001, 0003, 0000,
|
|
0003, 0011, 0001, 0001, 0020, 0000, 0001, 0011, 0001, 0000, 0001, 0011, 0002, 0001}
|
|
|
|
func zzUnpackAttributeNoParams() []int {
|
|
result := make([]int, 104)
|
|
offset := 0
|
|
offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result)
|
|
return result
|
|
}
|
|
|
|
func zzUnpackAttribute(packed []rune, offset int, result []int) int {
|
|
i := 0 /* index in packed string */
|
|
j := offset /* index in unpacked array */
|
|
l := len(packed) //78
|
|
for i < l {
|
|
count := packed[i]
|
|
i++
|
|
value := packed[i]
|
|
i++
|
|
result[j] = int(value)
|
|
j++
|
|
count--
|
|
|
|
for count > 0 {
|
|
result[j] = int(value)
|
|
j++
|
|
count--
|
|
}
|
|
}
|
|
return j
|
|
}
|
|
|
|
type Lexer struct {
|
|
/** the input device */
|
|
zzReader io.RuneReader
|
|
|
|
/** the current state of the DFA */
|
|
zzState int
|
|
|
|
/** the current lexical state */
|
|
zzLexicalState int
|
|
|
|
/** this buffer contains the current text to be matched and is
|
|
the source of the yytext() string */
|
|
zzBuffer []rune
|
|
|
|
//zzBytesBuffer []byte
|
|
|
|
/** the textposition at the last accepting state */
|
|
zzMarkedPos int
|
|
|
|
/** the current text Position in the buffer */
|
|
zzCurrentPos int
|
|
|
|
/** startRead marks the beginning of the yytext() string in the buffer */
|
|
zzStartRead int
|
|
|
|
/** endRead marks the last character in the buffer, that has been read
|
|
from input */
|
|
zzEndRead int
|
|
|
|
/** number of newlines encountered up to the start of the matched text */
|
|
yyline int
|
|
|
|
/** the number of characters up to the start of the matched text */
|
|
yychar int
|
|
|
|
/**
|
|
* the number of characters from the last newline up to the start of the
|
|
* matched text
|
|
*/
|
|
yycolumn int
|
|
|
|
/**
|
|
* zzAtBOL == true <=> the scanner is currently at the beginning of a line
|
|
*/
|
|
zzAtBOL bool
|
|
|
|
/** zzAtEOF == true <=> the scanner is at the EOF */
|
|
zzAtEOF bool
|
|
|
|
/** denotes if the user-EOF-code has already been executed */
|
|
zzEOFDone bool
|
|
|
|
/**
|
|
* The number of occupied positions in zzBuffer beyond zzEndRead.
|
|
* When a lead/high surrogate has been read from the input stream
|
|
* into the final zzBuffer Position, this will have a Value of 1;
|
|
* otherwise, it will have a Value of 0.
|
|
*/
|
|
zzFinalHighSurrogate int
|
|
|
|
/* user code: */
|
|
ltstr string
|
|
debugFlag bool
|
|
}
|
|
|
|
func (lexer *Lexer) init() {
|
|
lexer.zzLexicalState = YYINITIAL
|
|
lexer.zzBuffer = make([]rune, ZZ_BUFFERSIZE)
|
|
lexer.zzAtBOL = true
|
|
}
|
|
|
|
func (lexer *Lexer) Reset(in io.RuneReader) *Lexer {
|
|
lexer.zzLexicalState = YYINITIAL
|
|
lexer.zzAtBOL = true
|
|
lexer.zzReader = in
|
|
lexer.zzState = 0
|
|
lexer.zzMarkedPos = 0
|
|
lexer.zzCurrentPos = 0
|
|
lexer.zzStartRead = 0
|
|
lexer.zzEndRead = 0
|
|
lexer.yyline = 0
|
|
lexer.yychar = 0
|
|
lexer.yycolumn = 0
|
|
lexer.zzAtEOF = false
|
|
lexer.zzEOFDone = false
|
|
lexer.zzFinalHighSurrogate = 0
|
|
lexer.ltstr = ""
|
|
return lexer
|
|
}
|
|
|
|
func (lexer *Lexer) debug(info string) {
|
|
if !lexer.debugFlag {
|
|
return
|
|
}
|
|
|
|
}
|
|
|
|
func (lexer *Lexer) yyerror(msg string) {
|
|
locInfo := "(line: " + strconv.Itoa(lexer.yyline) + ", column: " + strconv.Itoa(lexer.yycolumn) + ", char: " + strconv.Itoa(lexer.yychar) + ")"
|
|
if msg == "" {
|
|
panic("syntex error" + locInfo)
|
|
} else {
|
|
panic("syntex error" + locInfo + ": " + msg)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a new scanner
|
|
*
|
|
* @param in the java.io.Reader to read input from.
|
|
*/
|
|
func NewLexer(in io.RuneReader, debug bool) *Lexer {
|
|
l := new(Lexer)
|
|
l.init()
|
|
l.debugFlag = debug
|
|
l.zzReader = in
|
|
return l
|
|
}
|
|
|
|
/**
|
|
* Unpacks the compressed character translation table.
|
|
*
|
|
* @param packed the packed character translation table
|
|
* @return the unpacked character translation table
|
|
*/
|
|
func zzUnpackCMap(packed []rune) []rune {
|
|
m := make([]rune, 0x110000)
|
|
i := 0 /* index in packed string */
|
|
j := 0 /* index in unpacked array */
|
|
for i < 208 {
|
|
count := packed[i]
|
|
i++
|
|
value := packed[i]
|
|
i++
|
|
m[j] = value
|
|
j++
|
|
count--
|
|
for count > 0 {
|
|
m[j] = value
|
|
j++
|
|
count--
|
|
}
|
|
}
|
|
return m
|
|
}
|
|
|
|
/**
|
|
* Refills the input buffer.
|
|
*
|
|
* @return <code>false</code>, iff there was new input.
|
|
*
|
|
* @exception java.io.IOException if any I/O-Error occurs
|
|
*/
|
|
func (lexer *Lexer) zzRefill() (bool, error) {
|
|
|
|
/* first: make room (if you can) */
|
|
if lexer.zzStartRead > 0 {
|
|
lexer.zzEndRead += lexer.zzFinalHighSurrogate
|
|
lexer.zzFinalHighSurrogate = 0
|
|
l := lexer.zzEndRead - lexer.zzStartRead
|
|
if l > 0 {
|
|
copy(lexer.zzBuffer[:l], lexer.zzBuffer[lexer.zzStartRead:lexer.zzEndRead])
|
|
}
|
|
|
|
/* translate stored positions */
|
|
lexer.zzEndRead -= lexer.zzStartRead
|
|
lexer.zzCurrentPos -= lexer.zzStartRead
|
|
lexer.zzMarkedPos -= lexer.zzStartRead
|
|
lexer.zzStartRead = 0
|
|
}
|
|
|
|
/* is the buffer big enough? */
|
|
if lexer.zzCurrentPos >= len(lexer.zzBuffer)-lexer.zzFinalHighSurrogate {
|
|
/* if not: blow it up */
|
|
newBuffer := make([]rune, len(lexer.zzBuffer)*2)
|
|
|
|
copy(newBuffer[:len(lexer.zzBuffer)], lexer.zzBuffer[:len(lexer.zzBuffer)])
|
|
lexer.zzBuffer = newBuffer
|
|
lexer.zzEndRead += lexer.zzFinalHighSurrogate
|
|
lexer.zzFinalHighSurrogate = 0
|
|
}
|
|
|
|
/* fill the buffer with new input */
|
|
requested := len(lexer.zzBuffer) - lexer.zzEndRead
|
|
|
|
var numRead = 0
|
|
for i := lexer.zzEndRead; i < lexer.zzEndRead+requested; i++ {
|
|
r, _, err := lexer.zzReader.ReadRune()
|
|
if err == io.EOF {
|
|
if numRead == 0 {
|
|
numRead = -1
|
|
}
|
|
break
|
|
} else if err != nil {
|
|
return false, err
|
|
} else {
|
|
numRead++
|
|
lexer.zzBuffer[i] = r
|
|
}
|
|
}
|
|
|
|
/* not supposed to occur according to specification of java.io.Reader */
|
|
if numRead == 0 {
|
|
panic("Reader returned 0 characters. See JFlex examples for workaround.")
|
|
}
|
|
|
|
if numRead > 0 {
|
|
|
|
lexer.zzEndRead += numRead
|
|
/* If numRead == requested, we might have requested to few chars to
|
|
encode a full Unicode character. We assume that a Reader would
|
|
otherwise never return half characters. */
|
|
if numRead == requested {
|
|
if utf8.ValidRune(lexer.zzBuffer[lexer.zzEndRead-1]) {
|
|
lexer.zzEndRead--
|
|
lexer.zzFinalHighSurrogate = 1
|
|
}
|
|
}
|
|
/* potentially more input available */
|
|
return false, nil
|
|
}
|
|
|
|
/* numRead < 0 ==> end of stream */
|
|
return true, nil
|
|
}
|
|
|
|
/**
|
|
* Closes the input stream.
|
|
*/
|
|
func (lexer *Lexer) yyclose() error {
|
|
lexer.zzAtEOF = true /* indicate end of file */
|
|
lexer.zzEndRead = lexer.zzStartRead /* invalidate buffer */
|
|
|
|
if lexer.zzReader != nil {
|
|
if c, ok := lexer.zzReader.(io.Closer); ok {
|
|
return c.Close()
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
/**
|
|
* Resets the scanner to read from a new input stream.
|
|
* Does not close the old reader.
|
|
*
|
|
* All internal variables are reset, the old input stream
|
|
* <b>cannot</b> be reused (internal buffer is discarded and lost).
|
|
* Lexical state is set to <tt>ZZ_INITIAL</tt>.
|
|
*
|
|
* Internal scan buffer is resized down to its initial length, if it has grown.
|
|
*
|
|
* @param reader the new input stream
|
|
*/
|
|
func (lexer *Lexer) yyreset(reader io.RuneReader) {
|
|
lexer.zzReader = reader
|
|
lexer.zzAtBOL = true
|
|
lexer.zzAtEOF = false
|
|
lexer.zzEOFDone = false
|
|
lexer.zzEndRead = 0
|
|
lexer.zzStartRead = 0
|
|
lexer.zzCurrentPos = 0
|
|
lexer.zzMarkedPos = 0
|
|
lexer.zzFinalHighSurrogate = 0
|
|
lexer.yyline = 0
|
|
lexer.yychar = 0
|
|
lexer.yycolumn = 0
|
|
lexer.zzLexicalState = YYINITIAL
|
|
if len(lexer.zzBuffer) > ZZ_BUFFERSIZE {
|
|
lexer.zzBuffer = make([]rune, ZZ_BUFFERSIZE)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the current lexical state.
|
|
*/
|
|
func (lexer *Lexer) yystate() int {
|
|
return lexer.zzLexicalState
|
|
}
|
|
|
|
/**
|
|
* Enters a new lexical state
|
|
*
|
|
* @param newState the new lexical state
|
|
*/
|
|
func (lexer *Lexer) yybegin(newState int) {
|
|
lexer.zzLexicalState = newState
|
|
}
|
|
|
|
/**
|
|
* Returns the text matched by the current regular expression.
|
|
*/
|
|
func (lexer *Lexer) yytext() string {
|
|
return string(lexer.zzBuffer[lexer.zzStartRead:lexer.zzMarkedPos])
|
|
}
|
|
|
|
/**
|
|
* Returns the character at Position <tt>pos</tt> from the
|
|
* matched text.
|
|
*
|
|
* It is equivalent to yytext().charAt(pos), but faster
|
|
*
|
|
* @param pos the Position of the character to fetch.
|
|
* A Value from 0 to yylength()-1.
|
|
*
|
|
* @return the character at Position pos
|
|
*/
|
|
func (lexer *Lexer) yycharat(pos int) rune {
|
|
return lexer.zzBuffer[lexer.zzStartRead+pos]
|
|
}
|
|
|
|
/**
|
|
* Returns the length of the matched text region.
|
|
*/
|
|
func (lexer *Lexer) yylength() int {
|
|
return lexer.zzMarkedPos - lexer.zzStartRead
|
|
}
|
|
|
|
/**
|
|
* Reports an error that occured while scanning.
|
|
*
|
|
* In a wellformed scanner (no or only correct usage of
|
|
* yypushback(int) and a match-all fallback rule) this method
|
|
* will only be called with things that "Can't Possibly Happen".
|
|
* If this method is called, something is seriously wrong
|
|
* (e.g. a JFlex bug producing a faulty scanner etc.).
|
|
*
|
|
* Usual syntax/scanner level error handling should be done
|
|
* in error fallback rules.
|
|
*
|
|
* @param errorCode the code of the errormessage to display
|
|
*/
|
|
func (lexer *Lexer) zzScanError(errorCode int) {
|
|
var message string
|
|
|
|
message = ZZ_ERROR_MSG[errorCode]
|
|
if message == "" {
|
|
message = ZZ_ERROR_MSG[ZZ_UNKNOWN_ERROR]
|
|
}
|
|
|
|
panic(message)
|
|
}
|
|
|
|
/**
|
|
* Pushes the specified amount of characters back into the input stream.
|
|
*
|
|
* They will be read again by then next call of the scanning method
|
|
*
|
|
* @param number the number of characters to be read again.
|
|
* This number must not be greater than yylength()!
|
|
*/
|
|
func (lexer *Lexer) yypushback(number int) {
|
|
if number > lexer.yylength() {
|
|
lexer.zzScanError(ZZ_PUSHBACK_2BIG)
|
|
}
|
|
|
|
lexer.zzMarkedPos -= number
|
|
}
|
|
|
|
/**
|
|
* Resumes scanning until the next regular expression is matched,
|
|
* the end of input is encountered or an I/O-Error occurs.
|
|
*
|
|
* @return the next token
|
|
* @exception java.io.IOException if any I/O-Error occurs
|
|
*/
|
|
func (lexer *Lexer) Yylex() (*LVal, error) {
|
|
var zzInput rune
|
|
var zzAction, zzCurrentPosL, zzMarkedPosL int
|
|
// cached fields:
|
|
zzEndReadL := lexer.zzEndRead
|
|
zzBufferL := lexer.zzBuffer
|
|
zzCMapL := ZZ_CMAP
|
|
|
|
zzTransL := ZZ_TRANS
|
|
zzRowMapL := ZZ_ROWMAP
|
|
zzAttrL := ZZ_ATTRIBUTE
|
|
|
|
for {
|
|
zzMarkedPosL = lexer.zzMarkedPos
|
|
|
|
lexer.yychar += zzMarkedPosL - lexer.zzStartRead
|
|
|
|
zzR := false
|
|
var zzCh rune
|
|
var zzCharCount int
|
|
zzCurrentPosL = lexer.zzStartRead
|
|
for zzCurrentPosL < zzMarkedPosL {
|
|
zzCh = zzBufferL[zzCurrentPosL]
|
|
zzCharCount = utf8.RuneLen(zzCh)
|
|
switch zzCh {
|
|
case '\u000B', '\u000C', '\u0085', '\u2028', '\u2029':
|
|
lexer.yyline++
|
|
lexer.yycolumn = 0
|
|
zzR = false
|
|
case '\r':
|
|
lexer.yyline++
|
|
lexer.yycolumn = 0
|
|
zzR = true
|
|
case '\n':
|
|
if zzR {
|
|
zzR = false
|
|
} else {
|
|
lexer.yyline++
|
|
lexer.yycolumn = 0
|
|
}
|
|
default:
|
|
zzR = false
|
|
lexer.yycolumn += zzCharCount
|
|
}
|
|
zzCurrentPosL += zzCharCount
|
|
}
|
|
|
|
if zzR {
|
|
// peek one character ahead if it is \n (if we have counted one line too much)
|
|
var zzPeek bool
|
|
if zzMarkedPosL < zzEndReadL {
|
|
zzPeek = zzBufferL[zzMarkedPosL] == '\n'
|
|
} else if lexer.zzAtEOF {
|
|
zzPeek = false
|
|
} else {
|
|
eof, err := lexer.zzRefill()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
zzEndReadL = lexer.zzEndRead
|
|
zzMarkedPosL = lexer.zzMarkedPos
|
|
zzBufferL = lexer.zzBuffer
|
|
if eof {
|
|
zzPeek = false
|
|
} else {
|
|
zzPeek = zzBufferL[zzMarkedPosL] == '\n'
|
|
}
|
|
|
|
}
|
|
if zzPeek {
|
|
lexer.yyline--
|
|
}
|
|
}
|
|
zzAction = -1
|
|
|
|
zzCurrentPosL = zzMarkedPosL
|
|
lexer.zzCurrentPos = zzMarkedPosL
|
|
lexer.zzStartRead = zzMarkedPosL
|
|
lexer.zzState = ZZ_LEXSTATE[lexer.zzLexicalState]
|
|
|
|
// set up zzAction for empty match case:
|
|
zzAttributes := zzAttrL[lexer.zzState]
|
|
if (zzAttributes & 1) == 1 {
|
|
zzAction = lexer.zzState
|
|
}
|
|
|
|
{
|
|
for true {
|
|
|
|
if zzCurrentPosL < zzEndReadL {
|
|
zzInput = zzBufferL[zzCurrentPosL]
|
|
zzCurrentPosL += 1 //utf8.RuneLen(zzInput)
|
|
} else if lexer.zzAtEOF {
|
|
zzInput = YYEOF
|
|
goto zzForAction
|
|
} else {
|
|
// store back cached positions
|
|
lexer.zzCurrentPos = zzCurrentPosL
|
|
lexer.zzMarkedPos = zzMarkedPosL
|
|
eof, err := lexer.zzRefill()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// get translated positions and possibly new buffer
|
|
zzCurrentPosL = lexer.zzCurrentPos
|
|
zzMarkedPosL = lexer.zzMarkedPos
|
|
zzBufferL = lexer.zzBuffer
|
|
zzEndReadL = lexer.zzEndRead
|
|
if eof {
|
|
zzInput = YYEOF
|
|
goto zzForAction
|
|
} else {
|
|
zzInput = zzBufferL[zzCurrentPosL]
|
|
zzCurrentPosL += 1 //utf8.RuneLen(zzInput)
|
|
}
|
|
}
|
|
|
|
zzNext := zzTransL[zzRowMapL[lexer.zzState]+int(zzCMapL[zzInput])]
|
|
if zzNext == -1 {
|
|
goto zzForAction
|
|
}
|
|
|
|
lexer.zzState = zzNext
|
|
|
|
zzAttributes = zzAttrL[lexer.zzState]
|
|
if (zzAttributes & 1) == 1 {
|
|
zzAction = lexer.zzState
|
|
zzMarkedPosL = zzCurrentPosL
|
|
if (zzAttributes & 8) == 8 {
|
|
goto zzForAction
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
zzForAction:
|
|
// store back cached Position
|
|
lexer.zzMarkedPos = zzMarkedPosL
|
|
|
|
if zzInput == YYEOF && lexer.zzStartRead == lexer.zzCurrentPos {
|
|
lexer.zzAtEOF = true
|
|
switch lexer.zzLexicalState {
|
|
case xc:
|
|
{
|
|
lexer.debug("<xc><<EOF>>")
|
|
|
|
lexer.yybegin(YYINITIAL)
|
|
lexer.yyerror("unterminated /* comment")
|
|
}
|
|
case 105:
|
|
case xq:
|
|
{
|
|
lexer.debug("<xq><<EOF>>")
|
|
|
|
lexer.yybegin(YYINITIAL)
|
|
lexer.yyerror("unterminated quoted string")
|
|
}
|
|
fallthrough
|
|
case 106:
|
|
case xdq:
|
|
{
|
|
lexer.debug("<xdq><<EOF>>")
|
|
|
|
lexer.yybegin(YYINITIAL)
|
|
lexer.yyerror("unterminated quoted identifier")
|
|
}
|
|
fallthrough
|
|
case 107:
|
|
case xbin:
|
|
{
|
|
lexer.debug("<xbin><<EOF>>")
|
|
|
|
lexer.yybegin(YYINITIAL)
|
|
lexer.yyerror("unterminated binary string literal")
|
|
}
|
|
fallthrough
|
|
case 108:
|
|
case xhex:
|
|
{
|
|
lexer.debug("<xhex><<EOF>>")
|
|
|
|
lexer.yybegin(YYINITIAL)
|
|
lexer.yyerror("unterminated hexadecimal integer")
|
|
}
|
|
fallthrough
|
|
case 109:
|
|
case xq2:
|
|
{
|
|
lexer.yybegin(YYINITIAL)
|
|
lexer.yyerror("unterminated q2 string")
|
|
}
|
|
fallthrough
|
|
case 110:
|
|
case xq2_2:
|
|
{
|
|
lexer.yybegin(YYINITIAL)
|
|
lexer.yyerror("unterminated q2 string")
|
|
}
|
|
fallthrough
|
|
case 111:
|
|
default:
|
|
return nil, nil
|
|
}
|
|
} else {
|
|
var action int
|
|
if zzAction < 0 {
|
|
action = zzAction
|
|
} else {
|
|
action = ZZ_ACTION[zzAction]
|
|
}
|
|
switch action {
|
|
case 1:
|
|
{
|
|
lexer.debug("{other}")
|
|
|
|
return newLVal(lexer.yytext(), NORMAL), nil
|
|
}
|
|
fallthrough
|
|
case 44:
|
|
case 2:
|
|
{
|
|
lexer.debug("{xq_start}")
|
|
|
|
lexer.yybegin(xq)
|
|
lexer.ltstr = ""
|
|
}
|
|
fallthrough
|
|
case 45:
|
|
case 3:
|
|
{
|
|
lexer.debug("{xdq_start}")
|
|
|
|
lexer.yybegin(xdq)
|
|
lexer.ltstr = ""
|
|
lexer.ltstr += lexer.yytext()
|
|
}
|
|
fallthrough
|
|
case 46:
|
|
case 4:
|
|
{
|
|
lexer.debug("{self} | {op_chars}")
|
|
|
|
return newLVal(lexer.yytext(), NORMAL), nil
|
|
}
|
|
fallthrough
|
|
case 47:
|
|
case 5:
|
|
{
|
|
lexer.debug("{identifier}")
|
|
|
|
return newLVal(lexer.yytext(), NORMAL), nil
|
|
}
|
|
fallthrough
|
|
case 48:
|
|
case 6:
|
|
{
|
|
lexer.debug("{integer}")
|
|
|
|
return newLVal(lexer.yytext(), INT), nil
|
|
}
|
|
fallthrough
|
|
case 49:
|
|
case 7:
|
|
{
|
|
lexer.debug("{whitespace} | {comment} | {c_line_comment}")
|
|
|
|
return newLVal(lexer.yytext(), WHITESPACE_OR_COMMENT), nil
|
|
}
|
|
fallthrough
|
|
case 50:
|
|
case 8:
|
|
{
|
|
lexer.debug("<xc>{xc_inside}")
|
|
|
|
lexer.ltstr += lexer.yytext()
|
|
}
|
|
fallthrough
|
|
case 51:
|
|
case 9:
|
|
{
|
|
lexer.debug("<xc>[\\/] | <xc>[\\*]")
|
|
|
|
lexer.ltstr += lexer.yytext()
|
|
}
|
|
fallthrough
|
|
case 52:
|
|
case 10:
|
|
{
|
|
lexer.debug("<xq>{xq_inside}")
|
|
|
|
lexer.ltstr += lexer.yytext()
|
|
}
|
|
fallthrough
|
|
case 53:
|
|
case 11:
|
|
{
|
|
lexer.debug("<xq>{xq_stop}")
|
|
|
|
lexer.yybegin(YYINITIAL)
|
|
return newLVal(lexer.ltstr, STRING), nil
|
|
}
|
|
fallthrough
|
|
case 54:
|
|
case 12:
|
|
{
|
|
lexer.debug("<xdq>{xdq_inside}")
|
|
|
|
lexer.ltstr += lexer.yytext()
|
|
}
|
|
fallthrough
|
|
case 55:
|
|
case 13:
|
|
{
|
|
lexer.debug("<xdq>{xdq_stop}")
|
|
|
|
lexer.yybegin(YYINITIAL)
|
|
lexer.ltstr += lexer.yytext()
|
|
return newLVal(lexer.ltstr, NORMAL), nil
|
|
}
|
|
fallthrough
|
|
case 56:
|
|
case 14:
|
|
{
|
|
lexer.debug("<xbin>{xbin_inside}")
|
|
|
|
lexer.ltstr += lexer.yytext()
|
|
}
|
|
fallthrough
|
|
case 57:
|
|
case 15:
|
|
{
|
|
lexer.debug("<xbin>{xbin_stop}")
|
|
|
|
lexer.yybegin(YYINITIAL)
|
|
lexer.ltstr += lexer.yytext()
|
|
return newLVal(lexer.ltstr, NORMAL), nil
|
|
}
|
|
fallthrough
|
|
case 58:
|
|
case 16:
|
|
{
|
|
lexer.debug("<xhex>{xhex_inside}")
|
|
|
|
lexer.ltstr += lexer.yytext()
|
|
}
|
|
fallthrough
|
|
case 59:
|
|
case 17:
|
|
{
|
|
lexer.debug("<xhex>{xhex_stop}")
|
|
|
|
lexer.yybegin(YYINITIAL)
|
|
lexer.ltstr += lexer.yytext()
|
|
return newLVal(lexer.ltstr, NORMAL), nil
|
|
}
|
|
fallthrough
|
|
case 60:
|
|
case 18:
|
|
{
|
|
lexer.ltstr += lexer.yytext()
|
|
}
|
|
fallthrough
|
|
case 61:
|
|
case 19:
|
|
{
|
|
lexer.yybegin(xq2_2)
|
|
}
|
|
fallthrough
|
|
case 62:
|
|
case 20:
|
|
{
|
|
lexer.ltstr += "]"
|
|
lexer.ltstr += lexer.yytext()
|
|
lexer.yybegin(xq2)
|
|
}
|
|
fallthrough
|
|
case 63:
|
|
case 21:
|
|
{
|
|
lexer.yybegin(YYINITIAL)
|
|
|
|
return newLVal(lexer.ltstr, STRING), nil
|
|
}
|
|
fallthrough
|
|
case 64:
|
|
case 22:
|
|
{
|
|
lexer.ltstr += "]"
|
|
lexer.yybegin(xq2_2)
|
|
}
|
|
fallthrough
|
|
case 65:
|
|
case 23:
|
|
{
|
|
lexer.debug("{xc_start}")
|
|
|
|
lexer.yybegin(xc)
|
|
lexer.ltstr = lexer.yytext()
|
|
}
|
|
fallthrough
|
|
case 66:
|
|
case 24:
|
|
{
|
|
lexer.debug("{xbin_start}")
|
|
|
|
lexer.yybegin(xbin)
|
|
lexer.ltstr = ""
|
|
lexer.ltstr += lexer.yytext()
|
|
}
|
|
fallthrough
|
|
case 67:
|
|
case 25:
|
|
{
|
|
lexer.debug("{xhex_start}")
|
|
|
|
lexer.yybegin(xhex)
|
|
lexer.ltstr = ""
|
|
lexer.ltstr += lexer.yytext()
|
|
}
|
|
fallthrough
|
|
case 68:
|
|
case 26:
|
|
{
|
|
lexer.debug("{decimal}")
|
|
|
|
return newLVal(lexer.yytext(), DECIMAL), nil
|
|
}
|
|
fallthrough
|
|
case 69:
|
|
case 27:
|
|
{
|
|
lexer.debug("{real}")
|
|
|
|
return newLVal(lexer.yytext(), DOUBLE), nil
|
|
}
|
|
fallthrough
|
|
case 70:
|
|
case 28:
|
|
{
|
|
lexer.debug("{assign}")
|
|
|
|
return newLVal(lexer.yytext(), NORMAL), nil
|
|
}
|
|
fallthrough
|
|
case 71:
|
|
case 29:
|
|
{
|
|
lexer.debug("{selstar}")
|
|
|
|
return newLVal(lexer.yytext(), NORMAL), nil
|
|
}
|
|
fallthrough
|
|
case 72:
|
|
case 30:
|
|
{
|
|
lexer.debug("{boundary}")
|
|
|
|
return newLVal(lexer.yytext(), NORMAL), nil
|
|
}
|
|
fallthrough
|
|
case 73:
|
|
case 31:
|
|
{
|
|
lexer.debug("<xc>{xc_start}")
|
|
|
|
lexer.ltstr += lexer.yytext()
|
|
}
|
|
fallthrough
|
|
case 74:
|
|
case 32:
|
|
{
|
|
lexer.debug("<xc>{xc_stop}")
|
|
|
|
lexer.yybegin(YYINITIAL)
|
|
lexer.ltstr += lexer.yytext()
|
|
return newLVal(lexer.ltstr, WHITESPACE_OR_COMMENT), nil
|
|
}
|
|
fallthrough
|
|
case 75:
|
|
case 33:
|
|
{
|
|
lexer.debug("<xq>{xq_double}")
|
|
|
|
lexer.ltstr += "\\'"
|
|
}
|
|
fallthrough
|
|
case 76:
|
|
case 34:
|
|
{ // keep original string
|
|
lexer.debug("<xdq>{xdq_double}")
|
|
|
|
lexer.ltstr += lexer.yytext()
|
|
}
|
|
fallthrough
|
|
case 77:
|
|
case 35:
|
|
{
|
|
lexer.yybegin(xq2)
|
|
lexer.ltstr = ""
|
|
}
|
|
fallthrough
|
|
case 78:
|
|
case 36:
|
|
{
|
|
lexer.debug("{integer_with_boundary}")
|
|
|
|
return newLVal(lexer.yytext(), NORMAL), nil
|
|
}
|
|
fallthrough
|
|
case 79:
|
|
case 37:
|
|
{
|
|
lexer.debug("{hex_integer}")
|
|
|
|
return newLVal(lexer.yytext(), HEX_INT), nil
|
|
}
|
|
fallthrough
|
|
case 80:
|
|
case 38:
|
|
{
|
|
lexer.debug("<xq>{xq_cat}")
|
|
}
|
|
fallthrough
|
|
case 81:
|
|
case 39:
|
|
{ /* ignore */
|
|
lexer.debug("<xbin>{xbin_cat}")
|
|
}
|
|
fallthrough
|
|
case 82:
|
|
case 40:
|
|
{
|
|
lexer.debug("<xhex>{xhex_cat}")
|
|
}
|
|
fallthrough
|
|
case 83:
|
|
case 41:
|
|
{
|
|
lexer.debug("{null}")
|
|
|
|
return newLVal("null", NULL), nil
|
|
}
|
|
fallthrough
|
|
case 84:
|
|
case 42:
|
|
{
|
|
lexer.debug("{is_null}")
|
|
|
|
return newLVal(lexer.yytext(), NORMAL), nil
|
|
}
|
|
fallthrough
|
|
case 85:
|
|
case 43:
|
|
{
|
|
lexer.debug("{not_null}")
|
|
|
|
return newLVal(lexer.yytext(), NORMAL), nil
|
|
}
|
|
fallthrough
|
|
case 86:
|
|
default:
|
|
lexer.zzScanError(ZZ_NO_MATCH)
|
|
}
|
|
}
|
|
}
|
|
}
|