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
                }
        }
}
Revision:	1.1
Committed:	Mon Sep 30 00:42:06 2024 UTC (6 weeks, 4 days ago) by yakumo_izuru
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	Mirrored from https://git.chaotic.ninja/git/yakumo_izuru/aya
#	User	Rev	Content
1	yakumo_izuru	1.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			}