Major optimization for loading syntax files

cmd/micro/highlighter.go

@@ -11,7 +11,8 @@ import (
 // FileTypeRules represents a complete set of syntax rules for a filetype
 type FileTypeRules struct {
 	filetype string
-	rules    []SyntaxRule
+	filename string
+	text     string
 }
 
 // SyntaxRule represents a regex to highlight in a certain style
@@ -49,8 +50,11 @@ var preInstalledSynFiles = []string{
 	"erb",
 	"fish",
 	"fortran",
-	"gentoo",
-	"git",
+	"gentoo-ebuild",
+	"gentoo-etc-portage",
+	"git-commit",
+	"git-config",
+	"git-rebase-todo",
 	"glsl",
 	"go",
 	"groff",
@@ -83,7 +87,9 @@ var preInstalledSynFiles = []string{
 	"pkgbuild",
 	"po",
 	"pov",
-	"privoxy",
+	"privoxy-action",
+	"privoxy-config",
+	"privoxy-filter",
 	"puppet",
 	"python",
 	"reST",
@@ -170,15 +176,9 @@ func LoadSyntaxFile(text, filename string) {
 	// Regex for parsing header statements
 	headerParser := regexp.MustCompile(`header "(.*)"`)
 
-	// Regex for parsing standard syntax rules
-	ruleParser := regexp.MustCompile(`color (.*?)\s+(?:\((.*?)\)\s+)?"(.*)"`)
-	// Regex for parsing syntax rules with start="..." end="..."
-	ruleStartEndParser := regexp.MustCompile(`color (.*?)\s+(?:\((.*?)\)\s+)?start="(.*)"\s+end="(.*)"`)
-
 	var syntaxRegex *regexp.Regexp
 	var headerRegex *regexp.Regexp
 	var filetype string
-	var rules []SyntaxRule
 	for lineNum, line := range lines {
 		if strings.TrimSpace(line) == "" ||
 			strings.TrimSpace(line)[0] == '#' {
@@ -191,11 +191,8 @@ func LoadSyntaxFile(text, filename string) {
 			syntaxMatches := syntaxParser.FindSubmatch([]byte(line))
 			if len(syntaxMatches) == 3 {
 				if syntaxRegex != nil {
-					// Add the current rules to the syntaxFiles variable
-					regexes := [2]*regexp.Regexp{syntaxRegex, headerRegex}
-					syntaxFiles[regexes] = FileTypeRules{filetype, rules}
+					TermError(filename, lineNum, "Syntax statement redeclaration")
 				}
-				rules = rules[:0]
 
 				filetype = string(syntaxMatches[1])
 				extensions := JoinRule(string(syntaxMatches[2]))
@@ -224,112 +221,135 @@ func LoadSyntaxFile(text, filename string) {
 				TermError(filename, lineNum, "Header statement is not valid: "+line)
 				continue
 			}
-		} else {
-			// Syntax rule, but it could be standard or start-end
-			if ruleParser.MatchString(line) {
-				// Standard syntax rule
-				// Parse the line
-				submatch := ruleParser.FindSubmatch([]byte(line))
-				var color string
-				var regexStr string
-				var flags string
-				if len(submatch) == 4 {
-					// If len is 4 then the user specified some additional flags to use
-					color = string(submatch[1])
-					flags = string(submatch[2])
-					regexStr = "(?" + flags + ")" + JoinRule(string(submatch[3]))
-				} else if len(submatch) == 3 {
-					// If len is 3, no additional flags were given
-					color = string(submatch[1])
-					regexStr = JoinRule(string(submatch[2]))
-				} else {
-					// If len is not 3 or 4 there is a problem
-					TermError(filename, lineNum, "Invalid statement: "+line)
-					continue
-				}
-				// Compile the regex
-				regex, err := regexp.Compile(regexStr)
-				if err != nil {
-					TermError(filename, lineNum, err.Error())
-					continue
-				}
-
-				// Get the style
-				// The user could give us a "color" that is really a part of the colorscheme
-				// 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]
-				} else {
-					st = StringToStyle(color)
-				}
-				// Add the regex, flags, and style
-				// False because this is not start-end
-				rules = append(rules, SyntaxRule{regex, flags, false, st})
-			} else if ruleStartEndParser.MatchString(line) {
-				// Start-end syntax rule
-				submatch := ruleStartEndParser.FindSubmatch([]byte(line))
-				var color string
-				var start string
-				var end string
-				// Use m and s flags by default
-				flags := "ms"
-				if len(submatch) == 5 {
-					// If len is 5 the user provided some additional flags
-					color = string(submatch[1])
-					flags += string(submatch[2])
-					start = string(submatch[3])
-					end = string(submatch[4])
-				} else if len(submatch) == 4 {
-					// If len is 4 the user did not provide additional flags
-					color = string(submatch[1])
-					start = string(submatch[2])
-					end = string(submatch[3])
-				} else {
-					// If len is not 4 or 5 there is a problem
-					TermError(filename, lineNum, "Invalid statement: "+line)
-					continue
-				}
-
-				// Compile the regex
-				regex, err := regexp.Compile("(?" + flags + ")" + "(" + start + ").*?(" + end + ")")
-				if err != nil {
-					TermError(filename, lineNum, err.Error())
-					continue
-				}
-
-				// Get the style
-				// The user could give us a "color" that is really a part of the colorscheme
-				// 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]
-				} else {
-					st = StringToStyle(color)
-				}
-				// Add the regex, flags, and style
-				// True because this is start-end
-				rules = append(rules, SyntaxRule{regex, flags, true, st})
-			}
 		}
 	}
 	if syntaxRegex != nil {
 		// Add the current rules to the syntaxFiles variable
 		regexes := [2]*regexp.Regexp{syntaxRegex, headerRegex}
-		syntaxFiles[regexes] = FileTypeRules{filetype, rules}
+		syntaxFiles[regexes] = FileTypeRules{filetype, filename, text}
 	}
 }
 
+func LoadRulesFromFile(text, filename string) []SyntaxRule {
+	lines := strings.Split(string(text), "\n")
+
+	// Regex for parsing standard syntax rules
+	ruleParser := regexp.MustCompile(`color (.*?)\s+(?:\((.*?)\)\s+)?"(.*)"`)
+	// Regex for parsing syntax rules with start="..." end="..."
+	ruleStartEndParser := regexp.MustCompile(`color (.*?)\s+(?:\((.*?)\)\s+)?start="(.*)"\s+end="(.*)"`)
+
+	var rules []SyntaxRule
+	for lineNum, line := range lines {
+		if strings.TrimSpace(line) == "" ||
+			strings.TrimSpace(line)[0] == '#' ||
+			strings.HasPrefix(line, "syntax") ||
+			strings.HasPrefix(line, "header") {
+			// Ignore this line
+			continue
+		}
+
+		// Syntax rule, but it could be standard or start-end
+		if ruleParser.MatchString(line) {
+			// Standard syntax rule
+			// Parse the line
+			submatch := ruleParser.FindSubmatch([]byte(line))
+			var color string
+			var regexStr string
+			var flags string
+			if len(submatch) == 4 {
+				// If len is 4 then the user specified some additional flags to use
+				color = string(submatch[1])
+				flags = string(submatch[2])
+				regexStr = "(?" + flags + ")" + JoinRule(string(submatch[3]))
+			} else if len(submatch) == 3 {
+				// If len is 3, no additional flags were given
+				color = string(submatch[1])
+				regexStr = JoinRule(string(submatch[2]))
+			} else {
+				// If len is not 3 or 4 there is a problem
+				TermError(filename, lineNum, "Invalid statement: "+line)
+				continue
+			}
+			// Compile the regex
+			regex, err := regexp.Compile(regexStr)
+			if err != nil {
+				TermError(filename, lineNum, err.Error())
+				continue
+			}
+
+			// Get the style
+			// The user could give us a "color" that is really a part of the colorscheme
+			// 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]
+			} else {
+				st = StringToStyle(color)
+			}
+			// Add the regex, flags, and style
+			// False because this is not start-end
+			rules = append(rules, SyntaxRule{regex, flags, false, st})
+		} else if ruleStartEndParser.MatchString(line) {
+			// Start-end syntax rule
+			submatch := ruleStartEndParser.FindSubmatch([]byte(line))
+			var color string
+			var start string
+			var end string
+			// Use m and s flags by default
+			flags := "ms"
+			if len(submatch) == 5 {
+				// If len is 5 the user provided some additional flags
+				color = string(submatch[1])
+				flags += string(submatch[2])
+				start = string(submatch[3])
+				end = string(submatch[4])
+			} else if len(submatch) == 4 {
+				// If len is 4 the user did not provide additional flags
+				color = string(submatch[1])
+				start = string(submatch[2])
+				end = string(submatch[3])
+			} else {
+				// If len is not 4 or 5 there is a problem
+				TermError(filename, lineNum, "Invalid statement: "+line)
+				continue
+			}
+
+			// Compile the regex
+			regex, err := regexp.Compile("(?" + flags + ")" + "(" + start + ").*?(" + end + ")")
+			if err != nil {
+				TermError(filename, lineNum, err.Error())
+				continue
+			}
+
+			// Get the style
+			// The user could give us a "color" that is really a part of the colorscheme
+			// 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]
+			} else {
+				st = StringToStyle(color)
+			}
+			// Add the regex, flags, and style
+			// True because this is start-end
+			rules = append(rules, SyntaxRule{regex, flags, true, st})
+		}
+	}
+	return rules
+}
+
 // GetRules finds the syntax rules that should be used for the buffer
 // 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) {
-			return syntaxFiles[r].rules, syntaxFiles[r].filetype
+			// 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]) {
-			return syntaxFiles[r].rules, syntaxFiles[r].filetype
+			// Check if the header statement matches the first line
+			return LoadRulesFromFile(syntaxFiles[r].text, syntaxFiles[r].filename), syntaxFiles[r].filetype
 		}
 	}
 	return nil, "Unknown"