"erb",
"fish",
"fortran",
+ "gdscript",
"gentoo-ebuild",
"gentoo-etc-portage",
"git-commit",
"privoxy-filter",
"puppet",
"python",
+ "r",
"reST",
"rpmspec",
"ruby",
// This involves finding the regex for syntax and if it exists, the regex
// for the header. Then we must get the text for the file and the filetype.
func LoadSyntaxFilesFromDir(dir string) {
+ colorscheme = make(Colorscheme)
InitColorscheme()
+ // Default style
+ defStyle = tcell.StyleDefault.
+ Foreground(tcell.ColorDefault).
+ Background(tcell.ColorDefault)
+
+ // There may be another default style defined in the colorscheme
+ // In that case we should use that one
+ if style, ok := colorscheme["default"]; ok {
+ defStyle = style
+ }
+ if screen != nil {
+ screen.SetStyle(defStyle)
+ }
+
syntaxFiles = make(map[[2]*regexp.Regexp]FileTypeRules)
files, _ := ioutil.ReadDir(dir)
for _, f := range files {
// in which case we should look that up in the colorscheme
// They can also just give us a straight up color
st := defStyle
- if _, ok := colorscheme[color]; ok {
- st = colorscheme[color]
+ groups := strings.Split(color, ".")
+ if len(groups) > 1 {
+ curGroup := ""
+ for i, g := range groups {
+ if i != 0 {
+ curGroup += "."
+ }
+ curGroup += g
+ if style, ok := colorscheme[curGroup]; ok {
+ st = style
+ }
+ }
+ } else if style, ok := colorscheme[color]; ok {
+ st = style
} else {
st = StringToStyle(color)
}
// and returns them. It also returns the filetype of the file
func GetRules(buf *Buffer) ([]SyntaxRule, string) {
for r := range syntaxFiles {
- if r[0] != nil && r[0].MatchString(buf.path) {
+ if r[0] != nil && r[0].MatchString(buf.Path) {
// Check if the syntax statement matches the extension
return LoadRulesFromFile(syntaxFiles[r].text, syntaxFiles[r].filename), syntaxFiles[r].filetype
- } else if r[1] != nil && r[1].MatchString(buf.lines[0]) {
+ } else if r[1] != nil && r[1].MatchString(buf.Line(0)) {
// Check if the header statement matches the first line
return LoadRulesFromFile(syntaxFiles[r].text, syntaxFiles[r].filename), syntaxFiles[r].filetype
}
// Match takes a buffer and returns the syntax matches: a 2d array specifying how it should be syntax highlighted
// We match the rules from up `synLinesUp` lines and down `synLinesDown` lines
func Match(v *View) SyntaxMatches {
- buf := v.buf
- rules := v.buf.rules
+ buf := v.Buf
+ rules := v.Buf.rules
- viewStart := v.topline
- viewEnd := v.topline + v.height
- if viewEnd > len(buf.lines) {
- viewEnd = len(buf.lines)
+ viewStart := v.Topline
+ viewEnd := v.Topline + v.height
+ if viewEnd > buf.NumLines {
+ viewEnd = buf.NumLines
}
- lines := buf.lines[viewStart:viewEnd]
+ lines := buf.Lines(viewStart, viewEnd)
matches := make(SyntaxMatches, len(lines))
for i, line := range lines {
matches[i] = make([]tcell.Style, len(line)+1)
+ for j, _ := range matches[i] {
+ matches[i][j] = defStyle
+ }
}
// We don't actually check the entire buffer, just from synLinesUp to synLinesDown
- totalStart := v.topline - synLinesUp
- totalEnd := v.topline + v.height + synLinesDown
+ totalStart := v.Topline - synLinesUp
+ totalEnd := v.Topline + v.height + synLinesDown
if totalStart < 0 {
totalStart = 0
}
- if totalEnd > len(buf.lines) {
- totalEnd = len(buf.lines)
+ if totalEnd > buf.NumLines {
+ totalEnd = buf.NumLines
}
- str := strings.Join(buf.lines[totalStart:totalEnd], "\n")
- startNum := ToCharPos(0, totalStart, v.buf)
+ str := strings.Join(buf.Lines(totalStart, totalEnd), "\n")
+ startNum := ToCharPos(Loc{0, totalStart}, v.Buf)
- toplineNum := ToCharPos(0, v.topline, v.buf)
+ toplineNum := ToCharPos(Loc{0, v.Topline}, v.Buf)
for _, rule := range rules {
if rule.startend {
if indicies := rule.regex.FindAllStringIndex(str, -1); indicies != nil {
for _, value := range indicies {
- value[0] += startNum
- value[1] += startNum
+ value[0] = runePos(value[0], str) + startNum
+ value[1] = runePos(value[1], str) + startNum
for i := value[0]; i < value[1]; i++ {
if i < toplineNum {
continue
}
- colNum, lineNum := FromCharPosStart(toplineNum, 0, v.topline, i, buf)
+ loc := FromCharPos(i, buf)
+ colNum, lineNum := loc.X, loc.Y
if lineNum == -1 || colNum == -1 {
continue
}
for lineN, line := range lines {
if indicies := rule.regex.FindAllStringIndex(line, -1); indicies != nil {
for _, value := range indicies {
- for i := value[0]; i < value[1]; i++ {
+ start := runePos(value[0], line)
+ end := runePos(value[1], line)
+ for i := start; i < end; i++ {
matches[lineN][i] = rule.style
}
}