You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
204 lines
3.0 KiB
204 lines
3.0 KiB
package ast |
|
|
|
import ( |
|
"strconv" |
|
"strings" |
|
"time" |
|
) |
|
|
|
type Position struct { |
|
Begin int |
|
End int |
|
} |
|
|
|
type Value interface { |
|
Pos() int |
|
End() int |
|
Source() string |
|
} |
|
|
|
type String struct { |
|
Position Position |
|
Value string |
|
Data []rune |
|
} |
|
|
|
func (s *String) Pos() int { |
|
return s.Position.Begin |
|
} |
|
|
|
func (s *String) End() int { |
|
return s.Position.End |
|
} |
|
|
|
func (s *String) Source() string { |
|
return string(s.Data) |
|
} |
|
|
|
type Integer struct { |
|
Position Position |
|
Value string |
|
Data []rune |
|
} |
|
|
|
func (i *Integer) Pos() int { |
|
return i.Position.Begin |
|
} |
|
|
|
func (i *Integer) End() int { |
|
return i.Position.End |
|
} |
|
|
|
func (i *Integer) Source() string { |
|
return string(i.Data) |
|
} |
|
|
|
func (i *Integer) Int() (int64, error) { |
|
return strconv.ParseInt(i.Value, 10, 64) |
|
} |
|
|
|
type Float struct { |
|
Position Position |
|
Value string |
|
Data []rune |
|
} |
|
|
|
func (f *Float) Pos() int { |
|
return f.Position.Begin |
|
} |
|
|
|
func (f *Float) End() int { |
|
return f.Position.End |
|
} |
|
|
|
func (f *Float) Source() string { |
|
return string(f.Data) |
|
} |
|
|
|
func (f *Float) Float() (float64, error) { |
|
return strconv.ParseFloat(f.Value, 64) |
|
} |
|
|
|
type Boolean struct { |
|
Position Position |
|
Value string |
|
Data []rune |
|
} |
|
|
|
func (b *Boolean) Pos() int { |
|
return b.Position.Begin |
|
} |
|
|
|
func (b *Boolean) End() int { |
|
return b.Position.End |
|
} |
|
|
|
func (b *Boolean) Source() string { |
|
return string(b.Data) |
|
} |
|
|
|
func (b *Boolean) Boolean() (bool, error) { |
|
return strconv.ParseBool(b.Value) |
|
} |
|
|
|
type Datetime struct { |
|
Position Position |
|
Value string |
|
Data []rune |
|
} |
|
|
|
func (d *Datetime) Pos() int { |
|
return d.Position.Begin |
|
} |
|
|
|
func (d *Datetime) End() int { |
|
return d.Position.End |
|
} |
|
|
|
func (d *Datetime) Source() string { |
|
return string(d.Data) |
|
} |
|
|
|
var timeFormats = [...]string{ |
|
"2006-01-02T15:04:05.999999999Z07:00", |
|
"2006-01-02T15:04:05.999999999", |
|
} |
|
|
|
func (d *Datetime) Time() (time.Time, error) { |
|
switch { |
|
case !strings.Contains(d.Value, ":"): |
|
return time.Parse("2006-01-02", d.Value) |
|
case !strings.Contains(d.Value, "-"): |
|
return time.Parse("15:04:05.999999999", d.Value) |
|
default: |
|
var t time.Time |
|
var err error |
|
for _, format := range timeFormats { |
|
if t, err = time.Parse(format, d.Value); err == nil { |
|
return t, nil |
|
} |
|
} |
|
return t, err |
|
} |
|
} |
|
|
|
type Array struct { |
|
Position Position |
|
Value []Value |
|
Data []rune |
|
} |
|
|
|
func (a *Array) Pos() int { |
|
return a.Position.Begin |
|
} |
|
|
|
func (a *Array) End() int { |
|
return a.Position.End |
|
} |
|
|
|
func (a *Array) Source() string { |
|
return string(a.Data) |
|
} |
|
|
|
type TableType uint8 |
|
|
|
const ( |
|
TableTypeNormal TableType = iota |
|
TableTypeArray |
|
) |
|
|
|
var tableTypes = [...]string{ |
|
"normal", |
|
"array", |
|
} |
|
|
|
func (t TableType) String() string { |
|
return tableTypes[t] |
|
} |
|
|
|
type Table struct { |
|
Position Position |
|
Line int |
|
Name string |
|
Fields map[string]interface{} |
|
Type TableType |
|
Data []rune |
|
} |
|
|
|
func (t *Table) Pos() int { |
|
return t.Position.Begin |
|
} |
|
|
|
func (t *Table) End() int { |
|
return t.Position.End |
|
} |
|
|
|
func (t *Table) Source() string { |
|
return string(t.Data) |
|
} |
|
|
|
type KeyValue struct { |
|
Key string |
|
Value Value |
|
Line int |
|
}
|
|
|