amber/parser/parser.go

package parser

import (
        "bytes"
        "fmt"
        "io"
        "io/ioutil"
        "net/http"
        "path/filepath"
        "strings"
)

type Parser struct {
        scanner      *scanner
        filename     string
        fs           http.FileSystem
        currenttoken *token
        namedBlocks  map[string]*NamedBlock
        parent       *Parser
        result       *Block
}

func newParser(rdr io.Reader) *Parser {
        p := new(Parser)
        p.scanner = newScanner(rdr)
        p.namedBlocks = make(map[string]*NamedBlock)
        return p
}

func StringParser(input string) (*Parser, error) {
        return newParser(bytes.NewReader([]byte(input))), nil
}

func ByteParser(input []byte) (*Parser, error) {
        return newParser(bytes.NewReader(input)), nil
}

func (p *Parser) SetFilename(filename string) {
        p.filename = filename
}

func (p *Parser) SetVirtualFilesystem(fs http.FileSystem) {
        p.fs = fs
}

func FileParser(filename string) (*Parser, error) {
        data, err := ioutil.ReadFile(filename)

        if err != nil {
                return nil, err
        }

        parser := newParser(bytes.NewReader(data))
        parser.filename = filename
        return parser, nil
}

func VirtualFileParser(filename string, fs http.FileSystem) (*Parser, error) {
        file, err := fs.Open(filename)
        if err != nil {
                return nil, err
        }

        data, err := ioutil.ReadAll(file)
        if err != nil {
                return nil, err
        }

        parser := newParser(bytes.NewReader(data))
        parser.filename = filename
        parser.fs = fs
        return parser, nil
}

func (p *Parser) Parse() *Block {
        if p.result != nil {
                return p.result
        }

        defer func() {
                if r := recover(); r != nil {
                        if rs, ok := r.(string); ok && rs[:len("Amber Error")] == "Amber Error" {
                                panic(r)
                        }

                        pos := p.pos()

                        if len(pos.Filename) > 0 {
                                panic(fmt.Sprintf("Amber Error in <%s>: %v - Line: %d, Column: %d, Length: %d", pos.Filename, r, pos.LineNum, pos.ColNum, pos.TokenLength))
                        } else {
                                panic(fmt.Sprintf("Amber Error: %v - Line: %d, Column: %d, Length: %d", r, pos.LineNum, pos.ColNum, pos.TokenLength))
                        }
                }
        }()

        block := newBlock()
        p.advance()

        for {
                if p.currenttoken == nil || p.currenttoken.Kind == tokEOF {
                        break
                }

                if p.currenttoken.Kind == tokBlank {
                        p.advance()
                        continue
                }

                block.push(p.parse())
        }

        if p.parent != nil {
                p.parent.Parse()

                for _, prev := range p.parent.namedBlocks {
                        ours := p.namedBlocks[prev.Name]

                        if ours == nil {
                                // Put a copy of the named block into current context, so that sub-templates can use the block
                                p.namedBlocks[prev.Name] = prev
                                continue
                        }

                        top := findTopmostParentWithNamedBlock(p, prev.Name)
                        nb := top.namedBlocks[prev.Name]
                        switch ours.Modifier {
                        case NamedBlockAppend:
                                for i := 0; i < len(ours.Children); i++ {
                                        nb.push(ours.Children[i])
                                }
                        case NamedBlockPrepend:
                                for i := len(ours.Children) - 1; i >= 0; i-- {
                                        nb.pushFront(ours.Children[i])
                                }
                        default:
                                nb.Children = ours.Children
                        }
                }

                block = p.parent.result
        }

        p.result = block
        return block
}

func (p *Parser) pos() SourcePosition {
        pos := p.scanner.Pos()
        pos.Filename = p.filename
        return pos
}

