mirror of
https://github.com/danog/blackfriday.git
synced 2024-11-30 04:29:13 +01:00
1168 lines
23 KiB
Go
1168 lines
23 KiB
Go
//
|
|
// Blackfriday Markdown Processor
|
|
// Available at http://github.com/russross/blackfriday
|
|
//
|
|
// Copyright © 2011 Russ Ross <russ@russross.com>.
|
|
// Licensed under the Simplified BSD License.
|
|
// See README.md for details.
|
|
//
|
|
|
|
//
|
|
// Functions to parse block-level elements.
|
|
//
|
|
|
|
package blackfriday
|
|
|
|
import (
|
|
"bytes"
|
|
)
|
|
|
|
// parse block-level data
|
|
func parseBlock(out *bytes.Buffer, rndr *render, data []byte) {
|
|
// this is called recursively: enforce a maximum depth
|
|
if rndr.nesting >= rndr.maxNesting {
|
|
return
|
|
}
|
|
rndr.nesting++
|
|
|
|
// parse out one block-level construct at a time
|
|
for len(data) > 0 {
|
|
// prefixed header:
|
|
//
|
|
// # Header 1
|
|
// ## Header 2
|
|
// ...
|
|
// ###### Header 6
|
|
if isPrefixHeader(rndr, data) {
|
|
data = data[blockPrefixHeader(out, rndr, data):]
|
|
continue
|
|
}
|
|
|
|
// block of preformatted HTML:
|
|
//
|
|
// <div>
|
|
// ...
|
|
// </div>
|
|
if data[0] == '<' && rndr.mk.BlockHtml != nil {
|
|
if i := blockHtml(out, rndr, data, true); i > 0 {
|
|
data = data[i:]
|
|
continue
|
|
}
|
|
}
|
|
|
|
// blank lines. note: returns the # of bytes to skip
|
|
if i := isEmpty(data); i > 0 {
|
|
data = data[i:]
|
|
continue
|
|
}
|
|
|
|
// horizontal rule:
|
|
//
|
|
// ------
|
|
// or
|
|
// ******
|
|
// or
|
|
// ______
|
|
if isHRule(data) {
|
|
if rndr.mk.HRule != nil {
|
|
rndr.mk.HRule(out, rndr.mk.Opaque)
|
|
}
|
|
var i int
|
|
for i = 0; i < len(data) && data[i] != '\n'; i++ {
|
|
}
|
|
data = data[i:]
|
|
continue
|
|
}
|
|
|
|
// fenced code block:
|
|
//
|
|
// ``` go
|
|
// func fact(n int) int {
|
|
// if n <= 1 {
|
|
// return n
|
|
// }
|
|
// return n * fact(n-1)
|
|
// }
|
|
// ```
|
|
if rndr.flags&EXTENSION_FENCED_CODE != 0 {
|
|
if i := blockFencedCode(out, rndr, data); i > 0 {
|
|
data = data[i:]
|
|
continue
|
|
}
|
|
}
|
|
|
|
// table:
|
|
//
|
|
// Name | Age | Phone
|
|
// ------|-----|---------
|
|
// Bob | 31 | 555-1234
|
|
// Alice | 27 | 555-4321
|
|
if rndr.flags&EXTENSION_TABLES != 0 {
|
|
if i := blockTable(out, rndr, data); i > 0 {
|
|
data = data[i:]
|
|
continue
|
|
}
|
|
}
|
|
|
|
// block quote:
|
|
//
|
|
// > A big quote I found somewhere
|
|
// > on the web
|
|
if blockQuotePrefix(data) > 0 {
|
|
data = data[blockQuote(out, rndr, data):]
|
|
continue
|
|
}
|
|
|
|
// indented code block:
|
|
//
|
|
// func max(a, b int) int {
|
|
// if a > b {
|
|
// return a
|
|
// }
|
|
// return b
|
|
// }
|
|
if blockCodePrefix(data) > 0 {
|
|
data = data[blockCode(out, rndr, data):]
|
|
continue
|
|
}
|
|
|
|
// an itemized/unordered list:
|
|
//
|
|
// * Item 1
|
|
// * Item 2
|
|
//
|
|
// also works with + or -
|
|
if blockUliPrefix(data) > 0 {
|
|
data = data[blockList(out, rndr, data, 0):]
|
|
continue
|
|
}
|
|
|
|
// a numbered/ordered list:
|
|
//
|
|
// 1. Item 1
|
|
// 2. Item 2
|
|
if blockOliPrefix(data) > 0 {
|
|
data = data[blockList(out, rndr, data, LIST_TYPE_ORDERED):]
|
|
continue
|
|
}
|
|
|
|
// anything else must look like a normal paragraph
|
|
// note: this finds underlined headers, too
|
|
data = data[blockParagraph(out, rndr, data):]
|
|
}
|
|
|
|
rndr.nesting--
|
|
}
|
|
|
|
func isPrefixHeader(rndr *render, data []byte) bool {
|
|
if data[0] != '#' {
|
|
return false
|
|
}
|
|
|
|
if rndr.flags&EXTENSION_SPACE_HEADERS != 0 {
|
|
level := 0
|
|
for level < len(data) && level < 6 && data[level] == '#' {
|
|
level++
|
|
}
|
|
if level < len(data) && data[level] != ' ' && data[level] != '\t' {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func blockPrefixHeader(out *bytes.Buffer, rndr *render, data []byte) int {
|
|
level := 0
|
|
for level < len(data) && level < 6 && data[level] == '#' {
|
|
level++
|
|
}
|
|
i, end := 0, 0
|
|
for i = level; i < len(data) && (data[i] == ' ' || data[i] == '\t'); i++ {
|
|
}
|
|
for end = i; end < len(data) && data[end] != '\n'; end++ {
|
|
}
|
|
skip := end
|
|
for end > 0 && data[end-1] == '#' {
|
|
end--
|
|
}
|
|
for end > 0 && (data[end-1] == ' ' || data[end-1] == '\t') {
|
|
end--
|
|
}
|
|
if end > i {
|
|
if rndr.mk.Header != nil {
|
|
work := func() bool {
|
|
parseInline(out, rndr, data[i:end])
|
|
return true
|
|
}
|
|
rndr.mk.Header(out, work, level, rndr.mk.Opaque)
|
|
}
|
|
}
|
|
return skip
|
|
}
|
|
|
|
func isUnderlinedHeader(data []byte) int {
|
|
i := 0
|
|
|
|
// test of level 1 header
|
|
if data[i] == '=' {
|
|
for i = 1; i < len(data) && data[i] == '='; i++ {
|
|
}
|
|
for i < len(data) && (data[i] == ' ' || data[i] == '\t') {
|
|
i++
|
|
}
|
|
if i >= len(data) || data[i] == '\n' {
|
|
return 1
|
|
} else {
|
|
return 0
|
|
}
|
|
}
|
|
|
|
// test of level 2 header
|
|
if data[i] == '-' {
|
|
for i = 1; i < len(data) && data[i] == '-'; i++ {
|
|
}
|
|
for i < len(data) && (data[i] == ' ' || data[i] == '\t') {
|
|
i++
|
|
}
|
|
if i >= len(data) || data[i] == '\n' {
|
|
return 2
|
|
} else {
|
|
return 0
|
|
}
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
func blockHtml(out *bytes.Buffer, rndr *render, data []byte, do_render bool) int {
|
|
var i, j int
|
|
|
|
// identify the opening tag
|
|
if len(data) < 2 || data[0] != '<' {
|
|
return 0
|
|
}
|
|
curtag, tagfound := blockHtmlFindTag(data[1:])
|
|
|
|
// handle special cases
|
|
if !tagfound {
|
|
|
|
// HTML comment, lax form
|
|
if len(data) > 5 && data[1] == '!' && data[2] == '-' && data[3] == '-' {
|
|
i = 5
|
|
|
|
for i < len(data) && !(data[i-2] == '-' && data[i-1] == '-' && data[i] == '>') {
|
|
i++
|
|
}
|
|
i++
|
|
|
|
if i < len(data) {
|
|
j = isEmpty(data[i:])
|
|
}
|
|
|
|
if j > 0 {
|
|
size := i + j
|
|
if do_render && rndr.mk.BlockHtml != nil {
|
|
rndr.mk.BlockHtml(out, data[:size], rndr.mk.Opaque)
|
|
}
|
|
return size
|
|
}
|
|
}
|
|
|
|
// HR, which is the only self-closing block tag considered
|
|
if len(data) > 4 &&
|
|
(data[1] == 'h' || data[1] == 'H') &&
|
|
(data[2] == 'r' || data[2] == 'R') {
|
|
|
|
i = 3
|
|
for i < len(data) && data[i] != '>' {
|
|
i++
|
|
}
|
|
|
|
if i+1 < len(data) {
|
|
i++
|
|
j = isEmpty(data[i:])
|
|
if j > 0 {
|
|
size := i + j
|
|
if do_render && rndr.mk.BlockHtml != nil {
|
|
rndr.mk.BlockHtml(out, data[:size], rndr.mk.Opaque)
|
|
}
|
|
return size
|
|
}
|
|
}
|
|
}
|
|
|
|
// no special case recognized
|
|
return 0
|
|
}
|
|
|
|
// look for an unindented matching closing tag
|
|
// followed by a blank line
|
|
i = 1
|
|
found := false
|
|
|
|
// if not found, try a second pass looking for indented match
|
|
// but not if tag is "ins" or "del" (following original Markdown.pl)
|
|
if curtag != "ins" && curtag != "del" {
|
|
i = 1
|
|
for i < len(data) {
|
|
i++
|
|
for i < len(data) && !(data[i-1] == '<' && data[i] == '/') {
|
|
i++
|
|
}
|
|
|
|
if i+2+len(curtag) >= len(data) {
|
|
break
|
|
}
|
|
|
|
j = blockHtmlFindEnd(curtag, rndr, data[i-1:])
|
|
|
|
if j > 0 {
|
|
i += j - 1
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
if !found {
|
|
return 0
|
|
}
|
|
|
|
// the end of the block has been found
|
|
if do_render && rndr.mk.BlockHtml != nil {
|
|
rndr.mk.BlockHtml(out, data[:i], rndr.mk.Opaque)
|
|
}
|
|
|
|
return i
|
|
}
|
|
|
|
func blockHtmlFindTag(data []byte) (string, bool) {
|
|
i := 0
|
|
for i < len(data) && isalnum(data[i]) {
|
|
i++
|
|
}
|
|
if i >= len(data) {
|
|
return "", false
|
|
}
|
|
key := string(data[:i])
|
|
if block_tags[key] {
|
|
return key, true
|
|
}
|
|
return "", false
|
|
}
|
|
|
|
func blockHtmlFindEnd(tag string, rndr *render, data []byte) int {
|
|
// assume data[0] == '<' && data[1] == '/' already tested
|
|
|
|
// check if tag is a match
|
|
if len(data) < len(tag)+3 || data[len(tag)+2] != '>' ||
|
|
bytes.Compare(data[2:2+len(tag)], []byte(tag)) != 0 {
|
|
return 0
|
|
}
|
|
|
|
// check for blank line/eof after the closing tag
|
|
i := len(tag) + 3
|
|
w := 0
|
|
if i < len(data) {
|
|
if w = isEmpty(data[i:]); w == 0 {
|
|
return 0 // non-blank after tag
|
|
}
|
|
}
|
|
i += w
|
|
w = 0
|
|
|
|
if rndr.flags&EXTENSION_LAX_HTML_BLOCKS != 0 {
|
|
if i < len(data) {
|
|
w = isEmpty(data[i:])
|
|
}
|
|
} else {
|
|
if i < len(data) {
|
|
if w = isEmpty(data[i:]); w == 0 {
|
|
return 0 // non-blank line after tag line
|
|
}
|
|
}
|
|
}
|
|
|
|
return i + w
|
|
}
|
|
|
|
func isEmpty(data []byte) int {
|
|
var i int
|
|
for i = 0; i < len(data) && data[i] != '\n'; i++ {
|
|
if data[i] != ' ' && data[i] != '\t' {
|
|
return 0
|
|
}
|
|
}
|
|
return i + 1
|
|
}
|
|
|
|
func isHRule(data []byte) bool {
|
|
// skip initial spaces
|
|
if len(data) < 3 {
|
|
return false
|
|
}
|
|
i := 0
|
|
|
|
// skip up to three spaces
|
|
for i < 3 && data[i] == ' ' {
|
|
i++
|
|
}
|
|
|
|
// look at the hrule char
|
|
if i+2 >= len(data) || (data[i] != '*' && data[i] != '-' && data[i] != '_') {
|
|
return false
|
|
}
|
|
c := data[i]
|
|
|
|
// the whole line must be the char or whitespace
|
|
n := 0
|
|
for i < len(data) && data[i] != '\n' {
|
|
switch {
|
|
case data[i] == c:
|
|
n++
|
|
case data[i] != ' ' && data[i] != '\t':
|
|
return false
|
|
}
|
|
i++
|
|
}
|
|
|
|
return n >= 3
|
|
}
|
|
|
|
func isFencedCode(data []byte, syntax **string, oldmarker string) (skip int, marker string) {
|
|
i, size := 0, 0
|
|
skip = 0
|
|
|
|
// skip initial spaces
|
|
if len(data) < 3 {
|
|
return
|
|
}
|
|
if data[0] == ' ' {
|
|
i++
|
|
if data[1] == ' ' {
|
|
i++
|
|
if data[2] == ' ' {
|
|
i++
|
|
}
|
|
}
|
|
}
|
|
|
|
// check for the marker characters: ~ or `
|
|
if i+2 >= len(data) || !(data[i] == '~' || data[i] == '`') {
|
|
return
|
|
}
|
|
|
|
c := data[i]
|
|
|
|
// the whole line must be the same char or whitespace
|
|
for i < len(data) && data[i] == c {
|
|
size++
|
|
i++
|
|
}
|
|
|
|
// the marker char must occur at least 3 times
|
|
if size < 3 {
|
|
return
|
|
}
|
|
marker = string(data[i-size : i])
|
|
|
|
// if this is the end marker, it must match the beginning marker
|
|
if oldmarker != "" && marker != oldmarker {
|
|
return
|
|
}
|
|
|
|
if syntax != nil {
|
|
syn := 0
|
|
|
|
for i < len(data) && (data[i] == ' ' || data[i] == '\t') {
|
|
i++
|
|
}
|
|
|
|
syntax_start := i
|
|
|
|
if i < len(data) && data[i] == '{' {
|
|
i++
|
|
syntax_start++
|
|
|
|
for i < len(data) && data[i] != '}' && data[i] != '\n' {
|
|
syn++
|
|
i++
|
|
}
|
|
|
|
if i == len(data) || data[i] != '}' {
|
|
return
|
|
}
|
|
|
|
// strip all whitespace at the beginning and the end
|
|
// of the {} block
|
|
for syn > 0 && isspace(data[syntax_start]) {
|
|
syntax_start++
|
|
syn--
|
|
}
|
|
|
|
for syn > 0 && isspace(data[syntax_start+syn-1]) {
|
|
syn--
|
|
}
|
|
|
|
i++
|
|
} else {
|
|
for i < len(data) && !isspace(data[i]) {
|
|
syn++
|
|
i++
|
|
}
|
|
}
|
|
|
|
language := string(data[syntax_start : syntax_start+syn])
|
|
*syntax = &language
|
|
}
|
|
|
|
for ; i < len(data) && data[i] != '\n'; i++ {
|
|
if !isspace(data[i]) {
|
|
return
|
|
}
|
|
}
|
|
|
|
skip = i + 1
|
|
return
|
|
}
|
|
|
|
func blockFencedCode(out *bytes.Buffer, rndr *render, data []byte) int {
|
|
var lang *string
|
|
beg, marker := isFencedCode(data, &lang, "")
|
|
if beg == 0 {
|
|
return 0
|
|
}
|
|
|
|
var work bytes.Buffer
|
|
|
|
for beg < len(data) {
|
|
fence_end, _ := isFencedCode(data[beg:], nil, marker)
|
|
if fence_end != 0 {
|
|
beg += fence_end
|
|
break
|
|
}
|
|
|
|
var end int
|
|
for end = beg + 1; end < len(data) && data[end-1] != '\n'; end++ {
|
|
}
|
|
|
|
if beg < end {
|
|
// verbatim copy to the working buffer
|
|
if isEmpty(data[beg:]) > 0 {
|
|
work.WriteByte('\n')
|
|
} else {
|
|
work.Write(data[beg:end])
|
|
}
|
|
}
|
|
beg = end
|
|
|
|
// did we find the end of the buffer without a closing marker?
|
|
if beg >= len(data) {
|
|
return 0
|
|
}
|
|
}
|
|
|
|
if work.Len() > 0 && work.Bytes()[work.Len()-1] != '\n' {
|
|
work.WriteByte('\n')
|
|
}
|
|
|
|
if rndr.mk.BlockCode != nil {
|
|
syntax := ""
|
|
if lang != nil {
|
|
syntax = *lang
|
|
}
|
|
|
|
rndr.mk.BlockCode(out, work.Bytes(), syntax, rndr.mk.Opaque)
|
|
}
|
|
|
|
return beg
|
|
}
|
|
|
|
func blockTable(out *bytes.Buffer, rndr *render, data []byte) int {
|
|
var header_work bytes.Buffer
|
|
i, columns, col_data := blockTableHeader(&header_work, rndr, data)
|
|
if i == 0 {
|
|
return 0
|
|
}
|
|
|
|
var body_work bytes.Buffer
|
|
|
|
for i < len(data) {
|
|
pipes, row_start := 0, i
|
|
for ; i < len(data) && data[i] != '\n'; i++ {
|
|
if data[i] == '|' {
|
|
pipes++
|
|
}
|
|
}
|
|
|
|
if pipes == 0 || i == len(data) {
|
|
i = row_start
|
|
break
|
|
}
|
|
|
|
blockTableRow(&body_work, rndr, data[row_start:i], columns, col_data)
|
|
i++
|
|
}
|
|
|
|
if rndr.mk.Table != nil {
|
|
rndr.mk.Table(out, header_work.Bytes(), body_work.Bytes(), col_data, rndr.mk.Opaque)
|
|
}
|
|
|
|
return i
|
|
}
|
|
|
|
func blockTableHeader(out *bytes.Buffer, rndr *render, data []byte) (size int, columns int, column_data []int) {
|
|
i, pipes := 0, 0
|
|
column_data = []int{}
|
|
for i = 0; i < len(data) && data[i] != '\n'; i++ {
|
|
if data[i] == '|' {
|
|
pipes++
|
|
}
|
|
}
|
|
|
|
if i == len(data) || pipes == 0 {
|
|
return 0, 0, column_data
|
|
}
|
|
|
|
header_end := i
|
|
|
|
if data[0] == '|' {
|
|
pipes--
|
|
}
|
|
|
|
if i > 2 && data[i-1] == '|' {
|
|
pipes--
|
|
}
|
|
|
|
columns = pipes + 1
|
|
column_data = make([]int, columns)
|
|
|
|
// parse the header underline
|
|
i++
|
|
if i < len(data) && data[i] == '|' {
|
|
i++
|
|
}
|
|
|
|
under_end := i
|
|
for under_end < len(data) && data[under_end] != '\n' {
|
|
under_end++
|
|
}
|
|
|
|
col := 0
|
|
for ; col < columns && i < under_end; col++ {
|
|
dashes := 0
|
|
|
|
for i < under_end && (data[i] == ' ' || data[i] == '\t') {
|
|
i++
|
|
}
|
|
|
|
if data[i] == ':' {
|
|
i++
|
|
column_data[col] |= TABLE_ALIGNMENT_LEFT
|
|
dashes++
|
|
}
|
|
|
|
for i < under_end && data[i] == '-' {
|
|
i++
|
|
dashes++
|
|
}
|
|
|
|
if i < under_end && data[i] == ':' {
|
|
i++
|
|
column_data[col] |= TABLE_ALIGNMENT_RIGHT
|
|
dashes++
|
|
}
|
|
|
|
for i < under_end && (data[i] == ' ' || data[i] == '\t') {
|
|
i++
|
|
}
|
|
|
|
if i < under_end && data[i] != '|' {
|
|
break
|
|
}
|
|
|
|
if dashes < 3 {
|
|
break
|
|
}
|
|
|
|
i++
|
|
}
|
|
|
|
if col < columns {
|
|
return 0, 0, column_data
|
|
}
|
|
|
|
blockTableRow(out, rndr, data[:header_end], columns, column_data)
|
|
size = under_end + 1
|
|
return
|
|
}
|
|
|
|
func blockTableRow(out *bytes.Buffer, rndr *render, data []byte, columns int, col_data []int) {
|
|
i, col := 0, 0
|
|
var row_work bytes.Buffer
|
|
|
|
if i < len(data) && data[i] == '|' {
|
|
i++
|
|
}
|
|
|
|
for col = 0; col < columns && i < len(data); col++ {
|
|
for i < len(data) && isspace(data[i]) {
|
|
i++
|
|
}
|
|
|
|
cell_start := i
|
|
|
|
for i < len(data) && data[i] != '|' {
|
|
i++
|
|
}
|
|
|
|
cell_end := i - 1
|
|
|
|
for cell_end > cell_start && isspace(data[cell_end]) {
|
|
cell_end--
|
|
}
|
|
|
|
var cell_work bytes.Buffer
|
|
parseInline(&cell_work, rndr, data[cell_start:cell_end+1])
|
|
|
|
if rndr.mk.TableCell != nil {
|
|
cdata := 0
|
|
if col < len(col_data) {
|
|
cdata = col_data[col]
|
|
}
|
|
rndr.mk.TableCell(&row_work, cell_work.Bytes(), cdata, rndr.mk.Opaque)
|
|
}
|
|
|
|
i++
|
|
}
|
|
|
|
for ; col < columns; col++ {
|
|
empty_cell := []byte{}
|
|
if rndr.mk.TableCell != nil {
|
|
cdata := 0
|
|
if col < len(col_data) {
|
|
cdata = col_data[col]
|
|
}
|
|
rndr.mk.TableCell(&row_work, empty_cell, cdata, rndr.mk.Opaque)
|
|
}
|
|
}
|
|
|
|
if rndr.mk.TableRow != nil {
|
|
rndr.mk.TableRow(out, row_work.Bytes(), rndr.mk.Opaque)
|
|
}
|
|
}
|
|
|
|
// returns blockquote prefix length
|
|
func blockQuotePrefix(data []byte) int {
|
|
i := 0
|
|
for i < len(data) && i < 3 && data[i] == ' ' {
|
|
i++
|
|
}
|
|
if i < len(data) && data[i] == '>' {
|
|
if i+1 < len(data) && (data[i+1] == ' ' || data[i+1] == '\t') {
|
|
return i + 2
|
|
}
|
|
return i + 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// parse a blockquote fragment
|
|
func blockQuote(out *bytes.Buffer, rndr *render, data []byte) int {
|
|
var block bytes.Buffer
|
|
var work bytes.Buffer
|
|
beg, end := 0, 0
|
|
for beg < len(data) {
|
|
for end = beg + 1; end < len(data) && data[end-1] != '\n'; end++ {
|
|
}
|
|
|
|
if pre := blockQuotePrefix(data[beg:]); pre > 0 {
|
|
beg += pre // skip prefix
|
|
} else {
|
|
// empty line followed by non-quote line
|
|
if isEmpty(data[beg:]) > 0 && (end >= len(data) || (blockQuotePrefix(data[end:]) == 0 && isEmpty(data[end:]) == 0)) {
|
|
break
|
|
}
|
|
}
|
|
|
|
if beg < end { // copy into the in-place working buffer
|
|
work.Write(data[beg:end])
|
|
}
|
|
beg = end
|
|
}
|
|
|
|
parseBlock(&block, rndr, work.Bytes())
|
|
if rndr.mk.BlockQuote != nil {
|
|
rndr.mk.BlockQuote(out, block.Bytes(), rndr.mk.Opaque)
|
|
}
|
|
return end
|
|
}
|
|
|
|
// returns prefix length for block code
|
|
func blockCodePrefix(data []byte) int {
|
|
if len(data) > 0 && data[0] == '\t' {
|
|
return 1
|
|
}
|
|
if len(data) > 3 && data[0] == ' ' && data[1] == ' ' && data[2] == ' ' && data[3] == ' ' {
|
|
return 4
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func blockCode(out *bytes.Buffer, rndr *render, data []byte) int {
|
|
var work bytes.Buffer
|
|
|
|
beg, end := 0, 0
|
|
for beg < len(data) {
|
|
for end = beg + 1; end < len(data) && data[end-1] != '\n'; end++ {
|
|
}
|
|
|
|
if pre := blockCodePrefix(data[beg:end]); pre > 0 {
|
|
beg += pre
|
|
} else {
|
|
if isEmpty(data[beg:end]) == 0 {
|
|
// non-empty non-prefixed line breaks the pre
|
|
break
|
|
}
|
|
}
|
|
|
|
if beg < end {
|
|
// verbatim copy to the working buffer, escaping entities
|
|
if isEmpty(data[beg:end]) > 0 {
|
|
work.WriteByte('\n')
|
|
} else {
|
|
work.Write(data[beg:end])
|
|
}
|
|
}
|
|
beg = end
|
|
}
|
|
|
|
// trim all the \n off the end of work
|
|
workbytes := work.Bytes()
|
|
n := 0
|
|
for len(workbytes) > n && workbytes[len(workbytes)-n-1] == '\n' {
|
|
n++
|
|
}
|
|
if n > 0 {
|
|
work.Truncate(len(workbytes) - n)
|
|
}
|
|
|
|
work.WriteByte('\n')
|
|
|
|
if rndr.mk.BlockCode != nil {
|
|
rndr.mk.BlockCode(out, work.Bytes(), "", rndr.mk.Opaque)
|
|
}
|
|
|
|
return beg
|
|
}
|
|
|
|
// returns unordered list item prefix
|
|
func blockUliPrefix(data []byte) int {
|
|
i := 0
|
|
|
|
// start with up to 3 spaces
|
|
for i < len(data) && i < 3 && data[i] == ' ' {
|
|
i++
|
|
}
|
|
|
|
// need a *, +, or - followed by a space/tab
|
|
if i+1 >= len(data) ||
|
|
(data[i] != '*' && data[i] != '+' && data[i] != '-') ||
|
|
(data[i+1] != ' ' && data[i+1] != '\t') {
|
|
return 0
|
|
}
|
|
return i + 2
|
|
}
|
|
|
|
// returns ordered list item prefix
|
|
func blockOliPrefix(data []byte) int {
|
|
i := 0
|
|
|
|
// start with up to 3 spaces
|
|
for i < len(data) && i < 3 && data[i] == ' ' {
|
|
i++
|
|
}
|
|
|
|
// count the digits
|
|
start := i
|
|
for i < len(data) && data[i] >= '0' && data[i] <= '9' {
|
|
i++
|
|
}
|
|
|
|
// we need >= 1 digits followed by a dot and a space/tab
|
|
if start == i || data[i] != '.' || i+1 >= len(data) ||
|
|
(data[i+1] != ' ' && data[i+1] != '\t') {
|
|
return 0
|
|
}
|
|
return i + 2
|
|
}
|
|
|
|
// parse ordered or unordered list block
|
|
func blockList(out *bytes.Buffer, rndr *render, data []byte, flags int) int {
|
|
i := 0
|
|
work := func() bool {
|
|
j := 0
|
|
for i < len(data) {
|
|
j = blockListItem(out, rndr, data[i:], &flags)
|
|
i += j
|
|
|
|
if j == 0 || flags&LIST_ITEM_END_OF_LIST != 0 {
|
|
break
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
if rndr.mk.List != nil {
|
|
rndr.mk.List(out, work, flags, rndr.mk.Opaque)
|
|
}
|
|
return i
|
|
}
|
|
|
|
// parse a single list item
|
|
// assumes initial prefix is already removed
|
|
func blockListItem(out *bytes.Buffer, rndr *render, data []byte, flags *int) int {
|
|
// keep track of the first indentation prefix
|
|
beg, end, pre, sublist, orgpre, i := 0, 0, 0, 0, 0, 0
|
|
|
|
for orgpre < 3 && orgpre < len(data) && data[orgpre] == ' ' {
|
|
orgpre++
|
|
}
|
|
|
|
beg = blockUliPrefix(data)
|
|
if beg == 0 {
|
|
beg = blockOliPrefix(data)
|
|
}
|
|
if beg == 0 {
|
|
return 0
|
|
}
|
|
|
|
// skip leading whitespace on first line
|
|
for beg < len(data) && (data[beg] == ' ' || data[beg] == '\t') {
|
|
beg++
|
|
}
|
|
|
|
// skip to the beginning of the following line
|
|
end = beg
|
|
for end < len(data) && data[end-1] != '\n' {
|
|
end++
|
|
}
|
|
|
|
// get working buffers
|
|
var work bytes.Buffer
|
|
var inter bytes.Buffer
|
|
|
|
// put the first line into the working buffer
|
|
work.Write(data[beg:end])
|
|
beg = end
|
|
|
|
// process the following lines
|
|
contains_blank_line, contains_block := false, false
|
|
for beg < len(data) {
|
|
end++
|
|
|
|
for end < len(data) && data[end-1] != '\n' {
|
|
end++
|
|
}
|
|
|
|
// process an empty line
|
|
if isEmpty(data[beg:end]) > 0 {
|
|
contains_blank_line = true
|
|
beg = end
|
|
continue
|
|
}
|
|
|
|
// calculate the indentation
|
|
i = 0
|
|
for i < 4 && beg+i < end && data[beg+i] == ' ' {
|
|
i++
|
|
}
|
|
|
|
pre = i
|
|
if data[beg] == '\t' {
|
|
i = 1
|
|
pre = TAB_SIZE_DEFAULT
|
|
if rndr.flags&EXTENSION_TAB_SIZE_EIGHT != 0 {
|
|
pre = TAB_SIZE_EIGHT
|
|
}
|
|
}
|
|
|
|
chunk := data[beg+i : end]
|
|
|
|
// check for a nested list item
|
|
if (blockUliPrefix(chunk) > 0 && !isHRule(chunk)) || blockOliPrefix(chunk) > 0 {
|
|
if contains_blank_line {
|
|
contains_block = true
|
|
}
|
|
|
|
// the following item must have the same indentation
|
|
if pre == orgpre {
|
|
break
|
|
}
|
|
|
|
if sublist == 0 {
|
|
sublist = work.Len()
|
|
}
|
|
} else {
|
|
// how about a nested prefix header?
|
|
if isPrefixHeader(rndr, chunk) {
|
|
// only nest headers that are indented
|
|
if contains_blank_line && i < 4 && data[beg] != '\t' {
|
|
*flags |= LIST_ITEM_END_OF_LIST
|
|
break
|
|
}
|
|
contains_block = true
|
|
} else {
|
|
// only join stuff after empty lines when indented
|
|
if contains_blank_line && i < 4 && data[beg] != '\t' {
|
|
*flags |= LIST_ITEM_END_OF_LIST
|
|
break
|
|
} else {
|
|
if contains_blank_line {
|
|
work.WriteByte('\n')
|
|
contains_block = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
contains_blank_line = false
|
|
|
|
// add the line into the working buffer without prefix
|
|
work.Write(data[beg+i : end])
|
|
beg = end
|
|
}
|
|
|
|
// render li contents
|
|
if contains_block {
|
|
*flags |= LIST_ITEM_CONTAINS_BLOCK
|
|
}
|
|
|
|
workbytes := work.Bytes()
|
|
if *flags&LIST_ITEM_CONTAINS_BLOCK != 0 {
|
|
// intermediate render of block li
|
|
if sublist > 0 && sublist < len(workbytes) {
|
|
parseBlock(&inter, rndr, workbytes[:sublist])
|
|
parseBlock(&inter, rndr, workbytes[sublist:])
|
|
} else {
|
|
parseBlock(&inter, rndr, workbytes)
|
|
}
|
|
} else {
|
|
// intermediate render of inline li
|
|
if sublist > 0 && sublist < len(workbytes) {
|
|
parseInline(&inter, rndr, workbytes[:sublist])
|
|
parseBlock(&inter, rndr, workbytes[sublist:])
|
|
} else {
|
|
parseInline(&inter, rndr, workbytes)
|
|
}
|
|
}
|
|
|
|
// render li itself
|
|
if rndr.mk.ListItem != nil {
|
|
rndr.mk.ListItem(out, inter.Bytes(), *flags, rndr.mk.Opaque)
|
|
}
|
|
|
|
return beg
|
|
}
|
|
|
|
// render a single paragraph that has already been parsed out
|
|
func renderParagraph(out *bytes.Buffer, rndr *render, data []byte) {
|
|
// trim leading whitespace
|
|
beg := 0
|
|
for beg < len(data) && isspace(data[beg]) {
|
|
beg++
|
|
}
|
|
|
|
// trim trailing whitespace
|
|
end := len(data)
|
|
for end > beg && isspace(data[end-1]) {
|
|
end--
|
|
}
|
|
if end == beg || rndr.mk.Paragraph == nil {
|
|
return
|
|
}
|
|
|
|
work := func() bool {
|
|
parseInline(out, rndr, data[beg:end])
|
|
return true
|
|
}
|
|
rndr.mk.Paragraph(out, work, rndr.mk.Opaque)
|
|
}
|
|
|
|
func blockParagraph(out *bytes.Buffer, rndr *render, data []byte) int {
|
|
// prev: index of 1st char of previous line
|
|
// line: index of 1st char of current line
|
|
// i: index of cursor/end of current line
|
|
var prev, line, i int
|
|
|
|
// keep going until we find something to mark the end of the paragraph
|
|
for i < len(data) {
|
|
// mark the beginning of the current line
|
|
prev = line
|
|
current := data[i:]
|
|
line = i
|
|
|
|
// did we find a blank line marking the end of the paragraph?
|
|
if n := isEmpty(current); n > 0 {
|
|
renderParagraph(out, rndr, data[:i])
|
|
return i + n
|
|
}
|
|
|
|
// an underline under some text marks a header, so our paragraph ended on prev line
|
|
if i > 0 && rndr.mk.Header != nil {
|
|
if level := isUnderlinedHeader(current); level > 0 {
|
|
// render the paragraph
|
|
renderParagraph(out, rndr, data[:prev])
|
|
|
|
// ignore leading and trailing whitespace
|
|
eol := i - 1
|
|
for prev < eol && (data[prev] == ' ' || data[prev] == '\t') {
|
|
prev++
|
|
}
|
|
for eol > prev && (data[eol-1] == ' ' || data[eol-1] == '\t') {
|
|
eol--
|
|
}
|
|
|
|
// render the header
|
|
// this ugly double closure avoids forcing variables onto the heap
|
|
work := func(o *bytes.Buffer, r *render, d []byte) func() bool {
|
|
return func() bool {
|
|
parseInline(o, r, d)
|
|
return true
|
|
}
|
|
}(out, rndr, data[prev:eol])
|
|
rndr.mk.Header(out, work, level, rndr.mk.Opaque)
|
|
|
|
// find the end of the underline
|
|
for ; i < len(data) && data[i] != '\n'; i++ {
|
|
}
|
|
return i
|
|
}
|
|
}
|
|
|
|
// if the next line starts a block of HTML, then the paragraph ends here
|
|
if rndr.flags&EXTENSION_LAX_HTML_BLOCKS != 0 {
|
|
if data[i] == '<' && rndr.mk.BlockHtml != nil && blockHtml(out, rndr, current, false) > 0 {
|
|
// rewind to before the HTML block
|
|
renderParagraph(out, rndr, data[:i])
|
|
return i
|
|
}
|
|
}
|
|
|
|
// if there's a prefixed header or a horizontal rule after this, paragraph is over
|
|
if isPrefixHeader(rndr, current) || isHRule(current) {
|
|
renderParagraph(out, rndr, data[:i])
|
|
return i
|
|
}
|
|
|
|
// otherwise, scan to the beginning of the next line
|
|
i++
|
|
for i < len(data) && data[i-1] != '\n' {
|
|
i++
|
|
}
|
|
}
|
|
|
|
renderParagraph(out, rndr, data[:i])
|
|
return i
|
|
}
|