Coverage Report

Generated on Fri, 15 Sep 2023 17:19:28 CST with gocov-html

Report Overview

`github.com/gobatis/gobatis`	`59.5%`	`256/430`
`github.com/gobatis/gobatis/cast`	`47.0%`	`678/1444`
`github.com/gobatis/gobatis/driver/postgres`	`93.3%`	`14/15`
`github.com/gobatis/gobatis/dtd`	`0.0%`	`0/76`
`github.com/gobatis/gobatis/executor`	`45.8%`	`721/1574`
`github.com/gobatis/gobatis/parser/expr`	`43.4%`	`532/1226`
`github.com/gobatis/gobatis/parser/simplemath`	`52.6%`	`153/291`
`github.com/gobatis/gobatis/parser/structpath`	`45.2%`	`128/283`
`github.com/gobatis/gobatis/parser/xml`	`37.5%`	`178/475`

This coverage report has been generated with the following command:

gocov test github.com/gobatis/gobatis github.com/gobatis/gobatis/cast github.com/gobatis/gobatis/driver/postgres github.com/gobatis/gobatis/dtd github.com/gobatis/gobatis/executor github.com/gobatis/gobatis/parser/expr github.com/gobatis/gobatis/parser/simplemath github.com/gobatis/gobatis/parser/structpath github.com/gobatis/gobatis/parser/xml | gocov-html

Package Overview: github.com/gobatis/gobatis 59.5%

Please select a function to see what's left for testing.

`DB.Affect(...)`	`github.com/gobatis/gobatis/db.go`	`100.0%`	`3/3`
`DB.Debug(...)`	`github.com/gobatis/gobatis/db.go`	`100.0%`	`3/3`
`returning.Raw(...)`	`github.com/gobatis/gobatis/element.go`	`100.0%`	`2/2`
`exec.Raw(...)`	`github.com/gobatis/gobatis/element.go`	`100.0%`	`2/2`
`DB.Scan(...)`	`github.com/gobatis/gobatis/db.go`	`100.0%`	`2/2`
`where.Raw(...)`	`github.com/gobatis/gobatis/element.go`	`100.0%`	`2/2`
`query.Raw(...)`	`github.com/gobatis/gobatis/element.go`	`100.0%`	`2/2`
`onConflict.Raw(...)`	`github.com/gobatis/gobatis/element.go`	`100.0%`	`2/2`
`DB.RowsAffected(...)`	`github.com/gobatis/gobatis/db.go`	`100.0%`	`1/1`
`@434:65(...)`	`github.com/gobatis/gobatis/db.go`	`100.0%`	`1/1`
`DB.addError(...)`	`github.com/gobatis/gobatis/db.go`	`100.0%`	`1/1`
`DB.Close(...)`	`github.com/gobatis/gobatis/db.go`	`100.0%`	`1/1`
`PagingScan(...)`	`github.com/gobatis/gobatis/queryer.go`	`100.0%`	`1/1`
`Param(...)`	`github.com/gobatis/gobatis/param.go`	`100.0%`	`1/1`
`DB.clone(...)`	`github.com/gobatis/gobatis/db.go`	`100.0%`	`1/1`
`OnConflict(...)`	`github.com/gobatis/gobatis/element.go`	`100.0%`	`1/1`
`Returning(...)`	`github.com/gobatis/gobatis/element.go`	`100.0%`	`1/1`
`DB.Ping(...)`	`github.com/gobatis/gobatis/db.go`	`100.0%`	`1/1`
`@370:10(...)`	`github.com/gobatis/gobatis/db.go`	`100.0%`	`1/1`
`Where(...)`	`github.com/gobatis/gobatis/element.go`	`100.0%`	`1/1`
`ParallelQuery.executor(...)`	`github.com/gobatis/gobatis/queryer.go`	`88.9%`	`8/9`
`PagingQuery.executors(...)`	`github.com/gobatis/gobatis/queryer.go`	`87.5%`	`14/16`
`@176:74(...)`	`github.com/gobatis/gobatis/db.go`	`85.7%`	`6/7`
`Open(...)`	`github.com/gobatis/gobatis/db.go`	`83.3%`	`5/6`
`DB.FetchQuery(...)`	`github.com/gobatis/gobatis/db.go`	`81.8%`	`9/11`
`DB.Insert(...)`	`github.com/gobatis/gobatis/db.go`	`80.0%`	`8/10`
`DB.Update(...)`	`github.com/gobatis/gobatis/db.go`	`80.0%`	`8/10`
`DB.raw(...)`	`github.com/gobatis/gobatis/db.go`	`80.0%`	`4/5`
`DB.ParallelQuery(...)`	`github.com/gobatis/gobatis/db.go`	`75.0%`	`18/24`
`del.Raw(...)`	`github.com/gobatis/gobatis/element.go`	`75.0%`	`15/20`
`DB.Delete(...)`	`github.com/gobatis/gobatis/db.go`	`75.0%`	`6/8`
`DB.Exec(...)`	`github.com/gobatis/gobatis/db.go`	`75.0%`	`6/8`
`DB.Query(...)`	`github.com/gobatis/gobatis/db.go`	`71.4%`	`5/7`
`DB.InsertBatch(...)`	`github.com/gobatis/gobatis/db.go`	`70.4%`	`19/27`
`update.Raw(...)`	`github.com/gobatis/gobatis/element.go`	`70.0%`	`21/30`
`insert.Raw(...)`	`github.com/gobatis/gobatis/element.go`	`68.2%`	`30/44`
`DB.PagingQuery(...)`	`github.com/gobatis/gobatis/db.go`	`66.7%`	`4/6`
`DB.conn(...)`	`github.com/gobatis/gobatis/db.go`	`66.7%`	`4/6`
`DB.context(...)`	`github.com/gobatis/gobatis/db.go`	`66.7%`	`2/3`
`insertBatch.Raw(...)`	`github.com/gobatis/gobatis/element.go`	`52.3%`	`23/44`
`@369:6(...)`	`github.com/gobatis/gobatis/db.go`	`50.0%`	`3/6`
`DB.setExecutor(...)`	`github.com/gobatis/gobatis/db.go`	`50.0%`	`2/4`
`@252:8(...)`	`github.com/gobatis/gobatis/element.go`	`50.0%`	`1/2`
`@160:8(...)`	`github.com/gobatis/gobatis/element.go`	`50.0%`	`1/2`
`DB.execute(...)`	`github.com/gobatis/gobatis/db.go`	`44.4%`	`4/9`
`DB.Begin(...)`	`github.com/gobatis/gobatis/db.go`	`0.0%`	`0/13`
`UseDB(...)`	`github.com/gobatis/gobatis/db.go`	`0.0%`	`0/7`
`DB.Rollback(...)`	`github.com/gobatis/gobatis/db.go`	`0.0%`	`0/6`
`DB.Commit(...)`	`github.com/gobatis/gobatis/db.go`	`0.0%`	`0/6`
`DB.WithContext(...)`	`github.com/gobatis/gobatis/db.go`	`0.0%`	`0/6`
`DB.WithTraceId(...)`	`github.com/gobatis/gobatis/db.go`	`0.0%`	`0/6`
`selectColumns.Reflect(...)`	`github.com/gobatis/gobatis/rows.go`	`0.0%`	`0/4`
`DB.Trace(...)`	`github.com/gobatis/gobatis/db.go`	`0.0%`	`0/3`
`innerSQL.Raw(...)`	`github.com/gobatis/gobatis/element.go`	`0.0%`	`0/2`
`@499:8(...)`	`github.com/gobatis/gobatis/db.go`	`0.0%`	`0/2`
`@478:8(...)`	`github.com/gobatis/gobatis/db.go`	`0.0%`	`0/2`
`DB.DB(...)`	`github.com/gobatis/gobatis/db.go`	`0.0%`	`0/1`
`WithDebug(...)`	`github.com/gobatis/gobatis/db.go`	`0.0%`	`0/1`
`fetch.Raw(...)`	`github.com/gobatis/gobatis/element.go`	`0.0%`	`0/1`
`Config.Apply(...)`	`github.com/gobatis/gobatis/config.go`	`0.0%`	`0/1`
`@446:8(...)`	`github.com/gobatis/gobatis/db.go`	`0.0%`	`0/1`
`newInnerSQL(...)`	`github.com/gobatis/gobatis/element.go`	`0.0%`	`0/1`
`build.Raw(...)`	`github.com/gobatis/gobatis/element.go`	`0.0%`	`0/1`
`@53:12(...)`	`github.com/gobatis/gobatis/db.go`	`0.0%`	`0/1`
`DB.LastInsertId(...)`	`github.com/gobatis/gobatis/db.go`	`0.0%`	`0/1`
`DB.AssociateQuery(...)`	`github.com/gobatis/gobatis/db.go`	`0.0%`	`0/1`
`LooseDest(...)`	`github.com/gobatis/gobatis/param.go`	`0.0%`	`0/1`
`WithTraceId(...)`	`github.com/gobatis/gobatis/db.go`	`0.0%`	`0/1`
`WithTx(...)`	`github.com/gobatis/gobatis/db.go`	`0.0%`	`0/1`
`Config.AfterInitialize(...)`	`github.com/gobatis/gobatis/config.go`	`0.0%`	`0/1`
`AssociateLink(...)`	`github.com/gobatis/gobatis/queryer.go`	`0.0%`	`0/1`
`Select(...)`	`github.com/gobatis/gobatis/rows.go`	`0.0%`	`0/1`
`Except(...)`	`github.com/gobatis/gobatis/rows.go`	`0.0%`	`0/1`
`DB.Stats(...)`	`github.com/gobatis/gobatis/db.go`	`0.0%`	`0/1`
`exceptColumns.Reflect(...)`	`github.com/gobatis/gobatis/rows.go`	`0.0%`	`0/1`

func DB.Affect

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) Affect(v any) *DB {
        c := d.clone()
        c.affect = v
        return c
}

func DB.Debug

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) Debug() *DB {
        c := d.clone()
        c.debug = true
        return c
}

func returning.Raw

Back

In /Users/kun/gobatis/gobatis/element.go:

func (r returning) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {
        raw = &executor.Raw{
                SQL: fmt.Sprintf("returning %s", executor.TrimColumns(r.sql)),
        }
        return
}

func exec.Raw

Back

In /Users/kun/gobatis/gobatis/element.go:

func (e exec) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {
        raw = &executor.Raw{
                SQL:    strings.TrimSpace(e.sql),
                Params: e.params,
        }
        return
}

func DB.Scan

Back

In /Users/kun/gobatis/gobatis/db.go:

223	`func (d DB) Scan(dest any) DB {`
224	`d.execute(dest)`
225	`return d`
226	`}`

func where.Raw

Back

In /Users/kun/gobatis/gobatis/element.go:

func (w where) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {
        raw = &executor.Raw{
                SQL:    fmt.Sprintf("where %s", strings.TrimSpace(w.sql)),
                Params: w.params,
        }
        return
}

func query.Raw

Back

In /Users/kun/gobatis/gobatis/element.go:

func (q query) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {
        raw = &executor.Raw{
                Query:  true,
                SQL:    q.sql,
                Params: q.params,
        }
        return
}

func onConflict.Raw

Back

In /Users/kun/gobatis/gobatis/element.go:

func (o onConflict) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {
        raw = &executor.Raw{
                SQL:    fmt.Sprintf("on conflict(%s) %s", executor.TrimColumns(o.fields), o.sql),
                Params: o.params,
        }
        return
}

func DB.RowsAffected

Back

In /Users/kun/gobatis/gobatis/db.go:

400	`func (d *DB) RowsAffected() (int64, error) {`
401	`return d.rowsAffected, d.Error`
402	`}`

func @434:65

Back

In /Users/kun/gobatis/gobatis/db.go:

434	`func(s executor.Scanner) error {`
435	`return query.Scan(s)`
436	`}`

func DB.addError

Back

In /Users/kun/gobatis/gobatis/db.go:

83	`func (d *DB) addError(err error) {`
84	`d.Error = executor.AddError(d.Error, err)`
85	`}`

func DB.Close

Back

In /Users/kun/gobatis/gobatis/db.go:

140	`func (d *DB) Close() error {`
141	`return d.db.Close()`
142	`}`

func PagingScan

Back

In /Users/kun/gobatis/gobatis/queryer.go:

43	`func PagingScan(items any, count any) []any {`
44	`return []any{items, count}`
45	`}`

func Param

Back

In /Users/kun/gobatis/gobatis/param.go:

11	`func Param(name string, value any) executor.Param {`
12	`return executor.Param{Name: name, Value: value}`
13	`}`

func DB.clone

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) clone() *DB {
        return &DB{
                Config:   d.Config,
                Error:    d.Error,
                tx:       d.tx,
                ctx:      d.ctx,
                trace:    d.trace,
                debug:    d.debug,
                traceId:  d.traceId,
                affect:   d.affect,
                executed: d.executed,
                executor: nil,
        }
}

func OnConflict

Back

In /Users/kun/gobatis/gobatis/element.go:

func OnConflict(fields string, sql string, params ...executor.Param) Element {
        return &onConflict{
                fields: fields,
                sql:    sql,
                params: params,
        }
}

func Returning

Back

In /Users/kun/gobatis/gobatis/element.go:

func Returning(fields string) Element {
        return &returning{
                sql: fields,
        }
}

func DB.Ping

Back

In /Users/kun/gobatis/gobatis/db.go:

148	`func (d *DB) Ping() error {`
149	`return d.db.Ping()`
150	`}`

func @370:10

Back

In /Users/kun/gobatis/gobatis/db.go:

370	`func() {`
371	`wg.Done()`
372	`}`

func Where

Back

In /Users/kun/gobatis/gobatis/element.go:

func Where(sql string, params ...executor.Param) Element {
        return &where{
                sql:    sql,
                params: params,
        }
}

func ParallelQuery.executor

Back

In /Users/kun/gobatis/gobatis/queryer.go:

func (q ParallelQuery) executor(namer dialector.Namer, tag string) (*executor.ParallelQuery, error) {
        if q.Scan == nil {
                return nil, fmt.Errorf("expect 1 scan dest; got nil")
        }
        var params []executor.Param
        for k, v := range q.Params {
                params = append(params, executor.Param{
                        Name:  k,
                        Value: v,
                })
        }
        raw := &executor.Raw{
                Ctx:    nil,
                Query:  true,
                SQL:    q.SQL,
                Params: nil,
        }
        for k, v := range q.Params {
                raw.Params = append(raw.Params, Param(k, v))
        }
        return &executor.ParallelQuery{Raw: raw, Dest: q.Scan}, nil
}

func PagingQuery.executors

Back

In /Users/kun/gobatis/gobatis/queryer.go:

func (p PagingQuery) executors(namer dialector.Namer, tag string) ([]ParallelQuery, error) {
        
        if p.Limit <= 0 {
                return nil, fmt.Errorf("invalid limit")
        }
        
        if l := len(p.Scan); l != 2 {
                return nil, fmt.Errorf("expect 2 scan dest; got: %d", l)
        }
        
        var params []executor.Param
        for k, v := range p.Params {
                params = append(params, executor.Param{
                        Name:  k,
                        Value: v,
                })
        }
        w := ""
        if p.Where != "" {
                w = fmt.Sprintf(" where %s", p.Where)
        }
        o := ""
        if p.Order != "" {
                o = fmt.Sprintf(" order by %s", p.Order)
        }
        q := ParallelQuery{
                SQL:    fmt.Sprintf("select %s from %s%s%s limit %d offset %d", p.Select, p.From, w, o, p.Limit, p.Limit*p.Page),
                Params: p.Params,
                Scan:   p.Scan[0],
        }
        
        c := ParallelQuery{
                SQL:    fmt.Sprintf("select count(%s) from %s%s", p.Count, p.From, w),
                Params: p.Params,
                Scan:   p.Scan[1],
        }
        
        return []ParallelQuery{q, c}, nil
}

func @176:74

Back

In /Users/kun/gobatis/gobatis/db.go:

func(s executor.Scanner) error {
                if d.executor.Query() {
                        e := s.Scan(dest)
                        if e != nil {
                                return e
                        }
                }
                d.rowsAffected = s.RowsAffected()
                d.lastInsertId = s.LastInsertId()
                return nil
        }

func Open

Back

In /Users/kun/gobatis/gobatis/db.go:

func Open(d dialector.Dialector, options ...Option) (db *DB, err error) {
        config := &Config{
                CreateBatchSize: 10,
                Plugins:         nil,
                NowFunc: func() time.Time {
                        return time.Now()
                },
                Dialector: d,
                Logger:    executor.DefaultLogger(),
                db:        nil,
        }
        config.db, err = d.DB()
        if err != nil {
                return
        }
        db = &DB{Config: config, Error: nil}
        return
}

func DB.FetchQuery

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) FetchQuery(query FetchQuery) error {
        
        c := d.clone()
        
        raw := &executor.Raw{
                Ctx:    d.context(),
                Query:  true,
                SQL:    query.SQL,
                Params: nil,
        }
        
        if query.Scan == nil {
                d.addError(fmt.Errorf("FetchQeruy.Scan is nil"))
                return c.Error
        }
        
        for k, v := range query.Params {
                raw.Params = append(raw.Params, executor.Param{
                        Name:  k,
                        Value: v,
                })
        }
        if c.traceId == "" {
                c.traceId = fmt.Sprintf("TID%d", time.Now().UnixNano())
        }
        c.setExecutor(executor.NewFetchQuery(c.context(), c.conn(), raw, query.Batch))
        return c.executor.Execute(c.Logger, "", c.trace, c.debug, nil, func(s executor.Scanner) error {
                return query.Scan(s)
        })
}

func DB.Insert

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) Insert(table string, data any, elems ...Element) *DB {
        c := d.clone()
        i := &insert{table: table, data: data, elems: elems}
        raw, err := c.raw(i)
        if err != nil {
                c.addError(err)
                return c
        }
        c.executor = executor.NewDefault(c.conn(), raw)
        if !raw.Query {
                c.execute(nil)
        }
        return c
}

func DB.Update

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) Update(table string, data map[string]any, where Element, elems ...Element) *DB {
        c := d.clone()
        u := update{table: table, data: data, elems: append([]Element{where}, elems...)}
        raw, err := c.raw(u)
        if err != nil {
                c.addError(err)
                return c
        }
        c.executor = executor.NewDefault(c.conn(), raw)
        if !raw.Query {
                c.execute(nil)
        }
        return c
}

func DB.raw

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) raw(element Element) (raw *executor.Raw, err error) {
        raw, err = element.Raw(d.Dialector.Namer(), "db")
        if err != nil {
                return
        }
        raw.Ctx = d.context()
        return
}

func DB.ParallelQuery

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) ParallelQuery(queryer ...ParallelQuery) *DB {
        c := d.clone()
        if len(queryer) == 0 {
                c.addError(fmt.Errorf("no querer"))
                return c
        }
        if d.executor != nil {
                c.addError(fmt.Errorf("db executor confilct"))
                return c
        }
        
        var executors []executor.Executor
        for _, v := range queryer {
                item, err := v.executor(d.Dialector.Namer(), "db")
                if err != nil {
                        c.addError(err)
                        return c
                }
                item.Conn = c.conn()
                item.Raw.Ctx = c.context()
                executors = append(executors, item)
        }
        
        lock := sync.Mutex{}
        wg := sync.WaitGroup{}
        pos := executor.CallFuncPos(0)
        for _, v := range executors {
                wg.Add(1)
                go func(v executor.Executor) {
                        defer func() {
                                wg.Done()
                        }()
                        err := v.Execute(c.Logger, pos, d.trace, d.debug, nil, nil)
                        if err != nil {
                                lock.Lock()
                                c.addError(err)
                                lock.Unlock()
                        }
                }(v)
        }
        wg.Wait()
        
        return c
}

func del.Raw

Back

In /Users/kun/gobatis/gobatis/element.go:

func (d del) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {
        for _, v := range d.elems {
                switch vv := v.(type) {
                case *where:
                        if d.where != nil {
                                err = fmt.Errorf("batis.Where() should be invoked no more than once")
                                return
                        }
                        d.where = vv
                default:
                        err = fmt.Errorf("method db.Delete() accept elements use of batis.Where()")
                        return
                }
        }
        
        raw = &executor.Raw{}
        
        var sqls []string
        sqls = append(sqls, fmt.Sprintf("delete from %s", namer.TableName(strings.TrimSpace(d.table))))
        
        if d.where != nil {
                var r *executor.Raw
                r, err = d.where.Raw(namer, tag)
                if err != nil {
                        return
                }
                sqls = append(sqls, fmt.Sprintf("%s", r.SQL))
                raw.Params = append(raw.Params, r.Params...)
        }
        raw.SQL = strings.Join(sqls, space)
        
        return
}

func DB.Delete

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) Delete(table string, where Element) *DB {
        c := d.clone()
        raw, err := c.raw(del{table: table, elems: []Element{where}})
        if err != nil {
                c.addError(err)
                return c
        }
        c.executor = executor.NewDefault(c.conn(), raw)
        c.execute(nil)
        return c
}

func DB.Exec

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) Exec(sql string, params ...executor.Param) *DB {
        c := d.clone()
        raw, err := c.raw(exec{sql: sql, params: params})
        if err != nil {
                c.addError(err)
                return c
        }
        c.executor = executor.NewDefault(c.conn(), raw)
        c.execute(nil)
        return c
}

func DB.Query

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) Query(sql string, params ...executor.Param) *DB {
        c := d.clone()
        raw, err := c.raw(query{sql: sql, params: params})
        if err != nil {
                c.addError(err)
                return c
        }
        c.executor = executor.NewDefault(c.conn(), raw)
        return c
}

func DB.InsertBatch

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) InsertBatch(table string, batch int, data any, elems ...Element) *DB {
        c := d.clone()
        
        if batch <= 0 {
                c.addError(fmt.Errorf("expect batch > 0, got %d", batch))
                return c
        }
        
        if data == nil {
                c.addError(fmt.Errorf("data is nil"))
                return c
        }
        
        chunks, err := executor.SplitStructSlice(data, batch)
        if err != nil {
                c.addError(err)
                return c
        }
        
        var raws []*executor.Raw
        var q bool
        for _, v := range chunks {
                i := &insertBatch{
                        table: table,
                        batch: batch,
                        data:  v,
                        elems: elems,
                }
                var raw *executor.Raw
                raw, err = c.raw(i)
                if err != nil {
                        c.addError(err)
                        return c
                }
                if raw.Query {
                        q = true
                }
                raws = append(raws, raw)
        }
        
        c.setExecutor(executor.NewInsertBatch(c.context(), c.conn(), raws))
        if !q {
                c.execute(nil)
        }
        return c
}

func update.Raw

Back

In /Users/kun/gobatis/gobatis/element.go:

func (u update) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {
        for _, v := range u.elems {
                switch vv := v.(type) {
                case *where:
                        if u.where != nil {
                                err = fmt.Errorf("batis.Where() should be invoked no more than once")
                                return
                        }
                        u.where = vv
                case *returning:
                        if u.returning != nil {
                                err = fmt.Errorf("batis.Returning() should be invoked no more than once")
                                return
                        }
                        u.returning = vv
                default:
                        err = fmt.Errorf("method db.Update() accept elements use of batis.Where()")
                        return
                }
        }
        
        raw = &executor.Raw{
                Query: u.returning != nil,
        }
        
        var sqls []string
        sqls = append(sqls, fmt.Sprintf("update %s set", namer.TableName(u.table)))
        
        var sets []string
        for k := range u.data {
                sets = append(sets, fmt.Sprintf("%s=#{%s}", namer.ColumnName(k), k))
        }
        sqls = append(sqls, strings.Join(sets, ","))
        for k, v := range u.data {
                raw.Params = append(raw.Params, executor.Param{
                        Name:  k,
                        Value: v,
                })
        }
        if u.where != nil {
                var r *executor.Raw
                r, err = u.where.Raw(namer, tag)
                if err != nil {
                        return
                }
                sqls = append(sqls, fmt.Sprintf("%s", r.SQL))
                raw.Params = append(raw.Params, r.Params...)
        }
        raw.SQL = strings.Join(sqls, space)
        
        return
}

func insert.Raw

Back

In /Users/kun/gobatis/gobatis/element.go:

func (i insert) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {
        
        defer func() {
                if err != nil {
                        err = fmt.Errorf("build insert sql error: %w", err)
                }
        }()
        
        for _, v := range i.elems {
                switch vv := v.(type) {
                case *onConflict:
                        if i.onConflict != nil {
                                err = fmt.Errorf("batis.OnConflict() should be invoked no more than once")
                                return
                        }
                        i.onConflict = vv
                case *returning:
                        if i.returning != nil {
                                err = fmt.Errorf("batis.Returning() should be invoked no more than once")
                                return
                        }
                        i.returning = vv
                default:
                        err = fmt.Errorf("method db.Insert() accept elements use of batis.OnConflict() or batis.Returning()")
                        return
                }
        }
        raw = &executor.Raw{
                Query: i.returning != nil,
        }
        var rows []executor.Row
        switch vv := i.data.(type) {
        case Rows:
                rows, err = vv.Reflect(namer, tag)
                if err != nil {
                        return
                }
        default:
                rows, err = executor.ReflectRows(i.data, namer, tag)
                if err != nil {
                        return
                }
        }
        
        if l := len(rows); l != 1 {
                err = fmt.Errorf("expect 1 row, got: %d", l)
                return
        }
        
        var sqls []string
        
        sqls = append(sqls, fmt.Sprintf("insert into %s(%s) values(%s)",
                namer.TableName(i.table),
                strings.Join(executor.RowColumns(rows[0], namer), ","),
                strings.Join(executor.RowVars(rows[0]), ","),
        ))
        raw.Params = append(raw.Params, executor.RowParams(rows[0])...)
        
        if i.onConflict != nil {
                var r *executor.Raw
                r, err = i.onConflict.Raw(namer, tag)
                if err != nil {
                        return
                }
                sqls = append(sqls, r.SQL)
                raw.Params = append(raw.Params, r.Params...)
        }
        
        if i.returning != nil {
                var r *executor.Raw
                r, err = i.returning.Raw(namer, tag)
                if err != nil {
                        return
                }
                sqls = append(sqls, r.SQL)
                raw.Params = append(raw.Params, r.Params...)
        }
        
        raw.SQL = strings.Join(sqls, space)
        
        return
}

func DB.PagingQuery

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) PagingQuery(query PagingQuery) *DB {
        c := d.clone()
        queries, err := query.executors(d.Dialector.Namer(), "db")
        if err != nil {
                c.addError(err)
                return c
        }
        return c.ParallelQuery(queries...)
}

func DB.conn

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) conn() executor.Conn {
        if d.tx != nil {
                return d.tx
        } else {
                conn, err := d.db.Conn(d.context())
                if err != nil {
                        d.addError(err)
                }
                return executor.NewDB(conn, d.traceId)
        }
}

func DB.context

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) context() context.Context {
        if d.ctx == nil {
                return context.Background()
        }
        return d.ctx
}

func insertBatch.Raw

Back

In /Users/kun/gobatis/gobatis/element.go:

func (i insertBatch) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {
        
        defer func() {
                if err != nil {
                        err = fmt.Errorf("build insert batch sql error: %w", err)
                }
        }()
        
        for _, v := range i.elems {
                switch vv := v.(type) {
                case *onConflict:
                        if i.onConflict != nil {
                                err = fmt.Errorf("batis.OnConflict() should be invoked no more than once")
                                return
                        }
                        i.onConflict = vv
                case *returning:
                        if i.returning != nil {
                                err = fmt.Errorf("batis.Returning() should be invoked no more than once")
                                return
                        }
                        i.returning = vv
                default:
                        err = fmt.Errorf("method db.Insert() accept elements use of batis.OnConflict() or batis.Returning()")
                        return
                }
        }
        
        raw = &executor.Raw{
                Query: i.returning != nil,
        }
        
        var rows []executor.Row
        switch vv := i.data.(type) {
        case Rows:
                rows, err = vv.Reflect(namer, tag)
                if err != nil {
                        return
                }
        default:
                rows, err = executor.ReflectRows(i.data, namer, tag)
                if err != nil {
                        return
                }
        }
        
        if l := len(rows); l == 0 {
                err = fmt.Errorf("expect rows legnth > 0, got: %d", l)
                return
        }
        
        var sqls []string
        
        sqls = append(sqls, fmt.Sprintf("insert into %s(%s) values%s",
                namer.TableName(i.table),
                strings.Join(executor.RowColumns(rows[0], namer), ","),
                strings.Join(executor.RowsVars(rows), ","),
        ))
        raw.Params = append(raw.Params, executor.RowsParams(rows)...)
        
        if i.onConflict != nil {
                var r *executor.Raw
                r, err = i.onConflict.Raw(namer, tag)
                if err != nil {
                        return
                }
                sqls = append(sqls, r.SQL)
                r.Params = append(r.Params, r.Params...)
        }
        
        if i.returning != nil {
                var r *executor.Raw
                r, err = i.returning.Raw(namer, tag)
                if err != nil {
                        return
                }
                sqls = append(sqls, r.SQL)
                r.Params = append(r.Params, r.Params...)
        }
        
        raw.SQL = strings.Join(sqls, space)
        
        return
}

func @369:6

Back

In /Users/kun/gobatis/gobatis/db.go:

func(v executor.Executor) {
                        defer func() {
                                wg.Done()
                        }()
                        err := v.Execute(c.Logger, pos, d.trace, d.debug, nil, nil)
                        if err != nil {
                                lock.Lock()
                                c.addError(err)
                                lock.Unlock()
                        }
                }

func DB.setExecutor

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) setExecutor(e executor.Executor) {
        if d.executor != nil {
                d.addError(fmt.Errorf("executor duplicated"))
                return
        }
        d.executor = e
}

func @252:8

Back

In /Users/kun/gobatis/gobatis/element.go:

func() {
                if err != nil {
                        err = fmt.Errorf("build insert batch sql error: %w", err)
                }
        }

func @160:8

Back

In /Users/kun/gobatis/gobatis/element.go:

func() {
                if err != nil {
                        err = fmt.Errorf("build insert sql error: %w", err)
                }
        }

func DB.execute

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) execute(dest any) {
        if d.Error != nil {
                return
        }
        if d.executor == nil {
                d.addError(fmt.Errorf("no executor"))
                return
        }
        if d.executed.Swap(true) {
                d.addError(fmt.Errorf("repeat execution"))
                return
        }
        
        d.addError(d.executor.Execute(d.Logger, "", d.trace, d.debug, d.affect, func(s executor.Scanner) error {
                if d.executor.Query() {
                        e := s.Scan(dest)
                        if e != nil {
                                return e
                        }
                }
                d.rowsAffected = s.RowsAffected()
                d.lastInsertId = s.LastInsertId()
                return nil
        }))
}

func DB.Begin

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) Begin() *DB {
        c := d.clone()
        if c.tx != nil {
                c.addError(fmt.Errorf("there is already a transaction"))
                return c
        }
        
        defer func() {
                d.Logger.Trace("", c.traceId, true, d.Error, &executor.SQLTrace{
                        Trace:        d.trace,
                        Debug:        d.debug,
                        BeginAt:      time.Now(),
                        RawSQL:       "begin",
                        PlainSQL:     "begin",
                        RowsAffected: 0,
                })
        }()
        
        tx, err := c.db.Begin()
        if err != nil {
                c.addError(err)
                return c
        }
        
        if c.traceId == "" {
                c.traceId = fmt.Sprintf("%p", d)
        }
        
        c.tx = executor.NewTx(tx, c.traceId)
        
        return c
}

func UseDB

Back

In /Users/kun/gobatis/gobatis/db.go:

func UseDB(ctx context.Context) *DB {
        v := ctx.Value(dbKey)
        if v != nil {
                if vv, ok := v.(*DB); ok {
                        c := vv.clone()
                        c.ctx = ctx
                        return c
                }
        }
        return nil
}

func DB.Rollback

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) Rollback() *DB {
        if d.tx == nil {
                d.addError(executor.ErrInvalidTransaction)
                return d
        }
        defer func() {
                d.addError(d.tx.Close())
                d.Logger.Trace("", d.traceId, true, d.Error, &executor.SQLTrace{
                        Trace:        d.trace,
                        Debug:        d.debug,
                        BeginAt:      time.Now(),
                        RawSQL:       "rollback",
                        PlainSQL:     "rollback",
                        RowsAffected: 0,
                })
        }()
        d.addError(d.tx.Rollback())
        return d
}

func DB.Commit

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) Commit() *DB {
        if d.tx == nil {
                d.addError(executor.ErrInvalidTransaction)
                return d
        }
        
        defer func() {
                d.addError(d.tx.Close())
                d.Logger.Trace("", d.traceId, true, d.Error, &executor.SQLTrace{
                        Trace:        d.trace,
                        Debug:        d.debug,
                        BeginAt:      time.Now(),
                        RawSQL:       "commit",
                        PlainSQL:     "commit",
                        RowsAffected: 0,
                })
        }()
        
        d.addError(d.tx.Commit())
        return d
}

func DB.WithContext

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) WithContext(ctx context.Context) *DB {
        v := UseDB(ctx)
        if v != nil {
                return v
        }
        c := d.clone()
        c.ctx = ctx
        return c
}

func DB.WithTraceId

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) WithTraceId(traceId string) *DB {
        c := d.clone()
        if c.traceId != "" {
                d.addError(fmt.Errorf("set traceId  repeatedly"))
                return c
        }
        c.traceId = traceId
        return c
}

func selectColumns.Reflect

Back

In /Users/kun/gobatis/gobatis/rows.go:

func (s selectColumns) Reflect(namer dialector.Namer, tag string) (rows []executor.Row, err error) {
        rows, err = executor.ReflectRows(s.data, namer, tag)
        if err != nil {
                return
        }

        return
}

func DB.Trace

Back

In /Users/kun/gobatis/gobatis/db.go:

func (d *DB) Trace() *DB {
        c := d.clone()
        c.trace = true
        return c
}

func innerSQL.Raw

Back

In /Users/kun/gobatis/gobatis/element.go:

func (i innerSQL) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {
        raw = &executor.Raw{
                SQL:    i.sql,
                Params: i.params,
        }
        return
}

func @499:8

Back

In /Users/kun/gobatis/gobatis/db.go:

func() {
                d.addError(d.tx.Close())
                d.Logger.Trace("", d.traceId, true, d.Error, &executor.SQLTrace{
                        Trace:        d.trace,
                        Debug:        d.debug,
                        BeginAt:      time.Now(),
                        RawSQL:       "rollback",
                        PlainSQL:     "rollback",
                        RowsAffected: 0,
                })
        }

func @478:8

Back

In /Users/kun/gobatis/gobatis/db.go:

func() {
                d.addError(d.tx.Close())
                d.Logger.Trace("", d.traceId, true, d.Error, &executor.SQLTrace{
                        Trace:        d.trace,
                        Debug:        d.debug,
                        BeginAt:      time.Now(),
                        RawSQL:       "commit",
                        PlainSQL:     "commit",
                        RowsAffected: 0,
                })
        }

func DB.DB

Back

In /Users/kun/gobatis/gobatis/db.go:

144	`func (d DB) DB() sql.DB {`
145	`return d.db`
146	`}`

func WithDebug

Back

In /Users/kun/gobatis/gobatis/db.go:

33	`func WithDebug(parent context.Context, debug bool) context.Context {`
34	`return context.WithValue(parent, "debug", debug)`
35	`}`

func fetch.Raw

Back

In /Users/kun/gobatis/gobatis/element.go:

338	`func (f fetch) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {`
339	`//TODO implement me`
340	`panic("implement me")`
341	`}`

func Config.Apply

Back

In /Users/kun/gobatis/gobatis/config.go:

28	`func (c Config) Apply(config *Config) error {`
29	`//TODO implement me`
30	`panic("implement me")`
31	`}`

func @446:8

Back

In /Users/kun/gobatis/gobatis/db.go:

func() {
                d.Logger.Trace("", c.traceId, true, d.Error, &executor.SQLTrace{
                        Trace:        d.trace,
                        Debug:        d.debug,
                        BeginAt:      time.Now(),
                        RawSQL:       "begin",
                        PlainSQL:     "begin",
                        RowsAffected: 0,
                })
        }

func newInnerSQL

Back

In /Users/kun/gobatis/gobatis/element.go:

30	`func newInnerSQL(sql string, params ...executor.Param) innerSQL {`
31	`return innerSQL{sql: sql, params: params}`
32	`}`

func build.Raw

Back

In /Users/kun/gobatis/gobatis/element.go:

414	`func (b build) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {`
415	`panic("todo")`
416	`}`

func @53:12

Back

In /Users/kun/gobatis/gobatis/db.go:

53	`func() time.Time {`
54	`return time.Now()`
55	`}`

func DB.LastInsertId

Back

In /Users/kun/gobatis/gobatis/db.go:

396	`func (d *DB) LastInsertId() (int64, error) {`
397	`return d.lastInsertId, d.Error`
398	`}`

func DB.AssociateQuery

Back

In /Users/kun/gobatis/gobatis/db.go:

404	`func (d *DB) AssociateQuery(query AssociateQuery) error {`
405	`return nil`
406	`}`

func LooseDest

Back

In /Users/kun/gobatis/gobatis/param.go:

15	`func LooseDest(dest any, fields ...string) Dest {`
16	`return Dest{loose: true, dest: dest, fields: fields}`
17	`}`

func WithTraceId

Back

In /Users/kun/gobatis/gobatis/db.go:

29	`func WithTraceId(parent context.Context, traceId string) context.Context {`
30	`return context.WithValue(parent, traceIdKey, traceId)`
31	`}`

func WithTx

Back

In /Users/kun/gobatis/gobatis/db.go:

25	`func WithTx(parent context.Context, tx *sql.Tx) context.Context {`
26	`return context.WithValue(parent, dbKey, tx)`
27	`}`

func Config.AfterInitialize

Back

In /Users/kun/gobatis/gobatis/config.go:

33	`func (c Config) AfterInitialize(db *DB) error {`
34	`//TODO implement me`
35	`panic("implement me")`
36	`}`

func AssociateLink

Back

In /Users/kun/gobatis/gobatis/queryer.go:

113	`func AssociateLink(dest any, condition, inject string) any {`
114	`return nil`
115	`}`

func Select

Back

In /Users/kun/gobatis/gobatis/rows.go:

func Select(data any, columns string) Rows {
        return &selectColumns{
                columns: columns,
                data:    data,
        }
}

func Except

Back

In /Users/kun/gobatis/gobatis/rows.go:

func Except(data any, columns string) Rows {
        return &exceptColumns{
                data:    data,
                columns: columns,
        }
}

func DB.Stats

Back

In /Users/kun/gobatis/gobatis/db.go:

152	`func (d *DB) Stats() sql.DBStats {`
153	`return d.db.Stats()`
154	`}`

func exceptColumns.Reflect

Back

In /Users/kun/gobatis/gobatis/rows.go:

48	`func (e exceptColumns) Reflect(namer dialector.Namer, tag string) (rows []executor.Row, err error) {`
49	`//TODO implement me`
50	`panic("implement me")`
51	`}`

Package Overview: github.com/gobatis/gobatis/cast 47.0%

Please select a function to see what's left for testing.

`ToStringE(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`100.0%`	`26/26`
`ToTimeE(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`100.0%`	`11/11`
`Indirect(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`100.0%`	`8/8`
`indirectToStringerOrError(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`100.0%`	`8/8`
`AddUint64E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`100.0%`	`8/8`
`MulUint64E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`100.0%`	`8/8`
`BigAddUint64(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`100.0%`	`6/6`
`BigMulUint64(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`100.0%`	`6/6`
`MulInt64E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`100.0%`	`6/6`
`SubInt64E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`100.0%`	`6/6`
`AddInt64E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`100.0%`	`6/6`
`parseDateWith(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`100.0%`	`4/4`
`DivInt64E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`100.0%`	`4/4`
`DivUint64E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`100.0%`	`4/4`
`BigAddInt64(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`100.0%`	`2/2`
`BigMulInt64(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`100.0%`	`2/2`
`BigSubInt64(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`100.0%`	`2/2`
`castOverFlowError(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`100.0%`	`1/1`
`resultOverFlowError(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`100.0%`	`1/1`
`StringToDate(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`100.0%`	`1/1`
`SubUint64E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`100.0%`	`1/1`
`ToUint64E(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`95.3%`	`41/43`
`ToInt64E(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`90.9%`	`30/33`
`ToUintE(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`90.7%`	`49/54`
`ToUint32E(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`90.0%`	`54/60`
`ToUint16E(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`87.1%`	`61/70`
`ToInt32E(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`86.4%`	`38/44`
`ToUint8E(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`85.5%`	`65/76`
`IsNil(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`83.3%`	`5/6`
`ToInt16E(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`82.8%`	`48/58`
`ToIntE(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`82.7%`	`43/52`
`ToInt8E(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`81.2%`	`52/64`
`ToDecimalE(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`66.7%`	`6/9`
`DivInt32E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`62.5%`	`5/8`
`SubInt8E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`62.5%`	`5/8`
`MulIntE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`62.5%`	`5/8`
`DivIntE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`62.5%`	`5/8`
`MulInt16E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`62.5%`	`5/8`
`AddIntE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`62.5%`	`5/8`
`ToBinOperandE(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`57.7%`	`15/26`
`DivAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`37.5%`	`6/16`
`MulAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`31.2%`	`5/16`
`AddAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`29.4%`	`5/17`
`SubAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`25.0%`	`4/16`
`ToBoolE(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`0.0%`	`0/37`
`ToFloat32E(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`0.0%`	`0/23`
`ToFloat64E(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`0.0%`	`0/22`
`ToReflectTypeE(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`0.0%`	`0/20`
`NotEqualAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/19`
`EqualAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/19`
`UnaryMinusAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/19`
`UnaryPlusAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/18`
`GreaterAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/17`
`LessOrEqualAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/17`
`LessAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/17`
`GreaterOrEqualAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/17`
`BitClearAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/15`
`LeftShiftAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/15`
`RightShiftAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/15`
`ModAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/15`
`CaretAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/15`
`OrAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/15`
`AndAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/15`
`UnaryCaretAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/13`
`DivUint16E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`AddInt32E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`MulUint32E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`SubUint32E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`AddUint32E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`MulUint16E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`SubUint16E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`AddUint16E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`DivUint8E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`MulUint8E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`SubUint8E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`AddUint8E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`DivUintE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`SubIntE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`AddInt8E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`MulInt8E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`MulUintE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`SubUintE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`AddUintE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`MulInt32E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`SubInt32E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`DivUint32E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`DivInt16E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`SubInt16E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`AddInt16E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`DivInt8E(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/8`
`LogicAndAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/7`
`LogicOrAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/7`
`BigDivUint64(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/6`
`BigSubUint64(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/6`
`UnaryNotAnyE(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/4`
`Value.Add(...)`	`github.com/gobatis/gobatis/cast/value.go`	`0.0%`	`0/2`
`jsonStringToObject(...)`	`github.com/gobatis/gobatis/cast/caste.go`	`0.0%`	`0/2`
`BigDivInt64(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/2`
`MulFloat32(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/1`
`SubFloat64(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/1`
`AddFloat64(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/1`
`MulFloat64(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/1`
`DivFloat64(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/1`
`AddFloat32(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/1`
`SubFloat32(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/1`
`DivFloat32(...)`	`github.com/gobatis/gobatis/cast/calc.go`	`0.0%`	`0/1`

func ToStringE

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func ToStringE(i interface{}) (string, error) {
        i = indirectToStringerOrError(i)
        
        switch s := i.(type) {
        case string:
                return s, nil
        case bool:
                return strconv.FormatBool(s), nil
        case float64:
                return strconv.FormatFloat(s, 'f', -1, 64), nil
        case float32:
                return strconv.FormatFloat(float64(s), 'f', -1, 32), nil
        case int:
                return strconv.Itoa(s), nil
        case int64:
                return strconv.FormatInt(s, 10), nil
        case int32:
                return strconv.Itoa(int(s)), nil
        case int16:
                return strconv.FormatInt(int64(s), 10), nil
        case int8:
                return strconv.FormatInt(int64(s), 10), nil
        case uint:
                return strconv.FormatUint(uint64(s), 10), nil
        case uint64:
                return strconv.FormatUint(uint64(s), 10), nil
        case uint32:
                return strconv.FormatUint(uint64(s), 10), nil
        case uint16:
                return strconv.FormatUint(uint64(s), 10), nil
        case uint8:
                return strconv.FormatUint(uint64(s), 10), nil
        case []byte:
                return string(s), nil
        case template.HTML:
                return string(s), nil
        case template.URL:
                return string(s), nil
        case template.JS:
                return string(s), nil
        case template.CSS:
                return string(s), nil
        case template.HTMLAttr:
                return string(s), nil
        case nil:
                return "", nil
        case fmt.Stringer:
                return s.String(), nil
        case error:
                return s.Error(), nil
        default:
                return "", fmt.Errorf("unable to cast %#v of type %T to string", i, i)
        }
}

func ToTimeE

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func ToTimeE(i interface{}) (time.Time, error) {
        i = Indirect(i)
        
        switch v := i.(type) {
        case time.Time:
                return v, nil
        case string:
                return StringToDate(v)
        case int:
                return time.Unix(int64(v), 0), nil
        case int64:
                return time.Unix(v, 0), nil
        case int32:
                return time.Unix(int64(v), 0), nil
        case uint:
                return time.Unix(int64(v), 0), nil
        case uint64:
                return time.Unix(int64(v), 0), nil
        case uint32:
                return time.Unix(int64(v), 0), nil
        default:
                return time.Time{}, fmt.Errorf("unable to cast %#v of type %T to Time", i, i)
        }
}

func Indirect

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func Indirect(a interface{}) interface{} {
        if a == nil {
                return nil
        }
        if t := reflect.TypeOf(a); t.Kind() != reflect.Ptr {
                // Avoid creating a reflect.Value if it's not a pointer.
                return a
        }
        v := reflect.ValueOf(a)
        for v.Kind() == reflect.Ptr && !v.IsNil() {
                v = v.Elem()
        }
        return v.Interface()
}

func indirectToStringerOrError

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func indirectToStringerOrError(a interface{}) interface{} {
        if a == nil {
                return nil
        }
        
        var errorType = reflect.TypeOf((*error)(nil)).Elem()
        var fmtStringerType = reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
        
        v := reflect.ValueOf(a)
        for !v.Type().Implements(fmtStringerType) && !v.Type().Implements(errorType) && v.Kind() == reflect.Ptr && !v.IsNil() {
                v = v.Elem()
        }
        return v.Interface()
}

func AddUint64E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func AddUint64E(a, b uint64) (r uint64, err error) {
        r = a + b
        br := BigAddUint64(a, b)
        rr := &big.Int{}
        rr.SetUint64(r)
        if rr.Cmp(br) != 0 {
                err = resultOverFlowError("uint64")
                return
        }
        return
}

func MulUint64E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func MulUint64E(a, b uint64) (r uint64, err error) {
        r = a * b
        br := BigMulUint64(a, b)
        rr := &big.Int{}
        rr.SetUint64(r)
        if rr.Cmp(br) != 0 {
                err = resultOverFlowError("uint64")
                return
        }
        return
}

func BigAddUint64

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func BigAddUint64(a, b uint64) *big.Int {
        r := big.NewInt(0)
        ba := &big.Int{}
        ba.SetUint64(a)
        bb := &big.Int{}
        bb.SetUint64(b)
        return r.Add(ba, bb)
}

func BigMulUint64

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func BigMulUint64(a, b uint64) *big.Int {
        r := big.NewInt(0)
        ba := &big.Int{}
        ba.SetUint64(a)
        bb := &big.Int{}
        bb.SetUint64(b)
        return r.Mul(ba, bb)
}

func MulInt64E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func MulInt64E(a, b int64) (r int64, err error) {
        r = a * b
        br := BigMulInt64(a, b)
        if big.NewInt(r).Cmp(br) != 0 {
                err = resultOverFlowError("int64")
                return
        }
        return
}

func SubInt64E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func SubInt64E(a, b int64) (r int64, err error) {
        r = a - b
        br := BigSubInt64(a, b)
        if big.NewInt(r).Cmp(br) != 0 {
                err = resultOverFlowError("int64")
                return
        }
        return
}

func AddInt64E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func AddInt64E(a, b int64) (r int64, err error) {
        r = a + b
        br := BigAddInt64(a, b)
        if big.NewInt(r).Cmp(br) != 0 {
                err = resultOverFlowError("int64")
                return
        }
        return
}

func parseDateWith

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func parseDateWith(s string, dates []string) (d time.Time, e error) {
        for _, dateType := range dates {
                if d, e = time.Parse(dateType, s); e == nil {
                        return
                }
        }
        return d, fmt.Errorf("unable to parse date: %s", s)
}

func DivInt64E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func DivInt64E(a, b int64) (r int64, err error) {
        if b == 0 {
                err = fmt.Errorf("divide 0")
                return
        }
        //br := BigDivInt64(a, b)
        //if big.NewInt(r).Cmp(br) != 0 {
        //        err = resultOverFlowError("int64")
        //        return
        //}
        return a / b, nil
}

func DivUint64E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func DivUint64E(a, b uint64) (r uint64, err error) {
        if b == 0 {
                err = fmt.Errorf("divide 0")
                return
        }
        //r = a / b
        //br := BigDivUint64(a, b)
        //rr := &big.Int{}
        //rr.SetUint64(r)
        //if rr.Cmp(br) != 0 {
        //        err = resultOverFlowError("uint64")
        //        return
        //}
        return a / b, nil
}

func BigAddInt64

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

16	`func BigAddInt64(a, b int64) *big.Int {`
17	`r := big.NewInt(0)`
18	`return r.Add(big.NewInt(a), big.NewInt(b))`
19	`}`

func BigMulInt64

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

26	`func BigMulInt64(a, b int64) *big.Int {`
27	`r := big.NewInt(0)`
28	`return r.Mul(big.NewInt(a), big.NewInt(b))`
29	`}`

func BigSubInt64

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

21	`func BigSubInt64(a, b int64) *big.Int {`
22	`r := big.NewInt(0)`
23	`return r.Sub(big.NewInt(a), big.NewInt(b))`
24	`}`

func castOverFlowError

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

24	`func castOverFlowError(from, to string) error {`
25	`return fmt.Errorf("result overflow type from %s to %s", from, to)`
26	`}`

func resultOverFlowError

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

12	`func resultOverFlowError(t string) error {`
13	`return fmt.Errorf("result overflow type %s", t)`
14	`}`

func StringToDate

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func StringToDate(s string) (time.Time, error) {
        return parseDateWith(s, []string{
                time.RFC3339,
                "2006-01-02T15:04:05", // iso8601 without timezone
                time.RFC1123Z,
                time.RFC1123,
                time.RFC822Z,
                time.RFC822,
                time.RFC850,
                time.ANSIC,
                time.UnixDate,
                time.RubyDate,
                "2006-01-02 15:04:05.999999999 -0700 MST", // Time.String()
                "2006-01-02",
                "02 Jan 2006",
                "2006-01-02T15:04:05-0700", // RFC3339 without timezone hh:mm colon
                "2006-01-02 15:04:05 -07:00",
                "2006-01-02 15:04:05 -0700",
                "2006-01-02 15:04:05Z07:00", // RFC3339 without T
                "2006-01-02 15:04:05Z0700",  // RFC3339 without T or timezone hh:mm colon
                "2006-01-02 15:04:05",
                time.Kitchen,
                time.Stamp,
                time.StampMilli,
                time.StampMicro,
                time.StampNano,
                "15:04:05",    // time without T
                "15:04:05+00", // TODO test time with T
        })
}

func SubUint64E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func SubUint64E(a, b uint64) (r uint64, err error) {
        //r = a - b
        //br := BigSubUint64(a, b)
        //rr := &big.Int{}
        //rr.SetUint64(r)
        //if rr.Cmp(br) != 0 {
        //        err = resultOverFlowError("uint64")
        //        return
        //}
        return a - b, nil
}

func ToUint64E

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func ToUint64E(i interface{}) (uint64, error) {
        i = Indirect(i)
        
        switch s := i.(type) {
        case string:
                v, err := strconv.ParseUint(s, 0, 64)
                if err != nil {
                        return 0, fmt.Errorf("unable to cast %#v to uint64: %s", i, err)
                }
                d, err := decimal.NewFromString(s)
                if err != nil {
                        return 0, err
                }
                q, _ := decimal.NewFromString(s)
                if !d.Equal(q) {
                        return 0, castOverFlowError("string", "uint64")
                }
                return v, nil
        case int:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                return uint64(s), nil
        case int64:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                return uint64(s), nil
        case int32:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                return uint64(s), nil
        case int16:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                return uint64(s), nil
        case int8:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                return uint64(s), nil
        case uint:
                return uint64(s), nil
        case uint64:
                return s, nil
        case uint32:
                return uint64(s), nil
        case uint16:
                return uint64(s), nil
        case uint8:
                return uint64(s), nil
        case float32:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                return uint64(s), nil
        case float64:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                return uint64(s), nil
        case bool:
                if s {
                        return 1, nil
                }
                return 0, nil
        case nil:
                return 0, nil
        default:
                return 0, fmt.Errorf("unable to cast %#v of type %T to uint64", i, i)
        }
}

func ToInt64E

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func ToInt64E(i interface{}) (int64, error) {
        i = Indirect(i)
        
        switch s := i.(type) {
        case int:
                return int64(s), nil
        case int64:
                return s, nil
        case int32:
                return int64(s), nil
        case int16:
                return int64(s), nil
        case int8:
                return int64(s), nil
        case uint:
                return int64(s), nil
        case uint64:
                a := big.Int{}
                a.SetUint64(s)
                b := big.NewInt(math.MaxInt64)
                if a.Cmp(b) > 1 {
                        return 0, castOverFlowError("uint64", "int64")
                }
                return int64(s), nil
        case uint32:
                return int64(s), nil
        case uint16:
                return int64(s), nil
        case uint8:
                return int64(s), nil
        case float64:
                return int64(s), nil
        case float32:
                return int64(s), nil
        case string:
                v, err := strconv.ParseInt(s, 0, 0)
                if err != nil {
                        return 0, fmt.Errorf("unable to cast %#v of type %T to int64", i, i)
                        
                }
                a, err := decimal.NewFromString(s)
                if err != nil {
                        return 0, err
                }
                if !a.Equal(decimal.NewFromInt(v)) {
                        return 0, castOverFlowError("string", "int64")
                }
                return v, nil
        case bool:
                if s {
                        return 1, nil
                }
                return 0, nil
        case nil:
                return 0, nil
        default:
                return 0, fmt.Errorf("unable to cast %#v of type %T to int64", i, i)
        }
}

func ToUintE

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func ToUintE(i interface{}) (uint, error) {
        i = Indirect(i)
        
        switch s := i.(type) {
        case string:
                v, err := strconv.ParseUint(s, 0, 0)
                if err != nil {
                        return 0, fmt.Errorf("unable to cast %#v to uint: %s", i, err)
                }
                d, err := decimal.NewFromString(s)
                if err != nil {
                        return 0, err
                }
                r := uint(v)
                q, _ := decimal.NewFromString(fmt.Sprintf("%d", r))
                if !d.Equal(q) {
                        return 0, castOverFlowError("string", "uint")
                }
                return r, nil
        case int:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                return uint(s), nil
        case int64:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                r := uint(s)
                if int64(r) != s {
                        return 0, castOverFlowError("int64", "uint")
                }
                return r, nil
        case int32:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                return uint(s), nil
        case int16:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                return uint(s), nil
        case int8:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                return uint(s), nil
        case uint:
                return s, nil
        case uint64:
                r := uint(s)
                if uint64(r) != s {
                        return 0, castOverFlowError("uint64", "uint")
                }
                return r, nil
        case uint32:
                return uint(s), nil
        case uint16:
                return uint(s), nil
        case uint8:
                return uint(s), nil
        case float64:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                u := int64(s)
                r := uint(s)
                if int64(r) != u {
                        return 0, castOverFlowError("float64", "uint")
                }
                return r, nil
        case float32:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                return uint(s), nil
        case bool:
                if s {
                        return 1, nil
                }
                return 0, nil
        case nil:
                return 0, nil
        default:
                return 0, fmt.Errorf("unable to cast %#v of type %T to uint", i, i)
        }
}

func ToUint32E

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func ToUint32E(i interface{}) (uint32, error) {
        i = Indirect(i)
        
        switch s := i.(type) {
        case string:
                v, err := strconv.ParseUint(s, 0, 32)
                if err != nil {
                        return 0, fmt.Errorf("unable to cast %#v to uint32: %s", i, err)
                }
                d, err := decimal.NewFromString(s)
                if err != nil {
                        return 0, err
                }
                r := uint32(v)
                q, _ := decimal.NewFromString(fmt.Sprintf("%d", r))
                if !d.Equal(q) {
                        return 0, castOverFlowError("string", "uint32")
                }
                return r, nil
        case int:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                r := uint32(s)
                if int(r) != s {
                        return 0, castOverFlowError("int", "uint32")
                }
                return r, nil
        case int64:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                r := uint32(s)
                if int64(r) != s {
                        return 0, castOverFlowError("int64", "uint32")
                }
                return r, nil
        case int32:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                return uint32(s), nil
        case int16:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                return uint32(s), nil
        case int8:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                return uint32(s), nil
        case uint:
                r := uint32(s)
                if uint(r) != s {
                        return 0, castOverFlowError("uint", "uint32")
                }
                return r, nil
        case uint64:
                r := uint32(s)
                if uint64(r) != s {
                        return 0, castOverFlowError("uint", "uint32")
                }
                return r, nil
        case uint32:
                return s, nil
        case uint16:
                return uint32(s), nil
        case uint8:
                return uint32(s), nil
        case float64:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                u := int64(s)
                r := uint32(s)
                if int64(r) != u {
                        return 0, castOverFlowError("float64", "uint32")
                }
                return r, nil
        case float32:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                return uint32(s), nil
        case bool:
                if s {
                        return 1, nil
                }
                return 0, nil
        case nil:
                return 0, nil
        default:
                return 0, fmt.Errorf("unable to cast %#v of type %T to uint32", i, i)
        }
}

func ToUint16E

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func ToUint16E(i interface{}) (uint16, error) {
        i = Indirect(i)
        
        switch s := i.(type) {
        case string:
                v, err := strconv.ParseUint(s, 0, 16)
                if err != nil {
                        return 0, fmt.Errorf("unable to cast %#v to uint16: %s", i, err)
                }
                d, err := decimal.NewFromString(s)
                if err != nil {
                        return 0, err
                }
                r := uint16(v)
                q, _ := decimal.NewFromString(fmt.Sprintf("%d", r))
                if !d.Equal(q) {
                        return 0, castOverFlowError("string", "uint16")
                }
                return r, nil
        case int:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                r := uint16(s)
                if int(r) != s {
                        return 0, castOverFlowError("int", "uint16")
                }
                return r, nil
        case int64:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                r := uint16(s)
                if int64(r) != s {
                        return 0, castOverFlowError("int64", "uint16")
                }
                return r, nil
        case int32:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                r := uint16(s)
                if int32(r) != s {
                        return 0, castOverFlowError("int32", "uint16")
                }
                return r, nil
        case int16:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                return uint16(s), nil
        case int8:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                return uint16(s), nil
        case uint:
                r := uint16(s)
                if uint(r) != s {
                        return 0, castOverFlowError("uint", "uint16")
                }
                return r, nil
        case uint64:
                r := uint16(s)
                if uint64(r) != s {
                        return 0, castOverFlowError("uint64", "uint16")
                }
                return r, nil
        case uint32:
                r := uint16(s)
                if uint32(r) != s {
                        return 0, castOverFlowError("uint32", "uint16")
                }
                return r, nil
        case uint16:
                return s, nil
        case uint8:
                return uint16(s), nil
        case float64:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                u := int64(s)
                r := uint16(s)
                if int64(r) != u {
                        return 0, castOverFlowError("float64", "uint16")
                }
                return r, nil
        case float32:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                u := int32(s)
                r := uint16(s)
                if int32(r) != u {
                        return 0, castOverFlowError("float32", "uint16")
                }
                return r, nil
        case bool:
                if s {
                        return 1, nil
                }
                return 0, nil
        case nil:
                return 0, nil
        default:
                return 0, fmt.Errorf("unable to cast %#v of type %T to uint16", i, i)
        }
}

func ToInt32E

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func ToInt32E(i interface{}) (int32, error) {
        i = Indirect(i)
        
        switch s := i.(type) {
        case int:
                r := int32(s)
                if int(r) != s {
                        return 0, castOverFlowError("int", "int32")
                }
                return r, nil
        case int64:
                r := int32(s)
                if int64(r) != s {
                        return 0, castOverFlowError("int64", "int32")
                }
                return r, nil
        case int32:
                return s, nil
        case int16:
                return int32(s), nil
        case int8:
                return int32(s), nil
        case uint:
                r := int32(s)
                if uint(r) != s {
                        return 0, castOverFlowError("uint", "int32")
                }
                return r, nil
        case uint64:
                r := int32(s)
                if uint64(r) != s {
                        return 0, castOverFlowError("uint64", "int32")
                }
                return r, nil
        case uint32:
                r := int32(s)
                if uint32(r) != s {
                        return 0, castOverFlowError("uint32", "int32")
                }
                return r, nil
        case uint16:
                return int32(s), nil
        case uint8:
                return int32(s), nil
        case float64:
                return int32(s), nil
        case float32:
                return int32(s), nil
        case string:
                v, err := strconv.ParseInt(s, 0, 0)
                if err != nil {
                        return 0, fmt.Errorf("unable to cast %#v of type %T to int32", i, i)
                }
                r := int32(v)
                d, err := decimal.NewFromString(s)
                if err != nil {
                        return 0, err
                }
                if !d.Equal(decimal.NewFromInt32(r)) {
                        return 0, castOverFlowError("string", "32")
                }
                return r, nil
        case bool:
                if s {
                        return 1, nil
                }
                return 0, nil
        case nil:
                return 0, nil
        default:
                return 0, fmt.Errorf("unable to cast %#v of type %T to int32", i, i)
        }
}

func ToUint8E

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func ToUint8E(i interface{}) (uint8, error) {
        i = Indirect(i)
        
        switch s := i.(type) {
        case string:
                v, err := strconv.ParseUint(s, 0, 8)
                if err != nil {
                        return 0, fmt.Errorf("unable to cast %#v to uint8: %s", i, err)
                }
                d, err := decimal.NewFromString(s)
                if err != nil {
                        return 0, err
                }
                r := uint8(v)
                q, _ := decimal.NewFromString(fmt.Sprintf("%d", r))
                if !d.Equal(q) {
                        return 0, castOverFlowError("string", "uint8")
                }
                return r, nil
        case int:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                r := uint8(s)
                if int(r) != s {
                        return 0, castOverFlowError("int", "uint8")
                }
                return r, nil
        case int64:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                r := uint8(s)
                if int64(r) != s {
                        return 0, castOverFlowError("int64", "uint8")
                }
                return r, nil
        case int32:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                r := uint8(s)
                if int32(r) != s {
                        return 0, castOverFlowError("int32", "uint8")
                }
                return r, nil
        case int16:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                r := uint8(s)
                if int16(r) != s {
                        return 0, castOverFlowError("int16", "uint8")
                }
                return r, nil
        case int8:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                return uint8(s), nil
        case uint:
                r := uint8(s)
                if uint(r) != s {
                        return 0, castOverFlowError("uint", "uint8")
                }
                return r, nil
        case uint64:
                r := uint8(s)
                if uint64(r) != s {
                        return 0, castOverFlowError("uint64", "uint8")
                }
                return r, nil
        case uint32:
                r := uint8(s)
                if uint32(r) != s {
                        return 0, castOverFlowError("uint32", "uint8")
                }
                return r, nil
        case uint16:
                r := uint8(s)
                if uint16(r) != s {
                        return 0, castOverFlowError("uint16", "uint8")
                }
                return r, nil
        case uint8:
                return s, nil
        case float64:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                u := int64(s)
                r := uint8(s)
                if int64(r) != u {
                        return 0, castOverFlowError("float64", "uint8")
                }
                return r, nil
        case float32:
                if s < 0 {
                        return 0, errNegativeNotAllowed
                }
                u := int32(s)
                r := uint8(s)
                if int32(r) != u {
                        return 0, castOverFlowError("float32", "uint8")
                }
                return r, nil
        case bool:
                if s {
                        return 1, nil
                }
                return 0, nil
        case nil:
                return 0, nil
        default:
                return 0, fmt.Errorf("unable to cast %#v of type %T to uint8", i, i)
        }
}

func IsNil

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func IsNil(val interface{}) bool {
        if val == nil {
                return true
        }
        rv := reflect.ValueOf(val)
        switch rv.Kind() {
        case reflect.Ptr, reflect.Func, reflect.Map, reflect.Slice, reflect.Interface:
                return rv.IsNil()
        }
        return false
}

func ToInt16E

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func ToInt16E(i interface{}) (int16, error) {
        i = Indirect(i)
        switch s := i.(type) {
        case int:
                r := int16(s)
                if int(r) != s {
                        return 0, castOverFlowError("int", "int16")
                }
                return r, nil
        case int64:
                r := int16(s)
                if int64(r) != s {
                        return 0, castOverFlowError("int64", "int16")
                }
                return r, nil
        case int32:
                r := int16(s)
                if int32(r) != s {
                        return 0, castOverFlowError("int32", "int16")
                }
                return r, nil
        case int16:
                return s, nil
        case int8:
                return int16(s), nil
        case uint:
                r := int16(s)
                if uint(r) != s {
                        return 0, castOverFlowError("uint", "int16")
                }
                return int16(s), nil
        case uint64:
                r := int16(s)
                if uint64(r) != s {
                        return 0, castOverFlowError("uint64", "int16")
                }
                return r, nil
        case uint32:
                r := int16(s)
                if uint32(r) != s {
                        return 0, castOverFlowError("uint32", "int16")
                }
                return r, nil
        case uint16:
                r := int16(s)
                if uint16(r) != s {
                        return 0, castOverFlowError("uint64", "int16")
                }
                return r, nil
        case uint8:
                return int16(s), nil
        case float64:
                u := int64(s)
                r := int16(s)
                if int64(r) != u {
                        return 0, castOverFlowError("float64", "int16")
                }
                return r, nil
        case float32:
                u := int32(s)
                r := int16(s)
                if int32(r) != u {
                        return 0, castOverFlowError("float32", "int16")
                }
                return r, nil
        case string:
                v, err := strconv.ParseInt(s, 0, 0)
                if err != nil {
                        return 0, fmt.Errorf("unable to cast %#v of type %T to int16", i, i)
                }
                r := int16(v)
                d, err := decimal.NewFromString(s)
                if err != nil {
                        return 0, err
                }
                if !d.Equal(decimal.NewFromInt32(int32(r))) {
                        return 0, castOverFlowError("string", "int16")
                }
                return r, nil
        case bool:
                if s {
                        return 1, nil
                }
                return 0, nil
        case nil:
                return 0, nil
        default:
                return 0, fmt.Errorf("unable to cast %#v of type %T to int16", i, i)
        }
}

func ToIntE

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func ToIntE(i interface{}) (int, error) {
        i = Indirect(i)
        
        switch s := i.(type) {
        case int:
                return s, nil
        case int64:
                r := int(s)
                if int64(r) != s {
                        return 0, castOverFlowError("int64", "int")
                }
                return r, nil
        case int32:
                r := int(s)
                if int32(r) != s {
                        return 0, castOverFlowError("int64", "int")
                }
                return r, nil
        case int16:
                return int(s), nil
        case int8:
                return int(s), nil
        case uint:
                r := int(s)
                if uint(r) != s {
                        return 0, castOverFlowError("uint", "int")
                }
                return r, nil
        case uint64:
                r := int(s)
                if uint64(r) != s {
                        return 0, castOverFlowError("uint64", "int")
                }
                return r, nil
        case uint32:
                r := int(s)
                if uint32(r) != s {
                        return 0, castOverFlowError("uint32", "int")
                }
                return r, nil
        case uint16:
                return int(s), nil
        case uint8:
                return int(s), nil
        case float64:
                u := int64(s)
                r := int(s)
                if int64(r) != u {
                        return 0, castOverFlowError("float64", "int")
                }
                return r, nil
        case float32:
                u := int32(s)
                r := int(s)
                if int32(r) != u {
                        return 0, castOverFlowError("float32", "int8")
                }
                return r, nil
        case string:
                v, err := strconv.ParseInt(s, 0, 0)
                if err != nil {
                        return 0, fmt.Errorf("unable to cast %#v of type %T to int", i, i)
                }
                r := int(v)
                d, err := decimal.NewFromString(s)
                if err != nil {
                        return 0, err
                }
                if !d.Equal(decimal.NewFromInt(int64(r))) {
                        return 0, castOverFlowError("string", "int")
                }
                return r, nil
        case bool:
                if s {
                        return 1, nil
                }
                return 0, nil
        case nil:
                return 0, nil
        default:
                return 0, fmt.Errorf("unable to cast %#v of type %T to int", i, i)
        }
}

func ToInt8E

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func ToInt8E(i interface{}) (int8, error) {
        i = Indirect(i)
        
        switch s := i.(type) {
        case int:
                r := int8(s)
                if int(r) != s {
                        return 0, castOverFlowError("int", "int8")
                }
                return r, nil
        case int64:
                r := int8(s)
                if int64(r) != s {
                        return 0, castOverFlowError("int64", "int8")
                }
                return r, nil
        case int32:
                r := int8(s)
                if int32(r) != s {
                        return 0, castOverFlowError("int32", "int8")
                }
                return r, nil
        case int16:
                r := int8(s)
                if int16(r) != s {
                        return 0, castOverFlowError("int16", "int8")
                }
                return r, nil
        case int8:
                return s, nil
        case uint:
                r := int8(s)
                if uint(r) != s {
                        return 0, castOverFlowError("uint", "int8")
                }
                return r, nil
        case uint64:
                r := int8(s)
                if uint64(r) != s {
                        return 0, castOverFlowError("uint64", "int8")
                }
                return r, nil
        case uint32:
                r := int8(s)
                if uint32(r) != s {
                        return 0, castOverFlowError("uint32", "int8")
                }
                return r, nil
        case uint16:
                r := int8(s)
                if uint16(r) != s {
                        return 0, castOverFlowError("uint16", "int8")
                }
                return r, nil
        case uint8:
                r := int8(s)
                if uint8(r) != s {
                        return 0, castOverFlowError("uint8", "int8")
                }
                return r, nil
        case float64:
                u := int64(s)
                r := int8(s)
                if int64(r) != u {
                        return 0, castOverFlowError("float64", "int8")
                }
                return r, nil
        case float32:
                u := int32(s)
                r := int8(s)
                if int32(r) != u {
                        return 0, castOverFlowError("float32", "int8")
                }
                return r, nil
        case string:
                v, err := strconv.ParseInt(s, 0, 0)
                if err != nil {
                        return 0, fmt.Errorf("unable to cast %#v of type %T to int8", i, i)
                }
                r := int8(v)
                d, err := decimal.NewFromString(s)
                if err != nil {
                        return 0, err
                }
                if !d.Equal(decimal.NewFromInt32(int32(r))) {
                        return 0, castOverFlowError("string", "int8")
                }
                return r, nil
        case bool:
                if s {
                        return 1, nil
                }
                return 0, nil
        case nil:
                return 0, nil
        default:
                return 0, fmt.Errorf("unable to cast %#v of type %T to int8", i, i)
        }
}

func ToDecimalE

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func ToDecimalE(v interface{}) (decimal.Decimal, error) {
        s, err := ToStringE(v)
        if err != nil {
                return decimal.Decimal{}, err
        }
        if s == "" {
                return decimal.Zero, nil
        }
        d, err := decimal.NewFromString(s)
        if err != nil {
                return decimal.Decimal{}, err
        }
        return d, nil
}

func DivInt32E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func DivInt32E(a, b int32) (r int32, err error) {
        r1, err := DivInt64E(int64(a), int64(b))
        if err != nil {
                return
        }
        r = int32(r1)
        if int64(r) != r1 {
                err = resultOverFlowError("int32")
                return
        }
        return
}

func SubInt8E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func SubInt8E(a, b int8) (r int8, err error) {
        r1, err := SubInt64E(int64(a), int64(b))
        if err != nil {
                return
        }
        r = int8(r1)
        if int64(r) != r1 {
                err = resultOverFlowError("int8")
                return
        }
        return
}

func MulIntE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func MulIntE(a, b int) (r int, err error) {
        r1, err := MulInt64E(int64(a), int64(b))
        if err != nil {
                return
        }
        r = int(r1)
        if int64(r) != r1 {
                err = resultOverFlowError("int")
                return
        }
        return
}

func DivIntE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func DivIntE(a, b int) (r int, err error) {
        r1, err := DivInt64E(int64(a), int64(b))
        if err != nil {
                return
        }
        r = int(r1)
        if int64(r) != r1 {
                err = resultOverFlowError("int")
                return
        }
        return
}

func MulInt16E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func MulInt16E(a, b int16) (r int16, err error) {
        r1, err := MulInt64E(int64(a), int64(b))
        if err != nil {
                return
        }
        r = int16(r1)
        if int64(r) != r1 {
                err = resultOverFlowError("int16")
                return
        }
        return
}

func AddIntE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func AddIntE(a, b int) (r int, err error) {
        r1, err := AddInt64E(int64(a), int64(b))
        if err != nil {
                return
        }
        r = int(r1)
        if int64(r) != r1 {
                err = resultOverFlowError("int")
                return
        }
        return
}

func ToBinOperandE

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func ToBinOperandE(left, right interface{}) (o1, o2 interface{}, err error) {
        
        _nil := false
        
        if IsNil(left) {
                _nil = true
        } else {
                o1 = Indirect(left)
        }
        
        if IsNil(right) {
                _nil = true
        } else {
                o2 = Indirect(right)
        }
        
        if _nil {
                return
        }
        
        switch left.(type) {
        case int:
                o2, err = ToIntE(right)
        case int8:
                o2, err = ToInt8E(right)
        case int16:
                o2, err = ToInt16E(right)
        case int32:
                o2, err = ToInt32E(right)
        case int64:
                o2, err = ToInt64E(right)
        case uint:
                o2, err = ToUintE(right)
        case uint8:
                o2, err = ToUint8E(right)
        case uint16:
                o2, err = ToUint16E(right)
        case uint32:
                o2, err = ToUint32E(right)
        case uint64:
                o2, err = ToUint64E(right)
        case decimal.Decimal:
                o2, err = ToDecimalE(right)
        case string:
                o2, err = ToStringE(right)
        default:
                err = fmt.Errorf("cant't convert")
        }
        if err != nil {
                return nil, nil, fmt.Errorf("operand types are different and %s", err)
        }
        
        return left, o2, nil
}

func DivAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func DivAnyE(left, right interface{}) (interface{}, error) {
        o1, o2, err := ToBinOperandE(left, right)
        if err != nil {
                return nil, err
        }
        switch s := o1.(type) {
        case int:
                return DivIntE(o1.(int), o2.(int))
        case int8:
                return DivInt8E(o1.(int8), o2.(int8))
        case int16:
                return DivInt16E(o1.(int16), o2.(int16))
        case int32:
                return DivInt32E(o1.(int32), o2.(int32))
        case int64:
                return DivInt64E(o1.(int64), o2.(int64))
        case uint:
                return DivUintE(o1.(uint), o2.(uint))
        case uint8:
                return DivUint8E(o1.(uint8), o2.(uint8))
        case uint16:
                return DivUint16E(o1.(uint16), o2.(uint16))
        case uint32:
                return DivUint32E(o1.(uint32), o2.(uint32))
        case uint64:
                return DivUint64E(o1.(uint64), o2.(uint64))
        case decimal.Decimal:
                return o1.(decimal.Decimal).Div(o2.(decimal.Decimal)), nil
        default:
                return nil, fmt.Errorf("unsupport div type '%s'", s)
        }
}

func MulAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func MulAnyE(left, right interface{}) (interface{}, error) {
        o1, o2, err := ToBinOperandE(left, right)
        if err != nil {
                return nil, err
        }
        switch s := o1.(type) {
        case int:
                return MulIntE(o1.(int), o2.(int))
        case int8:
                return MulInt8E(o1.(int8), o2.(int8))
        case int16:
                return MulInt16E(o1.(int16), o2.(int16))
        case int32:
                return MulInt32E(o1.(int32), o2.(int32))
        case int64:
                return MulInt64E(o1.(int64), o2.(int64))
        case uint:
                return MulUintE(o1.(uint), o2.(uint))
        case uint8:
                return MulUint8E(o1.(uint8), o2.(uint8))
        case uint16:
                return MulUint16E(o1.(uint16), o2.(uint16))
        case uint32:
                return MulUint32E(o1.(uint32), o2.(uint32))
        case uint64:
                return MulUint64E(o1.(uint64), o2.(uint64))
        case decimal.Decimal:
                return o1.(decimal.Decimal).Mul(o2.(decimal.Decimal)), nil
        default:
                return nil, fmt.Errorf("unsupport mul type '%s'", s)
        }
}

func AddAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func AddAnyE(left, right interface{}) (interface{}, error) {
        o1, o2, err := ToBinOperandE(left, right)
        if err != nil {
                return nil, err
        }
        switch s := o1.(type) {
        case int:
                return AddIntE(o1.(int), o2.(int))
        case int8:
                return AddInt8E(o1.(int8), o2.(int8))
        case int16:
                return AddInt16E(o1.(int16), o2.(int16))
        case int32:
                return AddInt32E(o1.(int32), o2.(int32))
        case int64:
                return AddInt64E(o1.(int64), o2.(int64))
        case uint:
                return AddUintE(o1.(uint), o2.(uint))
        case uint8:
                return AddUint8E(o1.(uint8), o2.(uint8))
        case uint16:
                return AddUint16E(o1.(uint16), o2.(uint16))
        case uint32:
                return AddUint32E(o1.(uint32), o2.(uint32))
        case uint64:
                return AddUint64E(o1.(uint64), o2.(uint64))
        case decimal.Decimal:
                return o1.(decimal.Decimal).Add(o2.(decimal.Decimal)), nil
        case string:
                return o1.(string) + o2.(string), nil
        default:
                return nil, fmt.Errorf("unsupport add type '%s'", s)
        }
}

func SubAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func SubAnyE(left, right interface{}) (interface{}, error) {
        o1, o2, err := ToBinOperandE(left, right)
        if err != nil {
                return nil, err
        }
        switch s := o1.(type) {
        case int:
                return SubIntE(o1.(int), o2.(int))
        case int8:
                return SubInt8E(o1.(int8), o2.(int8))
        case int16:
                return SubInt16E(o1.(int16), o2.(int16))
        case int32:
                return SubInt32E(o1.(int32), o2.(int32))
        case int64:
                return SubInt64E(o1.(int64), o2.(int64))
        case uint:
                return SubUintE(o1.(uint), o2.(uint))
        case uint8:
                return SubUint8E(o1.(uint8), o2.(uint8))
        case uint16:
                return SubUint16E(o1.(uint16), o2.(uint16))
        case uint32:
                return SubUint32E(o1.(uint32), o2.(uint32))
        case uint64:
                return SubUint64E(o1.(uint64), o2.(uint64))
        case decimal.Decimal:
                return o1.(decimal.Decimal).Sub(o2.(decimal.Decimal)), nil
        default:
                return nil, fmt.Errorf("unsupport sub type '%s'", s)
        }
}

func ToBoolE

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func ToBoolE(i interface{}) (bool, error) {
        i = Indirect(i)
        
        switch b := i.(type) {
        case bool:
                return b, nil
        case nil:
                return false, nil
        case int:
                if i.(int) != 0 {
                        return true, nil
                }
                return false, nil
        case int8:
                if i.(int8) != 0 {
                        return true, nil
                }
                return false, nil
        case int16:
                if i.(int16) != 0 {
                        return true, nil
                }
                return false, nil
        case int32:
                if i.(int32) != 0 {
                        return true, nil
                }
                return false, nil
        case int64:
                if i.(int64) != 0 {
                        return true, nil
                }
                return false, nil
        case uint:
                if i.(uint) != 0 {
                        return true, nil
                }
                return false, nil
        case uint8:
                if i.(uint8) != 0 {
                        return true, nil
                }
                return false, nil
        case uint16:
                if i.(uint16) != 0 {
                        return true, nil
                }
                return false, nil
        case uint32:
                if i.(uint32) != 0 {
                        return true, nil
                }
                return false, nil
        case uint64:
                if i.(uint64) != 0 {
                        return true, nil
                }
                return false, nil
        case decimal.Decimal:
                return !i.(decimal.Decimal).Equal(decimal.Zero), nil
        case string:
                return strconv.ParseBool(i.(string))
        default:
                return false, fmt.Errorf("unable to cast %#v of type %T to bool", i, i)
        }
}

func ToFloat32E

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func ToFloat32E(i interface{}) (float32, error) {
        i = Indirect(i)
        
        switch s := i.(type) {
        case float64:
                return float32(s), nil
        case float32:
                return s, nil
        case int:
                return float32(s), nil
        case int64:
                return float32(s), nil
        case int32:
                return float32(s), nil
        case int16:
                return float32(s), nil
        case int8:
                return float32(s), nil
        case uint:
                return float32(s), nil
        case uint64:
                return float32(s), nil
        case uint32:
                return float32(s), nil
        case uint16:
                return float32(s), nil
        case uint8:
                return float32(s), nil
        case string:
                v, err := strconv.ParseFloat(s, 32)
                if err == nil {
                        return float32(v), nil
                }
                return 0, fmt.Errorf("unable to cast %#v of type %T to float32", i, i)
        case bool:
                if s {
                        return 1, nil
                }
                return 0, nil
        case nil:
                return 0, nil
        default:
                return 0, fmt.Errorf("unable to cast %#v of type %T to float32", i, i)
        }
}

func ToFloat64E

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func ToFloat64E(i interface{}) (float64, error) {
        i = Indirect(i)
        
        switch s := i.(type) {
        case float64:
                return s, nil
        case float32:
                return float64(s), nil
        case int:
                return float64(s), nil
        case int64:
                return float64(s), nil
        case int32:
                return float64(s), nil
        case int16:
                return float64(s), nil
        case int8:
                return float64(s), nil
        case uint:
                return float64(s), nil
        case uint64:
                return float64(s), nil
        case uint32:
                return float64(s), nil
        case uint16:
                return float64(s), nil
        case uint8:
                return float64(s), nil
        case string:
                v, err := strconv.ParseFloat(s, 64)
                if err == nil {
                        return v, nil
                }
                return 0, fmt.Errorf("unable to cast %#v of type %T to float64", i, i)
        case bool:
                if s {
                        return 1, nil
                }
                return 0, nil
        default:
                return 0, fmt.Errorf("unable to cast %#v of type %T to float64", i, i)
        }
}

func ToReflectTypeE

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

func ToReflectTypeE(_type reflect.Type, operand interface{}) (interface{}, error) {
        var err error
        var result interface{}
        switch _type.Kind() {
        case reflect.Int8:
                result, err = ToInt8E(operand)
        case reflect.Int16:
                result, err = ToInt16E(operand)
        case reflect.Int32:
                result, err = ToInt32E(operand)
        case reflect.Int64:
                result, err = ToInt64E(operand)
        case reflect.Uint:
                result, err = ToUintE(operand)
        case reflect.Uint8:
                result, err = ToUint8E(operand)
        case reflect.Uint16:
                result, err = ToUint16E(operand)
        case reflect.Uint32:
                result, err = ToUint32E(operand)
        case reflect.Uint64:
                result, err = ToUint64E(operand)
        case reflect.String:
                result, err = ToStringE(operand)
        case reflect.Interface:
                result = operand
        default:
                if _type.Kind() == reflect.Struct && _type.Name() == "decimal.Decimal" {
                        result, err = ToDecimalE(operand)
                } else {
                        return nil, fmt.Errorf("unsupport convert type '%s'", _type)
                }
        }
        if err != nil {
                return nil, fmt.Errorf("convert type '%s' error: %s", _type, err)
        }
        return result, nil
}

func NotEqualAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func NotEqualAnyE(left, right interface{}) (bool, error) {
        
        o1, o2, err := ToBinOperandE(left, right)
        if err != nil {
                return false, err
        }
        
        if o1 == nil || o2 == nil {
                return o1 != o2, nil
        }
        
        switch s := o1.(type) {
        case int:
                return o1.(int) != o2.(int), nil
        case int8:
                return o1.(int8) != o2.(int8), nil
        case int16:
                return o1.(int16) != o2.(int16), nil
        case int32:
                return o1.(int32) != o2.(int32), nil
        case int64:
                return o1.(int64) != o2.(int64), nil
        case uint:
                return o1.(uint) != o2.(uint), nil
        case uint8:
                return o1.(uint8) != o2.(uint8), nil
        case uint16:
                return o1.(uint16) != o2.(uint16), nil
        case uint32:
                return o1.(uint32) != o2.(uint32), nil
        case uint64:
                return o1.(uint64) != o2.(uint64), nil
        case string:
                return o1.(string) != o2.(string), nil
        case decimal.Decimal:
                return !o1.(decimal.Decimal).Equal(o2.(decimal.Decimal)), nil
        default:
                return false, fmt.Errorf("unsupport not equal type '%s'", s)
        }
}

func EqualAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func EqualAnyE(left, right interface{}) (bool, error) {
        
        o1, o2, err := ToBinOperandE(left, right)
        if err != nil {
                return false, err
        }
        
        if o1 == nil || o2 == nil {
                return o1 == o2, nil
        }
        
        switch s := o1.(type) {
        case int:
                return o1.(int) == o2.(int), nil
        case int8:
                return o1.(int8) == o2.(int8), nil
        case int16:
                return o1.(int16) == o2.(int16), nil
        case int32:
                return o1.(int32) == o2.(int32), nil
        case int64:
                return o1.(int64) == o2.(int64), nil
        case uint:
                return o1.(uint) == o2.(uint), nil
        case uint8:
                return o1.(uint8) == o2.(uint8), nil
        case uint16:
                return o1.(uint16) == o2.(uint16), nil
        case uint32:
                return o1.(uint32) == o2.(uint32), nil
        case uint64:
                return o1.(uint64) == o2.(uint64), nil
        case string:
                return o1.(string) == o2.(string), nil
        case decimal.Decimal:
                return o1.(decimal.Decimal).Equal(o2.(decimal.Decimal)), nil
        default:
                return false, fmt.Errorf("unsupport equal type '%s'", s)
        }
}

func UnaryMinusAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func UnaryMinusAnyE(v interface{}) (interface{}, error) {
        v = Indirect(v)
        switch s := v.(type) {
        case int:
                return -v.(int), nil
        case int8:
                return -v.(int8), nil
        case int16:
                return -v.(int16), nil
        case int32:
                return -v.(int32), nil
        case int64:
                return -v.(int64), nil
        case uint:
                return -v.(uint), nil
        case uint8:
                return -v.(uint8), nil
        case uint16:
                return -v.(uint16), nil
        case uint32:
                return -v.(uint32), nil
        case uint64:
                return -v.(uint64), nil
        case decimal.Decimal:
                vv := v.(decimal.Decimal).String()
                if strings.HasPrefix(vv, "-") {
                        r, err := decimal.NewFromString(strings.TrimPrefix(vv, "-"))
                        return r, err
                } else {
                        r, err := decimal.NewFromString("-" + vv)
                        return r, err
                }
        default:
                return false, fmt.Errorf("unsupport unary minus type '%s'", s)
        }
}

func UnaryPlusAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func UnaryPlusAnyE(v interface{}) (interface{}, error) {
        v = Indirect(v)
        switch s := v.(type) {
        case int:
                return +v.(int), nil
        case int8:
                return +v.(int8), nil
        case int16:
                return +v.(int16), nil
        case int32:
                return +v.(int32), nil
        case int64:
                return +v.(int64), nil
        case uint:
                return +v.(uint), nil
        case uint8:
                return +v.(uint8), nil
        case uint16:
                return +v.(uint16), nil
        case uint32:
                return +v.(uint32), nil
        case uint64:
                return +v.(uint64), nil
        case decimal.Decimal:
                vv := v.(decimal.Decimal).String()
                if strings.HasPrefix(vv, "-") {
                        r, err := decimal.NewFromString(strings.TrimPrefix(vv, "-"))
                        return r, err
                }
                return v.(decimal.Decimal), nil
        default:
                return false, fmt.Errorf("unsupport unary plus type '%s'", s)
        }
}

func GreaterAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func GreaterAnyE(left, right interface{}) (bool, error) {
        o1, o2, err := ToBinOperandE(left, right)
        if err != nil {
                return false, err
        }
        switch s := o1.(type) {
        case int:
                return o1.(int) > o2.(int), nil
        case int8:
                return o1.(int8) > o2.(int8), nil
        case int16:
                return o1.(int16) > o2.(int16), nil
        case int32:
                return o1.(int32) > o2.(int32), nil
        case int64:
                return o1.(int64) > o2.(int64), nil
        case uint:
                return o1.(uint) > o2.(uint), nil
        case uint8:
                return o1.(uint8) > o2.(uint8), nil
        case uint16:
                return o1.(uint16) > o2.(uint16), nil
        case uint32:
                return o1.(uint32) > o2.(uint32), nil
        case uint64:
                return o1.(uint64) > o2.(uint64), nil
        case string:
                return o1.(string) > o2.(string), nil
        case decimal.Decimal:
                return o1.(decimal.Decimal).GreaterThanOrEqual(o2.(decimal.Decimal)), nil
        default:
                return false, fmt.Errorf("unsupport greater type '%s'", s)
        }
}

func LessOrEqualAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func LessOrEqualAnyE(left, right interface{}) (bool, error) {
        o1, o2, err := ToBinOperandE(left, right)
        if err != nil {
                return false, err
        }
        switch s := o1.(type) {
        case int:
                return o1.(int) <= o2.(int), nil
        case int8:
                return o1.(int8) <= o2.(int8), nil
        case int16:
                return o1.(int16) <= o2.(int16), nil
        case int32:
                return o1.(int32) <= o2.(int32), nil
        case int64:
                return o1.(int64) <= o2.(int64), nil
        case uint:
                return o1.(uint) <= o2.(uint), nil
        case uint8:
                return o1.(uint8) <= o2.(uint8), nil
        case uint16:
                return o1.(uint16) <= o2.(uint16), nil
        case uint32:
                return o1.(uint32) <= o2.(uint32), nil
        case uint64:
                return o1.(uint64) <= o2.(uint64), nil
        case string:
                return o1.(string) <= o2.(string), nil
        case decimal.Decimal:
                return o1.(decimal.Decimal).LessThanOrEqual(o2.(decimal.Decimal)), nil
        default:
                return false, fmt.Errorf("unsupport less or equal type '%s'", s)
        }
}

func LessAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func LessAnyE(left, right interface{}) (bool, error) {
        o1, o2, err := ToBinOperandE(left, right)
        if err != nil {
                return false, err
        }
        switch s := o1.(type) {
        case int:
                return o1.(int) < o2.(int), nil
        case int8:
                return o1.(int8) < o2.(int8), nil
        case int16:
                return o1.(int16) < o2.(int16), nil
        case int32:
                return o1.(int32) < o2.(int32), nil
        case int64:
                return o1.(int64) < o2.(int64), nil
        case uint:
                return o1.(uint) < o2.(uint), nil
        case uint8:
                return o1.(uint8) < o2.(uint8), nil
        case uint16:
                return o1.(uint16) < o2.(uint16), nil
        case uint32:
                return o1.(uint32) < o2.(uint32), nil
        case uint64:
                return o1.(uint64) < o2.(uint64), nil
        case string:
                return o1.(string) < o2.(string), nil
        case decimal.Decimal:
                return o1.(decimal.Decimal).LessThan(o2.(decimal.Decimal)), nil
        default:
                return false, fmt.Errorf("unsupport less type '%s'", s)
        }
}

func GreaterOrEqualAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func GreaterOrEqualAnyE(left, right interface{}) (bool, error) {
        o1, o2, err := ToBinOperandE(left, right)
        if err != nil {
                return false, err
        }
        switch s := o1.(type) {
        case int:
                return o1.(int) >= o2.(int), nil
        case int8:
                return o1.(int8) >= o2.(int8), nil
        case int16:
                return o1.(int16) >= o2.(int16), nil
        case int32:
                return o1.(int32) >= o2.(int32), nil
        case int64:
                return o1.(int64) >= o2.(int64), nil
        case uint:
                return o1.(uint) >= o2.(uint), nil
        case uint8:
                return o1.(uint8) >= o2.(uint8), nil
        case uint16:
                return o1.(uint16) >= o2.(uint16), nil
        case uint32:
                return o1.(uint32) >= o2.(uint32), nil
        case uint64:
                return o1.(uint64) >= o2.(uint64), nil
        case string:
                return o1.(string) >= o2.(string), nil
        case decimal.Decimal:
                return o1.(decimal.Decimal).GreaterThanOrEqual(o2.(decimal.Decimal)), nil
        default:
                return false, fmt.Errorf("unsupport greater or equal type '%s'", s)
        }
}

func BitClearAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func BitClearAnyE(left, right interface{}) (interface{}, error) {
        o1, o2, err := ToBinOperandE(left, right)
        if err != nil {
                return nil, err
        }
        switch s := o1.(type) {
        case int:
                return o1.(int) &^ o2.(int), nil
        case int8:
                return o1.(int8) &^ o2.(int8), nil
        case int16:
                return o1.(int16) &^ o2.(int16), nil
        case int32:
                return o1.(int32) &^ o2.(int32), nil
        case int64:
                return o1.(int64) &^ o2.(int64), nil
        case uint:
                return o1.(uint) &^ o2.(uint), nil
        case uint8:
                return o1.(uint8) &^ o2.(uint8), nil
        case uint16:
                return o1.(uint16) &^ o2.(uint16), nil
        case uint32:
                return o1.(uint32) &^ o2.(uint32), nil
        case uint64:
                return o1.(uint64) &^ o2.(uint64), nil
        default:
                return nil, fmt.Errorf("unsupport bit clear type '%s'", s)
        }
}

func LeftShiftAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func LeftShiftAnyE(left, right interface{}) (interface{}, error) {
        o1, o2, err := ToBinOperandE(left, right)
        if err != nil {
                return nil, err
        }
        switch s := o1.(type) {
        case int:
                return o1.(int) << o2.(int), nil
        case int8:
                return o1.(int8) << o2.(int8), nil
        case int16:
                return o1.(int16) << o2.(int16), nil
        case int32:
                return o1.(int32) << o2.(int32), nil
        case int64:
                return o1.(int64) << o2.(int64), nil
        case uint:
                return o1.(uint) << o2.(uint), nil
        case uint8:
                return o1.(uint8) << o2.(uint8), nil
        case uint16:
                return o1.(uint16) << o2.(uint16), nil
        case uint32:
                return o1.(uint32) << o2.(uint32), nil
        case uint64:
                return o1.(uint64) << o2.(uint64), nil
        default:
                return nil, fmt.Errorf("unsupport left shift type '%s'", s)
        }
}

func RightShiftAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func RightShiftAnyE(left, right interface{}) (interface{}, error) {
        o1, o2, err := ToBinOperandE(left, right)
        if err != nil {
                return nil, err
        }
        switch s := o1.(type) {
        case int:
                return o1.(int) >> o2.(int), nil
        case int8:
                return o1.(int8) >> o2.(int8), nil
        case int16:
                return o1.(int16) >> o2.(int16), nil
        case int32:
                return o1.(int32) >> o2.(int32), nil
        case int64:
                return o1.(int64) >> o2.(int64), nil
        case uint:
                return o1.(uint) >> o2.(uint), nil
        case uint8:
                return o1.(uint8) >> o2.(uint8), nil
        case uint16:
                return o1.(uint16) >> o2.(uint16), nil
        case uint32:
                return o1.(uint32) >> o2.(uint32), nil
        case uint64:
                return o1.(uint64) >> o2.(uint64), nil
        default:
                return nil, fmt.Errorf("unsupport right shift type '%s'", s)
        }
}

func ModAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func ModAnyE(left, right interface{}) (interface{}, error) {
        o1, o2, err := ToBinOperandE(left, right)
        if err != nil {
                return nil, err
        }
        switch s := o1.(type) {
        case int:
                return o1.(int) % o2.(int), nil
        case int8:
                return o1.(int8) % o2.(int8), nil
        case int16:
                return o1.(int16) % o2.(int16), nil
        case int32:
                return o1.(int32) % o2.(int32), nil
        case int64:
                return o1.(int64) % o2.(int64), nil
        case uint:
                return o1.(uint) % o2.(uint), nil
        case uint8:
                return o1.(uint8) % o2.(uint8), nil
        case uint16:
                return o1.(uint16) % o2.(uint16), nil
        case uint32:
                return o1.(uint32) % o2.(uint32), nil
        case uint64:
                return o1.(uint64) % o2.(uint64), nil
        default:
                return nil, fmt.Errorf("unsupport mod type '%s'", s)
        }
}

func CaretAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func CaretAnyE(left, right interface{}) (interface{}, error) {
        o1, o2, err := ToBinOperandE(left, right)
        if err != nil {
                return nil, err
        }
        switch s := o1.(type) {
        case int:
                return o1.(int) ^ o2.(int), nil
        case int8:
                return o1.(int8) ^ o2.(int8), nil
        case int16:
                return o1.(int16) ^ o2.(int16), nil
        case int32:
                return o1.(int32) ^ o2.(int32), nil
        case int64:
                return o1.(int64) ^ o2.(int64), nil
        case uint:
                return o1.(uint) ^ o2.(uint), nil
        case uint8:
                return o1.(uint8) ^ o2.(uint8), nil
        case uint16:
                return o1.(uint16) ^ o2.(uint16), nil
        case uint32:
                return o1.(uint32) ^ o2.(uint32), nil
        case uint64:
                return o1.(uint64) ^ o2.(uint64), nil
        default:
                return nil, fmt.Errorf("unsupport caret type '%s'", s)
        }
}

func OrAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func OrAnyE(left, right interface{}) (interface{}, error) {
        o1, o2, err := ToBinOperandE(left, right)
        if err != nil {
                return nil, err
        }
        switch s := o1.(type) {
        case int:
                return o1.(int) | o2.(int), nil
        case int8:
                return o1.(int8) | o2.(int8), nil
        case int16:
                return o1.(int16) | o2.(int16), nil
        case int32:
                return o1.(int32) | o2.(int32), nil
        case int64:
                return o1.(int64) | o2.(int64), nil
        case uint:
                return o1.(uint) | o2.(uint), nil
        case uint8:
                return o1.(uint8) | o2.(uint8), nil
        case uint16:
                return o1.(uint16) | o2.(uint16), nil
        case uint32:
                return o1.(uint32) | o2.(uint32), nil
        case uint64:
                return o1.(uint64) | o2.(uint64), nil
        default:
                return nil, fmt.Errorf("unsupport or type '%s'", s)
        }
}

func AndAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func AndAnyE(left, right interface{}) (interface{}, error) {
        o1, o2, err := ToBinOperandE(left, right)
        if err != nil {
                return nil, err
        }
        switch s := o1.(type) {
        case int:
                return o1.(int) & o2.(int), nil
        case int8:
                return o1.(int8) & o2.(int8), nil
        case int16:
                return o1.(int16) & o2.(int16), nil
        case int32:
                return o1.(int32) & o2.(int32), nil
        case int64:
                return o1.(int64) & o2.(int64), nil
        case uint:
                return o1.(uint) & o2.(uint), nil
        case uint8:
                return o1.(uint8) & o2.(uint8), nil
        case uint16:
                return o1.(uint16) & o2.(uint16), nil
        case uint32:
                return o1.(uint32) & o2.(uint32), nil
        case uint64:
                return o1.(uint64) & o2.(uint64), nil
        default:
                return nil, fmt.Errorf("unsupport and type '%s'", s)
        }
}

func UnaryCaretAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func UnaryCaretAnyE(v interface{}) (interface{}, error) {
        v = Indirect(v)
        switch s := v.(type) {
        case int:
                return ^v.(int), nil
        case int8:
                return ^v.(int8), nil
        case int16:
                return ^v.(int16), nil
        case int32:
                return ^v.(int32), nil
        case int64:
                return ^v.(int64), nil
        case uint:
                return ^v.(uint), nil
        case uint8:
                return ^v.(uint8), nil
        case uint16:
                return ^v.(uint16), nil
        case uint32:
                return ^v.(uint32), nil
        case uint64:
                return ^v.(uint64), nil
        default:
                return false, fmt.Errorf("unsupport unary caret type '%s'", s)
        }
}

func DivUint16E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func DivUint16E(a, b uint16) (r uint16, err error) {
        r1, err := DivUint64E(uint64(a), uint64(b))
        if err != nil {
                return
        }
        r = uint16(r1)
        if uint64(r) != r1 {
                err = resultOverFlowError("uint16")
                return
        }
        return
}

func AddInt32E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func AddInt32E(a, b int32) (r int32, err error) {
        r1, err := AddInt64E(int64(a), int64(b))
        if err != nil {
                return
        }
        r = int32(r1)
        if int64(r) != r1 {
                err = resultOverFlowError("int32")
                return
        }
        return
}

func MulUint32E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func MulUint32E(a, b uint32) (r uint32, err error) {
        r1, err := DivUint64E(uint64(a), uint64(b))
        if err != nil {
                return
        }
        r = uint32(r1)
        if uint64(r) != r1 {
                err = resultOverFlowError("uint32")
                return
        }
        return
}

func SubUint32E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func SubUint32E(a, b uint32) (r uint32, err error) {
        r1, err := SubUint64E(uint64(a), uint64(b))
        if err != nil {
                return
        }
        r = uint32(r1)
        if uint64(r) != r1 {
                err = resultOverFlowError("uint32")
                return
        }
        return
}

func AddUint32E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func AddUint32E(a, b uint32) (r uint32, err error) {
        r1, err := AddUint64E(uint64(a), uint64(b))
        if err != nil {
                return
        }
        r = uint32(r1)
        if uint64(r) != r1 {
                err = resultOverFlowError("uint32")
                return
        }
        return
}

func MulUint16E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func MulUint16E(a, b uint16) (r uint16, err error) {
        r1, err := MulUint64E(uint64(a), uint64(b))
        if err != nil {
                return
        }
        r = uint16(r1)
        if uint64(r) != r1 {
                err = resultOverFlowError("uint16")
                return
        }
        return
}

func SubUint16E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func SubUint16E(a, b uint16) (r uint16, err error) {
        r1, err := SubUint64E(uint64(a), uint64(b))
        if err != nil {
                return
        }
        r = uint16(r1)
        if uint64(r) != r1 {
                err = resultOverFlowError("uint16")
                return
        }
        return
}

func AddUint16E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func AddUint16E(a, b uint16) (r uint16, err error) {
        r1, err := AddUint64E(uint64(a), uint64(b))
        if err != nil {
                return
        }
        r = uint16(r1)
        if uint64(r) != r1 {
                err = resultOverFlowError("uint16")
                return
        }
        return
}

func DivUint8E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func DivUint8E(a, b uint8) (r uint8, err error) {
        r1, err := DivUint64E(uint64(a), uint64(b))
        if err != nil {
                return
        }
        r = uint8(r1)
        if uint64(r) != r1 {
                err = resultOverFlowError("uint8")
                return
        }
        return
}

func MulUint8E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func MulUint8E(a, b uint8) (r uint8, err error) {
        r1, err := MulUint64E(uint64(a), uint64(b))
        if err != nil {
                return
        }
        r = uint8(r1)
        if uint64(r) != r1 {
                err = resultOverFlowError("uint8")
                return
        }
        return
}

func SubUint8E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func SubUint8E(a, b uint8) (r uint8, err error) {
        r1, err := SubUint64E(uint64(a), uint64(b))
        if err != nil {
                return
        }
        r = uint8(r1)
        if uint64(r) != r1 {
                err = resultOverFlowError("uint8")
                return
        }
        return
}

func AddUint8E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func AddUint8E(a, b uint8) (r uint8, err error) {
        r1, err := AddUint64E(uint64(a), uint64(b))
        if err != nil {
                return
        }
        r = uint8(r1)
        if uint64(r) != r1 {
                err = resultOverFlowError("uint8")
                return
        }
        return
}

func DivUintE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func DivUintE(a, b uint) (r uint, err error) {
        r1, err := DivUint64E(uint64(a), uint64(b))
        if err != nil {
                return
        }
        r = uint(r1)
        if uint64(r) != r1 {
                err = resultOverFlowError("uint")
                return
        }
        return
}

func SubIntE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func SubIntE(a, b int) (r int, err error) {
        r1, err := SubInt64E(int64(a), int64(b))
        if err != nil {
                return
        }
        r = int(r1)
        if int64(r) != r1 {
                err = resultOverFlowError("int")
                return
        }
        return
}

func AddInt8E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func AddInt8E(a, b int8) (r int8, err error) {
        r1, err := AddInt64E(int64(a), int64(b))
        if err != nil {
                return
        }
        r = int8(r1)
        if int64(r) != r1 {
                err = resultOverFlowError("int8")
                return
        }
        return
}

func MulInt8E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func MulInt8E(a, b int8) (r int8, err error) {
        r1, err := MulInt64E(int64(a), int64(b))
        if err != nil {
                return
        }
        r = int8(r1)
        if int64(r) != r1 {
                err = resultOverFlowError("int8")
                return
        }
        return
}

func MulUintE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func MulUintE(a, b uint) (r uint, err error) {
        r1, err := MulUint64E(uint64(a), uint64(b))
        if err != nil {
                return
        }
        r = uint(r1)
        if uint64(r) != r1 {
                err = resultOverFlowError("uint")
                return
        }
        return
}

func SubUintE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func SubUintE(a, b uint) (r uint, err error) {
        r1, err := SubUint64E(uint64(a), uint64(b))
        if err != nil {
                return
        }
        r = uint(r1)
        if uint64(r) != r1 {
                err = resultOverFlowError("uint")
                return
        }
        return
}

func AddUintE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func AddUintE(a, b uint) (r uint, err error) {
        r1, err := AddUint64E(uint64(a), uint64(b))
        if err != nil {
                return
        }
        r = uint(r1)
        if uint64(r) != r1 {
                err = resultOverFlowError("uint")
                return
        }
        return
}

func MulInt32E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func MulInt32E(a, b int32) (r int32, err error) {
        r1, err := MulInt64E(int64(a), int64(b))
        if err != nil {
                return
        }
        r = int32(r1)
        if int64(r) != r1 {
                err = resultOverFlowError("int32")
                return
        }
        return
}

func SubInt32E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func SubInt32E(a, b int32) (r int32, err error) {
        r1, err := SubInt64E(int64(a), int64(b))
        if err != nil {
                return
        }
        r = int32(r1)
        if int64(r) != r1 {
                err = resultOverFlowError("int32")
                return
        }
        return
}

func DivUint32E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func DivUint32E(a, b uint32) (r uint32, err error) {
        r1, err := DivUint64E(uint64(a), uint64(b))
        if err != nil {
                return
        }
        r = uint32(r1)
        if uint64(r) != r1 {
                err = resultOverFlowError("uint32")
                return
        }
        return
}

func DivInt16E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func DivInt16E(a, b int16) (r int16, err error) {
        r1, err := DivInt64E(int64(a), int64(b))
        if err != nil {
                return
        }
        r = int16(r1)
        if int64(r) != r1 {
                err = resultOverFlowError("int16")
                return
        }
        return
}

func SubInt16E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func SubInt16E(a, b int16) (r int16, err error) {
        r1, err := SubInt64E(int64(a), int64(b))
        if err != nil {
                return
        }
        r = int16(r1)
        if int64(r) != r1 {
                err = resultOverFlowError("int16")
                return
        }
        return
}

func AddInt16E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func AddInt16E(a, b int16) (r int16, err error) {
        r1, err := AddInt64E(int64(a), int64(b))
        if err != nil {
                return
        }
        r = int16(r1)
        if int64(r) != r1 {
                err = resultOverFlowError("int16")
                return
        }
        return
}

func DivInt8E

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func DivInt8E(a, b int8) (r int8, err error) {
        r1, err := DivInt64E(int64(a), int64(b))
        if err != nil {
                return
        }
        r = int8(r1)
        if int64(r) != r1 {
                err = resultOverFlowError("int8")
                return
        }
        return
}

func LogicAndAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func LogicAndAnyE(left, right interface{}) (bool, error) {
        a, err := ToBoolE(left)
        if err != nil {
                return false, err
        }
        b, err := ToBoolE(right)
        if err != nil {
                return false, err
        }
        return a && b, nil
}

func LogicOrAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func LogicOrAnyE(left, right interface{}) (bool, error) {
        a, err := ToBoolE(left)
        if err != nil {
                return false, err
        }
        b, err := ToBoolE(right)
        if err != nil {
                return false, err
        }
        return a || b, nil
}

func BigDivUint64

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func BigDivUint64(a, b uint64) *big.Int {
        r := big.NewInt(0)
        ba := &big.Int{}
        ba.SetUint64(a)
        bb := &big.Int{}
        bb.SetUint64(b)
        return r.Div(ba, bb)
}

func BigSubUint64

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func BigSubUint64(a, b uint64) *big.Int {
        r := big.NewInt(0)
        ba := &big.Int{}
        ba.SetUint64(a)
        bb := &big.Int{}
        bb.SetUint64(b)
        return r.Sub(ba, bb)
}

func UnaryNotAnyE

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

func UnaryNotAnyE(v interface{}) (interface{}, error) {
        v = Indirect(v)
        switch s := v.(type) {
        case bool:
                return !v.(bool), nil
        default:
                return false, fmt.Errorf("unsupport unary not type '%s'", s)
        }
}

func Value.Add

Back

In /Users/kun/gobatis/gobatis/cast/value.go:

func (p Value) Add(a Value) (err error) {
        
        switch p.Kind() {
        case reflect.Int8:
        
        }
        
        return
}

func jsonStringToObject

Back

In /Users/kun/gobatis/gobatis/cast/caste.go:

1383	`func jsonStringToObject(s string, v interface{}) error {`
1384	`data := []byte(s)`
1385	`return json.Unmarshal(data, v)`
1386	`}`

func BigDivInt64

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

31	`func BigDivInt64(a, b int64) *big.Int {`
32	`r := big.NewInt(0)`
33	`return r.Div(big.NewInt(a), big.NewInt(b))`
34	`}`

func MulFloat32

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

96	`func MulFloat32(a, b float32) (r decimal.Decimal) {`
97	`return decimal.NewFromFloat32(a).Mul(decimal.NewFromFloat32(b))`
98	`}`

func SubFloat64

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

76	`func SubFloat64(a, b float64) (r decimal.Decimal) {`
77	`return decimal.NewFromFloat(a).Sub(decimal.NewFromFloat(b))`
78	`}`

func AddFloat64

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

72	`func AddFloat64(a, b float64) (r decimal.Decimal) {`
73	`return decimal.NewFromFloat(a).Add(decimal.NewFromFloat(b))`
74	`}`

func MulFloat64

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

80	`func MulFloat64(a, b float64) (r decimal.Decimal) {`
81	`return decimal.NewFromFloat(a).Mul(decimal.NewFromFloat(b))`
82	`}`

func DivFloat64

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

84	`func DivFloat64(a, b float64) (r decimal.Decimal) {`
85	`return decimal.NewFromFloat(a).Div(decimal.NewFromFloat(b))`
86	`}`

func AddFloat32

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

88	`func AddFloat32(a, b float32) (r decimal.Decimal) {`
89	`return decimal.NewFromFloat32(a).Add(decimal.NewFromFloat32(b))`
90	`}`

func SubFloat32

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

92	`func SubFloat32(a, b float32) (r decimal.Decimal) {`
93	`return decimal.NewFromFloat32(a).Sub(decimal.NewFromFloat32(b))`
94	`}`

func DivFloat32

Back

In /Users/kun/gobatis/gobatis/cast/calc.go:

100	`func DivFloat32(a, b float32) (r decimal.Decimal) {`
101	`return decimal.NewFromFloat32(a).Div(decimal.NewFromFloat32(b))`
102	`}`

Package Overview: github.com/gobatis/gobatis/driver/postgres 93.3%

Please select a function to see what's left for testing.

`Namer.TableName(...)`	`github.com/gobatis/gobatis/driver/postgres/db.go`	`100.0%`	`4/4`
`Open(...)`	`github.com/gobatis/gobatis/driver/postgres/db.go`	`100.0%`	`3/3`
`Namer.ColumnName(...)`	`github.com/gobatis/gobatis/driver/postgres/db.go`	`100.0%`	`3/3`
`Dialector.Namer(...)`	`github.com/gobatis/gobatis/driver/postgres/db.go`	`100.0%`	`1/1`
`Dialector.DB(...)`	`github.com/gobatis/gobatis/driver/postgres/db.go`	`100.0%`	`1/1`
`Namer.ReservedName(...)`	`github.com/gobatis/gobatis/driver/postgres/db.go`	`66.7%`	`2/3`

func Namer.TableName

Back

In /Users/kun/gobatis/gobatis/driver/postgres/db.go:

func (n Namer) TableName(name string) string {
        items := strings.Split(name, ".")
        for i := range items {
                items[i] = n.ReservedName(items[i])
        }
        return strings.Join(items, ".")
}

func Open

Back

In /Users/kun/gobatis/gobatis/driver/postgres/db.go:

func Open(dsn string) *Dialector {
        d := &Dialector{}
        d.db, d.err = sql.Open("pgx", dsn)
        return d
}

func Namer.ColumnName

Back

In /Users/kun/gobatis/gobatis/driver/postgres/db.go:

func (n Namer) ColumnName(name string) string {
        var re = regexp.MustCompile(`([^A-Z_])([A-Z])`)
        snakeStr := re.ReplaceAllString(name, "${1}_${2}")
        return strings.ToLower(snakeStr)
}

func Dialector.Namer

Back

In /Users/kun/gobatis/gobatis/driver/postgres/db.go:

26	`func (d Dialector) Namer() dialector.Namer {`
27	`return &Namer{}`
28	`}`

func Dialector.DB

Back

In /Users/kun/gobatis/gobatis/driver/postgres/db.go:

30	`func (d Dialector) DB() (*sql.DB, error) {`
31	`return d.db, d.err`
32	`}`

func Namer.ReservedName

Back

In /Users/kun/gobatis/gobatis/driver/postgres/db.go:

func (n Namer) ReservedName(name string) string {
        if strings.HasPrefix(name, "\"") {
                return name
        }
        return fmt.Sprintf("\"%s\"", name)
}

Package Overview: github.com/gobatis/gobatis/dtd 0.0%

Please select a function to see what's left for testing.

`MapperElement(...)`	`github.com/gobatis/gobatis/dtd/match.go`	`0.0%`	`0/33`
`ConfigElement(...)`	`github.com/gobatis/gobatis/dtd/match.go`	`0.0%`	`0/25`
`Element.HasNode(...)`	`github.com/gobatis/gobatis/dtd/element.go`	`0.0%`	`0/4`
`Element.HasAttribute(...)`	`github.com/gobatis/gobatis/dtd/element.go`	`0.0%`	`0/4`
`Element.AddNode(...)`	`github.com/gobatis/gobatis/dtd/element.go`	`0.0%`	`0/3`
`Element.AddAttribute(...)`	`github.com/gobatis/gobatis/dtd/element.go`	`0.0%`	`0/3`
`Element.GetNodeCount(...)`	`github.com/gobatis/gobatis/dtd/element.go`	`0.0%`	`0/3`
`NewElement(...)`	`github.com/gobatis/gobatis/dtd/element.go`	`0.0%`	`0/1`

func MapperElement

Back

In /Users/kun/gobatis/gobatis/dtd/match.go:

func MapperElement(name string) (elem *Element, err error) {
        switch name {
        case MAPPER:
                elem = Mapper
        case CACHE_REF:
                elem = CacheRef
        case CACHE:
                elem = Cache
        case RESULT_MAP:
                elem = ResultMap
        case CONSTRUCTOR:
                elem = Constructor
        case ID:
                elem = Id
        case RESULT:
                elem = Result
        case ID_ARG:
                elem = IdArg
        case ARG:
                elem = Arg
        case COLLECTION:
                elem = Collection
        case ASSOCIATION:
                elem = Association
        case DISCRIMINATOR:
                elem = Discriminator
        case CASE:
                elem = Case
        case TYPE_ALIAS:
                elem = TypeAlias
        case SELECT:
                elem = Select
        case INSERT:
                elem = Insert
        case SELECT_KEY:
                elem = SelectKey
        case UPDATE:
                elem = Update
        case DELETE:
                elem = Delete
        case INCLUDE:
                elem = Include
        case BIND:
                elem = Bind
        case SQL:
                elem = Sql
        case TRIM:
                elem = Trim
        case WHERE:
                elem = Where
        case SET:
                elem = Set
        case FOREACH:
                elem = Foreach
        case CHOOSE:
                elem = Choose
        case WHEN:
                elem = When
        case OTHERWISE:
                elem = Otherwise
        case IF:
                elem = If
        default:
                err = fmt.Errorf("not match %s dtd element", name)
        }

        return
}

func ConfigElement

Back

In /Users/kun/gobatis/gobatis/dtd/match.go:

func ConfigElement(name string) (elem *Element, err error) {
        switch name {
        case MODULE:
                elem = Module
        case DATABASE_ID_PROVIDER:
                elem = DatabaseIdProvider
        case PROPERTIES:
                elem = Properties
        case PROPERTY:
                elem = Property
        case SETTINGS:
                elem = Settings
        case SETTING:
                elem = Setting
        case TYPE_ALIASES:
                elem = TypeAliases
        case TYPE_ALIAS:
                elem = ConfigTypeAlias
        case TYPE_HANDLERS:
                elem = TypeHandlers
        case TYPE_HANDLER:
                elem = TypeHandle
        case OBJECT_FACTORY:
                elem = ObjectFactory
        case OBJECT_WRAPPER_FACTORY:
                elem = ObjectWrapperFactory
        case REFLECT_FACTORY:
                elem = ReflectFactory
        case PLUGINS:
                elem = Plugins
        case PLUGIN:
                elem = Plugin
        case ENVIRONMENTS:
                elem = Environments
        case ENVIRONMENT:
                elem = Environment
        case TRANSACTION_MANAGER:
                elem = TransactionManager
        case DATA_SOURCE:
                elem = DataSource
        case MAPPERS:
                elem = Mappers
        case MAPPER:
                elem = ConfigMapper
        case PACKAGE:
                elem = Package
        default:
                err = fmt.Errorf("not match %s dtd element", name)
        }
        return
}

func Element.HasNode

Back

In /Users/kun/gobatis/gobatis/dtd/element.go:

func (p Element) HasNode(name string) bool {
        if p.Nodes == nil {
                return false
        }
        _, ok := p.Nodes[name]
        return ok
}

func Element.HasAttribute

Back

In /Users/kun/gobatis/gobatis/dtd/element.go:

func (p Element) HasAttribute(name string) bool {
        if p.Attributes == nil {
                return false
        }
        _, ok := p.Attributes[name]
        return ok
}

func Element.AddNode

Back

In /Users/kun/gobatis/gobatis/dtd/element.go:

func (p *Element) AddNode(node string, times int) {
        if p.Nodes == nil {
                p.Nodes = map[string]int{}
        }
        
        p.Nodes[node] = times
        
}

func Element.AddAttribute

Back

In /Users/kun/gobatis/gobatis/dtd/element.go:

func (p *Element) AddAttribute(attribute string, check int) {
        if p.Attributes == nil {
                p.Attributes = map[string]int{}
        }
        
        p.Attributes[attribute] = check
        
}

func Element.GetNodeCount

Back

In /Users/kun/gobatis/gobatis/dtd/element.go:

func (p Element) GetNodeCount(name string) int {
        if p.Nodes == nil {
                return 0
        }
        return p.Nodes[name]
}

func NewElement

Back

In /Users/kun/gobatis/gobatis/dtd/element.go:

3	`func NewElement(name string) Element {`
4	`return Element{Name: name}`
5	`}`

Package Overview: github.com/gobatis/gobatis/executor 45.8%

Please select a function to see what's left for testing.

`replaceIsolatedLessThanWithEntity(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`100.0%`	`17/17`
`reflectStruct(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`100.0%`	`13/13`
`walkXMLNodes(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`9/9`
`initExprParser(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`9/9`
`RowsVars(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`100.0%`	`6/6`
`newExprParser(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`5/5`
`@347:8(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`100.0%`	`5/5`
`newRowMap(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`100.0%`	`4/4`
`isNil(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`100.0%`	`4/4`
`RowsParams(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`100.0%`	`4/4`
`InsertBatch.Query(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`100.0%`	`4/4`
`builtin.is(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`100.0%`	`4/4`
`xmlNode.AddNode(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`4/4`
`Extract(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`100.0%`	`4/4`
`reflectRow(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`100.0%`	`4/4`
`newParamParser(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`4/4`
`xmlNodeStack.Len(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`3/3`
`exprParams.set(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`3/3`
`RowColumns(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`100.0%`	`3/3`
`fragment.parseParams(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`100.0%`	`3/3`
`exprParser.addVar(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`3/3`
`toSnakeCase(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`100.0%`	`3/3`
`fragment.parseBlocks(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`100.0%`	`3/3`
`xmlParser.enterElement(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`3/3`
`xmlNodeStack.Push(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`3/3`
`Default.scan(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`100.0%`	`3/3`
`newXMLStack(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`3/3`
`RowParams(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`100.0%`	`3/3`
`RowVars(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`100.0%`	`3/3`
`newExprParams(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`3/3`
`init(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`100.0%`	`3/3`
`ParallelQuery.Execute(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`100.0%`	`2/2`
`@253:8(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`100.0%`	`2/2`
`coverage.add(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`2/2`
`newValueStack(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`2/2`
`@113:8(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`100.0%`	`2/2`
`newParamsStack(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`2/2`
`xmlParser.ExitEveryRule(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`2/2`
`parserErrorStrategy.RecoverInline(...)`	`github.com/gobatis/gobatis/executor/error.go`	`100.0%`	`2/2`
`parserErrorStrategy.Recover(...)`	`github.com/gobatis/gobatis/executor/error.go`	`100.0%`	`2/2`
`_error.format(...)`	`github.com/gobatis/gobatis/executor/error.go`	`100.0%`	`2/2`
`@1209:8(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`2/2`
`newErrorListener(...)`	`github.com/gobatis/gobatis/executor/error.go`	`100.0%`	`1/1`
`newXMLNode(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`1/1`
`TrimColumns(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`100.0%`	`1/1`
`coverage.setTotal(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`1/1`
`init(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`100.0%`	`1/1`
`valueStack.push(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`1/1`
`valueStack.len(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`1/1`
`NewDB(...)`	`github.com/gobatis/gobatis/executor/db.go`	`100.0%`	`1/1`
`DB.TraceId(...)`	`github.com/gobatis/gobatis/executor/db.go`	`100.0%`	`1/1`
`DB.IsTx(...)`	`github.com/gobatis/gobatis/executor/db.go`	`100.0%`	`1/1`
`throw(...)`	`github.com/gobatis/gobatis/executor/error.go`	`100.0%`	`1/1`
`exprParser.EnterOperand(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`1/1`
`coverage.len(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`1/1`
`exprParser.EnterExpressions(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`1/1`
`coverage.covered(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`1/1`
`exprParser.builtParams(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`1/1`
`NewFetchQuery(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`100.0%`	`1/1`
`newParserErrorStrategy(...)`	`github.com/gobatis/gobatis/executor/error.go`	`100.0%`	`1/1`
`scanner.RowsAffected(...)`	`github.com/gobatis/gobatis/executor/scanner.go`	`100.0%`	`1/1`
`scanner.LastInsertId(...)`	`github.com/gobatis/gobatis/executor/scanner.go`	`100.0%`	`1/1`
`@284:54(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`100.0%`	`1/1`
`logger.Debugf(...)`	`github.com/gobatis/gobatis/executor/logger.go`	`100.0%`	`1/1`
`Tx.IsTx(...)`	`github.com/gobatis/gobatis/executor/tx.go`	`100.0%`	`1/1`
`newCoverage(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`1/1`
`paramsStack.push(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`1/1`
`Tx.TraceId(...)`	`github.com/gobatis/gobatis/executor/tx.go`	`100.0%`	`1/1`
`DefaultLogger(...)`	`github.com/gobatis/gobatis/executor/logger.go`	`100.0%`	`1/1`
`insertBatchScanner.RowsAffected(...)`	`github.com/gobatis/gobatis/executor/scanner.go`	`100.0%`	`1/1`
`NewDefault(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`100.0%`	`1/1`
`Default.Query(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`100.0%`	`1/1`
`@208:62(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`100.0%`	`1/1`
`NewTx(...)`	`github.com/gobatis/gobatis/executor/tx.go`	`100.0%`	`1/1`
`insertBatchScanner.LastInsertId(...)`	`github.com/gobatis/gobatis/executor/scanner.go`	`100.0%`	`1/1`
`NewInsertBatch(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`100.0%`	`1/1`
`paramParser.EnterParamDecl(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`92.9%`	`13/14`
`logger.Trace(...)`	`github.com/gobatis/gobatis/executor/logger.go`	`90.5%`	`19/21`
`fragment.parseSql(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`90.0%`	`27/30`
`ReflectRows(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`88.9%`	`16/18`
`setValue(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`88.9%`	`16/18`
`getText(...)`	`github.com/gobatis/gobatis/executor/error.go`	`88.9%`	`8/9`
`InsertBatch.execute(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`87.5%`	`14/16`
`exprParser.realVars(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`87.5%`	`7/8`
`isStructSlice(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`87.5%`	`7/8`
`@71:8(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`87.5%`	`7/8`
`FetchQuery.Execute(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`87.0%`	`20/23`
`SplitStructSlice(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`85.7%`	`12/14`
`xmlNodeStack.Pop(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`85.7%`	`6/7`
`xmlNodeStack.Peak(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`83.3%`	`5/6`
`paramParser.addParam(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`83.3%`	`5/6`
`affectConstraint.Check(...)`	`github.com/gobatis/gobatis/executor/constraint.go`	`83.3%`	`5/6`
`Default.Execute(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`82.9%`	`34/41`
`InsertBatch.Execute(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`82.8%`	`24/29`
`scanner.Scan(...)`	`github.com/gobatis/gobatis/executor/scanner.go`	`82.4%`	`28/34`
`exprParser.parseExpression(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`82.4%`	`14/17`
`fragment.parseStatement(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`82.4%`	`14/17`
`setStruct(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`81.8%`	`9/11`
`_error.Error(...)`	`github.com/gobatis/gobatis/executor/error.go`	`80.0%`	`12/15`
`insertBatchScanner.Scan(...)`	`github.com/gobatis/gobatis/executor/scanner.go`	`80.0%`	`8/10`
`@377:54(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`80.0%`	`4/5`
`paramsStack.getVar(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`80.0%`	`4/5`
`setBool(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`80.0%`	`4/5`
`setString(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`80.0%`	`4/5`
`CallFuncPos(...)`	`github.com/gobatis/gobatis/executor/logger.go`	`77.8%`	`7/9`
`exprParser.ExitVar_(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`75.0%`	`9/12`
`newAffectConstraint(...)`	`github.com/gobatis/gobatis/executor/constraint.go`	`75.0%`	`9/12`
`handleSlice(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`75.0%`	`3/4`
`prepareFieldName(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`75.0%`	`3/4`
`ExtractTag(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`75.0%`	`3/4`
`exprParams.bind(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`73.3%`	`11/15`
`parseSQL(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`72.7%`	`8/11`
`xmlParser.exitElement(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`71.4%`	`5/7`
`exprParser.popBinaryOperands(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`71.4%`	`5/7`
`exprParams.get(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`70.0%`	`7/10`
`xmlParser.EnterEveryRule(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`70.0%`	`7/10`
`indirect(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`69.2%`	`18/26`
`valueStack.pop(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`66.7%`	`6/9`
`literalEqual(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`66.7%`	`2/3`
`xmlParser.enterChardata(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`66.7%`	`2/3`
`paramParser.walkMethods(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`66.7%`	`2/3`
`trimComma(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`66.7%`	`2/3`
`xmlParser.enterReference(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`63.6%`	`7/11`
`setArray(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`53.8%`	`14/26`
`exprParser.numericStringCalc(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`52.9%`	`9/17`
`@309:8(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`40.0%`	`2/5`
`AddError(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`40.0%`	`2/5`
`@172:8(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`40.0%`	`2/5`
`setNumber(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`38.9%`	`14/36`
`exprParser.ExitExpression(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`36.7%`	`11/30`
`castRecoverError(...)`	`github.com/gobatis/gobatis/executor/error.go`	`25.0%`	`2/8`
`fragment.parseBlock(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`16.7%`	`2/12`
`fragment.parseForeach(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`0.0%`	`0/42`
`exprValue.call(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/25`
`varToReflectKind(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/24`
`exprParser.ExitIndex(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/23`
`xmlParser.validateNode(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/21`
`fragment.parseChoose(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`0.0%`	`0/20`
`param.expected(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/20`
`TestSetValueBasic(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`0.0%`	`0/20`
`exprParser.ExitCall(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/17`
`exprParser.ExitSlice_(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/17`
`fragment.call(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`0.0%`	`0/16`
`exprParser.relationCalc(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/13`
`exprValue.visitMember(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/12`
`exprParser.unaryCalc(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/11`
`xmlParser.checkResultConflict(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/11`
`exprValue.visitArray(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/10`
`fragment.parseTest(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`0.0%`	`0/10`
`exprValue.visitMap(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/10`
`fragment.trimPrefixOverrides(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`0.0%`	`0/10`
`exprParser.popTertiaryOperands(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/10`
`exprParser.ExitMember(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/10`
`paramsStack.pop(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/9`
`printVars(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`0.0%`	`0/9`
`exprValue.visitSlice(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/8`
`exprParser.logicCalc(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/8`
`fragment.bindForeachParams(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`0.0%`	`0/7`
`fragment.checkParameter(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`0.0%`	`0/7`
`TestIndirect(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`0.0%`	`0/7`
`fragment.parseForeachChild(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`0.0%`	`0/6`
`caller.execer(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`0.0%`	`0/6`
`exprParser.tertiaryCalc(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/6`
`caller.queryer(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`0.0%`	`0/6`
`xmlNode.GetAttribute(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/6`
`reflectTypeElem(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`0.0%`	`0/5`
`xmlParser.enterAttribute(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/5`
`toReflectValueElem(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/5`
`exprParser.ExitInteger(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/5`
`exprParser.ExitFloat_(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/5`
`InvalidUnmarshalError.Error(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`0.0%`	`0/5`
`reflectValueElem(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`0.0%`	`0/5`
`fragment.trimPrefixOverride(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`0.0%`	`0/5`
`valueStack.peak(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/4`
`xmlNode.HasAttribute(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/4`
`@733:8(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/4`
`_uint8(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/4`
`_uint(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/4`
`caller.context(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`0.0%`	`0/4`
`fragment.fork(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`0.0%`	`0/4`
`_uint32(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/4`
`psr.merge(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`0.0%`	`0/4`
`_uint64(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/4`
`_int64(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/4`
`_uint16(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/4`
`_int32(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/4`
`_int16(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/4`
`coverage.notCovered(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/4`
`_string(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/4`
`_int8(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/4`
`paramsStack.peak(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/4`
`_bool(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/4`
`_int(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/4`
`builtin.get(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/4`
`trimValueQuote(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/4`
`_decimal(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/4`
`isDB(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`0.0%`	`0/3`
`param.Type(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/3`
`parseFragment(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/3`
`isContext(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`0.0%`	`0/3`
`xmlNode.AddAttribute(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/3`
`xmlNode.countNode(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/3`
`xmlNodeStack.Empty(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/3`
`isTx(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`0.0%`	`0/3`
`exprValue.convertible(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/3`
`@92:8(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/2`
`_error.with(...)`	`github.com/gobatis/gobatis/executor/error.go`	`0.0%`	`0/2`
`exprParser.ExitString_(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/2`
`_error.setParent(...)`	`github.com/gobatis/gobatis/executor/error.go`	`0.0%`	`0/2`
`exprParser.ExitNil_(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/2`
`_strings.TrimSpace(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`@52:43(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`0.0%`	`0/1`
`_strings.TrimSuffix(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`exprParser.throw(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/1`
`_strings.TrimPrefix(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`exprParser.ExitMisc(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/1`
`_strings.ReplaceAll(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`logger.Warnf(...)`	`github.com/gobatis/gobatis/executor/logger.go`	`0.0%`	`0/1`
`_len(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`ParallelQuery.Query(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`0.0%`	`0/1`
`FetchQuery.Query(...)`	`github.com/gobatis/gobatis/executor/executor.go`	`0.0%`	`0/1`
`_strings.TrimRight(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`_strings.TrimLeft(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`_strings.Trim(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`_strings.Title(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`_strings.ToTitle(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`_strings.ToLower(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`_strings.ToUpper(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`_strings.Repeat(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`Tx.BeginTx(...)`	`github.com/gobatis/gobatis/executor/tx.go`	`0.0%`	`0/1`
`_strings.HasSuffix(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`Tx.Close(...)`	`github.com/gobatis/gobatis/executor/tx.go`	`0.0%`	`0/1`
`_strings.HasPrefix(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`errorListener.SyntaxError(...)`	`github.com/gobatis/gobatis/executor/error.go`	`0.0%`	`0/1`
`paramsStack.len(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/1`
`paramsStack.empty(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/1`
`isError(...)`	`github.com/gobatis/gobatis/executor/utils.go`	`0.0%`	`0/1`
`_strings.Join(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`_strings.Fields(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`valueStack.empty(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/1`
`fragment.proxy(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`0.0%`	`0/1`
`_strings.Replace(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`_strings.SplitAfter(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`_strings.Split(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`_strings.SplitAfterN(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`_strings.SplitN(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`_strings.LastIndexAny(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`_strings.IndexAny(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`_strings.LastIndex(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`_strings.ContainsRune(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`exprValue.int(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/1`
`_strings.ContainsAny(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`_strings.Contains(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`_strings.Count(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`logger.Errorf(...)`	`github.com/gobatis/gobatis/executor/logger.go`	`0.0%`	`0/1`
`exprValue.accept(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`0.0%`	`0/1`
`logger.Infof(...)`	`github.com/gobatis/gobatis/executor/logger.go`	`0.0%`	`0/1`
`fragment.parseWhere(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`0.0%`	`0/1`
`fragment.parseTrim(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`0.0%`	`0/1`
`fragment.parseSet(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`0.0%`	`0/1`
`logger.brand(...)`	`github.com/gobatis/gobatis/executor/logger.go`	`0.0%`	`0/1`
`caller.removeParam(...)`	`github.com/gobatis/gobatis/executor/fragment.go`	`0.0%`	`0/1`
`_strings.EqualFold(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`_strings.Index(...)`	`github.com/gobatis/gobatis/executor/builtin.go`	`0.0%`	`0/1`
`parserErrorStrategy.Sync(...)`	`github.com/gobatis/gobatis/executor/error.go`	`100.0%`	`0/0`
`parserErrorStrategy.ReportError(...)`	`github.com/gobatis/gobatis/executor/error.go`	`100.0%`	`0/0`
`parserErrorStrategy.ReportMatch(...)`	`github.com/gobatis/gobatis/executor/error.go`	`100.0%`	`0/0`
`errorListener.ReportContextSensitivity(...)`	`github.com/gobatis/gobatis/executor/error.go`	`100.0%`	`0/0`
`errorListener.ReportAttemptingFullContext(...)`	`github.com/gobatis/gobatis/executor/error.go`	`100.0%`	`0/0`
`@20:8(...)`	`github.com/gobatis/gobatis/executor/parser.go`	`100.0%`	`0/0`
`errorListener.ReportAmbiguity(...)`	`github.com/gobatis/gobatis/executor/error.go`	`100.0%`	`0/0`

func replaceIsolatedLessThanWithEntity

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func replaceIsolatedLessThanWithEntity(s string) string {
        // 将字符串转换为 rune 切片，以支持多字节字符
        runes := []rune(s)
        lastLeftBracket := -1
        pos := map[int]struct{}{}
        for i, r := range runes {
                switch r {
                case '<':
                        // 如果之前已经有标记的 '<'，替换它
                        if lastLeftBracket != -1 {
                                pos[lastLeftBracket] = struct{}{}
                        }
                        lastLeftBracket = i
                case '>':
                        // 清除之前标记的 '<'
                        lastLeftBracket = -1
                }
        }
        
        // 检查是否在字符串的结尾有一个标记的 '<'
        if lastLeftBracket != -1 {
                pos[lastLeftBracket] = struct{}{}
        }
        
        var r []rune
        for i := range runes {
                if _, ok := pos[i]; ok {
                        r = append(r, []rune(lt)...)
                } else {
                        r = append(r, runes[i])
                }
        }
        
        return string(r)
}

func reflectStruct

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func reflectStruct(rt reflect.Type, rv reflect.Value, namer dialector.Namer, tag string) Row {
        
        if rv.Kind() == reflect.Ptr {
                rv = rv.Elem()
        }
        
        var r Row
        for i := 0; i < rt.NumField(); i++ {
                f := rt.Field(i)
                var n string
                if t := f.Tag.Get(tag); t != "" {
                        n = ExtractTag(t)
                } else {
                        n = namer.ColumnName(f.Name)
                }
                v := rv.Field(i)
                if !isNil(v) {
                        r = append(r, &Column{
                                column: n,
                                value:  v.Interface(),
                        })
                }
        }
        
        return r
}

func walkXMLNodes

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func walkXMLNodes(listener antlr.ParseTreeListener, tokens string) {
        lexer := xml.NewXMLLexer(antlr.NewInputStream(strings.TrimSpace(tokens)))
        lexer.RemoveErrorListeners()
        lexer.AddErrorListener(newErrorListener())
        stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
        parser := xml.NewXMLParser(stream)
        parser.BuildParseTrees = true
        parser.AddErrorListener(antlr.NewDiagnosticErrorListener(false))
        parser.SetErrorHandler(newParserErrorStrategy())
        antlr.ParseTreeWalkerDefault.Walk(listener, parser.Document())
}

func initExprParser

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func initExprParser(tokens string) (parser *expr.ExprParser) {
        lexer := expr.NewExprLexer(antlr.NewInputStream(tokens))
        lexer.RemoveErrorListeners()
        lexer.AddErrorListener(newErrorListener())
        stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
        parser = expr.NewExprParser(stream)
        parser.BuildParseTrees = true
        parser.AddErrorListener(antlr.NewDiagnosticErrorListener(false))
        parser.SetErrorHandler(newParserErrorStrategy())
        return
}

func RowsVars

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func RowsVars(rows []Row) (vars []string) {
        for i, v := range rows {
                var s []string
                for _, vv := range v {
                        s = append(s, fmt.Sprintf("#{%s%d}", vv.column, i))
                }
                vars = append(vars, fmt.Sprintf("(%s)", strings.Join(s, ",")))
        }
        return
}

func newExprParser

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func newExprParser(params ...reflect.Value) *exprParser {
        r := new(exprParser)
        r.paramsStack = newParamsStack()
        r.paramsStack.push(r.builtParams())
        r.paramsStack.push(newExprParams(params...))
        return r
}

func @347:8

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

func() {
                d = NewDefault(conn, &Raw{
                        Ctx:    f.ctx,
                        Query:  false,
                        SQL:    fmt.Sprintf("close %s", cursor),
                        Params: nil,
                })
                err = AddError(err, d.Execute(logger, pos, trace, debug, affect, nil))
                
                now := time.Now()
                err = AddError(err, tx.Commit())
                
                logger.Trace(pos, conn.TraceId(), true, err, &SQLTrace{
                        Trace:        trace,
                        Debug:        debug,
                        BeginAt:      now,
                        RawSQL:       "commit",
                        PlainSQL:     "commit",
                        RowsAffected: 0,
                })
        }

func newRowMap

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func newRowMap(columns []string, values []interface{}) rowMap {
        m := rowMap{}
        for i, v := range columns {
                m[v] = values[i]
        }
        return m
}

func isNil

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func isNil(v reflect.Value) bool {
        switch v.Kind() {
        case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice, reflect.UnsafePointer:
                if v.IsNil() {
                        return true
                }
        }
        return false
}

func RowsParams

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func RowsParams(rows []Row) (params []Param) {
        for i, v := range rows {
                for _, vv := range v {
                        params = append(params, Param{
                                Name:  fmt.Sprintf("%s%d", vv.column, i),
                                Value: vv.value,
                        })
                }
                
        }
        return
}

func InsertBatch.Query

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

func (i *InsertBatch) Query() bool {
        for _, v := range i.raws {
                if v.Query {
                        return v.Query
                }
        }
        return false
}

func builtin.is

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

func (p *builtin) is(name string) bool {
        p.mu.RLock()
        defer p.mu.RUnlock()
        _, ok := p._map[name]
        return ok
}

func xmlNode.AddNode

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *xmlNode) AddNode(node *xmlNode) {
        if p.nodesCount == nil {
                p.nodesCount = map[string]int{}
        }
        p.nodesCount[node.Name]++
        p.Nodes = append(p.Nodes, node)
}

func Extract

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func Extract[T any, V any](items []T, fn func(item T) V) []V {
        var r []V
        for _, v := range items {
                r = append(r, fn(v))
        }
        return r
}

func reflectRow

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func reflectRow(columns []string, row []interface{}, pv reflect.Value, first bool) (bool, error) {
        
        switch pv.Kind() {
        case reflect.Slice, reflect.Array:
                return false, setArray(pv, newRowMap(columns, row))
        case reflect.Struct:
                return true, setStruct(pv, newRowMap(columns, row))
        }
        return true, setValue(pv, row[0])
}

func newParamParser

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func newParamParser(file string) *paramParser {
        r := new(paramParser)
        r.coverage = newCoverage()
        r.file = file
        return r
}

func xmlNodeStack.Len

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *xmlNodeStack) Len() int {
        p.lock.RLock()
        defer p.lock.RUnlock()
        return p.list.Len()
}

func exprParams.set

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParams) set(params ...reflect.Value) {
        p.values = make([]exprValue, 0)
        for _, v := range params {
                p.values = append(p.values, exprValue{
                        value: v.Interface(),
                })
        }
}

func RowColumns

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func RowColumns(row Row, namer dialector.Namer) (columns []string) {
        for _, v := range row {
                columns = append(columns, namer.ReservedName(v.column))
        }
        return
}

func fragment.parseParams

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

func (p *fragment) parseParams(tokens string) []*param {
        parser := newParamParser(p.node.File)
        parser.walkMethods(initExprParser(tokens))
        return parser.params
}

func exprParser.addVar

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParser) addVar(_expr string, _var interface{}) {
        _var = cast.Indirect(_var)
        p.vars = append(p.vars, _var)
        p.exprs = append(p.exprs, _expr)
}

func toSnakeCase

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func toSnakeCase(s string) string {
        var re = regexp.MustCompile(`([^A-Z_])([A-Z])`)
        snakeStr := re.ReplaceAllString(s, "${1}_${2}")
        return strings.ToLower(snakeStr)
}

func fragment.parseBlocks

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

func (p *fragment) parseBlocks(parser *exprParser, node *xmlNode, res *psr) {
        for _, child := range node.Nodes {
                p.parseBlock(parser, child, res)
        }
        return
}

func xmlParser.enterElement

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *xmlParser) enterElement(c *xml.ElementContext) {
        name := c.Name(0)
        //if p.depth == 0 {
        //        if name.GetText() != p.rootElement.Name {
        //                throw(p.file, c, parseMapperErr).format("top level element %s unsupported", name.GetText())
        //        }
        //}
        p.stack.Push(newXMLNode(p.file, name.GetText(), c, name.GetSymbol()))
        p.depth++
}

func xmlNodeStack.Push

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *xmlNodeStack) Push(value *xmlNode) {
        p.lock.Lock()
        defer p.lock.Unlock()
        p.list.PushBack(value)
}

func Default.scan

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

func (d *Default) scan(s *scanner, f func(Scanner) error) error {
        if f == nil {
                return nil
        }
        return f(s)
}

func newXMLStack

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func newXMLStack() *xmlNodeStack {
        l := list.New()
        lock := &sync.RWMutex{}
        return &xmlNodeStack{l, lock}
}

func RowParams

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func RowParams(row Row) (params []Param) {
        for _, v := range row {
                params = append(params, Param{
                        Name:  v.column,
                        Value: v.value,
                })
        }
        return
}

func RowVars

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func RowVars(row Row) (vars []string) {
        for _, v := range row {
                vars = append(vars, fmt.Sprintf("#{%s}", v.column))
        }
        return
}

func newExprParams

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func newExprParams(params ...reflect.Value) *exprParams {
        r := &exprParams{}
        r.set(params...)
        return r
}

func init

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func init() {
        errorType = reflect.TypeOf((*error)(nil)).Elem()
        scannerType = reflect.TypeOf((*sql.Scanner)(nil)).Elem()
        valuerType = reflect.TypeOf((*Valuer)(nil)).Elem()
}

func ParallelQuery.Execute

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

func (p *ParallelQuery) Execute(logger Logger, pos string, trace, debug bool, affect any, _ func(Scanner) error) error {
        d := NewDefault(p.Conn, p.Raw)
        return d.Execute(logger, pos, trace, debug, affect, func(s Scanner) error {
                return s.Scan(p.Dest)
        })
}

func @253:8

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

func() {
                if d.rows != nil {
                        err = AddError(err, d.rows.Close())
                }
        }

func coverage.add

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *coverage) add(ctx antlr.ParserRuleContext) {
        for i := ctx.GetStart().GetTokenIndex(); i <= ctx.GetStop().GetTokenIndex(); i++ {
                p.scan[i] = true
        }
}

func newValueStack

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

791	`func newValueStack() *valueStack {`
792	`l := list.New()`
793	`return &valueStack{l}`
794	`}`

func @113:8

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

113	`func() {`
114	`e := recover()`
115	`err = castRecoverError(p.node.File, e)`
116	`}`

func newParamsStack

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

906	`func newParamsStack() *paramsStack {`
907	`l := list.New()`
908	`return &paramsStack{l}`
909	`}`

func xmlParser.ExitEveryRule

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *xmlParser) ExitEveryRule(ctx antlr.ParserRuleContext) {
        switch ctx.GetRuleIndex() {
        case xml.XMLParserRULE_element:
                p.exitElement(nil)
        }
}

func parserErrorStrategy.RecoverInline

Back

In /Users/kun/gobatis/gobatis/executor/error.go:

153	`func (p *parserErrorStrategy) RecoverInline(recognizer antlr.Parser) antlr.Token {`
154	`p.Recover(recognizer, antlr.NewInputMisMatchException(recognizer))`
155	`return nil`
156	`}`

func parserErrorStrategy.Recover

Back

In /Users/kun/gobatis/gobatis/executor/error.go:

func (p *parserErrorStrategy) Recover(recognizer antlr.Parser, e antlr.RecognitionException) {
        // TODO handle syntax error detail
        context := recognizer.GetParserRuleContext()
        throw("", context, syntaxErr).format("syntax error")
}

func _error.format

Back

In /Users/kun/gobatis/gobatis/executor/error.go:

71	`func (p *_error) format(format string, args ...interface{}) {`
72	`p.message = fmt.Sprintf(format, args...)`
73	`panic(p)`
74	`}`

func @1209:8

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

1209	`func() {`
1210	`e := recover()`
1211	`err = castRecoverError(p.file, e)`
1212	`}`

func newErrorListener

Back

In /Users/kun/gobatis/gobatis/executor/error.go:

170	`func newErrorListener() *errorListener {`
171	`return new(errorListener)`
172	`}`

func newXMLNode

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func newXMLNode(file, name string, ctx antlr.ParserRuleContext, token antlr.Token) *xmlNode {
        return &xmlNode{
                File:  file,
                Name:  name,
                ctx:   ctx,
                start: token,
        }
}

func TrimColumns

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

611	`func TrimColumns(s string) string {`
612	`return strings.TrimSuffix(s, ",")`
613	`}`

func coverage.setTotal

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

196	`func (p *coverage) setTotal(total int) {`
197	`p.total = total`
198	`}`

func init

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

func init() {
        _builtin = &builtin{
                mu: sync.RWMutex{},
                _map: map[string]interface{}{
                        "len":     _len,
                        "int":     _int,
                        "int8":    _int8,
                        "int16":   _int16,
                        "int32":   _int32,
                        "int64":   _int64,
                        "uint":    _uint,
                        "uint8":   _uint8,
                        "uint16":  _uint16,
                        "uint32":  _uint32,
                        "uint64":  _uint64,
                        "decimal": _decimal,
                        "bool":    _bool,
                        "string":  _string,
                        "strings": _strings{},
                },
        }
}

func valueStack.push

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

796	`func (p valueStack) push(value exprValue) {`
797	`p.list.PushBack(value)`
798	`}`

func valueStack.len

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

822	`func (p *valueStack) len() int {`
823	`return p.list.Len()`
824	`}`

func NewDB

Back

In /Users/kun/gobatis/gobatis/executor/db.go:

7	`func NewDB(db sql.Conn, traceId string) DB {`
8	`return &DB{Conn: db, traceId: traceId}`
9	`}`

func DB.TraceId

Back

In /Users/kun/gobatis/gobatis/executor/db.go:

18	`func (d *DB) TraceId() string {`
19	`return d.traceId`
20	`}`

func DB.IsTx

Back

In /Users/kun/gobatis/gobatis/executor/db.go:

22	`func (d *DB) IsTx() bool {`
23	`return false`
24	`}`

func throw

Back

In /Users/kun/gobatis/gobatis/executor/error.go:

54	`func throw(file string, ctx antlr.ParserRuleContext, code int) *_error {`
55	`return &_error{file: file, ctx: ctx, code: code}`
56	`}`

func exprParser.EnterOperand

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

1002	`func (p exprParser) EnterOperand(ctx expr.OperandContext) {`
1003	`p.coverage.add(ctx)`
1004	`}`

func coverage.len

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

206	`func (p *coverage) len() int {`
207	`return len(p.scan)`
208	`}`

func exprParser.EnterExpressions

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

994	`func (p exprParser) EnterExpressions(ctx expr.ExpressionsContext) {`
995	`p.coverage.setTotal(ctx.GetStop().GetTokenIndex() + 1)`
996	`}`

func coverage.covered

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

210	`func (p *coverage) covered() bool {`
211	`return p.total == p.len()`
212	`}`

func exprParser.builtParams

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

990	`func (p exprParser) builtParams() exprParams {`
991	`return newExprParams()`
992	`}`

func NewFetchQuery

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

289	`func NewFetchQuery(ctx context.Context, conn Conn, raw Raw, limit uint) FetchQuery {`
290	`return &FetchQuery{ctx: ctx, conn: conn, raw: raw, limit: limit}`
291	`}`

func newParserErrorStrategy

Back

In /Users/kun/gobatis/gobatis/executor/error.go:

139	`func newParserErrorStrategy() *parserErrorStrategy {`
140	`return &parserErrorStrategy{BailErrorStrategy: antlr.NewBailErrorStrategy()}`
141	`}`

func scanner.RowsAffected

Back

In /Users/kun/gobatis/gobatis/executor/scanner.go:

24	`func (s *scanner) RowsAffected() int64 {`
25	`return s.rowsAffected`
26	`}`

func scanner.LastInsertId

Back

In /Users/kun/gobatis/gobatis/executor/scanner.go:

28	`func (s *scanner) LastInsertId() int64 {`
29	`return s.lastInsertId`
30	`}`

func @284:54

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

284	`func(s Scanner) error {`
285	`return s.Scan(p.Dest)`
286	`}`

func logger.Debugf

Back

In /Users/kun/gobatis/gobatis/executor/logger.go:

71	`func (l logger) Debugf(format string, a ...any) {`
72	`syslog.Printf(format, a...)`
73	`}`

func Tx.IsTx

Back

In /Users/kun/gobatis/gobatis/executor/tx.go:

27	`func (t *Tx) IsTx() bool {`
28	`return true`
29	`}`

func newCoverage

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func newCoverage() *coverage {
        return &coverage{
                scan: map[int]bool{},
        }
}

func paramsStack.push

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

911	`func (p paramsStack) push(value exprParams) {`
912	`p.list.PushBack(value)`
913	`}`

func Tx.TraceId

Back

In /Users/kun/gobatis/gobatis/executor/tx.go:

19	`func (t *Tx) TraceId() string {`
20	`return t.traceId`
21	`}`

func DefaultLogger

Back

In /Users/kun/gobatis/gobatis/executor/logger.go:

21	`func DefaultLogger() Logger {`
22	`return &logger{}`
23	`}`

func insertBatchScanner.RowsAffected

Back

In /Users/kun/gobatis/gobatis/executor/scanner.go:

105	`func (i *insertBatchScanner) RowsAffected() int64 {`
106	`return i.rowsAffected`
107	`}`

func NewDefault

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

23	`func NewDefault(conn Conn, raw Raw) Default {`
24	`return &Default{conn: conn, raw: raw, clean: true}`
25	`}`

func Default.Query

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

40	`func (d *Default) Query() bool {`
41	`return d.raw.Query`
42	`}`

func @208:62

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

208	`func(s Scanner) error {`
209	`return scan(s)`
210	`}`

func NewTx

Back

In /Users/kun/gobatis/gobatis/executor/tx.go:

8	`func NewTx(tx sql.Tx, traceID string) Tx {`
9	`return &Tx{Tx: tx, traceId: traceID}`
10	`}`

func insertBatchScanner.LastInsertId

Back

In /Users/kun/gobatis/gobatis/executor/scanner.go:

109	`func (i *insertBatchScanner) LastInsertId() int64 {`
110	`return i.lastInsertId`
111	`}`

func NewInsertBatch

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

148	`func NewInsertBatch(ctx context.Context, conn Conn, raws []Raw) InsertBatch {`
149	`return &InsertBatch{ctx: ctx, conn: conn, raws: raws}`
150	`}`

func paramParser.EnterParamDecl

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *paramParser) EnterParamDecl(ctx *expr.ParamDeclContext) {
        var name string
        if ctx.IDENTIFIER() != nil {
                name = ctx.IDENTIFIER().GetText()
                if _builtin.is(name) {
                        throw(p.file, ctx, parameterConflictWithBuiltInErr).format("'%s' conflict with builtin", name)
                }
        }
        var _type string
        if ctx.ParamType() != nil {
                _type = ctx.ParamType().GetText()
        }
        slice := false
        if _type == "" {
                _type = reflect.Interface.String()
        } else {
                _type, slice = handleSlice(_type)
        }
        p.addParam(ctx, name, _type, slice)
        p.index++
}

func logger.Trace

Back

In /Users/kun/gobatis/gobatis/executor/logger.go:

func (l logger) Trace(pos, traceId string, tx bool, err error, tr *SQLTrace) {
        if !tr.Trace && !tr.Debug && err == nil {
                return
        }
        info := &strings.Builder{}
        var f func(format string, a ...any)
        if err != nil {
                f = l.Errorf
        } else {
                f = l.Debugf
        }
        if traceId != "" {
                traceId = fmt.Sprintf("[%s]", color.CyanString(traceId))
        }
        var t string
        if tx {
                t = fmt.Sprintf("[%s]", color.MagentaString("tx"))
        }
        if pos == "" {
                pos = CallFuncPos(5)
        }
        info.WriteString(fmt.Sprintf("%s%s %s", traceId, t, color.RedString(pos)))
        if err != nil {
                info.WriteString(color.RedString(fmt.Sprintf(" ERROR: %s", err.Error())))
        }
        
        if tr != nil {
                cost := time.Since(tr.BeginAt)
                info.WriteString(fmt.Sprintf("\n%s %s %s",
                        color.YellowString(fmt.Sprintf("[%s]", cost)),
                        color.BlueString(fmt.Sprintf("[rows:%d]", tr.RowsAffected)),
                        tr.RawSQL,
                ))
        }
        f(info.String())
}

func fragment.parseSql

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

func (p *fragment) parseSql(parser *exprParser, node *xmlNode, res *psr) {
        chars := []rune(node.Text)
        begin := false
        inject := false
        var from int
        var next int
        var s string
        for i := 0; i < len(chars); i++ {
                if !begin {
                        next = i + 1
                        if (chars[i] == 35 || chars[i] == 36) && next <= len(chars)-1 && chars[next] == 123 {
                                if chars[i] == 36 {
                                        inject = true
                                }
                                begin = true
                                i++
                                from = i + 1
                                continue
                        } else {
                                s += string(chars[i])
                        }
                } else if chars[i] == 125 {
                        _expr := string(chars[from:i])
                        r, _, err := parser.parseExpression(node.ctx, _expr)
                        if err != nil {
                                panic(err)
                        }
                        if inject {
                                s += fmt.Sprintf("%v", cast.Indirect(r))
                        } else {
                                parser.varIndex++
                                s += fmt.Sprintf("$%d", parser.varIndex)
                                parser.addVar(_expr, r)
                        }
                        begin = false
                        inject = false
                }
        }

        // to avoid useless space
        res.sql += s
}

func ReflectRows

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func ReflectRows(v any, namer dialector.Namer, tag string) (rows []Row, err error) {
        
        rv := reflect.ValueOf(v)
        if rv.Kind() == reflect.Ptr {
                rv = rv.Elem()
        }
        
        rt := rv.Type()
        multiple := false
        
        if rv.Kind() == reflect.Slice || rv.Kind() == reflect.Array {
                multiple = true
                rt = rv.Type().Elem()
        }
        
        if rt.Kind() == reflect.Ptr {
                rt = rt.Elem()
        }
        
        if rt.Kind() != reflect.Struct {
                err = fmt.Errorf("only accept struct, got: %s", rt.Kind())
                return
        }
        
        if multiple {
                for i := 0; i < rv.Len(); i++ {
                        rows = append(rows, reflectStruct(rt, rv.Index(i), namer, tag))
                }
        } else {
                rows = append(rows, reflectStruct(rt, rv, namer, tag))
        }
        
        return
}

func setValue

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func setValue(pv reflect.Value, v any) error {
        
        if t := reflect.New(pv.Type()); t.Type().Implements(scannerType) {
                s := t.Interface().(sql.Scanner)
                err := s.Scan(v)
                if err != nil {
                        return err
                }
                pv.Set(t.Elem())
                return nil
        }
        
        vv := reflect.ValueOf(v)
        
        switch vv.Kind() {
        case reflect.Bool:
                return setBool(pv, vv)
        case reflect.Int,
                reflect.Int8,
                reflect.Int16,
                reflect.Int32,
                reflect.Int64,
                reflect.Uint,
                reflect.Uint8,
                reflect.Uint16,
                reflect.Uint32,
                reflect.Uint64,
                reflect.Float32,
                reflect.Float64:
                return setNumber(pv, vv)
        case reflect.String:
                return setString(pv, vv)
        }
        
        switch pv.Interface().(type) {
        case time.Time:
                r, err := cast.ToTimeE(v)
                if err != nil {
                        return err
                }
                
                pv.Set(reflect.ValueOf(r))
        }
        
        return nil
}

func getText

Back

In /Users/kun/gobatis/gobatis/executor/error.go:

func getText(ctx antlr.ParserRuleContext) string {

        if ctx.GetChildCount() == 0 {
                return ""
        }

        var s string
        for _, child := range ctx.GetChildren() {
                _, ok := child.(*xml.AttributeContext)
                if ok {
                        s += " " + child.(antlr.ParseTree).GetText()
                } else {
                        s += child.(antlr.ParseTree).GetText()
                }
        }

        return s
}

func InsertBatch.execute

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

func (i *InsertBatch) execute(conn Conn, raw *Raw, logger Logger, pos string, trace, debug bool, ibs *insertBatchScanner, scan func(Scanner) error) (err error) {
        d := NewDefault(conn, raw)
        d.clean = false
        err = d.Execute(logger, pos, trace, debug, nil, nil)
        if err != nil {
                return
        }
        defer func() {
                if d.rows != nil {
                        err = AddError(err, d.rows.Close())
                }
        }()
        if d.result != nil {
                lastInsertId, _ := d.result.LastInsertId()
                rowsAffected, _ := d.result.RowsAffected()
                ibs.lastInsertId = lastInsertId
                ibs.rowsAffected += rowsAffected
        }
        ibs.rows = d.rows
        err = scan(ibs)
        if err != nil {
                return
        }
        return
}

func exprParser.realVars

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParser) realVars() ([]interface{}, error) {
        for i, v := range p.vars {
                n, ok := v.(Valuer)
                if ok {
                        vv, err := n.Value()
                        if err != nil {
                                return nil, err
                        }
                        p.vars[i] = vv
                }
        }
        return p.vars, nil
}

func isStructSlice

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func isStructSlice(r reflect.Type) bool {
        if r.Kind() != reflect.Slice {
                return false
        }
        elem := r.Elem()
        for {
                if elem.Kind() != reflect.Ptr {
                        break
                }
                elem = elem.Elem()
        }
        return elem.Kind() == reflect.Struct
}

func @71:8

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

func() {
                if d.clean {
                        if d.rows != nil {
                                err = AddError(err, d.rows.Close())
                        }
                        if !d.conn.IsTx() {
                                err = AddError(err, d.conn.Close())
                        }
                }
                if s == nil {
                        s = &scanner{}
                }
                logger.Trace(pos, d.conn.TraceId(), d.conn.IsTx(), err, &SQLTrace{
                        Trace:        trace,
                        Debug:        debug,
                        BeginAt:      beginAt,
                        RawSQL:       d.sql,
                        PlainSQL:     "",
                        RowsAffected: s.rowsAffected,
                })
        }

func FetchQuery.Execute

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

func (f *FetchQuery) Execute(logger Logger, pos string, trace, debug bool, affect any, scan func(Scanner) error) (err error) {
        
        conn := f.conn
        
        var tx *sql.Tx
        defer func() {
                if tx != nil {
                        if err != nil {
                                now := time.Now()
                                err = AddError(err, tx.Rollback())
                                logger.Trace(pos, conn.TraceId(), true, err, &SQLTrace{
                                        Trace:        trace,
                                        Debug:        debug,
                                        BeginAt:      now,
                                        RawSQL:       "rollback",
                                        PlainSQL:     "rollback",
                                        RowsAffected: 0,
                                })
                        }
                }
        }()
        
        if !conn.IsTx() {
                tx, err = conn.BeginTx(f.ctx, nil)
                if err != nil {
                        return
                }
                conn = NewTx(tx, conn.TraceId())
        }
        
        cursor := fmt.Sprintf("curosr_%s", conn.TraceId())
        
        d := NewDefault(conn, &Raw{
                Ctx:    f.ctx,
                Query:  false,
                SQL:    fmt.Sprintf("declare %s cursor for %s", cursor, f.raw.SQL),
                Params: f.raw.Params,
        })
        err = d.Execute(logger, pos, trace, debug, affect, nil)
        if err != nil {
                return
        }
        
        defer func() {
                d = NewDefault(conn, &Raw{
                        Ctx:    f.ctx,
                        Query:  false,
                        SQL:    fmt.Sprintf("close %s", cursor),
                        Params: nil,
                })
                err = AddError(err, d.Execute(logger, pos, trace, debug, affect, nil))
                
                now := time.Now()
                err = AddError(err, tx.Commit())
                
                logger.Trace(pos, conn.TraceId(), true, err, &SQLTrace{
                        Trace:        trace,
                        Debug:        debug,
                        BeginAt:      now,
                        RawSQL:       "commit",
                        PlainSQL:     "commit",
                        RowsAffected: 0,
                })
        }()
        
        for {
                d = NewDefault(conn, &Raw{
                        Ctx:    f.ctx,
                        Query:  true,
                        SQL:    fmt.Sprintf("fetch forward %d from %s", f.limit, cursor),
                        Params: nil,
                })
                var rowsAffected int64
                err = d.Execute(logger, pos, trace, debug, affect, func(s Scanner) error {
                        e := scan(s)
                        if e != nil {
                                return e
                        }
                        rowsAffected = s.RowsAffected()
                        return nil
                })
                if err != nil {
                        return
                }
                if rowsAffected == 0 {
                        break
                }
        }
        
        return
}

func SplitStructSlice

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func SplitStructSlice(data any, limit int) ([]any, error) {
        val := reflect.ValueOf(data)
        
        if !isStructSlice(val.Type()) {
                return nil, fmt.Errorf("expected a struct slice, got %s", val.Type())
        }
        
        sliceLen := val.Len()
        if sliceLen == 0 {
                return nil, fmt.Errorf("got empty slice")
        }
        
        var result []any
        for i := 0; i < sliceLen; i += limit {
                end := i + limit
                if end > sliceLen {
                        end = sliceLen
                }
                
                subSlice := val.Slice(i, end)
                result = append(result, subSlice.Interface())
        }
        
        return result, nil
}

func xmlNodeStack.Pop

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *xmlNodeStack) Pop() *xmlNode {
        p.lock.Lock()
        defer p.lock.Unlock()
        e := p.list.Back()
        if e != nil {
                p.list.Remove(e)
                return e.Value.(*xmlNode)
        }
        return nil
}

func xmlNodeStack.Peak

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *xmlNodeStack) Peak() *xmlNode {
        p.lock.RLock()
        defer p.lock.RUnlock()
        e := p.list.Back()
        if e != nil {
                return e.Value.(*xmlNode)
        }
        return nil
}

func paramParser.addParam

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *paramParser) addParam(ctx antlr.ParserRuleContext, name, _type string, slice bool) {
        if p.check == nil {
                p.check = map[string]bool{}
        }
        if _, ok := p.check[name]; ok {
                throw(p.file, ctx, checkParameterErr).format("duplicated parameter '%s'", name)
        }
        p.check[name] = true
        p.params = append(p.params, &param{name: name, rt: _type, slice: slice})
}

func affectConstraint.Check

Back

In /Users/kun/gobatis/gobatis/executor/constraint.go:

func (a affectConstraint) Check(rows int) error {
        if a.sign != "" {
                if rows < a.rows {
                        return fmt.Errorf("%w: expect affected rows >= %d, got %d", RowsAffectedCheckErr, a.rows, rows)
                }
        } else {
                if rows != a.rows {
                        return fmt.Errorf("%w: expect affected rows = %d, got %d", RowsAffectedCheckErr, a.rows, rows)
                }
        }
        return nil
}

func Default.Execute

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

func (d *Default) Execute(logger Logger, pos string, trace, debug bool, affect any, scan func(Scanner) error) (err error) {
        
        beginAt := time.Now()
        
        var params []*param
        var vars []reflect.Value
        for _, v := range d.raw.Params {
                params = append(params, &param{
                        name: v.Name,
                        rt:   reflect.TypeOf(v.Value).Name(),
                })
                vars = append(vars, reflect.ValueOf(v.Value))
        }
        
        var node *xmlNode
        node, err = parseSQL("test.file", fmt.Sprintf("<sql>%s</sql>", d.raw.SQL))
        if err != nil {
                return
        }
        
        d.fragment = &fragment{node: node, in: params}
        d.sql, d.exprs, d.vars, d.dynamic, err = d.fragment.parseStatement(vars...)
        if err != nil {
                return
        }
        var s *scanner
        
        defer func() {
                if d.clean {
                        if d.rows != nil {
                                err = AddError(err, d.rows.Close())
                        }
                        if !d.conn.IsTx() {
                                err = AddError(err, d.conn.Close())
                        }
                }
                if s == nil {
                        s = &scanner{}
                }
                logger.Trace(pos, d.conn.TraceId(), d.conn.IsTx(), err, &SQLTrace{
                        Trace:        trace,
                        Debug:        debug,
                        BeginAt:      beginAt,
                        RawSQL:       d.sql,
                        PlainSQL:     "",
                        RowsAffected: s.rowsAffected,
                })
        }()
        
        if d.raw.Query {
                d.rows, err = d.conn.QueryContext(d.raw.Ctx, d.sql, d.vars...)
                if err != nil {
                        return
                }
        } else {
                d.result, err = d.conn.ExecContext(d.raw.Ctx, d.sql, d.vars...)
                if err != nil {
                        return
                }
        }
        
        if d.raw.Query {
                s = &scanner{
                        rows:         d.rows,
                        rowsAffected: 0,
                        lastInsertId: 0,
                }
                err = d.scan(s, scan)
        } else {
                rowsAffected, _ := d.result.RowsAffected()
                lastInsertId, _ := d.result.LastInsertId()
                s = &scanner{
                        rows:         nil,
                        rowsAffected: rowsAffected,
                        lastInsertId: lastInsertId,
                }
                err = d.scan(s, scan)
        }
        if err != nil {
                return
        }
        
        if affect != nil {
                var ac *affectConstraint
                ac, err = newAffectConstraint(affect)
                if err != nil {
                        return
                }
                err = ac.Check(int(s.rowsAffected))
                if err != nil {
                        return
                }
        }
        
        return
}

func InsertBatch.Execute

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

func (i *InsertBatch) Execute(logger Logger, pos string, trace, debug bool, affect any, scan func(Scanner) error) (err error) {
        
        conn := i.conn
        
        var tx *sql.Tx
        defer func() {
                if tx != nil {
                        if err != nil {
                                now := time.Now()
                                err = AddError(err, tx.Rollback())
                                logger.Trace(pos, conn.TraceId(), true, err, &SQLTrace{
                                        Trace:        trace,
                                        Debug:        debug,
                                        BeginAt:      now,
                                        RawSQL:       "rollback",
                                        PlainSQL:     "rollback",
                                        RowsAffected: 0,
                                })
                        }
                }
        }()
        
        if !conn.IsTx() {
                now := time.Now()
                tx, err = conn.BeginTx(i.ctx, nil)
                if err != nil {
                        return
                }
                conn = NewTx(tx, conn.TraceId())
                logger.Trace(pos, conn.TraceId(), true, err, &SQLTrace{
                        Trace:        trace,
                        Debug:        debug,
                        BeginAt:      now,
                        RawSQL:       "begin",
                        PlainSQL:     "begin",
                        RowsAffected: 0,
                })
        }
        
        ibs := &insertBatchScanner{}
        for _, raw := range i.raws {
                err = i.execute(conn, raw, logger, pos, trace, debug, ibs, func(s Scanner) error {
                        return scan(s)
                })
                if err != nil {
                        return
                }
        }
        
        if affect != nil {
                var ac *affectConstraint
                ac, err = newAffectConstraint(affect)
                if err != nil {
                        return
                }
                err = ac.Check(int(ibs.rowsAffected))
                if err != nil {
                        return
                }
        }
        
        now := time.Now()
        err = tx.Commit()
        if err != nil {
                return
        }
        
        logger.Trace(pos, conn.TraceId(), true, err, &SQLTrace{
                Trace:        trace,
                Debug:        debug,
                BeginAt:      now,
                RawSQL:       "commit",
                PlainSQL:     "commit",
                RowsAffected: 0,
        })
        
        return
}

func scanner.Scan

Back

In /Users/kun/gobatis/gobatis/executor/scanner.go:

func (s *scanner) Scan(ptr any) (err error) {
        if s.rows == nil {
                err = fmt.Errorf("scan rows error: rows is nil")
                return
        }
        var pv reflect.Value
        if ptr != nil {
                pv = reflect.ValueOf(ptr)
                if pv.Kind() != reflect.Pointer || pv.IsNil() {
                        return &InvalidUnmarshalError{pv.Type()}
                }
                pv = indirect(pv, false)
        }
        columns, err := s.rows.Columns()
        if err != nil {
                return
        }
        l := len(columns)
        first := false
        s.rowsAffected = 0
        for s.rows.Next() {
                s.rowsAffected++
                if ptr != nil {
                        row := make([]interface{}, l)
                        pointers := make([]interface{}, l)
                        for i, _ := range columns {
                                pointers[i] = &row[i]
                        }
                        err = s.rows.Scan(pointers...)
                        if err != nil {
                                return
                        }
                        if !first {
                                first = true
                        }
                        var end bool
                        end, err = reflectRow(columns, row, pv, first)
                        if err != nil {
                                return
                        }
                        if end {
                                break
                        }
                }
        }
        //if s.rowsAffected == 0 {
        //        err = sql.ErrNoRows
        //        return
        //}
        return
}

func exprParser.parseExpression

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParser) parseExpression(nodeCtx antlr.ParserRuleContext,
        expression string) (result interface{}, static bool, err error) {

        defer func() {
                e := recover()
                err = castRecoverError(p.file, e)
        }()

        p.nodeCtx = nodeCtx
        p.static = false
        p.valueStack = newValueStack()
        p.coverage = newCoverage()

        parser := initExprParser(expression)
        antlr.ParseTreeWalkerDefault.Walk(p, parser.Expressions())

        if !p.coverage.covered() {
                p.throw(nil, parseCoveredErr).format(
                        "parse expression token not covered: %d/%d",
                        p.coverage.len(), p.coverage.total,
                )
        }

        if p.valueStack.len() != 1 {
                p.throw(nil, popResultErr).format("expect result stack length: 1, got %d", p.valueStack.len())
        }
        v, err := p.valueStack.pop()
        if err != nil {
                p.throw(nil, popResultErr).with(err)
        }
        result = v.value
        static = p.static

        return
}

func fragment.parseStatement

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

func (p *fragment) parseStatement(args ...reflect.Value) (sql string, exprs []string, vars []interface{},
        dynamic bool, err error) {

        defer func() {
                e := recover()
                err = castRecoverError(p.node.File, e)
        }()

        if len(p.in) != len(args) {
                throw(p.node.File, p.node.ctx, parasFragmentErr).format("expect %d args, got %d", len(p.in), len(args))
        }

        parser := newExprParser(args...)
        for i, v := range p.in {
                err = parser.paramsStack.list.Front().Next().Value.(*exprParams).bind(v, i)
                if err != nil {
                        throw(p.node.File, p.node.ctx, parasFragmentErr).with(err)
                }
        }
        res := new(psr)
        p.parseBlocks(parser, p.node, res)

        sql = res.sql
        vars, err = parser.realVars()
        if err != nil {
                return
        }
        exprs = parser.exprs
        dynamic = res.dynamic

        return
}

func setStruct

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func setStruct(pv reflect.Value, r rowMap) (err error) {
        
        //var tags map[string]struct{}
        //if first {
        //        tags = map[string]struct{}{}
        //}
        
        t := pv.Type()
        for i := 0; i < t.NumField(); i++ {
                n := prepareFieldName(t.Field(i))
                //if first {
                //        if _, ok := tags[n]; ok {
                //                return fmt.Errorf("field tag: '%s' is duplicated in struct: '%s'", n, _type)
                //        }
                //        tags[n] = struct{}{}
                //}
                v, ok := r[n]
                if !ok {
                        // TODO
                        //if !false {
                        //        return fmt.Errorf("no data for struct: '%s' field: '%s'", _type, _type.Field(i).Name)
                        //}
                } else if v != nil {
                        err = setValue(indirect(pv.Field(i), false), v)
                        if err != nil {
                                err = fmt.Errorf("parse column: %s value error: %w", n, err)
                                return
                        }
                }
        }
        
        return
}

func _error.Error

Back

In /Users/kun/gobatis/gobatis/executor/error.go:

func (p *_error) Error() string {
        msg := fmt.Sprintf("[ERROR %d]: %s", p.code, p.message)
        line := 0
        column := 0
        ctx := ""
        if p.parent != nil {
                line = p.parent.GetStart().GetLine()
                column = p.parent.GetStart().GetColumn()
                ctx = getText(p.parent)
        } else if p.ctx != nil {
                line = p.ctx.GetStart().GetLine()
                column = p.ctx.GetStart().GetColumn()
                ctx = getText(p.ctx)
        }
        if p.ctx != nil {
                msg += fmt.Sprintf("\n[file]: %s near line %d column %d:\n[context]: %s", p.file, line, column+1, ctx)
        }

        return msg
}

func insertBatchScanner.Scan

Back

In /Users/kun/gobatis/gobatis/executor/scanner.go:

func (i *insertBatchScanner) Scan(ptr any) error {
        rv := reflect.ValueOf(ptr)
        if rv.Elem().Type().Kind() != reflect.Slice {
                return fmt.Errorf("expect slice, got %s", rv.Elem().Type())
        }
        s := &scanner{rows: i.rows}
        err := s.Scan(ptr)
        if err != nil {
                return err
        }
        i.rowsAffected += s.rowsAffected
        i.lastInsertId = s.lastInsertId
        return nil
}

func @377:54

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

func(s Scanner) error {
                        e := scan(s)
                        if e != nil {
                                return e
                        }
                        rowsAffected = s.RowsAffected()
                        return nil
                }

func paramsStack.getVar

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *paramsStack) getVar(name string) (exprValue, bool) {
        for i := p.list.Back(); i != nil; i = i.Prev() {
                v := i.Value.(*exprParams)
                if r, ok := v.get(name); ok {
                        return r, true
                }
        }
        return exprValue{}, false
}

func setBool

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func setBool(pv reflect.Value, vv reflect.Value) (err error) {
        pv = indirect(pv, false)
        if pv.Kind() == reflect.Bool {
                pv.Set(vv)
                return nil
        }
        return fmt.Errorf("unsupport reflect type %s to %s", vv.Type(), pv.Type())
}

func setString

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func setString(pv reflect.Value, vv reflect.Value) error {
        pv = indirect(pv, false)
        if pv.Kind() == reflect.String {
                pv.Set(vv)
                return nil
        }
        return fmt.Errorf("unsupport reflect type %s to %s", vv.Type(), pv.Type())
}

func CallFuncPos

Back

In /Users/kun/gobatis/gobatis/executor/logger.go:

func CallFuncPos(skip int) string {
        i := skip
        for {
                _, file, line, ok := runtime.Caller(i)
                if !ok || i > 20 {
                        break
                }
                if !strings.Contains(file, "/gobatis/gobatis") || strings.HasSuffix(file, "_test.go") {
                        return fmt.Sprintf("%s:%d", file, line)
                }
                i++
        }
        return ""
}

func exprParser.ExitVar_

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParser) ExitVar_(ctx *expr.Var_Context) {
        p.static = false
        alias := ctx.IDENTIFIER().GetText()
        var val exprValue
        if _builtin.is(alias) {
                val = exprValue{value: _builtin.get(alias), alias: alias}
        } else {
                var ok bool
                val, ok = p.paramsStack.getVar(alias)
                if !ok {
                        p.throw(ctx, parameterNotFoundErr).format("var '%s' not found", alias)
                        return
                }
        }
        p.valueStack.push(&val)
        p.coverage.add(ctx)
}

func newAffectConstraint

Back

In /Users/kun/gobatis/gobatis/executor/constraint.go:

func newAffectConstraint(v any) (*affectConstraint, error) {
        
        switch r := v.(type) {
        case int:
                return &affectConstraint{rows: r}, nil
        case string:
                reg := regexp.MustCompile(`^([0-9]+)(\+)?$`)
                if !reg.MatchString(r) {
                        return nil, fmt.Errorf("%w; got: %s", InvalidAffectValueErr, r)
                }
                items := reg.FindStringSubmatch(r)
                var rows int64
                rows, err := strconv.ParseInt(items[1], 10, 64)
                if err != nil {
                        return nil, fmt.Errorf("db.Affect() parse value: %s to int error: %w", r, err)
                }
                return &affectConstraint{rows: int(rows), sign: items[2]}, nil
        default:
                return nil, InvalidAffectValueErr
        }
}

func handleSlice

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func handleSlice(_type string) (string, bool) {
        slice := strings.HasPrefix(_type, "[]")
        if slice {
                return strings.TrimSpace(strings.TrimPrefix(_type, "[]")), true
        }
        return _type, false
}

func prepareFieldName

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func prepareFieldName(f reflect.StructField) string {
        field := f.Tag.Get("db")
        if field == "" {
                field = toSnakeCase(f.Name)
        }
        return trimComma(field)
}

func ExtractTag

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func ExtractTag(s string) string {
        idx := strings.Index(s, ";")
        if idx == -1 {
                return s
        }
        return s[:idx]
}

func exprParams.bind

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParams) bind(expected *param, index int) error {

        if expected.name == "" {
                return fmt.Errorf("parameter name is empty")
        }

        if p.check == nil {
                p.check = map[string]int{}
        } else {
                _, ok := p.check[expected.name]
                if ok {
                        return fmt.Errorf("duplicated parameter '%s'", expected.name)
                }
        }

        vl := len(p.values) - 1
        if index < 0 || index > vl {
                return fmt.Errorf("parameter '%s' index %d out of parameters length %d", expected.name, index, vl)
        }

        ev := p.values[index]
        p.check[expected.name] = index

        if cast.IsNil(ev.value) {
                return nil
        }

        // TODO check
        //elem := toReflectValueElem(ev.value)
        //if !expected.expected(elem.Type()) {
        //        return fmt.Errorf("parameter '%s' expected '%s', got '%s'", expected.name, expected.Type(), elem.Type())
        //}

        return nil
}

func parseSQL

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func parseSQL(file, content string) (node *xmlNode, err error) {

        defer func() {
                //e := recover()
                //err = castRecoverError(file, e)
        }()

        l := &xmlParser{
                BaseParseTreeListener: nil,
                coverage:              newCoverage(),
                file:                  file,
                content:               nil,
                depth:                 0,
                stack:                 newXMLStack(),
                rootNode:              nil,
                //rootElement:           dtd.Mapper,
                elementGetter: dtd.MapperElement,
        }

        // replace single < to &lt;
        content = replaceIsolatedLessThanWithEntity(content)

        walkXMLNodes(l, content)
        if !l.coverage.covered() {
                throw(file, nil, parseCoveredErr).
                        format("parse mapper token not covered: %d/%d", l.coverage.len(), l.coverage.total)
        }

        if l.rootNode == nil {
                spew.Json(fmt.Sprintf("empty mapperCache file: %s", file))
                return
        }
        node = l.rootNode

        //spew.Json(l.rootNode)
        //for _, v := range l.rootNode.Nodes {
        //        switch v.Name {
        //        case dtd.SELECT, dtd.INSERT, dtd.DELETE, dtd.UPDATE, dtd.SQL:
        //                id := v.GetAttribute(dtd.ID)
        //                if id == "" {
        //                        throw(file, v.ctx, parseMapperErr).format("fragment: %s miss id", v.Name)
        //                }
        //                db.addFragment(file, v.ctx, id, v)
        //        }
        //}
        return
}

func xmlParser.exitElement

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *xmlParser) exitElement(_ *xml.ElementContext) {
        if p.stack.Peak() == nil {
                return
        }
        p.depth--
        child := p.stack.Pop()

        if p.stack.Len() > 0 {
                p.stack.Peak().AddNode(child)
        } else {
                p.rootNode = child
                //p.validateNode(child, p.rootElement)
        }
}

func exprParser.popBinaryOperands

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParser) popBinaryOperands() (left, right *exprValue, err error) {
        right, err = p.valueStack.pop()
        if err != nil {
                return
        }
        left, err = p.valueStack.pop()
        if err != nil {
                return
        }
        return
}

func exprParams.get

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParams) get(name string) (val exprValue, ok bool) {
        if p.check == nil {
                return
        }
        index, ok := p.check[name]
        if !ok {
                return
        }
        if index > len(p.values)-1 {
                return
        }
        ok = true
        val = p.values[index]
        return
}

func xmlParser.EnterEveryRule

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *xmlParser) EnterEveryRule(ctx antlr.ParserRuleContext) {
        switch ctx.GetRuleIndex() {
        case xml.XMLParserRULE_document:
                p.coverage.setTotal(ctx.GetStop().GetTokenIndex() + 1)
        case xml.XMLParserRULE_reference:
                p.enterReference(ctx.(*xml.ReferenceContext))
        case xml.XMLParserRULE_element:
                p.enterElement(ctx.(*xml.ElementContext))
                p.coverage.add(ctx)
        case xml.XMLParserRULE_attribute:
                p.enterAttribute(ctx.(*xml.AttributeContext))
                p.coverage.add(ctx)
        case xml.XMLParserRULE_chardata:
                p.enterChardata(ctx.(*xml.ChardataContext))
                p.coverage.add(ctx)
        case xml.XMLParserRULE_prolog, xml.XMLParserRULE_misc:
                p.coverage.add(ctx)
        }

}

func indirect

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func indirect(v reflect.Value, decodingNull bool) reflect.Value {
        // Issue #24153 indicates that it is generally not a guaranteed property
        // that you may round-trip a reflect.Value by calling Value.Addr().Elem()
        // and expect the value to still be settable for values derived from
        // unexported embedded struct fields.
        //
        // The logic below effectively does this when it first addresses the value
        // (to satisfy possible pointer methods) and continues to dereference
        // subsequent pointers as necessary.
        //
        // After the first round-trip, we set v back to the original value to
        // preserve the original RW flags contained in reflect.Value.
        v0 := v
        haveAddr := false
        
        // If v is a named type and is addressable,
        // start with its address, so that if the type has pointer methods,
        // we find them.
        if v.Kind() != reflect.Pointer && v.Type().Name() != "" && v.CanAddr() {
                haveAddr = true
                v = v.Addr()
        }
        for {
                // Load value from interface, but only if the result will be
                // usefully addressable.
                if v.Kind() == reflect.Interface && !v.IsNil() {
                        e := v.Elem()
                        if e.Kind() == reflect.Pointer && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Pointer) {
                                haveAddr = false
                                v = e
                                continue
                        }
                }
                
                if v.Kind() != reflect.Pointer {
                        break
                }
                
                if decodingNull && v.CanSet() {
                        break
                }
                
                // Prevent infinite loop if v is an interface pointing to its own address:
                //     var v interface{}
                //     v = &v
                if v.Elem().Kind() == reflect.Interface && v.Elem().Elem() == v {
                        v = v.Elem()
                        break
                }
                if v.IsNil() {
                        v.Set(reflect.New(v.Type().Elem()))
                }
                
                if haveAddr {
                        v = v0 // restore original value after round-trip Value.Addr().Elem()
                        haveAddr = false
                } else {
                        v = v.Elem()
                }
        }
        return v
}

func valueStack.pop

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *valueStack) pop() (val *exprValue, err error) {
        if p.list.Len() < 1 {
                err = fmt.Errorf("stack is empty unable to pop")
                return
        }
        e := p.list.Back()
        if e != nil {
                p.list.Remove(e)
                val = e.Value.(*exprValue)
                return
        }
        return
}

func literalEqual

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func literalEqual(pv, vv reflect.Value) error {
        if fmt.Sprintf("%v", pv.Interface()) != fmt.Sprintf("%v", vv.Interface()) {
                return fmt.Errorf("convert type %s:%v to %s:%v miss data", vv.Type(), vv.Interface(), pv.Type(), pv.Interface())
        }
        return nil
}

func xmlParser.enterChardata

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *xmlParser) enterChardata(c *xml.ChardataContext) {
        if p.stack.Peak() == nil {
                return
        }
        p.stack.Peak().AddNode(&xmlNode{File: p.file, Text: c.GetText(), ctx: c, start: c.GetStart(), textOnly: true})
}

func paramParser.walkMethods

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *paramParser) walkMethods(parser *expr.ExprParser) {
        antlr.ParseTreeWalkerDefault.Walk(p, parser.Parameters())
        if !p.coverage.covered() {
                throw(p.file, nil, parseCoveredErr).
                        format("parse mapper method not covered: %d/%d", p.coverage.len(), p.coverage.total)
        }
}

func trimComma

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func trimComma(field string) string {
        if strings.Contains(field, ",") {
                return strings.TrimSpace(strings.Split(field, ",")[0])
        }
        return field
}

func xmlParser.enterReference

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *xmlParser) enterReference(c *xml.ReferenceContext) {
        if c.EntityRef() != nil {
                v := ""
                switch c.EntityRef().GetText() {
                case "&lt;":
                        v = "<"
                case "&gt":
                        v = ">"
                case "&amp;":
                        v = "&"
                case "&apos;":
                        v = "'"
                case "&quot;":
                        v = "\""
                }
                if v != "" {
                        p.stack.Peak().AddNode(&xmlNode{File: p.file, Text: v, ctx: c, start: c.GetStart(), textOnly: true})
                        p.coverage.add(c)
                }
        }
}

func setArray

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func setArray(pv reflect.Value, r rowMap) (err error) {
        
        t := pv.Type().Elem()
        ptr := false
        if t.Kind() == reflect.Ptr {
                ptr = true
                for {
                        if t.Kind() != reflect.Ptr {
                                break
                        }
                        t = t.Elem()
                }
        }
        switch t.Kind() {
        case reflect.Struct:
                if ptr {
                        pv.Set(reflect.Append(pv, reflect.New(pv.Type().Elem().Elem())))
                } else {
                        pv.Set(reflect.Append(pv, reflect.New(pv.Type().Elem()).Elem()))
                }
                err = setStruct(indirect(pv.Index(pv.Len()-1), false), r)
                if err != nil {
                        return
                }
        default:
                // TODO 反射数组单值
                if ptr {
                        pv.Set(reflect.Append(pv, reflect.New(pv.Type().Elem().Elem())))
                } else {
                        pv.Set(reflect.Append(pv, reflect.New(pv.Type().Elem()).Elem()))
                }
                var a any
                for _, vv := range r {
                        a = vv
                }
                err = setValue(indirect(pv.Index(pv.Len()-1), false), a)
                if err != nil {
                        return
                }
                //err = fmt.Errorf("expect struct, got: %s", t.String())
                return
        }
        
        return
}

func exprParser.numericStringCalc

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParser) numericStringCalc(left, right *exprValue, ctx antlr.ParserRuleContext, op antlr.Token) {

        var err error
        var result interface{}
        switch op.GetTokenType() {
        case expr.ExprParserPLUS:
                result, err = cast.AddAnyE(left.value, right.value)
        case expr.ExprParserMINUS:
                result, err = cast.SubAnyE(left.value, right.value)
        case expr.ExprParserSTAR:
                result, err = cast.MulAnyE(left.value, right.value)
        case expr.ExprParserDIV:
                result, err = cast.DivAnyE(left.value, right.value)
        case expr.ExprParserCARET:
                result, err = cast.CaretAnyE(left.value, right.value)
        case expr.ExprParserOR:
                result, err = cast.OrAnyE(left.value, right.value)
        case expr.ExprParserMOD:
                result, err = cast.ModAnyE(left.value, right.value)
        case expr.ExprParserLSHIFT:
                result, err = cast.LeftShiftAnyE(left.value, right.value)
        case expr.ExprParserRSHIFT:
                result, err = cast.RightShiftAnyE(left.value, right.value)
        case expr.ExprParserBIT_CLEAR:
                result, err = cast.BitClearAnyE(left.value, right.value)
        default:
                p.throw(ctx, unsupportedNumericCalc).format("unsupported numeric calc")
        }
        if err != nil {
                p.throw(ctx, numericCalcErr).with(err)
        }

        p.valueStack.push(&exprValue{value: result})
}

func @309:8

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

func() {
                if tx != nil {
                        if err != nil {
                                now := time.Now()
                                err = AddError(err, tx.Rollback())
                                logger.Trace(pos, conn.TraceId(), true, err, &SQLTrace{
                                        Trace:        trace,
                                        Debug:        debug,
                                        BeginAt:      now,
                                        RawSQL:       "rollback",
                                        PlainSQL:     "rollback",
                                        RowsAffected: 0,
                                })
                        }
                }
        }

func AddError

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func AddError(err, added error) error {
        if err == nil {
                return added
        } else if added != nil {
                return fmt.Errorf("%v; %w", err, added)
        }
        return err
}

func @172:8

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

func() {
                if tx != nil {
                        if err != nil {
                                now := time.Now()
                                err = AddError(err, tx.Rollback())
                                logger.Trace(pos, conn.TraceId(), true, err, &SQLTrace{
                                        Trace:        trace,
                                        Debug:        debug,
                                        BeginAt:      now,
                                        RawSQL:       "rollback",
                                        PlainSQL:     "rollback",
                                        RowsAffected: 0,
                                })
                        }
                }
        }

func setNumber

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func setNumber(pv reflect.Value, vv reflect.Value) (err error) {
        pv = indirect(pv, false)
        switch pv.Kind() {
        case reflect.Int,
                reflect.Int8,
                reflect.Int16,
                reflect.Int32,
                reflect.Int64:
                var v int64
                if vv.CanInt() {
                        v = vv.Int()
                } else if vv.CanUint() {
                        v = int64(vv.Uint())
                } else if vv.CanFloat() {
                        v = int64(vv.Float())
                }
                pv.SetInt(v)
                err = literalEqual(pv, vv)
                if err != nil {
                        return
                }
                return
        case reflect.Uint,
                reflect.Uint8,
                reflect.Uint16,
                reflect.Uint32,
                reflect.Uint64:
                var v uint64
                if vv.CanUint() {
                        v = vv.Uint()
                } else if vv.CanInt() {
                        v = uint64(vv.Int())
                } else if vv.CanFloat() {
                        v = uint64(vv.Float())
                }
                pv.SetUint(v)
                err = literalEqual(pv, vv)
                if err != nil {
                        return
                }
                return
        case reflect.Float32,
                reflect.Float64:
                var v float64
                if vv.CanFloat() {
                        v = vv.Float()
                } else if vv.CanInt() {
                        v = float64(vv.Int())
                } else if vv.CanUint() {
                        v = float64(vv.Uint())
                }
                pv.SetFloat(v)
                //err = literalEqual(pv, vv)
                //if err != nil {
                //        return
                //}
                return
        default:
                return fmt.Errorf("unsupport reflect type %s to %s", vv.Type(), pv.Type())
        }
}

func exprParser.ExitExpression

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParser) ExitExpression(ctx *expr.ExpressionContext) {
        if ctx.GetUnary_op() != nil {
                left, err := p.valueStack.pop()
                if err != nil {
                        p.throw(ctx, popValueStackErr).with(err)
                }
                p.unaryCalc(left, ctx, ctx.GetUnary_op())
                p.coverage.add(ctx)
        } else if ctx.GetMul_op() != nil ||
                ctx.GetAdd_op() != nil ||
                ctx.GetRel_op() != nil ||
                ctx.Logical() != nil {
                left, right, err := p.popBinaryOperands()
                if err != nil {
                        p.throw(ctx, popBinaryOperandsErr).with(err)
                }
                if ctx.GetAdd_op() != nil {
                        p.numericStringCalc(left, right, ctx, ctx.GetAdd_op())
                        p.coverage.add(ctx)
                } else if ctx.GetMul_op() != nil {
                        p.numericStringCalc(left, right, ctx, ctx.GetMul_op())
                        p.coverage.add(ctx)
                } else if ctx.GetRel_op() != nil {
                        p.relationCalc(left, right, ctx, ctx.GetRel_op())
                        p.coverage.add(ctx)
                } else if ctx.Logical() != nil {
                        p.static = false
                        p.logicCalc(left, right, ctx, ctx.Logical().GetStart())
                        p.coverage.add(ctx)
                }
        } else if ctx.GetTertiary() != nil {
                p.static = false
                condition, left, right, err := p.popTertiaryOperands()
                if err != nil {
                        p.throw(ctx, popTertiaryOperandsErr).with(err)
                }
                p.coverage.add(ctx)
                p.tertiaryCalc(condition, left, right, ctx)
        }
}

func castRecoverError

Back

In /Users/kun/gobatis/gobatis/executor/error.go:

func castRecoverError(file string, e interface{}) error {
        if e != nil {
                _e, ok := e.(*_error)
                if ok {
                        if _e.file == "" {
                                _e.file = file
                        }
                        return _e
                }
                return &_error{
                        code:    unknownErr,
                        file:    file,
                        message: fmt.Sprintf("%v", e),
                }
        }
        return nil
}

func fragment.parseBlock

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

func (p *fragment) parseBlock(parser *exprParser, node *xmlNode, res *psr) {
        if node.textOnly {
                p.parseSql(parser, node, res)
        } else {
                res.dynamic = true
                switch node.Name {
                case dtd.IF:
                        r := new(psr)
                        if p.parseTest(parser, node, r) {
                                res.merge(r)
                        }
                case dtd.WHERE:
                        p.parseWhere(parser, node, res)
                case dtd.CHOOSE:
                        p.parseChoose(parser, node, res)
                case dtd.FOREACH:
                        p.parseForeach(parser, node, res)
                case dtd.TRIM:
                        p.parseTrim(parser, node, res)
                case dtd.SET:
                        p.parseSet(parser, node, res)
                }
        }
}

func fragment.parseForeach

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

func (p *fragment) parseForeach(parser *exprParser, node *xmlNode, res *psr) {

        _var := node.GetAttribute(dtd.COLLECTION)
        collection, ok := parser.paramsStack.getVar(_var)
        if !ok {
                throw(p.node.File, p.node.ctx, parasFragmentErr).
                        format("can't get foreach collection '%s' value", _var)
        }
        index := node.GetAttribute(dtd.INDEX)
        if index == "" {
                index = dtd.INDEX
        }
        item := node.GetAttribute(dtd.ITEM)
        slice := false
        if item == "" {
                item = dtd.ITEM
        } else {
                item, slice = handleSlice(item)
        }
        indexParam := &param{name: index, rt: reflect.Interface.String(), slice: false}
        itemParam := &param{name: item, rt: reflect.Interface.String(), slice: slice}
        open := node.GetAttribute(dtd.OPEN)
        _close := node.GetAttribute(dtd.CLOSE)
        separator := node.GetAttribute(dtd.SEPARATOR)

        parser.paramsStack.push(newExprParams())
        elem := toReflectValueElem(collection.value)
        frags := make([]string, 0)
        switch elem.Kind() {
        case reflect.Slice, reflect.Array:
                for i := 0; i < elem.Len(); i++ {
                        parser.paramsStack.peak().values = []exprValue{{value: i}, {value: elem.Index(i).Interface()}}
                        if i == 0 {
                                p.bindForeachParams(parser, indexParam, itemParam)
                        }
                        p.parseForeachChild(parser, node, &frags)
                }
        case reflect.Map:
                for i, v := range elem.MapKeys() {
                        parser.paramsStack.peak().values = []exprValue{{value: v.Interface()}, {value: elem.MapIndex(v).Interface()}}
                        if i == 0 {
                                p.bindForeachParams(parser, indexParam, itemParam)
                        }
                        p.parseForeachChild(parser, node, &frags)
                }
        case reflect.Struct:
                for i := 0; i < elem.NumField(); i++ {
                        parser.paramsStack.peak().values = []exprValue{{value: elem.Type().Field(i).Name}, {value: elem.Field(i).Interface()}}
                        if i == 0 {
                                p.bindForeachParams(parser, indexParam, itemParam)
                        }
                        p.parseForeachChild(parser, node, &frags)
                }
        default:
                throw(parser.file, node.ctx, parasFragmentErr).format("foreach collection type '%s' can't range", elem.Type())
        }
        _, err := parser.paramsStack.pop()
        if err != nil {
                throw(parser.file, node.ctx, popParamsStackErr).with(err)
        }
        if len(frags) > 0 {
                res.merge(&psr{
                        sql: open + strings.Join(frags, separator) + _close,
                })
        }
}

func exprValue.call

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprValue) call(ellipsis bool, params []reflect.Value) (r *exprValue, err error) {

        elem := toReflectValueElem(p.value)
        if elem.Kind() != reflect.Func {
                err = fmt.Errorf("visit '%s' is not func", elem.Kind())
                return
        }
        var out []reflect.Value
        defer func() {
                e := recover()
                if e != nil {
                        err = fmt.Errorf("function call error: %v", e)
                        return
                }
        }()
        for i, v := range params {
                if i < elem.Type().NumIn() {
                        va := elem.Type().In(i)
                        if va.Kind() != reflect.Interface && va.String() != v.Type().String() {
                                var vt interface{}
                                vt, err = cast.ToReflectTypeE(va, v.Interface())
                                if err == nil {
                                        params[i] = reflect.ValueOf(vt)
                                }
                        }
                }
        }
        if ellipsis {
                out = elem.CallSlice(params)
        } else {
                out = elem.Call(params)
        }

        if len(out) == 0 {
                err = fmt.Errorf("function must return one reuslt")
                return
        } else if len(out) > 1 {
                err = fmt.Errorf("function only support one result return")
                return
        }

        r = &exprValue{
                value: out[0].Interface(),
        }
        return
}

func varToReflectKind

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func varToReflectKind(t string) (kind reflect.Kind, err error) {
        switch t {
        case "bool":
                kind = reflect.Bool
        case "int":
                kind = reflect.Int
        case "int8":
                kind = reflect.Int8
        case "int16":
                kind = reflect.Int16
        case "int32":
                kind = reflect.Int32
        case "int64":
                kind = reflect.Int64
        case "uint":
                kind = reflect.Uint
        case "uint8":
                kind = reflect.Uint8
        case "uint16":
                kind = reflect.Uint16
        case "uint32":
                kind = reflect.Uint32
        case "uint64":
                kind = reflect.Uint64
        case "float32":
                kind = reflect.Float32
        case "float64":
                kind = reflect.Float64
        case "complex64":
                kind = reflect.Complex64
        case "complex128":
                kind = reflect.Complex128
        case "array":
                kind = reflect.Array
        case "slice":
                kind = reflect.Slice
        case "interface":
                kind = reflect.Interface
        case "map":
                kind = reflect.Map
        case "string":
                kind = reflect.String
        case "struct":
                kind = reflect.Struct
        default:
                err = fmt.Errorf("unsupported var type '%s'", t)
        }
        return
}

func exprParser.ExitIndex

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParser) ExitIndex(ctx *expr.IndexContext) {

        index, err := p.valueStack.pop()
        if err != nil {
                p.throw(ctx, popValueStackErr).with(err)
        }

        object, err := p.valueStack.pop()
        if err != nil {
                p.throw(ctx, popValueStackErr).with(err)
        }
        objectReflectElem := toReflectValueElem(object.value)
        var ev *exprValue
        if objectReflectElem.Kind() == reflect.Map {
                ev, err = object.visitMap(toReflectValueElem(index.value))
                if err != nil {
                        p.throw(ctx, visitMapErr).with(err)
                }
        } else if objectReflectElem.Kind() == reflect.Slice || objectReflectElem.Kind() == reflect.Array {
                var i int
                i, err = index.int()
                if err != nil {
                        p.throw(ctx, visitArrayErr).format("parse array index error: %s", err)
                }

                ev, err = object.visitArray(i)
                if err != nil {
                        p.throw(ctx, visitArrayErr).format("visit array error: %s", err)
                }

        } else {
                p.throw(ctx, indexErr).format("parameter unsupported index")
        }
        p.valueStack.push(ev)
        p.coverage.add(ctx)
}

func xmlParser.validateNode

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *xmlParser) validateNode(node *xmlNode, elem *dtd.Element) {

        // check required attributes
        if elem.Attributes != nil {
                for k, v := range elem.Attributes {
                        if v == dtd.REQUIRED && !node.HasAttribute(k) {
                                throw(p.file, node.ctx, validateXMLNodeErr).
                                        format("element: %s miss required attribute: %s", node.Name, k)
                        }
                }
        }

        switch node.Name {
        case dtd.SELECT, dtd.INSERT, dtd.UPDATE, dtd.DELETE:
                p.checkResultConflict(node)
        }

        for _, childNode := range node.Nodes {

                if childNode.textOnly {
                        continue
                }

                // check not supported node
                if !elem.HasNode(childNode.Name) {
                        throw(p.file, childNode.ctx, validateXMLNodeErr).
                                format("element: %s not support child element: %s", node.Name, childNode.Name)
                }

                // check at most once node
                if elem.GetNodeCount(childNode.Name) == dtd.AT_MOST_ONCE && node.countNode(childNode.Name) > 1 {
                        throw(p.file, childNode.ctx, validateXMLNodeErr).
                                format("element: %s not support duplicate element: %s", node.Name, childNode.Name)
                }

                childElem, err := p.elementGetter(childNode.Name)
                if err != nil {
                        throw(p.file, childNode.ctx, validateXMLNodeErr).with(err)
                }

                p.validateNode(childNode, childElem)
        }

        // check at least once node
        if elem.Nodes != nil {
                for k, v := range elem.Nodes {
                        if v == dtd.AT_LEAST_ONCE && node.countNode(k) == 0 {
                                throw(p.file, node.ctx, validateXMLNodeErr).
                                        format("element %s miss required element %s", node.Name, k)
                        }
                }
        }
}

func fragment.parseChoose

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

func (p *fragment) parseChoose(parser *exprParser, node *xmlNode, res *psr) {
        var pass bool
        var oc int
        for _, child := range node.Nodes {
                if pass {
                        break
                }
                switch child.Name {
                case dtd.WHEN:
                        r := new(psr)
                        if p.parseTest(parser, child, r) {
                                res.merge(r)
                                return
                        }
                case dtd.OTHERWISE:
                        oc++
                        p.parseBlocks(parser, child, res)
                        return
                default:
                        if child.textOnly {
                                if strings.TrimSpace(child.Text) == "" {
                                        continue
                                }
                                child.Name = "TEXT"
                        }
                        throw(parser.file, child.ctx, parasFragmentErr).
                                format("unsupported element '%s' element in choose", child.Name)
                }
        }
        if oc != 1 {
                throw(parser.file, node.ctx, parasFragmentErr).format("choose except 1 otherwise, got %d", oc)
        }
}

func param.expected

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p param) expected(vt reflect.Type) bool {

        vt = reflectTypeElem(vt)
        if p.slice {
                if vt.Kind() != reflect.Slice && vt.Kind() != reflect.Array {
                        return false
                }
                vt = vt.Elem()
        }
        vt = reflectTypeElem(vt)

        switch p.rt {
        case reflect.Interface.String():
                return true
        case reflect.Struct.String():
                if vt.Kind() == reflect.Struct {
                        return true
                } else {
                        return false
                }
        case reflect.Map.String():
                if vt.Kind() == reflect.Map {
                        return true
                } else {
                        return false
                }
        case reflect.Slice.String(), reflect.Array.String():
                if vt.Kind() == reflect.Slice || vt.Kind() == reflect.Array {
                        return true
                } else {
                        return false
                }
        default:
                if vt.String() == p.rt {
                        return true
                }
                return false
        }
}

func TestSetValueBasic

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func TestSetValueBasic(t *testing.T) {
        
        var a *int
        rv := reflect.ValueOf(&a)
        err := setValue(rv, 1)
        require.NoError(t, err)
        t.Log(*a)
        
        var b int8
        rv = reflect.ValueOf(&b)
        err = setValue(rv, 9)
        require.NoError(t, err)
        t.Log(b)
        
        var c float32
        rv = reflect.ValueOf(&c)
        err = setValue(rv, 3)
        require.NoError(t, err)
        t.Log(c)
        
        var d string
        rv = reflect.ValueOf(&d)
        err = setValue(rv, "hello world")
        require.NoError(t, err)
        t.Log(d)
}

func exprParser.ExitCall

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParser) ExitCall(ctx *expr.CallContext) {
        var l = 0
        if ctx.ExpressionList() != nil {
                l = len(ctx.ExpressionList().(*expr.ExpressionListContext).AllExpression())
        }
        args := make([]reflect.Value, l)
        for i := l - 1; i >= 0; i-- {
                arg, err := p.valueStack.pop()
                if err != nil {
                        p.throw(ctx, popValueStackErr).with(err)
                }
                args[i] = toReflectValueElem(arg.value)
        }
        f, err := p.valueStack.pop()
        if err != nil {
                p.throw(ctx, popValueStackErr).with(err)
        }
        r, err := f.call(ctx.ELLIPSIS() != nil, args)
        if err != nil {
                p.throw(ctx, callErr).with(err)
        }
        p.valueStack.push(r)
        p.coverage.add(ctx)
}

func exprParser.ExitSlice_

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParser) ExitSlice_(ctx *expr.Slice_Context) {
        l := len(ctx.AllExpression())
        args := make([]int, l)
        for i := l - 1; i >= 0; i-- {
                arg, err := p.valueStack.pop()
                if err != nil {
                        p.throw(ctx, popValueStackErr).with(err)
                }
                args[i], err = arg.int()
                if err != nil {
                        p.throw(ctx, visitArrayErr).with(err)
                }
        }
        target, err := p.valueStack.pop()
        if err != nil {
                p.throw(ctx, popValueStackErr).with(err)
        }
        r, err := target.visitSlice(ctx.GetText(), args...)
        if err != nil {
                p.throw(ctx, visitArrayErr).with(err)
        }
        p.valueStack.push(r)
        p.coverage.add(ctx)
}

func fragment.call

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

func (p *fragment) call(_type reflect.Type, in ...reflect.Value) []reflect.Value {

        c := &caller{fragment: p, args: in}
        for i := 0; i < _type.NumOut()-1; i++ {
                if _type.Out(i).Kind() == reflect.Ptr {
                        c.values = append(c.values, reflect.New(_type.Out(i).Elem()))
                } else {
                        c.values = append(c.values, reflect.New(_type.Out(i)))
                }
        }

        var err error
        if err != nil {
                if err == sql.ErrNoRows {
                        //if p.must {
                        //        c.values = append(c.values, reflect.ValueOf(err))
                        //} else {
                        //        c.values = append(c.values, reflect.Zero(errorType))
                        //}
                } else {
                        c.values = append(c.values, reflect.ValueOf(err))
                }
        } else {
                c.values = append(c.values, reflect.Zero(errorType))
        }

        for i := 0; i < _type.NumOut()-1; i++ {
                if _type.Out(i).Kind() == reflect.Ptr {
                        if err == sql.ErrNoRows {
                                c.values[i] = reflect.Zero(c.values[i].Type())
                        }
                } else {
                        c.values[i] = c.values[i].Elem()
                }
        }

        return c.values
}

func exprParser.relationCalc

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParser) relationCalc(left, right *exprValue, ctx antlr.ParserRuleContext, op antlr.Token) {

        var err error
        var result bool
        switch op.GetTokenType() {
        case expr.ExprParserEQUALS:
                result, err = cast.EqualAnyE(left.value, right.value)
        case expr.ExprParserNOT_EQUALS:
                result, err = cast.NotEqualAnyE(left.value, right.value)
        case expr.ExprParserLESS:
                result, err = cast.LessAnyE(left.value, right.value)
        case expr.ExprParserLESS_OR_EQUALS:
                result, err = cast.LessOrEqualAnyE(left.value, right.value)
        case expr.ExprParserGREATER:
                result, err = cast.GreaterAnyE(left.value, right.value)
        case expr.ExprParserGREATER_OR_EQUALS:
                result, err = cast.GreaterOrEqualAnyE(left.value, right.value)
        default:
                p.throw(ctx, unsupportedRelationCalcErr).format("unsupported relation calc")
        }
        if err != nil {
                p.throw(ctx, relationCalcError).with(err)

        }
        p.valueStack.push(&exprValue{value: result})
}

func exprValue.visitMember

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprValue) visitMember(name string) (r *exprValue, err error) {

        elem := toReflectValueElem(p.value)
        if elem.Kind() != reflect.Struct {
                err = fmt.Errorf("visit '%s.%s' is not struct", p.alias, name)
                return
        }

        mv := elem.FieldByName(name)
        if mv.Kind() == reflect.Invalid {
                mv = elem.MethodByName(name)
                if mv.Kind() == reflect.Invalid {
                        err = fmt.Errorf("visit member '%s.%s' is invalid", p.alias, name)
                        return
                }
        }

        r = &exprValue{
                value: mv.Interface(),
        }

        return
}

func exprParser.unaryCalc

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParser) unaryCalc(left *exprValue, ctx antlr.ParserRuleContext, op antlr.Token) {
        var err error
        var result interface{}
        switch op.GetTokenType() {
        case expr.ExprParserPLUS:
                result, err = cast.UnaryPlusAnyE(left.value)
        case expr.ExprParserMINUS:
                result, err = cast.UnaryMinusAnyE(left.value)
        case expr.ExprParserCARET:
                result, err = cast.UnaryCaretAnyE(left.value)
        case expr.ExprParserEXCLAMATION:
                result, err = cast.UnaryNotAnyE(left.value)
        default:
                p.throw(ctx, unsupportedUnaryCalc).format("unsupported %s%v", ctx.GetText(), left.value)
        }
        if err != nil {
                p.throw(ctx, unaryCalcError).with(err)
        }
        p.valueStack.push(&exprValue{value: result})
}

func xmlParser.checkResultConflict

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *xmlParser) checkResultConflict(node *xmlNode) {
        l := map[string]bool{}
        if node.HasAttribute(dtd.RESULT) {
                l[dtd.RESULT] = true
        }
        if node.HasAttribute(dtd.RESULT_MAP) {
                l[dtd.RESULT_MAP] = true
        }
        if len(l) > 1 {
                attrs := ""
                for k := range l {
                        attrs += k + ", "
                }
                attrs = strings.TrimSuffix(attrs, ", ")
                throw(p.file, node.ctx, resultAttributeConflictErr).format("%s attribute conflict", attrs)
        }
}

func exprValue.visitArray

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprValue) visitArray(index int) (r *exprValue, err error) {

        elem := toReflectValueElem(p.value)
        if elem.Kind() != reflect.Array && elem.Kind() != reflect.Slice {
                err = fmt.Errorf("visit var is not array or slice")
                return
        }

        mv := elem.Index(index)
        if mv.Kind() == reflect.Invalid {
                err = fmt.Errorf("visit array index '%d' is invalid", index)
                return
        }
        r = &exprValue{
                value: mv.Interface(),
        }
        return
}

func fragment.parseTest

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

func (p *fragment) parseTest(parser *exprParser, node *xmlNode, res *psr) bool {
        v, _, err := parser.parseExpression(node.ctx, node.GetAttribute(dtd.TEST))
        if err != nil {
                throw(p.node.File, p.node.ctx, parasFragmentErr).with(err)
        }
        b, err := cast.ToBoolE(v)
        if err != nil {
                throw(p.node.File, p.node.ctx, parasFragmentErr).with(err)
        }
        if !b {
                return false
        }
        p.parseBlocks(parser, node, res)

        return true
}

func exprValue.visitMap

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprValue) visitMap(index reflect.Value) (r *exprValue, err error) {

        elem := toReflectValueElem(p.value)
        if elem.Kind() != reflect.Map {
                err = fmt.Errorf("visit '%s' is not map", elem.Kind())
                return
        }

        mv := elem.MapIndex(index)
        r = &exprValue{}
        if mv.Kind() == reflect.Invalid {
                r.value = nil
        } else {
                r.value = mv.Interface()
        }
        return
}

func fragment.trimPrefixOverrides

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

func (p *fragment) trimPrefixOverrides(parser *exprParser, node *xmlNode, res *psr, tag, prefixes string) {
        wr := new(psr)
        p.parseBlocks(parser, node, wr)
        var err error
        s := strings.TrimSpace(wr.sql)
        filters := strings.Split(prefixes, "|")
        for _, v := range filters {
                s, err = p.trimPrefixOverride(s, v)
                if err != nil {
                        throw(p.node.File, p.node.ctx, parasFragmentErr).format("regexp compile error: %s", err)
                }
        }
        res.sql = fmt.Sprintf("%s %s %s", res.sql, tag, s)
}

func exprParser.popTertiaryOperands

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParser) popTertiaryOperands() (condition, left, right *exprValue, err error) {
        right, err = p.valueStack.pop()
        if err != nil {
                return
        }
        left, err = p.valueStack.pop()
        if err != nil {
                return
        }
        condition, err = p.valueStack.pop()
        if err != nil {
                return
        }
        return
}

func exprParser.ExitMember

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParser) ExitMember(ctx *expr.MemberContext) {
        name := ctx.IDENTIFIER().GetText()
        obj, err := p.valueStack.pop()
        if err != nil {
                p.throw(ctx, popValueStackErr).with(err)
        }
        var mev *exprValue
        mev, err = obj.visitMember(name)
        if err != nil {
                p.throw(ctx, visitMemberErr).with(err)
        }

        p.valueStack.push(mev)
        p.coverage.add(ctx)
}

func paramsStack.pop

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *paramsStack) pop() (val *exprParams, err error) {
        if p.list.Len() < 1 {
                err = fmt.Errorf("stack is empty unable to pop")
                return
        }
        e := p.list.Back()
        if e != nil {
                p.list.Remove(e)
                val = e.Value.(*exprParams)
                return
        }
        return
}

func printVars

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func printVars(vars []interface{}) string {
        if len(vars) == 0 {
                return ""
        }
        r := "\n"
        for i, v := range vars {
                _t := ""
                if v != nil {
                        _t = reflect.TypeOf(v).String()
                }
                r += fmt.Sprintf("   $%d %s (%s) %+v\n",
                        i+1, chalk.Green.Color("=>"), chalk.Yellow.Color(_t), v)
        }
        return r
}

func exprValue.visitSlice

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprValue) visitSlice(format string, indexes ...int) (r *exprValue, err error) {
        var v reflect.Value
        switch len(indexes) {
        case 2:
                v = toReflectValueElem(p.value).Slice(indexes[0], indexes[1])
        case 3:
                v = toReflectValueElem(p.value).Slice3(indexes[0], indexes[1], indexes[2])
        default:
                err = fmt.Errorf("unsuppoted slice range index '%s'", format)
                return
        }
        r = &exprValue{value: v.Interface()}
        return
}

func exprParser.logicCalc

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParser) logicCalc(left, right *exprValue, ctx antlr.ParserRuleContext, op antlr.Token) {

        var err error
        var result interface{}
        switch op.GetTokenType() {
        case expr.ExprParserLOGICAL_AND, expr.ExprParserLOGICAL_AND_LOWER, expr.ExprParserLOGICAL_AND_UPPER:
                result, err = cast.LogicAndAnyE(left.value, right.value)
        case expr.ExprParserLOGICAL_OR, expr.ExprParserLOGICAL_OR_LOWER, expr.ExprParserLOGICAL_OR_UPPER:
                result, err = cast.LogicOrAnyE(left.value, right.value)
        }
        if err != nil {
                p.throw(ctx, logicCalcErr).with(err)
        }
        p.valueStack.push(&exprValue{value: result})
}

func fragment.bindForeachParams

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

func (p *fragment) bindForeachParams(parser *exprParser, indexParam, itemParam *param) {
        parser.paramsStack.peak().check = map[string]int{}
        err := parser.paramsStack.peak().bind(indexParam, 0)
        if err != nil {
                throw(p.node.File, p.node.ctx, varBindErr).with(err)
        }
        err = parser.paramsStack.peak().bind(itemParam, 1)
        if err != nil {
                throw(p.node.File, p.node.ctx, varBindErr).with(err)
        }
}

func fragment.checkParameter

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

func (p *fragment) checkParameter(ft reflect.Type, mn, fn string) {
        ac := 0
        for i := 0; i < ft.NumIn(); i++ {
                if isContext(ft.In(i)) || isTx(ft.In(i)) || isDB(ft.In(i)) {
                        continue
                }
                ac++
        }
        if len(p.in) != ac {
                throw(p.node.File, p.node.ctx, checkParameterErr).
                        format("%s.%s expected %d bind parameter, got %d", mn, fn, len(p.in), ac)
        }
}

func TestIndirect

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func TestIndirect(t *testing.T) {
        
        var a *int
        rv := reflect.ValueOf(&a)
        
        t.Log(rv.Kind())
        
        rv = indirect(rv, false)
        
        t.Log(rv.Kind())
        
        rv.Set(reflect.ValueOf(3))
        
        t.Log(*a)
}

func fragment.parseForeachChild

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

func (p *fragment) parseForeachChild(parser *exprParser, node *xmlNode, frags *[]string) {
        r := ""
        for _, child := range node.Nodes {
                br := new(psr)
                p.parseBlock(parser, child, br)
                r += br.sql
        }
        *frags = append(*frags, r)
}

func caller.execer

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

func (p *caller) execer(in []reflect.Value) (execer, int) {
        if len(in) > 0 {
                t := reflect.TypeOf(new(execer)).Elem()
                for i, v := range in {
                        if v.Type().Implements(t) {
                                return v.Interface().(execer), i
                        }
                }
        }
        return nil, -1
}

func exprParser.tertiaryCalc

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParser) tertiaryCalc(condition, left, right *exprValue, ctx antlr.ParserRuleContext) {

        ok, err := cast.ToBoolE(condition.value)
        if err != nil {
                p.throw(ctx, castBoolErr).with(err)
        }
        if ok {
                p.valueStack.push(left)
        } else {
                p.valueStack.push(right)
        }
}

func caller.queryer

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

func (p *caller) queryer(in []reflect.Value) (queryer, int) {
        if len(in) > 0 {
                t := reflect.TypeOf(new(queryer)).Elem()
                for i, v := range in {
                        if v.Type().Implements(t) {
                                return v.Interface().(queryer), i
                        }
                }
        }
        return nil, -1
}

func xmlNode.GetAttribute

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *xmlNode) GetAttribute(name string) string {
        if p.Attributes == nil {
                return ""
        }
        v, ok := p.Attributes[name]
        if ok {
                return v.Value
        }
        return ""
}

func reflectTypeElem

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func reflectTypeElem(vt reflect.Type) reflect.Type {
        for {
                if vt.Kind() != reflect.Ptr {
                        break
                }
                vt = vt.Elem()
        }
        return vt
}

func xmlParser.enterAttribute

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *xmlParser) enterAttribute(c *xml.AttributeContext) {
        // <?xml version="1.0" encoding="UTF-8" ?>
        if p.stack.Peak() == nil {
                return
        }
        name := strings.TrimSpace(c.Name().GetText())
        value := strings.TrimSpace(trimValueQuote(c.STRING().GetText()))
        p.stack.Peak().AddAttribute(name, &xmlNodeAttribute{
                File:  p.file,
                Value: value,
                Start: c.STRING().GetSymbol(),
                ctx:   c,
        })
}

func toReflectValueElem

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func toReflectValueElem(source interface{}) reflect.Value {
        v := reflect.ValueOf(source)
        for {
                if v.Kind() == reflect.Ptr {
                        v = v.Elem()
                } else {
                        return v
                }
        }
}

func exprParser.ExitInteger

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParser) ExitInteger(ctx *expr.IntegerContext) {
        v, err := cast.ToIntE(ctx.GetText())
        if err != nil {
                p.throw(ctx, parseIntegerErr).with(err)
        }
        p.valueStack.push(&exprValue{
                value:  v,
                source: ctx.GetText(),
        })
        p.coverage.add(ctx)
}

func exprParser.ExitFloat_

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParser) ExitFloat_(ctx *expr.Float_Context) {
        v, err := cast.ToDecimalE(ctx.GetText())
        if err != nil {
                p.throw(ctx, parseDecimalErr).with(err)
        }
        p.valueStack.push(&exprValue{
                value:  v,
                source: ctx.GetText(),
        })
        p.coverage.add(ctx)
}

func InvalidUnmarshalError.Error

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func (e *InvalidUnmarshalError) Error() string {
        if e.Type == nil {
                return "gobatis: Unmarshal(nil)"
        }
        
        if e.Type.Kind() != reflect.Pointer {
                return "gobatis: Unmarshal(non-pointer " + e.Type.String() + ")"
        }
        return "gobatis: Unmarshal(nil " + e.Type.String() + ")"
}

func reflectValueElem

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func reflectValueElem(vt reflect.Value) reflect.Value {
        for {
                if vt.Kind() != reflect.Ptr {
                        break
                }
                vt = vt.Elem()
        }
        return vt
}

func fragment.trimPrefixOverride

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

func (p *fragment) trimPrefixOverride(sql, prefix string) (r string, err error) {
        reg, err := regexp.Compile(`(?i)^` + prefix)
        if err != nil {
                return
        }
        r = reg.ReplaceAllString(sql, "")
        return
}

func valueStack.peak

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *valueStack) peak() *exprValue {
        e := p.list.Back()
        if e != nil {
                return e.Value.(*exprValue)
        }
        return nil
}

func xmlNode.HasAttribute

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *xmlNode) HasAttribute(name string) bool {
        if p.Attributes == nil {
                return false
        }
        _, ok := p.Attributes[name]
        return ok
}

func @733:8

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func() {
                e := recover()
                if e != nil {
                        err = fmt.Errorf("function call error: %v", e)
                        return
                }
        }

func _uint8

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

func _uint8(v interface{}) uint8 {
        r, err := cast.ToUint8E(v)
        if err != nil {
                panic(err)
        }
        return r
}

func _uint

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

func _uint(v interface{}) uint {
        r, err := cast.ToUintE(v)
        if err != nil {
                panic(err)
        }
        return r
}

func caller.context

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

func (p *caller) context(in []reflect.Value) (context.Context, int) {
        for i, v := range in {
                if isContext(v.Type()) {
                        return v.Interface().(context.Context), i
                }
        }
        return context.Background(), -1
}

func fragment.fork

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

func (p *fragment) fork() *fragment {
        n := new(fragment)
        n.node = p.node
        n.in = p.in
        return n
}

func _uint32

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

func _uint32(v interface{}) uint32 {
        r, err := cast.ToUint32E(v)
        if err != nil {
                panic(err)
        }
        return r
}

func psr.merge

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

func (p *psr) merge(s ...*psr) {
        for _, v := range s {
                p.sql += " " + strings.TrimSpace(v.sql)
                if !p.dynamic && v.dynamic {
                        p.dynamic = v.dynamic
                }
        }
}

func _uint64

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

func _uint64(v interface{}) uint64 {
        r, err := cast.ToUint64E(v)
        if err != nil {
                panic(err)
        }
        return r
}

func _int64

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

func _int64(v interface{}) int64 {
        r, err := cast.ToInt64E(v)
        if err != nil {
                panic(err)
        }
        return r
}

func _uint16

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

func _uint16(v interface{}) uint16 {
        r, err := cast.ToUint16E(v)
        if err != nil {
                panic(err)
        }
        return r
}

func _int32

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

func _int32(v interface{}) int32 {
        r, err := cast.ToInt32E(v)
        if err != nil {
                panic(err)
        }
        return r
}

func _int16

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

func _int16(v interface{}) int16 {
        r, err := cast.ToInt16E(v)
        if err != nil {
                panic(err)
        }
        return r
}

func coverage.notCovered

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *coverage) notCovered() (indexes []int) {
        for i := 0; i <= p.total; i++ {
                if _, ok := p.scan[i]; !ok {
                        indexes = append(indexes, i)
                }
        }
        return
}

func _string

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

func _string(v interface{}) string {
        r, err := cast.ToStringE(v)
        if err != nil {
                panic(err)
        }
        return r
}

func _int8

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

func _int8(v interface{}) int8 {
        r, err := cast.ToInt8E(v)
        if err != nil {
                panic(err)
        }
        return r
}

func paramsStack.peak

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *paramsStack) peak() *exprParams {
        e := p.list.Back()
        if e != nil {
                return e.Value.(*exprParams)
        }
        return nil
}

func _bool

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

func _bool(v interface{}) bool {
        r, err := cast.ToBoolE(v)
        if err != nil {
                panic(err)
        }
        return r
}

func _int

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

func _int(v interface{}) int {
        r, err := cast.ToIntE(v)
        if err != nil {
                panic(err)
        }
        return r
}

func builtin.get

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

func (p *builtin) get(name string) interface{} {
        p.mu.RLock()
        defer p.mu.RUnlock()
        v, _ := p._map[name]
        return v
}

func trimValueQuote

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func trimValueQuote(s string) string {
        if len(s) > 1 {
                switch s[0] {
                case 34, 39:
                        return s[1 : len(s)-1]
                }
        }
        return s
}

func _decimal

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

func _decimal(v interface{}) decimal.Decimal {
        r, err := cast.ToDecimalE(v)
        if err != nil {
                panic(err)
        }
        return r
}

func isDB

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func isDB(v reflect.Type) bool {
        if v.Kind() == reflect.Ptr && v.Elem().Name() == "DB" && v.Elem().PkgPath() == "github.com/gobatis/gobatis" {
                return true
        }
        return false
}

func param.Type

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p param) Type() string {
        if p.slice {
                return fmt.Sprintf("[]%s", p.rt)
        }
        return p.rt
}

func parseFragment

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func parseFragment(file, id string, node *xmlNode) (frag *fragment, err error) {

        defer func() {
                e := recover()
                err = castRecoverError(file, e)
        }()

        frag = &fragment{
                //db:   nil,
                //id:   id,
                node: node,
        }

        //frag.setResultAttribute()

        //if node.HasAttribute(dtd.PARAMETER) {
        //        frag.in = frag.parseParams(node.GetAttribute(dtd.PARAMETER))
        //}
        //if node.HasAttribute(dtd.RESULT) {
        //        frag.out = frag.parseParams(node.GetAttribute(dtd.RESULT))
        //}
        return
}

func isContext

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func isContext(v reflect.Type) bool {
        if v.Name() == "Context" && v.PkgPath() == "context" {
                return true
        }
        return false
}

func xmlNode.AddAttribute

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *xmlNode) AddAttribute(name string, value *xmlNodeAttribute) {
        if p.Attributes == nil {
                p.Attributes = map[string]*xmlNodeAttribute{}
        }
        p.Attributes[name] = value
}

func xmlNode.countNode

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *xmlNode) countNode(name string) int {
        if p.nodesCount == nil {
                return 0
        }
        return p.nodesCount[name]
}

func xmlNodeStack.Empty

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *xmlNodeStack) Empty() bool {
        p.lock.RLock()
        defer p.lock.RUnlock()
        return p.list.Len() == 0
}

func isTx

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

func isTx(v reflect.Type) bool {
        if v.Kind() == reflect.Ptr && v.Elem().Name() == "Tx" &&
                (v.Elem().PkgPath() == "database/sql" ||
                        v.Elem().PkgPath() == "github.com/gobatis/gobatis") {
                return true
        }
        return false
}

func exprValue.convertible

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprValue) convertible(received, expected reflect.Kind) bool {
        if expected == reflect.Array && received == reflect.Slice {
                return true
        }
        return false
}

func @92:8

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

92	`func() {`
93	`e := recover()`
94	`err = castRecoverError(file, e)`
95	`}`

func _error.with

Back

In /Users/kun/gobatis/gobatis/executor/error.go:

76	`func (p *_error) with(err error) {`
77	`p.message = err.Error()`
78	`panic(p)`
79	`}`

func exprParser.ExitString_

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParser) ExitString_(ctx *expr.String_Context) {
        p.valueStack.push(&exprValue{
                value: trimValueQuote(ctx.GetText()),
        })
        p.coverage.add(ctx)
}

func _error.setParent

Back

In /Users/kun/gobatis/gobatis/executor/error.go:

66	`func (p _error) setParent(ctx antlr.ParserRuleContext) _error {`
67	`p.parent = ctx`
68	`return p`
69	`}`

func exprParser.ExitNil_

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

func (p *exprParser) ExitNil_(ctx *expr.Nil_Context) {
        p.valueStack.push(&exprValue{
                value: nil,
        })
        p.coverage.add(ctx)
}

func _strings.TrimSpace

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

189	`func (p _strings) TrimSpace(s string) string { return strings.TrimSpace(s) }`

func @52:43

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

52	`func(args []reflect.Value) (results []reflect.Value) {`
53	`return p.call(field.Type(), args...)`
54	`}`

func _strings.TrimSuffix

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

191	`func (p _strings) TrimSuffix(s, suffix string) string { return strings.TrimSuffix(s, suffix) }`

func exprParser.throw

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

1248	`func (p exprParser) throw(ctx antlr.ParserRuleContext, code int) _error {`
1249	`return throw(p.file, ctx, code).setParent(p.nodeCtx)`
1250	`}`

func _strings.TrimPrefix

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

190	`func (p _strings) TrimPrefix(s, prefix string) string { return strings.TrimPrefix(s, prefix) }`

func exprParser.ExitMisc

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

998	`func (p exprParser) ExitMisc(ctx expr.MiscContext) {`
999	`p.coverage.add(ctx)`
1000	`}`

func _strings.ReplaceAll

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

193	`func (p _strings) ReplaceAll(s, old, new string) string { return strings.ReplaceAll(s, old, new) }`

func logger.Warnf

Back

In /Users/kun/gobatis/gobatis/executor/logger.go:

83	`func (l logger) Warnf(format string, a ...any) {`
84	`syslog.Printf(format, a...)`
85	`}`

func _len

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

56	`func _len(v interface{}) int {`
57	`return reflect.ValueOf(v).Len()`
58	`}`

func ParallelQuery.Query

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

278	`func (p *ParallelQuery) Query() bool {`
279	`return p.Raw.Query`
280	`}`

func FetchQuery.Query

Back

In /Users/kun/gobatis/gobatis/executor/executor.go:

300	`func (f *FetchQuery) Query() bool {`
301	`return f.raw.Query`
302	`}`

func _strings.TrimRight

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

188	`func (p _strings) TrimRight(s, cutset string) string { return strings.TrimRight(s, cutset) }`

func _strings.TrimLeft

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

187	`func (p _strings) TrimLeft(s, cutset string) string { return strings.TrimLeft(s, cutset) }`

func _strings.Trim

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

186	`func (p _strings) Trim(s, cutset string) string { return strings.Trim(s, cutset) }`

func _strings.Title

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

185	`func (p _strings) Title(s string) string { return strings.Title(s) }`

func _strings.ToTitle

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

184	`func (p _strings) ToTitle(s string) string { return strings.ToTitle(s) }`

func _strings.ToLower

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

183	`func (p _strings) ToLower(s string) string { return strings.ToLower(s) }`

func _strings.ToUpper

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

182	`func (p _strings) ToUpper(s string) string { return strings.ToUpper(s) }`

func _strings.Repeat

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

181	`func (p _strings) Repeat(s string, count int) string { return strings.Repeat(s, count) }`

func Tx.BeginTx

Back

In /Users/kun/gobatis/gobatis/executor/tx.go:

23	`func (t Tx) BeginTx(ctx context.Context, opts sql.TxOptions) (*sql.Tx, error) {`
24	`return t.Tx, nil`
25	`}`

func _strings.HasSuffix

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

180	`func (p _strings) HasSuffix(s, suffix string) bool { return strings.HasSuffix(s, suffix) }`

func Tx.Close

Back

In /Users/kun/gobatis/gobatis/executor/tx.go:

31	`func (t *Tx) Close() error {`
32	`return nil`
33	`}`

func _strings.HasPrefix

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

179	`func (p _strings) HasPrefix(s, prefix string) bool { return strings.HasPrefix(s, prefix) }`

func errorListener.SyntaxError

Back

In /Users/kun/gobatis/gobatis/executor/error.go:

177

func (p *errorListener) SyntaxError(recognizer antlr.Recognizer, offendingSymbol interface{}, line, column int, msg string, e antlr.RecognitionException) {

178

throw("", nil, syntaxErr).format("词法分析错误")

179

}

func paramsStack.len

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

937	`func (p *paramsStack) len() int {`
938	`return p.list.Len()`
939	`}`

func paramsStack.empty

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

941	`func (p *paramsStack) empty() bool {`
942	`return p.list.Len() == 0`
943	`}`

func isError

Back

In /Users/kun/gobatis/gobatis/executor/utils.go:

56	`func isError(t reflect.Type) bool {`
57	`return t.Implements(reflect.TypeOf((*error)(nil)).Elem())`
58	`}`

func _strings.Join

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

178	`func (p _strings) Join(elems []string, sep string) string { return strings.Join(elems, sep) }`

func _strings.Fields

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

177	`func (p _strings) Fields(s string) []string { return strings.Fields(s) }`

func valueStack.empty

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

826	`func (p *valueStack) empty() bool {`
827	`return p.list.Len() == 0`
828	`}`

func fragment.proxy

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

func (p *fragment) proxy(field reflect.Value) {
        field.Set(reflect.MakeFunc(field.Type(), func(args []reflect.Value) (results []reflect.Value) {
                return p.call(field.Type(), args...)
        }))
}

func _strings.Replace

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

192	`func (p _strings) Replace(s, old, new string, n int) string { return strings.Replace(s, old, new, n) }`

func _strings.SplitAfter

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

176	`func (p _strings) SplitAfter(s, sep string) []string { return strings.SplitAfter(s, sep) }`

func _strings.Split

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

175	`func (p _strings) Split(s, sep string) []string { return strings.Split(s, sep) }`

func _strings.SplitAfterN

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

174	`func (p _strings) SplitAfterN(s, sep string, n int) []string { return strings.SplitAfterN(s, sep, n) }`

func _strings.SplitN

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

173	`func (p _strings) SplitN(s, sep string, n int) []string { return strings.SplitN(s, sep, n) }`

func _strings.LastIndexAny

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

172	`func (p _strings) LastIndexAny(s, chars string) int { return strings.LastIndexAny(s, chars) }`

func _strings.IndexAny

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

171	`func (p _strings) IndexAny(s, chars string) int { return strings.IndexAny(s, chars) }`

func _strings.LastIndex

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

170	`func (p _strings) LastIndex(s, substr string) int { return strings.LastIndex(s, substr) }`

func _strings.ContainsRune

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

169	`func (p _strings) ContainsRune(s string, r rune) bool { return strings.ContainsRune(s, r) }`

func exprValue.int

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

660	`func (p *exprValue) int() (v int, err error) {`
661	`return cast.ToIntE(p.value)`
662	`}`

func _strings.ContainsAny

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

168	`func (p _strings) ContainsAny(s, chars string) bool { return strings.ContainsAny(s, chars) }`

func _strings.Contains

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

167	`func (p _strings) Contains(s, substr string) bool { return strings.Contains(s, substr) }`

func _strings.Count

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

166	`func (p _strings) Count(s, substr string) int { return strings.Count(s, substr) }`

func logger.Errorf

Back

In /Users/kun/gobatis/gobatis/executor/logger.go:

79	`func (l logger) Errorf(format string, a ...any) {`
80	`syslog.Printf(format, a...)`
81	`}`

func exprValue.accept

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

649	`func (p *exprValue) accept(received, expected reflect.Kind) bool {`
650	`return expected == reflect.Interface \|\| received == expected`
651	`}`

func logger.Infof

Back

In /Users/kun/gobatis/gobatis/executor/logger.go:

75	`func (l logger) Infof(format string, a ...any) {`
76	`syslog.Printf(format, a...)`
77	`}`

func fragment.parseWhere

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

244	`func (p fragment) parseWhere(parser exprParser, node xmlNode, res psr) {`
245	`p.trimPrefixOverrides(parser, node, res, dtd.WHERE, "AND \|OR ")`
246	`}`

func fragment.parseTrim

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

282	`func (p fragment) parseTrim(parser exprParser, node xmlNode, res psr) {`
283	`p.trimPrefixOverrides(parser, node, res, node.GetAttribute(dtd.PREFIX), node.GetAttribute(dtd.PREFIX_OVERRIDES))`
284	`}`

func fragment.parseSet

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

301	`func (p fragment) parseSet(parser exprParser, node xmlNode, res psr) {`
302	`p.trimPrefixOverrides(parser, node, res, dtd.SET, ",")`
303	`}`

func logger.brand

Back

In /Users/kun/gobatis/gobatis/executor/logger.go:

30	`func (l logger) brand() string {`
31	`return ""`
32	`}`

func caller.removeParam

Back

In /Users/kun/gobatis/gobatis/executor/fragment.go:

406	`func (p *caller) removeParam(a []reflect.Value, i int) []reflect.Value {`
407	`return append(a[:i], a[i+1:]...)`
408	`}`

func _strings.EqualFold

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

194	`func (p _strings) EqualFold(s, t string) bool { return strings.EqualFold(s, t) }`

func _strings.Index

Back

In /Users/kun/gobatis/gobatis/executor/builtin.go:

195	`func (p _strings) Index(s, substr string) int { return strings.Index(s, substr) }`

func parserErrorStrategy.Sync

Back

In /Users/kun/gobatis/gobatis/executor/error.go:

158	`func (p *parserErrorStrategy) Sync(recognizer antlr.Parser) {`
159	`// pass`
160	`}`

func parserErrorStrategy.ReportError

Back

In /Users/kun/gobatis/gobatis/executor/error.go:

162	`func (p *parserErrorStrategy) ReportError(antlr.Parser, antlr.RecognitionException) {`
163	`// pass`
164	`}`

func parserErrorStrategy.ReportMatch

Back

In /Users/kun/gobatis/gobatis/executor/error.go:

166	`func (p *parserErrorStrategy) ReportMatch(antlr.Parser) {`
167	`// pass`
168	`}`

func errorListener.ReportContextSensitivity

Back

In /Users/kun/gobatis/gobatis/executor/error.go:

189	`func (p errorListener) ReportContextSensitivity(recognizer antlr.Parser, dfa antlr.DFA, startIndex, stopIndex, prediction int, configs antlr.ATNConfigSet) {`
190	`// pass`
191	`}`

func errorListener.ReportAttemptingFullContext

Back

In /Users/kun/gobatis/gobatis/executor/error.go:

185	`func (p errorListener) ReportAttemptingFullContext(recognizer antlr.Parser, dfa antlr.DFA, startIndex, stopIndex int, conflictingAlts *antlr.BitSet, configs antlr.ATNConfigSet) {`
186	`// pass`
187	`}`

func @20:8

Back

In /Users/kun/gobatis/gobatis/executor/parser.go:

20	`func() {`
21	`//e := recover()`
22	`//err = castRecoverError(file, e)`
23	`}`

func errorListener.ReportAmbiguity

Back

In /Users/kun/gobatis/gobatis/executor/error.go:

181	`func (p errorListener) ReportAmbiguity(recognizer antlr.Parser, dfa antlr.DFA, startIndex, stopIndex int, exact bool, ambigAlts *antlr.BitSet, configs antlr.ATNConfigSet) {`
182	`// pass`
183	`}`

Package Overview: github.com/gobatis/gobatis/parser/expr 43.4%

Please select a function to see what's left for testing.

`ExprParser.Parameters(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`28/28`
`ExprParser.Operand(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`21/21`
`ExprParser.ParamDecl(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`18/18`
`NewExprLexer(...)`	`github.com/gobatis/gobatis/parser/expr/expr_lexer.go`	`100.0%`	`15/15`
`NewExprParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`13/13`
`ExprParser.Expressions(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`10/10`
`ExprParser.Var_(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`8/8`
`ExprParser.ParamComma(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`8/8`
`ExprParser.Literal(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`8/8`
`@368:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`6/6`
`NewPrimaryExprContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`5/5`
`NewLogicalContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`5/5`
`NewLiteralContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`5/5`
`NewParamTypeContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`5/5`
`NewIntegerContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`5/5`
`NewSlice_Context(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`5/5`
`NewVar_Context(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`5/5`
`NewExpressionContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`5/5`
`NewParamDeclContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`5/5`
`NewBasicLitContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`5/5`
`NewOperandContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`5/5`
`NewParamCommaContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`5/5`
`NewParametersContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`5/5`
`NewString_Context(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`5/5`
`NewExpressionsContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`5/5`
`ParamDeclContext.ParamType(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`4/4`
`ParamCommaContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`2/2`
`ParamTypeContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`2/2`
`ExpressionsContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`2/2`
`ExpressionsContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`2/2`
`ParamTypeContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`2/2`
`ExpressionContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`2/2`
`OperandContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`2/2`
`ExpressionContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`2/2`
`OperandContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`2/2`
`ParamCommaContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`2/2`
`ParametersContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`2/2`
`ParametersContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`2/2`
`Var_Context.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`2/2`
`PrimaryExprContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`2/2`
`ParamDeclContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`2/2`
`ParamDeclContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`2/2`
`Var_Context.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`2/2`
`PrimaryExprContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`2/2`
`@1211:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`@3264:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`@598:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`OperandContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`ParamDeclContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`ParamTypeContext.IDENTIFIER(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`@2307:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`@1725:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`ParamTypeContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`@1976:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`ParamDeclContext.IDENTIFIER(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`IntegerContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`@2460:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`@718:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`ExpressionContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`Var_Context.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`String_Context.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`@493:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`Var_Context.IDENTIFIER(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`LogicalContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`LiteralContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`ExpressionsContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`BasicLitContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`Slice_Context.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`ParamCommaContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`@2654:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`@833:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`ExpressionContext.GetTertiary(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`ExpressionContext.GetRel_op(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`ExpressionContext.GetAdd_op(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`@2172:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`ExpressionContext.GetMul_op(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`ExpressionContext.GetUnary_op(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`@1857:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`@364:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`PrimaryExprContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`@1558:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`ParametersContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`1/1`
`ExprParser.Logical(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`92.3%`	`12/13`
`ExprParser.Integer(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`92.3%`	`12/13`
`ExprParser.String_(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`92.3%`	`12/13`
`ExprParser.primaryExpr(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`83.3%`	`35/42`
`ExprParser.expression(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`80.9%`	`93/115`
`ExpressionContext.Logical(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`75.0%`	`3/4`
`ExprParser.ParamType(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`73.3%`	`11/15`
`ExprParser.Slice_(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`68.4%`	`26/38`
`ExprParser.BasicLit(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`53.8%`	`14/26`
`Slice_Context.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`50.0%`	`1/2`
`LogicalContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`50.0%`	`1/2`
`IntegerContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`50.0%`	`1/2`
`IntegerContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`50.0%`	`1/2`
`BasicLitContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`50.0%`	`1/2`
`Slice_Context.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`50.0%`	`1/2`
`BasicLitContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`50.0%`	`1/2`
`String_Context.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`50.0%`	`1/2`
`LiteralContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`50.0%`	`1/2`
`LiteralContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`50.0%`	`1/2`
`LogicalContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`50.0%`	`1/2`
`String_Context.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`50.0%`	`1/2`
`@1980:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`16.7%`	`1/6`
`@1215:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`16.7%`	`1/6`
`@2176:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`16.7%`	`1/6`
`@722:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`16.7%`	`1/6`
`@2658:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`16.7%`	`1/6`
`@2311:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`16.7%`	`1/6`
`@1729:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`16.7%`	`1/6`
`@2464:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`16.7%`	`1/6`
`@3268:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`16.7%`	`1/6`
`@1861:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`16.7%`	`1/6`
`@602:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`16.7%`	`1/6`
`@837:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`16.7%`	`1/6`
`@497:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`16.7%`	`1/6`
`@1562:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`16.7%`	`1/6`
`ExprParser.ExpressionList(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/21`
`ExprParser.Call(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/20`
`ExprParser.Index(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/12`
`ExprParser.Member(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/10`
`ExprParser.Sempred(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/10`
`ExprParser.Misc(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/10`
`ExprParser.Nil_(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/8`
`ExprParser.Float_(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/8`
`ExprParser.Expression_Sempred(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/7`
`Slice_Context.AllExpression(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/6`
`@936:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/6`
`ExpressionContext.AllExpression(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/6`
`@2075:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/6`
`ParametersContext.AllParamComma(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/6`
`@3118:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/6`
`@2987:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/6`
`ExpressionListContext.AllExpression(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/6`
`@2861:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/6`
`ParametersContext.AllParamDecl(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/6`
`@2562:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/6`
`@2756:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/6`
`NewExpressionListContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/5`
`NewIndexContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/5`
`NewNil_Context(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/5`
`NewMemberContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/5`
`NewFloat_Context(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/5`
`NewCallContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/5`
`NewMiscContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/5`
`CallContext.ExpressionList(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyParamTypeContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`BasicLitContext.Nil_(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`IndexContext.Expression(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyLogicalContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`PrimaryExprContext.Operand(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`BasicLitContext.String_(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyBasicLitContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyExpressionListContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`PrimaryExprContext.PrimaryExpr(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyIntegerContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyMiscContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyExpressionContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`ExpressionListContext.Expression(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`ExpressionsContext.Expression(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`LiteralContext.BasicLit(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`BasicLitContext.Float_(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyExpressionsContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyCallContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`PrimaryExprContext.Member(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`PrimaryExprContext.Slice_(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyOperandContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyPrimaryExprContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyIndexContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyLiteralContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`OperandContext.Literal(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`OperandContext.Var_(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`BasicLitContext.Integer(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`OperandContext.Expression(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyFloat_Context(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptySlice_Context(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`PrimaryExprContext.Index(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`ExpressionContext.PrimaryExpr(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`Slice_Context.Expression(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyParamDeclContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyParamCommaContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`ParametersContext.ParamComma(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyVar_Context(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyMemberContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`ExpressionContext.Expression(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`ParametersContext.ParamDecl(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyString_Context(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`PrimaryExprContext.Call(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyNil_Context(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`NewEmptyParametersContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/4`
`ExprParser.PrimaryExpr_Sempred(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/3`
`IndexContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/2`
`Nil_Context.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/2`
`CallContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/2`
`CallContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/2`
`ExpressionListContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/2`
`ExpressionListContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/2`
`IndexContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/2`
`MiscContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/2`
`MiscContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/2`
`Float_Context.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/2`
`Float_Context.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/2`
`MemberContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/2`
`MemberContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/2`
`Nil_Context.ExitRule(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/2`
`IndexContext.R_BRACKET(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`LogicalContext.LOGICAL_AND(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`OperandContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ParametersContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ParametersContext.EOF(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`MiscContext.WS(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`LogicalContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`LogicalContext.LOGICAL_OR_UPPER(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`LiteralContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`LogicalContext.LOGICAL_AND_UPPER(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`LogicalContext.LOGICAL_OR_LOWER(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`LogicalContext.LOGICAL_AND_LOWER(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`LogicalContext.LOGICAL_OR(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`MiscContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`LogicalContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ParametersContext.STAR(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ParametersContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`BasicLitContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExprParser.PrimaryExpr(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`PrimaryExprContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`PrimaryExprContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ParamCommaContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`BasicLitContext.IMAGINARY_LIT(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`BasicLitContext.RUNE_LIT(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExprParser.Expression(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`BasicLitContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.QUESTION(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.COLON(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.GREATER_OR_EQUALS(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.GREATER(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.LESS_OR_EQUALS(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ParamCommaContext.COMMA(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.LESS(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`IntegerContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`IntegerContext.DECIMAL_LIT(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`IntegerContext.BINARY_LIT(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`IntegerContext.OCTAL_LIT(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`IntegerContext.HEX_LIT(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`IntegerContext.IMAGINARY_LIT(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`IntegerContext.RUNE_LIT(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.NOT_EQUALS(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`IntegerContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.EQUALS(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.OR(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.BIT_CLEAR(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.AMPERSAND(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.RSHIFT(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.LSHIFT(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`Slice_Context.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.MOD(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`Nil_Context.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`Nil_Context.NIL_LIT(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`Nil_Context.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`Nil_Context.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`@2071:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`OperandContext.R_PAREN(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ParamCommaContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`@2558:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.STAR(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.CARET(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ParamDeclContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.EXCLAMATION(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`String_Context.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`String_Context.RAW_STRING_LIT(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`String_Context.INTERPRETED_STRING_LIT(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.MINUS(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`String_Context.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.PLUS(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.SetTertiary(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.SetRel_op(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.SetAdd_op(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.SetMul_op(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.SetUnary_op(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`Slice_Context.COLON(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`Float_Context.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`Float_Context.FLOAT_LIT(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`Float_Context.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`Float_Context.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`MemberContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`MemberContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`Slice_Context.AllCOLON(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`@2752:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`@932:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`MemberContext.IDENTIFIER(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`Slice_Context.R_BRACKET(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`MemberContext.DOT(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`IndexContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`IndexContext.L_BRACKET(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`MiscContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`Var_Context.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`IndexContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`IndexContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`MiscContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`MemberContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`MiscContext.TERMINATOR(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`@2857:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`LiteralContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`OperandContext.L_PAREN(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionContext.DIV(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`Slice_Context.L_BRACKET(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionListContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionsContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionsContext.EOF(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionListContext.AllCOMMA(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionListContext.COMMA(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionListContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionListContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`OperandContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`Slice_Context.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionsContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`@2983:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ParamDeclContext.COLON(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ParamTypeContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ParamDeclContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ParamTypeContext.R_BRACKET(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`CallContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`CallContext.L_PAREN(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`CallContext.R_PAREN(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ParamTypeContext.L_BRACKET(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`CallContext.ELLIPSIS(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`CallContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`CallContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`@3114:8(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`Var_Context.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ParamTypeContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`0.0%`	`0/1`
`ExpressionsContext.IsExpressionsContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`MemberContext.IsMemberContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitParamType(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`Slice_Context.IsSlice_Context(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterExpressions(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`Var_Context.IsVar_Context(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`MiscContext.IsMiscContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`IndexContext.IsIndexContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`ExpressionContext.IsExpressionContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`Float_Context.IsFloat_Context(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterMisc(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`ParamDeclContext.IsParamDeclContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`ExpressionListContext.IsExpressionListContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`Nil_Context.IsNil_Context(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`IntegerContext.IsIntegerContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`PrimaryExprContext.IsPrimaryExprContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`ParamCommaContext.IsParamCommaContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`LogicalContext.IsLogicalContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`BasicLitContext.IsBasicLitContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`OperandContext.IsOperandContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`LiteralContext.IsLiteralContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`ParametersContext.IsParametersContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`BaseExprParserListener.VisitTerminal(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.VisitErrorNode(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterEveryRule(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitEveryRule(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterParameters(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitParameters(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterParamComma(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitExpressions(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterParamDecl(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitParamDecl(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterParamType(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`CallContext.IsCallContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitParamComma(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`ParamTypeContext.IsParamTypeContext(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`String_Context.IsString_Context(...)`	`github.com/gobatis/gobatis/parser/expr/expr_parser.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitMisc(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterExpression(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitExpression(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterPrimaryExpr(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitPrimaryExpr(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterLogical(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitLogical(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterOperand(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitOperand(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterVar_(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitVar_(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterMember(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitMember(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterLiteral(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitLiteral(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterBasicLit(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitBasicLit(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterInteger(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitInteger(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterNil_(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitNil_(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterString_(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitString_(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterFloat_(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitFloat_(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterIndex(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitIndex(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterExpressionList(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitExpressionList(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterCall(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitCall(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.EnterSlice_(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`
`BaseExprParserListener.ExitSlice_(...)`	`github.com/gobatis/gobatis/parser/expr/exprparser_base_listener.go`	`100.0%`	`0/0`

func ExprParser.Parameters

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) Parameters() (localctx IParametersContext) {
        localctx = NewParametersContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 0, ExprParserRULE_parameters)

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        var _alt int

        p.EnterOuterAlt(localctx, 1)
        p.SetState(54)
        p.GetErrorHandler().Sync(p)
        switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 1, p.GetParserRuleContext()) {
        case 1:
                {
                        p.SetState(44)
                        p.Match(ExprParserSTAR)
                }

        case 2:
                {
                        p.SetState(45)
                        p.ParamDecl()
                }
                p.SetState(51)
                p.GetErrorHandler().Sync(p)
                _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 0, p.GetParserRuleContext())

                for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
                        if _alt == 1 {
                                {
                                        p.SetState(46)
                                        p.ParamComma()
                                }
                                {
                                        p.SetState(47)
                                        p.ParamDecl()
                                }

                        }
                        p.SetState(53)
                        p.GetErrorHandler().Sync(p)
                        _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 0, p.GetParserRuleContext())
                }

        }
        {
                p.SetState(56)
                p.Match(ExprParserEOF)
        }

        return localctx
}

func ExprParser.Operand

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) Operand() (localctx IOperandContext) {
        localctx = NewOperandContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 18, ExprParserRULE_operand)

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.SetState(131)
        p.GetErrorHandler().Sync(p)
        switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 9, p.GetParserRuleContext()) {
        case 1:
                p.EnterOuterAlt(localctx, 1)
                {
                        p.SetState(125)
                        p.Literal()
                }

        case 2:
                p.EnterOuterAlt(localctx, 2)
                {
                        p.SetState(126)
                        p.Var_()
                }

        case 3:
                p.EnterOuterAlt(localctx, 3)
                {
                        p.SetState(127)
                        p.Match(ExprParserL_PAREN)
                }
                {
                        p.SetState(128)
                        p.expression(0)
                }
                {
                        p.SetState(129)
                        p.Match(ExprParserR_PAREN)
                }

        }

        return localctx
}

func ExprParser.ParamDecl

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) ParamDecl() (localctx IParamDeclContext) {
        localctx = NewParamDeclContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 4, ExprParserRULE_paramDecl)

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.SetState(64)
        p.GetErrorHandler().Sync(p)
        switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 2, p.GetParserRuleContext()) {
        case 1:
                p.EnterOuterAlt(localctx, 1)
                {
                        p.SetState(60)
                        p.Match(ExprParserIDENTIFIER)
                }

        case 2:
                p.EnterOuterAlt(localctx, 2)
                {
                        p.SetState(61)
                        p.Match(ExprParserIDENTIFIER)
                }
                {
                        p.SetState(62)
                        p.Match(ExprParserCOLON)
                }
                {
                        p.SetState(63)
                        p.ParamType()
                }

        }

        return localctx
}

func NewExprLexer

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_lexer.go:

func NewExprLexer(input antlr.CharStream) *ExprLexer {
        l := new(ExprLexer)
        lexerDeserializer := antlr.NewATNDeserializer(nil)
        lexerAtn := lexerDeserializer.DeserializeFromUInt16(serializedLexerAtn)
        lexerDecisionToDFA := make([]*antlr.DFA, len(lexerAtn.DecisionToState))
        for index, ds := range lexerAtn.DecisionToState {
                lexerDecisionToDFA[index] = antlr.NewDFA(ds, index)
        }
        l.BaseLexer = antlr.NewBaseLexer(input)
        l.Interpreter = antlr.NewLexerATNSimulator(l, lexerAtn, lexerDecisionToDFA, antlr.NewPredictionContextCache())

        l.channelNames = lexerChannelNames
        l.modeNames = lexerModeNames
        l.RuleNames = lexerRuleNames
        l.LiteralNames = lexerLiteralNames
        l.SymbolicNames = lexerSymbolicNames
        l.GrammarFileName = "ExprLexer.g4"
        // TODO: l.EOF = antlr.TokenEOF

        return l
}

func NewExprParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewExprParser(input antlr.TokenStream) *ExprParser {
        this := new(ExprParser)
        deserializer := antlr.NewATNDeserializer(nil)
        deserializedATN := deserializer.DeserializeFromUInt16(parserATN)
        decisionToDFA := make([]*antlr.DFA, len(deserializedATN.DecisionToState))
        for index, ds := range deserializedATN.DecisionToState {
                decisionToDFA[index] = antlr.NewDFA(ds, index)
        }
        this.BaseParser = antlr.NewBaseParser(input)

        this.Interpreter = antlr.NewParserATNSimulator(this, deserializedATN, decisionToDFA, antlr.NewPredictionContextCache())
        this.RuleNames = ruleNames
        this.LiteralNames = literalNames
        this.SymbolicNames = symbolicNames
        this.GrammarFileName = "ExprParser.g4"

        return this
}

func ExprParser.Expressions

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) Expressions() (localctx IExpressionsContext) {
        localctx = NewExpressionsContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 8, ExprParserRULE_expressions)

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(72)
                p.expression(0)
        }
        {
                p.SetState(73)
                p.Match(ExprParserEOF)
        }

        return localctx
}

func ExprParser.Var_

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) Var_() (localctx IVar_Context) {
        localctx = NewVar_Context(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 20, ExprParserRULE_var_)

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(133)
                p.Match(ExprParserIDENTIFIER)
        }

        return localctx
}

func ExprParser.ParamComma

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) ParamComma() (localctx IParamCommaContext) {
        localctx = NewParamCommaContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 2, ExprParserRULE_paramComma)

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(58)
                p.Match(ExprParserCOMMA)
        }

        return localctx
}

func ExprParser.Literal

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) Literal() (localctx ILiteralContext) {
        localctx = NewLiteralContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 24, ExprParserRULE_literal)

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(138)
                p.BasicLit()
        }

        return localctx
}

func @368:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func NewPrimaryExprContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewPrimaryExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryExprContext {
        var p = new(PrimaryExprContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_primaryExpr

        return p
}

func NewLogicalContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewLogicalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LogicalContext {
        var p = new(LogicalContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_logical

        return p
}

func NewLiteralContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LiteralContext {
        var p = new(LiteralContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_literal

        return p
}

func NewParamTypeContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewParamTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParamTypeContext {
        var p = new(ParamTypeContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_paramType

        return p
}

func NewIntegerContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewIntegerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntegerContext {
        var p = new(IntegerContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_integer

        return p
}

func NewSlice_Context

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewSlice_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Slice_Context {
        var p = new(Slice_Context)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_slice_

        return p
}

func NewVar_Context

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewVar_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Var_Context {
        var p = new(Var_Context)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_var_

        return p
}

func NewExpressionContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionContext {
        var p = new(ExpressionContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_expression

        return p
}

func NewParamDeclContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewParamDeclContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParamDeclContext {
        var p = new(ParamDeclContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_paramDecl

        return p
}

func NewBasicLitContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewBasicLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BasicLitContext {
        var p = new(BasicLitContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_basicLit

        return p
}

func NewOperandContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewOperandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OperandContext {
        var p = new(OperandContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_operand

        return p
}

func NewParamCommaContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewParamCommaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParamCommaContext {
        var p = new(ParamCommaContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_paramComma

        return p
}

func NewParametersContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewParametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParametersContext {
        var p = new(ParametersContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_parameters

        return p
}

func NewString_Context

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewString_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *String_Context {
        var p = new(String_Context)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_string_

        return p
}

func NewExpressionsContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewExpressionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionsContext {
        var p = new(ExpressionsContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_expressions

        return p
}

func ParamDeclContext.ParamType

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ParamDeclContext) ParamType() IParamTypeContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IParamTypeContext)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(IParamTypeContext)
}

func ParamCommaContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ParamCommaContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitParamComma(s)
        }
}

func ParamTypeContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ParamTypeContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterParamType(s)
        }
}

func ExpressionsContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ExpressionsContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterExpressions(s)
        }
}

func ExpressionsContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ExpressionsContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitExpressions(s)
        }
}

func ParamTypeContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ParamTypeContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitParamType(s)
        }
}

func ExpressionContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterExpression(s)
        }
}

func OperandContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *OperandContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitOperand(s)
        }
}

func ExpressionContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitExpression(s)
        }
}

func OperandContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *OperandContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterOperand(s)
        }
}

func ParamCommaContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ParamCommaContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterParamComma(s)
        }
}

func ParametersContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ParametersContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitParameters(s)
        }
}

func ParametersContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ParametersContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterParameters(s)
        }
}

func Var_Context.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *Var_Context) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterVar_(s)
        }
}

func PrimaryExprContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *PrimaryExprContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitPrimaryExpr(s)
        }
}

func ParamDeclContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ParamDeclContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterParamDecl(s)
        }
}

func ParamDeclContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ParamDeclContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitParamDecl(s)
        }
}

func Var_Context.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *Var_Context) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitVar_(s)
        }
}

func PrimaryExprContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *PrimaryExprContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterPrimaryExpr(s)
        }
}

func @1211:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1211	`func() {`
1212	`p.UnrollRecursionContexts(_parentctx)`
1213	`}`

func @3264:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

3264	`func() {`
3265	`p.ExitRule()`
3266	`}`

func @598:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

598	`func() {`
599	`p.ExitRule()`
600	`}`

func OperandContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1833	`func (s *OperandContext) GetRuleContext() antlr.RuleContext {`
1834	`return s`
1835	`}`

func ParamDeclContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

574	`func (s *ParamDeclContext) GetRuleContext() antlr.RuleContext {`
575	`return s`
576	`}`

func ParamTypeContext.IDENTIFIER

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

682	`func (s *ParamTypeContext) IDENTIFIER() antlr.TerminalNode {`
683	`return s.GetToken(ExprParserIDENTIFIER, 0)`
684	`}`

func @2307:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2307	`func() {`
2308	`p.ExitRule()`
2309	`}`

func @1725:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1725	`func() {`
1726	`p.ExitRule()`
1727	`}`

func ParamTypeContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

694	`func (s *ParamTypeContext) GetRuleContext() antlr.RuleContext {`
695	`return s`
696	`}`

func @1976:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1976	`func() {`
1977	`p.ExitRule()`
1978	`}`

func ParamDeclContext.IDENTIFIER

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

556	`func (s *ParamDeclContext) IDENTIFIER() antlr.TerminalNode {`
557	`return s.GetToken(ExprParserIDENTIFIER, 0)`
558	`}`

func IntegerContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2435	`func (s *IntegerContext) GetRuleContext() antlr.RuleContext {`
2436	`return s`
2437	`}`

func @2460:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2460	`func() {`
2461	`p.ExitRule()`
2462	`}`

func @718:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

718	`func() {`
719	`p.ExitRule()`
720	`}`

func ExpressionContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1177	`func (s *ExpressionContext) GetRuleContext() antlr.RuleContext {`
1178	`return s`
1179	`}`

func Var_Context.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1952	`func (s *Var_Context) GetRuleContext() antlr.RuleContext {`
1953	`return s`
1954	`}`

func String_Context.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2629	`func (s *String_Context) GetRuleContext() antlr.RuleContext {`
2630	`return s`
2631	`}`

func @493:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

493	`func() {`
494	`p.ExitRule()`
495	`}`

func Var_Context.IDENTIFIER

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1948	`func (s *Var_Context) IDENTIFIER() antlr.TerminalNode {`
1949	`return s.GetToken(ExprParserIDENTIFIER, 0)`
1950	`}`

func LogicalContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1700	`func (s *LogicalContext) GetRuleContext() antlr.RuleContext {`
1701	`return s`
1702	`}`

func LiteralContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2148	`func (s *LiteralContext) GetRuleContext() antlr.RuleContext {`
2149	`return s`
2150	`}`

func ExpressionsContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

809	`func (s *ExpressionsContext) GetRuleContext() antlr.RuleContext {`
810	`return s`
811	`}`

func BasicLitContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2283	`func (s *BasicLitContext) GetRuleContext() antlr.RuleContext {`
2284	`return s`
2285	`}`

func Slice_Context.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

3240	`func (s *Slice_Context) GetRuleContext() antlr.RuleContext {`
3241	`return s`
3242	`}`

func ParamCommaContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

469	`func (s *ParamCommaContext) GetRuleContext() antlr.RuleContext {`
470	`return s`
471	`}`

func @2654:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2654	`func() {`
2655	`p.ExitRule()`
2656	`}`

func @833:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

833	`func() {`
834	`p.ExitRule()`
835	`}`

func ExpressionContext.GetTertiary

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1042	`func (s *ExpressionContext) GetTertiary() antlr.Token { return s.tertiary }`

func ExpressionContext.GetRel_op

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1040	`func (s *ExpressionContext) GetRel_op() antlr.Token { return s.rel_op }`

func ExpressionContext.GetAdd_op

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1038	`func (s *ExpressionContext) GetAdd_op() antlr.Token { return s.add_op }`

func @2172:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2172	`func() {`
2173	`p.ExitRule()`
2174	`}`

func ExpressionContext.GetMul_op

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1036	`func (s *ExpressionContext) GetMul_op() antlr.Token { return s.mul_op }`

func ExpressionContext.GetUnary_op

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1034	`func (s *ExpressionContext) GetUnary_op() antlr.Token { return s.unary_op }`

func @1857:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1857	`func() {`
1858	`p.ExitRule()`
1859	`}`

func @364:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

364	`func() {`
365	`p.ExitRule()`
366	`}`

func PrimaryExprContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1525	`func (s *PrimaryExprContext) GetRuleContext() antlr.RuleContext {`
1526	`return s`
1527	`}`

func @1558:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1558	`func() {`
1559	`p.UnrollRecursionContexts(_parentctx)`
1560	`}`

func ParametersContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

340	`func (s *ParametersContext) GetRuleContext() antlr.RuleContext {`
341	`return s`
342	`}`

func ExprParser.Logical

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) Logical() (localctx ILogicalContext) {
        localctx = NewLogicalContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 16, ExprParserRULE_logical)
        var _la int

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(123)
                _la = p.GetTokenStream().LA(1)

                if !(((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<ExprParserLOGICAL_OR)|(1<<ExprParserLOGICAL_AND)|(1<<ExprParserLOGICAL_AND_LOWER)|(1<<ExprParserLOGICAL_OR_LOWER)|(1<<ExprParserLOGICAL_AND_UPPER)|(1<<ExprParserLOGICAL_OR_UPPER))) != 0) {
                        p.GetErrorHandler().RecoverInline(p)
                } else {
                        p.GetErrorHandler().ReportMatch(p)
                        p.Consume()
                }
        }

        return localctx
}

func ExprParser.Integer

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) Integer() (localctx IIntegerContext) {
        localctx = NewIntegerContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 28, ExprParserRULE_integer)
        var _la int

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(148)
                _la = p.GetTokenStream().LA(1)

                if !(((_la-40)&-(0x1f+1)) == 0 && ((1<<uint((_la-40)))&((1<<(ExprParserDECIMAL_LIT-40))|(1<<(ExprParserBINARY_LIT-40))|(1<<(ExprParserOCTAL_LIT-40))|(1<<(ExprParserHEX_LIT-40))|(1<<(ExprParserIMAGINARY_LIT-40))|(1<<(ExprParserRUNE_LIT-40)))) != 0) {
                        p.GetErrorHandler().RecoverInline(p)
                } else {
                        p.GetErrorHandler().ReportMatch(p)
                        p.Consume()
                }
        }

        return localctx
}

func ExprParser.String_

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) String_() (localctx IString_Context) {
        localctx = NewString_Context(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 32, ExprParserRULE_string_)
        var _la int

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(152)
                _la = p.GetTokenStream().LA(1)

                if !(_la == ExprParserRAW_STRING_LIT || _la == ExprParserINTERPRETED_STRING_LIT) {
                        p.GetErrorHandler().RecoverInline(p)
                } else {
                        p.GetErrorHandler().ReportMatch(p)
                        p.Consume()
                }
        }

        return localctx
}

func ExprParser.primaryExpr

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) primaryExpr(_p int) (localctx IPrimaryExprContext) {
        var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
        _parentState := p.GetState()
        localctx = NewPrimaryExprContext(p, p.GetParserRuleContext(), _parentState)
        var _prevctx IPrimaryExprContext = localctx
        var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
        _startState := 14
        p.EnterRecursionRule(localctx, 14, ExprParserRULE_primaryExpr, _p)

        defer func() {
                p.UnrollRecursionContexts(_parentctx)
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        var _alt int

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(109)
                p.Operand()
        }

        p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
        p.SetState(120)
        p.GetErrorHandler().Sync(p)
        _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 8, p.GetParserRuleContext())

        for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
                if _alt == 1 {
                        if p.GetParseListeners() != nil {
                                p.TriggerExitRuleEvent()
                        }
                        _prevctx = localctx
                        localctx = NewPrimaryExprContext(p, _parentctx, _parentState)
                        p.PushNewRecursionContext(localctx, _startState, ExprParserRULE_primaryExpr)
                        p.SetState(111)

                        if !(p.Precpred(p.GetParserRuleContext(), 1)) {
                                panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
                        }
                        p.SetState(116)
                        p.GetErrorHandler().Sync(p)
                        switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 7, p.GetParserRuleContext()) {
                        case 1:
                                {
                                        p.SetState(112)
                                        p.Member()
                                }

                        case 2:
                                {
                                        p.SetState(113)
                                        p.Index()
                                }

                        case 3:
                                {
                                        p.SetState(114)
                                        p.Slice_()
                                }

                        case 4:
                                {
                                        p.SetState(115)
                                        p.Call()
                                }

                        }

                }
                p.SetState(122)
                p.GetErrorHandler().Sync(p)
                _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 8, p.GetParserRuleContext())
        }

        return localctx
}

func ExprParser.expression

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) expression(_p int) (localctx IExpressionContext) {
        var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
        _parentState := p.GetState()
        localctx = NewExpressionContext(p, p.GetParserRuleContext(), _parentState)
        var _prevctx IExpressionContext = localctx
        var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
        _startState := 12
        p.EnterRecursionRule(localctx, 12, ExprParserRULE_expression, _p)
        var _la int

        defer func() {
                p.UnrollRecursionContexts(_parentctx)
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        var _alt int

        p.EnterOuterAlt(localctx, 1)
        p.SetState(82)
        p.GetErrorHandler().Sync(p)
        switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 4, p.GetParserRuleContext()) {
        case 1:
                {
                        p.SetState(79)
                        p.primaryExpr(0)
                }

        case 2:
                {
                        p.SetState(80)

                        var _lt = p.GetTokenStream().LT(1)

                        localctx.(*ExpressionContext).unary_op = _lt

                        _la = p.GetTokenStream().LA(1)

                        if !(((_la-34)&-(0x1f+1)) == 0 && ((1<<uint((_la-34)))&((1<<(ExprParserEXCLAMATION-34))|(1<<(ExprParserPLUS-34))|(1<<(ExprParserMINUS-34))|(1<<(ExprParserCARET-34)))) != 0) {
                                var _ri = p.GetErrorHandler().RecoverInline(p)

                                localctx.(*ExpressionContext).unary_op = _ri
                        } else {
                                p.GetErrorHandler().ReportMatch(p)
                                p.Consume()
                        }
                }
                {
                        p.SetState(81)
                        p.expression(6)
                }

        }
        p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
        p.SetState(105)
        p.GetErrorHandler().Sync(p)
        _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 6, p.GetParserRuleContext())

        for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
                if _alt == 1 {
                        if p.GetParseListeners() != nil {
                                p.TriggerExitRuleEvent()
                        }
                        _prevctx = localctx
                        p.SetState(103)
                        p.GetErrorHandler().Sync(p)
                        switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 5, p.GetParserRuleContext()) {
                        case 1:
                                localctx = NewExpressionContext(p, _parentctx, _parentState)
                                p.PushNewRecursionContext(localctx, _startState, ExprParserRULE_expression)
                                p.SetState(84)

                                if !(p.Precpred(p.GetParserRuleContext(), 5)) {
                                        panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", ""))
                                }
                                {
                                        p.SetState(85)

                                        var _lt = p.GetTokenStream().LT(1)

                                        localctx.(*ExpressionContext).mul_op = _lt

                                        _la = p.GetTokenStream().LA(1)

                                        if !(((_la-29)&-(0x1f+1)) == 0 && ((1<<uint((_la-29)))&((1<<(ExprParserDIV-29))|(1<<(ExprParserMOD-29))|(1<<(ExprParserLSHIFT-29))|(1<<(ExprParserRSHIFT-29))|(1<<(ExprParserBIT_CLEAR-29))|(1<<(ExprParserSTAR-29))|(1<<(ExprParserAMPERSAND-29)))) != 0) {
                                                var _ri = p.GetErrorHandler().RecoverInline(p)

                                                localctx.(*ExpressionContext).mul_op = _ri
                                        } else {
                                                p.GetErrorHandler().ReportMatch(p)
                                                p.Consume()
                                        }
                                }
                                {
                                        p.SetState(86)
                                        p.expression(6)
                                }

                        case 2:
                                localctx = NewExpressionContext(p, _parentctx, _parentState)
                                p.PushNewRecursionContext(localctx, _startState, ExprParserRULE_expression)
                                p.SetState(87)

                                if !(p.Precpred(p.GetParserRuleContext(), 4)) {
                                        panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", ""))
                                }
                                {
                                        p.SetState(88)

                                        var _lt = p.GetTokenStream().LT(1)

                                        localctx.(*ExpressionContext).add_op = _lt

                                        _la = p.GetTokenStream().LA(1)

                                        if !(((_la-28)&-(0x1f+1)) == 0 && ((1<<uint((_la-28)))&((1<<(ExprParserOR-28))|(1<<(ExprParserPLUS-28))|(1<<(ExprParserMINUS-28))|(1<<(ExprParserCARET-28)))) != 0) {
                                                var _ri = p.GetErrorHandler().RecoverInline(p)

                                                localctx.(*ExpressionContext).add_op = _ri
                                        } else {
                                                p.GetErrorHandler().ReportMatch(p)
                                                p.Consume()
                                        }
                                }
                                {
                                        p.SetState(89)
                                        p.expression(5)
                                }

                        case 3:
                                localctx = NewExpressionContext(p, _parentctx, _parentState)
                                p.PushNewRecursionContext(localctx, _startState, ExprParserRULE_expression)
                                p.SetState(90)

                                if !(p.Precpred(p.GetParserRuleContext(), 3)) {
                                        panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
                                }
                                {
                                        p.SetState(91)

                                        var _lt = p.GetTokenStream().LT(1)

                                        localctx.(*ExpressionContext).rel_op = _lt

                                        _la = p.GetTokenStream().LA(1)

                                        if !(((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<ExprParserEQUALS)|(1<<ExprParserNOT_EQUALS)|(1<<ExprParserLESS)|(1<<ExprParserLESS_OR_EQUALS)|(1<<ExprParserGREATER)|(1<<ExprParserGREATER_OR_EQUALS))) != 0) {
                                                var _ri = p.GetErrorHandler().RecoverInline(p)

                                                localctx.(*ExpressionContext).rel_op = _ri
                                        } else {
                                                p.GetErrorHandler().ReportMatch(p)
                                                p.Consume()
                                        }
                                }
                                {
                                        p.SetState(92)
                                        p.expression(4)
                                }

                        case 4:
                                localctx = NewExpressionContext(p, _parentctx, _parentState)
                                p.PushNewRecursionContext(localctx, _startState, ExprParserRULE_expression)
                                p.SetState(93)

                                if !(p.Precpred(p.GetParserRuleContext(), 2)) {
                                        panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
                                }
                                {
                                        p.SetState(94)
                                        p.Logical()
                                }
                                {
                                        p.SetState(95)
                                        p.expression(3)
                                }

                        case 5:
                                localctx = NewExpressionContext(p, _parentctx, _parentState)
                                p.PushNewRecursionContext(localctx, _startState, ExprParserRULE_expression)
                                p.SetState(97)

                                if !(p.Precpred(p.GetParserRuleContext(), 1)) {
                                        panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
                                }
                                {
                                        p.SetState(98)

                                        var _m = p.Match(ExprParserQUESTION)

                                        localctx.(*ExpressionContext).tertiary = _m
                                }
                                {
                                        p.SetState(99)
                                        p.expression(0)
                                }
                                {
                                        p.SetState(100)
                                        p.Match(ExprParserCOLON)
                                }
                                {
                                        p.SetState(101)
                                        p.expression(2)
                                }

                        }

                }
                p.SetState(107)
                p.GetErrorHandler().Sync(p)
                _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 6, p.GetParserRuleContext())
        }

        return localctx
}

func ExpressionContext.Logical

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ExpressionContext) Logical() ILogicalContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*ILogicalContext)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(ILogicalContext)
}

func ExprParser.ParamType

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) ParamType() (localctx IParamTypeContext) {
        localctx = NewParamTypeContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 6, ExprParserRULE_paramType)

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        p.SetState(68)
        p.GetErrorHandler().Sync(p)

        if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 3, p.GetParserRuleContext()) == 1 {
                {
                        p.SetState(66)
                        p.Match(ExprParserL_BRACKET)
                }
                {
                        p.SetState(67)
                        p.Match(ExprParserR_BRACKET)
                }

        }
        {
                p.SetState(70)
                p.Match(ExprParserIDENTIFIER)
        }

        return localctx
}

func ExprParser.Slice_

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) Slice_() (localctx ISlice_Context) {
        localctx = NewSlice_Context(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 42, ExprParserRULE_slice_)

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(177)
                p.Match(ExprParserL_BRACKET)
        }
        p.SetState(193)
        p.GetErrorHandler().Sync(p)
        switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 17, p.GetParserRuleContext()) {
        case 1:
                p.SetState(179)
                p.GetErrorHandler().Sync(p)

                if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 14, p.GetParserRuleContext()) == 1 {
                        {
                                p.SetState(178)
                                p.expression(0)
                        }

                }
                {
                        p.SetState(181)
                        p.Match(ExprParserCOLON)
                }
                p.SetState(183)
                p.GetErrorHandler().Sync(p)

                if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 15, p.GetParserRuleContext()) == 1 {
                        {
                                p.SetState(182)
                                p.expression(0)
                        }

                }

        case 2:
                p.SetState(186)
                p.GetErrorHandler().Sync(p)

                if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 16, p.GetParserRuleContext()) == 1 {
                        {
                                p.SetState(185)
                                p.expression(0)
                        }

                }
                {
                        p.SetState(188)
                        p.Match(ExprParserCOLON)
                }
                {
                        p.SetState(189)
                        p.expression(0)
                }
                {
                        p.SetState(190)
                        p.Match(ExprParserCOLON)
                }
                {
                        p.SetState(191)
                        p.expression(0)
                }

        }
        {
                p.SetState(195)
                p.Match(ExprParserR_BRACKET)
        }

        return localctx
}

func ExprParser.BasicLit

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) BasicLit() (localctx IBasicLitContext) {
        localctx = NewBasicLitContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 26, ExprParserRULE_basicLit)

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.SetState(146)
        p.GetErrorHandler().Sync(p)
        switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 10, p.GetParserRuleContext()) {
        case 1:
                p.EnterOuterAlt(localctx, 1)
                {
                        p.SetState(140)
                        p.Nil_()
                }

        case 2:
                p.EnterOuterAlt(localctx, 2)
                {
                        p.SetState(141)
                        p.Integer()
                }

        case 3:
                p.EnterOuterAlt(localctx, 3)
                {
                        p.SetState(142)
                        p.String_()
                }

        case 4:
                p.EnterOuterAlt(localctx, 4)
                {
                        p.SetState(143)
                        p.Float_()
                }

        case 5:
                p.EnterOuterAlt(localctx, 5)
                {
                        p.SetState(144)
                        p.Match(ExprParserIMAGINARY_LIT)
                }

        case 6:
                p.EnterOuterAlt(localctx, 6)
                {
                        p.SetState(145)
                        p.Match(ExprParserRUNE_LIT)
                }

        }

        return localctx
}

func Slice_Context.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *Slice_Context) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitSlice_(s)
        }
}

func LogicalContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *LogicalContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitLogical(s)
        }
}

func IntegerContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *IntegerContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterInteger(s)
        }
}

func IntegerContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *IntegerContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitInteger(s)
        }
}

func BasicLitContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *BasicLitContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitBasicLit(s)
        }
}

func Slice_Context.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *Slice_Context) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterSlice_(s)
        }
}

func BasicLitContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *BasicLitContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterBasicLit(s)
        }
}

func String_Context.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *String_Context) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitString_(s)
        }
}

func LiteralContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *LiteralContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterLiteral(s)
        }
}

func LiteralContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *LiteralContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitLiteral(s)
        }
}

func LogicalContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *LogicalContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterLogical(s)
        }
}

func String_Context.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *String_Context) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterString_(s)
        }
}

func @1980:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func @1215:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func @2176:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func @722:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func @2658:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func @2311:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func @1729:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func @2464:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func @3268:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func @1861:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func @602:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func @837:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func @497:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func @1562:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func ExprParser.ExpressionList

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) ExpressionList() (localctx IExpressionListContext) {
        localctx = NewExpressionListContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 38, ExprParserRULE_expressionList)

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        var _alt int

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(160)
                p.expression(0)
        }
        p.SetState(165)
        p.GetErrorHandler().Sync(p)
        _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 11, p.GetParserRuleContext())

        for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
                if _alt == 1 {
                        {
                                p.SetState(161)
                                p.Match(ExprParserCOMMA)
                        }
                        {
                                p.SetState(162)
                                p.expression(0)
                        }

                }
                p.SetState(167)
                p.GetErrorHandler().Sync(p)
                _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 11, p.GetParserRuleContext())
        }

        return localctx
}

func ExprParser.Call

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) Call() (localctx ICallContext) {
        localctx = NewCallContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 40, ExprParserRULE_call)

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(168)
                p.Match(ExprParserL_PAREN)
        }
        p.SetState(173)
        p.GetErrorHandler().Sync(p)

        if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 13, p.GetParserRuleContext()) == 1 {
                {
                        p.SetState(169)
                        p.ExpressionList()
                }
                p.SetState(171)
                p.GetErrorHandler().Sync(p)

                if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 12, p.GetParserRuleContext()) == 1 {
                        {
                                p.SetState(170)
                                p.Match(ExprParserELLIPSIS)
                        }

                }

        }
        {
                p.SetState(175)
                p.Match(ExprParserR_PAREN)
        }

        return localctx
}

func ExprParser.Index

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) Index() (localctx IIndexContext) {
        localctx = NewIndexContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 36, ExprParserRULE_index)

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(156)
                p.Match(ExprParserL_BRACKET)
        }
        {
                p.SetState(157)
                p.expression(0)
        }
        {
                p.SetState(158)
                p.Match(ExprParserR_BRACKET)
        }

        return localctx
}

func ExprParser.Member

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) Member() (localctx IMemberContext) {
        localctx = NewMemberContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 22, ExprParserRULE_member)

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(135)
                p.Match(ExprParserDOT)
        }
        {
                p.SetState(136)
                p.Match(ExprParserIDENTIFIER)
        }

        return localctx
}

func ExprParser.Sempred

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool {
        switch ruleIndex {
        case 6:
                var t *ExpressionContext = nil
                if localctx != nil {
                        t = localctx.(*ExpressionContext)
                }
                return p.Expression_Sempred(t, predIndex)

        case 7:
                var t *PrimaryExprContext = nil
                if localctx != nil {
                        t = localctx.(*PrimaryExprContext)
                }
                return p.PrimaryExpr_Sempred(t, predIndex)

        default:
                panic("No predicate with index: " + fmt.Sprint(ruleIndex))
        }
}

func ExprParser.Misc

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) Misc() (localctx IMiscContext) {
        localctx = NewMiscContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 10, ExprParserRULE_misc)

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(75)
                p.Match(ExprParserWS)
        }
        {
                p.SetState(76)
                p.Match(ExprParserTERMINATOR)
        }

        return localctx
}

func ExprParser.Nil_

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) Nil_() (localctx INil_Context) {
        localctx = NewNil_Context(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 30, ExprParserRULE_nil_)

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(150)
                p.Match(ExprParserNIL_LIT)
        }

        return localctx
}

func ExprParser.Float_

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) Float_() (localctx IFloat_Context) {
        localctx = NewFloat_Context(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 34, ExprParserRULE_float_)

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(154)
                p.Match(ExprParserFLOAT_LIT)
        }

        return localctx
}

func ExprParser.Expression_Sempred

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) Expression_Sempred(localctx antlr.RuleContext, predIndex int) bool {
        switch predIndex {
        case 0:
                return p.Precpred(p.GetParserRuleContext(), 5)

        case 1:
                return p.Precpred(p.GetParserRuleContext(), 4)

        case 2:
                return p.Precpred(p.GetParserRuleContext(), 3)

        case 3:
                return p.Precpred(p.GetParserRuleContext(), 2)

        case 4:
                return p.Precpred(p.GetParserRuleContext(), 1)

        default:
                panic("No predicate with index: " + fmt.Sprint(predIndex))
        }
}

func Slice_Context.AllExpression

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *Slice_Context) AllExpression() []IExpressionContext {
        var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpressionContext)(nil)).Elem())
        var tst = make([]IExpressionContext, len(ts))

        for i, t := range ts {
                if t != nil {
                        tst[i] = t.(IExpressionContext)
                }
        }

        return tst
}

func @936:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func ExpressionContext.AllExpression

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ExpressionContext) AllExpression() []IExpressionContext {
        var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpressionContext)(nil)).Elem())
        var tst = make([]IExpressionContext, len(ts))

        for i, t := range ts {
                if t != nil {
                        tst[i] = t.(IExpressionContext)
                }
        }

        return tst
}

func @2075:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func ParametersContext.AllParamComma

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ParametersContext) AllParamComma() []IParamCommaContext {
        var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IParamCommaContext)(nil)).Elem())
        var tst = make([]IParamCommaContext, len(ts))

        for i, t := range ts {
                if t != nil {
                        tst[i] = t.(IParamCommaContext)
                }
        }

        return tst
}

func @3118:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func @2987:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func ExpressionListContext.AllExpression

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ExpressionListContext) AllExpression() []IExpressionContext {
        var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpressionContext)(nil)).Elem())
        var tst = make([]IExpressionContext, len(ts))

        for i, t := range ts {
                if t != nil {
                        tst[i] = t.(IExpressionContext)
                }
        }

        return tst
}

func @2861:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func ParametersContext.AllParamDecl

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ParametersContext) AllParamDecl() []IParamDeclContext {
        var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IParamDeclContext)(nil)).Elem())
        var tst = make([]IParamDeclContext, len(ts))

        for i, t := range ts {
                if t != nil {
                        tst[i] = t.(IParamDeclContext)
                }
        }

        return tst
}

func @2562:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func @2756:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func NewExpressionListContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewExpressionListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionListContext {
        var p = new(ExpressionListContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_expressionList

        return p
}

func NewIndexContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewIndexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexContext {
        var p = new(IndexContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_index

        return p
}

func NewNil_Context

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewNil_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Nil_Context {
        var p = new(Nil_Context)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_nil_

        return p
}

func NewMemberContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewMemberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MemberContext {
        var p = new(MemberContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_member

        return p
}

func NewFloat_Context

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewFloat_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Float_Context {
        var p = new(Float_Context)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_float_

        return p
}

func NewCallContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CallContext {
        var p = new(CallContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_call

        return p
}

func NewMiscContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewMiscContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MiscContext {
        var p = new(MiscContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = ExprParserRULE_misc

        return p
}

func CallContext.ExpressionList

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *CallContext) ExpressionList() IExpressionListContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionListContext)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(IExpressionListContext)
}

func NewEmptyParamTypeContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyParamTypeContext() *ParamTypeContext {
        var p = new(ParamTypeContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_paramType
        return p
}

func BasicLitContext.Nil_

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *BasicLitContext) Nil_() INil_Context {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*INil_Context)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(INil_Context)
}

func IndexContext.Expression

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *IndexContext) Expression() IExpressionContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(IExpressionContext)
}

func NewEmptyLogicalContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyLogicalContext() *LogicalContext {
        var p = new(LogicalContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_logical
        return p
}

func PrimaryExprContext.Operand

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *PrimaryExprContext) Operand() IOperandContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IOperandContext)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(IOperandContext)
}

func BasicLitContext.String_

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *BasicLitContext) String_() IString_Context {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IString_Context)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(IString_Context)
}

func NewEmptyBasicLitContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyBasicLitContext() *BasicLitContext {
        var p = new(BasicLitContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_basicLit
        return p
}

func NewEmptyExpressionListContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyExpressionListContext() *ExpressionListContext {
        var p = new(ExpressionListContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_expressionList
        return p
}

func PrimaryExprContext.PrimaryExpr

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *PrimaryExprContext) PrimaryExpr() IPrimaryExprContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryExprContext)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(IPrimaryExprContext)
}

func NewEmptyIntegerContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyIntegerContext() *IntegerContext {
        var p = new(IntegerContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_integer
        return p
}

func NewEmptyMiscContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyMiscContext() *MiscContext {
        var p = new(MiscContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_misc
        return p
}

func NewEmptyExpressionContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyExpressionContext() *ExpressionContext {
        var p = new(ExpressionContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_expression
        return p
}

func ExpressionListContext.Expression

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ExpressionListContext) Expression(i int) IExpressionContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), i)

        if t == nil {
                return nil
        }

        return t.(IExpressionContext)
}

func ExpressionsContext.Expression

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ExpressionsContext) Expression() IExpressionContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(IExpressionContext)
}

func LiteralContext.BasicLit

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *LiteralContext) BasicLit() IBasicLitContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IBasicLitContext)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(IBasicLitContext)
}

func BasicLitContext.Float_

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *BasicLitContext) Float_() IFloat_Context {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IFloat_Context)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(IFloat_Context)
}

func NewEmptyExpressionsContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyExpressionsContext() *ExpressionsContext {
        var p = new(ExpressionsContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_expressions
        return p
}

func NewEmptyCallContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyCallContext() *CallContext {
        var p = new(CallContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_call
        return p
}

func PrimaryExprContext.Member

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *PrimaryExprContext) Member() IMemberContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IMemberContext)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(IMemberContext)
}

func PrimaryExprContext.Slice_

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *PrimaryExprContext) Slice_() ISlice_Context {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*ISlice_Context)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(ISlice_Context)
}

func NewEmptyOperandContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyOperandContext() *OperandContext {
        var p = new(OperandContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_operand
        return p
}

func NewEmptyPrimaryExprContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyPrimaryExprContext() *PrimaryExprContext {
        var p = new(PrimaryExprContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_primaryExpr
        return p
}

func NewEmptyIndexContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyIndexContext() *IndexContext {
        var p = new(IndexContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_index
        return p
}

func NewEmptyLiteralContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyLiteralContext() *LiteralContext {
        var p = new(LiteralContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_literal
        return p
}

func OperandContext.Literal

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *OperandContext) Literal() ILiteralContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*ILiteralContext)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(ILiteralContext)
}

func OperandContext.Var_

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *OperandContext) Var_() IVar_Context {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IVar_Context)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(IVar_Context)
}

func BasicLitContext.Integer

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *BasicLitContext) Integer() IIntegerContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IIntegerContext)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(IIntegerContext)
}

func OperandContext.Expression

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *OperandContext) Expression() IExpressionContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(IExpressionContext)
}

func NewEmptyFloat_Context

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyFloat_Context() *Float_Context {
        var p = new(Float_Context)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_float_
        return p
}

func NewEmptySlice_Context

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptySlice_Context() *Slice_Context {
        var p = new(Slice_Context)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_slice_
        return p
}

func PrimaryExprContext.Index

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *PrimaryExprContext) Index() IIndexContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndexContext)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(IIndexContext)
}

func ExpressionContext.PrimaryExpr

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ExpressionContext) PrimaryExpr() IPrimaryExprContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryExprContext)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(IPrimaryExprContext)
}

func Slice_Context.Expression

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *Slice_Context) Expression(i int) IExpressionContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), i)

        if t == nil {
                return nil
        }

        return t.(IExpressionContext)
}

func NewEmptyParamDeclContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyParamDeclContext() *ParamDeclContext {
        var p = new(ParamDeclContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_paramDecl
        return p
}

func NewEmptyParamCommaContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyParamCommaContext() *ParamCommaContext {
        var p = new(ParamCommaContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_paramComma
        return p
}

func ParametersContext.ParamComma

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ParametersContext) ParamComma(i int) IParamCommaContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IParamCommaContext)(nil)).Elem(), i)

        if t == nil {
                return nil
        }

        return t.(IParamCommaContext)
}

func NewEmptyVar_Context

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyVar_Context() *Var_Context {
        var p = new(Var_Context)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_var_
        return p
}

func NewEmptyMemberContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyMemberContext() *MemberContext {
        var p = new(MemberContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_member
        return p
}

func ExpressionContext.Expression

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ExpressionContext) Expression(i int) IExpressionContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), i)

        if t == nil {
                return nil
        }

        return t.(IExpressionContext)
}

func ParametersContext.ParamDecl

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ParametersContext) ParamDecl(i int) IParamDeclContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IParamDeclContext)(nil)).Elem(), i)

        if t == nil {
                return nil
        }

        return t.(IParamDeclContext)
}

func NewEmptyString_Context

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyString_Context() *String_Context {
        var p = new(String_Context)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_string_
        return p
}

func PrimaryExprContext.Call

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *PrimaryExprContext) Call() ICallContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*ICallContext)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(ICallContext)
}

func NewEmptyNil_Context

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyNil_Context() *Nil_Context {
        var p = new(Nil_Context)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_nil_
        return p
}

func NewEmptyParametersContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func NewEmptyParametersContext() *ParametersContext {
        var p = new(ParametersContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = ExprParserRULE_parameters
        return p
}

func ExprParser.PrimaryExpr_Sempred

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (p *ExprParser) PrimaryExpr_Sempred(localctx antlr.RuleContext, predIndex int) bool {
        switch predIndex {
        case 5:
                return p.Precpred(p.GetParserRuleContext(), 1)

        default:
                panic("No predicate with index: " + fmt.Sprint(predIndex))
        }
}

func IndexContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *IndexContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterIndex(s)
        }
}

func Nil_Context.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *Nil_Context) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterNil_(s)
        }
}

func CallContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *CallContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitCall(s)
        }
}

func CallContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *CallContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterCall(s)
        }
}

func ExpressionListContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ExpressionListContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitExpressionList(s)
        }
}

func ExpressionListContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *ExpressionListContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterExpressionList(s)
        }
}

func IndexContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *IndexContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitIndex(s)
        }
}

func MiscContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *MiscContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterMisc(s)
        }
}

func MiscContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *MiscContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitMisc(s)
        }
}

func Float_Context.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *Float_Context) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitFloat_(s)
        }
}

func Float_Context.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *Float_Context) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterFloat_(s)
        }
}

func MemberContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *MemberContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.EnterMember(s)
        }
}

func MemberContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *MemberContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitMember(s)
        }
}

func Nil_Context.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

func (s *Nil_Context) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(ExprParserListener); ok {
                listenerT.ExitNil_(s)
        }
}

func IndexContext.R_BRACKET

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2829	`func (s *IndexContext) R_BRACKET() antlr.TerminalNode {`
2830	`return s.GetToken(ExprParserR_BRACKET, 0)`
2831	`}`

func LogicalContext.LOGICAL_AND

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1676	`func (s *LogicalContext) LOGICAL_AND() antlr.TerminalNode {`
1677	`return s.GetToken(ExprParserLOGICAL_AND, 0)`
1678	`}`

func OperandContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1793	`func (s *OperandContext) GetParser() antlr.Parser { return s.parser }`

func ParametersContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

284	`func (s *ParametersContext) GetParser() antlr.Parser { return s.parser }`

func ParametersContext.EOF

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

286	`func (s *ParametersContext) EOF() antlr.TerminalNode {`
287	`return s.GetToken(ExprParserEOF, 0)`
288	`}`

func MiscContext.WS

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

900	`func (s *MiscContext) WS() antlr.TerminalNode {`
901	`return s.GetToken(ExprParserWS, 0)`
902	`}`

func LogicalContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1704	`func (s *LogicalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
1705	`return antlr.TreesStringTree(s, ruleNames, recog)`
1706	`}`

func LogicalContext.LOGICAL_OR_UPPER

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1696	`func (s *LogicalContext) LOGICAL_OR_UPPER() antlr.TerminalNode {`
1697	`return s.GetToken(ExprParserLOGICAL_OR_UPPER, 0)`
1698	`}`

func LiteralContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2152	`func (s *LiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
2153	`return antlr.TreesStringTree(s, ruleNames, recog)`
2154	`}`

func LogicalContext.LOGICAL_AND_UPPER

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1692	`func (s *LogicalContext) LOGICAL_AND_UPPER() antlr.TerminalNode {`
1693	`return s.GetToken(ExprParserLOGICAL_AND_UPPER, 0)`
1694	`}`

func LogicalContext.LOGICAL_OR_LOWER

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1688	`func (s *LogicalContext) LOGICAL_OR_LOWER() antlr.TerminalNode {`
1689	`return s.GetToken(ExprParserLOGICAL_OR_LOWER, 0)`
1690	`}`

func LogicalContext.LOGICAL_AND_LOWER

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1684	`func (s *LogicalContext) LOGICAL_AND_LOWER() antlr.TerminalNode {`
1685	`return s.GetToken(ExprParserLOGICAL_AND_LOWER, 0)`
1686	`}`

func LogicalContext.LOGICAL_OR

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1680	`func (s *LogicalContext) LOGICAL_OR() antlr.TerminalNode {`
1681	`return s.GetToken(ExprParserLOGICAL_OR, 0)`
1682	`}`

func MiscContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

898	`func (s *MiscContext) GetParser() antlr.Parser { return s.parser }`

func LogicalContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1674	`func (s *LogicalContext) GetParser() antlr.Parser { return s.parser }`

func ParametersContext.STAR

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

290	`func (s *ParametersContext) STAR() antlr.TerminalNode {`
291	`return s.GetToken(ExprParserSTAR, 0)`
292	`}`

func ParametersContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

344	`func (s *ParametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
345	`return antlr.TreesStringTree(s, ruleNames, recog)`
346	`}`

func BasicLitContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2233	`func (s *BasicLitContext) GetParser() antlr.Parser { return s.parser }`

func ExprParser.PrimaryExpr

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1545	`func (p *ExprParser) PrimaryExpr() (localctx IPrimaryExprContext) {`
1546	`return p.primaryExpr(0)`
1547	`}`

func PrimaryExprContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1529	`func (s *PrimaryExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
1530	`return antlr.TreesStringTree(s, ruleNames, recog)`
1531	`}`

func PrimaryExprContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1463	`func (s *PrimaryExprContext) GetParser() antlr.Parser { return s.parser }`

func ParamCommaContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

463	`func (s *ParamCommaContext) GetParser() antlr.Parser { return s.parser }`

func BasicLitContext.IMAGINARY_LIT

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2275	`func (s *BasicLitContext) IMAGINARY_LIT() antlr.TerminalNode {`
2276	`return s.GetToken(ExprParserIMAGINARY_LIT, 0)`
2277	`}`

func BasicLitContext.RUNE_LIT

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2279	`func (s *BasicLitContext) RUNE_LIT() antlr.TerminalNode {`
2280	`return s.GetToken(ExprParserRUNE_LIT, 0)`
2281	`}`

func ExprParser.Expression

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1197	`func (p *ExprParser) Expression() (localctx IExpressionContext) {`
1198	`return p.expression(0)`
1199	`}`

func BasicLitContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2287	`func (s *BasicLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
2288	`return antlr.TreesStringTree(s, ruleNames, recog)`
2289	`}`

func ExpressionContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1181	`func (s *ExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
1182	`return antlr.TreesStringTree(s, ruleNames, recog)`
1183	`}`

func ExpressionContext.QUESTION

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1173	`func (s *ExpressionContext) QUESTION() antlr.TerminalNode {`
1174	`return s.GetToken(ExprParserQUESTION, 0)`
1175	`}`

func ExpressionContext.COLON

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1169	`func (s *ExpressionContext) COLON() antlr.TerminalNode {`
1170	`return s.GetToken(ExprParserCOLON, 0)`
1171	`}`

func ExpressionContext.GREATER_OR_EQUALS

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1155	`func (s *ExpressionContext) GREATER_OR_EQUALS() antlr.TerminalNode {`
1156	`return s.GetToken(ExprParserGREATER_OR_EQUALS, 0)`
1157	`}`

func ExpressionContext.GREATER

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1151	`func (s *ExpressionContext) GREATER() antlr.TerminalNode {`
1152	`return s.GetToken(ExprParserGREATER, 0)`
1153	`}`

func ExpressionContext.LESS_OR_EQUALS

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1147	`func (s *ExpressionContext) LESS_OR_EQUALS() antlr.TerminalNode {`
1148	`return s.GetToken(ExprParserLESS_OR_EQUALS, 0)`
1149	`}`

func ParamCommaContext.COMMA

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

465	`func (s *ParamCommaContext) COMMA() antlr.TerminalNode {`
466	`return s.GetToken(ExprParserCOMMA, 0)`
467	`}`

func ExpressionContext.LESS

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1143	`func (s *ExpressionContext) LESS() antlr.TerminalNode {`
1144	`return s.GetToken(ExprParserLESS, 0)`
1145	`}`

func IntegerContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2409	`func (s *IntegerContext) GetParser() antlr.Parser { return s.parser }`

func IntegerContext.DECIMAL_LIT

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2411	`func (s *IntegerContext) DECIMAL_LIT() antlr.TerminalNode {`
2412	`return s.GetToken(ExprParserDECIMAL_LIT, 0)`
2413	`}`

func IntegerContext.BINARY_LIT

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2415	`func (s *IntegerContext) BINARY_LIT() antlr.TerminalNode {`
2416	`return s.GetToken(ExprParserBINARY_LIT, 0)`
2417	`}`

func IntegerContext.OCTAL_LIT

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2419	`func (s *IntegerContext) OCTAL_LIT() antlr.TerminalNode {`
2420	`return s.GetToken(ExprParserOCTAL_LIT, 0)`
2421	`}`

func IntegerContext.HEX_LIT

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2423	`func (s *IntegerContext) HEX_LIT() antlr.TerminalNode {`
2424	`return s.GetToken(ExprParserHEX_LIT, 0)`
2425	`}`

func IntegerContext.IMAGINARY_LIT

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2427	`func (s *IntegerContext) IMAGINARY_LIT() antlr.TerminalNode {`
2428	`return s.GetToken(ExprParserIMAGINARY_LIT, 0)`
2429	`}`

func IntegerContext.RUNE_LIT

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2431	`func (s *IntegerContext) RUNE_LIT() antlr.TerminalNode {`
2432	`return s.GetToken(ExprParserRUNE_LIT, 0)`
2433	`}`

func ExpressionContext.NOT_EQUALS

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1139	`func (s *ExpressionContext) NOT_EQUALS() antlr.TerminalNode {`
1140	`return s.GetToken(ExprParserNOT_EQUALS, 0)`
1141	`}`

func IntegerContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2439	`func (s *IntegerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
2440	`return antlr.TreesStringTree(s, ruleNames, recog)`
2441	`}`

func ExpressionContext.EQUALS

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1135	`func (s *ExpressionContext) EQUALS() antlr.TerminalNode {`
1136	`return s.GetToken(ExprParserEQUALS, 0)`
1137	`}`

func ExpressionContext.OR

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1131	`func (s *ExpressionContext) OR() antlr.TerminalNode {`
1132	`return s.GetToken(ExprParserOR, 0)`
1133	`}`

func ExpressionContext.BIT_CLEAR

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1127	`func (s *ExpressionContext) BIT_CLEAR() antlr.TerminalNode {`
1128	`return s.GetToken(ExprParserBIT_CLEAR, 0)`
1129	`}`

func ExpressionContext.AMPERSAND

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1123	`func (s *ExpressionContext) AMPERSAND() antlr.TerminalNode {`
1124	`return s.GetToken(ExprParserAMPERSAND, 0)`
1125	`}`

func ExpressionContext.RSHIFT

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1119	`func (s *ExpressionContext) RSHIFT() antlr.TerminalNode {`
1120	`return s.GetToken(ExprParserRSHIFT, 0)`
1121	`}`

func ExpressionContext.LSHIFT

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1115	`func (s *ExpressionContext) LSHIFT() antlr.TerminalNode {`
1116	`return s.GetToken(ExprParserLSHIFT, 0)`
1117	`}`

func Slice_Context.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

3244	`func (s *Slice_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
3245	`return antlr.TreesStringTree(s, ruleNames, recog)`
3246	`}`

func ExpressionContext.MOD

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1111	`func (s *ExpressionContext) MOD() antlr.TerminalNode {`
1112	`return s.GetToken(ExprParserMOD, 0)`
1113	`}`

func Nil_Context.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2528	`func (s *Nil_Context) GetParser() antlr.Parser { return s.parser }`

func Nil_Context.NIL_LIT

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2530	`func (s *Nil_Context) NIL_LIT() antlr.TerminalNode {`
2531	`return s.GetToken(ExprParserNIL_LIT, 0)`
2532	`}`

func Nil_Context.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2534	`func (s *Nil_Context) GetRuleContext() antlr.RuleContext {`
2535	`return s`
2536	`}`

func Nil_Context.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2538	`func (s *Nil_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
2539	`return antlr.TreesStringTree(s, ruleNames, recog)`
2540	`}`

func @2071:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2071	`func() {`
2072	`p.ExitRule()`
2073	`}`

func OperandContext.R_PAREN

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1829	`func (s *OperandContext) R_PAREN() antlr.TerminalNode {`
1830	`return s.GetToken(ExprParserR_PAREN, 0)`
1831	`}`

func ParamCommaContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

473	`func (s *ParamCommaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
474	`return antlr.TreesStringTree(s, ruleNames, recog)`
475	`}`

func @2558:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2558	`func() {`
2559	`p.ExitRule()`
2560	`}`

func ExpressionContext.STAR

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1103	`func (s *ExpressionContext) STAR() antlr.TerminalNode {`
1104	`return s.GetToken(ExprParserSTAR, 0)`
1105	`}`

func ExpressionContext.CARET

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1099	`func (s *ExpressionContext) CARET() antlr.TerminalNode {`
1100	`return s.GetToken(ExprParserCARET, 0)`
1101	`}`

func ParamDeclContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

554	`func (s *ParamDeclContext) GetParser() antlr.Parser { return s.parser }`

func ExpressionContext.EXCLAMATION

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1095	`func (s *ExpressionContext) EXCLAMATION() antlr.TerminalNode {`
1096	`return s.GetToken(ExprParserEXCLAMATION, 0)`
1097	`}`

func String_Context.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2619	`func (s *String_Context) GetParser() antlr.Parser { return s.parser }`

func String_Context.RAW_STRING_LIT

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2621	`func (s *String_Context) RAW_STRING_LIT() antlr.TerminalNode {`
2622	`return s.GetToken(ExprParserRAW_STRING_LIT, 0)`
2623	`}`

func String_Context.INTERPRETED_STRING_LIT

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2625	`func (s *String_Context) INTERPRETED_STRING_LIT() antlr.TerminalNode {`
2626	`return s.GetToken(ExprParserINTERPRETED_STRING_LIT, 0)`
2627	`}`

func ExpressionContext.MINUS

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1091	`func (s *ExpressionContext) MINUS() antlr.TerminalNode {`
1092	`return s.GetToken(ExprParserMINUS, 0)`
1093	`}`

func String_Context.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2633	`func (s *String_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
2634	`return antlr.TreesStringTree(s, ruleNames, recog)`
2635	`}`

func ExpressionContext.PLUS

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1087	`func (s *ExpressionContext) PLUS() antlr.TerminalNode {`
1088	`return s.GetToken(ExprParserPLUS, 0)`
1089	`}`

func ExpressionContext.SetTertiary

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1052	`func (s *ExpressionContext) SetTertiary(v antlr.Token) { s.tertiary = v }`

func ExpressionContext.SetRel_op

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1050	`func (s *ExpressionContext) SetRel_op(v antlr.Token) { s.rel_op = v }`

func ExpressionContext.SetAdd_op

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1048	`func (s *ExpressionContext) SetAdd_op(v antlr.Token) { s.add_op = v }`

func ExpressionContext.SetMul_op

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1046	`func (s *ExpressionContext) SetMul_op(v antlr.Token) { s.mul_op = v }`

func ExpressionContext.SetUnary_op

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1044	`func (s *ExpressionContext) SetUnary_op(v antlr.Token) { s.unary_op = v }`

func Slice_Context.COLON

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

3213	`func (s *Slice_Context) COLON(i int) antlr.TerminalNode {`
3214	`return s.GetToken(ExprParserCOLON, i)`
3215	`}`

func ExpressionContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1032	`func (s *ExpressionContext) GetParser() antlr.Parser { return s.parser }`

func Float_Context.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2722	`func (s *Float_Context) GetParser() antlr.Parser { return s.parser }`

func Float_Context.FLOAT_LIT

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2724	`func (s *Float_Context) FLOAT_LIT() antlr.TerminalNode {`
2725	`return s.GetToken(ExprParserFLOAT_LIT, 0)`
2726	`}`

func Float_Context.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2728	`func (s *Float_Context) GetRuleContext() antlr.RuleContext {`
2729	`return s`
2730	`}`

func Float_Context.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2732	`func (s *Float_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
2733	`return antlr.TreesStringTree(s, ruleNames, recog)`
2734	`}`

func MemberContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2051	`func (s *MemberContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
2052	`return antlr.TreesStringTree(s, ruleNames, recog)`
2053	`}`

func MemberContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2047	`func (s *MemberContext) GetRuleContext() antlr.RuleContext {`
2048	`return s`
2049	`}`

func Slice_Context.AllCOLON

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

3209	`func (s *Slice_Context) AllCOLON() []antlr.TerminalNode {`
3210	`return s.GetTokens(ExprParserCOLON)`
3211	`}`

func @2752:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2752	`func() {`
2753	`p.ExitRule()`
2754	`}`

func @932:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

932	`func() {`
933	`p.ExitRule()`
934	`}`

func MemberContext.IDENTIFIER

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2043	`func (s *MemberContext) IDENTIFIER() antlr.TerminalNode {`
2044	`return s.GetToken(ExprParserIDENTIFIER, 0)`
2045	`}`

func Slice_Context.R_BRACKET

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

3205	`func (s *Slice_Context) R_BRACKET() antlr.TerminalNode {`
3206	`return s.GetToken(ExprParserR_BRACKET, 0)`
3207	`}`

func MemberContext.DOT

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2039	`func (s *MemberContext) DOT() antlr.TerminalNode {`
2040	`return s.GetToken(ExprParserDOT, 0)`
2041	`}`

func IndexContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2813	`func (s *IndexContext) GetParser() antlr.Parser { return s.parser }`

func IndexContext.L_BRACKET

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2815	`func (s *IndexContext) L_BRACKET() antlr.TerminalNode {`
2816	`return s.GetToken(ExprParserL_BRACKET, 0)`
2817	`}`

func MiscContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

912	`func (s *MiscContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
913	`return antlr.TreesStringTree(s, ruleNames, recog)`
914	`}`

func Var_Context.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1956	`func (s *Var_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
1957	`return antlr.TreesStringTree(s, ruleNames, recog)`
1958	`}`

func IndexContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2833	`func (s *IndexContext) GetRuleContext() antlr.RuleContext {`
2834	`return s`
2835	`}`

func IndexContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2837	`func (s *IndexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
2838	`return antlr.TreesStringTree(s, ruleNames, recog)`
2839	`}`

func MiscContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

908	`func (s *MiscContext) GetRuleContext() antlr.RuleContext {`
909	`return s`
910	`}`

func MemberContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2037	`func (s *MemberContext) GetParser() antlr.Parser { return s.parser }`

func MiscContext.TERMINATOR

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

904	`func (s *MiscContext) TERMINATOR() antlr.TerminalNode {`
905	`return s.GetToken(ExprParserTERMINATOR, 0)`
906	`}`

func @2857:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2857	`func() {`
2858	`p.ExitRule()`
2859	`}`

func LiteralContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2136	`func (s *LiteralContext) GetParser() antlr.Parser { return s.parser }`

func OperandContext.L_PAREN

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1815	`func (s *OperandContext) L_PAREN() antlr.TerminalNode {`
1816	`return s.GetToken(ExprParserL_PAREN, 0)`
1817	`}`

func ExpressionContext.DIV

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1107	`func (s *ExpressionContext) DIV() antlr.TerminalNode {`
1108	`return s.GetToken(ExprParserDIV, 0)`
1109	`}`

func Slice_Context.L_BRACKET

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

3201	`func (s *Slice_Context) L_BRACKET() antlr.TerminalNode {`
3202	`return s.GetToken(ExprParserL_BRACKET, 0)`
3203	`}`

func ExpressionListContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2926	`func (s *ExpressionListContext) GetParser() antlr.Parser { return s.parser }`

func ExpressionsContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

813	`func (s *ExpressionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
814	`return antlr.TreesStringTree(s, ruleNames, recog)`
815	`}`

func ExpressionsContext.EOF

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

805	`func (s *ExpressionsContext) EOF() antlr.TerminalNode {`
806	`return s.GetToken(ExprParserEOF, 0)`
807	`}`

func ExpressionListContext.AllCOMMA

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2951	`func (s *ExpressionListContext) AllCOMMA() []antlr.TerminalNode {`
2952	`return s.GetTokens(ExprParserCOMMA)`
2953	`}`

func ExpressionListContext.COMMA

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2955	`func (s *ExpressionListContext) COMMA(i int) antlr.TerminalNode {`
2956	`return s.GetToken(ExprParserCOMMA, i)`
2957	`}`

func ExpressionListContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2959	`func (s *ExpressionListContext) GetRuleContext() antlr.RuleContext {`
2960	`return s`
2961	`}`

func ExpressionListContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2963	`func (s *ExpressionListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
2964	`return antlr.TreesStringTree(s, ruleNames, recog)`
2965	`}`

func OperandContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1837	`func (s *OperandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
1838	`return antlr.TreesStringTree(s, ruleNames, recog)`
1839	`}`

func Slice_Context.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

3199	`func (s *Slice_Context) GetParser() antlr.Parser { return s.parser }`

func ExpressionsContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

793	`func (s *ExpressionsContext) GetParser() antlr.Parser { return s.parser }`

func @2983:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2983	`func() {`
2984	`p.ExitRule()`
2985	`}`

func ParamDeclContext.COLON

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

560	`func (s *ParamDeclContext) COLON() antlr.TerminalNode {`
561	`return s.GetToken(ExprParserCOLON, 0)`
562	`}`

func ParamTypeContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

698	`func (s *ParamTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
699	`return antlr.TreesStringTree(s, ruleNames, recog)`
700	`}`

func ParamDeclContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

578	`func (s *ParamDeclContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
579	`return antlr.TreesStringTree(s, ruleNames, recog)`
580	`}`

func ParamTypeContext.R_BRACKET

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

690	`func (s *ParamTypeContext) R_BRACKET() antlr.TerminalNode {`
691	`return s.GetToken(ExprParserR_BRACKET, 0)`
692	`}`

func CallContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

3066	`func (s *CallContext) GetParser() antlr.Parser { return s.parser }`

func CallContext.L_PAREN

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

3068	`func (s *CallContext) L_PAREN() antlr.TerminalNode {`
3069	`return s.GetToken(ExprParserL_PAREN, 0)`
3070	`}`

func CallContext.R_PAREN

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

3072	`func (s *CallContext) R_PAREN() antlr.TerminalNode {`
3073	`return s.GetToken(ExprParserR_PAREN, 0)`
3074	`}`

func ParamTypeContext.L_BRACKET

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

686	`func (s *ParamTypeContext) L_BRACKET() antlr.TerminalNode {`
687	`return s.GetToken(ExprParserL_BRACKET, 0)`
688	`}`

func CallContext.ELLIPSIS

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

3086	`func (s *CallContext) ELLIPSIS() antlr.TerminalNode {`
3087	`return s.GetToken(ExprParserELLIPSIS, 0)`
3088	`}`

func CallContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

3090	`func (s *CallContext) GetRuleContext() antlr.RuleContext {`
3091	`return s`
3092	`}`

func CallContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

3094	`func (s *CallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
3095	`return antlr.TreesStringTree(s, ruleNames, recog)`
3096	`}`

func @3114:8

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

3114	`func() {`
3115	`p.ExitRule()`
3116	`}`

func Var_Context.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1946	`func (s *Var_Context) GetParser() antlr.Parser { return s.parser }`

func ParamTypeContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

680	`func (s *ParamTypeContext) GetParser() antlr.Parser { return s.parser }`

func ExpressionsContext.IsExpressionsContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

780	`func (*ExpressionsContext) IsExpressionsContext() {}`

func MemberContext.IsMemberContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2024	`func (*MemberContext) IsMemberContext() {}`

func BaseExprParserListener.ExitParamType

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

45	`func (s BaseExprParserListener) ExitParamType(ctx ParamTypeContext) {}`

func Slice_Context.IsSlice_Context

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

3186	`func (*Slice_Context) IsSlice_Context() {}`

func BaseExprParserListener.EnterExpressions

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

48	`func (s BaseExprParserListener) EnterExpressions(ctx ExpressionsContext) {}`

func Var_Context.IsVar_Context

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1933	`func (*Var_Context) IsVar_Context() {}`

func MiscContext.IsMiscContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

885	`func (*MiscContext) IsMiscContext() {}`

func IndexContext.IsIndexContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2800	`func (*IndexContext) IsIndexContext() {}`

func ExpressionContext.IsExpressionContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1019	`func (*ExpressionContext) IsExpressionContext() {}`

func Float_Context.IsFloat_Context

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2709	`func (*Float_Context) IsFloat_Context() {}`

func BaseExprParserListener.EnterMisc

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

54	`func (s BaseExprParserListener) EnterMisc(ctx MiscContext) {}`

func ParamDeclContext.IsParamDeclContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

541	`func (*ParamDeclContext) IsParamDeclContext() {}`

func ExpressionListContext.IsExpressionListContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2913	`func (*ExpressionListContext) IsExpressionListContext() {}`

func Nil_Context.IsNil_Context

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2515	`func (*Nil_Context) IsNil_Context() {}`

func IntegerContext.IsIntegerContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2396	`func (*IntegerContext) IsIntegerContext() {}`

func PrimaryExprContext.IsPrimaryExprContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1450	`func (*PrimaryExprContext) IsPrimaryExprContext() {}`

func ParamCommaContext.IsParamCommaContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

450	`func (*ParamCommaContext) IsParamCommaContext() {}`

func LogicalContext.IsLogicalContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1661	`func (*LogicalContext) IsLogicalContext() {}`

func BasicLitContext.IsBasicLitContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2220	`func (*BasicLitContext) IsBasicLitContext() {}`

func OperandContext.IsOperandContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

1780	`func (*OperandContext) IsOperandContext() {}`

func LiteralContext.IsLiteralContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2123	`func (*LiteralContext) IsLiteralContext() {}`

func ParametersContext.IsParametersContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

271	`func (*ParametersContext) IsParametersContext() {}`

func BaseExprParserListener.VisitTerminal

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

12	`func (s *BaseExprParserListener) VisitTerminal(node antlr.TerminalNode) {}`

func BaseExprParserListener.VisitErrorNode

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

15	`func (s *BaseExprParserListener) VisitErrorNode(node antlr.ErrorNode) {}`

func BaseExprParserListener.EnterEveryRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

18	`func (s *BaseExprParserListener) EnterEveryRule(ctx antlr.ParserRuleContext) {}`

func BaseExprParserListener.ExitEveryRule

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

21	`func (s *BaseExprParserListener) ExitEveryRule(ctx antlr.ParserRuleContext) {}`

func BaseExprParserListener.EnterParameters

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

24	`func (s BaseExprParserListener) EnterParameters(ctx ParametersContext) {}`

func BaseExprParserListener.ExitParameters

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

27	`func (s BaseExprParserListener) ExitParameters(ctx ParametersContext) {}`

func BaseExprParserListener.EnterParamComma

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

30	`func (s BaseExprParserListener) EnterParamComma(ctx ParamCommaContext) {}`

func BaseExprParserListener.ExitExpressions

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

51	`func (s BaseExprParserListener) ExitExpressions(ctx ExpressionsContext) {}`

func BaseExprParserListener.EnterParamDecl

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

36	`func (s BaseExprParserListener) EnterParamDecl(ctx ParamDeclContext) {}`

func BaseExprParserListener.ExitParamDecl

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

39	`func (s BaseExprParserListener) ExitParamDecl(ctx ParamDeclContext) {}`

func BaseExprParserListener.EnterParamType

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

42	`func (s BaseExprParserListener) EnterParamType(ctx ParamTypeContext) {}`

func CallContext.IsCallContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

3053	`func (*CallContext) IsCallContext() {}`

func BaseExprParserListener.ExitParamComma

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

33	`func (s BaseExprParserListener) ExitParamComma(ctx ParamCommaContext) {}`

func ParamTypeContext.IsParamTypeContext

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

667	`func (*ParamTypeContext) IsParamTypeContext() {}`

func String_Context.IsString_Context

Back

In /Users/kun/gobatis/gobatis/parser/expr/expr_parser.go:

2606	`func (*String_Context) IsString_Context() {}`

func BaseExprParserListener.ExitMisc

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

57	`func (s BaseExprParserListener) ExitMisc(ctx MiscContext) {}`

func BaseExprParserListener.EnterExpression

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

60	`func (s BaseExprParserListener) EnterExpression(ctx ExpressionContext) {}`

func BaseExprParserListener.ExitExpression

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

63	`func (s BaseExprParserListener) ExitExpression(ctx ExpressionContext) {}`

func BaseExprParserListener.EnterPrimaryExpr

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

66	`func (s BaseExprParserListener) EnterPrimaryExpr(ctx PrimaryExprContext) {}`

func BaseExprParserListener.ExitPrimaryExpr

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

69	`func (s BaseExprParserListener) ExitPrimaryExpr(ctx PrimaryExprContext) {}`

func BaseExprParserListener.EnterLogical

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

72	`func (s BaseExprParserListener) EnterLogical(ctx LogicalContext) {}`

func BaseExprParserListener.ExitLogical

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

75	`func (s BaseExprParserListener) ExitLogical(ctx LogicalContext) {}`

func BaseExprParserListener.EnterOperand

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

78	`func (s BaseExprParserListener) EnterOperand(ctx OperandContext) {}`

func BaseExprParserListener.ExitOperand

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

81	`func (s BaseExprParserListener) ExitOperand(ctx OperandContext) {}`

func BaseExprParserListener.EnterVar_

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

84	`func (s BaseExprParserListener) EnterVar_(ctx Var_Context) {}`

func BaseExprParserListener.ExitVar_

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

87	`func (s BaseExprParserListener) ExitVar_(ctx Var_Context) {}`

func BaseExprParserListener.EnterMember

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

90	`func (s BaseExprParserListener) EnterMember(ctx MemberContext) {}`

func BaseExprParserListener.ExitMember

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

93	`func (s BaseExprParserListener) ExitMember(ctx MemberContext) {}`

func BaseExprParserListener.EnterLiteral

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

96	`func (s BaseExprParserListener) EnterLiteral(ctx LiteralContext) {}`

func BaseExprParserListener.ExitLiteral

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

99	`func (s BaseExprParserListener) ExitLiteral(ctx LiteralContext) {}`

func BaseExprParserListener.EnterBasicLit

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

102	`func (s BaseExprParserListener) EnterBasicLit(ctx BasicLitContext) {}`

func BaseExprParserListener.ExitBasicLit

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

105	`func (s BaseExprParserListener) ExitBasicLit(ctx BasicLitContext) {}`

func BaseExprParserListener.EnterInteger

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

108	`func (s BaseExprParserListener) EnterInteger(ctx IntegerContext) {}`

func BaseExprParserListener.ExitInteger

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

111	`func (s BaseExprParserListener) ExitInteger(ctx IntegerContext) {}`

func BaseExprParserListener.EnterNil_

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

114	`func (s BaseExprParserListener) EnterNil_(ctx Nil_Context) {}`

func BaseExprParserListener.ExitNil_

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

117	`func (s BaseExprParserListener) ExitNil_(ctx Nil_Context) {}`

func BaseExprParserListener.EnterString_

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

120	`func (s BaseExprParserListener) EnterString_(ctx String_Context) {}`

func BaseExprParserListener.ExitString_

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

123	`func (s BaseExprParserListener) ExitString_(ctx String_Context) {}`

func BaseExprParserListener.EnterFloat_

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

126	`func (s BaseExprParserListener) EnterFloat_(ctx Float_Context) {}`

func BaseExprParserListener.ExitFloat_

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

129	`func (s BaseExprParserListener) ExitFloat_(ctx Float_Context) {}`

func BaseExprParserListener.EnterIndex

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

132	`func (s BaseExprParserListener) EnterIndex(ctx IndexContext) {}`

func BaseExprParserListener.ExitIndex

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

135	`func (s BaseExprParserListener) ExitIndex(ctx IndexContext) {}`

func BaseExprParserListener.EnterExpressionList

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

138	`func (s BaseExprParserListener) EnterExpressionList(ctx ExpressionListContext) {}`

func BaseExprParserListener.ExitExpressionList

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

141	`func (s BaseExprParserListener) ExitExpressionList(ctx ExpressionListContext) {}`

func BaseExprParserListener.EnterCall

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

144	`func (s BaseExprParserListener) EnterCall(ctx CallContext) {}`

func BaseExprParserListener.ExitCall

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

147	`func (s BaseExprParserListener) ExitCall(ctx CallContext) {}`

func BaseExprParserListener.EnterSlice_

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

150	`func (s BaseExprParserListener) EnterSlice_(ctx Slice_Context) {}`

func BaseExprParserListener.ExitSlice_

Back

In /Users/kun/gobatis/gobatis/parser/expr/exprparser_base_listener.go:

153	`func (s BaseExprParserListener) ExitSlice_(ctx Slice_Context) {}`

Package Overview: github.com/gobatis/gobatis/parser/simplemath 52.6%

Please select a function to see what's left for testing.

`simplemathlexerLexerInit(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_lexer.go`	`100.0%`	`15/15`
`simplemathParserInit(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`100.0%`	`13/13`
`NewSimpleMathLexer(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_lexer.go`	`100.0%`	`12/12`
`NewSimpleMathParser(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`100.0%`	`10/10`
`NewFactorContext(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`100.0%`	`5/5`
`NewTermContext(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`100.0%`	`5/5`
`NewExprContext(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`100.0%`	`5/5`
`SimpleMathParserInit(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`100.0%`	`2/2`
`SimpleMathLexerInit(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_lexer.go`	`100.0%`	`2/2`
`SimpleMathParser.Expr(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`100.0%`	`1/1`
`ExprContext.Term(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`87.5%`	`7/8`
`SimpleMathParser.expr(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`76.9%`	`40/52`
`ExprContext.Accept(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`66.7%`	`2/3`
`TermContext.Accept(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`66.7%`	`2/3`
`SimpleMathParser.Factor(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`62.5%`	`10/16`
`SimpleMathParser.term(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`42.3%`	`22/52`
`SimpleMathParser.Sempred(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/10`
`TermContext.Term(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/8`
`TermContext.Factor(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/8`
`ExprContext.Expr(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/8`
`NewEmptyExprContext(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/4`
`NewEmptyTermContext(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/4`
`NewEmptyFactorContext(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/4`
`SimpleMathParser.Expr_Sempred(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/3`
`FactorContext.Accept(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/3`
`SimpleMathParser.Term_Sempred(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/3`
`InitEmptyFactorContext(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/2`
`FactorContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/2`
`ExprContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/2`
`ExprContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/2`
`TermContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/2`
`TermContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/2`
`FactorContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/2`
`InitEmptyExprContext(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/2`
`InitEmptyTermContext(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/2`
`TermContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/1`
`FactorContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/1`
`BaseSimpleMathVisitor.VisitFactor(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_base_visitor.go`	`0.0%`	`0/1`
`BaseSimpleMathVisitor.VisitTerm(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_base_visitor.go`	`0.0%`	`0/1`
`BaseSimpleMathVisitor.VisitExpr(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_base_visitor.go`	`0.0%`	`0/1`
`TermContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/1`
`TermContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/1`
`FactorContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/1`
`FactorContext.NUMBER(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/1`
`ExprContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/1`
`SimpleMathParser.Term(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/1`
`ExprContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/1`
`FactorContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/1`
`ExprContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`0.0%`	`0/1`
`BaseSimpleMathListener.EnterTerm(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_base_listener.go`	`100.0%`	`0/0`
`BaseSimpleMathListener.VisitErrorNode(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_base_listener.go`	`100.0%`	`0/0`
`BaseSimpleMathListener.ExitExpr(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_base_listener.go`	`100.0%`	`0/0`
`BaseSimpleMathListener.VisitTerminal(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_base_listener.go`	`100.0%`	`0/0`
`BaseSimpleMathListener.EnterExpr(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_base_listener.go`	`100.0%`	`0/0`
`BaseSimpleMathListener.EnterEveryRule(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_base_listener.go`	`100.0%`	`0/0`
`FactorContext.IsFactorContext(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`100.0%`	`0/0`
`ExprContext.IsExprContext(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`100.0%`	`0/0`
`BaseSimpleMathListener.ExitTerm(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_base_listener.go`	`100.0%`	`0/0`
`BaseSimpleMathListener.EnterFactor(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_base_listener.go`	`100.0%`	`0/0`
`BaseSimpleMathListener.ExitFactor(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_base_listener.go`	`100.0%`	`0/0`
`BaseSimpleMathListener.ExitEveryRule(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_base_listener.go`	`100.0%`	`0/0`
`TermContext.IsTermContext(...)`	`github.com/gobatis/gobatis/parser/simplemath/simplemath_parser.go`	`100.0%`	`0/0`

func simplemathlexerLexerInit

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_lexer.go:

37	`func simplemathlexerLexerInit() {`
38	`staticData := &SimpleMathLexerLexerStaticData`
39	`staticData.ChannelNames = []string{`
40	`"DEFAULT_TOKEN_CHANNEL", "HIDDEN",`
41	`}`
42	`staticData.ModeNames = []string{`
43	`"DEFAULT_MODE",`
44	`}`
45	`staticData.LiteralNames = []string{`
46	`"", "'+'", "'*'",`
47	`}`
48	`staticData.SymbolicNames = []string{`
49	`"", "", "", "NUMBER", "WS",`
50	`}`
51	`staticData.RuleNames = []string{`
52	`"T__0", "T__1", "NUMBER", "WS",`
53	`}`
54	`staticData.PredictionContextCache = antlr.NewPredictionContextCache()`
55	`staticData.serializedATN = []int32{`
56	`4, 0, 4, 25, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 1,`
57	`0, 1, 0, 1, 1, 1, 1, 1, 2, 4, 2, 15, 8, 2, 11, 2, 12, 2, 16, 1, 3, 4, 3,`
58	`20, 8, 3, 11, 3, 12, 3, 21, 1, 3, 1, 3, 0, 0, 4, 1, 1, 3, 2, 5, 3, 7, 4,`
59	`1, 0, 2, 1, 0, 48, 57, 3, 0, 9, 10, 13, 13, 32, 32, 26, 0, 1, 1, 0, 0,`
60	`0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 1, 9, 1, 0, 0,`
61	`0, 3, 11, 1, 0, 0, 0, 5, 14, 1, 0, 0, 0, 7, 19, 1, 0, 0, 0, 9, 10, 5, 43,`
62	`0, 0, 10, 2, 1, 0, 0, 0, 11, 12, 5, 42, 0, 0, 12, 4, 1, 0, 0, 0, 13, 15,`
63	`7, 0, 0, 0, 14, 13, 1, 0, 0, 0, 15, 16, 1, 0, 0, 0, 16, 14, 1, 0, 0, 0,`
64	`16, 17, 1, 0, 0, 0, 17, 6, 1, 0, 0, 0, 18, 20, 7, 1, 0, 0, 19, 18, 1, 0,`
65	`0, 0, 20, 21, 1, 0, 0, 0, 21, 19, 1, 0, 0, 0, 21, 22, 1, 0, 0, 0, 22, 23,`
66	`1, 0, 0, 0, 23, 24, 6, 3, 0, 0, 24, 8, 1, 0, 0, 0, 3, 0, 16, 21, 1, 6,`
67	`0, 0,`
68	`}`
69	`deserializer := antlr.NewATNDeserializer(nil)`
70	`staticData.atn = deserializer.Deserialize(staticData.serializedATN)`
71	`atn := staticData.atn`
72	`staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState))`
73	`decisionToDFA := staticData.decisionToDFA`
74	`for index, state := range atn.DecisionToState {`
75	`decisionToDFA[index] = antlr.NewDFA(state, index)`
76	`}`
77	`}`

func simplemathParserInit

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

32	`func simplemathParserInit() {`
33	`staticData := &SimpleMathParserStaticData`
34	`staticData.LiteralNames = []string{`
35	`"", "'+'", "'*'",`
36	`}`
37	`staticData.SymbolicNames = []string{`
38	`"", "", "", "NUMBER", "WS",`
39	`}`
40	`staticData.RuleNames = []string{`
41	`"expr", "term", "factor",`
42	`}`
43	`staticData.PredictionContextCache = antlr.NewPredictionContextCache()`
44	`staticData.serializedATN = []int32{`
45	`4, 1, 4, 31, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 1, 0, 1, 0, 1, 0, 1, 0,`
46	`1, 0, 1, 0, 5, 0, 13, 8, 0, 10, 0, 12, 0, 16, 9, 0, 1, 1, 1, 1, 1, 1, 1,`
47	`1, 1, 1, 1, 1, 5, 1, 24, 8, 1, 10, 1, 12, 1, 27, 9, 1, 1, 2, 1, 2, 1, 2,`
48	`0, 2, 0, 2, 3, 0, 2, 4, 0, 0, 29, 0, 6, 1, 0, 0, 0, 2, 17, 1, 0, 0, 0,`
49	`4, 28, 1, 0, 0, 0, 6, 7, 6, 0, -1, 0, 7, 8, 3, 2, 1, 0, 8, 14, 1, 0, 0,`
50	`0, 9, 10, 10, 2, 0, 0, 10, 11, 5, 1, 0, 0, 11, 13, 3, 2, 1, 0, 12, 9, 1,`
51	`0, 0, 0, 13, 16, 1, 0, 0, 0, 14, 12, 1, 0, 0, 0, 14, 15, 1, 0, 0, 0, 15,`
52	`1, 1, 0, 0, 0, 16, 14, 1, 0, 0, 0, 17, 18, 6, 1, -1, 0, 18, 19, 3, 4, 2,`
53	`0, 19, 25, 1, 0, 0, 0, 20, 21, 10, 2, 0, 0, 21, 22, 5, 2, 0, 0, 22, 24,`
54	`3, 4, 2, 0, 23, 20, 1, 0, 0, 0, 24, 27, 1, 0, 0, 0, 25, 23, 1, 0, 0, 0,`
55	`25, 26, 1, 0, 0, 0, 26, 3, 1, 0, 0, 0, 27, 25, 1, 0, 0, 0, 28, 29, 5, 3,`
56	`0, 0, 29, 5, 1, 0, 0, 0, 2, 14, 25,`
57	`}`
58	`deserializer := antlr.NewATNDeserializer(nil)`
59	`staticData.atn = deserializer.Deserialize(staticData.serializedATN)`
60	`atn := staticData.atn`
61	`staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState))`
62	`decisionToDFA := staticData.decisionToDFA`
63	`for index, state := range atn.DecisionToState {`
64	`decisionToDFA[index] = antlr.NewDFA(state, index)`
65	`}`
66	`}`

func NewSimpleMathLexer

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_lexer.go:

func NewSimpleMathLexer(input antlr.CharStream) *SimpleMathLexer {
        SimpleMathLexerInit()
        l := new(SimpleMathLexer)
        l.BaseLexer = antlr.NewBaseLexer(input)
        staticData := &SimpleMathLexerLexerStaticData
        l.Interpreter = antlr.NewLexerATNSimulator(l, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache)
        l.channelNames = staticData.ChannelNames
        l.modeNames = staticData.ModeNames
        l.RuleNames = staticData.RuleNames
        l.LiteralNames = staticData.LiteralNames
        l.SymbolicNames = staticData.SymbolicNames
        l.GrammarFileName = "SimpleMath.g4"
        // TODO: l.EOF = antlr.TokenEOF

        return l
}

func NewSimpleMathParser

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func NewSimpleMathParser(input antlr.TokenStream) *SimpleMathParser {
        SimpleMathParserInit()
        this := new(SimpleMathParser)
        this.BaseParser = antlr.NewBaseParser(input)
        staticData := &SimpleMathParserStaticData
        this.Interpreter = antlr.NewParserATNSimulator(this, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache)
        this.RuleNames = staticData.RuleNames
        this.LiteralNames = staticData.LiteralNames
        this.SymbolicNames = staticData.SymbolicNames
        this.GrammarFileName = "SimpleMath.g4"

        return this
}

func NewFactorContext

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func NewFactorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FactorContext {
        var p = new(FactorContext)

        antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

        p.parser = parser
        p.RuleIndex = SimpleMathParserRULE_factor

        return p
}

func NewTermContext

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func NewTermContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TermContext {
        var p = new(TermContext)

        antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

        p.parser = parser
        p.RuleIndex = SimpleMathParserRULE_term

        return p
}

func NewExprContext

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func NewExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExprContext {
        var p = new(ExprContext)

        antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

        p.parser = parser
        p.RuleIndex = SimpleMathParserRULE_expr

        return p
}

func SimpleMathParserInit

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

72	`func SimpleMathParserInit() {`
73	`staticData := &SimpleMathParserStaticData`
74	`staticData.once.Do(simplemathParserInit)`
75	`}`

func SimpleMathLexerInit

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_lexer.go:

83	`func SimpleMathLexerInit() {`
84	`staticData := &SimpleMathLexerLexerStaticData`
85	`staticData.once.Do(simplemathlexerLexerInit)`
86	`}`

func SimpleMathParser.Expr

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

217	`func (p *SimpleMathParser) Expr() (localctx IExprContext) {`
218	`return p.expr(0)`
219	`}`

func ExprContext.Term

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func (s *ExprContext) Term() ITermContext {
        var t antlr.RuleContext
        for _, ctx := range s.GetChildren() {
                if _, ok := ctx.(ITermContext); ok {
                        t = ctx.(antlr.RuleContext)
                        break
                }
        }

        if t == nil {
                return nil
        }

        return t.(ITermContext)
}

func SimpleMathParser.expr

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func (p *SimpleMathParser) expr(_p int) (localctx IExprContext) {
        var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()

        _parentState := p.GetState()
        localctx = NewExprContext(p, p.GetParserRuleContext(), _parentState)
        var _prevctx IExprContext = localctx
        var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
        _startState := 0
        p.EnterRecursionRule(localctx, 0, SimpleMathParserRULE_expr, _p)
        var _alt int

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(7)
                p.term(0)
        }

        p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
        p.SetState(14)
        p.GetErrorHandler().Sync(p)
        if p.HasError() {
                goto errorExit
        }
        _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 0, p.GetParserRuleContext())
        if p.HasError() {
                goto errorExit
        }
        for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
                if _alt == 1 {
                        if p.GetParseListeners() != nil {
                                p.TriggerExitRuleEvent()
                        }
                        _prevctx = localctx
                        localctx = NewExprContext(p, _parentctx, _parentState)
                        p.PushNewRecursionContext(localctx, _startState, SimpleMathParserRULE_expr)
                        p.SetState(9)

                        if !(p.Precpred(p.GetParserRuleContext(), 2)) {
                                p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
                                goto errorExit
                        }
                        {
                                p.SetState(10)
                                p.Match(SimpleMathParserT__0)
                                if p.HasError() {
                                        // Recognition error - abort rule
                                        goto errorExit
                                }
                        }
                        {
                                p.SetState(11)
                                p.term(0)
                        }

                }
                p.SetState(16)
                p.GetErrorHandler().Sync(p)
                if p.HasError() {
                        goto errorExit
                }
                _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 0, p.GetParserRuleContext())
                if p.HasError() {
                        goto errorExit
                }
        }

errorExit:
        if p.HasError() {
                v := p.GetError()
                localctx.SetException(v)
                p.GetErrorHandler().ReportError(p, v)
                p.GetErrorHandler().Recover(p, v)
                p.SetError(nil)
        }
        p.UnrollRecursionContexts(_parentctx)
        return localctx
        goto errorExit // Trick to prevent compiler error if the label is not used
}

func ExprContext.Accept

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func (s *ExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
        switch t := visitor.(type) {
        case SimpleMathVisitor:
                return t.VisitExpr(s)

        default:
                return t.VisitChildren(s)
        }
}

func TermContext.Accept

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func (s *TermContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
        switch t := visitor.(type) {
        case SimpleMathVisitor:
                return t.VisitTerm(s)

        default:
                return t.VisitChildren(s)
        }
}

func SimpleMathParser.Factor

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func (p *SimpleMathParser) Factor() (localctx IFactorContext) {
        localctx = NewFactorContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 4, SimpleMathParserRULE_factor)
        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(28)
                p.Match(SimpleMathParserNUMBER)
                if p.HasError() {
                        // Recognition error - abort rule
                        goto errorExit
                }
        }

errorExit:
        if p.HasError() {
                v := p.GetError()
                localctx.SetException(v)
                p.GetErrorHandler().ReportError(p, v)
                p.GetErrorHandler().Recover(p, v)
                p.SetError(nil)
        }
        p.ExitRule()
        return localctx
        goto errorExit // Trick to prevent compiler error if the label is not used
}

func SimpleMathParser.term

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func (p *SimpleMathParser) term(_p int) (localctx ITermContext) {
        var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()

        _parentState := p.GetState()
        localctx = NewTermContext(p, p.GetParserRuleContext(), _parentState)
        var _prevctx ITermContext = localctx
        var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
        _startState := 2
        p.EnterRecursionRule(localctx, 2, SimpleMathParserRULE_term, _p)
        var _alt int

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(18)
                p.Factor()
        }

        p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
        p.SetState(25)
        p.GetErrorHandler().Sync(p)
        if p.HasError() {
                goto errorExit
        }
        _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1, p.GetParserRuleContext())
        if p.HasError() {
                goto errorExit
        }
        for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
                if _alt == 1 {
                        if p.GetParseListeners() != nil {
                                p.TriggerExitRuleEvent()
                        }
                        _prevctx = localctx
                        localctx = NewTermContext(p, _parentctx, _parentState)
                        p.PushNewRecursionContext(localctx, _startState, SimpleMathParserRULE_term)
                        p.SetState(20)

                        if !(p.Precpred(p.GetParserRuleContext(), 2)) {
                                p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
                                goto errorExit
                        }
                        {
                                p.SetState(21)
                                p.Match(SimpleMathParserT__1)
                                if p.HasError() {
                                        // Recognition error - abort rule
                                        goto errorExit
                                }
                        }
                        {
                                p.SetState(22)
                                p.Factor()
                        }

                }
                p.SetState(27)
                p.GetErrorHandler().Sync(p)
                if p.HasError() {
                        goto errorExit
                }
                _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1, p.GetParserRuleContext())
                if p.HasError() {
                        goto errorExit
                }
        }

errorExit:
        if p.HasError() {
                v := p.GetError()
                localctx.SetException(v)
                p.GetErrorHandler().ReportError(p, v)
                p.GetErrorHandler().Recover(p, v)
                p.SetError(nil)
        }
        p.UnrollRecursionContexts(_parentctx)
        return localctx
        goto errorExit // Trick to prevent compiler error if the label is not used
}

func SimpleMathParser.Sempred

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func (p *SimpleMathParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool {
        switch ruleIndex {
        case 0:
                var t *ExprContext = nil
                if localctx != nil {
                        t = localctx.(*ExprContext)
                }
                return p.Expr_Sempred(t, predIndex)

        case 1:
                var t *TermContext = nil
                if localctx != nil {
                        t = localctx.(*TermContext)
                }
                return p.Term_Sempred(t, predIndex)

        default:
                panic("No predicate with index: " + fmt.Sprint(ruleIndex))
        }
}

func TermContext.Term

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func (s *TermContext) Term() ITermContext {
        var t antlr.RuleContext
        for _, ctx := range s.GetChildren() {
                if _, ok := ctx.(ITermContext); ok {
                        t = ctx.(antlr.RuleContext)
                        break
                }
        }

        if t == nil {
                return nil
        }

        return t.(ITermContext)
}

func TermContext.Factor

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func (s *TermContext) Factor() IFactorContext {
        var t antlr.RuleContext
        for _, ctx := range s.GetChildren() {
                if _, ok := ctx.(IFactorContext); ok {
                        t = ctx.(antlr.RuleContext)
                        break
                }
        }

        if t == nil {
                return nil
        }

        return t.(IFactorContext)
}

func ExprContext.Expr

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func (s *ExprContext) Expr() IExprContext {
        var t antlr.RuleContext
        for _, ctx := range s.GetChildren() {
                if _, ok := ctx.(IExprContext); ok {
                        t = ctx.(antlr.RuleContext)
                        break
                }
        }

        if t == nil {
                return nil
        }

        return t.(IExprContext)
}

func NewEmptyExprContext

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func NewEmptyExprContext() *ExprContext {
        var p = new(ExprContext)
        antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
        p.RuleIndex = SimpleMathParserRULE_expr
        return p
}

func NewEmptyTermContext

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func NewEmptyTermContext() *TermContext {
        var p = new(TermContext)
        antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
        p.RuleIndex = SimpleMathParserRULE_term
        return p
}

func NewEmptyFactorContext

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func NewEmptyFactorContext() *FactorContext {
        var p = new(FactorContext)
        antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
        p.RuleIndex = SimpleMathParserRULE_factor
        return p
}

func SimpleMathParser.Expr_Sempred

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func (p *SimpleMathParser) Expr_Sempred(localctx antlr.RuleContext, predIndex int) bool {
        switch predIndex {
        case 0:
                return p.Precpred(p.GetParserRuleContext(), 2)

        default:
                panic("No predicate with index: " + fmt.Sprint(predIndex))
        }
}

func FactorContext.Accept

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func (s *FactorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
        switch t := visitor.(type) {
        case SimpleMathVisitor:
                return t.VisitFactor(s)

        default:
                return t.VisitChildren(s)
        }
}

func SimpleMathParser.Term_Sempred

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func (p *SimpleMathParser) Term_Sempred(localctx antlr.RuleContext, predIndex int) bool {
        switch predIndex {
        case 1:
                return p.Precpred(p.GetParserRuleContext(), 2)

        default:
                panic("No predicate with index: " + fmt.Sprint(predIndex))
        }
}

func InitEmptyFactorContext

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

518	`func InitEmptyFactorContext(p *FactorContext) {`
519	`antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)`
520	`p.RuleIndex = SimpleMathParserRULE_factor`
521	`}`

func FactorContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func (s *FactorContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(SimpleMathListener); ok {
                listenerT.EnterFactor(s)
        }
}

func ExprContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func (s *ExprContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(SimpleMathListener); ok {
                listenerT.EnterExpr(s)
        }
}

func ExprContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func (s *ExprContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(SimpleMathListener); ok {
                listenerT.ExitExpr(s)
        }
}

func TermContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func (s *TermContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(SimpleMathListener); ok {
                listenerT.ExitTerm(s)
        }
}

func TermContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func (s *TermContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(SimpleMathListener); ok {
                listenerT.EnterTerm(s)
        }
}

func FactorContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

func (s *FactorContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(SimpleMathListener); ok {
                listenerT.ExitFactor(s)
        }
}

func InitEmptyExprContext

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

135	`func InitEmptyExprContext(p *ExprContext) {`
136	`antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)`
137	`p.RuleIndex = SimpleMathParserRULE_expr`
138	`}`

func InitEmptyTermContext

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

327	`func InitEmptyTermContext(p *TermContext) {`
328	`antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)`
329	`p.RuleIndex = SimpleMathParserRULE_term`
330	`}`

func TermContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

345	`func (s *TermContext) GetParser() antlr.Parser { return s.parser }`

func FactorContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

546	`func (s *FactorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
547	`return antlr.TreesStringTree(s, ruleNames, recog)`
548	`}`

func BaseSimpleMathVisitor.VisitFactor

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_base_visitor.go:

18	`func (v BaseSimpleMathVisitor) VisitFactor(ctx FactorContext) interface{} {`
19	`return v.VisitChildren(ctx)`
20	`}`

func BaseSimpleMathVisitor.VisitTerm

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_base_visitor.go:

14	`func (v BaseSimpleMathVisitor) VisitTerm(ctx TermContext) interface{} {`
15	`return v.VisitChildren(ctx)`
16	`}`

func BaseSimpleMathVisitor.VisitExpr

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_base_visitor.go:

10	`func (v BaseSimpleMathVisitor) VisitExpr(ctx ExprContext) interface{} {`
11	`return v.VisitChildren(ctx)`
12	`}`

func TermContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

379	`func (s *TermContext) GetRuleContext() antlr.RuleContext {`
380	`return s`
381	`}`

func TermContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

383	`func (s *TermContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
384	`return antlr.TreesStringTree(s, ruleNames, recog)`
385	`}`

func FactorContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

542	`func (s *FactorContext) GetRuleContext() antlr.RuleContext {`
543	`return s`
544	`}`

func FactorContext.NUMBER

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

538	`func (s *FactorContext) NUMBER() antlr.TerminalNode {`
539	`return s.GetToken(SimpleMathParserNUMBER, 0)`
540	`}`

func ExprContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

191	`func (s *ExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
192	`return antlr.TreesStringTree(s, ruleNames, recog)`
193	`}`

func SimpleMathParser.Term

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

409	`func (p *SimpleMathParser) Term() (localctx ITermContext) {`
410	`return p.term(0)`
411	`}`

func ExprContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

187	`func (s *ExprContext) GetRuleContext() antlr.RuleContext {`
188	`return s`
189	`}`

func FactorContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

536	`func (s *FactorContext) GetParser() antlr.Parser { return s.parser }`

func ExprContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

153	`func (s *ExprContext) GetParser() antlr.Parser { return s.parser }`

func BaseSimpleMathListener.EnterTerm

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_base_listener.go:

30	`func (s BaseSimpleMathListener) EnterTerm(ctx TermContext) {}`

func BaseSimpleMathListener.VisitErrorNode

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_base_listener.go:

15	`func (s *BaseSimpleMathListener) VisitErrorNode(node antlr.ErrorNode) {}`

func BaseSimpleMathListener.ExitExpr

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_base_listener.go:

27	`func (s BaseSimpleMathListener) ExitExpr(ctx ExprContext) {}`

func BaseSimpleMathListener.VisitTerminal

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_base_listener.go:

12	`func (s *BaseSimpleMathListener) VisitTerminal(node antlr.TerminalNode) {}`

func BaseSimpleMathListener.EnterExpr

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_base_listener.go:

24	`func (s BaseSimpleMathListener) EnterExpr(ctx ExprContext) {}`

func BaseSimpleMathListener.EnterEveryRule

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_base_listener.go:

18	`func (s *BaseSimpleMathListener) EnterEveryRule(ctx antlr.ParserRuleContext) {}`

func FactorContext.IsFactorContext

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

523	`func (*FactorContext) IsFactorContext() {}`

func ExprContext.IsExprContext

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

140	`func (*ExprContext) IsExprContext() {}`

func BaseSimpleMathListener.ExitTerm

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_base_listener.go:

33	`func (s BaseSimpleMathListener) ExitTerm(ctx TermContext) {}`

func BaseSimpleMathListener.EnterFactor

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_base_listener.go:

36	`func (s BaseSimpleMathListener) EnterFactor(ctx FactorContext) {}`

func BaseSimpleMathListener.ExitFactor

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_base_listener.go:

39	`func (s BaseSimpleMathListener) ExitFactor(ctx FactorContext) {}`

func BaseSimpleMathListener.ExitEveryRule

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_base_listener.go:

21	`func (s *BaseSimpleMathListener) ExitEveryRule(ctx antlr.ParserRuleContext) {}`

func TermContext.IsTermContext

Back

In /Users/kun/gobatis/gobatis/parser/simplemath/simplemath_parser.go:

332	`func (*TermContext) IsTermContext() {}`

Package Overview: github.com/gobatis/gobatis/parser/structpath 45.2%

Please select a function to see what's left for testing.

`jsonpathlexerLexerInit(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_lexer.go`	`100.0%`	`15/15`
`jsonpathParserInit(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`100.0%`	`13/13`
`NewJsonPathLexer(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_lexer.go`	`100.0%`	`12/12`
`NewJsonPathParser(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`100.0%`	`10/10`
`NewIdentifierWithQualifierContext(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`100.0%`	`5/5`
`NewDotnotation_exprContext(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`100.0%`	`5/5`
`NewJsonpathContext(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`100.0%`	`5/5`
`NewDotnotationContext(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`100.0%`	`5/5`
`JsonPathParserInit(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`100.0%`	`2/2`
`JsonPathLexerInit(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_lexer.go`	`100.0%`	`2/2`
`JsonPathParser.IdentifierWithQualifier(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`65.0%`	`13/20`
`JsonPathParser.Jsonpath(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`64.3%`	`9/14`
`JsonPathParser.Dotnotation_expr(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`52.0%`	`13/25`
`JsonPathParser.Dotnotation(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`46.3%`	`19/41`
`DotnotationContext.AllDotnotation_expr(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/12`
`DotnotationContext.Dotnotation_expr(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/11`
`JsonpathContext.Dotnotation(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/8`
`Dotnotation_exprContext.IdentifierWithQualifier(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/8`
`NewEmptyDotnotationContext(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/4`
`NewEmptyDotnotation_exprContext(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/4`
`NewEmptyJsonpathContext(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/4`
`NewEmptyIdentifierWithQualifierContext(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/4`
`DotnotationContext.Accept(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/3`
`Dotnotation_exprContext.Accept(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/3`
`JsonpathContext.Accept(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/3`
`IdentifierWithQualifierContext.Accept(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/3`
`InitEmptyDotnotationContext(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/2`
`DotnotationContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/2`
`Dotnotation_exprContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/2`
`InitEmptyIdentifierWithQualifierContext(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/2`
`JsonpathContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/2`
`JsonpathContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/2`
`IdentifierWithQualifierContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/2`
`InitEmptyJsonpathContext(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/2`
`Dotnotation_exprContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/2`
`IdentifierWithQualifierContext.EnterRule(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/2`
`InitEmptyDotnotation_exprContext(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/2`
`DotnotationContext.ExitRule(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/2`
`BaseJsonPathVisitor.VisitIdentifierWithQualifier(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_base_visitor.go`	`0.0%`	`0/1`
`IdentifierWithQualifierContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/1`
`BaseJsonPathVisitor.VisitJsonpath(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_base_visitor.go`	`0.0%`	`0/1`
`DotnotationContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/1`
`DotnotationContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/1`
`DotnotationContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/1`
`BaseJsonPathVisitor.VisitDotnotation_expr(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_base_visitor.go`	`0.0%`	`0/1`
`IdentifierWithQualifierContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/1`
`IdentifierWithQualifierContext.INDENTIFIER(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/1`
`BaseJsonPathVisitor.VisitDotnotation(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_base_visitor.go`	`0.0%`	`0/1`
`IdentifierWithQualifierContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/1`
`JsonpathContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/1`
`JsonpathContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/1`
`Dotnotation_exprContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/1`
`JsonpathContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/1`
`Dotnotation_exprContext.INDENTIFIER(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/1`
`Dotnotation_exprContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/1`
`Dotnotation_exprContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`0.0%`	`0/1`
`Dotnotation_exprContext.IsDotnotation_exprContext(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`100.0%`	`0/0`
`BaseJsonPathListener.ExitDotnotation(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go`	`100.0%`	`0/0`
`BaseJsonPathListener.EnterDotnotation(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go`	`100.0%`	`0/0`
`BaseJsonPathListener.ExitJsonpath(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go`	`100.0%`	`0/0`
`BaseJsonPathListener.EnterJsonpath(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go`	`100.0%`	`0/0`
`BaseJsonPathListener.EnterDotnotation_expr(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go`	`100.0%`	`0/0`
`IdentifierWithQualifierContext.IsIdentifierWithQualifierContext(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`100.0%`	`0/0`
`BaseJsonPathListener.ExitEveryRule(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go`	`100.0%`	`0/0`
`BaseJsonPathListener.ExitDotnotation_expr(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go`	`100.0%`	`0/0`
`BaseJsonPathListener.EnterIdentifierWithQualifier(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go`	`100.0%`	`0/0`
`BaseJsonPathListener.ExitIdentifierWithQualifier(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go`	`100.0%`	`0/0`
`DotnotationContext.IsDotnotationContext(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`100.0%`	`0/0`
`BaseJsonPathListener.VisitTerminal(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go`	`100.0%`	`0/0`
`JsonpathContext.IsJsonpathContext(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_parser.go`	`100.0%`	`0/0`
`BaseJsonPathListener.EnterEveryRule(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go`	`100.0%`	`0/0`
`BaseJsonPathListener.VisitErrorNode(...)`	`github.com/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go`	`100.0%`	`0/0`

func jsonpathlexerLexerInit

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_lexer.go:

38	`func jsonpathlexerLexerInit() {`
39	`staticData := &JsonPathLexerLexerStaticData`
40	`staticData.ChannelNames = []string{`
41	`"DEFAULT_TOKEN_CHANNEL", "HIDDEN",`
42	`}`
43	`staticData.ModeNames = []string{`
44	`"DEFAULT_MODE",`
45	`}`
46	`staticData.LiteralNames = []string{`
47	`"", "'$.'", "'.'", "'[*]'",`
48	`}`
49	`staticData.SymbolicNames = []string{`
50	`"", "", "", "", "INDENTIFIER", "WS",`
51	`}`
52	`staticData.RuleNames = []string{`
53	`"T__0", "T__1", "T__2", "INDENTIFIER", "WS",`
54	`}`
55	`staticData.PredictionContextCache = antlr.NewPredictionContextCache()`
56	`staticData.serializedATN = []int32{`
57	`4, 0, 5, 34, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2,`
58	`4, 7, 4, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1,`
59	`3, 5, 3, 23, 8, 3, 10, 3, 12, 3, 26, 9, 3, 1, 4, 4, 4, 29, 8, 4, 11, 4,`
60	`12, 4, 30, 1, 4, 1, 4, 0, 0, 5, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 1, 0, 3,`
61	`2, 0, 65, 90, 97, 122, 3, 0, 48, 57, 65, 90, 97, 122, 3, 0, 9, 10, 13,`
62	`13, 32, 32, 35, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0,`
63	`7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 1, 11, 1, 0, 0, 0, 3, 14, 1, 0, 0, 0,`
64	`5, 16, 1, 0, 0, 0, 7, 20, 1, 0, 0, 0, 9, 28, 1, 0, 0, 0, 11, 12, 5, 36,`
65	`0, 0, 12, 13, 5, 46, 0, 0, 13, 2, 1, 0, 0, 0, 14, 15, 5, 46, 0, 0, 15,`
66	`4, 1, 0, 0, 0, 16, 17, 5, 91, 0, 0, 17, 18, 5, 42, 0, 0, 18, 19, 5, 93,`
67	`0, 0, 19, 6, 1, 0, 0, 0, 20, 24, 7, 0, 0, 0, 21, 23, 7, 1, 0, 0, 22, 21,`
68	`1, 0, 0, 0, 23, 26, 1, 0, 0, 0, 24, 22, 1, 0, 0, 0, 24, 25, 1, 0, 0, 0,`
69	`25, 8, 1, 0, 0, 0, 26, 24, 1, 0, 0, 0, 27, 29, 7, 2, 0, 0, 28, 27, 1, 0,`
70	`0, 0, 29, 30, 1, 0, 0, 0, 30, 28, 1, 0, 0, 0, 30, 31, 1, 0, 0, 0, 31, 32,`
71	`1, 0, 0, 0, 32, 33, 6, 4, 0, 0, 33, 10, 1, 0, 0, 0, 3, 0, 24, 30, 1, 6,`
72	`0, 0,`
73	`}`
74	`deserializer := antlr.NewATNDeserializer(nil)`
75	`staticData.atn = deserializer.Deserialize(staticData.serializedATN)`
76	`atn := staticData.atn`
77	`staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState))`
78	`decisionToDFA := staticData.decisionToDFA`
79	`for index, state := range atn.DecisionToState {`
80	`decisionToDFA[index] = antlr.NewDFA(state, index)`
81	`}`
82	`}`

func jsonpathParserInit

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

32	`func jsonpathParserInit() {`
33	`staticData := &JsonPathParserStaticData`
34	`staticData.LiteralNames = []string{`
35	`"", "'$.'", "'.'", "'[*]'",`
36	`}`
37	`staticData.SymbolicNames = []string{`
38	`"", "", "", "", "INDENTIFIER", "WS",`
39	`}`
40	`staticData.RuleNames = []string{`
41	`"jsonpath", "dotnotation", "dotnotation_expr", "identifierWithQualifier",`
42	`}`
43	`staticData.PredictionContextCache = antlr.NewPredictionContextCache()`
44	`staticData.serializedATN = []int32{`
45	`4, 1, 5, 27, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 1, 0, 1, 0,`
46	`1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 15, 8, 1, 10, 1, 12, 1, 18, 9, 1, 1, 2, 1,`
47	`2, 3, 2, 22, 8, 2, 1, 3, 1, 3, 1, 3, 1, 3, 0, 0, 4, 0, 2, 4, 6, 0, 0, 24,`
48	`0, 8, 1, 0, 0, 0, 2, 10, 1, 0, 0, 0, 4, 21, 1, 0, 0, 0, 6, 23, 1, 0, 0,`
49	`0, 8, 9, 3, 2, 1, 0, 9, 1, 1, 0, 0, 0, 10, 11, 5, 1, 0, 0, 11, 16, 3, 4,`
50	`2, 0, 12, 13, 5, 2, 0, 0, 13, 15, 3, 4, 2, 0, 14, 12, 1, 0, 0, 0, 15, 18,`
51	`1, 0, 0, 0, 16, 14, 1, 0, 0, 0, 16, 17, 1, 0, 0, 0, 17, 3, 1, 0, 0, 0,`
52	`18, 16, 1, 0, 0, 0, 19, 22, 3, 6, 3, 0, 20, 22, 5, 4, 0, 0, 21, 19, 1,`
53	`0, 0, 0, 21, 20, 1, 0, 0, 0, 22, 5, 1, 0, 0, 0, 23, 24, 5, 4, 0, 0, 24,`
54	`25, 5, 3, 0, 0, 25, 7, 1, 0, 0, 0, 2, 16, 21,`
55	`}`
56	`deserializer := antlr.NewATNDeserializer(nil)`
57	`staticData.atn = deserializer.Deserialize(staticData.serializedATN)`
58	`atn := staticData.atn`
59	`staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState))`
60	`decisionToDFA := staticData.decisionToDFA`
61	`for index, state := range atn.DecisionToState {`
62	`decisionToDFA[index] = antlr.NewDFA(state, index)`
63	`}`
64	`}`

func NewJsonPathLexer

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_lexer.go:

func NewJsonPathLexer(input antlr.CharStream) *JsonPathLexer {
        JsonPathLexerInit()
        l := new(JsonPathLexer)
        l.BaseLexer = antlr.NewBaseLexer(input)
        staticData := &JsonPathLexerLexerStaticData
        l.Interpreter = antlr.NewLexerATNSimulator(l, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache)
        l.channelNames = staticData.ChannelNames
        l.modeNames = staticData.ModeNames
        l.RuleNames = staticData.RuleNames
        l.LiteralNames = staticData.LiteralNames
        l.SymbolicNames = staticData.SymbolicNames
        l.GrammarFileName = "JsonPath.g4"
        // TODO: l.EOF = antlr.TokenEOF

        return l
}

func NewJsonPathParser

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func NewJsonPathParser(input antlr.TokenStream) *JsonPathParser {
        JsonPathParserInit()
        this := new(JsonPathParser)
        this.BaseParser = antlr.NewBaseParser(input)
        staticData := &JsonPathParserStaticData
        this.Interpreter = antlr.NewParserATNSimulator(this, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache)
        this.RuleNames = staticData.RuleNames
        this.LiteralNames = staticData.LiteralNames
        this.SymbolicNames = staticData.SymbolicNames
        this.GrammarFileName = "JsonPath.g4"

        return this
}

func NewIdentifierWithQualifierContext

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func NewIdentifierWithQualifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierWithQualifierContext {
        var p = new(IdentifierWithQualifierContext)

        antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

        p.parser = parser
        p.RuleIndex = JsonPathParserRULE_identifierWithQualifier

        return p
}

func NewDotnotation_exprContext

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func NewDotnotation_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dotnotation_exprContext {
        var p = new(Dotnotation_exprContext)

        antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

        p.parser = parser
        p.RuleIndex = JsonPathParserRULE_dotnotation_expr

        return p
}

func NewJsonpathContext

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func NewJsonpathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JsonpathContext {
        var p = new(JsonpathContext)

        antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

        p.parser = parser
        p.RuleIndex = JsonPathParserRULE_jsonpath

        return p
}

func NewDotnotationContext

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func NewDotnotationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DotnotationContext {
        var p = new(DotnotationContext)

        antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState)

        p.parser = parser
        p.RuleIndex = JsonPathParserRULE_dotnotation

        return p
}

func JsonPathParserInit

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

70	`func JsonPathParserInit() {`
71	`staticData := &JsonPathParserStaticData`
72	`staticData.once.Do(jsonpathParserInit)`
73	`}`

func JsonPathLexerInit

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_lexer.go:

88	`func JsonPathLexerInit() {`
89	`staticData := &JsonPathLexerLexerStaticData`
90	`staticData.once.Do(jsonpathlexerLexerInit)`
91	`}`

func JsonPathParser.IdentifierWithQualifier

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func (p *JsonPathParser) IdentifierWithQualifier() (localctx IIdentifierWithQualifierContext) {
        localctx = NewIdentifierWithQualifierContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 6, JsonPathParserRULE_identifierWithQualifier)
        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(23)
                p.Match(JsonPathParserINDENTIFIER)
                if p.HasError() {
                        // Recognition error - abort rule
                        goto errorExit
                }
        }
        {
                p.SetState(24)
                p.Match(JsonPathParserT__2)
                if p.HasError() {
                        // Recognition error - abort rule
                        goto errorExit
                }
        }

errorExit:
        if p.HasError() {
                v := p.GetError()
                localctx.SetException(v)
                p.GetErrorHandler().ReportError(p, v)
                p.GetErrorHandler().Recover(p, v)
                p.SetError(nil)
        }
        p.ExitRule()
        return localctx
        goto errorExit // Trick to prevent compiler error if the label is not used
}

func JsonPathParser.Jsonpath

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func (p *JsonPathParser) Jsonpath() (localctx IJsonpathContext) {
        localctx = NewJsonpathContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 0, JsonPathParserRULE_jsonpath)
        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(8)
                p.Dotnotation()
        }

errorExit:
        if p.HasError() {
                v := p.GetError()
                localctx.SetException(v)
                p.GetErrorHandler().ReportError(p, v)
                p.GetErrorHandler().Recover(p, v)
                p.SetError(nil)
        }
        p.ExitRule()
        return localctx
        goto errorExit // Trick to prevent compiler error if the label is not used
}

func JsonPathParser.Dotnotation_expr

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func (p *JsonPathParser) Dotnotation_expr() (localctx IDotnotation_exprContext) {
        localctx = NewDotnotation_exprContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 4, JsonPathParserRULE_dotnotation_expr)
        p.SetState(21)
        p.GetErrorHandler().Sync(p)
        if p.HasError() {
                goto errorExit
        }

        switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1, p.GetParserRuleContext()) {
        case 1:
                p.EnterOuterAlt(localctx, 1)
                {
                        p.SetState(19)
                        p.IdentifierWithQualifier()
                }

        case 2:
                p.EnterOuterAlt(localctx, 2)
                {
                        p.SetState(20)
                        p.Match(JsonPathParserINDENTIFIER)
                        if p.HasError() {
                                // Recognition error - abort rule
                                goto errorExit
                        }
                }

        case antlr.ATNInvalidAltNumber:
                goto errorExit
        }

errorExit:
        if p.HasError() {
                v := p.GetError()
                localctx.SetException(v)
                p.GetErrorHandler().ReportError(p, v)
                p.GetErrorHandler().Recover(p, v)
                p.SetError(nil)
        }
        p.ExitRule()
        return localctx
        goto errorExit // Trick to prevent compiler error if the label is not used
}

func JsonPathParser.Dotnotation

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func (p *JsonPathParser) Dotnotation() (localctx IDotnotationContext) {
        localctx = NewDotnotationContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 2, JsonPathParserRULE_dotnotation)
        var _alt int

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(10)
                p.Match(JsonPathParserT__0)
                if p.HasError() {
                        // Recognition error - abort rule
                        goto errorExit
                }
        }
        {
                p.SetState(11)
                p.Dotnotation_expr()
        }
        p.SetState(16)
        p.GetErrorHandler().Sync(p)
        if p.HasError() {
                goto errorExit
        }
        _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 0, p.GetParserRuleContext())
        if p.HasError() {
                goto errorExit
        }
        for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
                if _alt == 1 {
                        {
                                p.SetState(12)
                                p.Match(JsonPathParserT__1)
                                if p.HasError() {
                                        // Recognition error - abort rule
                                        goto errorExit
                                }
                        }
                        {
                                p.SetState(13)
                                p.Dotnotation_expr()
                        }

                }
                p.SetState(18)
                p.GetErrorHandler().Sync(p)
                if p.HasError() {
                        goto errorExit
                }
                _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 0, p.GetParserRuleContext())
                if p.HasError() {
                        goto errorExit
                }
        }

errorExit:
        if p.HasError() {
                v := p.GetError()
                localctx.SetException(v)
                p.GetErrorHandler().ReportError(p, v)
                p.GetErrorHandler().Recover(p, v)
                p.SetError(nil)
        }
        p.ExitRule()
        return localctx
        goto errorExit // Trick to prevent compiler error if the label is not used
}

func DotnotationContext.AllDotnotation_expr

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func (s *DotnotationContext) AllDotnotation_expr() []IDotnotation_exprContext {
        children := s.GetChildren()
        len := 0
        for _, ctx := range children {
                if _, ok := ctx.(IDotnotation_exprContext); ok {
                        len++
                }
        }

        tst := make([]IDotnotation_exprContext, len)
        i := 0
        for _, ctx := range children {
                if t, ok := ctx.(IDotnotation_exprContext); ok {
                        tst[i] = t.(IDotnotation_exprContext)
                        i++
                }
        }

        return tst
}

func DotnotationContext.Dotnotation_expr

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func (s *DotnotationContext) Dotnotation_expr(i int) IDotnotation_exprContext {
        var t antlr.RuleContext
        j := 0
        for _, ctx := range s.GetChildren() {
                if _, ok := ctx.(IDotnotation_exprContext); ok {
                        if j == i {
                                t = ctx.(antlr.RuleContext)
                                break
                        }
                        j++
                }
        }

        if t == nil {
                return nil
        }

        return t.(IDotnotation_exprContext)
}

func JsonpathContext.Dotnotation

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func (s *JsonpathContext) Dotnotation() IDotnotationContext {
        var t antlr.RuleContext
        for _, ctx := range s.GetChildren() {
                if _, ok := ctx.(IDotnotationContext); ok {
                        t = ctx.(antlr.RuleContext)
                        break
                }
        }

        if t == nil {
                return nil
        }

        return t.(IDotnotationContext)
}

func Dotnotation_exprContext.IdentifierWithQualifier

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func (s *Dotnotation_exprContext) IdentifierWithQualifier() IIdentifierWithQualifierContext {
        var t antlr.RuleContext
        for _, ctx := range s.GetChildren() {
                if _, ok := ctx.(IIdentifierWithQualifierContext); ok {
                        t = ctx.(antlr.RuleContext)
                        break
                }
        }

        if t == nil {
                return nil
        }

        return t.(IIdentifierWithQualifierContext)
}

func NewEmptyDotnotationContext

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func NewEmptyDotnotationContext() *DotnotationContext {
        var p = new(DotnotationContext)
        antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
        p.RuleIndex = JsonPathParserRULE_dotnotation
        return p
}

func NewEmptyDotnotation_exprContext

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func NewEmptyDotnotation_exprContext() *Dotnotation_exprContext {
        var p = new(Dotnotation_exprContext)
        antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
        p.RuleIndex = JsonPathParserRULE_dotnotation_expr
        return p
}

func NewEmptyJsonpathContext

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func NewEmptyJsonpathContext() *JsonpathContext {
        var p = new(JsonpathContext)
        antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
        p.RuleIndex = JsonPathParserRULE_jsonpath
        return p
}

func NewEmptyIdentifierWithQualifierContext

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func NewEmptyIdentifierWithQualifierContext() *IdentifierWithQualifierContext {
        var p = new(IdentifierWithQualifierContext)
        antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)
        p.RuleIndex = JsonPathParserRULE_identifierWithQualifier
        return p
}

func DotnotationContext.Accept

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func (s *DotnotationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
        switch t := visitor.(type) {
        case JsonPathVisitor:
                return t.VisitDotnotation(s)

        default:
                return t.VisitChildren(s)
        }
}

func Dotnotation_exprContext.Accept

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func (s *Dotnotation_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
        switch t := visitor.(type) {
        case JsonPathVisitor:
                return t.VisitDotnotation_expr(s)

        default:
                return t.VisitChildren(s)
        }
}

func JsonpathContext.Accept

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func (s *JsonpathContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
        switch t := visitor.(type) {
        case JsonPathVisitor:
                return t.VisitJsonpath(s)

        default:
                return t.VisitChildren(s)
        }
}

func IdentifierWithQualifierContext.Accept

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func (s *IdentifierWithQualifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
        switch t := visitor.(type) {
        case JsonPathVisitor:
                return t.VisitIdentifierWithQualifier(s)

        default:
                return t.VisitChildren(s)
        }
}

func InitEmptyDotnotationContext

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

249	`func InitEmptyDotnotationContext(p *DotnotationContext) {`
250	`antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)`
251	`p.RuleIndex = JsonPathParserRULE_dotnotation`
252	`}`

func DotnotationContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func (s *DotnotationContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(JsonPathListener); ok {
                listenerT.EnterDotnotation(s)
        }
}

func Dotnotation_exprContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func (s *Dotnotation_exprContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(JsonPathListener); ok {
                listenerT.ExitDotnotation_expr(s)
        }
}

func InitEmptyIdentifierWithQualifierContext

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

575	`func InitEmptyIdentifierWithQualifierContext(p *IdentifierWithQualifierContext) {`
576	`antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)`
577	`p.RuleIndex = JsonPathParserRULE_identifierWithQualifier`
578	`}`

func JsonpathContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func (s *JsonpathContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(JsonPathListener); ok {
                listenerT.EnterJsonpath(s)
        }
}

func JsonpathContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func (s *JsonpathContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(JsonPathListener); ok {
                listenerT.ExitJsonpath(s)
        }
}

func IdentifierWithQualifierContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func (s *IdentifierWithQualifierContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(JsonPathListener); ok {
                listenerT.ExitIdentifierWithQualifier(s)
        }
}

func InitEmptyJsonpathContext

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

134	`func InitEmptyJsonpathContext(p *JsonpathContext) {`
135	`antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)`
136	`p.RuleIndex = JsonPathParserRULE_jsonpath`
137	`}`

func Dotnotation_exprContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func (s *Dotnotation_exprContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(JsonPathListener); ok {
                listenerT.EnterDotnotation_expr(s)
        }
}

func IdentifierWithQualifierContext.EnterRule

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func (s *IdentifierWithQualifierContext) EnterRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(JsonPathListener); ok {
                listenerT.EnterIdentifierWithQualifier(s)
        }
}

func InitEmptyDotnotation_exprContext

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

434	`func InitEmptyDotnotation_exprContext(p *Dotnotation_exprContext) {`
435	`antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1)`
436	`p.RuleIndex = JsonPathParserRULE_dotnotation_expr`
437	`}`

func DotnotationContext.ExitRule

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

func (s *DotnotationContext) ExitRule(listener antlr.ParseTreeListener) {
        if listenerT, ok := listener.(JsonPathListener); ok {
                listenerT.ExitDotnotation(s)
        }
}

func BaseJsonPathVisitor.VisitIdentifierWithQualifier

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_base_visitor.go:

22	`func (v BaseJsonPathVisitor) VisitIdentifierWithQualifier(ctx IdentifierWithQualifierContext) interface{} {`
23	`return v.VisitChildren(ctx)`
24	`}`

func IdentifierWithQualifierContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

593	`func (s *IdentifierWithQualifierContext) GetParser() antlr.Parser { return s.parser }`

func BaseJsonPathVisitor.VisitJsonpath

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_base_visitor.go:

10	`func (v BaseJsonPathVisitor) VisitJsonpath(ctx JsonpathContext) interface{} {`
11	`return v.VisitChildren(ctx)`
12	`}`

func DotnotationContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

310	`func (s *DotnotationContext) GetRuleContext() antlr.RuleContext {`
311	`return s`
312	`}`

func DotnotationContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

314	`func (s *DotnotationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
315	`return antlr.TreesStringTree(s, ruleNames, recog)`
316	`}`

func DotnotationContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

267	`func (s *DotnotationContext) GetParser() antlr.Parser { return s.parser }`

func BaseJsonPathVisitor.VisitDotnotation_expr

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_base_visitor.go:

18	`func (v BaseJsonPathVisitor) VisitDotnotation_expr(ctx Dotnotation_exprContext) interface{} {`
19	`return v.VisitChildren(ctx)`
20	`}`

func IdentifierWithQualifierContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

599	`func (s *IdentifierWithQualifierContext) GetRuleContext() antlr.RuleContext {`
600	`return s`
601	`}`

func IdentifierWithQualifierContext.INDENTIFIER

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

595	`func (s *IdentifierWithQualifierContext) INDENTIFIER() antlr.TerminalNode {`
596	`return s.GetToken(JsonPathParserINDENTIFIER, 0)`
597	`}`

func BaseJsonPathVisitor.VisitDotnotation

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_base_visitor.go:

14	`func (v BaseJsonPathVisitor) VisitDotnotation(ctx DotnotationContext) interface{} {`
15	`return v.VisitChildren(ctx)`
16	`}`

func IdentifierWithQualifierContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

603	`func (s *IdentifierWithQualifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
604	`return antlr.TreesStringTree(s, ruleNames, recog)`
605	`}`

func JsonpathContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

152	`func (s *JsonpathContext) GetParser() antlr.Parser { return s.parser }`

func JsonpathContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

174	`func (s *JsonpathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
175	`return antlr.TreesStringTree(s, ruleNames, recog)`
176	`}`

func Dotnotation_exprContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

452	`func (s *Dotnotation_exprContext) GetParser() antlr.Parser { return s.parser }`

func JsonpathContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

170	`func (s *JsonpathContext) GetRuleContext() antlr.RuleContext {`
171	`return s`
172	`}`

func Dotnotation_exprContext.INDENTIFIER

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

470	`func (s *Dotnotation_exprContext) INDENTIFIER() antlr.TerminalNode {`
471	`return s.GetToken(JsonPathParserINDENTIFIER, 0)`
472	`}`

func Dotnotation_exprContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

474	`func (s *Dotnotation_exprContext) GetRuleContext() antlr.RuleContext {`
475	`return s`
476	`}`

func Dotnotation_exprContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

478	`func (s *Dotnotation_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
479	`return antlr.TreesStringTree(s, ruleNames, recog)`
480	`}`

func Dotnotation_exprContext.IsDotnotation_exprContext

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

439	`func (*Dotnotation_exprContext) IsDotnotation_exprContext() {}`

func BaseJsonPathListener.ExitDotnotation

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go:

33	`func (s BaseJsonPathListener) ExitDotnotation(ctx DotnotationContext) {}`

func BaseJsonPathListener.EnterDotnotation

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go:

30	`func (s BaseJsonPathListener) EnterDotnotation(ctx DotnotationContext) {}`

func BaseJsonPathListener.ExitJsonpath

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go:

27	`func (s BaseJsonPathListener) ExitJsonpath(ctx JsonpathContext) {}`

func BaseJsonPathListener.EnterJsonpath

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go:

24	`func (s BaseJsonPathListener) EnterJsonpath(ctx JsonpathContext) {}`

func BaseJsonPathListener.EnterDotnotation_expr

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go:

36	`func (s BaseJsonPathListener) EnterDotnotation_expr(ctx Dotnotation_exprContext) {}`

func IdentifierWithQualifierContext.IsIdentifierWithQualifierContext

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

580	`func (*IdentifierWithQualifierContext) IsIdentifierWithQualifierContext() {}`

func BaseJsonPathListener.ExitEveryRule

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go:

21	`func (s *BaseJsonPathListener) ExitEveryRule(ctx antlr.ParserRuleContext) {}`

func BaseJsonPathListener.ExitDotnotation_expr

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go:

39	`func (s BaseJsonPathListener) ExitDotnotation_expr(ctx Dotnotation_exprContext) {}`

func BaseJsonPathListener.EnterIdentifierWithQualifier

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go:

42	`func (s BaseJsonPathListener) EnterIdentifierWithQualifier(ctx IdentifierWithQualifierContext) {}`

func BaseJsonPathListener.ExitIdentifierWithQualifier

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go:

45	`func (s BaseJsonPathListener) ExitIdentifierWithQualifier(ctx IdentifierWithQualifierContext) {}`

func DotnotationContext.IsDotnotationContext

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

254	`func (*DotnotationContext) IsDotnotationContext() {}`

func BaseJsonPathListener.VisitTerminal

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go:

12	`func (s *BaseJsonPathListener) VisitTerminal(node antlr.TerminalNode) {}`

func JsonpathContext.IsJsonpathContext

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_parser.go:

139	`func (*JsonpathContext) IsJsonpathContext() {}`

func BaseJsonPathListener.EnterEveryRule

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go:

18	`func (s *BaseJsonPathListener) EnterEveryRule(ctx antlr.ParserRuleContext) {}`

func BaseJsonPathListener.VisitErrorNode

Back

In /Users/kun/gobatis/gobatis/parser/structpath/jsonpath_base_listener.go:

15	`func (s *BaseJsonPathListener) VisitErrorNode(node antlr.ErrorNode) {}`

Package Overview: github.com/gobatis/gobatis/parser/xml 37.5%

Please select a function to see what's left for testing.

`NewXMLLexer(...)`	`github.com/gobatis/gobatis/parser/xml/xml_lexer.go`	`100.0%`	`15/15`
`NewXMLParser(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`13/13`
`NewContentContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`5/5`
`NewElementContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`5/5`
`NewDocumentContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`5/5`
`NewReferenceContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`5/5`
`NewChardataContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`5/5`
`DocumentContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`1/1`
`ChardataContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`1/1`
`ReferenceContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`1/1`
`@936:8(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`1/1`
`ReferenceContext.EntityRef(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`1/1`
`ContentContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`1/1`
`@232:8(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`1/1`
`@565:8(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`1/1`
`@775:8(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`1/1`
`@1122:8(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`1/1`
`ElementContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`1/1`
`ElementContext.Name(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`1/1`
`XMLParser.Chardata(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`92.3%`	`12/13`
`XMLParser.Reference(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`92.3%`	`12/13`
`XMLParser.Content(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`78.6%`	`33/42`
`XMLParser.Document(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`63.6%`	`21/33`
`XMLParser.Element(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`58.8%`	`30/51`
`@779:8(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`16.7%`	`1/6`
`@569:8(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`16.7%`	`1/6`
`@940:8(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`16.7%`	`1/6`
`@1126:8(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`16.7%`	`1/6`
`@236:8(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`16.7%`	`1/6`
`XMLParser.Prolog(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/20`
`XMLParser.Misc(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/13`
`XMLParser.Attribute(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/12`
`DocumentContext.AllMisc(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/6`
`ElementContext.AllAttribute(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/6`
`ContentContext.AllElement(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/6`
`ContentContext.AllReference(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/6`
`@382:8(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/6`
`@1221:8(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/6`
`PrologContext.AllAttribute(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/6`
`@1034:8(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/6`
`ContentContext.AllChardata(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/6`
`NewAttributeContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/5`
`NewMiscContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/5`
`NewPrologContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/5`
`ContentContext.Chardata(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/4`
`PrologContext.Attribute(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/4`
`NewEmptyChardataContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/4`
`NewEmptyAttributeContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/4`
`DocumentContext.Element(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/4`
`NewEmptyElementContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/4`
`NewEmptyDocumentContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/4`
`DocumentContext.Prolog(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/4`
`ContentContext.Reference(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/4`
`DocumentContext.Misc(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/4`
`ContentContext.Element(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/4`
`NewEmptyReferenceContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/4`
`NewEmptyMiscContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/4`
`NewEmptyPrologContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/4`
`NewEmptyContentContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/4`
`ElementContext.Content(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/4`
`ElementContext.Attribute(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/4`
`ElementContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`AttributeContext.Name(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ElementContext.SLASH_CLOSE(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ElementContext.CLOSE(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ElementContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`@378:8(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ElementContext.AllCLOSE(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`PrologContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ElementContext.AllName(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`@1217:8(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ElementContext.OPEN(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ReferenceContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`DocumentContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ReferenceContext.CharRef(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ElementContext.AllOPEN(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ReferenceContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`PrologContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`PrologContext.XMLDeclOpen(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ElementContext.SLASH(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`PrologContext.SPECIAL_CLOSE(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`MiscContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ContentContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`AttributeContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`MiscContext.COMMENT(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`AttributeContext.EQUALS(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`AttributeContext.STRING(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`AttributeContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`AttributeContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ContentContext.COMMENT(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`@1030:8(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ContentContext.AllCOMMENT(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ContentContext.PI(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`MiscContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ContentContext.AllPI(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ChardataContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ChardataContext.TEXT(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ChardataContext.SEA_WS(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`DocumentContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ChardataContext.ToStringTree(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`MiscContext.SEA_WS(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ContentContext.CDATA(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ContentContext.AllCDATA(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ContentContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`MiscContext.PI(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`PrologContext.GetRuleContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`MiscContext.GetParser(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`0.0%`	`0/1`
`ElementContext.IsElementContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`0/0`
`MiscContext.IsMiscContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`0/0`
`DocumentContext.IsDocumentContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`0/0`
`ChardataContext.IsChardataContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`0/0`
`AttributeContext.IsAttributeContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`0/0`
`ContentContext.IsContentContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`0/0`
`ReferenceContext.IsReferenceContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`0/0`
`PrologContext.IsPrologContext(...)`	`github.com/gobatis/gobatis/parser/xml/xml_parser.go`	`100.0%`	`0/0`
`BaseXMLParserListener.VisitTerminal(...)`	`github.com/gobatis/gobatis/parser/xml/xmlparser_base_listener.go`	`100.0%`	`0/0`
`BaseXMLParserListener.VisitErrorNode(...)`	`github.com/gobatis/gobatis/parser/xml/xmlparser_base_listener.go`	`100.0%`	`0/0`
`BaseXMLParserListener.EnterEveryRule(...)`	`github.com/gobatis/gobatis/parser/xml/xmlparser_base_listener.go`	`100.0%`	`0/0`
`BaseXMLParserListener.ExitEveryRule(...)`	`github.com/gobatis/gobatis/parser/xml/xmlparser_base_listener.go`	`100.0%`	`0/0`
`BaseXMLParserListener.EnterDocument(...)`	`github.com/gobatis/gobatis/parser/xml/xmlparser_base_listener.go`	`100.0%`	`0/0`
`BaseXMLParserListener.ExitDocument(...)`	`github.com/gobatis/gobatis/parser/xml/xmlparser_base_listener.go`	`100.0%`	`0/0`
`BaseXMLParserListener.EnterProlog(...)`	`github.com/gobatis/gobatis/parser/xml/xmlparser_base_listener.go`	`100.0%`	`0/0`
`BaseXMLParserListener.ExitProlog(...)`	`github.com/gobatis/gobatis/parser/xml/xmlparser_base_listener.go`	`100.0%`	`0/0`
`BaseXMLParserListener.EnterContent(...)`	`github.com/gobatis/gobatis/parser/xml/xmlparser_base_listener.go`	`100.0%`	`0/0`
`BaseXMLParserListener.ExitContent(...)`	`github.com/gobatis/gobatis/parser/xml/xmlparser_base_listener.go`	`100.0%`	`0/0`
`BaseXMLParserListener.EnterElement(...)`	`github.com/gobatis/gobatis/parser/xml/xmlparser_base_listener.go`	`100.0%`	`0/0`
`BaseXMLParserListener.ExitElement(...)`	`github.com/gobatis/gobatis/parser/xml/xmlparser_base_listener.go`	`100.0%`	`0/0`
`BaseXMLParserListener.EnterReference(...)`	`github.com/gobatis/gobatis/parser/xml/xmlparser_base_listener.go`	`100.0%`	`0/0`
`BaseXMLParserListener.ExitReference(...)`	`github.com/gobatis/gobatis/parser/xml/xmlparser_base_listener.go`	`100.0%`	`0/0`
`BaseXMLParserListener.EnterAttribute(...)`	`github.com/gobatis/gobatis/parser/xml/xmlparser_base_listener.go`	`100.0%`	`0/0`
`BaseXMLParserListener.ExitAttribute(...)`	`github.com/gobatis/gobatis/parser/xml/xmlparser_base_listener.go`	`100.0%`	`0/0`
`BaseXMLParserListener.EnterChardata(...)`	`github.com/gobatis/gobatis/parser/xml/xmlparser_base_listener.go`	`100.0%`	`0/0`
`BaseXMLParserListener.ExitChardata(...)`	`github.com/gobatis/gobatis/parser/xml/xmlparser_base_listener.go`	`100.0%`	`0/0`
`BaseXMLParserListener.EnterMisc(...)`	`github.com/gobatis/gobatis/parser/xml/xmlparser_base_listener.go`	`100.0%`	`0/0`
`BaseXMLParserListener.ExitMisc(...)`	`github.com/gobatis/gobatis/parser/xml/xmlparser_base_listener.go`	`100.0%`	`0/0`

func NewXMLLexer

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_lexer.go:

func NewXMLLexer(input antlr.CharStream) *XMLLexer {
        l := new(XMLLexer)
        lexerDeserializer := antlr.NewATNDeserializer(nil)
        lexerAtn := lexerDeserializer.DeserializeFromUInt16(serializedLexerAtn)
        lexerDecisionToDFA := make([]*antlr.DFA, len(lexerAtn.DecisionToState))
        for index, ds := range lexerAtn.DecisionToState {
                lexerDecisionToDFA[index] = antlr.NewDFA(ds, index)
        }
        l.BaseLexer = antlr.NewBaseLexer(input)
        l.Interpreter = antlr.NewLexerATNSimulator(l, lexerAtn, lexerDecisionToDFA, antlr.NewPredictionContextCache())

        l.channelNames = lexerChannelNames
        l.modeNames = lexerModeNames
        l.RuleNames = lexerRuleNames
        l.LiteralNames = lexerLiteralNames
        l.SymbolicNames = lexerSymbolicNames
        l.GrammarFileName = "XMLLexer.g4"
        // TODO: l.EOF = antlr.TokenEOF

        return l
}

func NewXMLParser

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func NewXMLParser(input antlr.TokenStream) *XMLParser {
        this := new(XMLParser)
        deserializer := antlr.NewATNDeserializer(nil)
        deserializedATN := deserializer.DeserializeFromUInt16(parserATN)
        decisionToDFA := make([]*antlr.DFA, len(deserializedATN.DecisionToState))
        for index, ds := range deserializedATN.DecisionToState {
                decisionToDFA[index] = antlr.NewDFA(ds, index)
        }
        this.BaseParser = antlr.NewBaseParser(input)

        this.Interpreter = antlr.NewParserATNSimulator(this, deserializedATN, decisionToDFA, antlr.NewPredictionContextCache())
        this.RuleNames = ruleNames
        this.LiteralNames = literalNames
        this.SymbolicNames = symbolicNames
        this.GrammarFileName = "XMLParser.g4"

        return this
}

func NewContentContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func NewContentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ContentContext {
        var p = new(ContentContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = XMLParserRULE_content

        return p
}

func NewElementContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func NewElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElementContext {
        var p = new(ElementContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = XMLParserRULE_element

        return p
}

func NewDocumentContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func NewDocumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DocumentContext {
        var p = new(DocumentContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = XMLParserRULE_document

        return p
}

func NewReferenceContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func NewReferenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReferenceContext {
        var p = new(ReferenceContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = XMLParserRULE_reference

        return p
}

func NewChardataContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func NewChardataContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ChardataContext {
        var p = new(ChardataContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = XMLParserRULE_chardata

        return p
}

func DocumentContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

219	`func (s *DocumentContext) GetRuleContext() antlr.RuleContext {`
220	`return s`
221	`}`

func ChardataContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1109	`func (s *ChardataContext) GetRuleContext() antlr.RuleContext {`
1110	`return s`
1111	`}`

func ReferenceContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

923	`func (s *ReferenceContext) GetRuleContext() antlr.RuleContext {`
924	`return s`
925	`}`

func @936:8

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

936	`func() {`
937	`p.ExitRule()`
938	`}`

func ReferenceContext.EntityRef

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

915	`func (s *ReferenceContext) EntityRef() antlr.TerminalNode {`
916	`return s.GetToken(XMLParserEntityRef, 0)`
917	`}`

func ContentContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

552	`func (s *ContentContext) GetRuleContext() antlr.RuleContext {`
553	`return s`
554	`}`

func @232:8

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

232	`func() {`
233	`p.ExitRule()`
234	`}`

func @565:8

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

565	`func() {`
566	`p.ExitRule()`
567	`}`

func @775:8

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

775	`func() {`
776	`p.ExitRule()`
777	`}`

func @1122:8

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1122	`func() {`
1123	`p.ExitRule()`
1124	`}`

func ElementContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

762	`func (s *ElementContext) GetRuleContext() antlr.RuleContext {`
763	`return s`
764	`}`

func ElementContext.Name

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

709	`func (s *ElementContext) Name(i int) antlr.TerminalNode {`
710	`return s.GetToken(XMLParserName, i)`
711	`}`

func XMLParser.Chardata

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (p *XMLParser) Chardata() (localctx IChardataContext) {
        localctx = NewChardataContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 12, XMLParserRULE_chardata)
        var _la int

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(91)
                _la = p.GetTokenStream().LA(1)

                if !(_la == XMLParserSEA_WS || _la == XMLParserTEXT) {
                        p.GetErrorHandler().RecoverInline(p)
                } else {
                        p.GetErrorHandler().ReportMatch(p)
                        p.Consume()
                }
        }

        return localctx
}

func XMLParser.Reference

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (p *XMLParser) Reference() (localctx IReferenceContext) {
        localctx = NewReferenceContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 8, XMLParserRULE_reference)
        var _la int

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(85)
                _la = p.GetTokenStream().LA(1)

                if !(_la == XMLParserEntityRef || _la == XMLParserCharRef) {
                        p.GetErrorHandler().RecoverInline(p)
                } else {
                        p.GetErrorHandler().ReportMatch(p)
                        p.Consume()
                }
        }

        return localctx
}

func XMLParser.Content

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (p *XMLParser) Content() (localctx IContentContext) {
        localctx = NewContentContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 4, XMLParserRULE_content)
        var _la int

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        var _alt int

        p.EnterOuterAlt(localctx, 1)
        p.SetState(42)
        p.GetErrorHandler().Sync(p)
        _la = p.GetTokenStream().LA(1)

        if _la == XMLParserSEA_WS || _la == XMLParserTEXT {
                {
                        p.SetState(41)
                        p.Chardata()
                }

        }
        p.SetState(56)
        p.GetErrorHandler().Sync(p)
        _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 7, p.GetParserRuleContext())

        for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
                if _alt == 1 {
                        p.SetState(49)
                        p.GetErrorHandler().Sync(p)

                        switch p.GetTokenStream().LA(1) {
                        case XMLParserOPEN:
                                {
                                        p.SetState(44)
                                        p.Element()
                                }

                        case XMLParserEntityRef, XMLParserCharRef:
                                {
                                        p.SetState(45)
                                        p.Reference()
                                }

                        case XMLParserCDATA:
                                {
                                        p.SetState(46)
                                        p.Match(XMLParserCDATA)
                                }

                        case XMLParserPI:
                                {
                                        p.SetState(47)
                                        p.Match(XMLParserPI)
                                }

                        case XMLParserCOMMENT:
                                {
                                        p.SetState(48)
                                        p.Match(XMLParserCOMMENT)
                                }

                        default:
                                panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
                        }
                        p.SetState(52)
                        p.GetErrorHandler().Sync(p)
                        _la = p.GetTokenStream().LA(1)

                        if _la == XMLParserSEA_WS || _la == XMLParserTEXT {
                                {
                                        p.SetState(51)
                                        p.Chardata()
                                }

                        }

                }
                p.SetState(58)
                p.GetErrorHandler().Sync(p)
                _alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 7, p.GetParserRuleContext())
        }

        return localctx
}

func XMLParser.Document

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (p *XMLParser) Document() (localctx IDocumentContext) {
        localctx = NewDocumentContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 0, XMLParserRULE_document)
        var _la int

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        p.SetState(17)
        p.GetErrorHandler().Sync(p)
        _la = p.GetTokenStream().LA(1)

        if _la == XMLParserXMLDeclOpen {
                {
                        p.SetState(16)
                        p.Prolog()
                }

        }
        p.SetState(22)
        p.GetErrorHandler().Sync(p)
        _la = p.GetTokenStream().LA(1)

        for ((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<XMLParserCOMMENT)|(1<<XMLParserSEA_WS)|(1<<XMLParserPI))) != 0 {
                {
                        p.SetState(19)
                        p.Misc()
                }

                p.SetState(24)
                p.GetErrorHandler().Sync(p)
                _la = p.GetTokenStream().LA(1)
        }
        {
                p.SetState(25)
                p.Element()
        }
        p.SetState(29)
        p.GetErrorHandler().Sync(p)
        _la = p.GetTokenStream().LA(1)

        for ((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<XMLParserCOMMENT)|(1<<XMLParserSEA_WS)|(1<<XMLParserPI))) != 0 {
                {
                        p.SetState(26)
                        p.Misc()
                }

                p.SetState(31)
                p.GetErrorHandler().Sync(p)
                _la = p.GetTokenStream().LA(1)
        }

        return localctx
}

func XMLParser.Element

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (p *XMLParser) Element() (localctx IElementContext) {
        localctx = NewElementContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 6, XMLParserRULE_element)
        var _la int

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.SetState(83)
        p.GetErrorHandler().Sync(p)
        switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 10, p.GetParserRuleContext()) {
        case 1:
                p.EnterOuterAlt(localctx, 1)
                {
                        p.SetState(59)
                        p.Match(XMLParserOPEN)
                }
                {
                        p.SetState(60)
                        p.Match(XMLParserName)
                }
                p.SetState(64)
                p.GetErrorHandler().Sync(p)
                _la = p.GetTokenStream().LA(1)

                for _la == XMLParserName {
                        {
                                p.SetState(61)
                                p.Attribute()
                        }

                        p.SetState(66)
                        p.GetErrorHandler().Sync(p)
                        _la = p.GetTokenStream().LA(1)
                }
                {
                        p.SetState(67)
                        p.Match(XMLParserCLOSE)
                }
                {
                        p.SetState(68)
                        p.Content()
                }
                {
                        p.SetState(69)
                        p.Match(XMLParserOPEN)
                }
                {
                        p.SetState(70)
                        p.Match(XMLParserSLASH)
                }
                {
                        p.SetState(71)
                        p.Match(XMLParserName)
                }
                {
                        p.SetState(72)
                        p.Match(XMLParserCLOSE)
                }

        case 2:
                p.EnterOuterAlt(localctx, 2)
                {
                        p.SetState(74)
                        p.Match(XMLParserOPEN)
                }
                {
                        p.SetState(75)
                        p.Match(XMLParserName)
                }
                p.SetState(79)
                p.GetErrorHandler().Sync(p)
                _la = p.GetTokenStream().LA(1)

                for _la == XMLParserName {
                        {
                                p.SetState(76)
                                p.Attribute()
                        }

                        p.SetState(81)
                        p.GetErrorHandler().Sync(p)
                        _la = p.GetTokenStream().LA(1)
                }
                {
                        p.SetState(82)
                        p.Match(XMLParserSLASH_CLOSE)
                }

        }

        return localctx
}

func @779:8

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func @569:8

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func @940:8

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func @1126:8

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func @236:8

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func XMLParser.Prolog

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (p *XMLParser) Prolog() (localctx IPrologContext) {
        localctx = NewPrologContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 2, XMLParserRULE_prolog)
        var _la int

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(32)
                p.Match(XMLParserXMLDeclOpen)
        }
        p.SetState(36)
        p.GetErrorHandler().Sync(p)
        _la = p.GetTokenStream().LA(1)

        for _la == XMLParserName {
                {
                        p.SetState(33)
                        p.Attribute()
                }

                p.SetState(38)
                p.GetErrorHandler().Sync(p)
                _la = p.GetTokenStream().LA(1)
        }
        {
                p.SetState(39)
                p.Match(XMLParserSPECIAL_CLOSE)
        }

        return localctx
}

func XMLParser.Misc

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (p *XMLParser) Misc() (localctx IMiscContext) {
        localctx = NewMiscContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 14, XMLParserRULE_misc)
        var _la int

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(93)
                _la = p.GetTokenStream().LA(1)

                if !(((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<XMLParserCOMMENT)|(1<<XMLParserSEA_WS)|(1<<XMLParserPI))) != 0) {
                        p.GetErrorHandler().RecoverInline(p)
                } else {
                        p.GetErrorHandler().ReportMatch(p)
                        p.Consume()
                }
        }

        return localctx
}

func XMLParser.Attribute

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (p *XMLParser) Attribute() (localctx IAttributeContext) {
        localctx = NewAttributeContext(p, p.GetParserRuleContext(), p.GetState())
        p.EnterRule(localctx, 10, XMLParserRULE_attribute)

        defer func() {
                p.ExitRule()
        }()

        defer func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }()

        p.EnterOuterAlt(localctx, 1)
        {
                p.SetState(87)
                p.Match(XMLParserName)
        }
        {
                p.SetState(88)
                p.Match(XMLParserEQUALS)
        }
        {
                p.SetState(89)
                p.Match(XMLParserSTRING)
        }

        return localctx
}

func DocumentContext.AllMisc

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (s *DocumentContext) AllMisc() []IMiscContext {
        var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IMiscContext)(nil)).Elem())
        var tst = make([]IMiscContext, len(ts))

        for i, t := range ts {
                if t != nil {
                        tst[i] = t.(IMiscContext)
                }
        }

        return tst
}

func ElementContext.AllAttribute

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (s *ElementContext) AllAttribute() []IAttributeContext {
        var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAttributeContext)(nil)).Elem())
        var tst = make([]IAttributeContext, len(ts))

        for i, t := range ts {
                if t != nil {
                        tst[i] = t.(IAttributeContext)
                }
        }

        return tst
}

func ContentContext.AllElement

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (s *ContentContext) AllElement() []IElementContext {
        var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IElementContext)(nil)).Elem())
        var tst = make([]IElementContext, len(ts))

        for i, t := range ts {
                if t != nil {
                        tst[i] = t.(IElementContext)
                }
        }

        return tst
}

func ContentContext.AllReference

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (s *ContentContext) AllReference() []IReferenceContext {
        var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IReferenceContext)(nil)).Elem())
        var tst = make([]IReferenceContext, len(ts))

        for i, t := range ts {
                if t != nil {
                        tst[i] = t.(IReferenceContext)
                }
        }

        return tst
}

func @382:8

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func @1221:8

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func PrologContext.AllAttribute

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (s *PrologContext) AllAttribute() []IAttributeContext {
        var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAttributeContext)(nil)).Elem())
        var tst = make([]IAttributeContext, len(ts))

        for i, t := range ts {
                if t != nil {
                        tst[i] = t.(IAttributeContext)
                }
        }

        return tst
}

func @1034:8

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func() {
                if err := recover(); err != nil {
                        if v, ok := err.(antlr.RecognitionException); ok {
                                localctx.SetException(v)
                                p.GetErrorHandler().ReportError(p, v)
                                p.GetErrorHandler().Recover(p, v)
                        } else {
                                panic(err)
                        }
                }
        }

func ContentContext.AllChardata

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (s *ContentContext) AllChardata() []IChardataContext {
        var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IChardataContext)(nil)).Elem())
        var tst = make([]IChardataContext, len(ts))

        for i, t := range ts {
                if t != nil {
                        tst[i] = t.(IChardataContext)
                }
        }

        return tst
}

func NewAttributeContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func NewAttributeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AttributeContext {
        var p = new(AttributeContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = XMLParserRULE_attribute

        return p
}

func NewMiscContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func NewMiscContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MiscContext {
        var p = new(MiscContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = XMLParserRULE_misc

        return p
}

func NewPrologContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func NewPrologContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrologContext {
        var p = new(PrologContext)

        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

        p.parser = parser
        p.RuleIndex = XMLParserRULE_prolog

        return p
}

func ContentContext.Chardata

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (s *ContentContext) Chardata(i int) IChardataContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IChardataContext)(nil)).Elem(), i)

        if t == nil {
                return nil
        }

        return t.(IChardataContext)
}

func PrologContext.Attribute

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (s *PrologContext) Attribute(i int) IAttributeContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IAttributeContext)(nil)).Elem(), i)

        if t == nil {
                return nil
        }

        return t.(IAttributeContext)
}

func NewEmptyChardataContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func NewEmptyChardataContext() *ChardataContext {
        var p = new(ChardataContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = XMLParserRULE_chardata
        return p
}

func NewEmptyAttributeContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func NewEmptyAttributeContext() *AttributeContext {
        var p = new(AttributeContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = XMLParserRULE_attribute
        return p
}

func DocumentContext.Element

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (s *DocumentContext) Element() IElementContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementContext)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(IElementContext)
}

func NewEmptyElementContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func NewEmptyElementContext() *ElementContext {
        var p = new(ElementContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = XMLParserRULE_element
        return p
}

func NewEmptyDocumentContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func NewEmptyDocumentContext() *DocumentContext {
        var p = new(DocumentContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = XMLParserRULE_document
        return p
}

func DocumentContext.Prolog

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (s *DocumentContext) Prolog() IPrologContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrologContext)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(IPrologContext)
}

func ContentContext.Reference

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (s *ContentContext) Reference(i int) IReferenceContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IReferenceContext)(nil)).Elem(), i)

        if t == nil {
                return nil
        }

        return t.(IReferenceContext)
}

func DocumentContext.Misc

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (s *DocumentContext) Misc(i int) IMiscContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IMiscContext)(nil)).Elem(), i)

        if t == nil {
                return nil
        }

        return t.(IMiscContext)
}

func ContentContext.Element

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (s *ContentContext) Element(i int) IElementContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementContext)(nil)).Elem(), i)

        if t == nil {
                return nil
        }

        return t.(IElementContext)
}

func NewEmptyReferenceContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func NewEmptyReferenceContext() *ReferenceContext {
        var p = new(ReferenceContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = XMLParserRULE_reference
        return p
}

func NewEmptyMiscContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func NewEmptyMiscContext() *MiscContext {
        var p = new(MiscContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = XMLParserRULE_misc
        return p
}

func NewEmptyPrologContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func NewEmptyPrologContext() *PrologContext {
        var p = new(PrologContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = XMLParserRULE_prolog
        return p
}

func NewEmptyContentContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func NewEmptyContentContext() *ContentContext {
        var p = new(ContentContext)
        p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
        p.RuleIndex = XMLParserRULE_content
        return p
}

func ElementContext.Content

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (s *ElementContext) Content() IContentContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IContentContext)(nil)).Elem(), 0)

        if t == nil {
                return nil
        }

        return t.(IContentContext)
}

func ElementContext.Attribute

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

func (s *ElementContext) Attribute(i int) IAttributeContext {
        var t = s.GetTypedRuleContext(reflect.TypeOf((*IAttributeContext)(nil)).Elem(), i)

        if t == nil {
                return nil
        }

        return t.(IAttributeContext)
}

func ElementContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

695	`func (s *ElementContext) GetParser() antlr.Parser { return s.parser }`

func AttributeContext.Name

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1006	`func (s *AttributeContext) Name() antlr.TerminalNode {`
1007	`return s.GetToken(XMLParserName, 0)`
1008	`}`

func ElementContext.SLASH_CLOSE

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

758	`func (s *ElementContext) SLASH_CLOSE() antlr.TerminalNode {`
759	`return s.GetToken(XMLParserSLASH_CLOSE, 0)`
760	`}`

func ElementContext.CLOSE

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

717	`func (s *ElementContext) CLOSE(i int) antlr.TerminalNode {`
718	`return s.GetToken(XMLParserCLOSE, i)`
719	`}`

func ElementContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

766	`func (s *ElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
767	`return antlr.TreesStringTree(s, ruleNames, recog)`
768	`}`

func @378:8

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

378	`func() {`
379	`p.ExitRule()`
380	`}`

func ElementContext.AllCLOSE

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

713	`func (s *ElementContext) AllCLOSE() []antlr.TerminalNode {`
714	`return s.GetTokens(XMLParserCLOSE)`
715	`}`

func PrologContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

332	`func (s *PrologContext) GetParser() antlr.Parser { return s.parser }`

func ElementContext.AllName

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

705	`func (s *ElementContext) AllName() []antlr.TerminalNode {`
706	`return s.GetTokens(XMLParserName)`
707	`}`

func @1217:8

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1217	`func() {`
1218	`p.ExitRule()`
1219	`}`

func ElementContext.OPEN

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

701	`func (s *ElementContext) OPEN(i int) antlr.TerminalNode {`
702	`return s.GetToken(XMLParserOPEN, i)`
703	`}`

func ReferenceContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

913	`func (s *ReferenceContext) GetParser() antlr.Parser { return s.parser }`

func DocumentContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

223	`func (s *DocumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
224	`return antlr.TreesStringTree(s, ruleNames, recog)`
225	`}`

func ReferenceContext.CharRef

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

919	`func (s *ReferenceContext) CharRef() antlr.TerminalNode {`
920	`return s.GetToken(XMLParserCharRef, 0)`
921	`}`

func ElementContext.AllOPEN

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

697	`func (s *ElementContext) AllOPEN() []antlr.TerminalNode {`
698	`return s.GetTokens(XMLParserOPEN)`
699	`}`

func ReferenceContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

927	`func (s *ReferenceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
928	`return antlr.TreesStringTree(s, ruleNames, recog)`
929	`}`

func PrologContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

369	`func (s *PrologContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
370	`return antlr.TreesStringTree(s, ruleNames, recog)`
371	`}`

func PrologContext.XMLDeclOpen

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

334	`func (s *PrologContext) XMLDeclOpen() antlr.TerminalNode {`
335	`return s.GetToken(XMLParserXMLDeclOpen, 0)`
336	`}`

func ElementContext.SLASH

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

731	`func (s *ElementContext) SLASH() antlr.TerminalNode {`
732	`return s.GetToken(XMLParserSLASH, 0)`
733	`}`

func PrologContext.SPECIAL_CLOSE

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

338	`func (s *PrologContext) SPECIAL_CLOSE() antlr.TerminalNode {`
339	`return s.GetToken(XMLParserSPECIAL_CLOSE, 0)`
340	`}`

func MiscContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1208	`func (s *MiscContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
1209	`return antlr.TreesStringTree(s, ruleNames, recog)`
1210	`}`

func ContentContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

556	`func (s *ContentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
557	`return antlr.TreesStringTree(s, ruleNames, recog)`
558	`}`

func AttributeContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1004	`func (s *AttributeContext) GetParser() antlr.Parser { return s.parser }`

func MiscContext.COMMENT

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1192	`func (s *MiscContext) COMMENT() antlr.TerminalNode {`
1193	`return s.GetToken(XMLParserCOMMENT, 0)`
1194	`}`

func AttributeContext.EQUALS

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1010	`func (s *AttributeContext) EQUALS() antlr.TerminalNode {`
1011	`return s.GetToken(XMLParserEQUALS, 0)`
1012	`}`

func AttributeContext.STRING

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1014	`func (s *AttributeContext) STRING() antlr.TerminalNode {`
1015	`return s.GetToken(XMLParserSTRING, 0)`
1016	`}`

func AttributeContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1018	`func (s *AttributeContext) GetRuleContext() antlr.RuleContext {`
1019	`return s`
1020	`}`

func AttributeContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1022	`func (s *AttributeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
1023	`return antlr.TreesStringTree(s, ruleNames, recog)`
1024	`}`

func ContentContext.COMMENT

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

548	`func (s *ContentContext) COMMENT(i int) antlr.TerminalNode {`
549	`return s.GetToken(XMLParserCOMMENT, i)`
550	`}`

func @1030:8

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1030	`func() {`
1031	`p.ExitRule()`
1032	`}`

func ContentContext.AllCOMMENT

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

544	`func (s *ContentContext) AllCOMMENT() []antlr.TerminalNode {`
545	`return s.GetTokens(XMLParserCOMMENT)`
546	`}`

func ContentContext.PI

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

540	`func (s *ContentContext) PI(i int) antlr.TerminalNode {`
541	`return s.GetToken(XMLParserPI, i)`
542	`}`

func MiscContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1204	`func (s *MiscContext) GetRuleContext() antlr.RuleContext {`
1205	`return s`
1206	`}`

func ContentContext.AllPI

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

536	`func (s *ContentContext) AllPI() []antlr.TerminalNode {`
537	`return s.GetTokens(XMLParserPI)`
538	`}`

func ChardataContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1099	`func (s *ChardataContext) GetParser() antlr.Parser { return s.parser }`

func ChardataContext.TEXT

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1101	`func (s *ChardataContext) TEXT() antlr.TerminalNode {`
1102	`return s.GetToken(XMLParserTEXT, 0)`
1103	`}`

func ChardataContext.SEA_WS

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1105	`func (s *ChardataContext) SEA_WS() antlr.TerminalNode {`
1106	`return s.GetToken(XMLParserSEA_WS, 0)`
1107	`}`

func DocumentContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

174	`func (s *DocumentContext) GetParser() antlr.Parser { return s.parser }`

func ChardataContext.ToStringTree

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1113	`func (s *ChardataContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {`
1114	`return antlr.TreesStringTree(s, ruleNames, recog)`
1115	`}`

func MiscContext.SEA_WS

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1200	`func (s *MiscContext) SEA_WS() antlr.TerminalNode {`
1201	`return s.GetToken(XMLParserSEA_WS, 0)`
1202	`}`

func ContentContext.CDATA

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

532	`func (s *ContentContext) CDATA(i int) antlr.TerminalNode {`
533	`return s.GetToken(XMLParserCDATA, i)`
534	`}`

func ContentContext.AllCDATA

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

528	`func (s *ContentContext) AllCDATA() []antlr.TerminalNode {`
529	`return s.GetTokens(XMLParserCDATA)`
530	`}`

func ContentContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

457	`func (s *ContentContext) GetParser() antlr.Parser { return s.parser }`

func MiscContext.PI

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1196	`func (s *MiscContext) PI() antlr.TerminalNode {`
1197	`return s.GetToken(XMLParserPI, 0)`
1198	`}`

func PrologContext.GetRuleContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

365	`func (s *PrologContext) GetRuleContext() antlr.RuleContext {`
366	`return s`
367	`}`

func MiscContext.GetParser

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1190	`func (s *MiscContext) GetParser() antlr.Parser { return s.parser }`

func ElementContext.IsElementContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

682	`func (*ElementContext) IsElementContext() {}`

func MiscContext.IsMiscContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1177	`func (*MiscContext) IsMiscContext() {}`

func DocumentContext.IsDocumentContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

161	`func (*DocumentContext) IsDocumentContext() {}`

func ChardataContext.IsChardataContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

1086	`func (*ChardataContext) IsChardataContext() {}`

func AttributeContext.IsAttributeContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

991	`func (*AttributeContext) IsAttributeContext() {}`

func ContentContext.IsContentContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

444	`func (*ContentContext) IsContentContext() {}`

func ReferenceContext.IsReferenceContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

900	`func (*ReferenceContext) IsReferenceContext() {}`

func PrologContext.IsPrologContext

Back

In /Users/kun/gobatis/gobatis/parser/xml/xml_parser.go:

319	`func (*PrologContext) IsPrologContext() {}`

func BaseXMLParserListener.VisitTerminal

Back

In /Users/kun/gobatis/gobatis/parser/xml/xmlparser_base_listener.go:

12	`func (s *BaseXMLParserListener) VisitTerminal(node antlr.TerminalNode) {}`

func BaseXMLParserListener.VisitErrorNode

Back

In /Users/kun/gobatis/gobatis/parser/xml/xmlparser_base_listener.go:

15	`func (s *BaseXMLParserListener) VisitErrorNode(node antlr.ErrorNode) {}`

func BaseXMLParserListener.EnterEveryRule

Back

In /Users/kun/gobatis/gobatis/parser/xml/xmlparser_base_listener.go:

18	`func (s *BaseXMLParserListener) EnterEveryRule(ctx antlr.ParserRuleContext) {}`

func BaseXMLParserListener.ExitEveryRule

Back

In /Users/kun/gobatis/gobatis/parser/xml/xmlparser_base_listener.go:

21	`func (s *BaseXMLParserListener) ExitEveryRule(ctx antlr.ParserRuleContext) {}`

func BaseXMLParserListener.EnterDocument

Back

In /Users/kun/gobatis/gobatis/parser/xml/xmlparser_base_listener.go:

24	`func (s BaseXMLParserListener) EnterDocument(ctx DocumentContext) {}`

func BaseXMLParserListener.ExitDocument

Back

In /Users/kun/gobatis/gobatis/parser/xml/xmlparser_base_listener.go:

27	`func (s BaseXMLParserListener) ExitDocument(ctx DocumentContext) {}`

func BaseXMLParserListener.EnterProlog

Back

In /Users/kun/gobatis/gobatis/parser/xml/xmlparser_base_listener.go:

30	`func (s BaseXMLParserListener) EnterProlog(ctx PrologContext) {}`

func BaseXMLParserListener.ExitProlog

Back

In /Users/kun/gobatis/gobatis/parser/xml/xmlparser_base_listener.go:

33	`func (s BaseXMLParserListener) ExitProlog(ctx PrologContext) {}`

func BaseXMLParserListener.EnterContent

Back

In /Users/kun/gobatis/gobatis/parser/xml/xmlparser_base_listener.go:

36	`func (s BaseXMLParserListener) EnterContent(ctx ContentContext) {}`

func BaseXMLParserListener.ExitContent

Back

In /Users/kun/gobatis/gobatis/parser/xml/xmlparser_base_listener.go:

39	`func (s BaseXMLParserListener) ExitContent(ctx ContentContext) {}`

func BaseXMLParserListener.EnterElement

Back

In /Users/kun/gobatis/gobatis/parser/xml/xmlparser_base_listener.go:

42	`func (s BaseXMLParserListener) EnterElement(ctx ElementContext) {}`

func BaseXMLParserListener.ExitElement

Back

In /Users/kun/gobatis/gobatis/parser/xml/xmlparser_base_listener.go:

45	`func (s BaseXMLParserListener) ExitElement(ctx ElementContext) {}`

func BaseXMLParserListener.EnterReference

Back

In /Users/kun/gobatis/gobatis/parser/xml/xmlparser_base_listener.go:

48	`func (s BaseXMLParserListener) EnterReference(ctx ReferenceContext) {}`

func BaseXMLParserListener.ExitReference

Back

In /Users/kun/gobatis/gobatis/parser/xml/xmlparser_base_listener.go:

51	`func (s BaseXMLParserListener) ExitReference(ctx ReferenceContext) {}`

func BaseXMLParserListener.EnterAttribute

Back

In /Users/kun/gobatis/gobatis/parser/xml/xmlparser_base_listener.go:

54	`func (s BaseXMLParserListener) EnterAttribute(ctx AttributeContext) {}`

func BaseXMLParserListener.ExitAttribute

Back

In /Users/kun/gobatis/gobatis/parser/xml/xmlparser_base_listener.go:

57	`func (s BaseXMLParserListener) ExitAttribute(ctx AttributeContext) {}`

func BaseXMLParserListener.EnterChardata

Back

In /Users/kun/gobatis/gobatis/parser/xml/xmlparser_base_listener.go:

60	`func (s BaseXMLParserListener) EnterChardata(ctx ChardataContext) {}`

func BaseXMLParserListener.ExitChardata

Back

In /Users/kun/gobatis/gobatis/parser/xml/xmlparser_base_listener.go:

63	`func (s BaseXMLParserListener) ExitChardata(ctx ChardataContext) {}`

func BaseXMLParserListener.EnterMisc

Back

In /Users/kun/gobatis/gobatis/parser/xml/xmlparser_base_listener.go:

66	`func (s BaseXMLParserListener) EnterMisc(ctx MiscContext) {}`

func BaseXMLParserListener.ExitMisc

Back

In /Users/kun/gobatis/gobatis/parser/xml/xmlparser_base_listener.go:

69	`func (s BaseXMLParserListener) ExitMisc(ctx MiscContext) {}`

Report Total

45.8%

389	`func (q query) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {`
390	`raw = &executor.Raw{`
391	`Query: true,`
392	`SQL: q.sql,`
393	`Params: q.params,`
394	`}`
395	`return`
396	`}`

341	`func (d DB) ParallelQuery(queryer ...ParallelQuery) DB {`
342	`c := d.clone()`
343	`if len(queryer) == 0 {`
344	`c.addError(fmt.Errorf("no querer"))`
345	`return c`
346	`}`
347	`if d.executor != nil {`
348	`c.addError(fmt.Errorf("db executor confilct"))`
349	`return c`
350	`}`
351
352	`var executors []executor.Executor`
353	`for _, v := range queryer {`
354	`item, err := v.executor(d.Dialector.Namer(), "db")`
355	`if err != nil {`
356	`c.addError(err)`
357	`return c`
358	`}`
359	`item.Conn = c.conn()`
360	`item.Raw.Ctx = c.context()`
361	`executors = append(executors, item)`
362	`}`
363
364	`lock := sync.Mutex{}`
365	`wg := sync.WaitGroup{}`
366	`pos := executor.CallFuncPos(0)`
367	`for _, v := range executors {`
368	`wg.Add(1)`
369	`go func(v executor.Executor) {`
370	`defer func() {`
371	`wg.Done()`
372	`}()`
373	`err := v.Execute(c.Logger, pos, d.trace, d.debug, nil, nil)`
374	`if err != nil {`
375	`lock.Lock()`
376	`c.addError(err)`
377	`lock.Unlock()`
378	`}`
379	`}(v)`
380	`}`
381	`wg.Wait()`
382
383	`return c`
384	`}`

350	`func (d del) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {`
351	`for _, v := range d.elems {`
352	`switch vv := v.(type) {`
353	`case *where:`
354	`if d.where != nil {`
355	`err = fmt.Errorf("batis.Where() should be invoked no more than once")`
356	`return`
357	`}`
358	`d.where = vv`
359	`default:`
360	`err = fmt.Errorf("method db.Delete() accept elements use of batis.Where()")`
361	`return`
362	`}`
363	`}`
364
365	`raw = &executor.Raw{}`
366
367	`var sqls []string`
368	`sqls = append(sqls, fmt.Sprintf("delete from %s", namer.TableName(strings.TrimSpace(d.table))))`
369
370	`if d.where != nil {`
371	`var r *executor.Raw`
372	`r, err = d.where.Raw(namer, tag)`
373	`if err != nil {`
374	`return`
375	`}`
376	`sqls = append(sqls, fmt.Sprintf("%s", r.SQL))`
377	`raw.Params = append(raw.Params, r.Params...)`
378	`}`
379	`raw.SQL = strings.Join(sqls, space)`
380
381	`return`
382	`}`

229	`func (d DB) Exec(sql string, params ...executor.Param) DB {`
230	`c := d.clone()`
231	`raw, err := c.raw(exec{sql: sql, params: params})`
232	`if err != nil {`
233	`c.addError(err)`
234	`return c`
235	`}`
236	`c.executor = executor.NewDefault(c.conn(), raw)`
237	`c.execute(nil)`
238	`return c`
239	`}`

386	`func (d DB) PagingQuery(query PagingQuery) DB {`
387	`c := d.clone()`
388	`queries, err := query.executors(d.Dialector.Namer(), "db")`
389	`if err != nil {`
390	`c.addError(err)`
391	`return c`
392	`}`
393	`return c.ParallelQuery(queries...)`
394	`}`

122	`func (d DB) Affect(v any) DB {`
123	`c := d.clone()`
124	`c.affect = v`
125	`return c`
126	`}`

134	`func (d DB) Debug() DB {`
135	`c := d.clone()`
136	`c.debug = true`
137	`return c`
138	`}`

422	`func (r returning) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {`
423	`raw = &executor.Raw{`
424	`SQL: fmt.Sprintf("returning %s", executor.TrimColumns(r.sql)),`
425	`}`
426	`return`
427	`}`

403	`func (e exec) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {`
404	`raw = &executor.Raw{`
405	`SQL: strings.TrimSpace(e.sql),`
406	`Params: e.params,`
407	`}`
408	`return`
409	`}`

74	`func (w where) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {`
75	`raw = &executor.Raw{`
76	`SQL: fmt.Sprintf("where %s", strings.TrimSpace(w.sql)),`
77	`Params: w.params,`
78	`}`
79	`return`
80	`}`

53	`func (o onConflict) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {`
54	`raw = &executor.Raw{`
55	`SQL: fmt.Sprintf("on conflict(%s) %s", executor.TrimColumns(o.fields), o.sql),`
56	`Params: o.params,`
57	`}`
58	`return`
59	`}`

87	`func (d DB) clone() DB {`
88	`return &DB{`
89	`Config: d.Config,`
90	`Error: d.Error,`
91	`tx: d.tx,`
92	`ctx: d.ctx,`
93	`trace: d.trace,`
94	`debug: d.debug,`
95	`traceId: d.traceId,`
96	`affect: d.affect,`
97	`executed: d.executed,`
98	`executor: nil,`
99	`}`
100	`}`

61	`func OnConflict(fields string, sql string, params ...executor.Param) Element {`
62	`return &onConflict{`
63	`fields: fields,`
64	`sql: sql,`
65	`params: params,`
66	`}`
67	`}`

429	`func Returning(fields string) Element {`
430	`return &returning{`
431	`sql: fields,`
432	`}`
433	`}`

82	`func Where(sql string, params ...executor.Param) Element {`
83	`return &where{`
84	`sql: sql,`
85	`params: params,`
86	`}`
87	`}`

20	`func (q ParallelQuery) executor(namer dialector.Namer, tag string) (*executor.ParallelQuery, error) {`
21	`if q.Scan == nil {`
22	`return nil, fmt.Errorf("expect 1 scan dest; got nil")`
23	`}`
24	`var params []executor.Param`
25	`for k, v := range q.Params {`
26	`params = append(params, executor.Param{`
27	`Name: k,`
28	`Value: v,`
29	`})`
30	`}`
31	`raw := &executor.Raw{`
32	`Ctx: nil,`
33	`Query: true,`
34	`SQL: q.SQL,`
35	`Params: nil,`
36	`}`
37	`for k, v := range q.Params {`
38	`raw.Params = append(raw.Params, Param(k, v))`
39	`}`
40	`return &executor.ParallelQuery{Raw: raw, Dest: q.Scan}, nil`
41	`}`

60	`func (p PagingQuery) executors(namer dialector.Namer, tag string) ([]ParallelQuery, error) {`
61
62	`if p.Limit <= 0 {`
63	`return nil, fmt.Errorf("invalid limit")`
64	`}`
65
66	`if l := len(p.Scan); l != 2 {`
67	`return nil, fmt.Errorf("expect 2 scan dest; got: %d", l)`
68	`}`
69
70	`var params []executor.Param`
71	`for k, v := range p.Params {`
72	`params = append(params, executor.Param{`
73	`Name: k,`
74	`Value: v,`
75	`})`
76	`}`
77	`w := ""`
78	`if p.Where != "" {`
79	`w = fmt.Sprintf(" where %s", p.Where)`
80	`}`
81	`o := ""`
82	`if p.Order != "" {`
83	`o = fmt.Sprintf(" order by %s", p.Order)`
84	`}`
85	`q := ParallelQuery{`
86	`SQL: fmt.Sprintf("select %s from %s%s%s limit %d offset %d", p.Select, p.From, w, o, p.Limit, p.Limit*p.Page),`
87	`Params: p.Params,`
88	`Scan: p.Scan[0],`
89	`}`
90
91	`c := ParallelQuery{`
92	`SQL: fmt.Sprintf("select count(%s) from %s%s", p.Count, p.From, w),`
93	`Params: p.Params,`
94	`Scan: p.Scan[1],`
95	`}`
96
97	`return []ParallelQuery{q, c}, nil`
98	`}`

176	`func(s executor.Scanner) error {`
177	`if d.executor.Query() {`
178	`e := s.Scan(dest)`
179	`if e != nil {`
180	`return e`
181	`}`
182	`}`
183	`d.rowsAffected = s.RowsAffected()`
184	`d.lastInsertId = s.LastInsertId()`
185	`return nil`
186	`}`

49	`func Open(d dialector.Dialector, options ...Option) (db *DB, err error) {`
50	`config := &Config{`
51	`CreateBatchSize: 10,`
52	`Plugins: nil,`
53	`NowFunc: func() time.Time {`
54	`return time.Now()`
55	`},`
56	`Dialector: d,`
57	`Logger: executor.DefaultLogger(),`
58	`db: nil,`
59	`}`
60	`config.db, err = d.DB()`
61	`if err != nil {`
62	`return`
63	`}`
64	`db = &DB{Config: config, Error: nil}`
65	`return`
66	`}`

408	`func (d *DB) FetchQuery(query FetchQuery) error {`
409
410	`c := d.clone()`
411
412	`raw := &executor.Raw{`
413	`Ctx: d.context(),`
414	`Query: true,`
415	`SQL: query.SQL,`
416	`Params: nil,`
417	`}`
418
419	`if query.Scan == nil {`
420	`d.addError(fmt.Errorf("FetchQeruy.Scan is nil"))`
421	`return c.Error`
422	`}`
423
424	`for k, v := range query.Params {`
425	`raw.Params = append(raw.Params, executor.Param{`
426	`Name: k,`
427	`Value: v,`
428	`})`
429	`}`
430	`if c.traceId == "" {`
431	`c.traceId = fmt.Sprintf("TID%d", time.Now().UnixNano())`
432	`}`
433	`c.setExecutor(executor.NewFetchQuery(c.context(), c.conn(), raw, query.Batch))`
434	`return c.executor.Execute(c.Logger, "", c.trace, c.debug, nil, func(s executor.Scanner) error {`
435	`return query.Scan(s)`
436	`})`
437	`}`

271	`func (d DB) Insert(table string, data any, elems ...Element) DB {`
272	`c := d.clone()`
273	`i := &insert{table: table, data: data, elems: elems}`
274	`raw, err := c.raw(i)`
275	`if err != nil {`
276	`c.addError(err)`
277	`return c`
278	`}`
279	`c.executor = executor.NewDefault(c.conn(), raw)`
280	`if !raw.Query {`
281	`c.execute(nil)`
282	`}`
283	`return c`
284	`}`

255	`func (d DB) Update(table string, data map[string]any, where Element, elems ...Element) DB {`
256	`c := d.clone()`
257	`u := update{table: table, data: data, elems: append([]Element{where}, elems...)}`
258	`raw, err := c.raw(u)`
259	`if err != nil {`
260	`c.addError(err)`
261	`return c`
262	`}`
263	`c.executor = executor.NewDefault(c.conn(), raw)`
264	`if !raw.Query {`
265	`c.execute(nil)`
266	`}`
267	`return c`
268	`}`

201	`func (d DB) raw(element Element) (raw executor.Raw, err error) {`
202	`raw, err = element.Raw(d.Dialector.Namer(), "db")`
203	`if err != nil {`
204	`return`
205	`}`
206	`raw.Ctx = d.context()`
207	`return`
208	`}`

242	`func (d DB) Delete(table string, where Element) DB {`
243	`c := d.clone()`
244	`raw, err := c.raw(del{table: table, elems: []Element{where}})`
245	`if err != nil {`
246	`c.addError(err)`
247	`return c`
248	`}`
249	`c.executor = executor.NewDefault(c.conn(), raw)`
250	`c.execute(nil)`
251	`return c`
252	`}`

211	`func (d DB) Query(sql string, params ...executor.Param) DB {`
212	`c := d.clone()`
213	`raw, err := c.raw(query{sql: sql, params: params})`
214	`if err != nil {`
215	`c.addError(err)`
216	`return c`
217	`}`
218	`c.executor = executor.NewDefault(c.conn(), raw)`
219	`return c`
220	`}`

294	`func (d DB) InsertBatch(table string, batch int, data any, elems ...Element) DB {`
295	`c := d.clone()`
296
297	`if batch <= 0 {`
298	`c.addError(fmt.Errorf("expect batch > 0, got %d", batch))`
299	`return c`
300	`}`
301
302	`if data == nil {`
303	`c.addError(fmt.Errorf("data is nil"))`
304	`return c`
305	`}`
306
307	`chunks, err := executor.SplitStructSlice(data, batch)`
308	`if err != nil {`
309	`c.addError(err)`
310	`return c`
311	`}`
312
313	`var raws []*executor.Raw`
314	`var q bool`
315	`for _, v := range chunks {`
316	`i := &insertBatch{`
317	`table: table,`
318	`batch: batch,`
319	`data: v,`
320	`elems: elems,`
321	`}`
322	`var raw *executor.Raw`
323	`raw, err = c.raw(i)`
324	`if err != nil {`
325	`c.addError(err)`
326	`return c`
327	`}`
328	`if raw.Query {`
329	`q = true`
330	`}`
331	`raws = append(raws, raw)`
332	`}`
333
334	`c.setExecutor(executor.NewInsertBatch(c.context(), c.conn(), raws))`
335	`if !q {`
336	`c.execute(nil)`
337	`}`
338	`return c`
339	`}`

97	`func (u update) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {`
98	`for _, v := range u.elems {`
99	`switch vv := v.(type) {`
100	`case *where:`
101	`if u.where != nil {`
102	`err = fmt.Errorf("batis.Where() should be invoked no more than once")`
103	`return`
104	`}`
105	`u.where = vv`
106	`case *returning:`
107	`if u.returning != nil {`
108	`err = fmt.Errorf("batis.Returning() should be invoked no more than once")`
109	`return`
110	`}`
111	`u.returning = vv`
112	`default:`
113	`err = fmt.Errorf("method db.Update() accept elements use of batis.Where()")`
114	`return`
115	`}`
116	`}`
117
118	`raw = &executor.Raw{`
119	`Query: u.returning != nil,`
120	`}`
121
122	`var sqls []string`
123	`sqls = append(sqls, fmt.Sprintf("update %s set", namer.TableName(u.table)))`
124
125	`var sets []string`
126	`for k := range u.data {`
127	`sets = append(sets, fmt.Sprintf("%s=#{%s}", namer.ColumnName(k), k))`
128	`}`
129	`sqls = append(sqls, strings.Join(sets, ","))`
130	`for k, v := range u.data {`
131	`raw.Params = append(raw.Params, executor.Param{`
132	`Name: k,`
133	`Value: v,`
134	`})`
135	`}`
136	`if u.where != nil {`
137	`var r *executor.Raw`
138	`r, err = u.where.Raw(namer, tag)`
139	`if err != nil {`
140	`return`
141	`}`
142	`sqls = append(sqls, fmt.Sprintf("%s", r.SQL))`
143	`raw.Params = append(raw.Params, r.Params...)`
144	`}`
145	`raw.SQL = strings.Join(sqls, space)`
146
147	`return`
148	`}`

158	`func (i insert) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {`
159
160	`defer func() {`
161	`if err != nil {`
162	`err = fmt.Errorf("build insert sql error: %w", err)`
163	`}`
164	`}()`
165
166	`for _, v := range i.elems {`
167	`switch vv := v.(type) {`
168	`case *onConflict:`
169	`if i.onConflict != nil {`
170	`err = fmt.Errorf("batis.OnConflict() should be invoked no more than once")`
171	`return`
172	`}`
173	`i.onConflict = vv`
174	`case *returning:`
175	`if i.returning != nil {`
176	`err = fmt.Errorf("batis.Returning() should be invoked no more than once")`
177	`return`
178	`}`
179	`i.returning = vv`
180	`default:`
181	`err = fmt.Errorf("method db.Insert() accept elements use of batis.OnConflict() or batis.Returning()")`
182	`return`
183	`}`
184	`}`
185	`raw = &executor.Raw{`
186	`Query: i.returning != nil,`
187	`}`
188	`var rows []executor.Row`
189	`switch vv := i.data.(type) {`
190	`case Rows:`
191	`rows, err = vv.Reflect(namer, tag)`
192	`if err != nil {`
193	`return`
194	`}`
195	`default:`
196	`rows, err = executor.ReflectRows(i.data, namer, tag)`
197	`if err != nil {`
198	`return`
199	`}`
200	`}`
201
202	`if l := len(rows); l != 1 {`
203	`err = fmt.Errorf("expect 1 row, got: %d", l)`
204	`return`
205	`}`
206
207	`var sqls []string`
208
209	`sqls = append(sqls, fmt.Sprintf("insert into %s(%s) values(%s)",`
210	`namer.TableName(i.table),`
211	`strings.Join(executor.RowColumns(rows[0], namer), ","),`
212	`strings.Join(executor.RowVars(rows[0]), ","),`
213	`))`
214	`raw.Params = append(raw.Params, executor.RowParams(rows[0])...)`
215
216	`if i.onConflict != nil {`
217	`var r *executor.Raw`
218	`r, err = i.onConflict.Raw(namer, tag)`
219	`if err != nil {`
220	`return`
221	`}`
222	`sqls = append(sqls, r.SQL)`
223	`raw.Params = append(raw.Params, r.Params...)`
224	`}`
225
226	`if i.returning != nil {`
227	`var r *executor.Raw`
228	`r, err = i.returning.Raw(namer, tag)`
229	`if err != nil {`
230	`return`
231	`}`
232	`sqls = append(sqls, r.SQL)`
233	`raw.Params = append(raw.Params, r.Params...)`
234	`}`
235
236	`raw.SQL = strings.Join(sqls, space)`
237
238	`return`
239	`}`

189	`func (d *DB) conn() executor.Conn {`
190	`if d.tx != nil {`
191	`return d.tx`
192	`} else {`
193	`conn, err := d.db.Conn(d.context())`
194	`if err != nil {`
195	`d.addError(err)`
196	`}`
197	`return executor.NewDB(conn, d.traceId)`
198	`}`
199	`}`

156	`func (d *DB) context() context.Context {`
157	`if d.ctx == nil {`
158	`return context.Background()`
159	`}`
160	`return d.ctx`
161	`}`

250	`func (i insertBatch) Raw(namer dialector.Namer, tag string) (raw *executor.Raw, err error) {`
251
252	`defer func() {`
253	`if err != nil {`
254	`err = fmt.Errorf("build insert batch sql error: %w", err)`
255	`}`
256	`}()`
257
258	`for _, v := range i.elems {`
259	`switch vv := v.(type) {`
260	`case *onConflict:`
261	`if i.onConflict != nil {`
262	`err = fmt.Errorf("batis.OnConflict() should be invoked no more than once")`
263	`return`
264	`}`
265	`i.onConflict = vv`
266	`case *returning:`
267	`if i.returning != nil {`
268	`err = fmt.Errorf("batis.Returning() should be invoked no more than once")`
269	`return`
270	`}`
271	`i.returning = vv`
272	`default:`
273	`err = fmt.Errorf("method db.Insert() accept elements use of batis.OnConflict() or batis.Returning()")`
274	`return`
275	`}`
276	`}`
277
278	`raw = &executor.Raw{`
279	`Query: i.returning != nil,`
280	`}`
281
282	`var rows []executor.Row`
283	`switch vv := i.data.(type) {`
284	`case Rows:`
285	`rows, err = vv.Reflect(namer, tag)`
286	`if err != nil {`
287	`return`
288	`}`
289	`default:`
290	`rows, err = executor.ReflectRows(i.data, namer, tag)`
291	`if err != nil {`
292	`return`
293	`}`
294	`}`
295
296	`if l := len(rows); l == 0 {`
297	`err = fmt.Errorf("expect rows legnth > 0, got: %d", l)`
298	`return`
299	`}`
300
301	`var sqls []string`
302
303	`sqls = append(sqls, fmt.Sprintf("insert into %s(%s) values%s",`
304	`namer.TableName(i.table),`
305	`strings.Join(executor.RowColumns(rows[0], namer), ","),`
306	`strings.Join(executor.RowsVars(rows), ","),`
307	`))`
308	`raw.Params = append(raw.Params, executor.RowsParams(rows)...)`
309
310	`if i.onConflict != nil {`
311	`var r *executor.Raw`
312	`r, err = i.onConflict.Raw(namer, tag)`
313	`if err != nil {`
314	`return`
315	`}`
316	`sqls = append(sqls, r.SQL)`
317	`r.Params = append(r.Params, r.Params...)`
318	`}`
319
320	`if i.returning != nil {`
321	`var r *executor.Raw`
322	`r, err = i.returning.Raw(namer, tag)`
323	`if err != nil {`
324	`return`
325	`}`
326	`sqls = append(sqls, r.SQL)`
327	`r.Params = append(r.Params, r.Params...)`
328	`}`
329
330	`raw.SQL = strings.Join(sqls, space)`
331
332	`return`
333	`}`

369	`func(v executor.Executor) {`
370	`defer func() {`
371	`wg.Done()`
372	`}()`
373	`err := v.Execute(c.Logger, pos, d.trace, d.debug, nil, nil)`
374	`if err != nil {`
375	`lock.Lock()`
376	`c.addError(err)`
377	`lock.Unlock()`
378	`}`
379	`}`

286	`func (d *DB) setExecutor(e executor.Executor) {`
287	`if d.executor != nil {`
288	`d.addError(fmt.Errorf("executor duplicated"))`
289	`return`
290	`}`
291	`d.executor = e`
292	`}`

163	`func (d *DB) execute(dest any) {`
164	`if d.Error != nil {`
165	`return`
166	`}`
167	`if d.executor == nil {`
168	`d.addError(fmt.Errorf("no executor"))`
169	`return`
170	`}`
171	`if d.executed.Swap(true) {`
172	`d.addError(fmt.Errorf("repeat execution"))`
173	`return`
174	`}`
175
176	`d.addError(d.executor.Execute(d.Logger, "", d.trace, d.debug, d.affect, func(s executor.Scanner) error {`
177	`if d.executor.Query() {`
178	`e := s.Scan(dest)`
179	`if e != nil {`
180	`return e`
181	`}`
182	`}`
183	`d.rowsAffected = s.RowsAffected()`
184	`d.lastInsertId = s.LastInsertId()`
185	`return nil`
186	`}))`
187	`}`

439	`func (d DB) Begin() DB {`
440	`c := d.clone()`
441	`if c.tx != nil {`
442	`c.addError(fmt.Errorf("there is already a transaction"))`
443	`return c`
444	`}`
445
446	`defer func() {`
447	`d.Logger.Trace("", c.traceId, true, d.Error, &executor.SQLTrace{`
448	`Trace: d.trace,`
449	`Debug: d.debug,`
450	`BeginAt: time.Now(),`
451	`RawSQL: "begin",`
452	`PlainSQL: "begin",`
453	`RowsAffected: 0,`
454	`})`
455	`}()`
456
457	`tx, err := c.db.Begin()`
458	`if err != nil {`
459	`c.addError(err)`
460	`return c`
461	`}`
462
463	`if c.traceId == "" {`
464	`c.traceId = fmt.Sprintf("%p", d)`
465	`}`
466
467	`c.tx = executor.NewTx(tx, c.traceId)`
468
469	`return c`
470	`}`