openbilibili/go-common
1
0
Fork 0
Code Releases Activity

Create & Init Project...

Browse Source
This commit is contained in:
MiaoWoo
2019-04-22 18:49:16 +08:00
commit fc4fa37393
25440 changed files with 4054998 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
app/interface/main/dm2/lib/xregex/BUILD Normal file
View File

@@ -0,0 +1,32 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_library",
)
go_library(
name = "go_default_library",
srcs = [
"item.go",
"lexer.go",
"parser.go",
],
importpath = "go-common/app/interface/main/dm2/lib/xregex",
tags = ["automanaged"],
visibility = ["//visibility:public"],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

23
app/interface/main/dm2/lib/xregex/item.go Normal file
View File

@@ -0,0 +1,23 @@
package xregex
/*
golang version regex parser
refer to: https://github.com/aristotle9/as3cc/tree/master/java-template/src/org/lala/lex/utils/parser
*/
type rangeItem struct {
from int64
to int64
value int64
}
type stateTransItem struct {
isDead bool
toStates []int64
transEdge []*rangeItem
}
type productionItem struct {
headerID int64
bodyLength int64
}

432
app/interface/main/dm2/lib/xregex/lexer.go Normal file
View File

@@ -0,0 +1,432 @@
package xregex
/*
golang version regex parser
refer to: https://github.com/aristotle9/as3cc/tree/master/java-template/src/org/lala/lex/utils/parser
*/
import (
"errors"
"fmt"
"strconv"
)
const (
_initial = "INITIAL"
_deadState = 0xFFFFFFFF
_maxValue = 0x7fffffffffffffff
)
var (
errEOF = errors.New("已经到达末尾")
)
// Lexer golang lexter
type lexer struct {
transTable []*stateTransItem
finalTable map[int64]int64
initialTable map[string]int64
inputTable []*rangeItem
start int64
oldStart int64
tokenName string
yyText interface{}
yy interface{}
ended bool
initialInput int64
initialState string
line int64
column int64
advanced bool
source string
}
func newLexer() (lx *lexer) {
lx = &lexer{}
lx.transTable = []*stateTransItem{
{false, []int64{0xFFFFFFFF, 0x3, 0x2, 0x1},
[]*rangeItem{{0, 32, 0}, {33, 33, 1},
{34, 34, 2}, {35, 35, 3}}},
{false,
[]int64{0xFFFFFFFF, 0xF, 0xE, 0xD, 0xC, 0xB, 0xA, 0x9, 0x8, 0x7, 0x6, 0x5,
0x4},
[]*rangeItem{{0, 0, 0}, {1, 1, 1},
{2, 2, 2}, {3, 3, 3}, {4, 4, 4},
{5, 5, 5}, {6, 6, 6}, {7, 7, 7},
{8, 28, 8}, {29, 29, 9}, {30, 30, 10},
{31, 31, 11}, {32, 32, 12},
{33, 35, 0}}},
{false, []int64{0xFFFFFFFF, 0xF, 0xE, 0xD, 0x8, 0x12, 0x11, 0x10},
[]*rangeItem{{0, 0, 0}, {1, 1, 1},
{2, 2, 2}, {3, 3, 3}, {4, 7, 4},
{8, 8, 5}, {9, 9, 6}, {10, 27, 4},
{28, 28, 7}, {29, 32, 4},
{33, 35, 0}}},
{false, []int64{0xFFFFFFFF, 0x16, 0x15, 0x14, 0x13},
[]*rangeItem{{0, 21, 0}, {22, 24, 1},
{25, 25, 2}, {26, 26, 3}, {27, 27, 4},
{28, 35, 0}}},
{true, nil, nil}, {true, nil, nil},
{true, nil, nil}, {true, nil, nil},
{true, nil, nil}, {true, nil, nil},
{true, nil, nil}, {true, nil, nil},
{true, nil, nil},
{false,
[]int64{0xFFFFFFFF, 0x1F, 0x17, 0xE, 0x1D, 0x1C, 0x1B, 0x1A, 0x19, 0x1E, 0x21,
0x20, 0x18},
[]*rangeItem{{0, 0, 0}, {1, 1, 1},
{2, 9, 2}, {10, 11, 3}, {12, 12, 4},
{13, 13, 5}, {14, 14, 6}, {15, 15, 7},
{16, 16, 8}, {17, 18, 2}, {19, 19, 9},
{20, 20, 10}, {21, 21, 11}, {22, 23, 2},
{24, 24, 12}, {25, 32, 2},
{33, 35, 0}}},
{true, nil, nil}, {true, nil, nil},
{true, nil, nil}, {true, nil, nil},
{true, nil, nil}, {true, nil, nil},
{false, []int64{0xFFFFFFFF, 0x14},
[]*rangeItem{{0, 25, 0}, {26, 26, 1},
{27, 35, 0}}},
{true, nil, nil},
{false, []int64{0xFFFFFFFF, 0x16},
[]*rangeItem{{0, 21, 0}, {22, 24, 1},
{25, 35, 0}}},
{true, nil, nil},
{false, []int64{0xFFFFFFFF, 0x22},
[]*rangeItem{{0, 22, 0}, {23, 24, 1},
{25, 35, 0}}},
{false, []int64{0xFFFFFFFF, 0x23},
[]*rangeItem{{0, 10, 0}, {11, 11, 1},
{12, 12, 0}, {13, 14, 1}, {15, 17, 0},
{18, 18, 1}, {19, 19, 0}, {20, 20, 1},
{21, 21, 0}, {22, 24, 1},
{25, 35, 0}}},
{false, []int64{0xFFFFFFFF, 0x24},
[]*rangeItem{{0, 10, 0}, {11, 11, 1},
{12, 12, 0}, {13, 14, 1}, {15, 17, 0},
{18, 18, 1}, {19, 19, 0}, {20, 20, 1},
{21, 21, 0}, {22, 24, 1},
{25, 35, 0}}},
{true, nil, nil}, {true, nil, nil},
{true, nil, nil}, {true, nil, nil},
{true, nil, nil}, {true, nil, nil},
{true, nil, nil},
{false, []int64{0xFFFFFFFF, 0x25},
[]*rangeItem{{0, 22, 0}, {23, 24, 1},
{25, 35, 0}}},
{false, []int64{0xFFFFFFFF, 0x26},
[]*rangeItem{{0, 10, 0}, {11, 11, 1},
{12, 12, 0}, {13, 14, 1}, {15, 17, 0},
{18, 18, 1}, {19, 19, 0}, {20, 20, 1},
{21, 21, 0}, {22, 24, 1},
{25, 35, 0}}},
{false, []int64{0xFFFFFFFF, 0x27},
[]*rangeItem{{0, 10, 0}, {11, 11, 1},
{12, 12, 0}, {13, 14, 1}, {15, 17, 0},
{18, 18, 1}, {19, 19, 0}, {20, 20, 1},
{21, 21, 0}, {22, 24, 1},
{25, 35, 0}}},
{true, nil, nil}, {true, nil, nil},
{false, []int64{0xFFFFFFFF, 0x28},
[]*rangeItem{{0, 10, 0}, {11, 11, 1},
{12, 12, 0}, {13, 14, 1}, {15, 17, 0},
{18, 18, 1}, {19, 19, 0}, {20, 20, 1},
{21, 21, 0}, {22, 24, 1},
{25, 35, 0}}},
{false, []int64{0xFFFFFFFF, 0x29},
[]*rangeItem{{0, 10, 0}, {11, 11, 1},
{12, 12, 0}, {13, 14, 1}, {15, 17, 0},
{18, 18, 1}, {19, 19, 0}, {20, 20, 1},
{21, 21, 0}, {22, 24, 1},
{25, 35, 0}}},
{true, nil, nil}}
lx.finalTable = make(map[int64]int64)
lx.finalTable[0x4] = 0x0
lx.finalTable[0x5] = 0x4
lx.finalTable[0x6] = 0x1
lx.finalTable[0x7] = 0x2
lx.finalTable[0x8] = 0x1C
lx.finalTable[0x9] = 0x3
lx.finalTable[0xA] = 0x6
lx.finalTable[0xB] = 0x5
lx.finalTable[0xC] = 0xA
lx.finalTable[0xD] = 0x1C
lx.finalTable[0xE] = 0x12
lx.finalTable[0xF] = 0x1B
lx.finalTable[0x10] = 0x8
lx.finalTable[0x11] = 0x7
lx.finalTable[0x12] = 0x9
lx.finalTable[0x13] = 0xE
lx.finalTable[0x14] = 0xD
lx.finalTable[0x15] = 0xB
lx.finalTable[0x16] = 0xC
lx.finalTable[0x17] = 0x1A
lx.finalTable[0x18] = 0x1A
lx.finalTable[0x19] = 0x1A
lx.finalTable[0x1A] = 0x1A
lx.finalTable[0x1B] = 0x16
lx.finalTable[0x1C] = 0x17
lx.finalTable[0x1D] = 0x13
lx.finalTable[0x1E] = 0x15
lx.finalTable[0x1F] = 0x18
lx.finalTable[0x20] = 0x14
lx.finalTable[0x21] = 0x19
lx.finalTable[0x25] = 0xF
lx.finalTable[0x26] = 0x10
lx.finalTable[0x29] = 0x11
lx.inputTable = []*rangeItem{{0, 8, 17}, {9, 9, 26},
{10, 10, 0}, {11, 12, 17}, {13, 13, 0},
{14, 31, 17}, {32, 32, 26}, {33, 39, 17},
{40, 40, 31}, {41, 41, 5}, {42, 42, 32},
{43, 43, 30}, {44, 44, 25}, {45, 45, 28},
{46, 46, 2}, {47, 47, 1}, {48, 48, 24},
{49, 55, 23}, {56, 57, 22}, {58, 62, 17},
{63, 63, 29}, {64, 64, 17}, {65, 70, 18},
{71, 90, 17}, {91, 91, 6}, {92, 92, 3},
{93, 93, 8}, {94, 94, 9}, {95, 96, 17},
{97, 97, 18}, {98, 98, 14}, {99, 99, 20},
{100, 100, 11}, {101, 101, 18}, {102, 102, 13},
{103, 109, 17}, {110, 110, 21}, {111, 113, 17},
{114, 114, 12}, {115, 115, 10}, {116, 116, 19},
{117, 117, 15}, {118, 118, 17}, {119, 119, 10},
{120, 120, 16}, {121, 122, 17}, {123, 123, 4},
{124, 124, 7}, {125, 125, 27}, {126, 65535, 17}}
lx.initialTable = make(map[string]int64)
lx.initialTable["REPEAT"] = 0x1
lx.initialTable["BRACKET"] = 0x2
lx.initialTable["INITIAL"] = 0x3
return
}
func (lx *lexer) setSource(src string) {
if src != "" {
lx.source = src
}
lx.ended = false
lx.start = 0
lx.oldStart = 0
lx.line = 1
lx.column = 0
lx.advanced = true
lx.tokenName = ""
lx.yy = nil
lx.initialState = _initial
lx.initialInput = lx.initialTable[lx.initialState]
}
func (lx *lexer) getToken() (string, error) {
var err error
if lx.advanced {
lx.tokenName, err = lx.next()
lx.advanced = false
}
return lx.tokenName, err
}
func (lx *lexer) getPositionInfo() string {
return fmt.Sprintf("row(%d) column(%d)", lx.line, lx.column)
}
func (lx *lexer) next() (ret string, err error) {
for {
var (
nextState int64
ch int64
och = _maxValue
next = lx.start
curState = lx.transTable[0].toStates[lx.initialInput]
lastFinalState = int64(_deadState)
lastFinalPosition = lx.start
)
for {
if next < int64(len(lx.source)) {
ch = int64(lx.source[next])
// 计算行、列的位置
if och != _maxValue {
if ch == 0x0d { // \r符号
lx.column = 0
lx.line++
} else if ch == 0x0a { // \n
if och != 0x0d { // != \r
lx.column = 0
lx.line++
}
} else {
lx.column++
}
}
och = int(ch)
if nextState, err = lx.trans(curState, ch); err != nil {
return
}
} else {
nextState = _deadState
}
//OK
if nextState == _deadState {
if lx.start == lastFinalPosition {
if lx.start == int64(len(lx.source)) {
if !lx.ended {
lx.ended = true
return "<$>", nil
}
return "", errEOF
}
return "", fmt.Errorf("意外的字符(line:%d,col:%d) of %s", lx.line, lx.column, lx.source)
}
lx.yyText = lx.source[lx.start:lastFinalPosition]
lx.oldStart = lx.start
lx.start = lastFinalPosition
fIndex := lx.finalTable[lastFinalState]
switch fIndex {
case 0x0:
return "*", nil
case 0x1:
return "+", nil
case 0x2:
return "?", nil
case 0x3:
return "|", nil
case 0x4:
return "(", nil
case 0x5:
return ")", nil
case 0x6:
if err = lx.begin("BRACKET"); err != nil {
return
}
return "[", nil
case 0x7:
return "^", nil
case 0x8:
return "-", nil
case 0x9:
if err = lx.begin("INITIAL"); err != nil {
return
}
return "]", nil
case 0xA:
if err = lx.begin("REPEAT"); err != nil {
return
}
return "{", nil
case 0xB:
return ",", nil
case 0xC:
if lx.yyText, err = strconv.ParseInt(lx.yyText.(string), 10, 64); err != nil {
return
}
return "d", nil
case 0xE:
if err = lx.begin("INITIAL"); err != nil {
return
}
return "}", nil
case 0xF:
var tmp int64
if tmp, err = strconv.ParseInt(lx.yyText.(string)[2:4], 8, 64); err != nil {
return
}
lx.yyText = string(tmp)
return "c", nil
case 0x10:
var tmp int64
if tmp, err = strconv.ParseInt(lx.yyText.(string)[2:4], 16, 64); err != nil {
return
}
lx.yyText = string(tmp)
return "c", nil
case 0x11:
var tmp int64
if tmp, err = strconv.ParseInt(lx.yyText.(string)[2:6], 16, 64); err != nil {
return
}
lx.yyText = string(tmp)
return "c", nil
case 0x12:
return "escc", nil
case 0x13:
lx.yyText = "\r"
return "c", nil
case 0x14:
lx.yyText = "\n"
return "c", nil
case 0x15:
lx.yyText = "\t"
return "c", nil
case 0x16:
lx.yyText = "\b"
return "c", nil
case 0x17:
lx.yyText = "\f"
return "c", nil
case 0x18:
lx.yyText = "/"
return "c", nil
case 0x19:
return "escc", nil
case 0x1A:
lx.yyText = lx.yyText.(string)[1:2]
return "c", nil
case 0x1B:
return "/", nil
case 0x1C:
return "c", nil
}
break
} else {
next++
if _, ok := lx.finalTable[nextState]; ok {
lastFinalState = nextState
lastFinalPosition = next
}
curState = nextState
}
}
}
}
func (lx *lexer) begin(state string) error {
return lx.setInitialState(state)
}
func (lx *lexer) setInitialState(state string) (err error) {
if _, ok := lx.initialTable[state]; !ok {
err = fmt.Errorf("未定义的初始状态:%s", state)
return
}
lx.initialState = state
lx.initialInput = lx.initialTable[state]
return
}
func (lx *lexer) trans(curState, ch int64) (int64, error) {
if ch < lx.inputTable[0].from || ch > lx.inputTable[len(lx.inputTable)-1].to {
return 0, fmt.Errorf("line:%d,column:%d 输入字符超出范围", lx.line, lx.column)
}
if lx.transTable[curState].isDead {
return _deadState, nil
}
pubInput := find(ch, lx.inputTable)
innerInput := find(pubInput, lx.transTable[curState].transEdge)
return lx.transTable[curState].toStates[innerInput], nil
}
func find(code int64, table []*rangeItem) int64 {
var (
max = len(table) - 1
min int
mid uint64
)
for {
mid = uint64(min+max) >> 1
if table[mid].from <= code {
if table[mid].to >= code {
return table[mid].value
}
min = int(mid) + 1
} else {
max = int(mid) - 1
}
}
}

708
app/interface/main/dm2/lib/xregex/parser.go Normal file
View File

@@ -0,0 +1,708 @@
package xregex
/*
golang version regex parser
refer to: https://github.com/aristotle9/as3cc/tree/master/java-template/src/org/lala/lex/utils/parser
*/
import (
"container/list"
"fmt"
"strings"
)
// Parser golang regex parser
type Parser struct {
actionTable []map[int64]int64
gotoTable map[int64]map[int64]int64
prodList []*productionItem
inputTable map[string]int64
codes []interface{}
duplCount int64
num int64
flags string
flagsC string
}
// Info print parser info.
func (p *Parser) Info() (s string) {
s += fmt.Sprintf("actionTable len:%d,", len(p.actionTable))
s += fmt.Sprintf("prodList len:%d,", len(p.prodList))
s += fmt.Sprintf("inputTable len:%d,", len(p.inputTable))
s += fmt.Sprintf("codes len:%d\n", len(p.codes))
return
}
// New return regex parser instance.
func New() (p *Parser) {
p = &Parser{}
var tmp map[int64]int64
p.actionTable = make([]map[int64]int64, 0)
p.actionTable = append(p.actionTable, nil)
tmp = make(map[int64]int64)
tmp[0x20] = 0x4
tmp[0x21] = 0x18
tmp[0x4] = 0x2E
tmp[0x5] = 0x30
tmp[0x6] = 0x1
tmp[0x7] = 0x2
tmp[0x8] = 0x1C
tmp[0x2A] = 0x24
tmp[0x2B] = 0x20
tmp[0x24] = 0x1E
tmp[0x27] = 0x6
tmp[0x10] = 0x10
tmp[0x11] = 0x12
tmp[0x12] = 0x14
tmp[0x14] = 0x1A
tmp[0x15] = 0xE
tmp[0x16] = 0x8
tmp[0x17] = 0xC
tmp[0x1A] = 0x16
tmp[0x1D] = 0xA
tmp[0x2C] = 0x22
p.actionTable = append(p.actionTable, tmp)
tmp = make(map[int64]int64)
tmp[0x0] = 0x5
tmp[0x21] = 0x18
tmp[0x4] = 0x2E
tmp[0x5] = 0x30
tmp[0x2C] = 0x22
tmp[0x8] = 0x1C
tmp[0x9] = 0x2F
tmp[0x2A] = 0x24
tmp[0x2B] = 0x20
tmp[0x24] = 0x1E
tmp[0x10] = 0x10
tmp[0x11] = 0x12
tmp[0x12] = 0x14
tmp[0x14] = 0x1A
tmp[0x15] = 0xE
tmp[0x17] = 0xC
tmp[0x1A] = 0x16
tmp[0x1D] = 0xA
p.actionTable = append(p.actionTable, tmp)
tmp = make(map[int64]int64)
tmp[0x21] = 0x18
tmp[0x4] = 0x2E
tmp[0x5] = 0x30
tmp[0x7] = 0x21
tmp[0x8] = 0x1C
tmp[0x9] = 0x21
tmp[0xA] = 0x21
tmp[0x2B] = 0x20
tmp[0x24] = 0x1E
tmp[0x10] = 0x10
tmp[0x11] = 0x12
tmp[0x12] = 0x14
tmp[0x14] = 0x1A
tmp[0x15] = 0xE
tmp[0x17] = 0xC
tmp[0x1A] = 0x16
tmp[0x2A] = 0x24
tmp[0x1D] = 0xA
tmp[0x2C] = 0x22
p.actionTable = append(p.actionTable, tmp)
tmp = make(map[int64]int64)
tmp[0x0] = 0x7
tmp[0x1] = 0x7
tmp[0x2] = 0x7
tmp[0x4] = 0x2E
tmp[0x5] = 0x30
tmp[0x7] = 0x7
tmp[0x8] = 0x1C
tmp[0x9] = 0x7
tmp[0xA] = 0x7
tmp[0x2B] = 0x20
tmp[0x24] = 0x1E
tmp[0xF] = 0x7
tmp[0x10] = 0x10
tmp[0x11] = 0x12
tmp[0x12] = 0x14
tmp[0x14] = 0x1A
tmp[0x15] = 0xE
tmp[0x17] = 0xC
tmp[0x1A] = 0x16
tmp[0x2A] = 0x24
tmp[0x21] = 0x18
tmp[0x1D] = 0x7
tmp[0x2C] = 0x22
p.actionTable = append(p.actionTable, tmp)
tmp = make(map[int64]int64)
tmp[0x21] = 0x18
tmp[0x4] = 0x2E
tmp[0x5] = 0x30
tmp[0x2C] = 0x22
tmp[0x8] = 0x1C
tmp[0xA] = 0x31
tmp[0x2B] = 0x20
tmp[0x24] = 0x1E
tmp[0x10] = 0x10
tmp[0x11] = 0x12
tmp[0x12] = 0x14
tmp[0x14] = 0x1A
tmp[0x15] = 0xE
tmp[0x17] = 0xC
tmp[0x1A] = 0x16
tmp[0x2A] = 0x24
tmp[0x1D] = 0xA
p.actionTable = append(p.actionTable, tmp)
tmp = make(map[int64]int64)
tmp[0x21] = 0x18
tmp[0x4] = 0x2E
tmp[0x5] = 0x30
tmp[0x7] = 0x23
tmp[0x8] = 0x1C
tmp[0x9] = 0x23
tmp[0xA] = 0x23
tmp[0x2B] = 0x20
tmp[0x24] = 0x1E
tmp[0x10] = 0x10
tmp[0x11] = 0x12
tmp[0x12] = 0x14
tmp[0x14] = 0x23
tmp[0x15] = 0xE
tmp[0x17] = 0xC
tmp[0x1A] = 0x16
tmp[0x2A] = 0x24
tmp[0x1D] = 0x23
tmp[0x2C] = 0x22
p.actionTable = append(p.actionTable, tmp)
tmp = make(map[int64]int64)
tmp[0x21] = 0x18
tmp[0x4] = 0x2E
tmp[0x5] = 0x30
tmp[0x7] = 0x25
tmp[0x8] = 0x1C
tmp[0x9] = 0x25
tmp[0xA] = 0x25
tmp[0x2B] = 0x20
tmp[0x24] = 0x1E
tmp[0x10] = 0x10
tmp[0x11] = 0x12
tmp[0x12] = 0x14
tmp[0x14] = 0x25
tmp[0x15] = 0xE
tmp[0x17] = 0xC
tmp[0x1A] = 0x16
tmp[0x2A] = 0x24
tmp[0x1D] = 0x25
tmp[0x2C] = 0x22
p.actionTable = append(p.actionTable, tmp)
tmp = make(map[int64]int64)
tmp[0x21] = 0x18
tmp[0x4] = 0x2E
tmp[0x5] = 0x30
tmp[0x7] = 0x27
tmp[0x8] = 0x1C
tmp[0x9] = 0x27
tmp[0xA] = 0x27
tmp[0x2B] = 0x20
tmp[0x24] = 0x1E
tmp[0x10] = 0x10
tmp[0x11] = 0x12
tmp[0x12] = 0x14
tmp[0x14] = 0x27
tmp[0x15] = 0xE
tmp[0x17] = 0xC
tmp[0x1A] = 0x16
tmp[0x2A] = 0x24
tmp[0x1D] = 0x27
tmp[0x2C] = 0x22
p.actionTable = append(p.actionTable, tmp)
tmp = make(map[int64]int64)
tmp[0x0] = 0x9
tmp[0x1] = 0x9
tmp[0x2] = 0x9
tmp[0x4] = 0x2E
tmp[0x5] = 0x30
tmp[0x7] = 0x9
tmp[0x8] = 0x1C
tmp[0x9] = 0x9
tmp[0xA] = 0x9
tmp[0x2B] = 0x20
tmp[0x24] = 0x1E
tmp[0xF] = 0x9
tmp[0x10] = 0x10
tmp[0x11] = 0x12
tmp[0x12] = 0x14
tmp[0x14] = 0x1A
tmp[0x15] = 0xE
tmp[0x17] = 0xC
tmp[0x1A] = 0x16
tmp[0x2A] = 0x24
tmp[0x21] = 0x18
tmp[0x1D] = 0x9
tmp[0x2C] = 0x22
p.actionTable = append(p.actionTable, tmp)
tmp = make(map[int64]int64)
tmp[0x28] = 0x26
tmp[0x22] = 0x2C
tmp[0x1C] = 0x28
tmp[0x5] = 0x30
tmp[0x18] = 0x45
tmp[0x1B] = 0x2E
tmp[0xC] = 0x2E
tmp[0xD] = 0x2A
tmp[0xE] = 0x37
p.actionTable = append(p.actionTable, tmp)
tmp = make(map[int64]int64)
tmp[0x3] = 0x19
p.actionTable = append(p.actionTable, tmp)
tmp = make(map[int64]int64)
tmp[0x21] = 0x18
tmp[0x4] = 0x2E
tmp[0x5] = 0x30
tmp[0x7] = 0x29
tmp[0x8] = 0x1C
tmp[0x9] = 0x29
tmp[0xA] = 0x29
tmp[0x2B] = 0x20
tmp[0x24] = 0x1E
tmp[0x10] = 0x10
tmp[0x11] = 0x12
tmp[0x12] = 0x14
tmp[0x14] = 0x29
tmp[0x15] = 0xE
tmp[0x17] = 0xC
tmp[0x1A] = 0x16
tmp[0x2A] = 0x24
tmp[0x1D] = 0x29
tmp[0x2C] = 0x22
p.actionTable = append(p.actionTable, tmp)
tmp = make(map[int64]int64)
tmp[0x1F] = 0x4F
tmp[0x25] = 0x55
tmp[0x13] = 0x3F
p.actionTable = append(p.actionTable, tmp)
tmp = make(map[int64]int64)
tmp[0x29] = 0x5B
tmp[0x25] = 0x57
tmp[0x1E] = 0x4B
tmp[0x26] = 0x59
p.actionTable = append(p.actionTable, tmp)
tmp = make(map[int64]int64)
tmp[0x1E] = 0x4D
tmp[0x13] = 0x41
p.actionTable = append(p.actionTable, tmp)
tmp = make(map[int64]int64)
tmp[0x0] = 0xB
tmp[0x1] = 0xB
tmp[0x2] = 0xB
tmp[0x3] = 0x1B
tmp[0x4] = 0x2E
tmp[0x5] = 0x30
tmp[0x7] = 0xB
tmp[0x8] = 0x1C
tmp[0x9] = 0xB
tmp[0xA] = 0xB
tmp[0xB] = 0x1B
tmp[0xC] = 0x2E
tmp[0xD] = 0x2A
tmp[0xE] = 0x39
tmp[0xF] = 0xB
tmp[0x10] = 0x10
tmp[0x11] = 0x12
tmp[0x12] = 0x14
tmp[0x14] = 0x1A
tmp[0x15] = 0xE
tmp[0x16] = 0x8
tmp[0x17] = 0xC
tmp[0x18] = 0x39
tmp[0x19] = 0x47
tmp[0x1A] = 0x16
tmp[0x1B] = 0x2E
tmp[0x1C] = 0x28
tmp[0x1D] = 0xB
tmp[0x20] = 0xB
tmp[0x21] = 0x18
tmp[0x22] = 0x2C
tmp[0x23] = 0x53
tmp[0x24] = 0x1E
tmp[0x27] = 0x6
tmp[0x28] = 0x26
tmp[0x2A] = 0x24
tmp[0x2B] = 0x20
tmp[0x2C] = 0x22
p.actionTable = append(p.actionTable, tmp)
tmp = make(map[int64]int64)
tmp[0xC] = 0x35
tmp[0x1B] = 0x49
p.actionTable = append(p.actionTable, tmp)
tmp = make(map[int64]int64)
tmp[0x0] = 0xD
tmp[0x1] = 0xD
tmp[0x2] = 0xD
tmp[0x3] = 0xD
tmp[0x4] = 0x2E
tmp[0x5] = 0x30
tmp[0x7] = 0xD
tmp[0x8] = 0x1C
tmp[0x9] = 0xD
tmp[0xA] = 0xD
tmp[0xB] = 0xD
tmp[0xC] = 0x2E
tmp[0xD] = 0x2A
tmp[0xE] = 0xD
tmp[0xF] = 0xD
tmp[0x10] = 0x10
tmp[0x11] = 0x12
tmp[0x12] = 0x14
tmp[0x14] = 0x1A
tmp[0x15] = 0xE
tmp[0x16] = 0x8
tmp[0x17] = 0xC
tmp[0x18] = 0xD
tmp[0x1A] = 0x16
tmp[0x1B] = 0x2E
tmp[0x1C] = 0x28
tmp[0x1D] = 0xD
tmp[0x20] = 0xD
tmp[0x21] = 0x18
tmp[0x22] = 0x2C
tmp[0x24] = 0x1E
tmp[0x27] = 0x6
tmp[0x28] = 0x26
tmp[0x2A] = 0x24
tmp[0x2B] = 0x20
tmp[0x2C] = 0x22
p.actionTable = append(p.actionTable, tmp)
p.gotoTable = make(map[int64]map[int64]int64)
tmp = make(map[int64]int64)
tmp[0xB] = 0x33
tmp[0x3] = 0x1F
p.gotoTable[0x18] = tmp
tmp = make(map[int64]int64)
tmp[0x0] = 0xF
p.gotoTable[0x13] = tmp
tmp = make(map[int64]int64)
tmp[0x0] = 0x11
tmp[0x1] = 0x15
tmp[0x2] = 0x17
tmp[0x14] = 0x2B
tmp[0x7] = 0x2B
tmp[0x9] = 0x2B
tmp[0xA] = 0x2B
tmp[0x1D] = 0x2B
tmp[0xF] = 0x3D
p.gotoTable[0x14] = tmp
tmp = make(map[int64]int64)
tmp[0x16] = 0x43
p.gotoTable[0x15] = tmp
tmp = make(map[int64]int64)
tmp[0x0] = 0x13
tmp[0x1] = 0x13
tmp[0x2] = 0x13
tmp[0x3] = 0x1D
tmp[0x7] = 0x13
tmp[0x20] = 0x51
tmp[0x9] = 0x13
tmp[0xA] = 0x13
tmp[0xB] = 0x1D
tmp[0xE] = 0x3B
tmp[0xF] = 0x13
tmp[0x14] = 0x13
tmp[0x18] = 0x3B
tmp[0x1D] = 0x13
p.gotoTable[0x16] = tmp
tmp = make(map[int64]int64)
tmp[0x9] = 0x2D
tmp[0xA] = 0x2D
tmp[0x14] = 0x2D
tmp[0x1D] = 0x2D
tmp[0x7] = 0x2D
p.gotoTable[0x17] = tmp
p.prodList = []*productionItem{{0x19, 0x2}, {0x13, 0x1},
{0x13, 0x4}, {0x15, 0x2}, {0x15, 0x0},
{0x14, 0x3}, {0x14, 0x3}, {0x14, 0x2},
{0x14, 0x2}, {0x14, 0x2}, {0x14, 0x2},
{0x14, 0x3}, {0x14, 0x4}, {0x14, 0x2},
{0x14, 0x1}, {0x17, 0x3}, {0x17, 0x4},
{0x17, 0x5}, {0x17, 0x4}, {0x18, 0x4},
{0x18, 0x2}, {0x18, 0x1}, {0x18, 0x3},
{0x16, 0x1}, {0x16, 0x1}}
p.inputTable = make(map[string]int64)
p.inputTable["/"] = 0x2
p.inputTable["["] = 0x9
p.inputTable["escc"] = 0x12
p.inputTable["]"] = 0xA
p.inputTable["("] = 0x4
p.inputTable["{"] = 0xC
p.inputTable["^"] = 0xB
p.inputTable[")"] = 0x5
p.inputTable["|"] = 0x3
p.inputTable["?"] = 0x8
p.inputTable["}"] = 0xE
p.inputTable["+"] = 0x7
p.inputTable["*"] = 0x6
p.inputTable[","] = 0xF
p.inputTable["<$>"] = 0x1
p.inputTable["-"] = 0x11
p.inputTable["c"] = 0x10
p.inputTable["d"] = 0xD
return
}
func (p *Parser) put(data interface{}) error {
if fmt.Sprint(data) == "dupl" {
p.duplCount++
if p.duplCount > 100 {
return fmt.Errorf("dupl commands over 100")
}
}
return nil
}
func (p *Parser) parse(lx *lexer) (ret interface{}, err error) {
var (
act int64
token string
tokenID int64
state int64
actObj int64
stateStack = list.New()
outputStack []interface{}
)
stateStack.PushBack(uint(0))
for {
if token, err = lx.getToken(); err != nil {
return
}
tokenID = p.inputTable[token]
state = int64(stateStack.Front().Value.(uint))
actObj = p.actionTable[tokenID][state]
if actObj == 0 {
err = fmt.Errorf("Parse Error: %s", lx.getPositionInfo())
return
}
act = actObj
if act == 1 {
ret = outputStack[len(outputStack)-1]
return
} else if (act & 1) == 1 {
outputStack = append(outputStack, lx.yyText)
stateStack.PushFront(uint(act)>>1 - 1)
lx.advanced = true
} else if (act & 1) == 0 {
pi := uint(act) >> 1
length := p.prodList[pi].bodyLength
var result interface{}
if length > 0 {
result = outputStack[int64(len(outputStack))-length]
}
switch pi {
case 0x1:
result = p.codes
case 0x2:
result = p.codes
case 0x3:
p.flagsC = outputStack[len(outputStack)-1].(string)
if !strings.Contains(p.flags, p.flagsC) {
err = fmt.Errorf("Flag Repeated:%s", lx.getPositionInfo())
return
}
if !strings.Contains("igm", p.flagsC) {
err = fmt.Errorf("Unknow Flag:%s", lx.getPositionInfo())
return
}
p.flags += p.flagsC
case 0x4:
case 0x5:
if err = p.put("or"); err != nil {
return
}
case 0x6:
case 0x7:
case 0x8:
if err = p.put("star"); err != nil {
return
}
case 0x9:
if err = p.put("more"); err != nil {
return
}
case 0xA:
if err = p.put("ask"); err != nil {
return
}
case 0xB:
if err = p.put([]interface{}{"include", outputStack[len(outputStack)-2]}); err != nil {
return
}
case 0xC:
if err = p.put([]interface{}{"exclude", outputStack[len(outputStack)-2]}); err != nil {
return
}
case 0xD:
if err = p.put("cat"); err != nil {
return
}
case 0xE:
if err = p.put("single"); err != nil {
return
}
case 0xF:
p.num = (outputStack[len(outputStack)-2]).(int64) - 1
for p.num > 0 {
if err = p.put("dupl"); err != nil {
return
}
p.num--
}
p.num = (outputStack[len(outputStack)-2]).(int64) - 1
for p.num > 0 {
if err = p.put("cat"); err != nil {
return
}
p.num--
}
case 0x10:
if err = p.put("ask"); err != nil {
return
}
p.num = (outputStack[len(outputStack)-2]).(int64) - 1
for p.num > 0 {
if err = p.put("dupl"); err != nil {
return
}
p.num--
}
p.num = (outputStack[len(outputStack)-2]).(int64) - 1
for p.num > 0 {
if err = p.put("cat"); err != nil {
return
}
p.num--
}
case 0x11:
p.num = (outputStack[len(outputStack)-4]).(int64) - 1
for p.num > 0 {
if err = p.put("dupl"); err != nil {
return
}
p.num--
}
p.num = (outputStack[len(outputStack)-2]).(int64) - (outputStack[len(outputStack)-4]).(int64)
if p.num > 0 {
if err = p.put("dupl"); err != nil {
return
}
if err = p.put("ask"); err != nil {
return
}
for p.num > 1 {
if err = p.put("dupl"); err != nil {
return
}
p.num--
}
}
p.num = (outputStack[len(outputStack)-2]).(int64) - 1
for p.num > 0 {
if err = p.put("cat"); err != nil {
return
}
p.num--
}
case 0x12:
p.num = (outputStack[len(outputStack)-3]).(int64)
for p.num > 0 {
if err = p.put("dupl"); err != nil {
return
}
p.num--
}
if err = p.put("star"); err != nil {
return
}
p.num = (outputStack[len(outputStack)-3]).(int64)
for p.num > 0 {
if err = p.put("cat"); err != nil {
return
}
p.num--
}
case 0x13:
p.num = (outputStack[len(outputStack)-4]).(int64)
result = p.num + 1
if err = p.put([]interface{}{"c", (outputStack[len(outputStack)-3])}); err != nil {
return
}
if err = p.put([]interface{}{"c", (outputStack[len(outputStack)-1])}); err != nil {
return
}
if err = p.put("range"); err != nil {
return
}
case 0x14:
p.num = (outputStack[len(outputStack)-2]).(int64)
result = p.num + 1
if err = p.put("single"); err != nil {
return
}
case 0x15:
if err = p.put("single"); err != nil {
return
}
result = int64(1)
case 0x16:
if err = p.put([]interface{}{"c", (outputStack[len(outputStack)-3])}); err != nil {
return
}
if err = p.put([]interface{}{"c", (outputStack[len(outputStack)-1])}); err != nil {
return
}
if err = p.put("range"); err != nil {
return
}
result = int64(1)
case 0x17:
if err = p.put([]interface{}{"c", (outputStack[len(outputStack)-1])}); err != nil {
return
}
case 0x18:
if "\\c" == outputStack[len(outputStack)-1].(string) {
err = fmt.Errorf("Control Character:%s", lx.getPositionInfo())
return
}
if err = p.put([]interface{}{"escc", (outputStack[len(outputStack)-1])}); err != nil {
return
}
}
/** actions applying end **/
var j int64
var e *list.Element
for j < length {
e = stateStack.Front()
stateStack.Remove(e)
outputStack = outputStack[:len(outputStack)-1]
j++
}
state = int64(stateStack.Front().Value.(uint))
actObj = p.gotoTable[p.prodList[pi].headerID][state]
if actObj == 0 {
err = fmt.Errorf("goto error! %s", lx.getPositionInfo())
return
}
act = actObj
stateStack.PushFront(uint(act)>>1 - 1)
outputStack = append(outputStack, result)
}
}
}
// Parse parse input string.
func (p *Parser) Parse(source string) (result interface{}, err error) {
defer func() {
if e := recover(); e != nil {
err = fmt.Errorf("panic:%v", e)
return
}
}()
if source == "" {
return
}
lx := newLexer()
lx.setSource(source)
return p.parse(lx)
}