drop manual boot

boot.go

@@ -1,199 +1,13 @@
 package treerack
 
-import (
+import "os"
-	"errors"
-	"os"
-	"strconv"
-	"strings"
-)
-
-var errInvalidDefinition = errors.New("invalid syntax definition")
-
-func stringToCommitType(s string) CommitType {
-	switch s {
-	case "alias":
-		return Alias
-
-	// not used during boot:
-	// case "ws":
-	// 	return Whitespace
-	// case "nows":
-	// 	return NoWhitespace
-	// case "failpass":
-	// 	return FailPass
-
-	case "root":
-		return Root
-	default:
-		return None
-	}
-}
-
-func defineBootAnything(s *Syntax, d []string) error {
-	ct := stringToCommitType(d[2])
-	return s.anyChar(d[1], ct)
-}
-
-func defineBootClass(s *Syntax, d []string) error {
-	name := d[1]
-	ct := stringToCommitType(d[2])
-
-	/*
-		never fails:
-		not, chars, ranges, err := parseClass([]rune(d[3]))
-		if err != nil {
-			return err
-		}
-	*/
-	not, chars, ranges, _ := parseClass([]rune(d[3]))
-
-	return s.class(name, ct, not, chars, ranges)
-}
-
-func defineBootCharSequence(s *Syntax, d []string) error {
-	name := d[1]
-	ct := stringToCommitType(d[2])
-
-	/*
-		never fails:
-		chars, err := unescapeCharSequence(d[3])
-		if err != nil {
-			return err
-		}
-	*/
-	chars, _ := unescapeCharSequence(d[3])
-
-	return s.charSequence(name, ct, chars)
-}
-
-func splitQuantifiedSymbol(s string) (string, int, int) {
-	ssplit := strings.Split(s, ":")
-	if len(ssplit) != 3 {
-		return s, 0, 0
-	}
-
-	name := ssplit[0]
-
-	/*
-		never fails:
-		min, err := strconv.Atoi(ssplit[1])
-		if err != nil {
-			panic(err)
-		}
-
-		max, err := strconv.Atoi(ssplit[2])
-		if err != nil {
-			panic(err)
-		}
-	*/
-	min, _ := strconv.Atoi(ssplit[1])
-	max, _ := strconv.Atoi(ssplit[2])
-
-	return name, min, max
-}
-
-func namesToSequenceItemsQuantify(n []string) []SequenceItem {
-	si := make([]SequenceItem, len(n))
-	for i, ni := range n {
-		name, min, max := splitQuantifiedSymbol(ni)
-		si[i] = SequenceItem{Name: name, Min: min, Max: max}
-	}
-
-	return si
-}
-
-func defineBootSequence(s *Syntax, defs []string) error {
-	name := defs[1]
-	ct := stringToCommitType(defs[2])
-	items := namesToSequenceItemsQuantify(defs[3:])
-	return s.sequence(name, ct, items...)
-}
-
-func defineBootChoice(s *Syntax, defs []string) error {
-	name := defs[1]
-	ct := stringToCommitType(defs[2])
-	items := defs[3:]
-	return s.choice(name, ct, items...)
-}
-
-func defineBoot(s *Syntax, defs []string) error {
-	switch defs[0] {
-	case "anything":
-		return defineBootAnything(s, defs)
-	case "class":
-		return defineBootClass(s, defs)
-	case "chars":
-		return defineBootCharSequence(s, defs)
-	case "sequence":
-		return defineBootSequence(s, defs)
-	/*
-		never fails:
-		case "choice":
-			return defineBootChoice(s, defs)
-		default:
-			return errInvalidDefinition
-	*/
-	default:
-		return defineBootChoice(s, defs)
-	}
-}
-
-func defineAllBoot(s *Syntax, defs [][]string) error {
-	for _, d := range defs {
-		/*
-			never fails:
-			if err := defineBoot(s, d); err != nil {
-				return err
-			}
-		*/
-		defineBoot(s, d)
-	}
-
-	return nil
-}
-
-func createBoot() (*Syntax, error) {
-	s := &Syntax{}
-	/*
-		never fails:
-		if err := defineAllBoot(s, bootSyntaxDefs); err != nil {
-			return nil, err
-		}
-	*/
-	defineAllBoot(s, bootSyntaxDefs)
-
-	return s, s.Init()
-}
 
 func bootSyntax() (*Syntax, error) {
-	/*
-		never fails:
-
-		b, err := createBoot()
-		if err != nil {
-			return nil, err
-		}
-
-		f, err := os.Open("syntax.treerack")
-		if err != nil {
-			return nil, err
-		}
-
-		defer f.Close()
-
-		doc, err := b.Parse(f)
-		if err != nil {
-			return nil, err
-		}
-	*/
-	// b, _ := createBoot()
 	f, _ := os.Open("syntax.treerack")
 	defer f.Close()
-	// doc, _ := b.Parse(f)
+
-	doc, err := parsegen(f)
+	// never fails:
-	if err != nil {
+	doc, _ := parsegen(f)
-		panic(err)
-	}
 
 	s := &Syntax{}
 	return s, define(s, doc)

boot_test.go

@@ -46,7 +46,7 @@ func testParseFromTree(t *testing.T, n *Node, f io.ReadSeeker) *Node {
 
 func TestBoot(t *testing.T) {
 	t.Skip()
-	b, err := createBoot()
+	b, err := bootSyntax()
 	if err != nil {
 		t.Error(err)
 		return