326 lines
6.5 KiB
Go
326 lines
6.5 KiB
Go
package document
|
|
|
|
import (
|
|
"strings"
|
|
"timshome.page/gilo/char"
|
|
"timshome.page/gilo/editor/highlight"
|
|
"timshome.page/gilo/internal/gilo"
|
|
)
|
|
|
|
type Row struct {
|
|
parent *Document
|
|
chars []rune
|
|
render []rune
|
|
Hl []int
|
|
}
|
|
|
|
func newRow(parent *Document, s string) *Row {
|
|
var chars []rune
|
|
var render []rune
|
|
|
|
for _, ch := range s {
|
|
chars = append(chars, ch)
|
|
render = append(render, ch)
|
|
}
|
|
|
|
return &Row{parent, chars, render, []int{}}
|
|
}
|
|
|
|
func (r *Row) Size() int {
|
|
return len(r.chars)
|
|
}
|
|
|
|
// RenderSize is a convenient equivalent of row->rsize in kilo
|
|
func (r *Row) RenderSize() int {
|
|
return len(r.render)
|
|
}
|
|
|
|
func (r *Row) Render(at *gilo.Point) string {
|
|
return string(r.render[at.X:])
|
|
}
|
|
|
|
// RenderRune returns the array of runes in the current row. Unlike a string
|
|
// this will index how you expect with multi-byte characters
|
|
func (r *Row) RenderRune(at *gilo.Point) []rune {
|
|
return r.render[at.X:]
|
|
}
|
|
|
|
func (r *Row) Search(query string) int {
|
|
return strings.Index(string(r.render), query)
|
|
}
|
|
|
|
func (r *Row) insertRune(ch rune, at int) {
|
|
// If insertion index is invalid, just
|
|
// append the rune to the end of the array
|
|
if at < 0 || at >= r.Size() {
|
|
r.chars = append(r.chars, ch)
|
|
r.update()
|
|
|
|
return
|
|
}
|
|
|
|
var newSlice []rune
|
|
|
|
// Split the character array at the insertion point
|
|
start := r.chars[0:at]
|
|
end := r.chars[at:r.Size()]
|
|
|
|
// Splice it back together
|
|
newSlice = append(newSlice, start...)
|
|
newSlice = append(newSlice, ch)
|
|
newSlice = append(newSlice, end...)
|
|
|
|
r.chars = newSlice
|
|
r.update()
|
|
}
|
|
|
|
func (r *Row) appendString(str string) {
|
|
for _, ch := range str {
|
|
r.chars = append(r.chars, ch)
|
|
}
|
|
|
|
r.update()
|
|
}
|
|
|
|
func (r *Row) deleteRune(at int) {
|
|
if at < 0 || at >= r.Size() {
|
|
return
|
|
}
|
|
|
|
var newSlice []rune
|
|
|
|
// Split the character array at the insertion point
|
|
start := r.chars[0:at]
|
|
end := r.chars[at+1 : r.Size()] // Skip the index in question
|
|
|
|
// Splice it back together
|
|
newSlice = append(newSlice, start...)
|
|
newSlice = append(newSlice, end...)
|
|
|
|
r.chars = newSlice
|
|
r.update()
|
|
}
|
|
|
|
func (r *Row) update() {
|
|
r.render = r.render[:0]
|
|
replacement := strings.Repeat(" ", gilo.TabSize)
|
|
|
|
str := strings.ReplaceAll(string(r.chars), "\t", replacement)
|
|
for _, ch := range str {
|
|
r.render = append(r.render, ch)
|
|
}
|
|
|
|
r.updateSyntax()
|
|
}
|
|
|
|
// updateSyntax is the equivalent of editorUpdateSyntax in kilo
|
|
// this is basically the core syntax highlighting algorithm
|
|
func (r *Row) updateSyntax() {
|
|
i := 0
|
|
s := r.parent.Syntax
|
|
r.Hl = make([]int, r.RenderSize())
|
|
for x := range r.Hl {
|
|
r.Hl[x] = highlight.Normal
|
|
}
|
|
|
|
// Don't bother updating the syntax if there isn't any
|
|
if s == nil {
|
|
return
|
|
}
|
|
|
|
renderStr := string(r.render)
|
|
renderLen := r.RenderSize()
|
|
keywords1 := s.Keywords1
|
|
keywords2 := s.Keywords2
|
|
|
|
// Scan for comments
|
|
var scsIndex int = -1
|
|
var mcsIndex int = -1
|
|
var mceIndex int = -1
|
|
scs := s.LineCommentStart
|
|
mcs := s.MultilineCommentStart
|
|
mce := s.MultilineCommentEnd
|
|
hasMcs := len(mcs) > 0
|
|
hasMce := len(mce) > 0
|
|
if len(scs) > 0 {
|
|
scsIndex = strings.Index(renderStr, scs)
|
|
}
|
|
if hasMcs {
|
|
mcsIndex = strings.Index(renderStr, mcs)
|
|
}
|
|
if hasMce {
|
|
mceIndex = strings.Index(renderStr, mce)
|
|
}
|
|
|
|
prevSep := true
|
|
inString := '0'
|
|
inComment := false
|
|
for i < r.RenderSize() {
|
|
ch := r.render[i]
|
|
prevHl := highlight.Normal
|
|
if i > 0 {
|
|
prevHl = r.Hl[i-1]
|
|
}
|
|
|
|
ip1 := i + 1
|
|
|
|
// Single line comments
|
|
if inString == '0' && !inComment && scsIndex == i {
|
|
for j := scsIndex; j < renderLen; j++ {
|
|
r.Hl[j] = highlight.Comment
|
|
}
|
|
break
|
|
}
|
|
|
|
// Multiline comments
|
|
if hasMcs && hasMce && inString == '0' {
|
|
if inComment {
|
|
r.Hl[i] = highlight.MLComment
|
|
// We found the end of the multiline comment
|
|
if mceIndex == i {
|
|
for j := i; j < (i + len(mce)); j++ {
|
|
r.Hl[j] = highlight.MLComment
|
|
}
|
|
i += len(mce)
|
|
inComment = false
|
|
prevSep = true
|
|
continue
|
|
}
|
|
|
|
i++
|
|
continue
|
|
}
|
|
|
|
// Found the start of the multiline comment
|
|
if mcsIndex == i {
|
|
for j := i; j < (i + len(mce)); j++ {
|
|
r.Hl[j] = highlight.MLComment
|
|
}
|
|
i += len(mcs)
|
|
inComment = true
|
|
continue
|
|
}
|
|
}
|
|
|
|
// String literals
|
|
if s.Flags&highlight.DoStrings == highlight.DoStrings {
|
|
// At the start of a string literal
|
|
if inString == '0' && (ch == char.DoubleQuote || ch == char.SingleQuote) {
|
|
inString = ch
|
|
r.Hl[i] = highlight.String
|
|
i++
|
|
continue
|
|
}
|
|
|
|
// In an existing string
|
|
if inString != '0' {
|
|
r.Hl[i] = highlight.String
|
|
|
|
// Handle when a quote is escaped inside a string
|
|
if ch == char.Backslash && ip1 < renderLen {
|
|
r.Hl[ip1] = highlight.String
|
|
i += 2
|
|
continue
|
|
}
|
|
|
|
// This quote mark matches the beginning of the string
|
|
// so now the string is completed
|
|
if ch == inString {
|
|
inString = '0'
|
|
}
|
|
|
|
i++
|
|
prevSep = true
|
|
continue
|
|
}
|
|
}
|
|
|
|
// Numeric literals
|
|
if s.Flags&highlight.DoNumbers == highlight.DoNumbers {
|
|
if (char.IsDigit(ch) && prevSep) ||
|
|
(char.IsNumeric(ch) && prevHl == highlight.Number) {
|
|
r.Hl[i] = highlight.Number
|
|
i += 1
|
|
prevSep = false
|
|
continue
|
|
}
|
|
}
|
|
|
|
// Keywords
|
|
if prevSep {
|
|
matched := false
|
|
|
|
keywordLoop:
|
|
for n, list := range [][]string{keywords1, keywords2} {
|
|
hlType := highlight.Keyword1
|
|
if n == 1 {
|
|
hlType = highlight.Keyword2
|
|
}
|
|
|
|
for _, word := range list {
|
|
wordLen := len(word)
|
|
nextInd := i + wordLen
|
|
endMatch := renderStr[i:renderLen] == word
|
|
goodMatch := nextInd < renderLen && renderStr[i:nextInd] == word
|
|
|
|
if endMatch || (goodMatch && char.IsSeparator(r.render[nextInd])) {
|
|
for k := i; k < nextInd; k++ {
|
|
r.Hl[k] = hlType
|
|
}
|
|
i += wordLen
|
|
matched = true
|
|
break keywordLoop
|
|
}
|
|
}
|
|
}
|
|
|
|
if matched {
|
|
prevSep = false
|
|
continue
|
|
}
|
|
}
|
|
|
|
prevSep = char.IsSeparator(ch)
|
|
i++
|
|
}
|
|
}
|
|
|
|
func (r *Row) toString() string {
|
|
return string(r.chars)
|
|
}
|
|
|
|
// CursorXToRenderX is the equivalent of editorRowCxToRx in kilo
|
|
func (r *Row) CursorXToRenderX(cursorX int) (renderX int) {
|
|
renderX = 0
|
|
|
|
for i := 0; i < cursorX; i++ {
|
|
if r.chars[i] == '\t' {
|
|
renderX += (gilo.TabSize - 1) - (renderX % gilo.TabSize)
|
|
}
|
|
|
|
renderX += 1
|
|
}
|
|
|
|
return renderX
|
|
}
|
|
|
|
// RenderXtoCursorX is the equivalent of editorRowRxToCx in kilo
|
|
func (r *Row) RenderXtoCursorX(renderX int) (cursorX int) {
|
|
currentRenderX := 0
|
|
cursorX = 0
|
|
|
|
for cursorX = 0; cursorX < r.Size(); cursorX++ {
|
|
if r.chars[cursorX] == '\t' {
|
|
currentRenderX += (gilo.TabSize - 1) - (currentRenderX % gilo.TabSize)
|
|
} else {
|
|
currentRenderX += 1
|
|
}
|
|
|
|
if currentRenderX > renderX {
|
|
return cursorX
|
|
}
|
|
}
|
|
|
|
return cursorX
|
|
}
|