func (p *Parser) parseRelativeFile(filename string) *Parser {
        if len(p.filename) == 0 {
                panic("Unable to import or extend " + filename + " in a non filesystem based parser.")
        }

        filename = filepath.Join(filepath.Dir(p.filename), filename)

        if strings.IndexRune(filepath.Base(filename), '.') < 0 {
                filename = filename + ".amber"
        }

        parser, err := FileParser(filename)
        if err != nil && p.fs != nil {
                parser, err = VirtualFileParser(filename, p.fs)
        }
        if err != nil {
                panic("Unable to read " + filename + ", Error: " + string(err.Error()))
        }

        return parser
}

func (p *Parser) parse() Node {
        switch p.currenttoken.Kind {
        case tokDoctype:
                return p.parseDoctype()
        case tokComment:
                return p.parseComment()
        case tokText:
                return p.parseText()
        case tokIf:
                return p.parseIf()
        case tokEach:
                return p.parseEach()
        case tokImport:
                return p.parseImport()
        case tokTag:
                return p.parseTag()
        case tokAssignment:
                return p.parseAssignment()
        case tokNamedBlock:
                return p.parseNamedBlock()
        case tokExtends:
                return p.parseExtends()
        case tokIndent:
                return p.parseBlock(nil)
        case tokMixin:
                return p.parseMixin()
        case tokMixinCall:
                return p.parseMixinCall()
        }

        panic(fmt.Sprintf("Unexpected token: %d", p.currenttoken.Kind))
}

func (p *Parser) expect(typ rune) *token {
        if p.currenttoken.Kind != typ {
                panic("Unexpected token!")
        }
        curtok := p.currenttoken
        p.advance()
        return curtok
}

func (p *Parser) advance() {
        p.currenttoken = p.scanner.Next()
}

func (p *Parser) parseExtends() *Block {
        if p.parent != nil {
                panic("Unable to extend multiple parent templates.")
        }

        tok := p.expect(tokExtends)
        parser := p.parseRelativeFile(tok.Value)
        parser.Parse()
        p.parent = parser
        return newBlock()
}

func (p *Parser) parseBlock(parent Node) *Block {
        p.expect(tokIndent)
        block := newBlock()
        block.SourcePosition = p.pos()

        for {
                if p.currenttoken == nil || p.currenttoken.Kind == tokEOF || p.currenttoken.Kind == tokOutdent {
                        break
                }

                if p.currenttoken.Kind == tokBlank {
                        p.advance()
                        continue
                }

                if p.currenttoken.Kind == tokId ||
                        p.currenttoken.Kind == tokClassName ||
                        p.currenttoken.Kind == tokAttribute {

                        if tag, ok := parent.(*Tag); ok {
                                attr := p.expect(p.currenttoken.Kind)
                                cond := attr.Data["Condition"]

                                switch attr.Kind {
                                case tokId:
                                        tag.Attributes = append(tag.Attributes, Attribute{p.pos(), "id", attr.Value, true, cond})
                                case tokClassName:
                                        tag.Attributes = append(tag.Attributes, Attribute{p.pos(), "class", attr.Value, true, cond})
                                case tokAttribute:
                                        tag.Attributes = append(tag.Attributes, Attribute{p.pos(), attr.Value, attr.Data["Content"], attr.Data["Mode"] == "raw", cond})
                                }

                                continue
                        } else {
                                panic("Conditional attributes must be placed immediately within a parent tag.")
                        }
                }

                block.push(p.parse())
        }

        p.expect(tokOutdent)

        return block
}

func (p *Parser) parseIf() *Condition {
        tok := p.expect(tokIf)
        cnd := newCondition(tok.Value)
        cnd.SourcePosition = p.pos()

readmore:
        switch p.currenttoken.Kind {
        case tokIndent:
                cnd.Positive = p.parseBlock(cnd)
                goto readmore
        case tokElse:
                p.expect(tokElse)
                if p.currenttoken.Kind == tokIf {
                        cnd.Negative = newBlock()
                        cnd.Negative.push(p.parseIf())
                } else if p.currenttoken.Kind == tokIndent {
                        cnd.Negative = p.parseBlock(cnd)
                } else {
                        panic("Unexpected token!")
                }
                goto readmore
        }

        return cnd
}

