parse ... differently
parent
d369388fa8
commit
c9872dbe53
@ -0,0 +1,128 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
)
|
||||
|
||||
type nodeType int
|
||||
|
||||
const (
|
||||
n_error nodeType = iota
|
||||
n_root
|
||||
n_comment
|
||||
n_assignment
|
||||
)
|
||||
|
||||
type node interface {
|
||||
Type() nodeType
|
||||
parse(*parser) error
|
||||
}
|
||||
|
||||
type rootNode struct {
|
||||
children []node
|
||||
}
|
||||
|
||||
func newRootNode() node {
|
||||
return &rootNode{children: make([]node, 0, 8)}
|
||||
}
|
||||
|
||||
func (n *rootNode) Type() nodeType {
|
||||
return n_root
|
||||
}
|
||||
|
||||
func (n *rootNode) parse(p *parser) error {
|
||||
for {
|
||||
t := p.next()
|
||||
switch t.t {
|
||||
case t_error:
|
||||
return fmt.Errorf("parse error: saw lex error while parsing root node: %v", t.s)
|
||||
case t_eof:
|
||||
return nil
|
||||
case t_comment:
|
||||
shit := commentNode(t.s)
|
||||
n.addChild(&shit)
|
||||
case t_name:
|
||||
nn := &assignmentNode{name: t.s}
|
||||
if err := nn.parse(p); err != nil {
|
||||
return err
|
||||
}
|
||||
n.addChild(nn)
|
||||
default:
|
||||
return fmt.Errorf("parse error: unexpected token type %v while parsing root node", t.t)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (n *rootNode) addChild(child node) {
|
||||
if n.children == nil {
|
||||
n.children = make([]node, 0, 8)
|
||||
}
|
||||
n.children = append(n.children, child)
|
||||
}
|
||||
|
||||
func (n *rootNode) String() string {
|
||||
var buf bytes.Buffer
|
||||
buf.WriteString("{")
|
||||
for _, child := range n.children {
|
||||
fmt.Fprintf(&buf, "%s, ", child)
|
||||
}
|
||||
if len(n.children) > 0 {
|
||||
buf.Truncate(buf.Len() - 2)
|
||||
}
|
||||
buf.WriteString("}")
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
type commentNode string
|
||||
|
||||
func (n commentNode) Type() nodeType {
|
||||
return n_comment
|
||||
}
|
||||
|
||||
func (n commentNode) parse(p *parser) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (n commentNode) String() string {
|
||||
return fmt.Sprintf("{comment: %s}", string(n))
|
||||
}
|
||||
|
||||
type assignmentNode struct {
|
||||
name string
|
||||
value interface{}
|
||||
}
|
||||
|
||||
func (n assignmentNode) Type() nodeType {
|
||||
return n_assignment
|
||||
}
|
||||
|
||||
func (n *assignmentNode) parse(p *parser) error {
|
||||
t := p.next()
|
||||
switch t.t {
|
||||
case t_error:
|
||||
return fmt.Errorf("parse error: saw lex error while parsing assignment node: %v", t.s)
|
||||
case t_eof:
|
||||
return fmt.Errorf("parse error: unexpected eof in assignment node")
|
||||
case t_equals:
|
||||
default:
|
||||
return fmt.Errorf("parse error: unexpected %v token after name, expected =", t.t)
|
||||
}
|
||||
|
||||
t = p.next()
|
||||
switch t.t {
|
||||
case t_error:
|
||||
return fmt.Errorf("parse error: saw lex error while parsing assignment node: %v", t.s)
|
||||
case t_eof:
|
||||
return fmt.Errorf("parse error: unexpected eof in assignment node")
|
||||
case t_string:
|
||||
n.value = t.s
|
||||
return nil
|
||||
default:
|
||||
return fmt.Errorf("parse error: unexpected %v token after =, expected some kind of value", t.t)
|
||||
}
|
||||
}
|
||||
|
||||
func (n *assignmentNode) String() string {
|
||||
return fmt.Sprintf("{assign: name=%s, val=%s}", n.name, n.value)
|
||||
}
|
||||
@ -1,134 +1,42 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
)
|
||||
|
||||
const (
|
||||
e_no_error parseErrorType = iota
|
||||
e_lex_error
|
||||
e_unexpected_eof
|
||||
e_unexpected_token
|
||||
)
|
||||
|
||||
type parseErrorType int
|
||||
|
||||
type parseError struct {
|
||||
t parseErrorType
|
||||
m string
|
||||
}
|
||||
|
||||
func (p parseError) Error() string {
|
||||
return fmt.Sprintf("parse error: %s", p.m)
|
||||
}
|
||||
|
||||
func parseErrorf(t parseErrorType, tpl string, args ...interface{}) error {
|
||||
return parseError{t: t, m: fmt.Sprintf(tpl, args...)}
|
||||
}
|
||||
const ()
|
||||
|
||||
type parseFn func(*parser) (parseFn, error)
|
||||
|
||||
func parseRoot(p *parser) (parseFn, error) {
|
||||
if err := p.next(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
switch p.cur.t {
|
||||
case t_name:
|
||||
return parseAfterName(p.cur.s), nil
|
||||
default:
|
||||
return nil, parseErrorf(e_unexpected_token, "unexpected %s token in parseRoot", p.cur.t)
|
||||
}
|
||||
}
|
||||
|
||||
func parseAfterName(name string) parseFn {
|
||||
return func(p *parser) (parseFn, error) {
|
||||
switch err := p.next(); err {
|
||||
case io.EOF:
|
||||
return nil, parseErrorf(e_unexpected_eof, "unexpected eof after name %s", name)
|
||||
case nil:
|
||||
default:
|
||||
return nil, err
|
||||
}
|
||||
|
||||
switch p.cur.t {
|
||||
case t_equals:
|
||||
return parseAssign(name), nil
|
||||
default:
|
||||
return nil, parseErrorf(e_unexpected_token, "unexpected %s token in parseAfterName", p.cur.t)
|
||||
}
|
||||
func parse(r io.Reader) (node, error) {
|
||||
p := &parser{
|
||||
root: newRootNode(),
|
||||
input: lex(r),
|
||||
backup: make([]token, 0, 8),
|
||||
}
|
||||
}
|
||||
|
||||
func parseAssign(name string) parseFn {
|
||||
return func(p *parser) (parseFn, error) {
|
||||
switch err := p.next(); err {
|
||||
case io.EOF:
|
||||
return nil, parseErrorf(e_unexpected_eof, "unexpected eof when trying to parse value for name %s", name)
|
||||
case nil:
|
||||
default:
|
||||
return nil, err
|
||||
}
|
||||
|
||||
switch p.cur.t {
|
||||
case t_string:
|
||||
p.out.setUnique(name, p.cur.s)
|
||||
return parseRoot, nil
|
||||
default:
|
||||
return nil, parseErrorf(e_unexpected_token, "unexpected %s token in parseAssign", p.cur.t)
|
||||
}
|
||||
if err := p.parse(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return p.root, nil
|
||||
}
|
||||
|
||||
type parser struct {
|
||||
in chan token
|
||||
cur token
|
||||
out *Config
|
||||
root node
|
||||
input chan token
|
||||
backup []token
|
||||
}
|
||||
|
||||
func (p *parser) next() error {
|
||||
t, ok := <-p.in
|
||||
if !ok {
|
||||
return io.EOF
|
||||
func (p *parser) parse() error {
|
||||
if p.root == nil {
|
||||
p.root = newRootNode()
|
||||
}
|
||||
if t.t == t_error {
|
||||
return parseError{e_lex_error, t.s}
|
||||
}
|
||||
p.cur = t
|
||||
return nil
|
||||
return p.root.parse(p)
|
||||
}
|
||||
|
||||
func (p *parser) run() error {
|
||||
fn := parseRoot
|
||||
var err error
|
||||
for {
|
||||
fn, err = fn(p)
|
||||
switch err {
|
||||
case io.EOF:
|
||||
return nil
|
||||
case nil:
|
||||
default:
|
||||
return err
|
||||
}
|
||||
// returns the next token and advances the input stream
|
||||
func (p *parser) next() token {
|
||||
if len(p.backup) > 0 {
|
||||
t := p.backup[len(p.backup)-1]
|
||||
p.backup = p.backup[:len(p.backup)-1]
|
||||
return t
|
||||
}
|
||||
}
|
||||
|
||||
type assignment struct {
|
||||
name string
|
||||
value interface{}
|
||||
}
|
||||
|
||||
func parse(in chan token) (*Config, error) {
|
||||
p := &parser{
|
||||
in: in,
|
||||
out: new(Config),
|
||||
}
|
||||
if err := p.run(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return p.out, nil
|
||||
}
|
||||
|
||||
func parseString(in string) (*Config, error) {
|
||||
return parse(lexString(in))
|
||||
return <-p.input
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue