205 lines
3.0 KiB
Go
205 lines
3.0 KiB
Go
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
|
|
}
|