func (p *Parser) parseEach() *Each {
        tok := p.expect(tokEach)
        ech := newEach(tok.Value)
        ech.SourcePosition = p.pos()
        ech.X = tok.Data["X"]
        ech.Y = tok.Data["Y"]

        if p.currenttoken.Kind == tokIndent {
                ech.Block = p.parseBlock(ech)
        }

        return ech
}

func (p *Parser) parseImport() *Block {
        tok := p.expect(tokImport)
        node := p.parseRelativeFile(tok.Value).Parse()
        node.SourcePosition = p.pos()
        return node
}

func (p *Parser) parseNamedBlock() *Block {
        tok := p.expect(tokNamedBlock)

        if p.namedBlocks[tok.Value] != nil {
                panic("Multiple definitions of named blocks are not permitted. Block " + tok.Value + " has been re defined.")
        }

        block := newNamedBlock(tok.Value)
        block.SourcePosition = p.pos()

        if tok.Data["Modifier"] == "append" {
                block.Modifier = NamedBlockAppend
        } else if tok.Data["Modifier"] == "prepend" {
                block.Modifier = NamedBlockPrepend
        }

        if p.currenttoken.Kind == tokIndent {
                block.Block = *(p.parseBlock(nil))
        }

        p.namedBlocks[block.Name] = block

        if block.Modifier == NamedBlockDefault {
                return &block.Block
        }

        return newBlock()
}

func (p *Parser) parseDoctype() *Doctype {
        tok := p.expect(tokDoctype)
        node := newDoctype(tok.Value)
        node.SourcePosition = p.pos()
        return node
}

func (p *Parser) parseComment() *Comment {
        tok := p.expect(tokComment)
        cmnt := newComment(tok.Value)
        cmnt.SourcePosition = p.pos()
        cmnt.Silent = tok.Data["Mode"] == "silent"

        if p.currenttoken.Kind == tokIndent {
                cmnt.Block = p.parseBlock(cmnt)
        }

        return cmnt
}

func (p *Parser) parseText() *Text {
        tok := p.expect(tokText)
        node := newText(tok.Value, tok.Data["Mode"] == "raw")
        node.SourcePosition = p.pos()
        return node
}

func (p *Parser) parseAssignment() *Assignment {
        tok := p.expect(tokAssignment)
        node := newAssignment(tok.Data["X"], tok.Value)
        node.SourcePosition = p.pos()
        return node
}

func (p *Parser) parseTag() *Tag {
        tok := p.expect(tokTag)
        tag := newTag(tok.Value)
        tag.SourcePosition = p.pos()

        ensureBlock := func() {
                if tag.Block == nil {
                        tag.Block = newBlock()
                }
        }

readmore:
        switch p.currenttoken.Kind {
        case tokIndent:
                if tag.IsRawText() {
                        p.scanner.readRaw = true
                }

                block := p.parseBlock(tag)
                if tag.Block == nil {
                        tag.Block = block
                } else {
                        for _, c := range block.Children {
                                tag.Block.push(c)
                        }
                }
        case tokId:
                id := p.expect(tokId)
                if len(id.Data["Condition"]) > 0 {
                        panic("Conditional attributes must be placed in a block within a tag.")
                }
                tag.Attributes = append(tag.Attributes, Attribute{p.pos(), "id", id.Value, true, ""})
                goto readmore
        case tokClassName:
                cls := p.expect(tokClassName)
                if len(cls.Data["Condition"]) > 0 {
                        panic("Conditional attributes must be placed in a block within a tag.")
                }
                tag.Attributes = append(tag.Attributes, Attribute{p.pos(), "class", cls.Value, true, ""})
                goto readmore
        case tokAttribute:
                attr := p.expect(tokAttribute)
                if len(attr.Data["Condition"]) > 0 {
                        panic("Conditional attributes must be placed in a block within a tag.")
                }
                tag.Attributes = append(tag.Attributes, Attribute{p.pos(), attr.Value, attr.Data["Content"], attr.Data["Mode"] == "raw", ""})
                goto readmore
        case tokText:
                if p.currenttoken.Data["Mode"] != "piped" {
                        ensureBlock()
                        tag.Block.pushFront(p.parseText())
                        goto readmore
                }
        }

        return tag
}

