Cleanup codes

Author: yuin

_benchmark/cmark/Makefile

@@ -4,39 +4,22 @@ ifeq ($(OS),Windows_NT)
   CMARK_BIN=cmark_benchmark.exe
   CMARK_RUN=bash -c "PATH=./cmark-master/build/src:$${PATH} ./$(CMARK_BIN)"
 endif
-ifneq ($(WSL_INTEROP),)
-  CMARK_BIN=cmark_benchmark.exe
-  CMARK_RUN=cp ./cmark-master/build-mingw/windows/bin/libcmark.dll . && ./$(CMARK_BIN); rm -f libcmark.dll
-endif
 
 .PHONY: run
 
 run: $(CMARK_BIN)
 	@ $(CMARK_RUN)
-	@ if [ -z "$${WSL_INTEROP}" ]; then \
-		go run ./goldmark_benchmark.go; \
-	else \
-		GOOS=windows GOARCH=amd64 go build -o goldmark_benchmark.exe ./goldmark_benchmark.go && ./goldmark_benchmark.exe; \
-	fi
+	go run ./goldmark_benchmark.go
 
 ./cmark-master/Makefile:
 	wget -nc -O cmark.zip https://github.com/commonmark/cmark/archive/master.zip
 	unzip cmark.zip
 	rm -f cmark.zip
-	@ if [ -z "$${WSL_INTEROP}" ]; then \
-		cd cmark-master && make; \
-	else \
-		cd cmark-master && make mingw; \
-	fi
+	cd cmark-master && make
 
-$(CMARK_BIN): ./cmark-master/Makefile
-	@ if [ -z "$${WSL_INTEROP}" ]; then \
-		gcc -I./cmark-master/build/src -I./cmark-master/src  cmark_benchmark.c -o $(CMARK_BIN) -L./cmark-master/build/src -lcmark; \
-	else \
-		i686-w64-mingw32-gcc -I./cmark-master/build-mingw/windows/include cmark_benchmark.c -o $(CMARK_BIN) -L./cmark-master/build-mingw/windows/lib -lcmark.dll; \
-	fi
+$(CMARK_BIN): ./cmark-master/Makefile cmark_benchmark.c
+	gcc -I./cmark-master/build/src -I./cmark-master/src  cmark_benchmark.c -o $(CMARK_BIN) -L./cmark-master/build/src -lcmark; \
 
 .PHONY: clean
 clean:
 	rm -f $(CMARK_BIN)
-	rm -f goldmark_benchmark.exe

ast/block.go

@@ -10,8 +10,8 @@ import (
 // A BaseBlock struct implements the Node interface partialliy.
 type BaseBlock struct {
 	BaseNode
+	lines              textm.Segments
 	blankPreviousLines bool
-	lines              *textm.Segments
 }
 
 // Type implements Node.Type.
@@ -36,15 +36,12 @@ func (b *BaseBlock) SetBlankPreviousLines(v bool) {
 
 // Lines implements Node.Lines.
 func (b *BaseBlock) Lines() *textm.Segments {
-	if b.lines == nil {
-		b.lines = textm.NewSegments()
-	}
-	return b.lines
+	return &b.lines
 }
 
 // SetLines implements Node.SetLines.
 func (b *BaseBlock) SetLines(v *textm.Segments) {
-	b.lines = v
+	b.lines = *v
 }
 
 // A Document struct is a root node of Markdown text.

parser/parser.go

@@ -1030,47 +1030,35 @@ type lineStat struct {
 }
 
 func isBlankLine(lineNum, level int, stats []lineStat) bool {
-	ret := true
-	for i := len(stats) - 1 - level; i >= 0; i-- {
-		ret = false
+	l := len(stats)
+	if l == 0 {
+		return true
+	}
+	for i := l - 1 - level; i >= 0; i-- {
 		s := stats[i]
-		if s.lineNum == lineNum {
-			if s.level < level && s.isBlank {
-				return true
-			} else if s.level == level {
-				return s.isBlank
-			}
-		}
-		if s.lineNum < lineNum {
-			return ret
+		if s.lineNum == lineNum && s.level <= level {
+			return s.isBlank
+		} else if s.lineNum < lineNum {
+			break
 		}
 	}
-	return ret
+	return false
 }
 
 func (p *parser) parseBlocks(parent ast.Node, reader text.Reader, pc Context) {
-	pc.SetOpenedBlocks([]Block{})
+	pc.SetOpenedBlocks(nil)
 	blankLines := make([]lineStat, 0, 128)
-	var isBlank bool
 	for { // process blocks separated by blank lines
-		_, lines, ok := reader.SkipBlankLines()
+		_, _, ok := reader.SkipBlankLines()
 		if !ok {
 			return
 		}
-		lineNum, _ := reader.Position()
-		if lines != 0 {
-			blankLines = blankLines[0:0]
-			l := len(pc.OpenedBlocks())
-			for i := 0; i < l; i++ {
-				blankLines = append(blankLines, lineStat{lineNum - 1, i, lines != 0})
-			}
-		}
-		isBlank = isBlankLine(lineNum-1, 0, blankLines)
 		// first, we try to open blocks
-		if p.openBlocks(parent, isBlank, reader, pc) != newBlocksOpened {
+		if p.openBlocks(parent, true, reader, pc) != newBlocksOpened {
 			return
 		}
 		reader.AdvanceLine()
+		blankLines = blankLines[0:0]
 		for { // process opened blocks line by line
 			openedBlocks := pc.OpenedBlocks()
 			l := len(openedBlocks)
@@ -1096,15 +1084,15 @@ func (p *parser) parseBlocks(parent ast.Node, reader text.Reader, pc Context) {
 						// When current node is a container block and has no children,
 						// we try to open new child nodes
 						if state&HasChildren != 0 && i == lastIndex {
-							isBlank = isBlankLine(lineNum-1, i+1, blankLines)
+							isBlank := isBlankLine(lineNum-1, i+1, blankLines)
 							p.openBlocks(be.Node, isBlank, reader, pc)
 							break
 						}
 						continue
 					}
 				}
 				// current node may be closed or lazy continuation
-				isBlank = isBlankLine(lineNum-1, i, blankLines)
+				isBlank := isBlankLine(lineNum-1, i, blankLines)
 				thisParent := parent
 				if i != 0 {
 					thisParent = openedBlocks[i-1].Node

text/reader.go

@@ -229,12 +229,9 @@ func (r *reader) AdvanceLine() {
 		return
 	}
 	r.pos.Stop = r.sourceLength
-	for i := r.pos.Start; i < r.sourceLength; i++ {
-		c := r.source[i]
-		if c == '\n' {
-			r.pos.Stop = i + 1
-			break
-		}
+	i := bytes.IndexByte(r.source[r.pos.Start:], '\n')
+	if i != -1 {
+		r.pos.Stop = r.pos.Start + i + 1
 	}
 	r.line++
 	r.pos.Padding = 0

text/segment.go

@@ -176,17 +176,11 @@ func NewSegments() *Segments {
 
 // Append appends the given segment after the tail of the collection.
 func (s *Segments) Append(t Segment) {
-	if s.values == nil {
-		s.values = make([]Segment, 0, 20)
-	}
 	s.values = append(s.values, t)
 }
 
 // AppendAll appends all elements of given segments after the tail of the collection.
 func (s *Segments) AppendAll(t []Segment) {
-	if s.values == nil {
-		s.values = make([]Segment, 0, 20)
-	}
 	s.values = append(s.values, t...)
 }