Store states in linearray

cmd/micro/buffer.go

@@ -385,7 +385,7 @@ func (b *Buffer) Start() Loc {
 
 // End returns the location of the last character in the buffer
 func (b *Buffer) End() Loc {
-	return Loc{utf8.RuneCount(b.lines[b.NumLines-1]), b.NumLines - 1}
+	return Loc{utf8.RuneCount(b.lines[b.NumLines-1].data), b.NumLines - 1}
 }
 
 // RuneAt returns the rune at a given location in the buffer
@@ -402,7 +402,7 @@ func (b *Buffer) Line(n int) string {
 	if n >= len(b.lines) {
 		return ""
 	}
-	return string(b.lines[n])
+	return string(b.lines[n].data)
 }
 
 // Lines returns an array of strings containing the lines from start to end
@@ -410,7 +410,7 @@ func (b *Buffer) Lines(start, end int) []string {
 	lines := b.lines[start:end]
 	var slice []string
 	for _, line := range lines {
-		slice = append(slice, string(line))
+		slice = append(slice, string(line.data))
 	}
 	return slice
 }
@@ -429,7 +429,7 @@ func (b *Buffer) MoveLinesUp(start int, end int) {
 	if end == len(b.lines) {
 		b.Insert(
 			Loc{
-				utf8.RuneCount(b.lines[end-1]),
+				utf8.RuneCount(b.lines[end-1].data),
 				end - 1,
 			},
 			"\n"+b.Line(start-1),

cmd/micro/cellview.go

@@ -58,7 +58,7 @@ func (c *CellView) Draw(buf *Buffer, top, height, left, width int) {
 			break
 		}
 
-		lineStr := string(buf.lines[lineN])
+		lineStr := buf.Line(lineN)
 		line := []rune(lineStr)
 
 		colN := VisualToCharPos(left, lineStr, tabsize)

cmd/micro/lineArray.go

@@ -2,9 +2,10 @@ package main
 
 import (
 	"bufio"
-	"bytes"
 	"io"
 	"unicode/utf8"
+
+	"github.com/zyedidia/highlight"
 )
 
 func runeToByteIndex(n int, txt []byte) int {
@@ -28,10 +29,16 @@ func runeToByteIndex(n int, txt []byte) int {
 	return count
 }
 
+type Line struct {
+	data []byte
+
+	state highlight.State
+}
+
 // A LineArray simply stores and array of lines and makes it easy to insert
 // and delete in it
 type LineArray struct {
-	lines [][]byte
+	lines []Line
 }
 
 // NewLineArray returns a new line array from an array of bytes
@@ -44,12 +51,12 @@ func NewLineArray(reader io.Reader) *LineArray {
 		data, err := br.ReadBytes('\n')
 		if err != nil {
 			if err == io.EOF {
-				la.lines = append(la.lines, data[:])
+				la.lines = append(la.lines, Line{data[:len(data)], nil})
 			}
 			// Last line was read
 			break
 		} else {
-			la.lines = append(la.lines, data[:len(data)-1])
+			la.lines = append(la.lines, Line{data[:len(data)-1], nil})
 		}
 		i++
 	}
@@ -59,19 +66,26 @@ func NewLineArray(reader io.Reader) *LineArray {
 
 // Returns the String representation of the LineArray
 func (la *LineArray) String() string {
-	return string(bytes.Join(la.lines, []byte("\n")))
+	str := ""
+	for i, l := range la.lines {
+		str += string(l.data)
+		if i != len(la.lines)-1 {
+			str += "\n"
+		}
+	}
+	return str
 }
 
 // NewlineBelow adds a newline below the given line number
 func (la *LineArray) NewlineBelow(y int) {
-	la.lines = append(la.lines, []byte(" "))
+	la.lines = append(la.lines, Line{[]byte(" "), nil})
 	copy(la.lines[y+2:], la.lines[y+1:])
-	la.lines[y+1] = []byte("")
+	la.lines[y+1] = Line{[]byte(""), nil}
 }
 
 // inserts a byte array at a given location
 func (la *LineArray) insert(pos Loc, value []byte) {
-	x, y := runeToByteIndex(pos.X, la.lines[pos.Y]), pos.Y
+	x, y := runeToByteIndex(pos.X, la.lines[pos.Y].data), pos.Y
 	// x, y := pos.x, pos.y
 	for i := 0; i < len(value); i++ {
 		if value[i] == '\n' {
@@ -87,31 +101,32 @@ func (la *LineArray) insert(pos Loc, value []byte) {
 
 // inserts a byte at a given location
 func (la *LineArray) insertByte(pos Loc, value byte) {
-	la.lines[pos.Y] = append(la.lines[pos.Y], 0)
-	copy(la.lines[pos.Y][pos.X+1:], la.lines[pos.Y][pos.X:])
-	la.lines[pos.Y][pos.X] = value
+	la.lines[pos.Y].data = append(la.lines[pos.Y].data, 0)
+	copy(la.lines[pos.Y].data[pos.X+1:], la.lines[pos.Y].data[pos.X:])
+	la.lines[pos.Y].data[pos.X] = value
 }
 
 // JoinLines joins the two lines a and b
 func (la *LineArray) JoinLines(a, b int) {
-	la.insert(Loc{len(la.lines[a]), a}, la.lines[b])
+	la.insert(Loc{len(la.lines[a].data), a}, la.lines[b].data)
 	la.DeleteLine(b)
 }
 
 // Split splits a line at a given position
 func (la *LineArray) Split(pos Loc) {
 	la.NewlineBelow(pos.Y)
-	la.insert(Loc{0, pos.Y + 1}, la.lines[pos.Y][pos.X:])
+	la.insert(Loc{0, pos.Y + 1}, la.lines[pos.Y].data[pos.X:])
+	la.lines[pos.Y+1].state = la.lines[pos.Y].state
 	la.DeleteToEnd(Loc{pos.X, pos.Y})
 }
 
 // removes from start to end
 func (la *LineArray) remove(start, end Loc) string {
 	sub := la.Substr(start, end)
-	startX := runeToByteIndex(start.X, la.lines[start.Y])
-	endX := runeToByteIndex(end.X, la.lines[end.Y])
+	startX := runeToByteIndex(start.X, la.lines[start.Y].data)
+	endX := runeToByteIndex(end.X, la.lines[end.Y].data)
 	if start.Y == end.Y {
-		la.lines[start.Y] = append(la.lines[start.Y][:startX], la.lines[start.Y][endX:]...)
+		la.lines[start.Y].data = append(la.lines[start.Y].data[:startX], la.lines[start.Y].data[endX:]...)
 	} else {
 		for i := start.Y + 1; i <= end.Y-1; i++ {
 			la.DeleteLine(start.Y + 1)
@@ -125,12 +140,12 @@ func (la *LineArray) remove(start, end Loc) string {
 
 // DeleteToEnd deletes from the end of a line to the position
 func (la *LineArray) DeleteToEnd(pos Loc) {
-	la.lines[pos.Y] = la.lines[pos.Y][:pos.X]
+	la.lines[pos.Y].data = la.lines[pos.Y].data[:pos.X]
 }
 
 // DeleteFromStart deletes from the start of a line to the position
 func (la *LineArray) DeleteFromStart(pos Loc) {
-	la.lines[pos.Y] = la.lines[pos.Y][pos.X+1:]
+	la.lines[pos.Y].data = la.lines[pos.Y].data[pos.X+1:]
 }
 
 // DeleteLine deletes the line number
@@ -140,21 +155,21 @@ func (la *LineArray) DeleteLine(y int) {
 
 // DeleteByte deletes the byte at a position
 func (la *LineArray) DeleteByte(pos Loc) {
-	la.lines[pos.Y] = la.lines[pos.Y][:pos.X+copy(la.lines[pos.Y][pos.X:], la.lines[pos.Y][pos.X+1:])]
+	la.lines[pos.Y].data = la.lines[pos.Y].data[:pos.X+copy(la.lines[pos.Y].data[pos.X:], la.lines[pos.Y].data[pos.X+1:])]
 }
 
 // Substr returns the string representation between two locations
 func (la *LineArray) Substr(start, end Loc) string {
-	startX := runeToByteIndex(start.X, la.lines[start.Y])
-	endX := runeToByteIndex(end.X, la.lines[end.Y])
+	startX := runeToByteIndex(start.X, la.lines[start.Y].data)
+	endX := runeToByteIndex(end.X, la.lines[end.Y].data)
 	if start.Y == end.Y {
-		return string(la.lines[start.Y][startX:endX])
+		return string(la.lines[start.Y].data[startX:endX])
 	}
 	var str string
-	str += string(la.lines[start.Y][startX:]) + "\n"
+	str += string(la.lines[start.Y].data[startX:]) + "\n"
 	for i := start.Y + 1; i <= end.Y-1; i++ {
-		str += string(la.lines[i]) + "\n"
+		str += string(la.lines[i].data) + "\n"
 	}
-	str += string(la.lines[end.Y][:endX])
+	str += string(la.lines[end.Y].data[:endX])
 	return str
 }