mirror of
https://github.com/alecthomas/chroma.git
synced 2025-03-17 20:58:08 +02:00
Add NewLazyLexer to defer rules definitions and reduce init costs (#449)
Add NewLazyLexer and MustNewLazyLexer which accept a function that returns the rules for the lexer. This allows us to defer the rules definitions until they're needed. Lexers in a, g, s, and x packages have been updated to use the new lazy lexer.
This commit is contained in:
parent
5da831672d
commit
59126c5b32
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// ABAP lexer.
|
||||
var Abap = internal.Register(MustNewLexer(
|
||||
var Abap = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "ABAP",
|
||||
Aliases: []string{"abap"},
|
||||
@ -14,7 +14,11 @@ var Abap = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-abap"},
|
||||
CaseInsensitive: true,
|
||||
},
|
||||
Rules{
|
||||
abapRules,
|
||||
))
|
||||
|
||||
func abapRules() Rules {
|
||||
return Rules{
|
||||
"common": {
|
||||
{`\s+`, Text, nil},
|
||||
{`^\*.*$`, CommentSingle, nil},
|
||||
@ -52,5 +56,5 @@ var Abap = internal.Register(MustNewLexer(
|
||||
{`[/;:()\[\],.]`, Punctuation, nil},
|
||||
{`(!)(\w+)`, ByGroups(Operator, Name), nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Abnf lexer.
|
||||
var Abnf = internal.Register(MustNewLexer(
|
||||
var Abnf = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "ABNF",
|
||||
Aliases: []string{"abnf"},
|
||||
Filenames: []string{"*.abnf"},
|
||||
MimeTypes: []string{"text/x-abnf"},
|
||||
},
|
||||
Rules{
|
||||
abnfRules,
|
||||
))
|
||||
|
||||
func abnfRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`;.*$`, CommentSingle, nil},
|
||||
{`(%[si])?"[^"]*"`, Literal, nil},
|
||||
@ -34,5 +38,5 @@ var Abnf = internal.Register(MustNewLexer(
|
||||
{`\s+`, Text, nil},
|
||||
{`.`, Text, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Actionscript lexer.
|
||||
var Actionscript = internal.Register(MustNewLexer(
|
||||
var Actionscript = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "ActionScript",
|
||||
Aliases: []string{"as", "actionscript"},
|
||||
@ -15,7 +15,11 @@ var Actionscript = internal.Register(MustNewLexer(
|
||||
NotMultiline: true,
|
||||
DotAll: true,
|
||||
},
|
||||
Rules{
|
||||
actionscriptRules,
|
||||
))
|
||||
|
||||
func actionscriptRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\s+`, Text, nil},
|
||||
{`//.*?\n`, CommentSingle, nil},
|
||||
@ -35,5 +39,5 @@ var Actionscript = internal.Register(MustNewLexer(
|
||||
{`"(\\\\|\\"|[^"])*"`, LiteralStringDouble, nil},
|
||||
{`'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Actionscript 3 lexer.
|
||||
var Actionscript3 = internal.Register(MustNewLexer(
|
||||
var Actionscript3 = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "ActionScript 3",
|
||||
Aliases: []string{"as3", "actionscript3"},
|
||||
@ -14,7 +14,11 @@ var Actionscript3 = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"application/x-actionscript3", "text/x-actionscript3", "text/actionscript3"},
|
||||
DotAll: true,
|
||||
},
|
||||
Rules{
|
||||
actionscript3Rules,
|
||||
))
|
||||
|
||||
func actionscript3Rules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\s+`, Text, nil},
|
||||
{`(function\s+)([$a-zA-Z_]\w*)(\s*)(\()`, ByGroups(KeywordDeclaration, NameFunction, Text, Operator), Push("funcparams")},
|
||||
@ -52,5 +56,5 @@ var Actionscript3 = internal.Register(MustNewLexer(
|
||||
{`,`, Operator, Pop(1)},
|
||||
Default(Pop(1)),
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Ada lexer.
|
||||
var Ada = internal.Register(MustNewLexer(
|
||||
var Ada = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Ada",
|
||||
Aliases: []string{"ada", "ada95", "ada2005"},
|
||||
@ -14,7 +14,11 @@ var Ada = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-ada"},
|
||||
CaseInsensitive: true,
|
||||
},
|
||||
Rules{
|
||||
adaRules,
|
||||
))
|
||||
|
||||
func adaRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`[^\S\n]+`, Text, nil},
|
||||
{`--.*?\n`, CommentSingle, nil},
|
||||
@ -110,5 +114,5 @@ var Ada = internal.Register(MustNewLexer(
|
||||
{`\)`, Punctuation, Pop(1)},
|
||||
Include("root"),
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Angular2 lexer.
|
||||
var Angular2 = internal.Register(MustNewLexer(
|
||||
var Angular2 = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Angular2",
|
||||
Aliases: []string{"ng2"},
|
||||
Filenames: []string{},
|
||||
MimeTypes: []string{},
|
||||
},
|
||||
Rules{
|
||||
angular2Rules,
|
||||
))
|
||||
|
||||
func angular2Rules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`[^{([*#]+`, Other, nil},
|
||||
{`(\{\{)(\s*)`, ByGroups(CommentPreproc, Text), Push("ngExpression")},
|
||||
@ -38,5 +42,5 @@ var Angular2 = internal.Register(MustNewLexer(
|
||||
{`'.*?'`, LiteralString, Pop(1)},
|
||||
{`[^\s>]+`, LiteralString, Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// ANTLR lexer.
|
||||
var ANTLR = internal.Register(MustNewLexer(
|
||||
var ANTLR = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "ANTLR",
|
||||
Aliases: []string{"antlr"},
|
||||
Filenames: []string{},
|
||||
MimeTypes: []string{},
|
||||
},
|
||||
Rules{
|
||||
antlrRules,
|
||||
))
|
||||
|
||||
func antlrRules() Rules {
|
||||
return Rules{
|
||||
"whitespace": {
|
||||
{`\s+`, TextWhitespace, nil},
|
||||
},
|
||||
@ -97,5 +101,5 @@ var ANTLR = internal.Register(MustNewLexer(
|
||||
{`(\$[a-zA-Z]+)(\.?)(text|value)?`, ByGroups(NameVariable, Punctuation, NameProperty), nil},
|
||||
{`(\\\\|\\\]|\\\[|[^\[\]])+`, Other, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Apacheconf lexer.
|
||||
var Apacheconf = internal.Register(MustNewLexer(
|
||||
var Apacheconf = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "ApacheConf",
|
||||
Aliases: []string{"apacheconf", "aconf", "apache"},
|
||||
@ -14,7 +14,11 @@ var Apacheconf = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-apacheconf"},
|
||||
CaseInsensitive: true,
|
||||
},
|
||||
Rules{
|
||||
apacheconfRules,
|
||||
))
|
||||
|
||||
func apacheconfRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\s+`, Text, nil},
|
||||
{`(#.*?)$`, Comment, nil},
|
||||
@ -34,5 +38,5 @@ var Apacheconf = internal.Register(MustNewLexer(
|
||||
{`"([^"\\]*(?:\\.[^"\\]*)*)"`, LiteralStringDouble, nil},
|
||||
{`[^\s"\\]+`, Text, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Apl lexer.
|
||||
var Apl = internal.Register(MustNewLexer(
|
||||
var Apl = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "APL",
|
||||
Aliases: []string{"apl"},
|
||||
Filenames: []string{"*.apl"},
|
||||
MimeTypes: []string{},
|
||||
},
|
||||
Rules{
|
||||
aplRules,
|
||||
))
|
||||
|
||||
func aplRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\s+`, Text, nil},
|
||||
{`[⍝#].*$`, CommentSingle, nil},
|
||||
@ -32,5 +36,5 @@ var Apl = internal.Register(MustNewLexer(
|
||||
{`[⍺⍵⍶⍹∇:]`, NameBuiltinPseudo, nil},
|
||||
{`[{}]`, KeywordType, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Applescript lexer.
|
||||
var Applescript = internal.Register(MustNewLexer(
|
||||
var Applescript = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "AppleScript",
|
||||
Aliases: []string{"applescript"},
|
||||
@ -14,7 +14,11 @@ var Applescript = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{},
|
||||
DotAll: true,
|
||||
},
|
||||
Rules{
|
||||
applescriptRules,
|
||||
))
|
||||
|
||||
func applescriptRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\s+`, Text, nil},
|
||||
{`¬\n`, LiteralStringEscape, nil},
|
||||
@ -51,5 +55,5 @@ var Applescript = internal.Register(MustNewLexer(
|
||||
{`[^*(]+`, CommentMultiline, nil},
|
||||
{`[*(]`, CommentMultiline, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Arduino lexer.
|
||||
var Arduino = internal.Register(MustNewLexer(
|
||||
var Arduino = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Arduino",
|
||||
Aliases: []string{"arduino"},
|
||||
@ -14,7 +14,11 @@ var Arduino = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-arduino"},
|
||||
EnsureNL: true,
|
||||
},
|
||||
Rules{
|
||||
arduinoRules,
|
||||
))
|
||||
|
||||
func arduinoRules() Rules {
|
||||
return Rules{
|
||||
"statements": {
|
||||
{Words(``, `\b`, `catch`, `const_cast`, `delete`, `dynamic_cast`, `explicit`, `export`, `friend`, `mutable`, `namespace`, `new`, `operator`, `private`, `protected`, `public`, `reinterpret_cast`, `restrict`, `static_cast`, `template`, `this`, `throw`, `throws`, `try`, `typeid`, `typename`, `using`, `virtual`, `constexpr`, `nullptr`, `decltype`, `thread_local`, `alignas`, `alignof`, `static_assert`, `noexcept`, `override`, `final`), Keyword, nil},
|
||||
{`char(16_t|32_t)\b`, KeywordType, nil},
|
||||
@ -106,5 +110,5 @@ var Arduino = internal.Register(MustNewLexer(
|
||||
{`^\s*#endif.*?(?<!\\)\n`, CommentPreproc, Pop(1)},
|
||||
{`.*?\n`, Comment, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Awk lexer.
|
||||
var Awk = internal.Register(MustNewLexer(
|
||||
var Awk = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Awk",
|
||||
Aliases: []string{"awk", "gawk", "mawk", "nawk"},
|
||||
Filenames: []string{"*.awk"},
|
||||
MimeTypes: []string{"application/x-awk"},
|
||||
},
|
||||
Rules{
|
||||
awkRules,
|
||||
))
|
||||
|
||||
func awkRules() Rules {
|
||||
return Rules{
|
||||
"commentsandwhitespace": {
|
||||
{`\s+`, Text, nil},
|
||||
{`#.*$`, CommentSingle, nil},
|
||||
@ -44,5 +48,5 @@ var Awk = internal.Register(MustNewLexer(
|
||||
{`"(\\\\|\\"|[^"])*"`, LiteralStringDouble, nil},
|
||||
{`'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Ballerina lexer.
|
||||
var Ballerina = internal.Register(MustNewLexer(
|
||||
var Ballerina = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Ballerina",
|
||||
Aliases: []string{"ballerina"},
|
||||
@ -14,7 +14,11 @@ var Ballerina = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-ballerina"},
|
||||
DotAll: true,
|
||||
},
|
||||
Rules{
|
||||
ballerinaRules,
|
||||
))
|
||||
|
||||
func ballerinaRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`[^\S\n]+`, Text, nil},
|
||||
{`//.*?\n`, CommentSingle, nil},
|
||||
@ -42,5 +46,5 @@ var Ballerina = internal.Register(MustNewLexer(
|
||||
"import": {
|
||||
{`[\w.]+`, NameNamespace, Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -7,17 +7,27 @@ import (
|
||||
"github.com/alecthomas/chroma/lexers/internal"
|
||||
)
|
||||
|
||||
// TODO(moorereason): can this be factored away?
|
||||
var bashAnalyserRe = regexp.MustCompile(`(?m)^#!.*/bin/(?:env |)(?:bash|zsh|sh|ksh)`)
|
||||
|
||||
// Bash lexer.
|
||||
var Bash = internal.Register(MustNewLexer(
|
||||
var Bash = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Bash",
|
||||
Aliases: []string{"bash", "sh", "ksh", "zsh", "shell"},
|
||||
Filenames: []string{"*.sh", "*.ksh", "*.bash", "*.ebuild", "*.eclass", ".env", "*.env", "*.exheres-0", "*.exlib", "*.zsh", "*.zshrc", ".bashrc", "bashrc", ".bash_*", "bash_*", "zshrc", ".zshrc", "PKGBUILD"},
|
||||
MimeTypes: []string{"application/x-sh", "application/x-shellscript"},
|
||||
},
|
||||
Rules{
|
||||
bashRules,
|
||||
).SetAnalyser(func(text string) float32 {
|
||||
if bashAnalyserRe.FindString(text) != "" {
|
||||
return 1.0
|
||||
}
|
||||
return 0.0
|
||||
}))
|
||||
|
||||
func bashRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
Include("basic"),
|
||||
{"`", LiteralStringBacktick, Push("backticks")},
|
||||
@ -86,10 +96,5 @@ var Bash = internal.Register(MustNewLexer(
|
||||
{"`", LiteralStringBacktick, Pop(1)},
|
||||
Include("root"),
|
||||
},
|
||||
},
|
||||
).SetAnalyser(func(text string) float32 {
|
||||
if bashAnalyserRe.FindString(text) != "" {
|
||||
return 1.0
|
||||
}
|
||||
return 0.0
|
||||
}))
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Batchfile lexer.
|
||||
var Batchfile = internal.Register(MustNewLexer(
|
||||
var Batchfile = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Batchfile",
|
||||
Aliases: []string{"bat", "batch", "dosbatch", "winbatch"},
|
||||
@ -14,7 +14,11 @@ var Batchfile = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"application/x-dos-batch"},
|
||||
CaseInsensitive: true,
|
||||
},
|
||||
Rules{
|
||||
batchfileRules,
|
||||
))
|
||||
|
||||
func batchfileRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\)((?=\()|(?=\^?[\t\v\f\r ,;=\xa0]|[&<>|\n\x1a]))(?:(?:[^\n\x1a^]|\^[\n\x1a]?[\w\W])*)`, CommentSingle, nil},
|
||||
{`(?=((?:(?<=^[^:])|^[^:]?)[\t\v\f\r ,;=\xa0]*)(:))`, Text, Push("follow")},
|
||||
@ -190,5 +194,5 @@ var Batchfile = internal.Register(MustNewLexer(
|
||||
{`else(?=\^?[\t\v\f\r ,;=\xa0]|[&<>|\n\x1a])`, Keyword, Pop(1)},
|
||||
Default(Pop(1)),
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Bibtex lexer.
|
||||
var Bibtex = internal.Register(MustNewLexer(
|
||||
var Bibtex = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "BibTeX",
|
||||
Aliases: []string{"bib", "bibtex"},
|
||||
@ -15,7 +15,11 @@ var Bibtex = internal.Register(MustNewLexer(
|
||||
NotMultiline: true,
|
||||
CaseInsensitive: true,
|
||||
},
|
||||
Rules{
|
||||
bibtexRules,
|
||||
))
|
||||
|
||||
func bibtexRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
Include("whitespace"),
|
||||
{`@comment`, Comment, nil},
|
||||
@ -72,5 +76,5 @@ var Bibtex = internal.Register(MustNewLexer(
|
||||
"whitespace": {
|
||||
{`\s+`, Text, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Blitzbasic lexer.
|
||||
var Blitzbasic = internal.Register(MustNewLexer(
|
||||
var Blitzbasic = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "BlitzBasic",
|
||||
Aliases: []string{"blitzbasic", "b3d", "bplus"},
|
||||
@ -14,7 +14,11 @@ var Blitzbasic = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-bb"},
|
||||
CaseInsensitive: true,
|
||||
},
|
||||
Rules{
|
||||
blitzbasicRules,
|
||||
))
|
||||
|
||||
func blitzbasicRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`[ \t]+`, Text, nil},
|
||||
{`;.*?\n`, CommentSingle, nil},
|
||||
@ -44,5 +48,5 @@ var Blitzbasic = internal.Register(MustNewLexer(
|
||||
{`"C?`, LiteralStringDouble, Pop(1)},
|
||||
{`[^"]+`, LiteralStringDouble, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,19 +6,23 @@ import (
|
||||
)
|
||||
|
||||
// Bnf lexer.
|
||||
var Bnf = internal.Register(MustNewLexer(
|
||||
var Bnf = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "BNF",
|
||||
Aliases: []string{"bnf"},
|
||||
Filenames: []string{"*.bnf"},
|
||||
MimeTypes: []string{"text/x-bnf"},
|
||||
},
|
||||
Rules{
|
||||
bnfRules,
|
||||
))
|
||||
|
||||
func bnfRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`(<)([ -;=?-~]+)(>)`, ByGroups(Punctuation, NameClass, Punctuation), nil},
|
||||
{`::=`, Operator, nil},
|
||||
{`[^<>:]+`, Text, nil},
|
||||
{`.`, Text, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Brainfuck lexer.
|
||||
var Brainfuck = internal.Register(MustNewLexer(
|
||||
var Brainfuck = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Brainfuck",
|
||||
Aliases: []string{"brainfuck", "bf"},
|
||||
Filenames: []string{"*.bf", "*.b"},
|
||||
MimeTypes: []string{"application/x-brainfuck"},
|
||||
},
|
||||
Rules{
|
||||
brainfuckRules,
|
||||
))
|
||||
|
||||
func brainfuckRules() Rules {
|
||||
return Rules{
|
||||
"common": {
|
||||
{`[.,]+`, NameTag, nil},
|
||||
{`[+-]+`, NameBuiltin, nil},
|
||||
@ -30,5 +34,5 @@ var Brainfuck = internal.Register(MustNewLexer(
|
||||
{`\]`, Keyword, Pop(1)},
|
||||
Include("common"),
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// C lexer.
|
||||
var C = internal.Register(MustNewLexer(
|
||||
var C = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "C",
|
||||
Aliases: []string{"c"},
|
||||
@ -14,7 +14,11 @@ var C = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-chdr", "text/x-csrc"},
|
||||
EnsureNL: true,
|
||||
},
|
||||
Rules{
|
||||
cRules,
|
||||
))
|
||||
|
||||
func cRules() Rules {
|
||||
return Rules{
|
||||
"whitespace": {
|
||||
{`^#if\s+0`, CommentPreproc, Push("if0")},
|
||||
{`^#`, CommentPreproc, Push("macro")},
|
||||
@ -88,5 +92,5 @@ var C = internal.Register(MustNewLexer(
|
||||
{`^\s*#endif.*?(?<!\\)\n`, CommentPreproc, Pop(1)},
|
||||
{`.*?\n`, Comment, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,143 +6,149 @@ import (
|
||||
)
|
||||
|
||||
// caddyfileCommon are the rules common to both of the lexer variants
|
||||
var caddyfileCommon = Rules{
|
||||
"site_block_common": {
|
||||
// Import keyword
|
||||
{`(import)(\s+)([^\s]+)`, ByGroups(Keyword, Text, NameVariableMagic), nil},
|
||||
// Matcher definition
|
||||
{`@[^\s]+(?=\s)`, NameDecorator, Push("matcher")},
|
||||
// Matcher token stub for docs
|
||||
{`\[\<matcher\>\]`, NameDecorator, Push("matcher")},
|
||||
// These cannot have matchers but may have things that look like
|
||||
// matchers in their arguments, so we just parse as a subdirective.
|
||||
{`try_files`, Keyword, Push("subdirective")},
|
||||
// These are special, they can nest more directives
|
||||
{`handle_errors|handle|route|handle_path|not`, Keyword, Push("nested_directive")},
|
||||
// Any other directive
|
||||
{`[^\s#]+`, Keyword, Push("directive")},
|
||||
Include("base"),
|
||||
},
|
||||
"matcher": {
|
||||
{`\{`, Punctuation, Push("block")},
|
||||
// Not can be one-liner
|
||||
{`not`, Keyword, Push("deep_not_matcher")},
|
||||
// Any other same-line matcher
|
||||
{`[^\s#]+`, Keyword, Push("arguments")},
|
||||
// Terminators
|
||||
{`\n`, Text, Pop(1)},
|
||||
{`\}`, Punctuation, Pop(1)},
|
||||
Include("base"),
|
||||
},
|
||||
"block": {
|
||||
{`\}`, Punctuation, Pop(2)},
|
||||
// Not can be one-liner
|
||||
{`not`, Keyword, Push("not_matcher")},
|
||||
// Any other subdirective
|
||||
{`[^\s#]+`, Keyword, Push("subdirective")},
|
||||
Include("base"),
|
||||
},
|
||||
"nested_block": {
|
||||
{`\}`, Punctuation, Pop(2)},
|
||||
// Matcher definition
|
||||
{`@[^\s]+(?=\s)`, NameDecorator, Push("matcher")},
|
||||
// Something that starts with literally < is probably a docs stub
|
||||
{`\<[^#]+\>`, Keyword, Push("nested_directive")},
|
||||
// Any other directive
|
||||
{`[^\s#]+`, Keyword, Push("nested_directive")},
|
||||
Include("base"),
|
||||
},
|
||||
"not_matcher": {
|
||||
{`\}`, Punctuation, Pop(2)},
|
||||
{`\{(?=\s)`, Punctuation, Push("block")},
|
||||
{`[^\s#]+`, Keyword, Push("arguments")},
|
||||
{`\s+`, Text, nil},
|
||||
},
|
||||
"deep_not_matcher": {
|
||||
{`\}`, Punctuation, Pop(2)},
|
||||
{`\{(?=\s)`, Punctuation, Push("block")},
|
||||
{`[^\s#]+`, Keyword, Push("deep_subdirective")},
|
||||
{`\s+`, Text, nil},
|
||||
},
|
||||
"directive": {
|
||||
{`\{(?=\s)`, Punctuation, Push("block")},
|
||||
Include("matcher_token"),
|
||||
Include("comments_pop_1"),
|
||||
{`\n`, Text, Pop(1)},
|
||||
Include("base"),
|
||||
},
|
||||
"nested_directive": {
|
||||
{`\{(?=\s)`, Punctuation, Push("nested_block")},
|
||||
Include("matcher_token"),
|
||||
Include("comments_pop_1"),
|
||||
{`\n`, Text, Pop(1)},
|
||||
Include("base"),
|
||||
},
|
||||
"subdirective": {
|
||||
{`\{(?=\s)`, Punctuation, Push("block")},
|
||||
Include("comments_pop_1"),
|
||||
{`\n`, Text, Pop(1)},
|
||||
Include("base"),
|
||||
},
|
||||
"arguments": {
|
||||
{`\{(?=\s)`, Punctuation, Push("block")},
|
||||
Include("comments_pop_2"),
|
||||
{`\\\n`, Text, nil}, // Skip escaped newlines
|
||||
{`\n`, Text, Pop(2)},
|
||||
Include("base"),
|
||||
},
|
||||
"deep_subdirective": {
|
||||
{`\{(?=\s)`, Punctuation, Push("block")},
|
||||
Include("comments_pop_3"),
|
||||
{`\n`, Text, Pop(3)},
|
||||
Include("base"),
|
||||
},
|
||||
"matcher_token": {
|
||||
{`@[^\s]+`, NameDecorator, Push("arguments")}, // Named matcher
|
||||
{`/[^\s]+`, NameDecorator, Push("arguments")}, // Path matcher
|
||||
{`\*`, NameDecorator, Push("arguments")}, // Wildcard path matcher
|
||||
{`\[\<matcher\>\]`, NameDecorator, Push("arguments")}, // Matcher token stub for docs
|
||||
},
|
||||
"comments": {
|
||||
{`^#.*\n`, CommentSingle, nil}, // Comment at start of line
|
||||
{`\s+#.*\n`, CommentSingle, nil}, // Comment preceded by whitespace
|
||||
},
|
||||
"comments_pop_1": {
|
||||
{`^#.*\n`, CommentSingle, Pop(1)}, // Comment at start of line
|
||||
{`\s+#.*\n`, CommentSingle, Pop(1)}, // Comment preceded by whitespace
|
||||
},
|
||||
"comments_pop_2": {
|
||||
{`^#.*\n`, CommentSingle, Pop(2)}, // Comment at start of line
|
||||
{`\s+#.*\n`, CommentSingle, Pop(2)}, // Comment preceded by whitespace
|
||||
},
|
||||
"comments_pop_3": {
|
||||
{`^#.*\n`, CommentSingle, Pop(3)}, // Comment at start of line
|
||||
{`\s+#.*\n`, CommentSingle, Pop(3)}, // Comment preceded by whitespace
|
||||
},
|
||||
"base": {
|
||||
Include("comments"),
|
||||
{`(on|off|first|last|before|after|internal|strip_prefix|strip_suffix|replace)\b`, NameConstant, nil},
|
||||
{`(https?://)?([a-z0-9.-]+)(:)([0-9]+)`, ByGroups(Name, Name, Punctuation, LiteralNumberInteger), nil},
|
||||
{`[a-z-]+/[a-z-+]+`, LiteralString, nil},
|
||||
{`[0-9]+[km]?\b`, LiteralNumberInteger, nil},
|
||||
{`\{[\w+.\$-]+\}`, LiteralStringEscape, nil}, // Placeholder
|
||||
{`\[(?=[^#{}$]+\])`, Punctuation, nil},
|
||||
{`\]|\|`, Punctuation, nil},
|
||||
{`[^\s#{}$\]]+`, LiteralString, nil},
|
||||
{`/[^\s#]*`, Name, nil},
|
||||
{`\s+`, Text, nil},
|
||||
},
|
||||
func caddyfileCommonRules() Rules {
|
||||
return Rules{
|
||||
"site_block_common": {
|
||||
// Import keyword
|
||||
{`(import)(\s+)([^\s]+)`, ByGroups(Keyword, Text, NameVariableMagic), nil},
|
||||
// Matcher definition
|
||||
{`@[^\s]+(?=\s)`, NameDecorator, Push("matcher")},
|
||||
// Matcher token stub for docs
|
||||
{`\[\<matcher\>\]`, NameDecorator, Push("matcher")},
|
||||
// These cannot have matchers but may have things that look like
|
||||
// matchers in their arguments, so we just parse as a subdirective.
|
||||
{`try_files`, Keyword, Push("subdirective")},
|
||||
// These are special, they can nest more directives
|
||||
{`handle_errors|handle|route|handle_path|not`, Keyword, Push("nested_directive")},
|
||||
// Any other directive
|
||||
{`[^\s#]+`, Keyword, Push("directive")},
|
||||
Include("base"),
|
||||
},
|
||||
"matcher": {
|
||||
{`\{`, Punctuation, Push("block")},
|
||||
// Not can be one-liner
|
||||
{`not`, Keyword, Push("deep_not_matcher")},
|
||||
// Any other same-line matcher
|
||||
{`[^\s#]+`, Keyword, Push("arguments")},
|
||||
// Terminators
|
||||
{`\n`, Text, Pop(1)},
|
||||
{`\}`, Punctuation, Pop(1)},
|
||||
Include("base"),
|
||||
},
|
||||
"block": {
|
||||
{`\}`, Punctuation, Pop(2)},
|
||||
// Not can be one-liner
|
||||
{`not`, Keyword, Push("not_matcher")},
|
||||
// Any other subdirective
|
||||
{`[^\s#]+`, Keyword, Push("subdirective")},
|
||||
Include("base"),
|
||||
},
|
||||
"nested_block": {
|
||||
{`\}`, Punctuation, Pop(2)},
|
||||
// Matcher definition
|
||||
{`@[^\s]+(?=\s)`, NameDecorator, Push("matcher")},
|
||||
// Something that starts with literally < is probably a docs stub
|
||||
{`\<[^#]+\>`, Keyword, Push("nested_directive")},
|
||||
// Any other directive
|
||||
{`[^\s#]+`, Keyword, Push("nested_directive")},
|
||||
Include("base"),
|
||||
},
|
||||
"not_matcher": {
|
||||
{`\}`, Punctuation, Pop(2)},
|
||||
{`\{(?=\s)`, Punctuation, Push("block")},
|
||||
{`[^\s#]+`, Keyword, Push("arguments")},
|
||||
{`\s+`, Text, nil},
|
||||
},
|
||||
"deep_not_matcher": {
|
||||
{`\}`, Punctuation, Pop(2)},
|
||||
{`\{(?=\s)`, Punctuation, Push("block")},
|
||||
{`[^\s#]+`, Keyword, Push("deep_subdirective")},
|
||||
{`\s+`, Text, nil},
|
||||
},
|
||||
"directive": {
|
||||
{`\{(?=\s)`, Punctuation, Push("block")},
|
||||
Include("matcher_token"),
|
||||
Include("comments_pop_1"),
|
||||
{`\n`, Text, Pop(1)},
|
||||
Include("base"),
|
||||
},
|
||||
"nested_directive": {
|
||||
{`\{(?=\s)`, Punctuation, Push("nested_block")},
|
||||
Include("matcher_token"),
|
||||
Include("comments_pop_1"),
|
||||
{`\n`, Text, Pop(1)},
|
||||
Include("base"),
|
||||
},
|
||||
"subdirective": {
|
||||
{`\{(?=\s)`, Punctuation, Push("block")},
|
||||
Include("comments_pop_1"),
|
||||
{`\n`, Text, Pop(1)},
|
||||
Include("base"),
|
||||
},
|
||||
"arguments": {
|
||||
{`\{(?=\s)`, Punctuation, Push("block")},
|
||||
Include("comments_pop_2"),
|
||||
{`\\\n`, Text, nil}, // Skip escaped newlines
|
||||
{`\n`, Text, Pop(2)},
|
||||
Include("base"),
|
||||
},
|
||||
"deep_subdirective": {
|
||||
{`\{(?=\s)`, Punctuation, Push("block")},
|
||||
Include("comments_pop_3"),
|
||||
{`\n`, Text, Pop(3)},
|
||||
Include("base"),
|
||||
},
|
||||
"matcher_token": {
|
||||
{`@[^\s]+`, NameDecorator, Push("arguments")}, // Named matcher
|
||||
{`/[^\s]+`, NameDecorator, Push("arguments")}, // Path matcher
|
||||
{`\*`, NameDecorator, Push("arguments")}, // Wildcard path matcher
|
||||
{`\[\<matcher\>\]`, NameDecorator, Push("arguments")}, // Matcher token stub for docs
|
||||
},
|
||||
"comments": {
|
||||
{`^#.*\n`, CommentSingle, nil}, // Comment at start of line
|
||||
{`\s+#.*\n`, CommentSingle, nil}, // Comment preceded by whitespace
|
||||
},
|
||||
"comments_pop_1": {
|
||||
{`^#.*\n`, CommentSingle, Pop(1)}, // Comment at start of line
|
||||
{`\s+#.*\n`, CommentSingle, Pop(1)}, // Comment preceded by whitespace
|
||||
},
|
||||
"comments_pop_2": {
|
||||
{`^#.*\n`, CommentSingle, Pop(2)}, // Comment at start of line
|
||||
{`\s+#.*\n`, CommentSingle, Pop(2)}, // Comment preceded by whitespace
|
||||
},
|
||||
"comments_pop_3": {
|
||||
{`^#.*\n`, CommentSingle, Pop(3)}, // Comment at start of line
|
||||
{`\s+#.*\n`, CommentSingle, Pop(3)}, // Comment preceded by whitespace
|
||||
},
|
||||
"base": {
|
||||
Include("comments"),
|
||||
{`(on|off|first|last|before|after|internal|strip_prefix|strip_suffix|replace)\b`, NameConstant, nil},
|
||||
{`(https?://)?([a-z0-9.-]+)(:)([0-9]+)`, ByGroups(Name, Name, Punctuation, LiteralNumberInteger), nil},
|
||||
{`[a-z-]+/[a-z-+]+`, LiteralString, nil},
|
||||
{`[0-9]+[km]?\b`, LiteralNumberInteger, nil},
|
||||
{`\{[\w+.\$-]+\}`, LiteralStringEscape, nil}, // Placeholder
|
||||
{`\[(?=[^#{}$]+\])`, Punctuation, nil},
|
||||
{`\]|\|`, Punctuation, nil},
|
||||
{`[^\s#{}$\]]+`, LiteralString, nil},
|
||||
{`/[^\s#]*`, Name, nil},
|
||||
{`\s+`, Text, nil},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// Caddyfile lexer.
|
||||
var Caddyfile = internal.Register(MustNewLexer(
|
||||
var Caddyfile = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Caddyfile",
|
||||
Aliases: []string{"caddyfile", "caddy"},
|
||||
Filenames: []string{"Caddyfile*"},
|
||||
MimeTypes: []string{},
|
||||
},
|
||||
Rules{
|
||||
caddyfileRules,
|
||||
))
|
||||
|
||||
func caddyfileRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
Include("comments"),
|
||||
// Global options block
|
||||
@ -186,21 +192,25 @@ var Caddyfile = internal.Register(MustNewLexer(
|
||||
{`\}`, Punctuation, Pop(2)},
|
||||
Include("site_block_common"),
|
||||
},
|
||||
}.Merge(caddyfileCommon),
|
||||
))
|
||||
}.Merge(caddyfileCommonRules())
|
||||
}
|
||||
|
||||
// Caddyfile directive-only lexer.
|
||||
var CaddyfileDirectives = internal.Register(MustNewLexer(
|
||||
var CaddyfileDirectives = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Caddyfile Directives",
|
||||
Aliases: []string{"caddyfile-directives", "caddyfile-d", "caddy-d"},
|
||||
Filenames: []string{},
|
||||
MimeTypes: []string{},
|
||||
},
|
||||
Rules{
|
||||
caddyfileDirectivesRules,
|
||||
))
|
||||
|
||||
func caddyfileDirectivesRules() Rules {
|
||||
return Rules{
|
||||
// Same as "site_block" in Caddyfile
|
||||
"root": {
|
||||
Include("site_block_common"),
|
||||
},
|
||||
}.Merge(caddyfileCommon),
|
||||
))
|
||||
}.Merge(caddyfileCommonRules())
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Cap'N'Proto Proto lexer.
|
||||
var CapNProto = internal.Register(MustNewLexer(
|
||||
var CapNProto = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Cap'n Proto",
|
||||
Aliases: []string{"capnp"},
|
||||
Filenames: []string{"*.capnp"},
|
||||
MimeTypes: []string{},
|
||||
},
|
||||
Rules{
|
||||
capNProtoRules,
|
||||
))
|
||||
|
||||
func capNProtoRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`#.*?$`, CommentSingle, nil},
|
||||
{`@[0-9a-zA-Z]*`, NameDecorator, nil},
|
||||
@ -57,5 +61,5 @@ var CapNProto = internal.Register(MustNewLexer(
|
||||
{`[])]`, NameAttribute, Pop(1)},
|
||||
Default(Pop(1)),
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Ceylon lexer.
|
||||
var Ceylon = internal.Register(MustNewLexer(
|
||||
var Ceylon = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Ceylon",
|
||||
Aliases: []string{"ceylon"},
|
||||
@ -14,7 +14,11 @@ var Ceylon = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-ceylon"},
|
||||
DotAll: true,
|
||||
},
|
||||
Rules{
|
||||
ceylonRules,
|
||||
))
|
||||
|
||||
func ceylonRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`^(\s*(?:[a-zA-Z_][\w.\[\]]*\s+)+?)([a-zA-Z_]\w*)(\s*)(\()`, ByGroups(UsingSelf("root"), NameFunction, Text, Operator), nil},
|
||||
{`[^\S\n]+`, Text, nil},
|
||||
@ -59,5 +63,5 @@ var Ceylon = internal.Register(MustNewLexer(
|
||||
{`\*/`, CommentMultiline, Pop(1)},
|
||||
{`[*/]`, CommentMultiline, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Cfengine3 lexer.
|
||||
var Cfengine3 = internal.Register(MustNewLexer(
|
||||
var Cfengine3 = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "CFEngine3",
|
||||
Aliases: []string{"cfengine3", "cf3"},
|
||||
Filenames: []string{"*.cf"},
|
||||
MimeTypes: []string{},
|
||||
},
|
||||
Rules{
|
||||
cfengine3Rules,
|
||||
))
|
||||
|
||||
func cfengine3Rules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`#.*?\n`, Comment, nil},
|
||||
{`(body)(\s+)(\S+)(\s+)(control)`, ByGroups(Keyword, Text, Keyword, Text, Keyword), nil},
|
||||
@ -52,5 +56,5 @@ var Cfengine3 = internal.Register(MustNewLexer(
|
||||
{`\w+`, NameVariable, nil},
|
||||
{`\s+`, Text, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Chaiscript lexer.
|
||||
var Chaiscript = internal.Register(MustNewLexer(
|
||||
var Chaiscript = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "ChaiScript",
|
||||
Aliases: []string{"chai", "chaiscript"},
|
||||
@ -14,7 +14,11 @@ var Chaiscript = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-chaiscript", "application/x-chaiscript"},
|
||||
DotAll: true,
|
||||
},
|
||||
Rules{
|
||||
chaiscriptRules,
|
||||
))
|
||||
|
||||
func chaiscriptRules() Rules {
|
||||
return Rules{
|
||||
"commentsandwhitespace": {
|
||||
{`\s+`, Text, nil},
|
||||
{`//.*?\n`, CommentSingle, nil},
|
||||
@ -59,5 +63,5 @@ var Chaiscript = internal.Register(MustNewLexer(
|
||||
{`[^\\"$]+`, LiteralStringDouble, nil},
|
||||
{`"`, LiteralStringDouble, Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -7,14 +7,18 @@ import (
|
||||
)
|
||||
|
||||
// Cheetah lexer.
|
||||
var Cheetah = internal.Register(MustNewLexer(
|
||||
var Cheetah = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Cheetah",
|
||||
Aliases: []string{"cheetah", "spitfire"},
|
||||
Filenames: []string{"*.tmpl", "*.spt"},
|
||||
MimeTypes: []string{"application/x-cheetah", "application/x-spitfire"},
|
||||
},
|
||||
Rules{
|
||||
cheetahRules,
|
||||
))
|
||||
|
||||
func cheetahRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`(##[^\n]*)$`, ByGroups(Comment), nil},
|
||||
{`#[*](.|\n)*?[*]#`, Comment, nil},
|
||||
@ -33,5 +37,5 @@ var Cheetah = internal.Register(MustNewLexer(
|
||||
`, Other, nil},
|
||||
{`\s+`, Text, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -230,7 +230,7 @@ var (
|
||||
)
|
||||
|
||||
// Common Lisp lexer.
|
||||
var CommonLisp = internal.Register(TypeRemappingLexer(MustNewLexer(
|
||||
var CommonLisp = internal.Register(TypeRemappingLexer(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Common Lisp",
|
||||
Aliases: []string{"common-lisp", "cl", "lisp"},
|
||||
@ -238,7 +238,19 @@ var CommonLisp = internal.Register(TypeRemappingLexer(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-common-lisp"},
|
||||
CaseInsensitive: true,
|
||||
},
|
||||
Rules{
|
||||
commonLispRules,
|
||||
), TypeMapping{
|
||||
{NameVariable, NameFunction, clBuiltinFunctions},
|
||||
{NameVariable, Keyword, clSpecialForms},
|
||||
{NameVariable, NameBuiltin, clMacros},
|
||||
{NameVariable, Keyword, clLambdaListKeywords},
|
||||
{NameVariable, Keyword, clDeclarations},
|
||||
{NameVariable, KeywordType, clBuiltinTypes},
|
||||
{NameVariable, NameClass, clBuiltinClasses},
|
||||
}))
|
||||
|
||||
func commonLispRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
Default(Push("body")),
|
||||
},
|
||||
@ -294,13 +306,5 @@ var CommonLisp = internal.Register(TypeRemappingLexer(MustNewLexer(
|
||||
{`\(`, Punctuation, Push("body")},
|
||||
{`\)`, Punctuation, Pop(1)},
|
||||
},
|
||||
},
|
||||
), TypeMapping{
|
||||
{NameVariable, NameFunction, clBuiltinFunctions},
|
||||
{NameVariable, Keyword, clSpecialForms},
|
||||
{NameVariable, NameBuiltin, clMacros},
|
||||
{NameVariable, Keyword, clLambdaListKeywords},
|
||||
{NameVariable, Keyword, clDeclarations},
|
||||
{NameVariable, KeywordType, clBuiltinTypes},
|
||||
{NameVariable, NameClass, clBuiltinClasses},
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Clojure lexer.
|
||||
var Clojure = internal.Register(MustNewLexer(
|
||||
var Clojure = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Clojure",
|
||||
Aliases: []string{"clojure", "clj"},
|
||||
Filenames: []string{"*.clj"},
|
||||
MimeTypes: []string{"text/x-clojure", "application/x-clojure"},
|
||||
},
|
||||
Rules{
|
||||
clojureRules,
|
||||
))
|
||||
|
||||
func clojureRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`;.*$`, CommentSingle, nil},
|
||||
{`[,\s]+`, Text, nil},
|
||||
@ -34,5 +38,5 @@ var Clojure = internal.Register(MustNewLexer(
|
||||
{`(\{|\})`, Punctuation, nil},
|
||||
{`(\(|\))`, Punctuation, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Cmake lexer.
|
||||
var Cmake = internal.Register(MustNewLexer(
|
||||
var Cmake = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "CMake",
|
||||
Aliases: []string{"cmake"},
|
||||
Filenames: []string{"*.cmake", "CMakeLists.txt"},
|
||||
MimeTypes: []string{"text/x-cmake"},
|
||||
},
|
||||
Rules{
|
||||
cmakeRules,
|
||||
))
|
||||
|
||||
func cmakeRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\b(\w+)([ \t]*)(\()`, ByGroups(NameBuiltin, Text, Punctuation), Push("args")},
|
||||
Include("keywords"),
|
||||
@ -40,5 +44,5 @@ var Cmake = internal.Register(MustNewLexer(
|
||||
{`[ \t]+`, Text, nil},
|
||||
{`#.*\n`, Comment, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Cobol lexer.
|
||||
var Cobol = internal.Register(MustNewLexer(
|
||||
var Cobol = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "COBOL",
|
||||
Aliases: []string{"cobol"},
|
||||
@ -14,7 +14,11 @@ var Cobol = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-cobol"},
|
||||
CaseInsensitive: true,
|
||||
},
|
||||
Rules{
|
||||
cobolRules,
|
||||
))
|
||||
|
||||
func cobolRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
Include("comment"),
|
||||
Include("strings"),
|
||||
@ -47,5 +51,5 @@ var Cobol = internal.Register(MustNewLexer(
|
||||
{`[+-]?\d*\.\d+(E[-+]?\d+)?`, LiteralNumberFloat, nil},
|
||||
{`[+-]?\d+\.\d*(E[-+]?\d+)?`, LiteralNumberFloat, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Coffeescript lexer.
|
||||
var Coffeescript = internal.Register(MustNewLexer(
|
||||
var Coffeescript = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "CoffeeScript",
|
||||
Aliases: []string{"coffee-script", "coffeescript", "coffee"},
|
||||
@ -15,7 +15,11 @@ var Coffeescript = internal.Register(MustNewLexer(
|
||||
NotMultiline: true,
|
||||
DotAll: true,
|
||||
},
|
||||
Rules{
|
||||
coffeescriptRules,
|
||||
))
|
||||
|
||||
func coffeescriptRules() Rules {
|
||||
return Rules{
|
||||
"commentsandwhitespace": {
|
||||
{`\s+`, Text, nil},
|
||||
{`###[^#].*?###`, CommentMultiline, nil},
|
||||
@ -87,5 +91,5 @@ var Coffeescript = internal.Register(MustNewLexer(
|
||||
{`#|\\.|\'|"`, LiteralString, nil},
|
||||
Include("strings"),
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Cfstatement lexer.
|
||||
var Cfstatement = internal.Register(MustNewLexer(
|
||||
var Cfstatement = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "cfstatement",
|
||||
Aliases: []string{"cfs"},
|
||||
@ -15,7 +15,11 @@ var Cfstatement = internal.Register(MustNewLexer(
|
||||
NotMultiline: true,
|
||||
CaseInsensitive: true,
|
||||
},
|
||||
Rules{
|
||||
cfstatementRules,
|
||||
))
|
||||
|
||||
func cfstatementRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`//.*?\n`, CommentSingle, nil},
|
||||
{`/\*(?:.|\n)*?\*/`, CommentMultiline, nil},
|
||||
@ -44,5 +48,5 @@ var Cfstatement = internal.Register(MustNewLexer(
|
||||
{`#`, LiteralStringDouble, nil},
|
||||
{`"`, LiteralStringDouble, Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Coq lexer.
|
||||
var Coq = internal.Register(MustNewLexer(
|
||||
var Coq = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Coq",
|
||||
Aliases: []string{"coq"},
|
||||
Filenames: []string{"*.v"},
|
||||
MimeTypes: []string{"text/x-coq"},
|
||||
},
|
||||
Rules{
|
||||
coqRules,
|
||||
))
|
||||
|
||||
func coqRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\s+`, Text, nil},
|
||||
{`false|true|\(\)|\[\]`, NameBuiltinPseudo, nil},
|
||||
@ -59,5 +63,5 @@ var Coq = internal.Register(MustNewLexer(
|
||||
{`[a-z][a-z0-9_\']*`, Name, Pop(1)},
|
||||
Default(Pop(1)),
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// CPP lexer.
|
||||
var CPP = internal.Register(MustNewLexer(
|
||||
var CPP = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "C++",
|
||||
Aliases: []string{"cpp", "c++"},
|
||||
@ -14,7 +14,11 @@ var CPP = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-c++hdr", "text/x-c++src"},
|
||||
EnsureNL: true,
|
||||
},
|
||||
Rules{
|
||||
cppRules,
|
||||
))
|
||||
|
||||
func cppRules() Rules {
|
||||
return Rules{
|
||||
"statements": {
|
||||
{Words(``, `\b`, `catch`, `const_cast`, `delete`, `dynamic_cast`, `explicit`, `export`, `friend`, `mutable`, `namespace`, `new`, `operator`, `private`, `protected`, `public`, `reinterpret_cast`, `restrict`, `static_cast`, `template`, `this`, `throw`, `throws`, `try`, `typeid`, `typename`, `using`, `virtual`, `constexpr`, `nullptr`, `decltype`, `thread_local`, `alignas`, `alignof`, `static_assert`, `noexcept`, `override`, `final`, `concept`, `requires`, `consteval`, `co_await`, `co_return`, `co_yield`), Keyword, nil},
|
||||
{`(enum)\b(\s+)(class)\b(\s*)`, ByGroups(Keyword, Text, Keyword, Text), Push("classname")},
|
||||
@ -102,5 +106,5 @@ var CPP = internal.Register(MustNewLexer(
|
||||
{`^\s*#endif.*?(?<!\\)\n`, CommentPreproc, Pop(1)},
|
||||
{`.*?\n`, Comment, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// CassandraCQL lexer.
|
||||
var CassandraCQL = internal.Register(MustNewLexer(
|
||||
var CassandraCQL = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Cassandra CQL",
|
||||
Aliases: []string{"cassandra", "cql"},
|
||||
@ -15,7 +15,11 @@ var CassandraCQL = internal.Register(MustNewLexer(
|
||||
NotMultiline: true,
|
||||
CaseInsensitive: true,
|
||||
},
|
||||
Rules{
|
||||
cassandraCQLRules,
|
||||
))
|
||||
|
||||
func cassandraCQLRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\s+`, TextWhitespace, nil},
|
||||
{`(--|\/\/).*\n?`, CommentSingle, nil},
|
||||
@ -23,7 +27,8 @@ var CassandraCQL = internal.Register(MustNewLexer(
|
||||
{`(ascii|bigint|blob|boolean|counter|date|decimal|double|float|frozen|inet|int|list|map|set|smallint|text|time|timestamp|timeuuid|tinyint|tuple|uuid|varchar|varint)\b`, NameBuiltin, nil},
|
||||
{Words(``, `\b`, `ADD`, `AGGREGATE`, `ALL`, `ALLOW`, `ALTER`, `AND`, `ANY`, `APPLY`, `AS`, `ASC`, `AUTHORIZE`, `BATCH`, `BEGIN`, `BY`, `CLUSTERING`, `COLUMNFAMILY`, `COMPACT`, `CONSISTENCY`, `COUNT`, `CREATE`, `CUSTOM`, `DELETE`, `DESC`, `DISTINCT`, `DROP`, `EACH_QUORUM`, `ENTRIES`, `EXISTS`, `FILTERING`, `FROM`, `FULL`, `GRANT`, `IF`, `IN`, `INDEX`, `INFINITY`, `INSERT`, `INTO`, `KEY`, `KEYS`, `KEYSPACE`, `KEYSPACES`, `LEVEL`, `LIMIT`, `LOCAL_ONE`, `LOCAL_QUORUM`, `MATERIALIZED`, `MODIFY`, `NAN`, `NORECURSIVE`, `NOSUPERUSER`, `NOT`, `OF`, `ON`, `ONE`, `ORDER`, `PARTITION`, `PASSWORD`, `PER`, `PERMISSION`, `PERMISSIONS`, `PRIMARY`, `QUORUM`, `RENAME`, `REVOKE`, `SCHEMA`, `SELECT`, `STATIC`, `STORAGE`, `SUPERUSER`, `TABLE`, `THREE`, `TO`, `TOKEN`, `TRUNCATE`, `TTL`, `TWO`, `TYPE`, `UNLOGGED`, `UPDATE`, `USE`, `USER`, `USERS`, `USING`, `VALUES`, `VIEW`, `WHERE`, `WITH`, `WRITETIME`, `REPLICATION`, `OR`, `REPLACE`, `FUNCTION`, `CALLED`, `INPUT`, `RETURNS`, `LANGUAGE`, `ROLE`, `ROLES`, `TRIGGER`, `DURABLE_WRITES`, `LOGIN`, `OPTIONS`, `LOGGED`, `SFUNC`, `STYPE`, `FINALFUNC`, `INITCOND`, `IS`, `CONTAINS`, `JSON`, `PAGING`, `OFF`), Keyword, nil},
|
||||
{"[+*/<>=~!@#%^&|`?-]+", Operator, nil},
|
||||
{`(?s)(java|javascript)(\s+)(AS)(\s+)('|\$\$)(.*?)(\5)`,
|
||||
{
|
||||
`(?s)(java|javascript)(\s+)(AS)(\s+)('|\$\$)(.*?)(\5)`,
|
||||
UsingByGroup(
|
||||
internal.Get,
|
||||
1, 6,
|
||||
@ -65,5 +70,5 @@ var CassandraCQL = internal.Register(MustNewLexer(
|
||||
{`[^\$]+`, LiteralStringHeredoc, nil},
|
||||
{`\$\$`, LiteralStringHeredoc, Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Crystal lexer.
|
||||
var Crystal = internal.Register(MustNewLexer(
|
||||
var Crystal = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Crystal",
|
||||
Aliases: []string{"cr", "crystal"},
|
||||
@ -14,7 +14,11 @@ var Crystal = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-crystal"},
|
||||
DotAll: true,
|
||||
},
|
||||
Rules{
|
||||
crystalRules,
|
||||
))
|
||||
|
||||
func crystalRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`#.*?$`, CommentSingle, nil},
|
||||
{Words(``, `\b`, `abstract`, `asm`, `as`, `begin`, `break`, `case`, `do`, `else`, `elsif`, `end`, `ensure`, `extend`, `ifdef`, `if`, `include`, `instance_sizeof`, `next`, `of`, `pointerof`, `private`, `protected`, `rescue`, `return`, `require`, `sizeof`, `super`, `then`, `typeof`, `unless`, `until`, `when`, `while`, `with`, `yield`), Keyword, nil},
|
||||
@ -258,5 +262,5 @@ var Crystal = internal.Register(MustNewLexer(
|
||||
{`[\\#<>]`, LiteralStringRegex, nil},
|
||||
{`[^\\#<>]+`, LiteralStringRegex, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// CSharp lexer.
|
||||
var CSharp = internal.Register(MustNewLexer(
|
||||
var CSharp = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "C#",
|
||||
Aliases: []string{"csharp", "c#"},
|
||||
@ -15,7 +15,11 @@ var CSharp = internal.Register(MustNewLexer(
|
||||
DotAll: true,
|
||||
EnsureNL: true,
|
||||
},
|
||||
Rules{
|
||||
cSharpRules,
|
||||
))
|
||||
|
||||
func cSharpRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`^\s*\[.*?\]`, NameAttribute, nil},
|
||||
{`[^\S\n]+`, Text, nil},
|
||||
@ -47,5 +51,5 @@ var CSharp = internal.Register(MustNewLexer(
|
||||
{`(?=\()`, Text, Pop(1)},
|
||||
{`(@?[_a-zA-Z]\w*|\.)+`, NameNamespace, Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// CSS lexer.
|
||||
var CSS = internal.Register(MustNewLexer(
|
||||
var CSS = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "CSS",
|
||||
Aliases: []string{"css"},
|
||||
Filenames: []string{"*.css"},
|
||||
MimeTypes: []string{"text/css"},
|
||||
},
|
||||
Rules{
|
||||
cssRules,
|
||||
))
|
||||
|
||||
func cssRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
Include("basics"),
|
||||
},
|
||||
@ -113,5 +117,5 @@ var CSS = internal.Register(MustNewLexer(
|
||||
{`%`, KeywordType, nil},
|
||||
Default(Pop(1)),
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Cython lexer.
|
||||
var Cython = internal.Register(MustNewLexer(
|
||||
var Cython = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Cython",
|
||||
Aliases: []string{"cython", "pyx", "pyrex"},
|
||||
Filenames: []string{"*.pyx", "*.pxd", "*.pxi"},
|
||||
MimeTypes: []string{"text/x-cython", "application/x-cython"},
|
||||
},
|
||||
Rules{
|
||||
cythonRules,
|
||||
))
|
||||
|
||||
func cythonRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\n`, Text, nil},
|
||||
{`^(\s*)("""(?:.|\n)*?""")`, ByGroups(Text, LiteralStringDoc), nil},
|
||||
@ -131,5 +135,5 @@ var Cython = internal.Register(MustNewLexer(
|
||||
Include("strings"),
|
||||
Include("nl"),
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// PHP lexer for pure PHP code (not embedded in HTML).
|
||||
var PHP = internal.Register(MustNewLexer(
|
||||
var PHP = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "PHP",
|
||||
Aliases: []string{"php", "php3", "php4", "php5"},
|
||||
@ -16,65 +16,71 @@ var PHP = internal.Register(MustNewLexer(
|
||||
CaseInsensitive: true,
|
||||
EnsureNL: true,
|
||||
},
|
||||
phpCommonRules.Rename("php", "root"),
|
||||
phpRules,
|
||||
))
|
||||
|
||||
var phpCommonRules = Rules{
|
||||
"php": {
|
||||
{`\?>`, CommentPreproc, Pop(1)},
|
||||
{`(<<<)([\'"]?)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*)(\2\n.*?\n\s*)(\3)(;?)(\n)`, ByGroups(LiteralString, LiteralString, LiteralStringDelimiter, LiteralString, LiteralStringDelimiter, Punctuation, Text), nil},
|
||||
{`\s+`, Text, nil},
|
||||
{`#.*?\n`, CommentSingle, nil},
|
||||
{`//.*?\n`, CommentSingle, nil},
|
||||
{`/\*\*/`, CommentMultiline, nil},
|
||||
{`/\*\*.*?\*/`, LiteralStringDoc, nil},
|
||||
{`/\*.*?\*/`, CommentMultiline, nil},
|
||||
{`(->|::)(\s*)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*)`, ByGroups(Operator, Text, NameAttribute), nil},
|
||||
{`[~!%^&*+=|:.<>/@-]+`, Operator, nil},
|
||||
{`\?`, Operator, nil},
|
||||
{`[\[\]{}();,]+`, Punctuation, nil},
|
||||
{`(class)(\s+)`, ByGroups(Keyword, Text), Push("classname")},
|
||||
{`(function)(\s*)(?=\()`, ByGroups(Keyword, Text), nil},
|
||||
{`(function)(\s+)(&?)(\s*)`, ByGroups(Keyword, Text, Operator, Text), Push("functionname")},
|
||||
{`(const)(\s+)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*)`, ByGroups(Keyword, Text, NameConstant), nil},
|
||||
{`(and|E_PARSE|old_function|E_ERROR|or|as|E_WARNING|parent|eval|PHP_OS|break|exit|case|extends|PHP_VERSION|cfunction|FALSE|print|for|require|continue|foreach|require_once|declare|return|default|static|do|switch|die|stdClass|echo|else|TRUE|elseif|var|empty|if|xor|enddeclare|include|virtual|endfor|include_once|while|endforeach|global|endif|list|endswitch|new|endwhile|not|array|E_ALL|NULL|final|php_user_filter|interface|implements|public|private|protected|abstract|clone|try|catch|throw|this|use|namespace|trait|yield|finally)\b`, Keyword, nil},
|
||||
{`(true|false|null)\b`, KeywordConstant, nil},
|
||||
Include("magicconstants"),
|
||||
{`\$\{\$+(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*\}`, NameVariable, nil},
|
||||
{`\$+(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*`, NameVariable, nil},
|
||||
{`(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*`, NameOther, nil},
|
||||
{`(\d+\.\d*|\d*\.\d+)(e[+-]?[0-9]+)?`, LiteralNumberFloat, nil},
|
||||
{`\d+e[+-]?[0-9]+`, LiteralNumberFloat, nil},
|
||||
{`0[0-7]+`, LiteralNumberOct, nil},
|
||||
{`0x[a-f0-9]+`, LiteralNumberHex, nil},
|
||||
{`[\d_]+`, LiteralNumberInteger, nil},
|
||||
{`0b[01]+`, LiteralNumberBin, nil},
|
||||
{`'([^'\\]*(?:\\.[^'\\]*)*)'`, LiteralStringSingle, nil},
|
||||
{"`([^`\\\\]*(?:\\\\.[^`\\\\]*)*)`", LiteralStringBacktick, nil},
|
||||
{`"`, LiteralStringDouble, Push("string")},
|
||||
},
|
||||
"magicfuncs": {
|
||||
{Words(``, `\b`, `__construct`, `__destruct`, `__call`, `__callStatic`, `__get`, `__set`, `__isset`, `__unset`, `__sleep`, `__wakeup`, `__toString`, `__invoke`, `__set_state`, `__clone`, `__debugInfo`), NameFunctionMagic, nil},
|
||||
},
|
||||
"magicconstants": {
|
||||
{Words(``, `\b`, `__LINE__`, `__FILE__`, `__DIR__`, `__FUNCTION__`, `__CLASS__`, `__TRAIT__`, `__METHOD__`, `__NAMESPACE__`), NameConstant, nil},
|
||||
},
|
||||
"classname": {
|
||||
{`(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*`, NameClass, Pop(1)},
|
||||
},
|
||||
"functionname": {
|
||||
Include("magicfuncs"),
|
||||
{`(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*`, NameFunction, Pop(1)},
|
||||
Default(Pop(1)),
|
||||
},
|
||||
"string": {
|
||||
{`"`, LiteralStringDouble, Pop(1)},
|
||||
{`[^{$"\\]+`, LiteralStringDouble, nil},
|
||||
{`\\([nrt"$\\]|[0-7]{1,3}|x[0-9a-f]{1,2})`, LiteralStringEscape, nil},
|
||||
{`\$(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*(\[\S+?\]|->(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*)?`, LiteralStringInterpol, nil},
|
||||
{`(\{\$\{)(.*?)(\}\})`, ByGroups(LiteralStringInterpol, UsingSelf("root"), LiteralStringInterpol), nil},
|
||||
{`(\{)(\$.*?)(\})`, ByGroups(LiteralStringInterpol, UsingSelf("root"), LiteralStringInterpol), nil},
|
||||
{`(\$\{)(\S+)(\})`, ByGroups(LiteralStringInterpol, NameVariable, LiteralStringInterpol), nil},
|
||||
{`[${\\]`, LiteralStringDouble, nil},
|
||||
},
|
||||
func phpRules() Rules {
|
||||
return phpCommonRules().Rename("php", "root")
|
||||
}
|
||||
|
||||
func phpCommonRules() Rules {
|
||||
return Rules{
|
||||
"php": {
|
||||
{`\?>`, CommentPreproc, Pop(1)},
|
||||
{`(<<<)([\'"]?)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*)(\2\n.*?\n\s*)(\3)(;?)(\n)`, ByGroups(LiteralString, LiteralString, LiteralStringDelimiter, LiteralString, LiteralStringDelimiter, Punctuation, Text), nil},
|
||||
{`\s+`, Text, nil},
|
||||
{`#.*?\n`, CommentSingle, nil},
|
||||
{`//.*?\n`, CommentSingle, nil},
|
||||
{`/\*\*/`, CommentMultiline, nil},
|
||||
{`/\*\*.*?\*/`, LiteralStringDoc, nil},
|
||||
{`/\*.*?\*/`, CommentMultiline, nil},
|
||||
{`(->|::)(\s*)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*)`, ByGroups(Operator, Text, NameAttribute), nil},
|
||||
{`[~!%^&*+=|:.<>/@-]+`, Operator, nil},
|
||||
{`\?`, Operator, nil},
|
||||
{`[\[\]{}();,]+`, Punctuation, nil},
|
||||
{`(class)(\s+)`, ByGroups(Keyword, Text), Push("classname")},
|
||||
{`(function)(\s*)(?=\()`, ByGroups(Keyword, Text), nil},
|
||||
{`(function)(\s+)(&?)(\s*)`, ByGroups(Keyword, Text, Operator, Text), Push("functionname")},
|
||||
{`(const)(\s+)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*)`, ByGroups(Keyword, Text, NameConstant), nil},
|
||||
{`(and|E_PARSE|old_function|E_ERROR|or|as|E_WARNING|parent|eval|PHP_OS|break|exit|case|extends|PHP_VERSION|cfunction|FALSE|print|for|require|continue|foreach|require_once|declare|return|default|static|do|switch|die|stdClass|echo|else|TRUE|elseif|var|empty|if|xor|enddeclare|include|virtual|endfor|include_once|while|endforeach|global|endif|list|endswitch|new|endwhile|not|array|E_ALL|NULL|final|php_user_filter|interface|implements|public|private|protected|abstract|clone|try|catch|throw|this|use|namespace|trait|yield|finally)\b`, Keyword, nil},
|
||||
{`(true|false|null)\b`, KeywordConstant, nil},
|
||||
Include("magicconstants"),
|
||||
{`\$\{\$+(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*\}`, NameVariable, nil},
|
||||
{`\$+(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*`, NameVariable, nil},
|
||||
{`(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*`, NameOther, nil},
|
||||
{`(\d+\.\d*|\d*\.\d+)(e[+-]?[0-9]+)?`, LiteralNumberFloat, nil},
|
||||
{`\d+e[+-]?[0-9]+`, LiteralNumberFloat, nil},
|
||||
{`0[0-7]+`, LiteralNumberOct, nil},
|
||||
{`0x[a-f0-9]+`, LiteralNumberHex, nil},
|
||||
{`[\d_]+`, LiteralNumberInteger, nil},
|
||||
{`0b[01]+`, LiteralNumberBin, nil},
|
||||
{`'([^'\\]*(?:\\.[^'\\]*)*)'`, LiteralStringSingle, nil},
|
||||
{"`([^`\\\\]*(?:\\\\.[^`\\\\]*)*)`", LiteralStringBacktick, nil},
|
||||
{`"`, LiteralStringDouble, Push("string")},
|
||||
},
|
||||
"magicfuncs": {
|
||||
{Words(``, `\b`, `__construct`, `__destruct`, `__call`, `__callStatic`, `__get`, `__set`, `__isset`, `__unset`, `__sleep`, `__wakeup`, `__toString`, `__invoke`, `__set_state`, `__clone`, `__debugInfo`), NameFunctionMagic, nil},
|
||||
},
|
||||
"magicconstants": {
|
||||
{Words(``, `\b`, `__LINE__`, `__FILE__`, `__DIR__`, `__FUNCTION__`, `__CLASS__`, `__TRAIT__`, `__METHOD__`, `__NAMESPACE__`), NameConstant, nil},
|
||||
},
|
||||
"classname": {
|
||||
{`(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*`, NameClass, Pop(1)},
|
||||
},
|
||||
"functionname": {
|
||||
Include("magicfuncs"),
|
||||
{`(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*`, NameFunction, Pop(1)},
|
||||
Default(Pop(1)),
|
||||
},
|
||||
"string": {
|
||||
{`"`, LiteralStringDouble, Pop(1)},
|
||||
{`[^{$"\\]+`, LiteralStringDouble, nil},
|
||||
{`\\([nrt"$\\]|[0-7]{1,3}|x[0-9a-f]{1,2})`, LiteralStringEscape, nil},
|
||||
{`\$(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*(\[\S+?\]|->(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w]|[^\x00-\x7f])*)?`, LiteralStringInterpol, nil},
|
||||
{`(\{\$\{)(.*?)(\}\})`, ByGroups(LiteralStringInterpol, UsingSelf("root"), LiteralStringInterpol), nil},
|
||||
{`(\{)(\$.*?)(\})`, ByGroups(LiteralStringInterpol, UsingSelf("root"), LiteralStringInterpol), nil},
|
||||
{`(\$\{)(\S+)(\})`, ByGroups(LiteralStringInterpol, NameVariable, LiteralStringInterpol), nil},
|
||||
{`[${\\]`, LiteralStringDouble, nil},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
@ -9,7 +9,7 @@ import (
|
||||
)
|
||||
|
||||
// PHTML lexer is PHP in HTML.
|
||||
var PHTML = internal.Register(DelegatingLexer(h.HTML, MustNewLexer(
|
||||
var PHTML = internal.Register(DelegatingLexer(h.HTML, MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "PHTML",
|
||||
Aliases: []string{"phtml"},
|
||||
@ -19,16 +19,20 @@ var PHTML = internal.Register(DelegatingLexer(h.HTML, MustNewLexer(
|
||||
CaseInsensitive: true,
|
||||
EnsureNL: true,
|
||||
},
|
||||
Rules{
|
||||
"root": {
|
||||
{`<\?(php)?`, CommentPreproc, Push("php")},
|
||||
{`[^<]+`, Other, nil},
|
||||
{`<`, Other, nil},
|
||||
},
|
||||
}.Merge(phpCommonRules),
|
||||
phtmlRules,
|
||||
).SetAnalyser(func(text string) float32 {
|
||||
if strings.Contains(text, "<?php") {
|
||||
return 0.5
|
||||
}
|
||||
return 0.0
|
||||
})))
|
||||
|
||||
func phtmlRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`<\?(php)?`, CommentPreproc, Push("php")},
|
||||
{`[^<]+`, Other, nil},
|
||||
{`<`, Other, nil},
|
||||
},
|
||||
}.Merge(phpCommonRules())
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// D lexer. https://dlang.org/spec/lex.html
|
||||
var D = internal.Register(MustNewLexer(
|
||||
var D = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "D",
|
||||
Aliases: []string{"d"},
|
||||
@ -14,7 +14,11 @@ var D = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-d"},
|
||||
EnsureNL: true,
|
||||
},
|
||||
Rules{
|
||||
dRules,
|
||||
))
|
||||
|
||||
func dRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`[^\S\n]+`, Text, nil},
|
||||
|
||||
@ -65,5 +69,5 @@ var D = internal.Register(MustNewLexer(
|
||||
"import": {
|
||||
{`[\w.]+\*?`, NameNamespace, Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Dart lexer.
|
||||
var Dart = internal.Register(MustNewLexer(
|
||||
var Dart = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Dart",
|
||||
Aliases: []string{"dart"},
|
||||
@ -14,7 +14,11 @@ var Dart = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-dart"},
|
||||
DotAll: true,
|
||||
},
|
||||
Rules{
|
||||
dartRules,
|
||||
))
|
||||
|
||||
func dartRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
Include("string_literal"),
|
||||
{`#!(.*?)$`, CommentPreproc, nil},
|
||||
@ -87,5 +91,5 @@ var Dart = internal.Register(MustNewLexer(
|
||||
Include("string_common"),
|
||||
{`(\$|\')+`, LiteralStringSingle, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Diff lexer.
|
||||
var Diff = internal.Register(MustNewLexer(
|
||||
var Diff = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Diff",
|
||||
Aliases: []string{"diff", "udiff"},
|
||||
@ -14,7 +14,11 @@ var Diff = internal.Register(MustNewLexer(
|
||||
Filenames: []string{"*.diff", "*.patch"},
|
||||
MimeTypes: []string{"text/x-diff", "text/x-patch"},
|
||||
},
|
||||
Rules{
|
||||
diffRules,
|
||||
))
|
||||
|
||||
func diffRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{` .*\n`, Text, nil},
|
||||
{`\+.*\n`, GenericInserted, nil},
|
||||
@ -25,5 +29,5 @@ var Diff = internal.Register(MustNewLexer(
|
||||
{`=.*\n`, GenericHeading, nil},
|
||||
{`.*\n`, Text, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Django/Jinja lexer.
|
||||
var DjangoJinja = internal.Register(MustNewLexer(
|
||||
var DjangoJinja = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Django/Jinja",
|
||||
Aliases: []string{"django", "jinja"},
|
||||
@ -14,7 +14,11 @@ var DjangoJinja = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"application/x-django-templating", "application/x-jinja"},
|
||||
DotAll: true,
|
||||
},
|
||||
Rules{
|
||||
djangoJinjaRules,
|
||||
))
|
||||
|
||||
func djangoJinjaRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`[^{]+`, Other, nil},
|
||||
{`\{\{`, CommentPreproc, Push("var")},
|
||||
@ -49,5 +53,5 @@ var DjangoJinja = internal.Register(MustNewLexer(
|
||||
Include("varnames"),
|
||||
{`.`, Punctuation, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -8,7 +8,7 @@ import (
|
||||
)
|
||||
|
||||
// Docker lexer.
|
||||
var Docker = internal.Register(MustNewLexer(
|
||||
var Docker = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Docker",
|
||||
Aliases: []string{"docker", "dockerfile"},
|
||||
@ -16,7 +16,11 @@ var Docker = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-dockerfile-config"},
|
||||
CaseInsensitive: true,
|
||||
},
|
||||
Rules{
|
||||
dockerRules,
|
||||
))
|
||||
|
||||
func dockerRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`#.*`, Comment, nil},
|
||||
{`(ONBUILD)((?:\s*\\?\s*))`, ByGroups(Keyword, Using(b.Bash)), nil},
|
||||
@ -27,5 +31,5 @@ var Docker = internal.Register(MustNewLexer(
|
||||
{`((?:RUN|CMD|ENTRYPOINT|ENV|ARG|LABEL|ADD|COPY))`, Keyword, nil},
|
||||
{`(.*\\\n)*.+`, Using(b.Bash), nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Dtd lexer.
|
||||
var Dtd = internal.Register(MustNewLexer(
|
||||
var Dtd = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "DTD",
|
||||
Aliases: []string{"dtd"},
|
||||
@ -14,7 +14,11 @@ var Dtd = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"application/xml-dtd"},
|
||||
DotAll: true,
|
||||
},
|
||||
Rules{
|
||||
dtdRules,
|
||||
))
|
||||
|
||||
func dtdRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
Include("common"),
|
||||
{`(<!ELEMENT)(\s+)(\S+)`, ByGroups(Keyword, Text, NameTag), Push("element")},
|
||||
@ -65,5 +69,5 @@ var Dtd = internal.Register(MustNewLexer(
|
||||
{`[^>\s|()?+*,]+`, NameAttribute, nil},
|
||||
{`>`, Keyword, Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Ebnf lexer.
|
||||
var Ebnf = internal.Register(MustNewLexer(
|
||||
var Ebnf = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "EBNF",
|
||||
Aliases: []string{"ebnf"},
|
||||
Filenames: []string{"*.ebnf"},
|
||||
MimeTypes: []string{"text/x-ebnf"},
|
||||
},
|
||||
Rules{
|
||||
ebnfRules,
|
||||
))
|
||||
|
||||
func ebnfRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
Include("whitespace"),
|
||||
Include("comment_start"),
|
||||
@ -47,5 +51,5 @@ var Ebnf = internal.Register(MustNewLexer(
|
||||
"identifier": {
|
||||
{`([a-zA-Z][\w \-]*)`, Keyword, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Elixir lexer.
|
||||
var Elixir = internal.Register(MustNewLexer(
|
||||
var Elixir = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Elixir",
|
||||
Aliases: []string{"elixir", "ex", "exs"},
|
||||
Filenames: []string{"*.ex", "*.exs"},
|
||||
MimeTypes: []string{"text/x-elixir"},
|
||||
},
|
||||
Rules{
|
||||
elixirRules,
|
||||
))
|
||||
|
||||
func elixirRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\s+`, Text, nil},
|
||||
{`#.*$`, CommentSingle, nil},
|
||||
@ -273,5 +277,5 @@ var Elixir = internal.Register(MustNewLexer(
|
||||
{`\\.`, LiteralStringOther, nil},
|
||||
{`'[a-zA-Z]*`, LiteralStringOther, Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Elm lexer.
|
||||
var Elm = internal.Register(MustNewLexer(
|
||||
var Elm = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Elm",
|
||||
Aliases: []string{"elm"},
|
||||
Filenames: []string{"*.elm"},
|
||||
MimeTypes: []string{"text/x-elm"},
|
||||
},
|
||||
Rules{
|
||||
elmRules,
|
||||
))
|
||||
|
||||
func elmRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\{-`, CommentMultiline, Push("comment")},
|
||||
{`--.*`, CommentSingle, nil},
|
||||
@ -55,5 +59,5 @@ var Elm = internal.Register(MustNewLexer(
|
||||
{`\|\]`, NameEntity, Pop(1)},
|
||||
{`.*\n`, NameEntity, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -522,14 +522,24 @@ var (
|
||||
)
|
||||
|
||||
// EmacsLisp lexer.
|
||||
var EmacsLisp = internal.Register(TypeRemappingLexer(MustNewLexer(
|
||||
var EmacsLisp = internal.Register(TypeRemappingLexer(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "EmacsLisp",
|
||||
Aliases: []string{"emacs", "elisp", "emacs-lisp"},
|
||||
Filenames: []string{"*.el"},
|
||||
MimeTypes: []string{"text/x-elisp", "application/x-elisp"},
|
||||
},
|
||||
Rules{
|
||||
emacsLispRules,
|
||||
), TypeMapping{
|
||||
{NameVariable, NameFunction, emacsBuiltinFunction},
|
||||
{NameVariable, NameBuiltin, emacsSpecialForms},
|
||||
{NameVariable, NameException, emacsErrorKeywords},
|
||||
{NameVariable, NameBuiltin, append(emacsBuiltinFunctionHighlighted, emacsMacros...)},
|
||||
{NameVariable, KeywordPseudo, emacsLambdaListKeywords},
|
||||
}))
|
||||
|
||||
func emacsLispRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
Default(Push("body")),
|
||||
},
|
||||
@ -572,11 +582,5 @@ var EmacsLisp = internal.Register(TypeRemappingLexer(MustNewLexer(
|
||||
{`\\\n`, LiteralString, nil},
|
||||
{`"`, LiteralString, Pop(1)},
|
||||
},
|
||||
},
|
||||
), TypeMapping{
|
||||
{NameVariable, NameFunction, emacsBuiltinFunction},
|
||||
{NameVariable, NameBuiltin, emacsSpecialForms},
|
||||
{NameVariable, NameException, emacsErrorKeywords},
|
||||
{NameVariable, NameBuiltin, append(emacsBuiltinFunctionHighlighted, emacsMacros...)},
|
||||
{NameVariable, KeywordPseudo, emacsLambdaListKeywords},
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Erlang lexer.
|
||||
var Erlang = internal.Register(MustNewLexer(
|
||||
var Erlang = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Erlang",
|
||||
Aliases: []string{"erlang"},
|
||||
Filenames: []string{"*.erl", "*.hrl", "*.es", "*.escript"},
|
||||
MimeTypes: []string{"text/x-erlang"},
|
||||
},
|
||||
Rules{
|
||||
erlangRules,
|
||||
))
|
||||
|
||||
func erlangRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\s+`, Text, nil},
|
||||
{`%.*\n`, Comment, nil},
|
||||
@ -62,5 +66,5 @@ var Erlang = internal.Register(MustNewLexer(
|
||||
{`,`, Punctuation, Pop(1)},
|
||||
{`(?=\})`, Punctuation, Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Factor lexer.
|
||||
var Factor = internal.Register(MustNewLexer(
|
||||
var Factor = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Factor",
|
||||
Aliases: []string{"factor"},
|
||||
Filenames: []string{"*.factor"},
|
||||
MimeTypes: []string{"text/x-factor"},
|
||||
},
|
||||
Rules{
|
||||
factorRules,
|
||||
))
|
||||
|
||||
func factorRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`#!.*$`, CommentPreproc, nil},
|
||||
Default(Push("base")),
|
||||
@ -111,5 +115,5 @@ var Factor = internal.Register(MustNewLexer(
|
||||
{`;\s`, Keyword, Pop(1)},
|
||||
{`\S+`, NameFunction, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Fish lexer.
|
||||
var Fish = internal.Register(MustNewLexer(
|
||||
var Fish = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Fish",
|
||||
Aliases: []string{"fish", "fishshell"},
|
||||
Filenames: []string{"*.fish", "*.load"},
|
||||
MimeTypes: []string{"application/x-fish"},
|
||||
},
|
||||
Rules{
|
||||
fishRules,
|
||||
))
|
||||
|
||||
func fishRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
Include("basic"),
|
||||
Include("data"),
|
||||
@ -61,5 +65,5 @@ var Fish = internal.Register(MustNewLexer(
|
||||
{`\d+`, LiteralNumber, nil},
|
||||
Include("root"),
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Forth lexer.
|
||||
var Forth = internal.Register(MustNewLexer(
|
||||
var Forth = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Forth",
|
||||
Aliases: []string{"forth"},
|
||||
@ -14,7 +14,11 @@ var Forth = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"application/x-forth"},
|
||||
CaseInsensitive: true,
|
||||
},
|
||||
Rules{
|
||||
forthRules,
|
||||
))
|
||||
|
||||
func forthRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\s+`, Text, nil},
|
||||
{`\\.*?\n`, CommentSingle, nil},
|
||||
@ -36,5 +40,5 @@ var Forth = internal.Register(MustNewLexer(
|
||||
"stringdef": {
|
||||
{`[^"]+`, LiteralString, Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Fortran lexer.
|
||||
var Fortran = internal.Register(MustNewLexer(
|
||||
var Fortran = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Fortran",
|
||||
Aliases: []string{"fortran"},
|
||||
@ -14,7 +14,11 @@ var Fortran = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-fortran"},
|
||||
CaseInsensitive: true,
|
||||
},
|
||||
Rules{
|
||||
fortranRules,
|
||||
))
|
||||
|
||||
func fortranRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`^#.*\n`, CommentPreproc, nil},
|
||||
{`!.*\n`, Comment, nil},
|
||||
@ -43,5 +47,5 @@ var Fortran = internal.Register(MustNewLexer(
|
||||
{`[+-]?\d*\.\d+([ed][-+]?\d+)?(_[a-z]\w+)?`, LiteralNumberFloat, nil},
|
||||
{`[+-]?\d+\.\d*([ed][-+]?\d+)?(_[a-z]\w+)?`, LiteralNumberFloat, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Fsharp lexer.
|
||||
var Fsharp = internal.Register(MustNewLexer(
|
||||
var Fsharp = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "FSharp",
|
||||
Aliases: []string{"fsharp"},
|
||||
Filenames: []string{"*.fs", "*.fsi"},
|
||||
MimeTypes: []string{"text/x-fsharp"},
|
||||
},
|
||||
Rules{
|
||||
fsharpRules,
|
||||
))
|
||||
|
||||
func fsharpRules() Rules {
|
||||
return Rules{
|
||||
"escape-sequence": {
|
||||
{`\\[\\"\'ntbrafv]`, LiteralStringEscape, nil},
|
||||
{`\\[0-9]{3}`, LiteralStringEscape, nil},
|
||||
@ -90,5 +94,5 @@ var Fsharp = internal.Register(MustNewLexer(
|
||||
{`"""B?`, LiteralString, Pop(1)},
|
||||
{`"`, LiteralString, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Gas lexer.
|
||||
var Gas = internal.Register(MustNewLexer(
|
||||
var Gas = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "GAS",
|
||||
Aliases: []string{"gas", "asm"},
|
||||
Filenames: []string{"*.s", "*.S"},
|
||||
MimeTypes: []string{"text/x-gas"},
|
||||
},
|
||||
Rules{
|
||||
gasRules,
|
||||
))
|
||||
|
||||
func gasRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
Include("whitespace"),
|
||||
{`(?:[a-zA-Z$_][\w$.@-]*|\.[\w$.@-]+):`, NameLabel, nil},
|
||||
@ -51,5 +55,5 @@ var Gas = internal.Register(MustNewLexer(
|
||||
"punctuation": {
|
||||
{`[-*,.()\[\]!:]+`, Punctuation, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// GDScript lexer.
|
||||
var GDScript = internal.Register(MustNewLexer(
|
||||
var GDScript = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "GDScript",
|
||||
Aliases: []string{"gdscript", "gd"},
|
||||
Filenames: []string{"*.gd"},
|
||||
MimeTypes: []string{"text/x-gdscript", "application/x-gdscript"},
|
||||
},
|
||||
Rules{
|
||||
gdscriptRules,
|
||||
))
|
||||
|
||||
func gdscriptRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\n`, Text, nil},
|
||||
{`^(\s*)([rRuUbB]{,2})("""(?:.|\n)*?""")`, ByGroups(Text, LiteralStringAffix, LiteralStringDoc), nil},
|
||||
@ -120,5 +124,5 @@ var GDScript = internal.Register(MustNewLexer(
|
||||
Include("strings-single"),
|
||||
{`\n`, LiteralStringSingle, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -7,14 +7,18 @@ import (
|
||||
)
|
||||
|
||||
// Genshi Text lexer.
|
||||
var GenshiText = internal.Register(MustNewLexer(
|
||||
var GenshiText = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Genshi Text",
|
||||
Aliases: []string{"genshitext"},
|
||||
Filenames: []string{},
|
||||
MimeTypes: []string{"application/x-genshi-text", "text/x-genshi"},
|
||||
},
|
||||
Rules{
|
||||
genshiTextRules,
|
||||
))
|
||||
|
||||
func genshiTextRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`[^#$\s]+`, Other, nil},
|
||||
{`^(\s*)(##.*)$`, ByGroups(Text, Comment), nil},
|
||||
@ -33,11 +37,11 @@ var GenshiText = internal.Register(MustNewLexer(
|
||||
{`(?<!\$)(\$\{)(.+?)(\})`, ByGroups(CommentPreproc, Using(Python), CommentPreproc), nil},
|
||||
{`(?<!\$)(\$)([a-zA-Z_][\w.]*)`, NameVariable, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
// Html+Genshi lexer.
|
||||
var GenshiHTMLTemplate = internal.Register(MustNewLexer(
|
||||
var GenshiHTMLTemplate = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Genshi HTML",
|
||||
Aliases: []string{"html+genshi", "html+kid"},
|
||||
@ -50,7 +54,7 @@ var GenshiHTMLTemplate = internal.Register(MustNewLexer(
|
||||
))
|
||||
|
||||
// Genshi lexer.
|
||||
var Genshi = internal.Register(MustNewLexer(
|
||||
var Genshi = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Genshi",
|
||||
Aliases: []string{"genshi", "kid", "xml+genshi", "xml+kid"},
|
||||
@ -62,53 +66,55 @@ var Genshi = internal.Register(MustNewLexer(
|
||||
genshiMarkupRules,
|
||||
))
|
||||
|
||||
var genshiMarkupRules = Rules{
|
||||
"root": {
|
||||
{`[^<$]+`, Other, nil},
|
||||
{`(<\?python)(.*?)(\?>)`, ByGroups(CommentPreproc, Using(Python), CommentPreproc), nil},
|
||||
{`<\s*(script|style)\s*.*?>.*?<\s*/\1\s*>`, Other, nil},
|
||||
{`<\s*py:[a-zA-Z0-9]+`, NameTag, Push("pytag")},
|
||||
{`<\s*[a-zA-Z0-9:.]+`, NameTag, Push("tag")},
|
||||
Include("variable"),
|
||||
{`[<$]`, Other, nil},
|
||||
},
|
||||
"pytag": {
|
||||
{`\s+`, Text, nil},
|
||||
{`[\w:-]+\s*=`, NameAttribute, Push("pyattr")},
|
||||
{`/?\s*>`, NameTag, Pop(1)},
|
||||
},
|
||||
"pyattr": {
|
||||
{`(")(.*?)(")`, ByGroups(LiteralString, Using(Python), LiteralString), Pop(1)},
|
||||
{`(')(.*?)(')`, ByGroups(LiteralString, Using(Python), LiteralString), Pop(1)},
|
||||
{`[^\s>]+`, LiteralString, Pop(1)},
|
||||
},
|
||||
"tag": {
|
||||
{`\s+`, Text, nil},
|
||||
{`py:[\w-]+\s*=`, NameAttribute, Push("pyattr")},
|
||||
{`[\w:-]+\s*=`, NameAttribute, Push("attr")},
|
||||
{`/?\s*>`, NameTag, Pop(1)},
|
||||
},
|
||||
"attr": {
|
||||
{`"`, LiteralString, Push("attr-dstring")},
|
||||
{`'`, LiteralString, Push("attr-sstring")},
|
||||
{`[^\s>]*`, LiteralString, Pop(1)},
|
||||
},
|
||||
"attr-dstring": {
|
||||
{`"`, LiteralString, Pop(1)},
|
||||
Include("strings"),
|
||||
{`'`, LiteralString, nil},
|
||||
},
|
||||
"attr-sstring": {
|
||||
{`'`, LiteralString, Pop(1)},
|
||||
Include("strings"),
|
||||
{`'`, LiteralString, nil},
|
||||
},
|
||||
"strings": {
|
||||
{`[^"'$]+`, LiteralString, nil},
|
||||
Include("variable"),
|
||||
},
|
||||
"variable": {
|
||||
{`(?<!\$)(\$\{)(.+?)(\})`, ByGroups(CommentPreproc, Using(Python), CommentPreproc), nil},
|
||||
{`(?<!\$)(\$)([a-zA-Z_][\w\.]*)`, NameVariable, nil},
|
||||
},
|
||||
func genshiMarkupRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`[^<$]+`, Other, nil},
|
||||
{`(<\?python)(.*?)(\?>)`, ByGroups(CommentPreproc, Using(Python), CommentPreproc), nil},
|
||||
{`<\s*(script|style)\s*.*?>.*?<\s*/\1\s*>`, Other, nil},
|
||||
{`<\s*py:[a-zA-Z0-9]+`, NameTag, Push("pytag")},
|
||||
{`<\s*[a-zA-Z0-9:.]+`, NameTag, Push("tag")},
|
||||
Include("variable"),
|
||||
{`[<$]`, Other, nil},
|
||||
},
|
||||
"pytag": {
|
||||
{`\s+`, Text, nil},
|
||||
{`[\w:-]+\s*=`, NameAttribute, Push("pyattr")},
|
||||
{`/?\s*>`, NameTag, Pop(1)},
|
||||
},
|
||||
"pyattr": {
|
||||
{`(")(.*?)(")`, ByGroups(LiteralString, Using(Python), LiteralString), Pop(1)},
|
||||
{`(')(.*?)(')`, ByGroups(LiteralString, Using(Python), LiteralString), Pop(1)},
|
||||
{`[^\s>]+`, LiteralString, Pop(1)},
|
||||
},
|
||||
"tag": {
|
||||
{`\s+`, Text, nil},
|
||||
{`py:[\w-]+\s*=`, NameAttribute, Push("pyattr")},
|
||||
{`[\w:-]+\s*=`, NameAttribute, Push("attr")},
|
||||
{`/?\s*>`, NameTag, Pop(1)},
|
||||
},
|
||||
"attr": {
|
||||
{`"`, LiteralString, Push("attr-dstring")},
|
||||
{`'`, LiteralString, Push("attr-sstring")},
|
||||
{`[^\s>]*`, LiteralString, Pop(1)},
|
||||
},
|
||||
"attr-dstring": {
|
||||
{`"`, LiteralString, Pop(1)},
|
||||
Include("strings"),
|
||||
{`'`, LiteralString, nil},
|
||||
},
|
||||
"attr-sstring": {
|
||||
{`'`, LiteralString, Pop(1)},
|
||||
Include("strings"),
|
||||
{`'`, LiteralString, nil},
|
||||
},
|
||||
"strings": {
|
||||
{`[^"'$]+`, LiteralString, nil},
|
||||
Include("variable"),
|
||||
},
|
||||
"variable": {
|
||||
{`(?<!\$)(\$\{)(.+?)(\})`, ByGroups(CommentPreproc, Using(Python), CommentPreproc), nil},
|
||||
{`(?<!\$)(\$)([a-zA-Z_][\w\.]*)`, NameVariable, nil},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
@ -5,23 +5,27 @@ import (
|
||||
"github.com/alecthomas/chroma/lexers/internal"
|
||||
)
|
||||
|
||||
var stepKeywords = `^(\s*)(하지만|조건|먼저|만일|만약|단|그리고|그러면|那麼|那么|而且|當|当|前提|假設|假设|假如|假定|但是|但し|並且|并且|同時|同时|もし|ならば|ただし|しかし|かつ|و |متى |لكن |عندما |ثم |بفرض |اذاً |כאשר |וגם |בהינתן |אזי |אז |אבל |Якщо |Унда |То |Припустимо, що |Припустимо |Онда |Но |Нехай |Лекин |Когато |Када |Кад |К тому же |И |Задато |Задати |Задате |Если |Допустим |Дадено |Ва |Бирок |Аммо |Али |Але |Агар |А |І |Și |És |Zatati |Zakładając |Zadato |Zadate |Zadano |Zadani |Zadan |Youse know when youse got |Youse know like when |Yna |Ya know how |Ya gotta |Y |Wun |Wtedy |When y'all |When |Wenn |WEN |Và |Ve |Und |Un |Thì |Then y'all |Then |Tapi |Tak |Tada |Tad |Så |Stel |Soit |Siis |Si |Sed |Se |Quando |Quand |Quan |Pryd |Pokud |Pokiaľ |Però |Pero |Pak |Oraz |Onda |Ond |Oletetaan |Og |Och |O zaman |Når |När |Niin |Nhưng |N |Mutta |Men |Mas |Maka |Majd |Mais |Maar |Ma |Lorsque |Lorsqu'|Kun |Kuid |Kui |Khi |Keď |Ketika |Když |Kaj |Kai |Kada |Kad |Jeżeli |Ja |Ir |I CAN HAZ |I |Ha |Givun |Givet |Given y'all |Given |Gitt |Gegeven |Gegeben sei |Fakat |Eğer ki |Etant donné |Et |Então |Entonces |Entao |En |Eeldades |E |Duota |Dun |Donitaĵo |Donat |Donada |Do |Diyelim ki |Dengan |Den youse gotta |De |Dato |Dar |Dann |Dan |Dado |Dacă |Daca |DEN |Când |Cuando |Cho |Cept |Cand |Cal |But y'all |But |Buh |Biết |Bet |BUT |Atès |Atunci |Atesa |Anrhegedig a |Angenommen |And y'all |And |An |Ama |Als |Alors |Allora |Ali |Aleshores |Ale |Akkor |Aber |AN |A také |A |\* )`
|
||||
|
||||
var featureKeywords = `^(기능|機能|功能|フィーチャ|خاصية|תכונה|Функціонал|Функционалност|Функционал|Фича|Особина|Могућност|Özellik|Właściwość|Tính năng|Trajto|Savybė|Požiadavka|Požadavek|Osobina|Ominaisuus|Omadus|OH HAI|Mogućnost|Mogucnost|Jellemző|Fīča|Funzionalità|Funktionalität|Funkcionalnost|Funkcionalitāte|Funcționalitate|Functionaliteit|Functionalitate|Funcionalitat|Funcionalidade|Fonctionnalité|Fitur|Feature|Egenskap|Egenskab|Crikey|Característica|Arwedd)(:)(.*)$`
|
||||
|
||||
var featureElementKeywords = `^(\s*)(시나리오 개요|시나리오|배경|背景|場景大綱|場景|场景大纲|场景|劇本大綱|劇本|剧本大纲|剧本|テンプレ|シナリオテンプレート|シナリオテンプレ|シナリオアウトライン|シナリオ|سيناريو مخطط|سيناريو|الخلفية|תרחיש|תבנית תרחיש|רקע|Тарих|Сценарій|Сценарио|Сценарий структураси|Сценарий|Структура сценарію|Структура сценарија|Структура сценария|Скица|Рамка на сценарий|Пример|Предыстория|Предистория|Позадина|Передумова|Основа|Концепт|Контекст|Założenia|Wharrimean is|Tình huống|The thing of it is|Tausta|Taust|Tapausaihio|Tapaus|Szenariogrundriss|Szenario|Szablon scenariusza|Stsenaarium|Struktura scenarija|Skica|Skenario konsep|Skenario|Situācija|Senaryo taslağı|Senaryo|Scénář|Scénario|Schema dello scenario|Scenārijs pēc parauga|Scenārijs|Scenár|Scenaro|Scenariusz|Scenariul de şablon|Scenariul de sablon|Scenariu|Scenario Outline|Scenario Amlinellol|Scenario|Scenarijus|Scenarijaus šablonas|Scenarij|Scenarie|Rerefons|Raamstsenaarium|Primer|Pozadí|Pozadina|Pozadie|Plan du scénario|Plan du Scénario|Osnova scénáře|Osnova|Náčrt Scénáře|Náčrt Scenáru|Mate|MISHUN SRSLY|MISHUN|Kịch bản|Konturo de la scenaro|Kontext|Konteksts|Kontekstas|Kontekst|Koncept|Khung tình huống|Khung kịch bản|Háttér|Grundlage|Geçmiş|Forgatókönyv vázlat|Forgatókönyv|Fono|Esquema do Cenário|Esquema do Cenario|Esquema del escenario|Esquema de l'escenari|Escenario|Escenari|Dis is what went down|Dasar|Contexto|Contexte|Contesto|Condiţii|Conditii|Cenário|Cenario|Cefndir|Bối cảnh|Blokes|Bakgrunn|Bakgrund|Baggrund|Background|B4|Antecedents|Antecedentes|All y'all|Achtergrond|Abstrakt Scenario|Abstract Scenario)(:)(.*)$`
|
||||
|
||||
var examplesKeywords = `^(\s*)(예|例子|例|サンプル|امثلة|דוגמאות|Сценарији|Примери|Приклади|Мисоллар|Значения|Örnekler|Voorbeelden|Variantai|Tapaukset|Scenarios|Scenariji|Scenarijai|Příklady|Példák|Príklady|Przykłady|Primjeri|Primeri|Piemēri|Pavyzdžiai|Paraugs|Juhtumid|Exemplos|Exemples|Exemplele|Exempel|Examples|Esempi|Enghreifftiau|Ekzemploj|Eksempler|Ejemplos|EXAMPLZ|Dữ liệu|Contoh|Cobber|Beispiele)(:)(.*)$`
|
||||
|
||||
// Gherkin lexer.
|
||||
var Gherkin = internal.Register(MustNewLexer(
|
||||
var Gherkin = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Gherkin",
|
||||
Aliases: []string{"cucumber", "Cucumber", "gherkin", "Gherkin"},
|
||||
Filenames: []string{"*.feature", "*.FEATURE"},
|
||||
MimeTypes: []string{"text/x-gherkin"},
|
||||
},
|
||||
Rules{
|
||||
gherkinRules,
|
||||
))
|
||||
|
||||
func gherkinRules() Rules {
|
||||
stepKeywords := `^(\s*)(하지만|조건|먼저|만일|만약|단|그리고|그러면|那麼|那么|而且|當|当|前提|假設|假设|假如|假定|但是|但し|並且|并且|同時|同时|もし|ならば|ただし|しかし|かつ|و |متى |لكن |عندما |ثم |بفرض |اذاً |כאשר |וגם |בהינתן |אזי |אז |אבל |Якщо |Унда |То |Припустимо, що |Припустимо |Онда |Но |Нехай |Лекин |Когато |Када |Кад |К тому же |И |Задато |Задати |Задате |Если |Допустим |Дадено |Ва |Бирок |Аммо |Али |Але |Агар |А |І |Și |És |Zatati |Zakładając |Zadato |Zadate |Zadano |Zadani |Zadan |Youse know when youse got |Youse know like when |Yna |Ya know how |Ya gotta |Y |Wun |Wtedy |When y'all |When |Wenn |WEN |Và |Ve |Und |Un |Thì |Then y'all |Then |Tapi |Tak |Tada |Tad |Så |Stel |Soit |Siis |Si |Sed |Se |Quando |Quand |Quan |Pryd |Pokud |Pokiaľ |Però |Pero |Pak |Oraz |Onda |Ond |Oletetaan |Og |Och |O zaman |Når |När |Niin |Nhưng |N |Mutta |Men |Mas |Maka |Majd |Mais |Maar |Ma |Lorsque |Lorsqu'|Kun |Kuid |Kui |Khi |Keď |Ketika |Když |Kaj |Kai |Kada |Kad |Jeżeli |Ja |Ir |I CAN HAZ |I |Ha |Givun |Givet |Given y'all |Given |Gitt |Gegeven |Gegeben sei |Fakat |Eğer ki |Etant donné |Et |Então |Entonces |Entao |En |Eeldades |E |Duota |Dun |Donitaĵo |Donat |Donada |Do |Diyelim ki |Dengan |Den youse gotta |De |Dato |Dar |Dann |Dan |Dado |Dacă |Daca |DEN |Când |Cuando |Cho |Cept |Cand |Cal |But y'all |But |Buh |Biết |Bet |BUT |Atès |Atunci |Atesa |Anrhegedig a |Angenommen |And y'all |And |An |Ama |Als |Alors |Allora |Ali |Aleshores |Ale |Akkor |Aber |AN |A také |A |\* )`
|
||||
|
||||
featureKeywords := `^(기능|機能|功能|フィーチャ|خاصية|תכונה|Функціонал|Функционалност|Функционал|Фича|Особина|Могућност|Özellik|Właściwość|Tính năng|Trajto|Savybė|Požiadavka|Požadavek|Osobina|Ominaisuus|Omadus|OH HAI|Mogućnost|Mogucnost|Jellemző|Fīča|Funzionalità|Funktionalität|Funkcionalnost|Funkcionalitāte|Funcționalitate|Functionaliteit|Functionalitate|Funcionalitat|Funcionalidade|Fonctionnalité|Fitur|Feature|Egenskap|Egenskab|Crikey|Característica|Arwedd)(:)(.*)$`
|
||||
|
||||
featureElementKeywords := `^(\s*)(시나리오 개요|시나리오|배경|背景|場景大綱|場景|场景大纲|场景|劇本大綱|劇本|剧本大纲|剧本|テンプレ|シナリオテンプレート|シナリオテンプレ|シナリオアウトライン|シナリオ|سيناريو مخطط|سيناريو|الخلفية|תרחיש|תבנית תרחיש|רקע|Тарих|Сценарій|Сценарио|Сценарий структураси|Сценарий|Структура сценарію|Структура сценарија|Структура сценария|Скица|Рамка на сценарий|Пример|Предыстория|Предистория|Позадина|Передумова|Основа|Концепт|Контекст|Założenia|Wharrimean is|Tình huống|The thing of it is|Tausta|Taust|Tapausaihio|Tapaus|Szenariogrundriss|Szenario|Szablon scenariusza|Stsenaarium|Struktura scenarija|Skica|Skenario konsep|Skenario|Situācija|Senaryo taslağı|Senaryo|Scénář|Scénario|Schema dello scenario|Scenārijs pēc parauga|Scenārijs|Scenár|Scenaro|Scenariusz|Scenariul de şablon|Scenariul de sablon|Scenariu|Scenario Outline|Scenario Amlinellol|Scenario|Scenarijus|Scenarijaus šablonas|Scenarij|Scenarie|Rerefons|Raamstsenaarium|Primer|Pozadí|Pozadina|Pozadie|Plan du scénario|Plan du Scénario|Osnova scénáře|Osnova|Náčrt Scénáře|Náčrt Scenáru|Mate|MISHUN SRSLY|MISHUN|Kịch bản|Konturo de la scenaro|Kontext|Konteksts|Kontekstas|Kontekst|Koncept|Khung tình huống|Khung kịch bản|Háttér|Grundlage|Geçmiş|Forgatókönyv vázlat|Forgatókönyv|Fono|Esquema do Cenário|Esquema do Cenario|Esquema del escenario|Esquema de l'escenari|Escenario|Escenari|Dis is what went down|Dasar|Contexto|Contexte|Contesto|Condiţii|Conditii|Cenário|Cenario|Cefndir|Bối cảnh|Blokes|Bakgrunn|Bakgrund|Baggrund|Background|B4|Antecedents|Antecedentes|All y'all|Achtergrond|Abstrakt Scenario|Abstract Scenario)(:)(.*)$`
|
||||
|
||||
examplesKeywords := `^(\s*)(예|例子|例|サンプル|امثلة|דוגמאות|Сценарији|Примери|Приклади|Мисоллар|Значения|Örnekler|Voorbeelden|Variantai|Tapaukset|Scenarios|Scenariji|Scenarijai|Příklady|Példák|Príklady|Przykłady|Primjeri|Primeri|Piemēri|Pavyzdžiai|Paraugs|Juhtumid|Exemplos|Exemples|Exemplele|Exempel|Examples|Esempi|Enghreifftiau|Ekzemploj|Eksempler|Ejemplos|EXAMPLZ|Dữ liệu|Contoh|Cobber|Beispiele)(:)(.*)$`
|
||||
|
||||
return Rules{
|
||||
"comments": {
|
||||
{`\s*#.*$`, Comment, nil},
|
||||
},
|
||||
@ -114,5 +118,5 @@ var Gherkin = internal.Register(MustNewLexer(
|
||||
{examplesKeywords, ByGroups(NameFunction, Keyword, Keyword, NameFunction), Push("examplesTable")},
|
||||
{`(\s|.)`, NameFunction, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// GLSL lexer.
|
||||
var GLSL = internal.Register(MustNewLexer(
|
||||
var GLSL = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "GLSL",
|
||||
Aliases: []string{"glsl"},
|
||||
Filenames: []string{"*.vert", "*.frag", "*.geo"},
|
||||
MimeTypes: []string{"text/x-glslsrc"},
|
||||
},
|
||||
Rules{
|
||||
glslRules,
|
||||
))
|
||||
|
||||
func glslRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`^#.*`, CommentPreproc, nil},
|
||||
{`//.*`, CommentSingle, nil},
|
||||
@ -33,5 +37,5 @@ var GLSL = internal.Register(MustNewLexer(
|
||||
{`\.`, Punctuation, nil},
|
||||
{`\s+`, Text, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Gnuplot lexer.
|
||||
var Gnuplot = internal.Register(MustNewLexer(
|
||||
var Gnuplot = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Gnuplot",
|
||||
Aliases: []string{"gnuplot"},
|
||||
Filenames: []string{"*.plot", "*.plt"},
|
||||
MimeTypes: []string{"text/x-gnuplot"},
|
||||
},
|
||||
Rules{
|
||||
gnuplotRules,
|
||||
))
|
||||
|
||||
func gnuplotRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
Include("whitespace"),
|
||||
{`bind\b|bin\b|bi\b`, Keyword, Push("bind")},
|
||||
@ -113,5 +117,5 @@ var Gnuplot = internal.Register(MustNewLexer(
|
||||
{`functions\b|function\b|functio\b|functi\b|funct\b|func\b|fun\b|fu\b|f\b|set\b|se\b|s\b|terminal\b|termina\b|termin\b|termi\b|term\b|ter\b|te\b|t\b|variables\b|variable\b|variabl\b|variab\b|varia\b|vari\b|var\b|va\b|v\b`, NameBuiltin, nil},
|
||||
Include("genericargs"),
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
110
lexers/g/go.go
110
lexers/g/go.go
@ -9,7 +9,7 @@ import (
|
||||
)
|
||||
|
||||
// Go lexer.
|
||||
var Go = internal.Register(MustNewLexer(
|
||||
var Go = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Go",
|
||||
Aliases: []string{"go", "golang"},
|
||||
@ -17,7 +17,19 @@ var Go = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-gosrc"},
|
||||
EnsureNL: true,
|
||||
},
|
||||
Rules{
|
||||
goRules,
|
||||
).SetAnalyser(func(text string) float32 {
|
||||
if strings.Contains(text, "fmt.") && strings.Contains(text, "package ") {
|
||||
return 0.5
|
||||
}
|
||||
if strings.Contains(text, "package ") {
|
||||
return 0.1
|
||||
}
|
||||
return 0.0
|
||||
}))
|
||||
|
||||
func goRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\n`, Text, nil},
|
||||
{`\s+`, Text, nil},
|
||||
@ -47,58 +59,52 @@ var Go = internal.Register(MustNewLexer(
|
||||
{`[|^<>=!()\[\]{}.,;:]`, Punctuation, nil},
|
||||
{`[^\W\d]\w*`, NameOther, nil},
|
||||
},
|
||||
},
|
||||
).SetAnalyser(func(text string) float32 {
|
||||
if strings.Contains(text, "fmt.") && strings.Contains(text, "package ") {
|
||||
return 0.5
|
||||
}
|
||||
if strings.Contains(text, "package ") {
|
||||
return 0.1
|
||||
}
|
||||
return 0.0
|
||||
}))
|
||||
|
||||
var goTemplateRules = Rules{
|
||||
"root": {
|
||||
{`{{(- )?/\*(.|\n)*?\*/( -)?}}`, CommentMultiline, nil},
|
||||
{`{{[-]?`, CommentPreproc, Push("template")},
|
||||
{`[^{]+`, Other, nil},
|
||||
{`{`, Other, nil},
|
||||
},
|
||||
"template": {
|
||||
{`[-]?}}`, CommentPreproc, Pop(1)},
|
||||
{`(?=}})`, CommentPreproc, Pop(1)}, // Terminate the pipeline
|
||||
{`\(`, Operator, Push("subexpression")},
|
||||
{`"(\\\\|\\"|[^"])*"`, LiteralString, nil},
|
||||
Include("expression"),
|
||||
},
|
||||
"subexpression": {
|
||||
{`\)`, Operator, Pop(1)},
|
||||
Include("expression"),
|
||||
},
|
||||
"expression": {
|
||||
{`\s+`, Whitespace, nil},
|
||||
{`\(`, Operator, Push("subexpression")},
|
||||
{`(range|if|else|while|with|template|end|true|false|nil|and|call|html|index|js|len|not|or|print|printf|println|urlquery|eq|ne|lt|le|gt|ge)\b`, Keyword, nil},
|
||||
{`\||:?=|,`, Operator, nil},
|
||||
{`[$]?[^\W\d]\w*`, NameOther, nil},
|
||||
{`[$]?\.(?:[^\W\d]\w*)?`, NameAttribute, nil},
|
||||
{`"(\\\\|\\"|[^"])*"`, LiteralString, nil},
|
||||
{`-?\d+i`, LiteralNumber, nil},
|
||||
{`-?\d+\.\d*([Ee][-+]\d+)?i`, LiteralNumber, nil},
|
||||
{`\.\d+([Ee][-+]\d+)?i`, LiteralNumber, nil},
|
||||
{`-?\d+[Ee][-+]\d+i`, LiteralNumber, nil},
|
||||
{`-?\d+(\.\d+[eE][+\-]?\d+|\.\d*|[eE][+\-]?\d+)`, LiteralNumberFloat, nil},
|
||||
{`-?\.\d+([eE][+\-]?\d+)?`, LiteralNumberFloat, nil},
|
||||
{`-?0[0-7]+`, LiteralNumberOct, nil},
|
||||
{`-?0[xX][0-9a-fA-F]+`, LiteralNumberHex, nil},
|
||||
{`-?(0|[1-9][0-9]*)`, LiteralNumberInteger, nil},
|
||||
{`'(\\['"\\abfnrtv]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|[^\\])'`, LiteralStringChar, nil},
|
||||
{"`[^`]*`", LiteralString, nil},
|
||||
},
|
||||
}
|
||||
|
||||
var GoHTMLTemplate = internal.Register(DelegatingLexer(h.HTML, MustNewLexer(
|
||||
func goTemplateRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`{{(- )?/\*(.|\n)*?\*/( -)?}}`, CommentMultiline, nil},
|
||||
{`{{[-]?`, CommentPreproc, Push("template")},
|
||||
{`[^{]+`, Other, nil},
|
||||
{`{`, Other, nil},
|
||||
},
|
||||
"template": {
|
||||
{`[-]?}}`, CommentPreproc, Pop(1)},
|
||||
{`(?=}})`, CommentPreproc, Pop(1)}, // Terminate the pipeline
|
||||
{`\(`, Operator, Push("subexpression")},
|
||||
{`"(\\\\|\\"|[^"])*"`, LiteralString, nil},
|
||||
Include("expression"),
|
||||
},
|
||||
"subexpression": {
|
||||
{`\)`, Operator, Pop(1)},
|
||||
Include("expression"),
|
||||
},
|
||||
"expression": {
|
||||
{`\s+`, Whitespace, nil},
|
||||
{`\(`, Operator, Push("subexpression")},
|
||||
{`(range|if|else|while|with|template|end|true|false|nil|and|call|html|index|js|len|not|or|print|printf|println|urlquery|eq|ne|lt|le|gt|ge)\b`, Keyword, nil},
|
||||
{`\||:?=|,`, Operator, nil},
|
||||
{`[$]?[^\W\d]\w*`, NameOther, nil},
|
||||
{`[$]?\.(?:[^\W\d]\w*)?`, NameAttribute, nil},
|
||||
{`"(\\\\|\\"|[^"])*"`, LiteralString, nil},
|
||||
{`-?\d+i`, LiteralNumber, nil},
|
||||
{`-?\d+\.\d*([Ee][-+]\d+)?i`, LiteralNumber, nil},
|
||||
{`\.\d+([Ee][-+]\d+)?i`, LiteralNumber, nil},
|
||||
{`-?\d+[Ee][-+]\d+i`, LiteralNumber, nil},
|
||||
{`-?\d+(\.\d+[eE][+\-]?\d+|\.\d*|[eE][+\-]?\d+)`, LiteralNumberFloat, nil},
|
||||
{`-?\.\d+([eE][+\-]?\d+)?`, LiteralNumberFloat, nil},
|
||||
{`-?0[0-7]+`, LiteralNumberOct, nil},
|
||||
{`-?0[xX][0-9a-fA-F]+`, LiteralNumberHex, nil},
|
||||
{`-?(0|[1-9][0-9]*)`, LiteralNumberInteger, nil},
|
||||
{`'(\\['"\\abfnrtv]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|[^\\])'`, LiteralStringChar, nil},
|
||||
{"`[^`]*`", LiteralString, nil},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
var GoHTMLTemplate = internal.Register(DelegatingLexer(h.HTML, MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Go HTML Template",
|
||||
Aliases: []string{"go-html-template"},
|
||||
@ -106,7 +112,7 @@ var GoHTMLTemplate = internal.Register(DelegatingLexer(h.HTML, MustNewLexer(
|
||||
goTemplateRules,
|
||||
)))
|
||||
|
||||
var GoTextTemplate = internal.Register(MustNewLexer(
|
||||
var GoTextTemplate = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Go Text Template",
|
||||
Aliases: []string{"go-text-template"},
|
||||
|
@ -6,13 +6,17 @@ import (
|
||||
)
|
||||
|
||||
// Go lexer.
|
||||
var Graphql = internal.Register(MustNewLexer(
|
||||
var Graphql = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "GraphQL",
|
||||
Aliases: []string{"graphql", "graphqls", "gql"},
|
||||
Filenames: []string{"*.graphql", "*.graphqls"},
|
||||
},
|
||||
Rules{
|
||||
graphqlRules,
|
||||
))
|
||||
|
||||
func graphqlRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`(query|mutation|subscription|fragment|scalar|implements|interface|union|enum|input|type)`, KeywordDeclaration, Push("type")},
|
||||
{`(on|extend|schema|directive|\.\.\.)`, KeywordDeclaration, nil},
|
||||
@ -41,5 +45,5 @@ var Graphql = internal.Register(MustNewLexer(
|
||||
{`[^\W\d]\w*`, NameClass, Pop(1)},
|
||||
Include("root"),
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Groovy lexer.
|
||||
var Groovy = internal.Register(MustNewLexer(
|
||||
var Groovy = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Groovy",
|
||||
Aliases: []string{"groovy"},
|
||||
@ -14,7 +14,11 @@ var Groovy = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-groovy"},
|
||||
DotAll: true,
|
||||
},
|
||||
Rules{
|
||||
groovyRules,
|
||||
))
|
||||
|
||||
func groovyRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`#!(.*?)$`, CommentPreproc, Push("base")},
|
||||
Default(Push("base")),
|
||||
@ -54,5 +58,5 @@ var Groovy = internal.Register(MustNewLexer(
|
||||
"import": {
|
||||
{`[\w.]+\*?`, NameNamespace, Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Handlebars lexer.
|
||||
var Handlebars = internal.Register(MustNewLexer(
|
||||
var Handlebars = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Handlebars",
|
||||
Aliases: []string{"handlebars", "hbs"},
|
||||
Filenames: []string{"*.handlebars", "*.hbs"},
|
||||
MimeTypes: []string{},
|
||||
},
|
||||
Rules{
|
||||
handlebarsRules,
|
||||
))
|
||||
|
||||
func handlebarsRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`[^{]+`, Other, nil},
|
||||
{`\{\{!.*\}\}`, Comment, nil},
|
||||
@ -52,5 +56,5 @@ var Handlebars = internal.Register(MustNewLexer(
|
||||
{`:?'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil},
|
||||
{`[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?`, LiteralNumber, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Haskell lexer.
|
||||
var Haskell = internal.Register(MustNewLexer(
|
||||
var Haskell = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Haskell",
|
||||
Aliases: []string{"haskell", "hs"},
|
||||
Filenames: []string{"*.hs"},
|
||||
MimeTypes: []string{"text/x-haskell"},
|
||||
},
|
||||
Rules{
|
||||
haskellRules,
|
||||
))
|
||||
|
||||
func haskellRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\s+`, Text, nil},
|
||||
{`--(?![!#$%&*+./<=>?@^|_~:\\]).*?$`, CommentSingle, nil},
|
||||
@ -95,5 +99,5 @@ var Haskell = internal.Register(MustNewLexer(
|
||||
{`\d+`, LiteralStringEscape, Pop(1)},
|
||||
{`\s+\\`, LiteralStringEscape, Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Haxe lexer.
|
||||
var Haxe = internal.Register(MustNewLexer(
|
||||
var Haxe = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Haxe",
|
||||
Aliases: []string{"hx", "haxe", "hxsl"},
|
||||
@ -14,7 +14,11 @@ var Haxe = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/haxe", "text/x-haxe", "text/x-hx"},
|
||||
DotAll: true,
|
||||
},
|
||||
Rules{
|
||||
haxeRules,
|
||||
))
|
||||
|
||||
func haxeRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
Include("spaces"),
|
||||
Include("meta"),
|
||||
@ -609,8 +613,8 @@ var Haxe = internal.Register(MustNewLexer(
|
||||
{`\}`, Punctuation, Pop(1)},
|
||||
{`,`, Punctuation, Push("#pop", "object")},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
func haxePreProcMutator(state *LexerState) error {
|
||||
stack, ok := state.Get("haxe-pre-proc").([][]string)
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// HCL lexer.
|
||||
var HCL = internal.Register(MustNewLexer(
|
||||
var HCL = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "HCL",
|
||||
Aliases: []string{"hcl"},
|
||||
Filenames: []string{"*.hcl"},
|
||||
MimeTypes: []string{"application/x-hcl"},
|
||||
},
|
||||
Rules{
|
||||
hclRules,
|
||||
))
|
||||
|
||||
func hclRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
Include("string"),
|
||||
Include("punctuation"),
|
||||
@ -65,5 +69,5 @@ var HCL = internal.Register(MustNewLexer(
|
||||
{`\s+`, Text, nil},
|
||||
{`\\\n`, Text, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Hexdump lexer.
|
||||
var Hexdump = internal.Register(MustNewLexer(
|
||||
var Hexdump = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Hexdump",
|
||||
Aliases: []string{"hexdump"},
|
||||
Filenames: []string{},
|
||||
MimeTypes: []string{},
|
||||
},
|
||||
Rules{
|
||||
hexdumpRules,
|
||||
))
|
||||
|
||||
func hexdumpRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\n`, Text, nil},
|
||||
Include("offset"),
|
||||
@ -63,5 +67,5 @@ var Hexdump = internal.Register(MustNewLexer(
|
||||
{`\s`, Text, nil},
|
||||
{`^\*`, Punctuation, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// HLB lexer.
|
||||
var HLB = internal.Register(MustNewLexer(
|
||||
var HLB = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "HLB",
|
||||
Aliases: []string{"hlb"},
|
||||
Filenames: []string{"*.hlb"},
|
||||
MimeTypes: []string{},
|
||||
},
|
||||
Rules{
|
||||
hlbRules,
|
||||
))
|
||||
|
||||
func hlbRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`(#.*)`, ByGroups(CommentSingle), nil},
|
||||
{`((\b(0(b|B|o|O|x|X)[a-fA-F0-9]+)\b)|(\b(0|[1-9][0-9]*)\b))`, ByGroups(LiteralNumber), nil},
|
||||
@ -50,5 +54,5 @@ var HLB = internal.Register(MustNewLexer(
|
||||
{`(\n|\r|\r\n)`, Text, nil},
|
||||
{`.`, Text, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -8,7 +8,7 @@ import (
|
||||
)
|
||||
|
||||
// HTML lexer.
|
||||
var HTML = internal.Register(MustNewLexer(
|
||||
var HTML = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "HTML",
|
||||
Aliases: []string{"html"},
|
||||
@ -18,7 +18,11 @@ var HTML = internal.Register(MustNewLexer(
|
||||
DotAll: true,
|
||||
CaseInsensitive: true,
|
||||
},
|
||||
Rules{
|
||||
htmlRules,
|
||||
))
|
||||
|
||||
func htmlRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`[^<&]+`, Text, nil},
|
||||
{`&\S*?;`, NameEntity, nil},
|
||||
@ -55,5 +59,5 @@ var HTML = internal.Register(MustNewLexer(
|
||||
{`'.*?'`, LiteralString, Pop(1)},
|
||||
{`[^\s>]+`, LiteralString, Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -8,7 +8,7 @@ import (
|
||||
)
|
||||
|
||||
// HTTP lexer.
|
||||
var HTTP = internal.Register(httpBodyContentTypeLexer(MustNewLexer(
|
||||
var HTTP = internal.Register(httpBodyContentTypeLexer(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "HTTP",
|
||||
Aliases: []string{"http"},
|
||||
@ -17,7 +17,11 @@ var HTTP = internal.Register(httpBodyContentTypeLexer(MustNewLexer(
|
||||
NotMultiline: true,
|
||||
DotAll: true,
|
||||
},
|
||||
Rules{
|
||||
httpRules,
|
||||
)))
|
||||
|
||||
func httpRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`(GET|POST|PUT|DELETE|HEAD|OPTIONS|TRACE|PATCH|CONNECT)( +)([^ ]+)( +)(HTTP)(/)([12]\.[01])(\r?\n|\Z)`, ByGroups(NameFunction, Text, NameNamespace, Text, KeywordReserved, Operator, LiteralNumber, Text), Push("headers")},
|
||||
{`(HTTP)(/)([12]\.[01])( +)(\d{3})( +)([^\r\n]+)(\r?\n|\Z)`, ByGroups(KeywordReserved, Operator, LiteralNumber, Text, LiteralNumber, Text, NameException, Text), Push("headers")},
|
||||
@ -30,8 +34,8 @@ var HTTP = internal.Register(httpBodyContentTypeLexer(MustNewLexer(
|
||||
"content": {
|
||||
{`.+`, EmitterFunc(httpContentBlock), nil},
|
||||
},
|
||||
},
|
||||
)))
|
||||
}
|
||||
}
|
||||
|
||||
func httpContentBlock(groups []string, lexer Lexer) Iterator {
|
||||
tokens := []Token{
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Hy lexer.
|
||||
var Hy = internal.Register(MustNewLexer(
|
||||
var Hy = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Hy",
|
||||
Aliases: []string{"hylang"},
|
||||
Filenames: []string{"*.hy"},
|
||||
MimeTypes: []string{"text/x-hy", "application/x-hy"},
|
||||
},
|
||||
Rules{
|
||||
hyRules,
|
||||
))
|
||||
|
||||
func hyRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`;.*$`, CommentSingle, nil},
|
||||
{`[,\s]+`, Text, nil},
|
||||
@ -47,5 +51,5 @@ var Hy = internal.Register(MustNewLexer(
|
||||
{`(?<!\.)(self|None|Ellipsis|NotImplemented|False|True|cls)\b`, NameBuiltinPseudo, nil},
|
||||
{Words(`(?<!\.)`, `\b`, `ArithmeticError`, `AssertionError`, `AttributeError`, `BaseException`, `DeprecationWarning`, `EOFError`, `EnvironmentError`, `Exception`, `FloatingPointError`, `FutureWarning`, `GeneratorExit`, `IOError`, `ImportError`, `ImportWarning`, `IndentationError`, `IndexError`, `KeyError`, `KeyboardInterrupt`, `LookupError`, `MemoryError`, `NameError`, `NotImplemented`, `NotImplementedError`, `OSError`, `OverflowError`, `OverflowWarning`, `PendingDeprecationWarning`, `ReferenceError`, `RuntimeError`, `RuntimeWarning`, `StandardError`, `StopIteration`, `SyntaxError`, `SyntaxWarning`, `SystemError`, `SystemExit`, `TabError`, `TypeError`, `UnboundLocalError`, `UnicodeDecodeError`, `UnicodeEncodeError`, `UnicodeError`, `UnicodeTranslateError`, `UnicodeWarning`, `UserWarning`, `ValueError`, `VMSError`, `Warning`, `WindowsError`, `ZeroDivisionError`), NameException, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Idris lexer.
|
||||
var Idris = internal.Register(MustNewLexer(
|
||||
var Idris = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Idris",
|
||||
Aliases: []string{"idris", "idr"},
|
||||
Filenames: []string{"*.idr"},
|
||||
MimeTypes: []string{"text/x-idris"},
|
||||
},
|
||||
Rules{
|
||||
idrisRules,
|
||||
))
|
||||
|
||||
func idrisRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`^(\s*)(%lib|link|flag|include|hide|freeze|access|default|logging|dynamic|name|error_handlers|language)`, ByGroups(Text, KeywordReserved), nil},
|
||||
{`(\s*)(--(?![!#$%&*+./<=>?@^|_~:\\]).*?)$`, ByGroups(Text, CommentSingle), nil},
|
||||
@ -76,5 +80,5 @@ var Idris = internal.Register(MustNewLexer(
|
||||
{`\d+`, LiteralStringEscape, Pop(1)},
|
||||
{`\s+\\`, LiteralStringEscape, Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Igor lexer.
|
||||
var Igor = internal.Register(MustNewLexer(
|
||||
var Igor = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Igor",
|
||||
Aliases: []string{"igor", "igorpro"},
|
||||
@ -14,7 +14,11 @@ var Igor = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/ipf"},
|
||||
CaseInsensitive: true,
|
||||
},
|
||||
Rules{
|
||||
igorRules,
|
||||
))
|
||||
|
||||
func igorRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`//.*$`, CommentSingle, nil},
|
||||
{`"([^"\\]|\\.)*"`, LiteralString, nil},
|
||||
@ -28,5 +32,5 @@ var Igor = internal.Register(MustNewLexer(
|
||||
{`.`, Text, nil},
|
||||
{`\n|\r`, Text, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Ini lexer.
|
||||
var Ini = internal.Register(MustNewLexer(
|
||||
var Ini = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "INI",
|
||||
Aliases: []string{"ini", "cfg", "dosini"},
|
||||
Filenames: []string{"*.ini", "*.cfg", "*.inf", ".gitconfig", ".editorconfig"},
|
||||
MimeTypes: []string{"text/x-ini", "text/inf"},
|
||||
},
|
||||
Rules{
|
||||
iniRules,
|
||||
))
|
||||
|
||||
func iniRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\s+`, Text, nil},
|
||||
{`[;#].*`, CommentSingle, nil},
|
||||
@ -21,5 +25,5 @@ var Ini = internal.Register(MustNewLexer(
|
||||
{`(.*?)([ \t]*)(=)([ \t]*)(.*(?:\n[ \t].+)*)`, ByGroups(NameAttribute, Text, Operator, Text, LiteralString), nil},
|
||||
{`(.+?)$`, NameAttribute, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Io lexer.
|
||||
var Io = internal.Register(MustNewLexer(
|
||||
var Io = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Io",
|
||||
Aliases: []string{"io"},
|
||||
Filenames: []string{"*.io"},
|
||||
MimeTypes: []string{"text/x-iosrc"},
|
||||
},
|
||||
Rules{
|
||||
ioRules,
|
||||
))
|
||||
|
||||
func ioRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\n`, Text, nil},
|
||||
{`\s+`, Text, nil},
|
||||
@ -36,5 +40,5 @@ var Io = internal.Register(MustNewLexer(
|
||||
{`\+/`, CommentMultiline, Pop(1)},
|
||||
{`[+/]`, CommentMultiline, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -146,16 +146,19 @@ func Register(lexer chroma.Lexer) chroma.Lexer {
|
||||
return lexer
|
||||
}
|
||||
|
||||
// Used for the fallback lexer as well as the explicit plaintext lexer
|
||||
var PlaintextRules = chroma.Rules{
|
||||
"root": []chroma.Rule{
|
||||
{`.+`, chroma.Text, nil},
|
||||
{`\n`, chroma.Text, nil},
|
||||
},
|
||||
// PlaintextRules is used for the fallback lexer as well as the explicit
|
||||
// plaintext lexer.
|
||||
func PlaintextRules() chroma.Rules {
|
||||
return chroma.Rules{
|
||||
"root": []chroma.Rule{
|
||||
{`.+`, chroma.Text, nil},
|
||||
{`\n`, chroma.Text, nil},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// Fallback lexer if no other is found.
|
||||
var Fallback chroma.Lexer = chroma.MustNewLexer(&chroma.Config{
|
||||
var Fallback chroma.Lexer = chroma.MustNewLazyLexer(&chroma.Config{
|
||||
Name: "fallback",
|
||||
Filenames: []string{"*"},
|
||||
}, PlaintextRules)
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// J lexer.
|
||||
var J = internal.Register(MustNewLexer(
|
||||
var J = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "J",
|
||||
Aliases: []string{"j"},
|
||||
Filenames: []string{"*.ijs"},
|
||||
MimeTypes: []string{"text/x-j"},
|
||||
},
|
||||
Rules{
|
||||
jRules,
|
||||
))
|
||||
|
||||
func jRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`#!.*$`, CommentPreproc, nil},
|
||||
{`NB\..*`, CommentSingle, nil},
|
||||
@ -69,5 +73,5 @@ var J = internal.Register(MustNewLexer(
|
||||
{`''`, LiteralString, nil},
|
||||
{`'`, LiteralString, Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Java lexer.
|
||||
var Java = internal.Register(MustNewLexer(
|
||||
var Java = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Java",
|
||||
Aliases: []string{"java"},
|
||||
@ -15,7 +15,11 @@ var Java = internal.Register(MustNewLexer(
|
||||
DotAll: true,
|
||||
EnsureNL: true,
|
||||
},
|
||||
Rules{
|
||||
javaRules,
|
||||
))
|
||||
|
||||
func javaRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`[^\S\n]+`, Text, nil},
|
||||
{`//.*?\n`, CommentSingle, nil},
|
||||
@ -48,5 +52,5 @@ var Java = internal.Register(MustNewLexer(
|
||||
"import": {
|
||||
{`[\w.]+\*?`, NameNamespace, Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// JSON lexer.
|
||||
var JSON = internal.Register(MustNewLexer(
|
||||
var JSON = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "JSON",
|
||||
Aliases: []string{"json"},
|
||||
@ -15,7 +15,11 @@ var JSON = internal.Register(MustNewLexer(
|
||||
NotMultiline: true,
|
||||
DotAll: true,
|
||||
},
|
||||
Rules{
|
||||
jsonRules,
|
||||
))
|
||||
|
||||
func jsonRules() Rules {
|
||||
return Rules{
|
||||
"whitespace": {
|
||||
{`\s+`, Text, nil},
|
||||
},
|
||||
@ -51,5 +55,5 @@ var JSON = internal.Register(MustNewLexer(
|
||||
"root": {
|
||||
Include("value"),
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -8,7 +8,7 @@ import (
|
||||
// JSX lexer.
|
||||
//
|
||||
// This was generated from https://github.com/fcurella/jsx-lexer
|
||||
var JSX = internal.Register(MustNewLexer(
|
||||
var JSX = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "react",
|
||||
Aliases: []string{"jsx", "react"},
|
||||
@ -16,7 +16,11 @@ var JSX = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/jsx", "text/typescript-jsx"},
|
||||
DotAll: true,
|
||||
},
|
||||
Rules{
|
||||
jsxRules,
|
||||
))
|
||||
|
||||
func jsxRules() Rules {
|
||||
return Rules{
|
||||
"commentsandwhitespace": {
|
||||
{`\s+`, Text, nil},
|
||||
{`<!--`, Comment, nil},
|
||||
@ -91,5 +95,5 @@ var JSX = internal.Register(MustNewLexer(
|
||||
{`}`, Punctuation, Pop(1)},
|
||||
Include("root"),
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Julia lexer.
|
||||
var Julia = internal.Register(MustNewLexer(
|
||||
var Julia = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Julia",
|
||||
Aliases: []string{"julia", "jl"},
|
||||
Filenames: []string{"*.jl"},
|
||||
MimeTypes: []string{"text/x-julia", "application/x-julia"},
|
||||
},
|
||||
Rules{
|
||||
juliaRules,
|
||||
))
|
||||
|
||||
func juliaRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\n`, Text, nil},
|
||||
{`[^\S\n]+`, Text, nil},
|
||||
@ -91,5 +95,5 @@ var Julia = internal.Register(MustNewLexer(
|
||||
{`\)`, Punctuation, Pop(1)},
|
||||
Include("root"),
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -5,14 +5,18 @@ import (
|
||||
"github.com/alecthomas/chroma/lexers/internal"
|
||||
)
|
||||
|
||||
var Jungle = internal.Register(MustNewLexer(
|
||||
var Jungle = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Jungle",
|
||||
Aliases: []string{"jungle"},
|
||||
Filenames: []string{"*.jungle"},
|
||||
MimeTypes: []string{"text/x-jungle"},
|
||||
},
|
||||
Rules{
|
||||
jungleRules,
|
||||
))
|
||||
|
||||
func jungleRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`[^\S\n]+`, Text, nil},
|
||||
{`\n`, Text, nil},
|
||||
@ -46,5 +50,5 @@ var Jungle = internal.Register(MustNewLexer(
|
||||
{`[a-zA-Z_]\w*`, Name, nil},
|
||||
Default(Pop(1)),
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
File diff suppressed because one or more lines are too long
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Lighttpd Configuration File lexer.
|
||||
var Lighttpd = internal.Register(MustNewLexer(
|
||||
var Lighttpd = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Lighttpd configuration file",
|
||||
Aliases: []string{"lighty", "lighttpd"},
|
||||
Filenames: []string{},
|
||||
MimeTypes: []string{"text/x-lighttpd-conf"},
|
||||
},
|
||||
Rules{
|
||||
lighttpdRules,
|
||||
))
|
||||
|
||||
func lighttpdRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`#.*\n`, CommentSingle, nil},
|
||||
{`/\S*`, Name, nil},
|
||||
@ -26,5 +30,5 @@ var Lighttpd = internal.Register(MustNewLexer(
|
||||
{`"([^"\\]*(?:\\.[^"\\]*)*)"`, LiteralStringDouble, nil},
|
||||
{`\s+`, Text, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Llvm lexer.
|
||||
var Llvm = internal.Register(MustNewLexer(
|
||||
var Llvm = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "LLVM",
|
||||
Aliases: []string{"llvm"},
|
||||
Filenames: []string{"*.ll"},
|
||||
MimeTypes: []string{"text/x-llvm"},
|
||||
},
|
||||
Rules{
|
||||
llvmRules,
|
||||
))
|
||||
|
||||
func llvmRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
Include("whitespace"),
|
||||
{`([-a-zA-Z$._][\w\-$.]*|"[^"]*?")\s*:`, NameLabel, nil},
|
||||
@ -39,5 +43,5 @@ var Llvm = internal.Register(MustNewLexer(
|
||||
{Words(``, ``, `void`, `half`, `float`, `double`, `x86_fp80`, `fp128`, `ppc_fp128`, `label`, `metadata`, `token`), KeywordType, nil},
|
||||
{`i[1-9]\d*`, Keyword, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Lua lexer.
|
||||
var Lua = internal.Register(MustNewLexer(
|
||||
var Lua = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Lua",
|
||||
Aliases: []string{"lua"},
|
||||
Filenames: []string{"*.lua", "*.wlua"},
|
||||
MimeTypes: []string{"text/x-lua", "application/x-lua"},
|
||||
},
|
||||
Rules{
|
||||
luaRules,
|
||||
))
|
||||
|
||||
func luaRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`#!.*`, CommentPreproc, nil},
|
||||
Default(Push("base")),
|
||||
@ -71,5 +75,5 @@ var Lua = internal.Register(MustNewLexer(
|
||||
{`"`, LiteralStringDouble, Pop(1)},
|
||||
{`[^\\"]+`, LiteralStringDouble, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -7,7 +7,7 @@ import (
|
||||
)
|
||||
|
||||
// Makefile lexer.
|
||||
var Makefile = internal.Register(MustNewLexer(
|
||||
var Makefile = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Base Makefile",
|
||||
Aliases: []string{"make", "makefile", "mf", "bsdmake"},
|
||||
@ -15,7 +15,11 @@ var Makefile = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-makefile"},
|
||||
EnsureNL: true,
|
||||
},
|
||||
Rules{
|
||||
makefileRules,
|
||||
))
|
||||
|
||||
func makefileRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`^(?:[\t ]+.*\n|\n)+`, Using(Bash), nil},
|
||||
{`\$[<@$+%?|*]`, Keyword, nil},
|
||||
@ -50,5 +54,5 @@ var Makefile = internal.Register(MustNewLexer(
|
||||
{`\n`, Text, Pop(1)},
|
||||
{`.`, Text, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -7,14 +7,18 @@ import (
|
||||
)
|
||||
|
||||
// Mako lexer.
|
||||
var Mako = internal.Register(MustNewLexer(
|
||||
var Mako = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Mako",
|
||||
Aliases: []string{"mako"},
|
||||
Filenames: []string{"*.mao"},
|
||||
MimeTypes: []string{"application/x-mako"},
|
||||
},
|
||||
Rules{
|
||||
makoRules,
|
||||
))
|
||||
|
||||
func makoRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`(\s*)(%)(\s*end(?:\w+))(\n|\Z)`, ByGroups(Text, CommentPreproc, Keyword, Other), nil},
|
||||
{`(\s*)(%)([^\n]*)(\n|\Z)`, ByGroups(Text, CommentPreproc, Using(Python), Other), nil},
|
||||
@ -56,5 +60,5 @@ var Mako = internal.Register(MustNewLexer(
|
||||
{`'.*?'`, LiteralString, Pop(1)},
|
||||
{`[^\s>]+`, LiteralString, Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -7,14 +7,18 @@ import (
|
||||
)
|
||||
|
||||
// Markdown lexer.
|
||||
var Markdown = internal.Register(DelegatingLexer(h.HTML, MustNewLexer(
|
||||
var Markdown = internal.Register(DelegatingLexer(h.HTML, MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "markdown",
|
||||
Aliases: []string{"md", "mkd"},
|
||||
Filenames: []string{"*.md", "*.mkd", "*.markdown"},
|
||||
MimeTypes: []string{"text/x-markdown"},
|
||||
},
|
||||
Rules{
|
||||
markdownRules,
|
||||
)))
|
||||
|
||||
func markdownRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`^(#[^#].+\n)`, ByGroups(GenericHeading), nil},
|
||||
{`^(#{2,6}.+\n)`, ByGroups(GenericSubheading), nil},
|
||||
@ -23,7 +27,8 @@ var Markdown = internal.Register(DelegatingLexer(h.HTML, MustNewLexer(
|
||||
{`^(\s*)([0-9]+\.)( .+\n)`, ByGroups(Text, Keyword, UsingSelf("inline")), nil},
|
||||
{`^(\s*>\s)(.+\n)`, ByGroups(Keyword, GenericEmph), nil},
|
||||
{"^(```\\n)([\\w\\W]*?)(^```$)", ByGroups(String, Text, String), nil},
|
||||
{"^(```)(\\w+)(\\n)([\\w\\W]*?)(^```$)",
|
||||
{
|
||||
"^(```)(\\w+)(\\n)([\\w\\W]*?)(^```$)",
|
||||
UsingByGroup(
|
||||
internal.Get,
|
||||
2, 4,
|
||||
@ -44,5 +49,5 @@ var Markdown = internal.Register(DelegatingLexer(h.HTML, MustNewLexer(
|
||||
{`[^\\\s]+`, Other, nil},
|
||||
{`.|\n`, Other, nil},
|
||||
},
|
||||
},
|
||||
)))
|
||||
}
|
||||
}
|
||||
|
@ -8,7 +8,7 @@ import (
|
||||
)
|
||||
|
||||
// Mason lexer.
|
||||
var Mason = internal.Register(MustNewLexer(
|
||||
var Mason = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Mason",
|
||||
Aliases: []string{"mason"},
|
||||
@ -16,7 +16,11 @@ var Mason = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"application/x-mason"},
|
||||
Priority: 0.1,
|
||||
},
|
||||
Rules{
|
||||
masonRules,
|
||||
))
|
||||
|
||||
func masonRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\s+`, Text, nil},
|
||||
{`(<%doc>)(.*?)(</%doc>)(?s)`, ByGroups(NameTag, CommentMultiline, NameTag), nil},
|
||||
@ -39,5 +43,5 @@ var Mason = internal.Register(MustNewLexer(
|
||||
\Z # end of string
|
||||
)`, ByGroups(Using(HTML), Operator), nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Mathematica lexer.
|
||||
var Mathematica = internal.Register(MustNewLexer(
|
||||
var Mathematica = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Mathematica",
|
||||
Aliases: []string{"mathematica", "mma", "nb"},
|
||||
Filenames: []string{"*.nb", "*.cdf", "*.nbp", "*.ma"},
|
||||
MimeTypes: []string{"application/mathematica", "application/vnd.wolfram.mathematica", "application/vnd.wolfram.mathematica.package", "application/vnd.wolfram.cdf"},
|
||||
},
|
||||
Rules{
|
||||
mathematicaRules,
|
||||
))
|
||||
|
||||
func mathematicaRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`(?s)\(\*.*?\*\)`, Comment, nil},
|
||||
{"([a-zA-Z]+[A-Za-z0-9]*`)", NameNamespace, nil},
|
||||
@ -28,5 +32,5 @@ var Mathematica = internal.Register(MustNewLexer(
|
||||
{`".*?"`, LiteralString, nil},
|
||||
{`\s+`, TextWhitespace, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// Matlab lexer.
|
||||
var Matlab = internal.Register(MustNewLexer(
|
||||
var Matlab = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Matlab",
|
||||
Aliases: []string{"matlab"},
|
||||
Filenames: []string{"*.m"},
|
||||
MimeTypes: []string{"text/matlab"},
|
||||
},
|
||||
Rules{
|
||||
matlabRules,
|
||||
))
|
||||
|
||||
func matlabRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\n`, Text, nil},
|
||||
{`^!.*`, LiteralStringOther, nil},
|
||||
@ -47,5 +51,5 @@ var Matlab = internal.Register(MustNewLexer(
|
||||
{`(\s*)(?:(.+)(\s*)(=)(\s*))?(.+)(\()(.*)(\))(\s*)`, ByGroups(TextWhitespace, Text, TextWhitespace, Punctuation, TextWhitespace, NameFunction, Punctuation, Text, Punctuation, TextWhitespace), Pop(1)},
|
||||
{`(\s*)([a-zA-Z_]\w*)`, ByGroups(Text, NameFunction), Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// MiniZinc lexer.
|
||||
var MZN = internal.Register(MustNewLexer(
|
||||
var MZN = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "MiniZinc",
|
||||
Aliases: []string{"minizinc", "MZN", "mzn"},
|
||||
Filenames: []string{"*.mzn", "*.dzn", "*.fzn"},
|
||||
MimeTypes: []string{"text/minizinc"},
|
||||
},
|
||||
Rules{
|
||||
mznRules,
|
||||
))
|
||||
|
||||
func mznRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`\n`, Text, nil},
|
||||
{`\s+`, Text, nil},
|
||||
@ -37,5 +41,5 @@ var MZN = internal.Register(MustNewLexer(
|
||||
{`\b([^\W\d]\w*)\b(\()`, ByGroups(NameFunction, Punctuation), nil},
|
||||
{`[^\W\d]\w*`, NameOther, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,14 +6,18 @@ import (
|
||||
)
|
||||
|
||||
// MLIR lexer.
|
||||
var Mlir = internal.Register(MustNewLexer(
|
||||
var Mlir = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "MLIR",
|
||||
Aliases: []string{"mlir"},
|
||||
Filenames: []string{"*.mlir"},
|
||||
MimeTypes: []string{"text/x-mlir"},
|
||||
},
|
||||
Rules{
|
||||
mlirRules,
|
||||
))
|
||||
|
||||
func mlirRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
Include("whitespace"),
|
||||
{`c?"[^"]*?"`, LiteralString, nil},
|
||||
@ -39,5 +43,5 @@ var Mlir = internal.Register(MustNewLexer(
|
||||
{`bf16|f16|f32|f64|index`, Keyword, nil},
|
||||
{`i[1-9]\d*`, Keyword, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ import (
|
||||
)
|
||||
|
||||
// Modula-2 lexer.
|
||||
var Modula2 = internal.Register(MustNewLexer(
|
||||
var Modula2 = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "Modula-2",
|
||||
Aliases: []string{"modula2", "m2"},
|
||||
@ -14,7 +14,11 @@ var Modula2 = internal.Register(MustNewLexer(
|
||||
MimeTypes: []string{"text/x-modula2"},
|
||||
DotAll: true,
|
||||
},
|
||||
Rules{
|
||||
modula2Rules,
|
||||
))
|
||||
|
||||
func modula2Rules() Rules {
|
||||
return Rules{
|
||||
"whitespace": {
|
||||
{`\n+`, Text, nil},
|
||||
{`\s+`, Text, nil},
|
||||
@ -111,5 +115,5 @@ var Modula2 = internal.Register(MustNewLexer(
|
||||
Include("unigraph_punctuation"),
|
||||
Include("unigraph_operators"),
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
@ -5,14 +5,18 @@ import (
|
||||
"github.com/alecthomas/chroma/lexers/internal"
|
||||
)
|
||||
|
||||
var MonkeyC = internal.Register(MustNewLexer(
|
||||
var MonkeyC = internal.Register(MustNewLazyLexer(
|
||||
&Config{
|
||||
Name: "MonkeyC",
|
||||
Aliases: []string{"monkeyc"},
|
||||
Filenames: []string{"*.mc"},
|
||||
MimeTypes: []string{"text/x-monkeyc"},
|
||||
},
|
||||
Rules{
|
||||
monkeyCRules,
|
||||
))
|
||||
|
||||
func monkeyCRules() Rules {
|
||||
return Rules{
|
||||
"root": {
|
||||
{`[^\S\n]+`, Text, nil},
|
||||
{`\n`, Text, nil},
|
||||
@ -58,5 +62,5 @@ var MonkeyC = internal.Register(MustNewLexer(
|
||||
{`[a-zA-Z_][\w_\.]*`, NameNamespace, nil},
|
||||
Default(Pop(1)),
|
||||
},
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user