79 lines
1.6 KiB
Go
79 lines
1.6 KiB
Go
package format
|
|
|
|
// Parse creates a new parser with the recommended
|
|
// parameters.
|
|
func Parse(tokens []LexToken) Formatter {
|
|
p := &parser{
|
|
tokens: tokens,
|
|
pos: -1,
|
|
}
|
|
p.initState = initialParserState
|
|
return p.run()
|
|
}
|
|
|
|
// run starts the statemachine
|
|
func (p *parser) run() Formatter {
|
|
var f Formatter
|
|
for state := p.initState; state != nil; {
|
|
state = state(p, &f)
|
|
}
|
|
return f
|
|
}
|
|
|
|
// parserState represents the state of the scanner
|
|
// as a function that returns the next state.
|
|
type parserState func(*parser, *Formatter) parserState
|
|
|
|
// nest returns what the next token AND
|
|
// advances p.pos.
|
|
func (p *parser) next() *LexToken {
|
|
if p.pos >= len(p.tokens)-1 {
|
|
return nil
|
|
}
|
|
p.pos += 1
|
|
return &p.tokens[p.pos]
|
|
}
|
|
|
|
// the parser type
|
|
type parser struct {
|
|
tokens []LexToken
|
|
pos int
|
|
serial int
|
|
|
|
initState parserState
|
|
}
|
|
|
|
// the starting state for parsing
|
|
func initialParserState(p *parser, f *Formatter) parserState {
|
|
var t *LexToken
|
|
for t = p.next(); t[0] != T_EOF; t = p.next() {
|
|
var item ItemFormatter
|
|
switch t[0] {
|
|
case T_YEAR_MARK:
|
|
f.typ = DATEFORMAT
|
|
item = new(YearFormatter)
|
|
case T_MONTH_MARK:
|
|
f.typ = DATEFORMAT
|
|
item = new(MonthFormatter)
|
|
case T_DAY_MARK:
|
|
f.typ = DATEFORMAT
|
|
item = new(DayFormatter)
|
|
case T_RAW_MARK:
|
|
item = new(basicFormatter)
|
|
case T_STRING_MARK:
|
|
item = new(basicFormatter)
|
|
case T_COMMA_MARK, T_DECIMAL_MARK:
|
|
f.typ = DECIMALFORMAT
|
|
item = new(basicFormatter)
|
|
}
|
|
item.setOriginal(t[1])
|
|
f.Items = append(f.Items, item)
|
|
}
|
|
if len(t[1]) > 0 {
|
|
r := new(basicFormatter)
|
|
r.origin = t[1]
|
|
f.Items = append(f.Items, r)
|
|
}
|
|
return nil
|
|
}
|