func (p *Parser) parseMixin() *Mixin {
        tok := p.expect(tokMixin)
        mixin := newMixin(tok.Value, tok.Data["Args"])
        mixin.SourcePosition = p.pos()

        if p.currenttoken.Kind == tokIndent {
                mixin.Block = p.parseBlock(mixin)
        }

        return mixin
}

func (p *Parser) parseMixinCall() *MixinCall {
        tok := p.expect(tokMixinCall)
        mixinCall := newMixinCall(tok.Value, tok.Data["Args"])
        mixinCall.SourcePosition = p.pos()
        return mixinCall
}

func findTopmostParentWithNamedBlock(p *Parser, name string) *Parser {
        top := p

        for {
                if top.namedBlocks[name] == nil {
                        return nil
                }
                if top.parent == nil {
                        return top
                }
                if top.parent.namedBlocks[name] != nil {
                        top = top.parent
                } else {
                        return top
                }
        }
}
1	package parser
2
3	import (
4	"bytes"
5	"fmt"
6	"io"
7	"io/ioutil"
8	"net/http"
9	"path/filepath"
10	"strings"
11	)
12
13	type Parser struct {
14	scanner *scanner
15	filename string
16	fs http.FileSystem
17	currenttoken *token
18	namedBlocks map[string]*NamedBlock
19	parent *Parser
20	result *Block
21	}
22
23	func newParser(rdr io.Reader) *Parser {
24	p := new(Parser)
25	p.scanner = newScanner(rdr)
26	p.namedBlocks = make(map[string]*NamedBlock)
27	return p
28	}
29
30	func StringParser(input string) (*Parser, error) {
31	return newParser(bytes.NewReader([]byte(input))), nil
32	}
33
34	func ByteParser(input []byte) (*Parser, error) {
35	return newParser(bytes.NewReader(input)), nil
36	}
37
38	func (p *Parser) SetFilename(filename string) {
39	p.filename = filename
40	}
41
42	func (p *Parser) SetVirtualFilesystem(fs http.FileSystem) {
43	p.fs = fs
44	}
45
46	func FileParser(filename string) (*Parser, error) {
47	data, err := ioutil.ReadFile(filename)
48
49	if err != nil {
50	return nil, err
51	}
52
53	parser := newParser(bytes.NewReader(data))
54	parser.filename = filename
55	return parser, nil
56	}
57
58	func VirtualFileParser(filename string, fs http.FileSystem) (*Parser, error) {
59	file, err := fs.Open(filename)
60	if err != nil {
61	return nil, err
62	}
63
64	data, err := ioutil.ReadAll(file)
65	if err != nil {
66	return nil, err
67	}
68
69	parser := newParser(bytes.NewReader(data))
70	parser.filename = filename
71	parser.fs = fs
72	return parser, nil
73	}
74
75	func (p Parser) Parse() Block {
76	if p.result != nil {
77	return p.result
78	}
79
80	defer func() {
81	if r := recover(); r != nil {
82	if rs, ok := r.(string); ok && rs[:len("Amber Error")] == "Amber Error" {
83	panic(r)
84	}
85
86	pos := p.pos()
87
88	if len(pos.Filename) > 0 {
89	panic(fmt.Sprintf("Amber Error in <%s>: %v - Line: %d, Column: %d, Length: %d", pos.Filename, r, pos.LineNum, pos.ColNum, pos.TokenLength))
90	} else {
91	panic(fmt.Sprintf("Amber Error: %v - Line: %d, Column: %d, Length: %d", r, pos.LineNum, pos.ColNum, pos.TokenLength))
92	}
93	}
94	}()
95
96	block := newBlock()
97	p.advance()
98
99	for {
100	if p.currenttoken == nil \|\| p.currenttoken.Kind == tokEOF {
101	break
102	}
103
104	if p.currenttoken.Kind == tokBlank {
105	p.advance()
106	continue
107	}
108
109	block.push(p.parse())
110	}
111
112	if p.parent != nil {
113	p.parent.Parse()
114
115	for _, prev := range p.parent.namedBlocks {
116	ours := p.namedBlocks[prev.Name]
117
118	if ours == nil {
119	// Put a copy of the named block into current context, so that sub-templates can use the block
120	p.namedBlocks[prev.Name] = prev
121	continue
122	}
123
124	top := findTopmostParentWithNamedBlock(p, prev.Name)
125	nb := top.namedBlocks[prev.Name]
126	switch ours.Modifier {
127	case NamedBlockAppend:
128	for i := 0; i < len(ours.Children); i++ {
129	nb.push(ours.Children[i])
130	}
131	case NamedBlockPrepend:
132	for i := len(ours.Children) - 1; i >= 0; i-- {
133	nb.pushFront(ours.Children[i])
134	}
135	default:
136	nb.Children = ours.Children
137	}
138	}
139
140	block = p.parent.result
141	}
142
143	p.result = block
144	return block
145	}
146
147	func (p *Parser) pos() SourcePosition {
148	pos := p.scanner.Pos()
149	pos.Filename = p.filename
150	return pos
151	}
152
153	func (p Parser) parseRelativeFile(filename string) Parser {
154	if len(p.filename) == 0 {
155	panic("Unable to import or extend " + filename + " in a non filesystem based parser.")
156	}
157
158	filename = filepath.Join(filepath.Dir(p.filename), filename)
159
160	if strings.IndexRune(filepath.Base(filename), '.') < 0 {
161	filename = filename + ".amber"
162	}
163
164	parser, err := FileParser(filename)
165	if err != nil && p.fs != nil {
166	parser, err = VirtualFileParser(filename, p.fs)
167	}
168	if err != nil {
169	panic("Unable to read " + filename + ", Error: " + string(err.Error()))
170	}
171
172	return parser
173	}
174
175	func (p *Parser) parse() Node {
176	switch p.currenttoken.Kind {
177	case tokDoctype:
178	return p.parseDoctype()
179	case tokComment:
180	return p.parseComment()
181	case tokText:
182	return p.parseText()
183	case tokIf:
184	return p.parseIf()
185	case tokEach:
186	return p.parseEach()
187	case tokImport:
188	return p.parseImport()
189	case tokTag:
190	return p.parseTag()
191	case tokAssignment:
192	return p.parseAssignment()
193	case tokNamedBlock:
194	return p.parseNamedBlock()
195	case tokExtends:
196	return p.parseExtends()
197	case tokIndent:
198	return p.parseBlock(nil)
199	case tokMixin:
200	return p.parseMixin()
201	case tokMixinCall:
202	return p.parseMixinCall()
203	}
204
205	panic(fmt.Sprintf("Unexpected token: %d", p.currenttoken.Kind))
206	}
207
208	func (p Parser) expect(typ rune) token {
209	if p.currenttoken.Kind != typ {
210	panic("Unexpected token!")
211	}
212	curtok := p.currenttoken
213	p.advance()
214	return curtok
215	}
216
217	func (p *Parser) advance() {
218	p.currenttoken = p.scanner.Next()
219	}
220
221	func (p Parser) parseExtends() Block {
222	if p.parent != nil {
223	panic("Unable to extend multiple parent templates.")
224	}
225
226	tok := p.expect(tokExtends)
227	parser := p.parseRelativeFile(tok.Value)
228	parser.Parse()
229	p.parent = parser
230	return newBlock()
231	}
232
233	func (p Parser) parseBlock(parent Node) Block {
234	p.expect(tokIndent)
235	block := newBlock()
236	block.SourcePosition = p.pos()
237
238	for {
239	if p.currenttoken == nil \|\| p.currenttoken.Kind == tokEOF \|\| p.currenttoken.Kind == tokOutdent {
240	break
241	}
242
243	if p.currenttoken.Kind == tokBlank {
244	p.advance()
245	continue
246	}
247
248	if p.currenttoken.Kind == tokId \|\|
249	p.currenttoken.Kind == tokClassName \|\|
250	p.currenttoken.Kind == tokAttribute {
251
252	if tag, ok := parent.(*Tag); ok {
253	attr := p.expect(p.currenttoken.Kind)
254	cond := attr.Data["Condition"]
255
256	switch attr.Kind {
257	case tokId:
258	tag.Attributes = append(tag.Attributes, Attribute{p.pos(), "id", attr.Value, true, cond})
259	case tokClassName:
260	tag.Attributes = append(tag.Attributes, Attribute{p.pos(), "class", attr.Value, true, cond})
261	case tokAttribute:
262	tag.Attributes = append(tag.Attributes, Attribute{p.pos(), attr.Value, attr.Data["Content"], attr.Data["Mode"] == "raw", cond})
263	}
264
265	continue
266	} else {
267	panic("Conditional attributes must be placed immediately within a parent tag.")
268	}
269	}
270
271	block.push(p.parse())
272	}
273
274	p.expect(tokOutdent)
275
276	return block
277	}
278
279	func (p Parser) parseIf() Condition {
280	tok := p.expect(tokIf)
281	cnd := newCondition(tok.Value)
282	cnd.SourcePosition = p.pos()
283
284	readmore:
285	switch p.currenttoken.Kind {
286	case tokIndent:
287	cnd.Positive = p.parseBlock(cnd)
288	goto readmore
289	case tokElse:
290	p.expect(tokElse)
291	if p.currenttoken.Kind == tokIf {
292	cnd.Negative = newBlock()
293	cnd.Negative.push(p.parseIf())
294	} else if p.currenttoken.Kind == tokIndent {
295	cnd.Negative = p.parseBlock(cnd)
296	} else {
297	panic("Unexpected token!")
298	}
299	goto readmore
300	}
301
302	return cnd
303	}
304
305	func (p Parser) parseEach() Each {
306	tok := p.expect(tokEach)
307	ech := newEach(tok.Value)
308	ech.SourcePosition = p.pos()
309	ech.X = tok.Data["X"]
310	ech.Y = tok.Data["Y"]
311
312	if p.currenttoken.Kind == tokIndent {
313	ech.Block = p.parseBlock(ech)
314	}
315
316	return ech
317	}
318
319	func (p Parser) parseImport() Block {
320	tok := p.expect(tokImport)
321	node := p.parseRelativeFile(tok.Value).Parse()
322	node.SourcePosition = p.pos()
323	return node
324	}
325
326	func (p Parser) parseNamedBlock() Block {
327	tok := p.expect(tokNamedBlock)
328
329	if p.namedBlocks[tok.Value] != nil {
330	panic("Multiple definitions of named blocks are not permitted. Block " + tok.Value + " has been re defined.")
331	}
332
333	block := newNamedBlock(tok.Value)
334	block.SourcePosition = p.pos()
335
336	if tok.Data["Modifier"] == "append" {
337	block.Modifier = NamedBlockAppend
338	} else if tok.Data["Modifier"] == "prepend" {
339	block.Modifier = NamedBlockPrepend
340	}
341
342	if p.currenttoken.Kind == tokIndent {
343	block.Block = *(p.parseBlock(nil))
344	}
345
346	p.namedBlocks[block.Name] = block
347
348	if block.Modifier == NamedBlockDefault {
349	return &block.Block
350	}
351
352	return newBlock()
353	}
354
355	func (p Parser) parseDoctype() Doctype {
356	tok := p.expect(tokDoctype)
357	node := newDoctype(tok.Value)
358	node.SourcePosition = p.pos()
359	return node
360	}
361
362	func (p Parser) parseComment() Comment {
363	tok := p.expect(tokComment)
364	cmnt := newComment(tok.Value)
365	cmnt.SourcePosition = p.pos()
366	cmnt.Silent = tok.Data["Mode"] == "silent"
367
368	if p.currenttoken.Kind == tokIndent {
369	cmnt.Block = p.parseBlock(cmnt)
370	}
371
372	return cmnt
373	}
374
375	func (p Parser) parseText() Text {
376	tok := p.expect(tokText)
377	node := newText(tok.Value, tok.Data["Mode"] == "raw")
378	node.SourcePosition = p.pos()
379	return node
380	}
381
382	func (p Parser) parseAssignment() Assignment {
383	tok := p.expect(tokAssignment)
384	node := newAssignment(tok.Data["X"], tok.Value)
385	node.SourcePosition = p.pos()
386	return node
387	}
388
389	func (p Parser) parseTag() Tag {
390	tok := p.expect(tokTag)
391	tag := newTag(tok.Value)
392	tag.SourcePosition = p.pos()
393
394	ensureBlock := func() {
395	if tag.Block == nil {
396	tag.Block = newBlock()
397	}
398	}
399
400	readmore:
401	switch p.currenttoken.Kind {
402	case tokIndent:
403	if tag.IsRawText() {
404	p.scanner.readRaw = true
405	}
406
407	block := p.parseBlock(tag)
408	if tag.Block == nil {
409	tag.Block = block
410	} else {
411	for _, c := range block.Children {
412	tag.Block.push(c)
413	}
414	}
415	case tokId:
416	id := p.expect(tokId)
417	if len(id.Data["Condition"]) > 0 {
418	panic("Conditional attributes must be placed in a block within a tag.")
419	}
420	tag.Attributes = append(tag.Attributes, Attribute{p.pos(), "id", id.Value, true, ""})
421	goto readmore
422	case tokClassName:
423	cls := p.expect(tokClassName)
424	if len(cls.Data["Condition"]) > 0 {
425	panic("Conditional attributes must be placed in a block within a tag.")
426	}
427	tag.Attributes = append(tag.Attributes, Attribute{p.pos(), "class", cls.Value, true, ""})
428	goto readmore
429	case tokAttribute:
430	attr := p.expect(tokAttribute)
431	if len(attr.Data["Condition"]) > 0 {
432	panic("Conditional attributes must be placed in a block within a tag.")
433	}
434	tag.Attributes = append(tag.Attributes, Attribute{p.pos(), attr.Value, attr.Data["Content"], attr.Data["Mode"] == "raw", ""})
435	goto readmore
436	case tokText:
437	if p.currenttoken.Data["Mode"] != "piped" {
438	ensureBlock()
439	tag.Block.pushFront(p.parseText())
440	goto readmore
441	}
442	}
443
444	return tag
445	}
446
447	func (p Parser) parseMixin() Mixin {
448	tok := p.expect(tokMixin)
449	mixin := newMixin(tok.Value, tok.Data["Args"])
450	mixin.SourcePosition = p.pos()
451
452	if p.currenttoken.Kind == tokIndent {
453	mixin.Block = p.parseBlock(mixin)
454	}
455
456	return mixin
457	}
458
459	func (p Parser) parseMixinCall() MixinCall {
460	tok := p.expect(tokMixinCall)
461	mixinCall := newMixinCall(tok.Value, tok.Data["Args"])
462	mixinCall.SourcePosition = p.pos()
463	return mixinCall
464	}
465
466	func findTopmostParentWithNamedBlock(p Parser, name string) Parser {
467	top := p
468
469	for {
470	if top.namedBlocks[name] == nil {
471	return nil
472	}
473	if top.parent == nil {
474	return top
475	}
476	if top.parent.namedBlocks[name] != nil {
477	top = top.parent
478	} else {
479	return top
480	}
481	}
482	}
nishi@chaotic.ninja	ViewVC Help
Powered by ViewVC 1.3.0-dev