yosssi/gcss/parse.go

package gcss

import "strings"

// Special characters
const (
        cr               = "\r"
        lf               = "\n"
        crlf             = "\r\n"
        space            = " "
        colon            = ":"
        comma            = ","
        openBrace        = "{"
        closeBrace       = "}"
        semicolon        = ";"
        ampersand        = "&"
        atMark           = "@"
        dollarMark       = "$"
        openParenthesis  = "("
        closeParenthesis = ")"
        slash            = "/"
        doubleSlash      = slash + slash
)

// parse parses the string, generates the elements
// and returns the two channels: the first one returns
// the generated elements and the last one returns
// an error when it occurs.
func parse(lines []string) (<-chan element, <-chan error) {
        elemc := make(chan element, len(lines))
        errc := make(chan error)

        go func() {
                i := 0
                l := len(lines)

                for i < l {
                        // Fetch a line.
                        ln := newLine(i+1, lines[i])
                        i++

                        // Ignore the empty line.
                        if ln.isEmpty() {
                                continue
                        }

                        if ln.isTopIndent() {
                                elem, err := newElement(ln, nil)

                                if err != nil {
                                        errc <- err
                                        return
                                }

                                if err := appendChildren(elem, lines, &i, l); err != nil {
                                        errc <- err
                                        return
                                }

                                elemc <- elem
                        }
                }

                close(elemc)
        }()

        return elemc, errc
}

// appendChildren parses the lines and appends the child elements
// to the parent element.
func appendChildren(parent element, lines []string, i *int, l int) error {
        for *i < l {
                // Fetch a line.
                ln := newLine(*i+1, lines[*i])

                // Ignore the empty line.
                if ln.isEmpty() {
                        *i++
                        return nil
                }

                ok, err := ln.childOf(parent)

                if err != nil {
                        return err
                }

                if !ok {
                        return nil
                }

                child, err := newElement(ln, parent)

                if err != nil {
                        return err
                }

                parent.AppendChild(child)

                *i++

                if err := appendChildren(child, lines, i, l); err != nil {
                        return err
                }
        }

        return nil
}

// formatLF replaces the line feed codes with LF and
// returns the result string.
func formatLF(s string) string {
        return strings.Replace(strings.Replace(s, crlf, lf, -1), cr, lf, -1)
}
1	yakumo_izuru	1.1	package gcss
2
3			import "strings"
4
5			// Special characters
6			const (
7			cr = "\r"
8			lf = "\n"
9			crlf = "\r\n"
10			space = " "
11			colon = ":"
12			comma = ","
13			openBrace = "{"
14			closeBrace = "}"
15			semicolon = ";"
16			ampersand = "&"
17			atMark = "@"
18			dollarMark = "$"
19			openParenthesis = "("
20			closeParenthesis = ")"
21			slash = "/"
22			doubleSlash = slash + slash
23			)
24
25			// parse parses the string, generates the elements
26			// and returns the two channels: the first one returns
27			// the generated elements and the last one returns
28			// an error when it occurs.
29			func parse(lines []string) (<-chan element, <-chan error) {
30			elemc := make(chan element, len(lines))
31			errc := make(chan error)
32
33			go func() {
34			i := 0
35			l := len(lines)
36
37			for i < l {
38			// Fetch a line.
39			ln := newLine(i+1, lines[i])
40			i++
41
42			// Ignore the empty line.
43			if ln.isEmpty() {
44			continue
45			}
46
47			if ln.isTopIndent() {
48			elem, err := newElement(ln, nil)
49
50			if err != nil {
51			errc <- err
52			return
53			}
54
55			if err := appendChildren(elem, lines, &i, l); err != nil {
56			errc <- err
57			return
58			}
59
60			elemc <- elem
61			}
62			}
63
64			close(elemc)
65			}()
66
67			return elemc, errc
68			}
69
70			// appendChildren parses the lines and appends the child elements
71			// to the parent element.
72			func appendChildren(parent element, lines []string, i *int, l int) error {
73			for *i < l {
74			// Fetch a line.
75			ln := newLine(i+1, lines[i])
76
77			// Ignore the empty line.
78			if ln.isEmpty() {
79			*i++
80			return nil
81			}
82
83			ok, err := ln.childOf(parent)
84
85			if err != nil {
86			return err
87			}
88
89			if !ok {
90			return nil
91			}
92
93			child, err := newElement(ln, parent)
94
95			if err != nil {
96			return err
97			}
98
99			parent.AppendChild(child)
100
101			*i++
102
103			if err := appendChildren(child, lines, i, l); err != nil {
104			return err
105			}
106			}
107
108			return nil
109			}
110
111			// formatLF replaces the line feed codes with LF and
112			// returns the result string.
113			func formatLF(s string) string {
114			return strings.Replace(strings.Replace(s, crlf, lf, -1), cr, lf, -1)
115			}
nishi@chaotic.ninja	ViewVC Help
Powered by ViewVC 1.3.0-dev