107 lines
1.6 KiB
Go
107 lines
1.6 KiB
Go
// Copyright 2015 The Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package markdown
|
|
|
|
import "unicode/utf8"
|
|
|
|
type ParserInline struct {
|
|
}
|
|
|
|
type (
|
|
InlineRule func(*StateInline, bool) bool
|
|
PostprocessRule func(*StateInline)
|
|
)
|
|
|
|
var (
|
|
inlineRules []InlineRule
|
|
postprocessRules []PostprocessRule
|
|
)
|
|
|
|
func (i ParserInline) Parse(src string, md *Markdown, env *Environment) []Token {
|
|
if src == "" {
|
|
return nil
|
|
}
|
|
|
|
var s StateInline
|
|
s.Src = src
|
|
s.Md = md
|
|
s.Env = env
|
|
s.PosMax = len(src)
|
|
s.Tokens = s.bootstrap[:0]
|
|
|
|
i.Tokenize(&s)
|
|
|
|
for _, r := range postprocessRules {
|
|
r(&s)
|
|
}
|
|
|
|
return s.Tokens
|
|
}
|
|
|
|
func (ParserInline) Tokenize(s *StateInline) {
|
|
end := s.PosMax
|
|
src := s.Src
|
|
maxNesting := s.Md.MaxNesting
|
|
ok := false
|
|
|
|
for s.Pos < end {
|
|
if s.Level < maxNesting {
|
|
for _, rule := range inlineRules {
|
|
ok = rule(s, false)
|
|
if ok {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
if ok {
|
|
if s.Pos >= end {
|
|
break
|
|
}
|
|
continue
|
|
}
|
|
|
|
r, size := utf8.DecodeRuneInString(src[s.Pos:])
|
|
s.Pending.WriteRune(r)
|
|
s.Pos += size
|
|
}
|
|
|
|
if s.Pending.Len() > 0 {
|
|
s.PushPending()
|
|
}
|
|
}
|
|
|
|
func (ParserInline) SkipToken(s *StateInline) {
|
|
pos := s.Pos
|
|
if s.Cache != nil {
|
|
if newPos, ok := s.Cache[pos]; ok {
|
|
s.Pos = newPos
|
|
return
|
|
}
|
|
} else {
|
|
s.Cache = make(map[int]int)
|
|
}
|
|
|
|
ok := false
|
|
if s.Level < s.Md.MaxNesting {
|
|
for _, r := range inlineRules {
|
|
s.Level++
|
|
ok = r(s, true)
|
|
s.Level--
|
|
if ok {
|
|
break
|
|
}
|
|
}
|
|
} else {
|
|
s.Pos = s.PosMax
|
|
}
|
|
|
|
if !ok {
|
|
_, size := utf8.DecodeRuneInString(s.Src[s.Pos:])
|
|
s.Pos += size
|
|
}
|
|
s.Cache[pos] = s.Pos
|
|
}
|