package lexers
import "github.com/alecthomas/chroma/lexers"
Index ¶
- Variables
- func Analyse(text string) chroma.Lexer
- func Get(name string) chroma.Lexer
- func Match(filename string) chroma.Lexer
- func MatchMimeType(mimeType string) chroma.Lexer
- func Names(withAliases bool) []string
- func Register(lexer chroma.Lexer) chroma.Lexer
Variables ¶
var ANTLR = Register(MustNewLexer( &Config{ Name: "ANTLR", Aliases: []string{"antlr"}, Filenames: []string{}, MimeTypes: []string{}, }, Rules{ "whitespace": { {`\s+`, TextWhitespace, nil}, }, "comments": { {`//.*$`, Comment, nil}, {`/\*(.|\n)*?\*/`, Comment, nil}, }, "root": { Include("whitespace"), Include("comments"), {`(lexer|parser|tree)?(\s*)(grammar\b)(\s*)([A-Za-z]\w*)(;)`, ByGroups(Keyword, TextWhitespace, Keyword, TextWhitespace, NameClass, Punctuation), nil}, {`options\b`, Keyword, Push("options")}, {`tokens\b`, Keyword, Push("tokens")}, {`(scope)(\s*)([A-Za-z]\w*)(\s*)(\{)`, ByGroups(Keyword, TextWhitespace, NameVariable, TextWhitespace, Punctuation), Push("action")}, {`(catch|finally)\b`, Keyword, Push("exception")}, {`(@[A-Za-z]\w*)(\s*)(::)?(\s*)([A-Za-z]\w*)(\s*)(\{)`, ByGroups(NameLabel, TextWhitespace, Punctuation, TextWhitespace, NameLabel, TextWhitespace, Punctuation), Push("action")}, {`((?:protected|private|public|fragment)\b)?(\s*)([A-Za-z]\w*)(!)?`, ByGroups(Keyword, TextWhitespace, NameLabel, Punctuation), Push("rule-alts", "rule-prelims")}, }, "exception": { {`\n`, TextWhitespace, Pop(1)}, {`\s`, TextWhitespace, nil}, Include("comments"), {`\[`, Punctuation, Push("nested-arg-action")}, {`\{`, Punctuation, Push("action")}, }, "rule-prelims": { Include("whitespace"), Include("comments"), {`returns\b`, Keyword, nil}, {`\[`, Punctuation, Push("nested-arg-action")}, {`\{`, Punctuation, Push("action")}, {`(throws)(\s+)([A-Za-z]\w*)`, ByGroups(Keyword, TextWhitespace, NameLabel), nil}, {`(,)(\s*)([A-Za-z]\w*)`, ByGroups(Punctuation, TextWhitespace, NameLabel), nil}, {`options\b`, Keyword, Push("options")}, {`(scope)(\s+)(\{)`, ByGroups(Keyword, TextWhitespace, Punctuation), Push("action")}, {`(scope)(\s+)([A-Za-z]\w*)(\s*)(;)`, ByGroups(Keyword, TextWhitespace, NameLabel, TextWhitespace, Punctuation), nil}, {`(@[A-Za-z]\w*)(\s*)(\{)`, ByGroups(NameLabel, TextWhitespace, Punctuation), Push("action")}, {`:`, Punctuation, Pop(1)}, }, "rule-alts": { Include("whitespace"), Include("comments"), {`options\b`, Keyword, Push("options")}, {`:`, Punctuation, nil}, {`'(\\\\|\\'|[^'])*'`, LiteralString, nil}, {`"(\\\\|\\"|[^"])*"`, LiteralString, nil}, {`<<([^>]|>[^>])>>`, LiteralString, nil}, {`\$?[A-Z_]\w*`, NameConstant, nil}, {`\$?[a-z_]\w*`, NameVariable, nil}, {`(\+|\||->|=>|=|\(|\)|\.\.|\.|\?|\*|\^|!|\#|~)`, Operator, nil}, {`,`, Punctuation, nil}, {`\[`, Punctuation, Push("nested-arg-action")}, {`\{`, Punctuation, Push("action")}, {`;`, Punctuation, Pop(1)}, }, "tokens": { Include("whitespace"), Include("comments"), {`\{`, Punctuation, nil}, {`([A-Z]\w*)(\s*)(=)?(\s*)(\'(?:\\\\|\\\'|[^\']*)\')?(\s*)(;)`, ByGroups(NameLabel, TextWhitespace, Punctuation, TextWhitespace, LiteralString, TextWhitespace, Punctuation), nil}, {`\}`, Punctuation, Pop(1)}, }, "options": { Include("whitespace"), Include("comments"), {`\{`, Punctuation, nil}, {`([A-Za-z]\w*)(\s*)(=)(\s*)([A-Za-z]\w*|\'(?:\\\\|\\\'|[^\']*)\'|[0-9]+|\*)(\s*)(;)`, ByGroups(NameVariable, TextWhitespace, Punctuation, TextWhitespace, Text, TextWhitespace, Punctuation), nil}, {`\}`, Punctuation, Pop(1)}, }, "action": { {`([^${}\'"/\\]+|"(\\\\|\\"|[^"])*"|'(\\\\|\\'|[^'])*'|//.*$\n?|/\*(.|\n)*?\*/|/(?!\*)(\\\\|\\/|[^/])*/|\\(?!%)|/)+`, Other, nil}, {`(\\)(%)`, ByGroups(Punctuation, Other), nil}, {`(\$[a-zA-Z]+)(\.?)(text|value)?`, ByGroups(NameVariable, Punctuation, NameProperty), nil}, {`\{`, Punctuation, Push()}, {`\}`, Punctuation, Pop(1)}, }, "nested-arg-action": { {`([^$\[\]\'"/]+|"(\\\\|\\"|[^"])*"|'(\\\\|\\'|[^'])*'|//.*$\n?|/\*(.|\n)*?\*/|/(?!\*)(\\\\|\\/|[^/])*/|/)+`, Other, nil}, {`\[`, Punctuation, Push()}, {`\]`, Punctuation, Pop(1)}, {`(\$[a-zA-Z]+)(\.?)(text|value)?`, ByGroups(NameVariable, Punctuation, NameProperty), nil}, {`(\\\\|\\\]|\\\[|[^\[\]])+`, Other, nil}, }, }, ))
ANTLR lexer.
var Abnf = Register(MustNewLexer( &Config{ Name: "ABNF", Aliases: []string{"abnf"}, Filenames: []string{"*.abnf"}, MimeTypes: []string{"text/x-abnf"}, }, Rules{ "root": { {`;.*$`, CommentSingle, nil}, {`(%[si])?"[^"]*"`, Literal, nil}, {`%b[01]+\-[01]+\b`, Literal, nil}, {`%b[01]+(\.[01]+)*\b`, Literal, nil}, {`%d[0-9]+\-[0-9]+\b`, Literal, nil}, {`%d[0-9]+(\.[0-9]+)*\b`, Literal, nil}, {`%x[0-9a-fA-F]+\-[0-9a-fA-F]+\b`, Literal, nil}, {`%x[0-9a-fA-F]+(\.[0-9a-fA-F]+)*\b`, Literal, nil}, {`\b[0-9]+\*[0-9]+`, Operator, nil}, {`\b[0-9]+\*`, Operator, nil}, {`\b[0-9]+`, Operator, nil}, {`\*`, Operator, nil}, {Words(``, `\b`, `ALPHA`, `BIT`, `CHAR`, `CR`, `CRLF`, `CTL`, `DIGIT`, `DQUOTE`, `HEXDIG`, `HTAB`, `LF`, `LWSP`, `OCTET`, `SP`, `VCHAR`, `WSP`), Keyword, nil}, {`[a-zA-Z][a-zA-Z0-9-]+\b`, NameClass, nil}, {`(=/|=|/)`, Operator, nil}, {`[\[\]()]`, Punctuation, nil}, {`\s+`, Text, nil}, {`.`, Text, nil}, }, }, ))
Abnf lexer.
var Actionscript = Register(MustNewLexer( &Config{ Name: "ActionScript", Aliases: []string{"as", "actionscript"}, Filenames: []string{"*.as"}, MimeTypes: []string{"application/x-actionscript", "text/x-actionscript", "text/actionscript"}, NotMultiline: true, DotAll: true, }, Rules{ "root": { {`\s+`, Text, nil}, {`//.*?\n`, CommentSingle, nil}, {`/\*.*?\*/`, CommentMultiline, nil}, {`/(\\\\|\\/|[^/\n])*/[gim]*`, LiteralStringRegex, nil}, {`[~^*!%&<>|+=:;,/?\\-]+`, Operator, nil}, {`[{}\[\]();.]+`, Punctuation, nil}, {Words(``, `\b`, `case`, `default`, `for`, `each`, `in`, `while`, `do`, `break`, `return`, `continue`, `if`, `else`, `throw`, `try`, `catch`, `var`, `with`, `new`, `typeof`, `arguments`, `instanceof`, `this`, `switch`), Keyword, nil}, {Words(``, `\b`, `class`, `public`, `final`, `internal`, `native`, `override`, `private`, `protected`, `static`, `import`, `extends`, `implements`, `interface`, `intrinsic`, `return`, `super`, `dynamic`, `function`, `const`, `get`, `namespace`, `package`, `set`), KeywordDeclaration, nil}, {`(true|false|null|NaN|Infinity|-Infinity|undefined|Void)\b`, KeywordConstant, nil}, {Words(``, `\b`, `Accessibility`, `AccessibilityProperties`, `ActionScriptVersion`, `ActivityEvent`, `AntiAliasType`, `ApplicationDomain`, `AsBroadcaster`, `Array`, `AsyncErrorEvent`, `AVM1Movie`, `BevelFilter`, `Bitmap`, `BitmapData`, `BitmapDataChannel`, `BitmapFilter`, `BitmapFilterQuality`, `BitmapFilterType`, `BlendMode`, `BlurFilter`, `Boolean`, `ByteArray`, `Camera`, `Capabilities`, `CapsStyle`, `Class`, `Color`, `ColorMatrixFilter`, `ColorTransform`, `ContextMenu`, `ContextMenuBuiltInItems`, `ContextMenuEvent`, `ContextMenuItem`, `ConvultionFilter`, `CSMSettings`, `DataEvent`, `Date`, `DefinitionError`, `DeleteObjectSample`, `Dictionary`, `DisplacmentMapFilter`, `DisplayObject`, `DisplacmentMapFilterMode`, `DisplayObjectContainer`, `DropShadowFilter`, `Endian`, `EOFError`, `Error`, `ErrorEvent`, `EvalError`, `Event`, `EventDispatcher`, `EventPhase`, `ExternalInterface`, `FileFilter`, `FileReference`, `FileReferenceList`, `FocusDirection`, `FocusEvent`, `Font`, `FontStyle`, `FontType`, `FrameLabel`, `FullScreenEvent`, `Function`, `GlowFilter`, `GradientBevelFilter`, `GradientGlowFilter`, `GradientType`, `Graphics`, `GridFitType`, `HTTPStatusEvent`, `IBitmapDrawable`, `ID3Info`, `IDataInput`, `IDataOutput`, `IDynamicPropertyOutputIDynamicPropertyWriter`, `IEventDispatcher`, `IExternalizable`, `IllegalOperationError`, `IME`, `IMEConversionMode`, `IMEEvent`, `int`, `InteractiveObject`, `InterpolationMethod`, `InvalidSWFError`, `InvokeEvent`, `IOError`, `IOErrorEvent`, `JointStyle`, `Key`, `Keyboard`, `KeyboardEvent`, `KeyLocation`, `LineScaleMode`, `Loader`, `LoaderContext`, `LoaderInfo`, `LoadVars`, `LocalConnection`, `Locale`, `Math`, `Matrix`, `MemoryError`, `Microphone`, `MorphShape`, `Mouse`, `MouseEvent`, `MovieClip`, `MovieClipLoader`, `Namespace`, `NetConnection`, `NetStatusEvent`, `NetStream`, `NewObjectSample`, `Number`, `Object`, `ObjectEncoding`, `PixelSnapping`, `Point`, `PrintJob`, `PrintJobOptions`, `PrintJobOrientation`, `ProgressEvent`, `Proxy`, `QName`, `RangeError`, `Rectangle`, `ReferenceError`, `RegExp`, `Responder`, `Sample`, `Scene`, `ScriptTimeoutError`, `Security`, `SecurityDomain`, `SecurityError`, `SecurityErrorEvent`, `SecurityPanel`, `Selection`, `Shape`, `SharedObject`, `SharedObjectFlushStatus`, `SimpleButton`, `Socket`, `Sound`, `SoundChannel`, `SoundLoaderContext`, `SoundMixer`, `SoundTransform`, `SpreadMethod`, `Sprite`, `StackFrame`, `StackOverflowError`, `Stage`, `StageAlign`, `StageDisplayState`, `StageQuality`, `StageScaleMode`, `StaticText`, `StatusEvent`, `String`, `StyleSheet`, `SWFVersion`, `SyncEvent`, `SyntaxError`, `System`, `TextColorType`, `TextField`, `TextFieldAutoSize`, `TextFieldType`, `TextFormat`, `TextFormatAlign`, `TextLineMetrics`, `TextRenderer`, `TextSnapshot`, `Timer`, `TimerEvent`, `Transform`, `TypeError`, `uint`, `URIError`, `URLLoader`, `URLLoaderDataFormat`, `URLRequest`, `URLRequestHeader`, `URLRequestMethod`, `URLStream`, `URLVariabeles`, `VerifyError`, `Video`, `XML`, `XMLDocument`, `XMLList`, `XMLNode`, `XMLNodeType`, `XMLSocket`, `XMLUI`), NameBuiltin, nil}, {Words(``, `\b`, `decodeURI`, `decodeURIComponent`, `encodeURI`, `escape`, `eval`, `isFinite`, `isNaN`, `isXMLName`, `clearInterval`, `fscommand`, `getTimer`, `getURL`, `getVersion`, `parseFloat`, `parseInt`, `setInterval`, `trace`, `updateAfterEvent`, `unescape`), NameFunction, nil}, {`[$a-zA-Z_]\w*`, NameOther, nil}, {`[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?`, LiteralNumberFloat, nil}, {`0x[0-9a-f]+`, LiteralNumberHex, nil}, {`[0-9]+`, LiteralNumberInteger, nil}, {`"(\\\\|\\"|[^"])*"`, LiteralStringDouble, nil}, {`'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil}, }, }, ))
Actionscript lexer.
var Actionscript3 = Register(MustNewLexer( &Config{ Name: "ActionScript 3", Aliases: []string{"as3", "actionscript3"}, Filenames: []string{"*.as"}, MimeTypes: []string{"application/x-actionscript3", "text/x-actionscript3", "text/actionscript3"}, DotAll: true, }, Rules{ "root": { {`\s+`, Text, nil}, {`(function\s+)([$a-zA-Z_]\w*)(\s*)(\()`, ByGroups(KeywordDeclaration, NameFunction, Text, Operator), Push("funcparams")}, {`(var|const)(\s+)([$a-zA-Z_]\w*)(\s*)(:)(\s*)([$a-zA-Z_]\w*(?:\.<\w+>)?)`, ByGroups(KeywordDeclaration, Text, Name, Text, Punctuation, Text, KeywordType), nil}, {`(import|package)(\s+)((?:[$a-zA-Z_]\w*|\.)+)(\s*)`, ByGroups(Keyword, Text, NameNamespace, Text), nil}, {`(new)(\s+)([$a-zA-Z_]\w*(?:\.<\w+>)?)(\s*)(\()`, ByGroups(Keyword, Text, KeywordType, Text, Operator), nil}, {`//.*?\n`, CommentSingle, nil}, {`/\*.*?\*/`, CommentMultiline, nil}, {`/(\\\\|\\/|[^\n])*/[gisx]*`, LiteralStringRegex, nil}, {`(\.)([$a-zA-Z_]\w*)`, ByGroups(Operator, NameAttribute), nil}, {"" /* 155 byte string literal not displayed */, Keyword, nil}, {"" /* 182 byte string literal not displayed */, KeywordDeclaration, nil}, {`(true|false|null|NaN|Infinity|-Infinity|undefined|void)\b`, KeywordConstant, nil}, {"" /* 205 byte string literal not displayed */, NameFunction, nil}, {`[$a-zA-Z_]\w*`, Name, nil}, {`[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?`, LiteralNumberFloat, nil}, {`0x[0-9a-f]+`, LiteralNumberHex, nil}, {`[0-9]+`, LiteralNumberInteger, nil}, {`"(\\\\|\\"|[^"])*"`, LiteralStringDouble, nil}, {`'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil}, {`[~^*!%&<>|+=:;,/?\\{}\[\]().-]+`, Operator, nil}, }, "funcparams": { {`\s+`, Text, nil}, {`(\s*)(\.\.\.)?([$a-zA-Z_]\w*)(\s*)(:)(\s*)([$a-zA-Z_]\w*(?:\.<\w+>)?|\*)(\s*)`, ByGroups(Text, Punctuation, Name, Text, Operator, Text, KeywordType, Text), Push("defval")}, {`\)`, Operator, Push("type")}, }, "type": { {`(\s*)(:)(\s*)([$a-zA-Z_]\w*(?:\.<\w+>)?|\*)`, ByGroups(Text, Operator, Text, KeywordType), Pop(2)}, {`\s+`, Text, Pop(2)}, Default(Pop(2)), }, "defval": { {`(=)(\s*)([^(),]+)(\s*)(,?)`, ByGroups(Operator, Text, UsingSelf("root"), Text, Operator), Pop(1)}, {`,`, Operator, Pop(1)}, Default(Pop(1)), }, }, ))
Actionscript 3 lexer.
var Ada = Register(MustNewLexer( &Config{ Name: "Ada", Aliases: []string{"ada", "ada95", "ada2005"}, Filenames: []string{"*.adb", "*.ads", "*.ada"}, MimeTypes: []string{"text/x-ada"}, CaseInsensitive: true, }, Rules{ "root": { {`[^\S\n]+`, Text, nil}, {`--.*?\n`, CommentSingle, nil}, {`[^\S\n]+`, Text, nil}, {`function|procedure|entry`, KeywordDeclaration, Push("subprogram")}, {`(subtype|type)(\s+)(\w+)`, ByGroups(KeywordDeclaration, Text, KeywordType), Push("type_def")}, {`task|protected`, KeywordDeclaration, nil}, {`(subtype)(\s+)`, ByGroups(KeywordDeclaration, Text), nil}, {`(end)(\s+)`, ByGroups(KeywordReserved, Text), Push("end")}, {`(pragma)(\s+)(\w+)`, ByGroups(KeywordReserved, Text, CommentPreproc), nil}, {`(true|false|null)\b`, KeywordConstant, nil}, {Words(``, `\b`, `Address`, `Byte`, `Boolean`, `Character`, `Controlled`, `Count`, `Cursor`, `Duration`, `File_Mode`, `File_Type`, `Float`, `Generator`, `Integer`, `Long_Float`, `Long_Integer`, `Long_Long_Float`, `Long_Long_Integer`, `Natural`, `Positive`, `Reference_Type`, `Short_Float`, `Short_Integer`, `Short_Short_Float`, `Short_Short_Integer`, `String`, `Wide_Character`, `Wide_String`), KeywordType, nil}, {`(and(\s+then)?|in|mod|not|or(\s+else)|rem)\b`, OperatorWord, nil}, {`generic|private`, KeywordDeclaration, nil}, {`package`, KeywordDeclaration, Push("package")}, {`array\b`, KeywordReserved, Push("array_def")}, {`(with|use)(\s+)`, ByGroups(KeywordNamespace, Text), Push("import")}, {`(\w+)(\s*)(:)(\s*)(constant)`, ByGroups(NameConstant, Text, Punctuation, Text, KeywordReserved), nil}, {`<<\w+>>`, NameLabel, nil}, {`(\w+)(\s*)(:)(\s*)(declare|begin|loop|for|while)`, ByGroups(NameLabel, Text, Punctuation, Text, KeywordReserved), nil}, {Words(`\b`, `\b`, `abort`, `abs`, `abstract`, `accept`, `access`, `aliased`, `all`, `array`, `at`, `begin`, `body`, `case`, `constant`, `declare`, `delay`, `delta`, `digits`, `do`, `else`, `elsif`, `end`, `entry`, `exception`, `exit`, `interface`, `for`, `goto`, `if`, `is`, `limited`, `loop`, `new`, `null`, `of`, `or`, `others`, `out`, `overriding`, `pragma`, `protected`, `raise`, `range`, `record`, `renames`, `requeue`, `return`, `reverse`, `select`, `separate`, `subtype`, `synchronized`, `task`, `tagged`, `terminate`, `then`, `type`, `until`, `when`, `while`, `xor`), KeywordReserved, nil}, {`"[^"]*"`, LiteralString, nil}, Include("attribute"), Include("numbers"), {`'[^']'`, LiteralStringChar, nil}, {`(\w+)(\s*|[(,])`, ByGroups(Name, UsingSelf("root")), nil}, {`(<>|=>|:=|[()|:;,.'])`, Punctuation, nil}, {`[*<>+=/&-]`, Operator, nil}, {`\n+`, Text, nil}, }, "numbers": { {`[0-9_]+#[0-9a-f]+#`, LiteralNumberHex, nil}, {`[0-9_]+\.[0-9_]*`, LiteralNumberFloat, nil}, {`[0-9_]+`, LiteralNumberInteger, nil}, }, "attribute": { {`(')(\w+)`, ByGroups(Punctuation, NameAttribute), nil}, }, "subprogram": { {`\(`, Punctuation, Push("#pop", "formal_part")}, {`;`, Punctuation, Pop(1)}, {`is\b`, KeywordReserved, Pop(1)}, {`"[^"]+"|\w+`, NameFunction, nil}, Include("root"), }, "end": { {`(if|case|record|loop|select)`, KeywordReserved, nil}, {`"[^"]+"|[\w.]+`, NameFunction, nil}, {`\s+`, Text, nil}, {`;`, Punctuation, Pop(1)}, }, "type_def": { {`;`, Punctuation, Pop(1)}, {`\(`, Punctuation, Push("formal_part")}, {`with|and|use`, KeywordReserved, nil}, {`array\b`, KeywordReserved, Push("#pop", "array_def")}, {`record\b`, KeywordReserved, Push("record_def")}, {`(null record)(;)`, ByGroups(KeywordReserved, Punctuation), Pop(1)}, Include("root"), }, "array_def": { {`;`, Punctuation, Pop(1)}, {`(\w+)(\s+)(range)`, ByGroups(KeywordType, Text, KeywordReserved), nil}, Include("root"), }, "record_def": { {`end record`, KeywordReserved, Pop(1)}, Include("root"), }, "import": { {`[\w.]+`, NameNamespace, Pop(1)}, Default(Pop(1)), }, "formal_part": { {`\)`, Punctuation, Pop(1)}, {`\w+`, NameVariable, nil}, {`,|:[^=]`, Punctuation, nil}, {`(in|not|null|out|access)\b`, KeywordReserved, nil}, Include("root"), }, "package": { {`body`, KeywordDeclaration, nil}, {`is\s+new|renames`, KeywordReserved, nil}, {`is`, KeywordReserved, Pop(1)}, {`;`, Punctuation, Pop(1)}, {`\(`, Punctuation, Push("package_instantiation")}, {`([\w.]+)`, NameClass, nil}, Include("root"), }, "package_instantiation": { {`("[^"]+"|\w+)(\s+)(=>)`, ByGroups(NameVariable, Text, Punctuation), nil}, {`[\w.\'"]`, Text, nil}, {`\)`, Punctuation, Pop(1)}, Include("root"), }, }, ))
Ada lexer.
var Angular2 = Register(MustNewLexer( &Config{ Name: "Angular2", Aliases: []string{"ng2"}, Filenames: []string{}, MimeTypes: []string{}, }, Rules{ "root": { {`[^{([*#]+`, Other, nil}, {`(\{\{)(\s*)`, ByGroups(CommentPreproc, Text), Push("ngExpression")}, {`([([]+)([\w:.-]+)([\])]+)(\s*)(=)(\s*)`, ByGroups(Punctuation, NameAttribute, Punctuation, Text, Operator, Text), Push("attr")}, {`([([]+)([\w:.-]+)([\])]+)(\s*)`, ByGroups(Punctuation, NameAttribute, Punctuation, Text), nil}, {`([*#])([\w:.-]+)(\s*)(=)(\s*)`, ByGroups(Punctuation, NameAttribute, Punctuation, Operator), Push("attr")}, {`([*#])([\w:.-]+)(\s*)`, ByGroups(Punctuation, NameAttribute, Punctuation), nil}, }, "ngExpression": { {`\s+(\|\s+)?`, Text, nil}, {`\}\}`, CommentPreproc, Pop(1)}, {`:?(true|false)`, LiteralStringBoolean, nil}, {`:?"(\\\\|\\"|[^"])*"`, LiteralStringDouble, nil}, {`:?'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil}, {`[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?`, LiteralNumber, nil}, {`[a-zA-Z][\w-]*(\(.*\))?`, NameVariable, nil}, {`\.[\w-]+(\(.*\))?`, NameVariable, nil}, {`(\?)(\s*)([^}\s]+)(\s*)(:)(\s*)([^}\s]+)(\s*)`, ByGroups(Operator, Text, LiteralString, Text, Operator, Text, LiteralString, Text), nil}, }, "attr": { {`".*?"`, LiteralString, Pop(1)}, {`'.*?'`, LiteralString, Pop(1)}, {`[^\s>]+`, LiteralString, Pop(1)}, }, }, ))
Angular2 lexer.
var Apacheconf = Register(MustNewLexer( &Config{ Name: "ApacheConf", Aliases: []string{"apacheconf", "aconf", "apache"}, Filenames: []string{".htaccess", "apache.conf", "apache2.conf"}, MimeTypes: []string{"text/x-apacheconf"}, CaseInsensitive: true, }, Rules{ "root": { {`\s+`, Text, nil}, {`(#.*?)$`, Comment, nil}, {`(<[^\s>]+)(?:(\s+)(.*?))?(>)`, ByGroups(NameTag, Text, LiteralString, NameTag), nil}, {`([a-z]\w*)(\s+)`, ByGroups(NameBuiltin, Text), Push("value")}, {`\.+`, Text, nil}, }, "value": { {`\\\n`, Text, nil}, {`$`, Text, Pop(1)}, {`\\`, Text, nil}, {`[^\S\n]+`, Text, nil}, {`\d+\.\d+\.\d+\.\d+(?:/\d+)?`, LiteralNumber, nil}, {`\d+`, LiteralNumber, nil}, {`/([a-z0-9][\w./-]+)`, LiteralStringOther, nil}, {"" /* 164 byte string literal not displayed */, Keyword, nil}, {`"([^"\\]*(?:\\.[^"\\]*)*)"`, LiteralStringDouble, nil}, {`[^\s"\\]+`, Text, nil}, }, }, ))
Apacheconf lexer.
var Apl = Register(MustNewLexer( &Config{ Name: "APL", Aliases: []string{"apl"}, Filenames: []string{"*.apl"}, MimeTypes: []string{}, }, Rules{ "root": { {`\s+`, Text, nil}, {`[⍝#].*$`, CommentSingle, nil}, {`\'((\'\')|[^\'])*\'`, LiteralStringSingle, nil}, {`"(("")|[^"])*"`, LiteralStringDouble, nil}, {`[⋄◇()]`, Punctuation, nil}, {`[\[\];]`, LiteralStringRegex, nil}, {`⎕[A-Za-zΔ∆⍙][A-Za-zΔ∆⍙_¯0-9]*`, NameFunction, nil}, {`[A-Za-zΔ∆⍙][A-Za-zΔ∆⍙_¯0-9]*`, NameVariable, nil}, {"" /* 137 byte string literal not displayed */, LiteralNumber, nil}, {`[\.\\/⌿⍀¨⍣⍨⍠⍤∘]`, NameAttribute, nil}, {"" /* 152 byte string literal not displayed */, Operator, nil}, {`⍬`, NameConstant, nil}, {`[⎕⍞]`, NameVariableGlobal, nil}, {`[←→]`, KeywordDeclaration, nil}, {`[⍺⍵⍶⍹∇:]`, NameBuiltinPseudo, nil}, {`[{}]`, KeywordType, nil}, }, }, ))
Apl lexer.
var Applescript = Register(MustNewLexer( &Config{ Name: "AppleScript", Aliases: []string{"applescript"}, Filenames: []string{"*.applescript"}, MimeTypes: []string{}, DotAll: true, }, Rules{ "root": { {`\s+`, Text, nil}, {`¬\n`, LiteralStringEscape, nil}, {`'s\s+`, Text, nil}, {`(--|#).*?$`, Comment, nil}, {`\(\*`, CommentMultiline, Push("comment")}, {`[(){}!,.:]`, Punctuation, nil}, {`(«)([^»]+)(»)`, ByGroups(Text, NameBuiltin, Text), nil}, {`\b((?:considering|ignoring)\s*)(application responses|case|diacriticals|hyphens|numeric strings|punctuation|white space)`, ByGroups(Keyword, NameBuiltin), nil}, {`(-|\*|\+|&|≠|>=?|<=?|=|≥|≤|/|÷|\^)`, Operator, nil}, {"" /* 736 byte string literal not displayed */, OperatorWord, nil}, {"" /* 1846 byte string literal not displayed */, ByGroups(Keyword, NameFunction), nil}, {`^(\s*)(in|on|script|to)(\s+)`, ByGroups(Text, Keyword, Text), nil}, {"" /* 191 byte string literal not displayed */, ByGroups(Keyword, NameClass), nil}, {"" /* 135 byte string literal not displayed */, NameConstant, nil}, {"" /* 642 byte string literal not displayed */, NameBuiltin, nil}, {"" /* 196 byte string literal not displayed */, Keyword, nil}, {`\b(global|local|prop(erty)?|set|get)\b`, Keyword, nil}, {`\b(but|put|returning|the)\b`, NameBuiltin, nil}, {`\b(attachment|attribute run|character|day|month|paragraph|word|year)s?\b`, NameBuiltin, nil}, {"" /* 135 byte string literal not displayed */, NameBuiltin, nil}, {"" /* 4937 byte string literal not displayed */, NameAttribute, nil}, {"" /* 637 byte string literal not displayed */, NameBuiltin, nil}, {"" /* 406 byte string literal not displayed */, NameBuiltin, nil}, {"" /* 211 byte string literal not displayed */, NameBuiltin, nil}, {`"(\\\\|\\"|[^"])*"`, LiteralStringDouble, nil}, {`\b([a-zA-Z]\w*)\b`, NameVariable, nil}, {`[-+]?(\d+\.\d*|\d*\.\d+)(E[-+][0-9]+)?`, LiteralNumberFloat, nil}, {`[-+]?\d+`, LiteralNumberInteger, nil}, }, "comment": { {`\(\*`, CommentMultiline, Push()}, {`\*\)`, CommentMultiline, Pop(1)}, {`[^*(]+`, CommentMultiline, nil}, {`[*(]`, CommentMultiline, nil}, }, }, ))
Applescript lexer.
var Awk = Register(MustNewLexer( &Config{ Name: "Awk", Aliases: []string{"awk", "gawk", "mawk", "nawk"}, Filenames: []string{"*.awk"}, MimeTypes: []string{"application/x-awk"}, }, Rules{ "commentsandwhitespace": { {`\s+`, Text, nil}, {`#.*$`, CommentSingle, nil}, }, "slashstartsregex": { Include("commentsandwhitespace"), {`/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/\B`, LiteralStringRegex, Pop(1)}, {`(?=/)`, Text, Push("#pop", "badregex")}, Default(Pop(1)), }, "badregex": { {`\n`, Text, Pop(1)}, }, "root": { {`^(?=\s|/)`, Text, Push("slashstartsregex")}, Include("commentsandwhitespace"), {`\+\+|--|\|\||&&|in\b|\$|!?~|(\*\*|[-<>+*%\^/!=|])=?`, Operator, Push("slashstartsregex")}, {`[{(\[;,]`, Punctuation, Push("slashstartsregex")}, {`[})\].]`, Punctuation, nil}, {`(break|continue|do|while|exit|for|if|else|return)\b`, Keyword, Push("slashstartsregex")}, {`function\b`, KeywordDeclaration, Push("slashstartsregex")}, {"" /* 198 byte string literal not displayed */, KeywordReserved, nil}, {"" /* 141 byte string literal not displayed */, NameBuiltin, nil}, {`[$a-zA-Z_]\w*`, NameOther, nil}, {`[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?`, LiteralNumberFloat, nil}, {`0x[0-9a-fA-F]+`, LiteralNumberHex, nil}, {`[0-9]+`, LiteralNumberInteger, nil}, {`"(\\\\|\\"|[^"])*"`, LiteralStringDouble, nil}, {`'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil}, }, }, ))
Awk lexer.
var Bash = Register(MustNewLexer( &Config{ Name: "Bash", Aliases: []string{"bash", "sh", "ksh", "zsh", "shell"}, Filenames: []string{"*.sh", "*.ksh", "*.bash", "*.ebuild", "*.eclass", "*.exheres-0", "*.exlib", "*.zsh", "*.zshrc", ".bashrc", "bashrc", ".bash_*", "bash_*", "zshrc", ".zshrc", "PKGBUILD"}, MimeTypes: []string{"application/x-sh", "application/x-shellscript"}, }, Rules{ "root": { Include("basic"), {"`", LiteralStringBacktick, Push("backticks")}, Include("data"), Include("interp"), }, "interp": { {`\$\(\(`, Keyword, Push("math")}, {`\$\(`, Keyword, Push("paren")}, {`\$\{#?`, LiteralStringInterpol, Push("curly")}, {`\$[a-zA-Z_]\w*`, NameVariable, nil}, {`\$(?:\d+|[#$?!_*@-])`, NameVariable, nil}, {`\$`, Text, nil}, }, "basic": { {`\b(if|fi|else|while|do|done|for|then|return|function|case|select|continue|until|esac|elif)(\s*)\b`, ByGroups(Keyword, Text), nil}, {"" /* 337 byte string literal not displayed */, NameBuiltin, nil}, {`\A#!.+\n`, CommentPreproc, nil}, {`#.*\n`, CommentSingle, nil}, {`\\[\w\W]`, LiteralStringEscape, nil}, {`(\b\w+)(\s*)(\+?=)`, ByGroups(NameVariable, Text, Operator), nil}, {`[\[\]{}()=]`, Operator, nil}, {`<<<`, Operator, nil}, {`<<-?\s*(\'?)\\?(\w+)[\w\W]+?\2`, LiteralString, nil}, {`&&|\|\|`, Operator, nil}, }, "data": { {`(?s)\$?"(\\\\|\\[0-7]+|\\.|[^"\\$])*"`, LiteralStringDouble, nil}, {`"`, LiteralStringDouble, Push("string")}, {`(?s)\$'(\\\\|\\[0-7]+|\\.|[^'\\])*'`, LiteralStringSingle, nil}, {`(?s)'.*?'`, LiteralStringSingle, nil}, {`;`, Punctuation, nil}, {`&`, Punctuation, nil}, {`\|`, Punctuation, nil}, {`\s+`, Text, nil}, {`\d+\b`, LiteralNumber, nil}, {"[^=\\s\\[\\]{}()$\"\\'`\\\\<&|;]+", Text, nil}, {`<`, Text, nil}, }, "string": { {`"`, LiteralStringDouble, Pop(1)}, {`(?s)(\\\\|\\[0-7]+|\\.|[^"\\$])+`, LiteralStringDouble, nil}, Include("interp"), }, "curly": { {`\}`, LiteralStringInterpol, Pop(1)}, {`:-`, Keyword, nil}, {`\w+`, NameVariable, nil}, {"[^}:\"\\'`$\\\\]+", Punctuation, nil}, {`:`, Punctuation, nil}, Include("root"), }, "paren": { {`\)`, Keyword, Pop(1)}, Include("root"), }, "math": { {`\)\)`, Keyword, Pop(1)}, {`[-+*/%^|&]|\*\*|\|\|`, Operator, nil}, {`\d+#\d+`, LiteralNumber, nil}, {`\d+#(?! )`, LiteralNumber, nil}, {`\d+`, LiteralNumber, nil}, Include("root"), }, "backticks": { {"`", LiteralStringBacktick, Pop(1)}, Include("root"), }, }, ).SetAnalyser(func(text string) float32 { if bashAnalyserRe.FindString(text) != "" { return 1.0 } return 0.0 }))
Bash lexer.
var Batchfile = Register(MustNewLexer( &Config{ Name: "Batchfile", Aliases: []string{"bat", "batch", "dosbatch", "winbatch"}, Filenames: []string{"*.bat", "*.cmd"}, MimeTypes: []string{"application/x-dos-batch"}, CaseInsensitive: true, }, 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")}, {`(?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)`, UsingSelf("text"), nil}, Include("redirect"), {`[\n\x1a]+`, Text, nil}, {`\(`, Punctuation, Push("root/compound")}, {`@+`, Punctuation, nil}, {"" /* 246 byte string literal not displayed */, ByGroups(Keyword, UsingSelf("text")), Push("follow")}, {"" /* 814 byte string literal not displayed */, ByGroups(Keyword, UsingSelf("text")), Push("follow")}, {Words(``, `(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&<>|(])`, `assoc`, `break`, `cd`, `chdir`, `cls`, `color`, `copy`, `date`, `del`, `dir`, `dpath`, `echo`, `endlocal`, `erase`, `exit`, `ftype`, `keys`, `md`, `mkdir`, `mklink`, `move`, `path`, `pause`, `popd`, `prompt`, `pushd`, `rd`, `ren`, `rename`, `rmdir`, `setlocal`, `shift`, `start`, `time`, `title`, `type`, `ver`, `verify`, `vol`), Keyword, Push("follow")}, {`(call)((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?)(:)`, ByGroups(Keyword, UsingSelf("text"), Punctuation), Push("call")}, {`call(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&<>|(])`, Keyword, nil}, {"" /* 137 byte string literal not displayed */, ByGroups(Keyword, UsingSelf("text"), Keyword), Push("for/f", "for")}, {"" /* 137 byte string literal not displayed */, ByGroups(Keyword, UsingSelf("text"), Keyword), Push("for/l", "for")}, {`for(?=\^?[\t\v\f\r ,;=\xa0]|[&<>|\n\x1a])(?!\^)`, Keyword, Push("for2", "for")}, {`(goto(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&<>|(]))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?)(:?)`, ByGroups(Keyword, UsingSelf("text"), Punctuation), Push("label")}, {"" /* 291 byte string literal not displayed */, ByGroups(Keyword, UsingSelf("text"), Keyword, UsingSelf("text"), Keyword, UsingSelf("text")), Push("(?", "if")}, {"" /* 605 byte string literal not displayed */, CommentSingle, Push("follow")}, {`(set(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&<>|(]))((?:(?:\^[\n\x1a]?)?[^\S\n])*)(/a)`, ByGroups(Keyword, UsingSelf("text"), Keyword), Push("arithmetic")}, {"" /* 222 byte string literal not displayed */, ByGroups(Keyword, UsingSelf("text"), Keyword, UsingSelf("text"), UsingSelf("variable"), Punctuation), Push("follow")}, Default(Push("follow")), }, "follow": { {"" /* 133 byte string literal not displayed */, ByGroups(Text, Punctuation, Text, NameLabel, CommentSingle), nil}, Include("redirect"), {`(?=[\n\x1a])`, Text, Pop(1)}, {`\|\|?|&&?`, Punctuation, Pop(1)}, Include("text"), }, "arithmetic": { {`0[0-7]+`, LiteralNumberOct, nil}, {`0x[\da-f]+`, LiteralNumberHex, nil}, {`\d+`, LiteralNumberInteger, nil}, {`[(),]+`, Punctuation, nil}, {`([=+\-*/!~]|%|\^\^)+`, Operator, nil}, {"" /* 429 byte string literal not displayed */, UsingSelf("variable"), nil}, {`(?=[\x00|&])`, Text, Pop(1)}, Include("follow"), }, "call": { {`(:?)((?:(?:[^\n\x1a&<>|\t\v\f\r ,;=\xa0+:^]|\^[\n\x1a]?[\w\W])*))`, ByGroups(Punctuation, NameLabel), Pop(1)}, }, "label": { {"" /* 439 byte string literal not displayed */, ByGroups(NameLabel, CommentSingle), Pop(1)}, }, "redirect": { {`((?:(?<=[\n\x1a\t\v\f\r ,;=\xa0])\d)?)(>>?&|<&)([\n\x1a\t\v\f\r ,;=\xa0]*)(\d)`, ByGroups(LiteralNumberInteger, Punctuation, Text, LiteralNumberInteger), nil}, {"" /* 513 byte string literal not displayed */, ByGroups(LiteralNumberInteger, Punctuation, UsingSelf("text")), nil}, }, "root/compound": { {`\)`, Punctuation, Pop(1)}, {`(?=((?:(?<=^[^:])|^[^:]?)[\t\v\f\r ,;=\xa0]*)(:))`, Text, Push("follow/compound")}, {`(?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)`, UsingSelf("text"), nil}, Include("redirect/compound"), {`[\n\x1a]+`, Text, nil}, {`\(`, Punctuation, Push("root/compound")}, {`@+`, Punctuation, nil}, {"" /* 258 byte string literal not displayed */, ByGroups(Keyword, UsingSelf("text")), Push("follow/compound")}, {"" /* 827 byte string literal not displayed */, ByGroups(Keyword, UsingSelf("text")), Push("follow/compound")}, {Words(``, `(?:(?=\))|(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&<>|(]))`, `assoc`, `break`, `cd`, `chdir`, `cls`, `color`, `copy`, `date`, `del`, `dir`, `dpath`, `echo`, `endlocal`, `erase`, `exit`, `ftype`, `keys`, `md`, `mkdir`, `mklink`, `move`, `path`, `pause`, `popd`, `prompt`, `pushd`, `rd`, `ren`, `rename`, `rmdir`, `setlocal`, `shift`, `start`, `time`, `title`, `type`, `ver`, `verify`, `vol`), Keyword, Push("follow/compound")}, {`(call)((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)?)(:)`, ByGroups(Keyword, UsingSelf("text"), Punctuation), Push("call/compound")}, {`call(?:(?=\))|(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&<>|(]))`, Keyword, nil}, {"" /* 159 byte string literal not displayed */, ByGroups(Keyword, UsingSelf("text"), Keyword), Push("for/f", "for")}, {"" /* 159 byte string literal not displayed */, ByGroups(Keyword, UsingSelf("text"), Keyword), Push("for/l", "for")}, {`for(?:(?=\))|(?=\^?[\t\v\f\r ,;=\xa0]|[&<>|\n\x1a]))(?!\^)`, Keyword, Push("for2", "for")}, {"" /* 129 byte string literal not displayed */, ByGroups(Keyword, UsingSelf("text"), Punctuation), Push("label/compound")}, {"" /* 324 byte string literal not displayed */, ByGroups(Keyword, UsingSelf("text"), Keyword, UsingSelf("text"), Keyword, UsingSelf("text")), Push("(?", "if")}, {"" /* 626 byte string literal not displayed */, CommentSingle, Push("follow/compound")}, {`(set(?:(?=\))|(?=(?:\^[\n\x1a]?)?[\t\v\f\r ,;=\xa0+./:[\\\]]|[\n\x1a&<>|(])))((?:(?:\^[\n\x1a]?)?[^\S\n])*)(/a)`, ByGroups(Keyword, UsingSelf("text"), Keyword), Push("arithmetic/compound")}, {"" /* 234 byte string literal not displayed */, ByGroups(Keyword, UsingSelf("text"), Keyword, UsingSelf("text"), UsingSelf("variable"), Punctuation), Push("follow/compound")}, Default(Push("follow/compound")), }, "follow/compound": { {`(?=\))`, Text, Pop(1)}, {"" /* 132 byte string literal not displayed */, ByGroups(Text, Punctuation, Text, NameLabel, CommentSingle), nil}, Include("redirect/compound"), {`(?=[\n\x1a])`, Text, Pop(1)}, {`\|\|?|&&?`, Punctuation, Pop(1)}, Include("text"), }, "arithmetic/compound": { {`(?=\))`, Text, Pop(1)}, {`0[0-7]+`, LiteralNumberOct, nil}, {`0x[\da-f]+`, LiteralNumberHex, nil}, {`\d+`, LiteralNumberInteger, nil}, {`[(),]+`, Punctuation, nil}, {`([=+\-*/!~]|%|\^\^)+`, Operator, nil}, {"" /* 427 byte string literal not displayed */, UsingSelf("variable"), nil}, {`(?=[\x00|&])`, Text, Pop(1)}, Include("follow"), }, "call/compound": { {`(?=\))`, Text, Pop(1)}, {`(:?)((?:(?:[^\n\x1a&<>|\t\v\f\r ,;=\xa0+:^)]|\^[\n\x1a]?[^)])*))`, ByGroups(Punctuation, NameLabel), Pop(1)}, }, "label/compound": { {`(?=\))`, Text, Pop(1)}, {"" /* 437 byte string literal not displayed */, ByGroups(NameLabel, CommentSingle), Pop(1)}, }, "redirect/compound": { {`((?:(?<=[\n\x1a\t\v\f\r ,;=\xa0])\d)?)(>>?&|<&)([\n\x1a\t\v\f\r ,;=\xa0]*)(\d)`, ByGroups(LiteralNumberInteger, Punctuation, Text, LiteralNumberInteger), nil}, {"" /* 514 byte string literal not displayed */, ByGroups(LiteralNumberInteger, Punctuation, UsingSelf("text")), nil}, }, "variable-or-escape": { {"" /* 300 byte string literal not displayed */, NameVariable, nil}, {`%%|\^[\n\x1a]?(\^!|[\w\W])`, LiteralStringEscape, nil}, }, "string": { {`"`, LiteralStringDouble, Pop(1)}, {"" /* 300 byte string literal not displayed */, NameVariable, nil}, {`\^!|%%`, LiteralStringEscape, nil}, {`[^"%^\n\x1a]+|[%^]`, LiteralStringDouble, nil}, Default(Pop(1)), }, "sqstring": { Include("variable-or-escape"), {`[^%]+|%`, LiteralStringSingle, nil}, }, "bqstring": { Include("variable-or-escape"), {`[^%]+|%`, LiteralStringBacktick, nil}, }, "text": { {`"`, LiteralStringDouble, Push("string")}, Include("variable-or-escape"), {`[^"%^\n\x1a&<>|\t\v\f\r ,;=\xa0\d)]+|.`, Text, nil}, }, "variable": { {`"`, LiteralStringDouble, Push("string")}, Include("variable-or-escape"), {`[^"%^\n\x1a]+|.`, NameVariable, nil}, }, "for": { {`((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+))(in)((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+))(\()`, ByGroups(UsingSelf("text"), Keyword, UsingSelf("text"), Punctuation), Pop(1)}, Include("follow"), }, "for2": { {`\)`, Punctuation, nil}, {`((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+))(do(?=\^?[\t\v\f\r ,;=\xa0]|[&<>|\n\x1a]))`, ByGroups(UsingSelf("text"), Keyword), Pop(1)}, {`[\n\x1a]+`, Text, nil}, Include("follow"), }, "for/f": { {"" /* 348 byte string literal not displayed */, ByGroups(LiteralStringDouble, UsingSelf("string"), Text, Punctuation), nil}, {`"`, LiteralStringDouble, Push("#pop", "for2", "string")}, {"" /* 351 byte string literal not displayed */, ByGroups(UsingSelf("sqstring"), Text, Punctuation), nil}, {"" /* 398 byte string literal not displayed */, ByGroups(UsingSelf("bqstring"), Text, Punctuation), nil}, Include("for2"), }, "for/l": { {`-?\d+`, LiteralNumberInteger, nil}, Include("for2"), }, "if": { {`((?:cmdextversion|errorlevel)(?=\^?[\t\v\f\r ,;=\xa0]|[&<>|\n\x1a]))((?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+))(\d+)`, ByGroups(Keyword, UsingSelf("text"), LiteralNumberInteger), Pop(1)}, {"" /* 501 byte string literal not displayed */, ByGroups(Keyword, UsingSelf("text"), UsingSelf("variable")), Pop(1)}, {"" /* 497 byte string literal not displayed */, ByGroups(Keyword, UsingSelf("text")), Pop(1)}, {"" /* 259 byte string literal not displayed */, ByGroups(UsingSelf("arithmetic"), OperatorWord, UsingSelf("arithmetic")), Pop(1)}, {"" /* 408 byte string literal not displayed */, UsingSelf("text"), Push("#pop", "if2")}, }, "if2": { {"" /* 502 byte string literal not displayed */, ByGroups(UsingSelf("text"), Operator, UsingSelf("text")), Pop(1)}, {"" /* 525 byte string literal not displayed */, ByGroups(UsingSelf("text"), OperatorWord, UsingSelf("text")), Pop(1)}, }, "(?": { {`(?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)`, UsingSelf("text"), nil}, {`\(`, Punctuation, Push("#pop", "else?", "root/compound")}, Default(Pop(1)), }, "else?": { {`(?:(?:(?:\^[\n\x1a])?[\t\v\f\r ,;=\xa0])+)`, UsingSelf("text"), nil}, {`else(?=\^?[\t\v\f\r ,;=\xa0]|[&<>|\n\x1a])`, Keyword, Pop(1)}, Default(Pop(1)), }, }, ))
Batchfile lexer.
var Blitzbasic = Register(MustNewLexer( &Config{ Name: "BlitzBasic", Aliases: []string{"blitzbasic", "b3d", "bplus"}, Filenames: []string{"*.bb", "*.decls"}, MimeTypes: []string{"text/x-bb"}, CaseInsensitive: true, }, Rules{ "root": { {`[ \t]+`, Text, nil}, {`;.*?\n`, CommentSingle, nil}, {`"`, LiteralStringDouble, Push("string")}, {`[0-9]+\.[0-9]*(?!\.)`, LiteralNumberFloat, nil}, {`\.[0-9]+(?!\.)`, LiteralNumberFloat, nil}, {`[0-9]+`, LiteralNumberInteger, nil}, {`\$[0-9a-f]+`, LiteralNumberHex, nil}, {`\%[10]+`, LiteralNumberBin, nil}, {Words(`\b`, `\b`, `Shl`, `Shr`, `Sar`, `Mod`, `Or`, `And`, `Not`, `Abs`, `Sgn`, `Handle`, `Int`, `Float`, `Str`, `First`, `Last`, `Before`, `After`), Operator, nil}, {`([+\-*/~=<>^])`, Operator, nil}, {`[(),:\[\]\\]`, Punctuation, nil}, {`\.([ \t]*)([a-z]\w*)`, NameLabel, nil}, {`\b(New)\b([ \t]+)([a-z]\w*)`, ByGroups(KeywordReserved, Text, NameClass), nil}, {`\b(Gosub|Goto)\b([ \t]+)([a-z]\w*)`, ByGroups(KeywordReserved, Text, NameLabel), nil}, {`\b(Object)\b([ \t]*)([.])([ \t]*)([a-z]\w*)\b`, ByGroups(Operator, Text, Punctuation, Text, NameClass), nil}, {`\b([a-z]\w*)(?:([ \t]*)(@{1,2}|[#$%])|([ \t]*)([.])([ \t]*)(?:([a-z]\w*)))?\b([ \t]*)(\()`, ByGroups(NameFunction, Text, KeywordType, Text, Punctuation, Text, NameClass, Text, Punctuation), nil}, {`\b(Function)\b([ \t]+)([a-z]\w*)(?:([ \t]*)(@{1,2}|[#$%])|([ \t]*)([.])([ \t]*)(?:([a-z]\w*)))?`, ByGroups(KeywordReserved, Text, NameFunction, Text, KeywordType, Text, Punctuation, Text, NameClass), nil}, {`\b(Type)([ \t]+)([a-z]\w*)`, ByGroups(KeywordReserved, Text, NameClass), nil}, {`\b(Pi|True|False|Null)\b`, KeywordConstant, nil}, {`\b(Local|Global|Const|Field|Dim)\b`, KeywordDeclaration, nil}, {Words(`\b`, `\b`, `End`, `Return`, `Exit`, `Chr`, `Len`, `Asc`, `New`, `Delete`, `Insert`, `Include`, `Function`, `Type`, `If`, `Then`, `Else`, `ElseIf`, `EndIf`, `For`, `To`, `Next`, `Step`, `Each`, `While`, `Wend`, `Repeat`, `Until`, `Forever`, `Select`, `Case`, `Default`, `Goto`, `Gosub`, `Data`, `Read`, `Restore`), KeywordReserved, nil}, {`([a-z]\w*)(?:([ \t]*)(@{1,2}|[#$%])|([ \t]*)([.])([ \t]*)(?:([a-z]\w*)))?`, ByGroups(NameVariable, Text, KeywordType, Text, Punctuation, Text, NameClass), nil}, }, "string": { {`""`, LiteralStringDouble, nil}, {`"C?`, LiteralStringDouble, Pop(1)}, {`[^"]+`, LiteralStringDouble, nil}, }, }, ))
Blitzbasic lexer.
var Bnf = Register(MustNewLexer( &Config{ Name: "BNF", Aliases: []string{"bnf"}, Filenames: []string{"*.bnf"}, MimeTypes: []string{"text/x-bnf"}, }, Rules{ "root": { {`(<)([ -;=?-~]+)(>)`, ByGroups(Punctuation, NameClass, Punctuation), nil}, {`::=`, Operator, nil}, {`[^<>:]+`, Text, nil}, {`.`, Text, nil}, }, }, ))
Bnf lexer.
var Brainfuck = Register(MustNewLexer( &Config{ Name: "Brainfuck", Aliases: []string{"brainfuck", "bf"}, Filenames: []string{"*.bf", "*.b"}, MimeTypes: []string{"application/x-brainfuck"}, }, Rules{ "common": { {`[.,]+`, NameTag, nil}, {`[+-]+`, NameBuiltin, nil}, {`[<>]+`, NameVariable, nil}, {`[^.,+\-<>\[\]]+`, Comment, nil}, }, "root": { {`\[`, Keyword, Push("loop")}, {`\]`, Error, nil}, Include("common"), }, "loop": { {`\[`, Keyword, Push()}, {`\]`, Keyword, Pop(1)}, Include("common"), }, }, ))
Brainfuck lexer.
var C = Register(MustNewLexer( &Config{ Name: "C", Aliases: []string{"c"}, Filenames: []string{"*.c", "*.h", "*.idc"}, MimeTypes: []string{"text/x-chdr", "text/x-csrc"}, }, Rules{ "whitespace": { {`^#if\s+0`, CommentPreproc, Push("if0")}, {`^#`, CommentPreproc, Push("macro")}, {`^(\s*(?:/[*].*?[*]/\s*)?)(#if\s+0)`, ByGroups(UsingSelf("root"), CommentPreproc), Push("if0")}, {`^(\s*(?:/[*].*?[*]/\s*)?)(#)`, ByGroups(UsingSelf("root"), CommentPreproc), Push("macro")}, {`\n`, Text, nil}, {`\s+`, Text, nil}, {`\\\n`, Text, nil}, {`//(\n|[\w\W]*?[^\\]\n)`, CommentSingle, nil}, {`/(\\\n)?[*][\w\W]*?[*](\\\n)?/`, CommentMultiline, nil}, {`/(\\\n)?[*][\w\W]*`, CommentMultiline, nil}, }, "statements": { {`(L?)(")`, ByGroups(LiteralStringAffix, LiteralString), Push("string")}, {`(L?)(')(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])(')`, ByGroups(LiteralStringAffix, LiteralStringChar, LiteralStringChar, LiteralStringChar), nil}, {`(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*`, LiteralNumberFloat, nil}, {`(\d+\.\d*|\.\d+|\d+[fF])[fF]?`, LiteralNumberFloat, nil}, {`0x[0-9a-fA-F]+[LlUu]*`, LiteralNumberHex, nil}, {`0[0-7]+[LlUu]*`, LiteralNumberOct, nil}, {`\d+[LlUu]*`, LiteralNumberInteger, nil}, {`\*/`, Error, nil}, {`[~!%^&*+=|?:<>/-]`, Operator, nil}, {`[()\[\],.]`, Punctuation, nil}, {Words(``, `\b`, `asm`, `auto`, `break`, `case`, `const`, `continue`, `default`, `do`, `else`, `enum`, `extern`, `for`, `goto`, `if`, `register`, `restricted`, `return`, `sizeof`, `static`, `struct`, `switch`, `typedef`, `union`, `volatile`, `while`), Keyword, nil}, {`(bool|int|long|float|short|double|char|unsigned|signed|void)\b`, KeywordType, nil}, {Words(``, `\b`, `inline`, `_inline`, `__inline`, `naked`, `restrict`, `thread`, `typename`), KeywordReserved, nil}, {`(__m(128i|128d|128|64))\b`, KeywordReserved, nil}, {Words(`__`, `\b`, `asm`, `int8`, `based`, `except`, `int16`, `stdcall`, `cdecl`, `fastcall`, `int32`, `declspec`, `finally`, `int64`, `try`, `leave`, `wchar_t`, `w64`, `unaligned`, `raise`, `noop`, `identifier`, `forceinline`, `assume`), KeywordReserved, nil}, {`(true|false|NULL)\b`, NameBuiltin, nil}, {`([a-zA-Z_]\w*)(\s*)(:)(?!:)`, ByGroups(NameLabel, Text, Punctuation), nil}, {`[a-zA-Z_]\w*`, Name, nil}, }, "root": { Include("whitespace"), {`((?:[\w*\s])+?(?:\s|[*]))([a-zA-Z_]\w*)(\s*\([^;]*?\))([^;{]*)(\{)`, ByGroups(UsingSelf("root"), NameFunction, UsingSelf("root"), UsingSelf("root"), Punctuation), Push("function")}, {`((?:[\w*\s])+?(?:\s|[*]))([a-zA-Z_]\w*)(\s*\([^;]*?\))([^;]*)(;)`, ByGroups(UsingSelf("root"), NameFunction, UsingSelf("root"), UsingSelf("root"), Punctuation), nil}, Default(Push("statement")), }, "statement": { Include("whitespace"), Include("statements"), {`[{}]`, Punctuation, nil}, {`;`, Punctuation, Pop(1)}, }, "function": { Include("whitespace"), Include("statements"), {`;`, Punctuation, nil}, {`\{`, Punctuation, Push()}, {`\}`, Punctuation, Pop(1)}, }, "string": { {`"`, LiteralString, Pop(1)}, {`\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|[0-7]{1,3})`, LiteralStringEscape, nil}, {`[^\\"\n]+`, LiteralString, nil}, {`\\\n`, LiteralString, nil}, {`\\`, LiteralString, nil}, }, "macro": { {`(include)(\s*(?:/[*].*?[*]/\s*)?)([^\n]+)`, ByGroups(CommentPreproc, Text, CommentPreprocFile), nil}, {`[^/\n]+`, CommentPreproc, nil}, {`/[*](.|\n)*?[*]/`, CommentMultiline, nil}, {`//.*?\n`, CommentSingle, Pop(1)}, {`/`, CommentPreproc, nil}, {`(?<=\\)\n`, CommentPreproc, nil}, {`\n`, CommentPreproc, Pop(1)}, }, "if0": { {`^\s*#if.*?(?<!\\)\n`, CommentPreproc, Push()}, {`^\s*#el(?:se|if).*\n`, CommentPreproc, Pop(1)}, {`^\s*#endif.*?(?<!\\)\n`, CommentPreproc, Pop(1)}, {`.*?\n`, Comment, nil}, }, }, ))
C lexer.
var CPP = Register(MustNewLexer( &Config{ Name: "C++", Aliases: []string{"cpp", "c++"}, Filenames: []string{"*.cpp", "*.hpp", "*.c++", "*.h++", "*.cc", "*.hh", "*.cxx", "*.hxx", "*.C", "*.H", "*.cp", "*.CPP"}, MimeTypes: []string{"text/x-c++hdr", "text/x-c++src"}, }, 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}, {`(class)(\s+)`, ByGroups(Keyword, Text), Push("classname")}, {`(R)(")([^\\()\s]{,16})(\()((?:.|\n)*?)(\)\3)(")`, ByGroups(LiteralStringAffix, LiteralString, LiteralStringDelimiter, LiteralStringDelimiter, LiteralString, LiteralStringDelimiter, LiteralString), nil}, {`(u8|u|U)(")`, ByGroups(LiteralStringAffix, LiteralString), Push("string")}, {`(L?)(")`, ByGroups(LiteralStringAffix, LiteralString), Push("string")}, {`(L?)(')(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])(')`, ByGroups(LiteralStringAffix, LiteralStringChar, LiteralStringChar, LiteralStringChar), nil}, {`(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*`, LiteralNumberFloat, nil}, {`(\d+\.\d*|\.\d+|\d+[fF])[fF]?`, LiteralNumberFloat, nil}, {`0x[0-9a-fA-F]+[LlUu]*`, LiteralNumberHex, nil}, {`0[0-7]+[LlUu]*`, LiteralNumberOct, nil}, {`\d+[LlUu]*`, LiteralNumberInteger, nil}, {`\*/`, Error, nil}, {`[~!%^&*+=|?:<>/-]`, Operator, nil}, {`[()\[\],.]`, Punctuation, nil}, {Words(``, `\b`, `asm`, `auto`, `break`, `case`, `const`, `continue`, `default`, `do`, `else`, `enum`, `extern`, `for`, `goto`, `if`, `register`, `restricted`, `return`, `sizeof`, `static`, `struct`, `switch`, `typedef`, `union`, `volatile`, `while`), Keyword, nil}, {`(bool|int|long|float|short|double|char|unsigned|signed|void)\b`, KeywordType, nil}, {Words(``, `\b`, `inline`, `_inline`, `__inline`, `naked`, `restrict`, `thread`, `typename`), KeywordReserved, nil}, {`(__m(128i|128d|128|64))\b`, KeywordReserved, nil}, {Words(`__`, `\b`, `asm`, `int8`, `based`, `except`, `int16`, `stdcall`, `cdecl`, `fastcall`, `int32`, `declspec`, `finally`, `int64`, `try`, `leave`, `wchar_t`, `w64`, `unaligned`, `raise`, `noop`, `identifier`, `forceinline`, `assume`), KeywordReserved, nil}, {`(true|false|NULL)\b`, NameBuiltin, nil}, {`([a-zA-Z_]\w*)(\s*)(:)(?!:)`, ByGroups(NameLabel, Text, Punctuation), nil}, {`[a-zA-Z_]\w*`, Name, nil}, }, "root": { Include("whitespace"), {`((?:[\w*\s])+?(?:\s|[*]))([a-zA-Z_]\w*)(\s*\([^;]*?\))([^;{]*)(\{)`, ByGroups(UsingSelf("root"), NameFunction, UsingSelf("root"), UsingSelf("root"), Punctuation), Push("function")}, {`((?:[\w*\s])+?(?:\s|[*]))([a-zA-Z_]\w*)(\s*\([^;]*?\))([^;]*)(;)`, ByGroups(UsingSelf("root"), NameFunction, UsingSelf("root"), UsingSelf("root"), Punctuation), nil}, Default(Push("statement")), {Words(`__`, `\b`, `virtual_inheritance`, `uuidof`, `super`, `single_inheritance`, `multiple_inheritance`, `interface`, `event`), KeywordReserved, nil}, {`__(offload|blockingoffload|outer)\b`, KeywordPseudo, nil}, }, "classname": { {`[a-zA-Z_]\w*`, NameClass, Pop(1)}, {`\s*(?=>)`, Text, Pop(1)}, }, "whitespace": { {`^#if\s+0`, CommentPreproc, Push("if0")}, {`^#`, CommentPreproc, Push("macro")}, {`^(\s*(?:/[*].*?[*]/\s*)?)(#if\s+0)`, ByGroups(UsingSelf("root"), CommentPreproc), Push("if0")}, {`^(\s*(?:/[*].*?[*]/\s*)?)(#)`, ByGroups(UsingSelf("root"), CommentPreproc), Push("macro")}, {`\n`, Text, nil}, {`\s+`, Text, nil}, {`\\\n`, Text, nil}, {`//(\n|[\w\W]*?[^\\]\n)`, CommentSingle, nil}, {`/(\\\n)?[*][\w\W]*?[*](\\\n)?/`, CommentMultiline, nil}, {`/(\\\n)?[*][\w\W]*`, CommentMultiline, nil}, }, "statement": { Include("whitespace"), Include("statements"), {`[{}]`, Punctuation, nil}, {`;`, Punctuation, Pop(1)}, }, "function": { Include("whitespace"), Include("statements"), {`;`, Punctuation, nil}, {`\{`, Punctuation, Push()}, {`\}`, Punctuation, Pop(1)}, }, "string": { {`"`, LiteralString, Pop(1)}, {`\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|[0-7]{1,3})`, LiteralStringEscape, nil}, {`[^\\"\n]+`, LiteralString, nil}, {`\\\n`, LiteralString, nil}, {`\\`, LiteralString, nil}, }, "macro": { {`(include)(\s*(?:/[*].*?[*]/\s*)?)([^\n]+)`, ByGroups(CommentPreproc, Text, CommentPreprocFile), nil}, {`[^/\n]+`, CommentPreproc, nil}, {`/[*](.|\n)*?[*]/`, CommentMultiline, nil}, {`//.*?\n`, CommentSingle, Pop(1)}, {`/`, CommentPreproc, nil}, {`(?<=\\)\n`, CommentPreproc, nil}, {`\n`, CommentPreproc, Pop(1)}, }, "if0": { {`^\s*#if.*?(?<!\\)\n`, CommentPreproc, Push()}, {`^\s*#el(?:se|if).*\n`, CommentPreproc, Pop(1)}, {`^\s*#endif.*?(?<!\\)\n`, CommentPreproc, Pop(1)}, {`.*?\n`, Comment, nil}, }, }, ))
CPP lexer.
var CSS = Register(MustNewLexer( &Config{ Name: "CSS", Aliases: []string{"css"}, Filenames: []string{"*.css"}, MimeTypes: []string{"text/css"}, }, Rules{ "root": { Include("basics"), }, "basics": { {`\s+`, Text, nil}, {`/\*(?:.|\n)*?\*/`, Comment, nil}, {`\{`, Punctuation, Push("content")}, {`(\:{1,2})([\w-]+)`, ByGroups(Punctuation, NameDecorator), nil}, {`(\.)([\w-]+)`, ByGroups(Punctuation, NameClass), nil}, {`(\#)([\w-]+)`, ByGroups(Punctuation, NameNamespace), nil}, {`(@)([\w-]+)`, ByGroups(Punctuation, Keyword), Push("atrule")}, {`[\w-]+`, NameTag, nil}, {`[~^*!%&$\[\]()<>|+=@:;,./?-]`, Operator, nil}, {`"(\\\\|\\"|[^"])*"`, LiteralStringDouble, nil}, {`'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil}, }, "atrule": { {`\{`, Punctuation, Push("atcontent")}, {`;`, Punctuation, Pop(1)}, Include("basics"), }, "atcontent": { Include("basics"), {`\}`, Punctuation, Pop(2)}, }, "content": { {`\s+`, Text, nil}, {`\}`, Punctuation, Pop(1)}, {`;`, Punctuation, nil}, {`^@.*?$`, CommentPreproc, nil}, {Words(``, ``, `-ms-`, `mso-`, `-moz-`, `-o-`, `-xv-`, `-atsc-`, `-wap-`, `-khtml-`, `-webkit-`, `prince-`, `-ah-`, `-hp-`, `-ro-`, `-rim-`, `-tc-`), KeywordPseudo, nil}, {"" /* 5150 byte string literal not displayed */, ByGroups(Keyword, Text, Punctuation), Push("value-start")}, {`(--[a-zA-Z_][\w-]*)(\s*)(\:)`, ByGroups(NameVariable, Text, Punctuation), Push("value-start")}, {`([a-zA-Z_][\w-]*)(\s*)(\:)`, ByGroups(Name, Text, Punctuation), Push("value-start")}, {`/\*(?:.|\n)*?\*/`, Comment, nil}, }, "value-start": { {`\s+`, Text, nil}, {Words(``, ``, `-ms-`, `mso-`, `-moz-`, `-o-`, `-xv-`, `-atsc-`, `-wap-`, `-khtml-`, `-webkit-`, `prince-`, `-ah-`, `-hp-`, `-ro-`, `-rim-`, `-tc-`), NameBuiltinPseudo, nil}, Include("urls"), {"" /* 551 byte string literal not displayed */, ByGroups(NameBuiltin, Punctuation), Push("function-start")}, {`([a-zA-Z_][\w-]+)(\()`, ByGroups(NameFunction, Punctuation), Push("function-start")}, {Words(``, `\b`, `absolute`, `alias`, `all`, `all-petite-caps`, `all-scroll`, `all-small-caps`, `allow-end`, `alpha`, `alternate`, `alternate-reverse`, `always`, `armenian`, `auto`, `avoid`, `avoid-column`, `avoid-page`, `backwards`, `balance`, `baseline`, `below`, `blink`, `block`, `bold`, `bolder`, `border-box`, `both`, `bottom`, `box-decoration`, `break-word`, `capitalize`, `cell`, `center`, `circle`, `clip`, `clone`, `close-quote`, `col-resize`, `collapse`, `color`, `color-burn`, `color-dodge`, `column`, `column-reverse`, `compact`, `condensed`, `contain`, `container`, `content-box`, `context-menu`, `copy`, `cover`, `crisp-edges`, `crosshair`, `currentColor`, `cursive`, `darken`, `dashed`, `decimal`, `decimal-leading-zero`, `default`, `descendants`, `difference`, `digits`, `disc`, `distribute`, `dot`, `dotted`, `double`, `double-circle`, `e-resize`, `each-line`, `ease`, `ease-in`, `ease-in-out`, `ease-out`, `edges`, `ellipsis`, `end`, `ew-resize`, `exclusion`, `expanded`, `extra-condensed`, `extra-expanded`, `fantasy`, `fill`, `fill-box`, `filled`, `first`, `fixed`, `flat`, `flex`, `flex-end`, `flex-start`, `flip`, `force-end`, `forwards`, `from-image`, `full-width`, `geometricPrecision`, `georgian`, `groove`, `hanging`, `hard-light`, `help`, `hidden`, `hide`, `horizontal`, `hue`, `icon`, `infinite`, `inherit`, `initial`, `ink`, `inline`, `inline-block`, `inline-flex`, `inline-table`, `inset`, `inside`, `inter-word`, `invert`, `isolate`, `italic`, `justify`, `large`, `larger`, `last`, `left`, `lighten`, `lighter`, `line-through`, `linear`, `list-item`, `local`, `loose`, `lower-alpha`, `lower-greek`, `lower-latin`, `lower-roman`, `lowercase`, `ltr`, `luminance`, `luminosity`, `mandatory`, `manipulation`, `manual`, `margin-box`, `match-parent`, `medium`, `mixed`, `monospace`, `move`, `multiply`, `n-resize`, `ne-resize`, `nesw-resize`, `no-close-quote`, `no-drop`, `no-open-quote`, `no-repeat`, `none`, `normal`, `not-allowed`, `nowrap`, `ns-resize`, `nw-resize`, `nwse-resize`, `objects`, `oblique`, `off`, `on`, `open`, `open-quote`, `optimizeLegibility`, `optimizeSpeed`, `outset`, `outside`, `over`, `overlay`, `overline`, `padding-box`, `page`, `pan-down`, `pan-left`, `pan-right`, `pan-up`, `pan-x`, `pan-y`, `paused`, `petite-caps`, `pixelated`, `pointer`, `preserve-3d`, `progress`, `proximity`, `relative`, `repeat`, `repeat no-repeat`, `repeat-x`, `repeat-y`, `reverse`, `ridge`, `right`, `round`, `row`, `row-resize`, `row-reverse`, `rtl`, `ruby`, `ruby-base`, `ruby-base-container`, `ruby-text`, `ruby-text-container`, `run-in`, `running`, `s-resize`, `sans-serif`, `saturation`, `scale-down`, `screen`, `scroll`, `se-resize`, `semi-condensed`, `semi-expanded`, `separate`, `serif`, `sesame`, `show`, `sideways`, `sideways-left`, `sideways-right`, `slice`, `small`, `small-caps`, `smaller`, `smooth`, `snap`, `soft-light`, `solid`, `space`, `space-around`, `space-between`, `spaces`, `square`, `start`, `static`, `step-end`, `step-start`, `sticky`, `stretch`, `strict`, `stroke-box`, `style`, `sw-resize`, `table`, `table-caption`, `table-cell`, `table-column`, `table-column-group`, `table-footer-group`, `table-header-group`, `table-row`, `table-row-group`, `text`, `thick`, `thin`, `titling-caps`, `to`, `top`, `triangle`, `ultra-condensed`, `ultra-expanded`, `under`, `underline`, `unicase`, `unset`, `upper-alpha`, `upper-latin`, `upper-roman`, `uppercase`, `upright`, `use-glyph-orientation`, `vertical`, `vertical-text`, `view-box`, `visible`, `w-resize`, `wait`, `wavy`, `weight`, `weight style`, `wrap`, `wrap-reverse`, `x-large`, `x-small`, `xx-large`, `xx-small`, `zoom-in`, `zoom-out`), KeywordConstant, nil}, {Words(``, `\b`, `above`, `aural`, `behind`, `bidi-override`, `center-left`, `center-right`, `cjk-ideographic`, `continuous`, `crop`, `cross`, `embed`, `far-left`, `far-right`, `fast`, `faster`, `hebrew`, `high`, `higher`, `hiragana`, `hiragana-iroha`, `katakana`, `katakana-iroha`, `landscape`, `left-side`, `leftwards`, `level`, `loud`, `low`, `lower`, `message-box`, `middle`, `mix`, `narrower`, `once`, `portrait`, `right-side`, `rightwards`, `silent`, `slow`, `slower`, `small-caption`, `soft`, `spell-out`, `status-bar`, `super`, `text-bottom`, `text-top`, `wider`, `x-fast`, `x-high`, `x-loud`, `x-low`, `x-soft`, `yes`, `pre`, `pre-wrap`, `pre-line`), KeywordConstant, nil}, {Words(``, `\b`, `aliceblue`, `antiquewhite`, `aqua`, `aquamarine`, `azure`, `beige`, `bisque`, `black`, `blanchedalmond`, `blue`, `blueviolet`, `brown`, `burlywood`, `cadetblue`, `chartreuse`, `chocolate`, `coral`, `cornflowerblue`, `cornsilk`, `crimson`, `cyan`, `darkblue`, `darkcyan`, `darkgoldenrod`, `darkgray`, `darkgreen`, `darkgrey`, `darkkhaki`, `darkmagenta`, `darkolivegreen`, `darkorange`, `darkorchid`, `darkred`, `darksalmon`, `darkseagreen`, `darkslateblue`, `darkslategray`, `darkslategrey`, `darkturquoise`, `darkviolet`, `deeppink`, `deepskyblue`, `dimgray`, `dimgrey`, `dodgerblue`, `firebrick`, `floralwhite`, `forestgreen`, `fuchsia`, `gainsboro`, `ghostwhite`, `gold`, `goldenrod`, `gray`, `green`, `greenyellow`, `grey`, `honeydew`, `hotpink`, `indianred`, `indigo`, `ivory`, `khaki`, `lavender`, `lavenderblush`, `lawngreen`, `lemonchiffon`, `lightblue`, `lightcoral`, `lightcyan`, `lightgoldenrodyellow`, `lightgray`, `lightgreen`, `lightgrey`, `lightpink`, `lightsalmon`, `lightseagreen`, `lightskyblue`, `lightslategray`, `lightslategrey`, `lightsteelblue`, `lightyellow`, `lime`, `limegreen`, `linen`, `magenta`, `maroon`, `mediumaquamarine`, `mediumblue`, `mediumorchid`, `mediumpurple`, `mediumseagreen`, `mediumslateblue`, `mediumspringgreen`, `mediumturquoise`, `mediumvioletred`, `midnightblue`, `mintcream`, `mistyrose`, `moccasin`, `navajowhite`, `navy`, `oldlace`, `olive`, `olivedrab`, `orange`, `orangered`, `orchid`, `palegoldenrod`, `palegreen`, `paleturquoise`, `palevioletred`, `papayawhip`, `peachpuff`, `peru`, `pink`, `plum`, `powderblue`, `purple`, `rebeccapurple`, `red`, `rosybrown`, `royalblue`, `saddlebrown`, `salmon`, `sandybrown`, `seagreen`, `seashell`, `sienna`, `silver`, `skyblue`, `slateblue`, `slategray`, `slategrey`, `snow`, `springgreen`, `steelblue`, `tan`, `teal`, `thistle`, `tomato`, `turquoise`, `violet`, `wheat`, `white`, `whitesmoke`, `yellow`, `yellowgreen`, `transparent`), KeywordConstant, nil}, {Words(``, `\b`, `align-content`, `align-items`, `align-self`, `alignment-baseline`, `all`, `animation`, `animation-delay`, `animation-direction`, `animation-duration`, `animation-fill-mode`, `animation-iteration-count`, `animation-name`, `animation-play-state`, `animation-timing-function`, `appearance`, `azimuth`, `backface-visibility`, `background`, `background-attachment`, `background-blend-mode`, `background-clip`, `background-color`, `background-image`, `background-origin`, `background-position`, `background-repeat`, `background-size`, `baseline-shift`, `bookmark-label`, `bookmark-level`, `bookmark-state`, `border`, `border-bottom`, `border-bottom-color`, `border-bottom-left-radius`, `border-bottom-right-radius`, `border-bottom-style`, `border-bottom-width`, `border-boundary`, `border-collapse`, `border-color`, `border-image`, `border-image-outset`, `border-image-repeat`, `border-image-slice`, `border-image-source`, `border-image-width`, `border-left`, `border-left-color`, `border-left-style`, `border-left-width`, `border-radius`, `border-right`, `border-right-color`, `border-right-style`, `border-right-width`, `border-spacing`, `border-style`, `border-top`, `border-top-color`, `border-top-left-radius`, `border-top-right-radius`, `border-top-style`, `border-top-width`, `border-width`, `bottom`, `box-decoration-break`, `box-shadow`, `box-sizing`, `box-snap`, `box-suppress`, `break-after`, `break-before`, `break-inside`, `caption-side`, `caret`, `caret-animation`, `caret-color`, `caret-shape`, `chains`, `clear`, `clip`, `clip-path`, `clip-rule`, `color`, `color-interpolation-filters`, `column-count`, `column-fill`, `column-gap`, `column-rule`, `column-rule-color`, `column-rule-style`, `column-rule-width`, `column-span`, `column-width`, `columns`, `content`, `counter-increment`, `counter-reset`, `counter-set`, `crop`, `cue`, `cue-after`, `cue-before`, `cursor`, `direction`, `display`, `dominant-baseline`, `elevation`, `empty-cells`, `filter`, `flex`, `flex-basis`, `flex-direction`, `flex-flow`, `flex-grow`, `flex-shrink`, `flex-wrap`, `float`, `float-defer`, `float-offset`, `float-reference`, `flood-color`, `flood-opacity`, `flow`, `flow-from`, `flow-into`, `font`, `font-family`, `font-feature-settings`, `font-kerning`, `font-language-override`, `font-size`, `font-size-adjust`, `font-stretch`, `font-style`, `font-synthesis`, `font-variant`, `font-variant-alternates`, `font-variant-caps`, `font-variant-east-asian`, `font-variant-ligatures`, `font-variant-numeric`, `font-variant-position`, `font-weight`, `footnote-display`, `footnote-policy`, `glyph-orientation-vertical`, `grid`, `grid-area`, `grid-auto-columns`, `grid-auto-flow`, `grid-auto-rows`, `grid-column`, `grid-column-end`, `grid-column-gap`, `grid-column-start`, `grid-gap`, `grid-row`, `grid-row-end`, `grid-row-gap`, `grid-row-start`, `grid-template`, `grid-template-areas`, `grid-template-columns`, `grid-template-rows`, `hanging-punctuation`, `height`, `hyphenate-character`, `hyphenate-limit-chars`, `hyphenate-limit-last`, `hyphenate-limit-lines`, `hyphenate-limit-zone`, `hyphens`, `image-orientation`, `image-resolution`, `initial-letter`, `initial-letter-align`, `initial-letter-wrap`, `isolation`, `justify-content`, `justify-items`, `justify-self`, `left`, `letter-spacing`, `lighting-color`, `line-break`, `line-grid`, `line-height`, `line-snap`, `list-style`, `list-style-image`, `list-style-position`, `list-style-type`, `margin`, `margin-bottom`, `margin-left`, `margin-right`, `margin-top`, `marker-side`, `marquee-direction`, `marquee-loop`, `marquee-speed`, `marquee-style`, `mask`, `mask-border`, `mask-border-mode`, `mask-border-outset`, `mask-border-repeat`, `mask-border-slice`, `mask-border-source`, `mask-border-width`, `mask-clip`, `mask-composite`, `mask-image`, `mask-mode`, `mask-origin`, `mask-position`, `mask-repeat`, `mask-size`, `mask-type`, `max-height`, `max-lines`, `max-width`, `min-height`, `min-width`, `mix-blend-mode`, `motion`, `motion-offset`, `motion-path`, `motion-rotation`, `move-to`, `nav-down`, `nav-left`, `nav-right`, `nav-up`, `object-fit`, `object-position`, `offset-after`, `offset-before`, `offset-end`, `offset-start`, `opacity`, `order`, `orphans`, `outline`, `outline-color`, `outline-offset`, `outline-style`, `outline-width`, `overflow`, `overflow-style`, `overflow-wrap`, `overflow-x`, `overflow-y`, `padding`, `padding-bottom`, `padding-left`, `padding-right`, `padding-top`, `page`, `page-break-after`, `page-break-before`, `page-break-inside`, `page-policy`, `pause`, `pause-after`, `pause-before`, `perspective`, `perspective-origin`, `pitch`, `pitch-range`, `play-during`, `polar-angle`, `polar-distance`, `position`, `presentation-level`, `quotes`, `region-fragment`, `resize`, `rest`, `rest-after`, `rest-before`, `richness`, `right`, `rotation`, `rotation-point`, `ruby-align`, `ruby-merge`, `ruby-position`, `running`, `scroll-snap-coordinate`, `scroll-snap-destination`, `scroll-snap-points-x`, `scroll-snap-points-y`, `scroll-snap-type`, `shape-image-threshold`, `shape-inside`, `shape-margin`, `shape-outside`, `size`, `speak`, `speak-as`, `speak-header`, `speak-numeral`, `speak-punctuation`, `speech-rate`, `stress`, `string-set`, `tab-size`, `table-layout`, `text-align`, `text-align-last`, `text-combine-upright`, `text-decoration`, `text-decoration-color`, `text-decoration-line`, `text-decoration-skip`, `text-decoration-style`, `text-emphasis`, `text-emphasis-color`, `text-emphasis-position`, `text-emphasis-style`, `text-indent`, `text-justify`, `text-orientation`, `text-overflow`, `text-shadow`, `text-space-collapse`, `text-space-trim`, `text-spacing`, `text-transform`, `text-underline-position`, `text-wrap`, `top`, `transform`, `transform-origin`, `transform-style`, `transition`, `transition-delay`, `transition-duration`, `transition-property`, `transition-timing-function`, `unicode-bidi`, `user-select`, `vertical-align`, `visibility`, `voice-balance`, `voice-duration`, `voice-family`, `voice-pitch`, `voice-range`, `voice-rate`, `voice-stress`, `voice-volume`, `volume`, `white-space`, `widows`, `width`, `will-change`, `word-break`, `word-spacing`, `word-wrap`, `wrap-after`, `wrap-before`, `wrap-flow`, `wrap-inside`, `wrap-through`, `writing-mode`, `z-index`), Keyword, nil}, {`\!important`, CommentPreproc, nil}, {`/\*(?:.|\n)*?\*/`, Comment, nil}, Include("numeric-values"), {`[~^*!%&<>|+=@:./?-]+`, Operator, nil}, {`[\[\](),]+`, Punctuation, nil}, {`"(\\\\|\\"|[^"])*"`, LiteralStringDouble, nil}, {`'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil}, {`[a-zA-Z_][\w-]*`, Name, nil}, {`;`, Punctuation, Pop(1)}, {`\}`, Punctuation, Pop(2)}, }, "function-start": { {`\s+`, Text, nil}, Include("urls"), {Words(``, ``, `-ms-`, `mso-`, `-moz-`, `-o-`, `-xv-`, `-atsc-`, `-wap-`, `-khtml-`, `-webkit-`, `prince-`, `-ah-`, `-hp-`, `-ro-`, `-rim-`, `-tc-`), KeywordPseudo, nil}, {Words(``, `\b`, `absolute`, `alias`, `all`, `all-petite-caps`, `all-scroll`, `all-small-caps`, `allow-end`, `alpha`, `alternate`, `alternate-reverse`, `always`, `armenian`, `auto`, `avoid`, `avoid-column`, `avoid-page`, `backwards`, `balance`, `baseline`, `below`, `blink`, `block`, `bold`, `bolder`, `border-box`, `both`, `bottom`, `box-decoration`, `break-word`, `capitalize`, `cell`, `center`, `circle`, `clip`, `clone`, `close-quote`, `col-resize`, `collapse`, `color`, `color-burn`, `color-dodge`, `column`, `column-reverse`, `compact`, `condensed`, `contain`, `container`, `content-box`, `context-menu`, `copy`, `cover`, `crisp-edges`, `crosshair`, `currentColor`, `cursive`, `darken`, `dashed`, `decimal`, `decimal-leading-zero`, `default`, `descendants`, `difference`, `digits`, `disc`, `distribute`, `dot`, `dotted`, `double`, `double-circle`, `e-resize`, `each-line`, `ease`, `ease-in`, `ease-in-out`, `ease-out`, `edges`, `ellipsis`, `end`, `ew-resize`, `exclusion`, `expanded`, `extra-condensed`, `extra-expanded`, `fantasy`, `fill`, `fill-box`, `filled`, `first`, `fixed`, `flat`, `flex`, `flex-end`, `flex-start`, `flip`, `force-end`, `forwards`, `from-image`, `full-width`, `geometricPrecision`, `georgian`, `groove`, `hanging`, `hard-light`, `help`, `hidden`, `hide`, `horizontal`, `hue`, `icon`, `infinite`, `inherit`, `initial`, `ink`, `inline`, `inline-block`, `inline-flex`, `inline-table`, `inset`, `inside`, `inter-word`, `invert`, `isolate`, `italic`, `justify`, `large`, `larger`, `last`, `left`, `lighten`, `lighter`, `line-through`, `linear`, `list-item`, `local`, `loose`, `lower-alpha`, `lower-greek`, `lower-latin`, `lower-roman`, `lowercase`, `ltr`, `luminance`, `luminosity`, `mandatory`, `manipulation`, `manual`, `margin-box`, `match-parent`, `medium`, `mixed`, `monospace`, `move`, `multiply`, `n-resize`, `ne-resize`, `nesw-resize`, `no-close-quote`, `no-drop`, `no-open-quote`, `no-repeat`, `none`, `normal`, `not-allowed`, `nowrap`, `ns-resize`, `nw-resize`, `nwse-resize`, `objects`, `oblique`, `off`, `on`, `open`, `open-quote`, `optimizeLegibility`, `optimizeSpeed`, `outset`, `outside`, `over`, `overlay`, `overline`, `padding-box`, `page`, `pan-down`, `pan-left`, `pan-right`, `pan-up`, `pan-x`, `pan-y`, `paused`, `petite-caps`, `pixelated`, `pointer`, `preserve-3d`, `progress`, `proximity`, `relative`, `repeat`, `repeat no-repeat`, `repeat-x`, `repeat-y`, `reverse`, `ridge`, `right`, `round`, `row`, `row-resize`, `row-reverse`, `rtl`, `ruby`, `ruby-base`, `ruby-base-container`, `ruby-text`, `ruby-text-container`, `run-in`, `running`, `s-resize`, `sans-serif`, `saturation`, `scale-down`, `screen`, `scroll`, `se-resize`, `semi-condensed`, `semi-expanded`, `separate`, `serif`, `sesame`, `show`, `sideways`, `sideways-left`, `sideways-right`, `slice`, `small`, `small-caps`, `smaller`, `smooth`, `snap`, `soft-light`, `solid`, `space`, `space-around`, `space-between`, `spaces`, `square`, `start`, `static`, `step-end`, `step-start`, `sticky`, `stretch`, `strict`, `stroke-box`, `style`, `sw-resize`, `table`, `table-caption`, `table-cell`, `table-column`, `table-column-group`, `table-footer-group`, `table-header-group`, `table-row`, `table-row-group`, `text`, `thick`, `thin`, `titling-caps`, `to`, `top`, `triangle`, `ultra-condensed`, `ultra-expanded`, `under`, `underline`, `unicase`, `unset`, `upper-alpha`, `upper-latin`, `upper-roman`, `uppercase`, `upright`, `use-glyph-orientation`, `vertical`, `vertical-text`, `view-box`, `visible`, `w-resize`, `wait`, `wavy`, `weight`, `weight style`, `wrap`, `wrap-reverse`, `x-large`, `x-small`, `xx-large`, `xx-small`, `zoom-in`, `zoom-out`), KeywordConstant, nil}, {Words(``, `\b`, `above`, `aural`, `behind`, `bidi-override`, `center-left`, `center-right`, `cjk-ideographic`, `continuous`, `crop`, `cross`, `embed`, `far-left`, `far-right`, `fast`, `faster`, `hebrew`, `high`, `higher`, `hiragana`, `hiragana-iroha`, `katakana`, `katakana-iroha`, `landscape`, `left-side`, `leftwards`, `level`, `loud`, `low`, `lower`, `message-box`, `middle`, `mix`, `narrower`, `once`, `portrait`, `right-side`, `rightwards`, `silent`, `slow`, `slower`, `small-caption`, `soft`, `spell-out`, `status-bar`, `super`, `text-bottom`, `text-top`, `wider`, `x-fast`, `x-high`, `x-loud`, `x-low`, `x-soft`, `yes`, `pre`, `pre-wrap`, `pre-line`), KeywordConstant, nil}, {Words(``, `\b`, `aliceblue`, `antiquewhite`, `aqua`, `aquamarine`, `azure`, `beige`, `bisque`, `black`, `blanchedalmond`, `blue`, `blueviolet`, `brown`, `burlywood`, `cadetblue`, `chartreuse`, `chocolate`, `coral`, `cornflowerblue`, `cornsilk`, `crimson`, `cyan`, `darkblue`, `darkcyan`, `darkgoldenrod`, `darkgray`, `darkgreen`, `darkgrey`, `darkkhaki`, `darkmagenta`, `darkolivegreen`, `darkorange`, `darkorchid`, `darkred`, `darksalmon`, `darkseagreen`, `darkslateblue`, `darkslategray`, `darkslategrey`, `darkturquoise`, `darkviolet`, `deeppink`, `deepskyblue`, `dimgray`, `dimgrey`, `dodgerblue`, `firebrick`, `floralwhite`, `forestgreen`, `fuchsia`, `gainsboro`, `ghostwhite`, `gold`, `goldenrod`, `gray`, `green`, `greenyellow`, `grey`, `honeydew`, `hotpink`, `indianred`, `indigo`, `ivory`, `khaki`, `lavender`, `lavenderblush`, `lawngreen`, `lemonchiffon`, `lightblue`, `lightcoral`, `lightcyan`, `lightgoldenrodyellow`, `lightgray`, `lightgreen`, `lightgrey`, `lightpink`, `lightsalmon`, `lightseagreen`, `lightskyblue`, `lightslategray`, `lightslategrey`, `lightsteelblue`, `lightyellow`, `lime`, `limegreen`, `linen`, `magenta`, `maroon`, `mediumaquamarine`, `mediumblue`, `mediumorchid`, `mediumpurple`, `mediumseagreen`, `mediumslateblue`, `mediumspringgreen`, `mediumturquoise`, `mediumvioletred`, `midnightblue`, `mintcream`, `mistyrose`, `moccasin`, `navajowhite`, `navy`, `oldlace`, `olive`, `olivedrab`, `orange`, `orangered`, `orchid`, `palegoldenrod`, `palegreen`, `paleturquoise`, `palevioletred`, `papayawhip`, `peachpuff`, `peru`, `pink`, `plum`, `powderblue`, `purple`, `rebeccapurple`, `red`, `rosybrown`, `royalblue`, `saddlebrown`, `salmon`, `sandybrown`, `seagreen`, `seashell`, `sienna`, `silver`, `skyblue`, `slateblue`, `slategray`, `slategrey`, `snow`, `springgreen`, `steelblue`, `tan`, `teal`, `thistle`, `tomato`, `turquoise`, `violet`, `wheat`, `white`, `whitesmoke`, `yellow`, `yellowgreen`, `transparent`), KeywordConstant, nil}, {"" /* 551 byte string literal not displayed */, ByGroups(NameBuiltin, Punctuation), Push("function-start")}, {`([a-zA-Z_][\w-]+)(\()`, ByGroups(NameFunction, Punctuation), Push("function-start")}, {`/\*(?:.|\n)*?\*/`, Comment, nil}, Include("numeric-values"), {`[*+/-]`, Operator, nil}, {`[,]`, Punctuation, nil}, {`"(\\\\|\\"|[^"])*"`, LiteralStringDouble, nil}, {`'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil}, {`[a-zA-Z_-]\w*`, Name, nil}, {`\)`, Punctuation, Pop(1)}, }, "urls": { {`(url)(\()(".*?")(\))`, ByGroups(NameBuiltin, Punctuation, LiteralStringDouble, Punctuation), nil}, {`(url)(\()('.*?')(\))`, ByGroups(NameBuiltin, Punctuation, LiteralStringSingle, Punctuation), nil}, {`(url)(\()(.*?)(\))`, ByGroups(NameBuiltin, Punctuation, LiteralStringOther, Punctuation), nil}, }, "numeric-values": { {`\#[a-zA-Z0-9]{1,6}`, LiteralNumberHex, nil}, {`[+\-]?[0-9]*[.][0-9]+`, LiteralNumberFloat, Push("numeric-end")}, {`[+\-]?[0-9]+`, LiteralNumberInteger, Push("numeric-end")}, }, "numeric-end": { {Words(``, `\b`, `deg`, `grad`, `rad`, `turn`, `Hz`, `kHz`, `em`, `ex`, `ch`, `rem`, `vh`, `vw`, `vmin`, `vmax`, `px`, `mm`, `cm`, `in`, `pt`, `pc`, `q`, `dpi`, `dpcm`, `dppx`, `s`, `ms`), KeywordType, nil}, {`%`, KeywordType, nil}, Default(Pop(1)), }, }, ))
CSS lexer.
var CSharp = Register(MustNewLexer( &Config{ Name: "C#", Aliases: []string{"csharp", "c#"}, Filenames: []string{"*.cs"}, MimeTypes: []string{"text/x-csharp"}, DotAll: true, }, Rules{ "root": { {`^\s*\[.*?\]`, NameAttribute, nil}, {`[^\S\n]+`, Text, nil}, {`\\\n`, Text, nil}, {`//.*?\n`, CommentSingle, nil}, {`/[*].*?[*]/`, CommentMultiline, nil}, {`\n`, Text, nil}, {`[~!%^&*()+=|\[\]:;,.<>/?-]`, Punctuation, nil}, {`[{}]`, Punctuation, nil}, {`@"(""|[^"])*"`, LiteralString, nil}, {`\$@?"(""|[^"])*"`, LiteralString, nil}, {`"(\\\\|\\"|[^"\n])*["\n]`, LiteralString, nil}, {`'\\.'|'[^\\]'`, LiteralStringChar, nil}, {`[0-9](\.[0-9]*)?([eE][+-][0-9]+)?[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?`, LiteralNumber, nil}, {`#[ \t]*(if|endif|else|elif|define|undef|line|error|warning|region|endregion|pragma)\b.*?\n`, CommentPreproc, nil}, {`\b(extern)(\s+)(alias)\b`, ByGroups(Keyword, Text, Keyword), nil}, {"" /* 526 byte string literal not displayed */, Keyword, nil}, {`(global)(::)`, ByGroups(Keyword, Punctuation), nil}, {`(bool|byte|char|decimal|double|dynamic|float|int|long|object|sbyte|short|string|uint|ulong|ushort|var)\b\??`, KeywordType, nil}, {`(class|struct)(\s+)`, ByGroups(Keyword, Text), Push("class")}, {`\b([_a-zA-Z]\w*)(\.)`, ByGroups(NameClass, Punctuation), nil}, {`(namespace|using)(\s+)`, ByGroups(Keyword, Text), Push("namespace")}, {`@?[_a-zA-Z]\w*`, Name, nil}, }, "class": { {`@?[_a-zA-Z]\w*`, NameClass, Pop(1)}, Default(Pop(1)), }, "namespace": { {`(?=\()`, Text, Pop(1)}, {`(@?[_a-zA-Z]\w*|\.)+`, NameNamespace, Pop(1)}, }, }, ))
CSharp lexer.
var CapNProto = Register(MustNewLexer( &Config{ Name: "Cap'n Proto", Aliases: []string{"capnp"}, Filenames: []string{"*.capnp"}, MimeTypes: []string{}, }, Rules{ "root": { {`#.*?$`, CommentSingle, nil}, {`@[0-9a-zA-Z]*`, NameDecorator, nil}, {`=`, Literal, Push("expression")}, {`:`, NameClass, Push("type")}, {`\$`, NameAttribute, Push("annotation")}, {`(struct|enum|interface|union|import|using|const|annotation|extends|in|of|on|as|with|from|fixed)\b`, Keyword, nil}, {`[\w.]+`, Name, nil}, {`[^#@=:$\w]+`, Text, nil}, }, "type": { {`[^][=;,(){}$]+`, NameClass, nil}, {`[[(]`, NameClass, Push("parentype")}, Default(Pop(1)), }, "parentype": { {`[^][;()]+`, NameClass, nil}, {`[[(]`, NameClass, Push()}, {`[])]`, NameClass, Pop(1)}, Default(Pop(1)), }, "expression": { {`[^][;,(){}$]+`, Literal, nil}, {`[[(]`, Literal, Push("parenexp")}, Default(Pop(1)), }, "parenexp": { {`[^][;()]+`, Literal, nil}, {`[[(]`, Literal, Push()}, {`[])]`, Literal, Pop(1)}, Default(Pop(1)), }, "annotation": { {`[^][;,(){}=:]+`, NameAttribute, nil}, {`[[(]`, NameAttribute, Push("annexp")}, Default(Pop(1)), }, "annexp": { {`[^][;()]+`, NameAttribute, nil}, {`[[(]`, NameAttribute, Push()}, {`[])]`, NameAttribute, Pop(1)}, Default(Pop(1)), }, }, ))
Cap'N'Proto Proto lexer.
var Ceylon = Register(MustNewLexer( &Config{ Name: "Ceylon", Aliases: []string{"ceylon"}, Filenames: []string{"*.ceylon"}, MimeTypes: []string{"text/x-ceylon"}, DotAll: true, }, Rules{ "root": { {`^(\s*(?:[a-zA-Z_][\w.\[\]]*\s+)+?)([a-zA-Z_]\w*)(\s*)(\()`, ByGroups(UsingSelf("root"), NameFunction, Text, Operator), nil}, {`[^\S\n]+`, Text, nil}, {`//.*?\n`, CommentSingle, nil}, {`/\*`, CommentMultiline, Push("comment")}, {"" /* 155 byte string literal not displayed */, NameDecorator, nil}, {"" /* 138 byte string literal not displayed */, Keyword, nil}, {`(abstracts|extends|satisfies|super|given|of|out|assign)\b`, KeywordDeclaration, nil}, {`(function|value|void|new)\b`, KeywordType, nil}, {`(assembly|module|package)(\s+)`, ByGroups(KeywordNamespace, Text), nil}, {`(true|false|null)\b`, KeywordConstant, nil}, {`(class|interface|object|alias)(\s+)`, ByGroups(KeywordDeclaration, Text), Push("class")}, {`(import)(\s+)`, ByGroups(KeywordNamespace, Text), Push("import")}, {`"(\\\\|\\"|[^"])*"`, LiteralString, nil}, {`'\\.'|'[^\\]'|'\\\{#[0-9a-fA-F]{4}\}'`, LiteralStringChar, nil}, {"\".*``.*``.*\"", LiteralStringInterpol, nil}, {`(\.)([a-z_]\w*)`, ByGroups(Operator, NameAttribute), nil}, {`[a-zA-Z_]\w*:`, NameLabel, nil}, {`[a-zA-Z_]\w*`, Name, nil}, {`[~^*!%&\[\](){}<>|+=:;,./?-]`, Operator, nil}, {`\d{1,3}(_\d{3})+\.\d{1,3}(_\d{3})+[kMGTPmunpf]?`, LiteralNumberFloat, nil}, {`\d{1,3}(_\d{3})+\.[0-9]+([eE][+-]?[0-9]+)?[kMGTPmunpf]?`, LiteralNumberFloat, nil}, {`[0-9][0-9]*\.\d{1,3}(_\d{3})+[kMGTPmunpf]?`, LiteralNumberFloat, nil}, {`[0-9][0-9]*\.[0-9]+([eE][+-]?[0-9]+)?[kMGTPmunpf]?`, LiteralNumberFloat, nil}, {`#([0-9a-fA-F]{4})(_[0-9a-fA-F]{4})+`, LiteralNumberHex, nil}, {`#[0-9a-fA-F]+`, LiteralNumberHex, nil}, {`\$([01]{4})(_[01]{4})+`, LiteralNumberBin, nil}, {`\$[01]+`, LiteralNumberBin, nil}, {`\d{1,3}(_\d{3})+[kMGTP]?`, LiteralNumberInteger, nil}, {`[0-9]+[kMGTP]?`, LiteralNumberInteger, nil}, {`\n`, Text, nil}, }, "class": { {`[A-Za-z_]\w*`, NameClass, Pop(1)}, }, "import": { {`[a-z][\w.]*`, NameNamespace, Pop(1)}, }, "comment": { {`[^*/]`, CommentMultiline, nil}, {`/\*`, CommentMultiline, Push()}, {`\*/`, CommentMultiline, Pop(1)}, {`[*/]`, CommentMultiline, nil}, }, }, ))
Ceylon lexer.
var Cfengine3 = Register(MustNewLexer( &Config{ Name: "CFEngine3", Aliases: []string{"cfengine3", "cf3"}, Filenames: []string{"*.cf"}, MimeTypes: []string{}, }, Rules{ "root": { {`#.*?\n`, Comment, nil}, {`(body)(\s+)(\S+)(\s+)(control)`, ByGroups(Keyword, Text, Keyword, Text, Keyword), nil}, {`(body|bundle)(\s+)(\S+)(\s+)(\w+)(\()`, ByGroups(Keyword, Text, Keyword, Text, NameFunction, Punctuation), Push("arglist")}, {`(body|bundle)(\s+)(\S+)(\s+)(\w+)`, ByGroups(Keyword, Text, Keyword, Text, NameFunction), nil}, {`(")([^"]+)(")(\s+)(string|slist|int|real)(\s*)(=>)(\s*)`, ByGroups(Punctuation, NameVariable, Punctuation, Text, KeywordType, Text, Operator, Text), nil}, {`(\S+)(\s*)(=>)(\s*)`, ByGroups(KeywordReserved, Text, Operator, Text), nil}, {`"`, LiteralString, Push("string")}, {`(\w+)(\()`, ByGroups(NameFunction, Punctuation), nil}, {`([\w.!&|()]+)(::)`, ByGroups(NameClass, Punctuation), nil}, {`(\w+)(:)`, ByGroups(KeywordDeclaration, Punctuation), nil}, {`@[{(][^)}]+[})]`, NameVariable, nil}, {`[(){},;]`, Punctuation, nil}, {`=>`, Operator, nil}, {`->`, Operator, nil}, {`\d+\.\d+`, LiteralNumberFloat, nil}, {`\d+`, LiteralNumberInteger, nil}, {`\w+`, NameFunction, nil}, {`\s+`, Text, nil}, }, "string": { {`\$[{(]`, LiteralStringInterpol, Push("interpol")}, {`\\.`, LiteralStringEscape, nil}, {`"`, LiteralString, Pop(1)}, {`\n`, LiteralString, nil}, {`.`, LiteralString, nil}, }, "interpol": { {`\$[{(]`, LiteralStringInterpol, Push()}, {`[})]`, LiteralStringInterpol, Pop(1)}, {`[^${()}]+`, LiteralStringInterpol, nil}, }, "arglist": { {`\)`, Punctuation, Pop(1)}, {`,`, Punctuation, nil}, {`\w+`, NameVariable, nil}, {`\s+`, Text, nil}, }, }, ))
Cfengine3 lexer.
var Cfstatement = Register(MustNewLexer( &Config{ Name: "cfstatement", Aliases: []string{"cfs"}, Filenames: []string{}, MimeTypes: []string{}, NotMultiline: true, CaseInsensitive: true, }, Rules{ "root": { {`//.*?\n`, CommentSingle, nil}, {`/\*(?:.|\n)*?\*/`, CommentMultiline, nil}, {`\+\+|--`, Operator, nil}, {`[-+*/^&=!]`, Operator, nil}, {`<=|>=|<|>|==`, Operator, nil}, {`mod\b`, Operator, nil}, {`(eq|lt|gt|lte|gte|not|is|and|or)\b`, Operator, nil}, {`\|\||&&`, Operator, nil}, {`\?`, Operator, nil}, {`"`, LiteralStringDouble, Push("string")}, {`'.*?'`, LiteralStringSingle, nil}, {`\d+`, LiteralNumber, nil}, {"" /* 208 byte string literal not displayed */, Keyword, nil}, {`(true|false|null)\b`, KeywordConstant, nil}, {`(application|session|client|cookie|super|this|variables|arguments)\b`, NameConstant, nil}, {`([a-z_$][\w.]*)(\s*)(\()`, ByGroups(NameFunction, Text, Punctuation), nil}, {`[a-z_$][\w.]*`, NameVariable, nil}, {`[()\[\]{};:,.\\]`, Punctuation, nil}, {`\s+`, Text, nil}, }, "string": { {`""`, LiteralStringDouble, nil}, {`#.+?#`, LiteralStringInterpol, nil}, {`[^"#]+`, LiteralStringDouble, nil}, {`#`, LiteralStringDouble, nil}, {`"`, LiteralStringDouble, Pop(1)}, }, }, ))
Cfstatement lexer.
var Chaiscript = Register(MustNewLexer( &Config{ Name: "ChaiScript", Aliases: []string{"chai", "chaiscript"}, Filenames: []string{"*.chai"}, MimeTypes: []string{"text/x-chaiscript", "application/x-chaiscript"}, DotAll: true, }, Rules{ "commentsandwhitespace": { {`\s+`, Text, nil}, {`//.*?\n`, CommentSingle, nil}, {`/\*.*?\*/`, CommentMultiline, nil}, {`^\#.*?\n`, CommentSingle, nil}, }, "slashstartsregex": { Include("commentsandwhitespace"), {`/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/([gim]+\b|\B)`, LiteralStringRegex, Pop(1)}, {`(?=/)`, Text, Push("#pop", "badregex")}, Default(Pop(1)), }, "badregex": { {`\n`, Text, Pop(1)}, }, "root": { Include("commentsandwhitespace"), {`\n`, Text, nil}, {`[^\S\n]+`, Text, nil}, {`\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|\.\.(<<|>>>?|==?|!=?|[-<>+*%&|^/])=?`, Operator, Push("slashstartsregex")}, {`[{(\[;,]`, Punctuation, Push("slashstartsregex")}, {`[})\].]`, Punctuation, nil}, {`[=+\-*/]`, Operator, nil}, {`(for|in|while|do|break|return|continue|if|else|throw|try|catch)\b`, Keyword, Push("slashstartsregex")}, {`(var)\b`, KeywordDeclaration, Push("slashstartsregex")}, {`(attr|def|fun)\b`, KeywordReserved, nil}, {`(true|false)\b`, KeywordConstant, nil}, {`(eval|throw)\b`, NameBuiltin, nil}, {"`\\S+`", NameBuiltin, nil}, {`[$a-zA-Z_]\w*`, NameOther, nil}, {`[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?`, LiteralNumberFloat, nil}, {`0x[0-9a-fA-F]+`, LiteralNumberHex, nil}, {`[0-9]+`, LiteralNumberInteger, nil}, {`"`, LiteralStringDouble, Push("dqstring")}, {`'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil}, }, "dqstring": { {`\$\{[^"}]+?\}`, LiteralStringInterpol, nil}, {`\$`, LiteralStringDouble, nil}, {`\\\\`, LiteralStringDouble, nil}, {`\\"`, LiteralStringDouble, nil}, {`[^\\"$]+`, LiteralStringDouble, nil}, {`"`, LiteralStringDouble, Pop(1)}, }, }, ))
Chaiscript lexer.
var Cheetah = Register(MustNewLexer( &Config{ Name: "Cheetah", Aliases: []string{"cheetah", "spitfire"}, Filenames: []string{"*.tmpl", "*.spt"}, MimeTypes: []string{"application/x-cheetah", "application/x-spitfire"}, }, Rules{ "root": { {`(##[^\n]*)$`, ByGroups(Comment), nil}, {`#[*](.|\n)*?[*]#`, Comment, nil}, {`#end[^#\n]*(?:#|$)`, CommentPreproc, nil}, {`#slurp$`, CommentPreproc, nil}, {`(#[a-zA-Z]+)([^#\n]*)(#|$)`, ByGroups(CommentPreproc, Using(Python, nil), CommentPreproc), nil}, {`(\$)([a-zA-Z_][\w.]*\w)`, ByGroups(CommentPreproc, Using(Python, nil)), nil}, {`(\$\{!?)(.*?)(\})(?s)`, ByGroups(CommentPreproc, Using(Python, nil), CommentPreproc), nil}, {"" /* 278 byte string literal not displayed */, Other, nil}, {`\s+`, Text, nil}, }, }, ))
Cheetah lexer.
var Clojure = Register(MustNewLexer( &Config{ Name: "Clojure", Aliases: []string{"clojure", "clj"}, Filenames: []string{"*.clj"}, MimeTypes: []string{"text/x-clojure", "application/x-clojure"}, }, Rules{ "root": { {`;.*$`, CommentSingle, nil}, {`[,\s]+`, Text, nil}, {`-?\d+\.\d+`, LiteralNumberFloat, nil}, {`-?\d+`, LiteralNumberInteger, nil}, {`0x-?[abcdef\d]+`, LiteralNumberHex, nil}, {`"(\\\\|\\"|[^"])*"`, LiteralString, nil}, {`'(?!#)[\w!$%*+<=>?/.#-]+`, LiteralStringSymbol, nil}, {`\\(.|[a-z]+)`, LiteralStringChar, nil}, {`::?#?(?!#)[\w!$%*+<=>?/.#-]+`, LiteralStringSymbol, nil}, {"~@|[`\\'#^~&@]", Operator, nil}, {Words(``, ` `, `.`, `def`, `do`, `fn`, `if`, `let`, `new`, `quote`, `var`, `loop`), Keyword, nil}, {Words(``, ` `, `def-`, `defn`, `defn-`, `defmacro`, `defmulti`, `defmethod`, `defstruct`, `defonce`, `declare`, `definline`, `definterface`, `defprotocol`, `defrecord`, `deftype`, `defproject`, `ns`), KeywordDeclaration, nil}, {Words(``, ` `, `*`, `+`, `-`, `->`, `/`, `<`, `<=`, `=`, `==`, `>`, `>=`, `..`, `accessor`, `agent`, `agent-errors`, `aget`, `alength`, `all-ns`, `alter`, `and`, `append-child`, `apply`, `array-map`, `aset`, `aset-boolean`, `aset-byte`, `aset-char`, `aset-double`, `aset-float`, `aset-int`, `aset-long`, `aset-short`, `assert`, `assoc`, `await`, `await-for`, `bean`, `binding`, `bit-and`, `bit-not`, `bit-or`, `bit-shift-left`, `bit-shift-right`, `bit-xor`, `boolean`, `branch?`, `butlast`, `byte`, `cast`, `char`, `children`, `class`, `clear-agent-errors`, `comment`, `commute`, `comp`, `comparator`, `complement`, `concat`, `conj`, `cons`, `constantly`, `cond`, `if-not`, `construct-proxy`, `contains?`, `count`, `create-ns`, `create-struct`, `cycle`, `dec`, `deref`, `difference`, `disj`, `dissoc`, `distinct`, `doall`, `doc`, `dorun`, `doseq`, `dosync`, `dotimes`, `doto`, `double`, `down`, `drop`, `drop-while`, `edit`, `end?`, `ensure`, `eval`, `every?`, `false?`, `ffirst`, `file-seq`, `filter`, `find`, `find-doc`, `find-ns`, `find-var`, `first`, `float`, `flush`, `for`, `fnseq`, `frest`, `gensym`, `get-proxy-class`, `get`, `hash-map`, `hash-set`, `identical?`, `identity`, `if-let`, `import`, `in-ns`, `inc`, `index`, `insert-child`, `insert-left`, `insert-right`, `inspect-table`, `inspect-tree`, `instance?`, `int`, `interleave`, `intersection`, `into`, `into-array`, `iterate`, `join`, `key`, `keys`, `keyword`, `keyword?`, `last`, `lazy-cat`, `lazy-cons`, `left`, `lefts`, `line-seq`, `list*`, `list`, `load`, `load-file`, `locking`, `long`, `loop`, `macroexpand`, `macroexpand-1`, `make-array`, `make-node`, `map`, `map-invert`, `map?`, `mapcat`, `max`, `max-key`, `memfn`, `merge`, `merge-with`, `meta`, `min`, `min-key`, `name`, `namespace`, `neg?`, `new`, `newline`, `next`, `nil?`, `node`, `not`, `not-any?`, `not-every?`, `not=`, `ns-imports`, `ns-interns`, `ns-map`, `ns-name`, `ns-publics`, `ns-refers`, `ns-resolve`, `ns-unmap`, `nth`, `nthrest`, `or`, `parse`, `partial`, `path`, `peek`, `pop`, `pos?`, `pr`, `pr-str`, `print`, `print-str`, `println`, `println-str`, `prn`, `prn-str`, `project`, `proxy`, `proxy-mappings`, `quot`, `rand`, `rand-int`, `range`, `re-find`, `re-groups`, `re-matcher`, `re-matches`, `re-pattern`, `re-seq`, `read`, `read-line`, `reduce`, `ref`, `ref-set`, `refer`, `rem`, `remove`, `remove-method`, `remove-ns`, `rename`, `rename-keys`, `repeat`, `replace`, `replicate`, `resolve`, `rest`, `resultset-seq`, `reverse`, `rfirst`, `right`, `rights`, `root`, `rrest`, `rseq`, `second`, `select`, `select-keys`, `send`, `send-off`, `seq`, `seq-zip`, `seq?`, `set`, `short`, `slurp`, `some`, `sort`, `sort-by`, `sorted-map`, `sorted-map-by`, `sorted-set`, `special-symbol?`, `split-at`, `split-with`, `str`, `string?`, `struct`, `struct-map`, `subs`, `subvec`, `symbol`, `symbol?`, `sync`, `take`, `take-nth`, `take-while`, `test`, `time`, `to-array`, `to-array-2d`, `tree-seq`, `true?`, `union`, `up`, `update-proxy`, `val`, `vals`, `var-get`, `var-set`, `var?`, `vector`, `vector-zip`, `vector?`, `when`, `when-first`, `when-let`, `when-not`, `with-local-vars`, `with-meta`, `with-open`, `with-out-str`, `xml-seq`, `xml-zip`, `zero?`, `zipmap`, `zipper`), NameBuiltin, nil}, {`(?<=\()(?!#)[\w!$%*+<=>?/.#-]+`, NameFunction, nil}, {`(?!#)[\w!$%*+<=>?/.#-]+`, NameVariable, nil}, {`(\[|\])`, Punctuation, nil}, {`(\{|\})`, Punctuation, nil}, {`(\(|\))`, Punctuation, nil}, }, }, ))
Clojure lexer.
var Cmake = Register(MustNewLexer( &Config{ Name: "CMake", Aliases: []string{"cmake"}, Filenames: []string{"*.cmake", "CMakeLists.txt"}, MimeTypes: []string{"text/x-cmake"}, }, Rules{ "root": { {`\b(\w+)([ \t]*)(\()`, ByGroups(NameBuiltin, Text, Punctuation), Push("args")}, Include("keywords"), Include("ws"), }, "args": { {`\(`, Punctuation, Push()}, {`\)`, Punctuation, Pop(1)}, {`(\$\{)(.+?)(\})`, ByGroups(Operator, NameVariable, Operator), nil}, {`(\$ENV\{)(.+?)(\})`, ByGroups(Operator, NameVariable, Operator), nil}, {`(\$<)(.+?)(>)`, ByGroups(Operator, NameVariable, Operator), nil}, {`(?s)".*?"`, LiteralStringDouble, nil}, {`\\\S+`, LiteralString, nil}, {`[^)$"# \t\n]+`, LiteralString, nil}, {`\n`, Text, nil}, Include("keywords"), Include("ws"), }, "string": {}, "keywords": { {`\b(WIN32|UNIX|APPLE|CYGWIN|BORLAND|MINGW|MSVC|MSVC_IDE|MSVC60|MSVC70|MSVC71|MSVC80|MSVC90)\b`, Keyword, nil}, }, "ws": { {`[ \t]+`, Text, nil}, {`#.*\n`, Comment, nil}, }, }, ))
Cmake lexer.
var Cobol = Register(MustNewLexer( &Config{ Name: "COBOL", Aliases: []string{"cobol"}, Filenames: []string{"*.cob", "*.COB", "*.cpy", "*.CPY"}, MimeTypes: []string{"text/x-cobol"}, CaseInsensitive: true, }, Rules{ "root": { Include("comment"), Include("strings"), Include("core"), Include("nums"), {`[a-z0-9]([\w\-]*[a-z0-9]+)?`, NameVariable, nil}, {`[ \t]+`, Text, nil}, }, "comment": { {`(^.{6}[*/].*\n|^.{6}|\*>.*\n)`, Comment, nil}, }, "core": { {`(^|(?<=[^\w\-]))(ALL\s+)?((ZEROES)|(HIGH-VALUE|LOW-VALUE|QUOTE|SPACE|ZERO)(S)?)\s*($|(?=[^\w\-]))`, NameConstant, nil}, {Words(`(^|(?<=[^\w\-]))`, `\s*($|(?=[^\w\-]))`, `ACCEPT`, `ADD`, `ALLOCATE`, `CALL`, `CANCEL`, `CLOSE`, `COMPUTE`, `CONFIGURATION`, `CONTINUE`, `DATA`, `DELETE`, `DISPLAY`, `DIVIDE`, `DIVISION`, `ELSE`, `END`, `END-ACCEPT`, `END-ADD`, `END-CALL`, `END-COMPUTE`, `END-DELETE`, `END-DISPLAY`, `END-DIVIDE`, `END-EVALUATE`, `END-IF`, `END-MULTIPLY`, `END-OF-PAGE`, `END-PERFORM`, `END-READ`, `END-RETURN`, `END-REWRITE`, `END-SEARCH`, `END-START`, `END-STRING`, `END-SUBTRACT`, `END-UNSTRING`, `END-WRITE`, `ENVIRONMENT`, `EVALUATE`, `EXIT`, `FD`, `FILE`, `FILE-CONTROL`, `FOREVER`, `FREE`, `GENERATE`, `GO`, `GOBACK`, `IDENTIFICATION`, `IF`, `INITIALIZE`, `INITIATE`, `INPUT-OUTPUT`, `INSPECT`, `INVOKE`, `I-O-CONTROL`, `LINKAGE`, `LOCAL-STORAGE`, `MERGE`, `MOVE`, `MULTIPLY`, `OPEN`, `PERFORM`, `PROCEDURE`, `PROGRAM-ID`, `RAISE`, `READ`, `RELEASE`, `RESUME`, `RETURN`, `REWRITE`, `SCREEN`, `SD`, `SEARCH`, `SECTION`, `SET`, `SORT`, `START`, `STOP`, `STRING`, `SUBTRACT`, `SUPPRESS`, `TERMINATE`, `THEN`, `UNLOCK`, `UNSTRING`, `USE`, `VALIDATE`, `WORKING-STORAGE`, `WRITE`), KeywordReserved, nil}, {Words(`(^|(?<=[^\w\-]))`, `\s*($|(?=[^\w\-]))`, `ACCESS`, `ADDRESS`, `ADVANCING`, `AFTER`, `ALL`, `ALPHABET`, `ALPHABETIC`, `ALPHABETIC-LOWER`, `ALPHABETIC-UPPER`, `ALPHANUMERIC`, `ALPHANUMERIC-EDITED`, `ALSO`, `ALTER`, `ALTERNATEANY`, `ARE`, `AREA`, `AREAS`, `ARGUMENT-NUMBER`, `ARGUMENT-VALUE`, `AS`, `ASCENDING`, `ASSIGN`, `AT`, `AUTO`, `AUTO-SKIP`, `AUTOMATIC`, `AUTOTERMINATE`, `BACKGROUND-COLOR`, `BASED`, `BEEP`, `BEFORE`, `BELL`, `BLANK`, `BLINK`, `BLOCK`, `BOTTOM`, `BY`, `BYTE-LENGTH`, `CHAINING`, `CHARACTER`, `CHARACTERS`, `CLASS`, `CODE`, `CODE-SET`, `COL`, `COLLATING`, `COLS`, `COLUMN`, `COLUMNS`, `COMMA`, `COMMAND-LINE`, `COMMIT`, `COMMON`, `CONSTANT`, `CONTAINS`, `CONTENT`, `CONTROL`, `CONTROLS`, `CONVERTING`, `COPY`, `CORR`, `CORRESPONDING`, `COUNT`, `CRT`, `CURRENCY`, `CURSOR`, `CYCLE`, `DATE`, `DAY`, `DAY-OF-WEEK`, `DE`, `DEBUGGING`, `DECIMAL-POINT`, `DECLARATIVES`, `DEFAULT`, `DELIMITED`, `DELIMITER`, `DEPENDING`, `DESCENDING`, `DETAIL`, `DISK`, `DOWN`, `DUPLICATES`, `DYNAMIC`, `EBCDIC`, `ENTRY`, `ENVIRONMENT-NAME`, `ENVIRONMENT-VALUE`, `EOL`, `EOP`, `EOS`, `ERASE`, `ERROR`, `ESCAPE`, `EXCEPTION`, `EXCLUSIVE`, `EXTEND`, `EXTERNAL`, `FILE-ID`, `FILLER`, `FINAL`, `FIRST`, `FIXED`, `FLOAT-LONG`, `FLOAT-SHORT`, `FOOTING`, `FOR`, `FOREGROUND-COLOR`, `FORMAT`, `FROM`, `FULL`, `FUNCTION`, `FUNCTION-ID`, `GIVING`, `GLOBAL`, `GROUP`, `HEADING`, `HIGHLIGHT`, `I-O`, `ID`, `IGNORE`, `IGNORING`, `IN`, `INDEX`, `INDEXED`, `INDICATE`, `INITIAL`, `INITIALIZED`, `INPUT`, `INTO`, `INTRINSIC`, `INVALID`, `IS`, `JUST`, `JUSTIFIED`, `KEY`, `LABEL`, `LAST`, `LEADING`, `LEFT`, `LENGTH`, `LIMIT`, `LIMITS`, `LINAGE`, `LINAGE-COUNTER`, `LINE`, `LINES`, `LOCALE`, `LOCK`, `LOWLIGHT`, `MANUAL`, `MEMORY`, `MINUS`, `MODE`, `MULTIPLE`, `NATIONAL`, `NATIONAL-EDITED`, `NATIVE`, `NEGATIVE`, `NEXT`, `NO`, `NULL`, `NULLS`, `NUMBER`, `NUMBERS`, `NUMERIC`, `NUMERIC-EDITED`, `OBJECT-COMPUTER`, `OCCURS`, `OF`, `OFF`, `OMITTED`, `ON`, `ONLY`, `OPTIONAL`, `ORDER`, `ORGANIZATION`, `OTHER`, `OUTPUT`, `OVERFLOW`, `OVERLINE`, `PACKED-DECIMAL`, `PADDING`, `PAGE`, `PARAGRAPH`, `PLUS`, `POINTER`, `POSITION`, `POSITIVE`, `PRESENT`, `PREVIOUS`, `PRINTER`, `PRINTING`, `PROCEDURE-POINTER`, `PROCEDURES`, `PROCEED`, `PROGRAM`, `PROGRAM-POINTER`, `PROMPT`, `QUOTE`, `QUOTES`, `RANDOM`, `RD`, `RECORD`, `RECORDING`, `RECORDS`, `RECURSIVE`, `REDEFINES`, `REEL`, `REFERENCE`, `RELATIVE`, `REMAINDER`, `REMOVAL`, `RENAMES`, `REPLACING`, `REPORT`, `REPORTING`, `REPORTS`, `REPOSITORY`, `REQUIRED`, `RESERVE`, `RETURNING`, `REVERSE-VIDEO`, `REWIND`, `RIGHT`, `ROLLBACK`, `ROUNDED`, `RUN`, `SAME`, `SCROLL`, `SECURE`, `SEGMENT-LIMIT`, `SELECT`, `SENTENCE`, `SEPARATE`, `SEQUENCE`, `SEQUENTIAL`, `SHARING`, `SIGN`, `SIGNED`, `SIGNED-INT`, `SIGNED-LONG`, `SIGNED-SHORT`, `SIZE`, `SORT-MERGE`, `SOURCE`, `SOURCE-COMPUTER`, `SPECIAL-NAMES`, `STANDARD`, `STANDARD-1`, `STANDARD-2`, `STATUS`, `SUM`, `SYMBOLIC`, `SYNC`, `SYNCHRONIZED`, `TALLYING`, `TAPE`, `TEST`, `THROUGH`, `THRU`, `TIME`, `TIMES`, `TO`, `TOP`, `TRAILING`, `TRANSFORM`, `TYPE`, `UNDERLINE`, `UNIT`, `UNSIGNED`, `UNSIGNED-INT`, `UNSIGNED-LONG`, `UNSIGNED-SHORT`, `UNTIL`, `UP`, `UPDATE`, `UPON`, `USAGE`, `USING`, `VALUE`, `VALUES`, `VARYING`, `WAIT`, `WHEN`, `WITH`, `WORDS`, `YYYYDDD`, `YYYYMMDD`), KeywordPseudo, nil}, {Words(`(^|(?<=[^\w\-]))`, `\s*($|(?=[^\w\-]))`, `ACTIVE-CLASS`, `ALIGNED`, `ANYCASE`, `ARITHMETIC`, `ATTRIBUTE`, `B-AND`, `B-NOT`, `B-OR`, `B-XOR`, `BIT`, `BOOLEAN`, `CD`, `CENTER`, `CF`, `CH`, `CHAIN`, `CLASS-ID`, `CLASSIFICATION`, `COMMUNICATION`, `CONDITION`, `DATA-POINTER`, `DESTINATION`, `DISABLE`, `EC`, `EGI`, `EMI`, `ENABLE`, `END-RECEIVE`, `ENTRY-CONVENTION`, `EO`, `ESI`, `EXCEPTION-OBJECT`, `EXPANDS`, `FACTORY`, `FLOAT-BINARY-16`, `FLOAT-BINARY-34`, `FLOAT-BINARY-7`, `FLOAT-DECIMAL-16`, `FLOAT-DECIMAL-34`, `FLOAT-EXTENDED`, `FORMAT`, `FUNCTION-POINTER`, `GET`, `GROUP-USAGE`, `IMPLEMENTS`, `INFINITY`, `INHERITS`, `INTERFACE`, `INTERFACE-ID`, `INVOKE`, `LC_ALL`, `LC_COLLATE`, `LC_CTYPE`, `LC_MESSAGES`, `LC_MONETARY`, `LC_NUMERIC`, `LC_TIME`, `LINE-COUNTER`, `MESSAGE`, `METHOD`, `METHOD-ID`, `NESTED`, `NONE`, `NORMAL`, `OBJECT`, `OBJECT-REFERENCE`, `OPTIONS`, `OVERRIDE`, `PAGE-COUNTER`, `PF`, `PH`, `PROPERTY`, `PROTOTYPE`, `PURGE`, `QUEUE`, `RAISE`, `RAISING`, `RECEIVE`, `RELATION`, `REPLACE`, `REPRESENTS-NOT-A-NUMBER`, `RESET`, `RESUME`, `RETRY`, `RF`, `RH`, `SECONDS`, `SEGMENT`, `SELF`, `SEND`, `SOURCES`, `STATEMENT`, `STEP`, `STRONG`, `SUB-QUEUE-1`, `SUB-QUEUE-2`, `SUB-QUEUE-3`, `SUPER`, `SYMBOL`, `SYSTEM-DEFAULT`, `TABLE`, `TERMINAL`, `TEXT`, `TYPEDEF`, `UCS-4`, `UNIVERSAL`, `USER-DEFAULT`, `UTF-16`, `UTF-8`, `VAL-STATUS`, `VALID`, `VALIDATE`, `VALIDATE-STATUS`), Error, nil}, {"" /* 202 byte string literal not displayed */, KeywordType, nil}, {`(\*\*|\*|\+|-|/|<=|>=|<|>|==|/=|=)`, Operator, nil}, {`([(),;:&%.])`, Punctuation, nil}, {"" /* 703 byte string literal not displayed */, NameFunction, nil}, {`(^|(?<=[^\w\-]))(true|false)\s*($|(?=[^\w\-]))`, NameBuiltin, nil}, {`(^|(?<=[^\w\-]))(equal|equals|ne|lt|le|gt|ge|greater|less|than|not|and|or)\s*($|(?=[^\w\-]))`, OperatorWord, nil}, }, "strings": { {`"[^"\n]*("|\n)`, LiteralStringDouble, nil}, {`'[^'\n]*('|\n)`, LiteralStringSingle, nil}, }, "nums": { {`\d+(\s*|\.$|$)`, LiteralNumberInteger, nil}, {`[+-]?\d*\.\d+(E[-+]?\d+)?`, LiteralNumberFloat, nil}, {`[+-]?\d+\.\d*(E[-+]?\d+)?`, LiteralNumberFloat, nil}, }, }, ))
Cobol lexer.
var Coffeescript = Register(MustNewLexer( &Config{ Name: "CoffeeScript", Aliases: []string{"coffee-script", "coffeescript", "coffee"}, Filenames: []string{"*.coffee"}, MimeTypes: []string{"text/coffeescript"}, NotMultiline: true, DotAll: true, }, Rules{ "commentsandwhitespace": { {`\s+`, Text, nil}, {`###[^#].*?###`, CommentMultiline, nil}, {`#(?!##[^#]).*?\n`, CommentSingle, nil}, }, "multilineregex": { {`[^/#]+`, LiteralStringRegex, nil}, {`///([gim]+\b|\B)`, LiteralStringRegex, Pop(1)}, {`#\{`, LiteralStringInterpol, Push("interpoling_string")}, {`[/#]`, LiteralStringRegex, nil}, }, "slashstartsregex": { Include("commentsandwhitespace"), {`///`, LiteralStringRegex, Push("#pop", "multilineregex")}, {`/(?! )(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/([gim]+\b|\B)`, LiteralStringRegex, Pop(1)}, {`/`, Operator, nil}, Default(Pop(1)), }, "root": { Include("commentsandwhitespace"), {`^(?=\s|/)`, Text, Push("slashstartsregex")}, {"" /* 143 byte string literal not displayed */, Operator, Push("slashstartsregex")}, {`(?:\([^()]*\))?\s*[=-]>`, NameFunction, Push("slashstartsregex")}, {`[{(\[;,]`, Punctuation, Push("slashstartsregex")}, {`[})\].]`, Punctuation, nil}, {"" /* 180 byte string literal not displayed */, Keyword, Push("slashstartsregex")}, {`(?<![.$])(true|false|yes|no|on|off|null|NaN|Infinity|undefined)\b`, KeywordConstant, nil}, {"" /* 208 byte string literal not displayed */, NameBuiltin, nil}, {`[$a-zA-Z_][\w.:$]*\s*[:=]\s`, NameVariable, Push("slashstartsregex")}, {`@[$a-zA-Z_][\w.:$]*\s*[:=]\s`, NameVariableInstance, Push("slashstartsregex")}, {`@`, NameOther, Push("slashstartsregex")}, {`@?[$a-zA-Z_][\w$]*`, NameOther, nil}, {`[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?`, LiteralNumberFloat, nil}, {`0x[0-9a-fA-F]+`, LiteralNumberHex, nil}, {`[0-9]+`, LiteralNumberInteger, nil}, {`"""`, LiteralString, Push("tdqs")}, {`'''`, LiteralString, Push("tsqs")}, {`"`, LiteralString, Push("dqs")}, {`'`, LiteralString, Push("sqs")}, }, "strings": { {`[^#\\\'"]+`, LiteralString, nil}, }, "interpoling_string": { {`\}`, LiteralStringInterpol, Pop(1)}, Include("root"), }, "dqs": { {`"`, LiteralString, Pop(1)}, {`\\.|\'`, LiteralString, nil}, {`#\{`, LiteralStringInterpol, Push("interpoling_string")}, {`#`, LiteralString, nil}, Include("strings"), }, "sqs": { {`'`, LiteralString, Pop(1)}, {`#|\\.|"`, LiteralString, nil}, Include("strings"), }, "tdqs": { {`"""`, LiteralString, Pop(1)}, {`\\.|\'|"`, LiteralString, nil}, {`#\{`, LiteralStringInterpol, Push("interpoling_string")}, {`#`, LiteralString, nil}, Include("strings"), }, "tsqs": { {`'''`, LiteralString, Pop(1)}, {`#|\\.|\'|"`, LiteralString, nil}, Include("strings"), }, }, ))
Coffeescript lexer.
var CommonLisp = Register(MustNewLexer( &Config{ Name: "Common Lisp", Aliases: []string{"common-lisp", "cl", "lisp"}, Filenames: []string{"*.cl", "*.lisp"}, MimeTypes: []string{"text/x-common-lisp"}, CaseInsensitive: true, }, Rules{ "root": { Default(Push("body")), }, "multiline-comment": { {`#\|`, CommentMultiline, Push()}, {`\|#`, CommentMultiline, Pop(1)}, {`[^|#]+`, CommentMultiline, nil}, {`[|#]`, CommentMultiline, nil}, }, "commented-form": { {`\(`, CommentPreproc, Push()}, {`\)`, CommentPreproc, Pop(1)}, {`[^()]+`, CommentPreproc, nil}, }, "body": { {`\s+`, Text, nil}, {`;.*$`, CommentSingle, nil}, {`#\|`, CommentMultiline, Push("multiline-comment")}, {`#\d*Y.*$`, CommentSpecial, nil}, {`"(\\.|\\\n|[^"\\])*"`, LiteralString, nil}, {`:(\|[^|]+\||(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~])(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~]|[#.:])*)`, LiteralStringSymbol, nil}, {`::(\|[^|]+\||(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~])(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~]|[#.:])*)`, LiteralStringSymbol, nil}, {`:#(\|[^|]+\||(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~])(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~]|[#.:])*)`, LiteralStringSymbol, nil}, {`'(\|[^|]+\||(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~])(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~]|[#.:])*)`, LiteralStringSymbol, nil}, {`'`, Operator, nil}, {"`", Operator, nil}, {"[-+]?\\d+\\.?(?=[ \"()\\'\\n,;`])", LiteralNumberInteger, nil}, {"[-+]?\\d+/\\d+(?=[ \"()\\'\\n,;`])", LiteralNumber, nil}, {"[-+]?(\\d*\\.\\d+([defls][-+]?\\d+)?|\\d+(\\.\\d*)?[defls][-+]?\\d+)(?=[ \"()\\'\\n,;`])", LiteralNumberFloat, nil}, {"#\\\\.(?=[ \"()\\'\\n,;`])", LiteralStringChar, nil}, {`#\\(\|[^|]+\||(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~])(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~]|[#.:])*)`, LiteralStringChar, nil}, {`#\(`, Operator, Push("body")}, {`#\d*\*[01]*`, LiteralOther, nil}, {`#:(\|[^|]+\||(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~])(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~]|[#.:])*)`, LiteralStringSymbol, nil}, {`#[.,]`, Operator, nil}, {`#\'`, NameFunction, nil}, {`#b[+-]?[01]+(/[01]+)?`, LiteralNumberBin, nil}, {`#o[+-]?[0-7]+(/[0-7]+)?`, LiteralNumberOct, nil}, {`#x[+-]?[0-9a-f]+(/[0-9a-f]+)?`, LiteralNumberHex, nil}, {`#\d+r[+-]?[0-9a-z]+(/[0-9a-z]+)?`, LiteralNumber, nil}, {`(#c)(\()`, ByGroups(LiteralNumber, Punctuation), Push("body")}, {`(#\d+a)(\()`, ByGroups(LiteralOther, Punctuation), Push("body")}, {`(#s)(\()`, ByGroups(LiteralOther, Punctuation), Push("body")}, {`#p?"(\\.|[^"])*"`, LiteralOther, nil}, {`#\d+=`, Operator, nil}, {`#\d+#`, Operator, nil}, {"#+nil(?=[ \"()\\'\\n,;`])\\s*\\(", CommentPreproc, Push("commented-form")}, {`#[+-]`, Operator, nil}, {`(,@|,|\.)`, Operator, nil}, {"(t|nil)(?=[ \"()\\'\\n,;`])", NameConstant, nil}, {`\*(\|[^|]+\||(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~])(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~]|[#.:])*)\*`, NameVariableGlobal, nil}, {`(\|[^|]+\||(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~])(?:\\.|[\w!$%&*+-/<=>?@\[\]^{}~]|[#.:])*)`, NameVariable, nil}, {`\(`, Punctuation, Push("body")}, {`\)`, Punctuation, Pop(1)}, }, }, ))
Common Lisp lexer.
var Coq = Register(MustNewLexer( &Config{ Name: "Coq", Aliases: []string{"coq"}, Filenames: []string{"*.v"}, MimeTypes: []string{"text/x-coq"}, }, Rules{ "root": { {`\s+`, Text, nil}, {`false|true|\(\)|\[\]`, NameBuiltinPseudo, nil}, {`\(\*`, Comment, Push("comment")}, {Words(`\b`, `\b`, `Section`, `Module`, `End`, `Require`, `Import`, `Export`, `Variable`, `Variables`, `Parameter`, `Parameters`, `Axiom`, `Hypothesis`, `Hypotheses`, `Notation`, `Local`, `Tactic`, `Reserved`, `Scope`, `Open`, `Close`, `Bind`, `Delimit`, `Definition`, `Let`, `Ltac`, `Fixpoint`, `CoFixpoint`, `Morphism`, `Relation`, `Implicit`, `Arguments`, `Set`, `Unset`, `Contextual`, `Strict`, `Prenex`, `Implicits`, `Inductive`, `CoInductive`, `Record`, `Structure`, `Canonical`, `Coercion`, `Theorem`, `Lemma`, `Corollary`, `Proposition`, `Fact`, `Remark`, `Example`, `Proof`, `Goal`, `Save`, `Qed`, `Defined`, `Hint`, `Resolve`, `Rewrite`, `View`, `Search`, `Show`, `Print`, `Printing`, `All`, `Graph`, `Projections`, `inside`, `outside`, `Check`, `Global`, `Instance`, `Class`, `Existing`, `Universe`, `Polymorphic`, `Monomorphic`, `Context`), KeywordNamespace, nil}, {Words(`\b`, `\b`, `forall`, `exists`, `exists2`, `fun`, `fix`, `cofix`, `struct`, `match`, `end`, `in`, `return`, `let`, `if`, `is`, `then`, `else`, `for`, `of`, `nosimpl`, `with`, `as`), Keyword, nil}, {Words(`\b`, `\b`, `Type`, `Prop`), KeywordType, nil}, {Words(`\b`, `\b`, `pose`, `set`, `move`, `case`, `elim`, `apply`, `clear`, `hnf`, `intro`, `intros`, `generalize`, `rename`, `pattern`, `after`, `destruct`, `induction`, `using`, `refine`, `inversion`, `injection`, `rewrite`, `congr`, `unlock`, `compute`, `ring`, `field`, `replace`, `fold`, `unfold`, `change`, `cutrewrite`, `simpl`, `have`, `suff`, `wlog`, `suffices`, `without`, `loss`, `nat_norm`, `assert`, `cut`, `trivial`, `revert`, `bool_congr`, `nat_congr`, `symmetry`, `transitivity`, `auto`, `split`, `left`, `right`, `autorewrite`, `tauto`, `setoid_rewrite`, `intuition`, `eauto`, `eapply`, `econstructor`, `etransitivity`, `constructor`, `erewrite`, `red`, `cbv`, `lazy`, `vm_compute`, `native_compute`, `subst`), Keyword, nil}, {Words(`\b`, `\b`, `by`, `done`, `exact`, `reflexivity`, `tauto`, `romega`, `omega`, `assumption`, `solve`, `contradiction`, `discriminate`, `congruence`), KeywordPseudo, nil}, {Words(`\b`, `\b`, `do`, `last`, `first`, `try`, `idtac`, `repeat`), KeywordReserved, nil}, {`\b([A-Z][\w\']*)`, Name, nil}, {"" /* 194 byte string literal not displayed */, Operator, nil}, {`([=<>@^|&+\*/$%-]|[!?~])?[!$%&*+\./:<=>?@^|~-]`, Operator, nil}, {`\b(unit|nat|bool|string|ascii|list)\b`, KeywordType, nil}, {`[^\W\d][\w']*`, Name, nil}, {`\d[\d_]*`, LiteralNumberInteger, nil}, {`0[xX][\da-fA-F][\da-fA-F_]*`, LiteralNumberHex, nil}, {`0[oO][0-7][0-7_]*`, LiteralNumberOct, nil}, {`0[bB][01][01_]*`, LiteralNumberBin, nil}, {`-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)`, LiteralNumberFloat, nil}, {`'(?:(\\[\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))'`, LiteralStringChar, nil}, {`'.'`, LiteralStringChar, nil}, {`'`, Keyword, nil}, {`"`, LiteralStringDouble, Push("string")}, {`[~?][a-z][\w\']*:`, Name, nil}, }, "comment": { {`[^(*)]+`, Comment, nil}, {`\(\*`, Comment, Push()}, {`\*\)`, Comment, Pop(1)}, {`[(*)]`, Comment, nil}, }, "string": { {`[^"]+`, LiteralStringDouble, nil}, {`""`, LiteralStringDouble, nil}, {`"`, LiteralStringDouble, Pop(1)}, }, "dotted": { {`\s+`, Text, nil}, {`\.`, Punctuation, nil}, {`[A-Z][\w\']*(?=\s*\.)`, NameNamespace, nil}, {`[A-Z][\w\']*`, NameClass, Pop(1)}, {`[a-z][a-z0-9_\']*`, Name, Pop(1)}, Default(Pop(1)), }, }, ))
Coq lexer.
var Crystal = Register(MustNewLexer( &Config{ Name: "Crystal", Aliases: []string{"cr", "crystal"}, Filenames: []string{"*.cr"}, MimeTypes: []string{"text/x-crystal"}, DotAll: true, }, 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}, {Words(``, `\b`, `true`, `false`, `nil`), KeywordConstant, nil}, {`(module|lib)(\s+)([a-zA-Z_]\w*(?:::[a-zA-Z_]\w*)*)`, ByGroups(Keyword, Text, NameNamespace), nil}, {`(def|fun|macro)(\s+)((?:[a-zA-Z_]\w*::)*)`, ByGroups(Keyword, Text, NameNamespace), Push("funcname")}, {"def(?=[*%&^`~+-/\\[<>=])", Keyword, Push("funcname")}, {`(class|struct|union|type|alias|enum)(\s+)((?:[a-zA-Z_]\w*::)*)`, ByGroups(Keyword, Text, NameNamespace), Push("classname")}, {`(self|out|uninitialized)\b|(is_a|responds_to)\?`, KeywordPseudo, nil}, {Words(``, `\b`, `debugger`, `record`, `pp`, `assert_responds_to`, `spawn`, `parallel`, `getter`, `setter`, `property`, `delegate`, `def_hash`, `def_equals`, `def_equals_and_hash`, `forward_missing_to`), NameBuiltinPseudo, nil}, {`getter[!?]|property[!?]|__(DIR|FILE|LINE)__\b`, NameBuiltinPseudo, nil}, {Words(`(?<!\.)`, `\b`, `Object`, `Value`, `Struct`, `Reference`, `Proc`, `Class`, `Nil`, `Symbol`, `Enum`, `Void`, `Bool`, `Number`, `Int`, `Int8`, `Int16`, `Int32`, `Int64`, `UInt8`, `UInt16`, `UInt32`, `UInt64`, `Float`, `Float32`, `Float64`, `Char`, `String`, `Pointer`, `Slice`, `Range`, `Exception`, `Regex`, `Mutex`, `StaticArray`, `Array`, `Hash`, `Set`, `Tuple`, `Deque`, `Box`, `Process`, `File`, `Dir`, `Time`, `Channel`, `Concurrent`, `Scheduler`, `abort`, `at_exit`, `caller`, `delay`, `exit`, `fork`, `future`, `get_stack_top`, `gets`, `lazy`, `loop`, `main`, `p`, `print`, `printf`, `puts`, `raise`, `rand`, `read_line`, `sleep`, `sprintf`, `system`, `with_color`), NameBuiltin, nil}, {"(?<!\\w)(<<-?)([\"`\\']?)([a-zA-Z_]\\w*)(\\2)(.*?\\n)", StringHeredoc, nil}, {`(<<-?)("|\')()(\2)(.*?\n)`, StringHeredoc, nil}, {`__END__`, CommentPreproc, Push("end-part")}, {"" /* 356 byte string literal not displayed */, ByGroups(Text, LiteralStringRegex), Push("multiline-regex")}, {`(?<=\(|,|\[)/`, LiteralStringRegex, Push("multiline-regex")}, {`(\s+)(/)(?![\s=])`, ByGroups(Text, LiteralStringRegex), Push("multiline-regex")}, {`(0o[0-7]+(?:_[0-7]+)*(?:_?[iu][0-9]+)?)\b(\s*)([/?])?`, ByGroups(LiteralNumberOct, Text, Operator), nil}, {`(0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*(?:_?[iu][0-9]+)?)\b(\s*)([/?])?`, ByGroups(LiteralNumberHex, Text, Operator), nil}, {`(0b[01]+(?:_[01]+)*(?:_?[iu][0-9]+)?)\b(\s*)([/?])?`, ByGroups(LiteralNumberBin, Text, Operator), nil}, {`((?:0(?![0-9])|[1-9][\d_]*)(?:\.\d[\d_]*)(?:e[+-]?[0-9]+)?(?:_?f[0-9]+)?)(\s*)([/?])?`, ByGroups(LiteralNumberFloat, Text, Operator), nil}, {`((?:0(?![0-9])|[1-9][\d_]*)(?:\.\d[\d_]*)?(?:e[+-]?[0-9]+)(?:_?f[0-9]+)?)(\s*)([/?])?`, ByGroups(LiteralNumberFloat, Text, Operator), nil}, {`((?:0(?![0-9])|[1-9][\d_]*)(?:\.\d[\d_]*)?(?:e[+-]?[0-9]+)?(?:_?f[0-9]+))(\s*)([/?])?`, ByGroups(LiteralNumberFloat, Text, Operator), nil}, {`(0\b|[1-9][\d]*(?:_\d+)*(?:_?[iu][0-9]+)?)\b(\s*)([/?])?`, ByGroups(LiteralNumberInteger, Text, Operator), nil}, {`@@[a-zA-Z_]\w*`, NameVariableClass, nil}, {`@[a-zA-Z_]\w*`, NameVariableInstance, nil}, {`\$\w+`, NameVariableGlobal, nil}, {"\\$[!@&`\\'+~=/\\\\,;.<>_*$?:\"^-]", NameVariableGlobal, nil}, {`\$-[0adFiIlpvw]`, NameVariableGlobal, nil}, {`::`, Operator, nil}, Include("strings"), {`\?(\\[MC]-)*(\\([\\befnrtv#"\']|x[a-fA-F0-9]{1,2}|[0-7]{1,3})|\S)(?!\w)`, LiteralStringChar, nil}, {`[A-Z][A-Z_]+\b`, NameConstant, nil}, {`\{%`, LiteralStringInterpol, Push("in-macro-control")}, {`\{\{`, LiteralStringInterpol, Push("in-macro-expr")}, {`(@\[)(\s*)([A-Z]\w*)`, ByGroups(Operator, Text, NameDecorator), Push("in-attr")}, {Words(`(\.|::)`, ``, `!=`, `!~`, `!`, `%`, `&&`, `&`, `**`, `*`, `+`, `-`, `/`, `<=>`, `<<`, `<=`, `<`, `===`, `==`, `=~`, `=`, `>=`, `>>`, `>`, `[]=`, `[]?`, `[]`, `^`, `||`, `|`, `~`), ByGroups(Operator, NameOperator), nil}, {"(\\.|::)([a-zA-Z_]\\w*[!?]?|[*%&^`~+\\-/\\[<>=])", ByGroups(Operator, Name), nil}, {`[a-zA-Z_]\w*(?:[!?](?!=))?`, Name, nil}, {`(\[|\]\??|\*\*|<=>?|>=|<<?|>>?|=~|===|!~|&&?|\|\||\.{1,3})`, Operator, nil}, {`[-+/*%=<>&!^|~]=?`, Operator, nil}, {`[(){};,/?:\\]`, Punctuation, nil}, {`\s+`, Text, nil}, }, "funcname": { {"(?:([a-zA-Z_]\\w*)(\\.))?([a-zA-Z_]\\w*[!?]?|\\*\\*?|[-+]@?|[/%&|^`~]|\\[\\]=?|<<|>>|<=?>|>=?|===?)", ByGroups(NameClass, Operator, NameFunction), Pop(1)}, Default(Pop(1)), }, "classname": { {`[A-Z_]\w*`, NameClass, nil}, {`(\()(\s*)([A-Z_]\w*)(\s*)(\))`, ByGroups(Punctuation, Text, NameClass, Text, Punctuation), nil}, Default(Pop(1)), }, "in-intp": { {`\{`, LiteralStringInterpol, Push()}, {`\}`, LiteralStringInterpol, Pop(1)}, Include("root"), }, "string-intp": { {`#\{`, LiteralStringInterpol, Push("in-intp")}, }, "string-escaped": { {`\\([\\befnstv#"\']|x[a-fA-F0-9]{1,2}|[0-7]{1,3})`, LiteralStringEscape, nil}, }, "string-intp-escaped": { Include("string-intp"), Include("string-escaped"), }, "interpolated-regex": { Include("string-intp"), {`[\\#]`, LiteralStringRegex, nil}, {`[^\\#]+`, LiteralStringRegex, nil}, }, "interpolated-string": { Include("string-intp"), {`[\\#]`, LiteralStringOther, nil}, {`[^\\#]+`, LiteralStringOther, nil}, }, "multiline-regex": { Include("string-intp"), {`\\\\`, LiteralStringRegex, nil}, {`\\/`, LiteralStringRegex, nil}, {`[\\#]`, LiteralStringRegex, nil}, {`[^\\/#]+`, LiteralStringRegex, nil}, {`/[imsx]*`, LiteralStringRegex, Pop(1)}, }, "end-part": { {`.+`, CommentPreproc, Pop(1)}, }, "in-macro-control": { {`\{%`, LiteralStringInterpol, Push()}, {`%\}`, LiteralStringInterpol, Pop(1)}, {`for\b|in\b`, Keyword, nil}, Include("root"), }, "in-macro-expr": { {`\{\{`, LiteralStringInterpol, Push()}, {`\}\}`, LiteralStringInterpol, Pop(1)}, Include("root"), }, "in-attr": { {`\[`, Operator, Push()}, {`\]`, Operator, Pop(1)}, Include("root"), }, "strings": { {`\:@{0,2}[a-zA-Z_]\w*[!?]?`, LiteralStringSymbol, nil}, {Words(`\:@{0,2}`, ``, `!=`, `!~`, `!`, `%`, `&&`, `&`, `**`, `*`, `+`, `-`, `/`, `<=>`, `<<`, `<=`, `<`, `===`, `==`, `=~`, `=`, `>=`, `>>`, `>`, `[]=`, `[]?`, `[]`, `^`, `||`, `|`, `~`), LiteralStringSymbol, nil}, {`:'(\\\\|\\'|[^'])*'`, LiteralStringSymbol, nil}, {`'(\\\\|\\'|[^']|\\[^'\\]+)'`, LiteralStringChar, nil}, {`:"`, LiteralStringSymbol, Push("simple-sym")}, {`([a-zA-Z_]\w*)(:)(?!:)`, ByGroups(LiteralStringSymbol, Punctuation), nil}, {`"`, LiteralStringDouble, Push("simple-string")}, {"(?<!\\.)`", LiteralStringBacktick, Push("simple-backtick")}, {`%\{`, LiteralStringOther, Push("cb-intp-string")}, {`%[wi]\{`, LiteralStringOther, Push("cb-string")}, {`%r\{`, LiteralStringRegex, Push("cb-regex")}, {`%\[`, LiteralStringOther, Push("sb-intp-string")}, {`%[wi]\[`, LiteralStringOther, Push("sb-string")}, {`%r\[`, LiteralStringRegex, Push("sb-regex")}, {`%\(`, LiteralStringOther, Push("pa-intp-string")}, {`%[wi]\(`, LiteralStringOther, Push("pa-string")}, {`%r\(`, LiteralStringRegex, Push("pa-regex")}, {`%<`, LiteralStringOther, Push("ab-intp-string")}, {`%[wi]<`, LiteralStringOther, Push("ab-string")}, {`%r<`, LiteralStringRegex, Push("ab-regex")}, {`(%r([\W_]))((?:\\\2|(?!\2).)*)(\2[imsx]*)`, String, nil}, {`(%[wi]([\W_]))((?:\\\2|(?!\2).)*)(\2)`, String, nil}, {`(?<=[-+/*%=<>&!^|~,(])(\s*)(%([\t ])(?:(?:\\\3|(?!\3).)*)\3)`, ByGroups(Text, LiteralStringOther, None), nil}, {`^(\s*)(%([\t ])(?:(?:\\\3|(?!\3).)*)\3)`, ByGroups(Text, LiteralStringOther, None), nil}, {`(%([\[{(<]))((?:\\\2|(?!\2).)*)(\2)`, String, nil}, }, "simple-string": { Include("string-intp-escaped"), {`[^\\"#]+`, LiteralStringDouble, nil}, {`[\\#]`, LiteralStringDouble, nil}, {`"`, LiteralStringDouble, Pop(1)}, }, "simple-sym": { Include("string-escaped"), {`[^\\"#]+`, LiteralStringSymbol, nil}, {`[\\#]`, LiteralStringSymbol, nil}, {`"`, LiteralStringSymbol, Pop(1)}, }, "simple-backtick": { Include("string-intp-escaped"), {"[^\\\\`#]+", LiteralStringBacktick, nil}, {`[\\#]`, LiteralStringBacktick, nil}, {"`", LiteralStringBacktick, Pop(1)}, }, "cb-intp-string": { {`\\[\{]`, LiteralStringOther, nil}, {`\{`, LiteralStringOther, Push()}, {`\}`, LiteralStringOther, Pop(1)}, Include("string-intp-escaped"), {`[\\#{}]`, LiteralStringOther, nil}, {`[^\\#{}]+`, LiteralStringOther, nil}, }, "cb-string": { {`\\[\\{}]`, LiteralStringOther, nil}, {`\{`, LiteralStringOther, Push()}, {`\}`, LiteralStringOther, Pop(1)}, {`[\\#{}]`, LiteralStringOther, nil}, {`[^\\#{}]+`, LiteralStringOther, nil}, }, "cb-regex": { {`\\[\\{}]`, LiteralStringRegex, nil}, {`\{`, LiteralStringRegex, Push()}, {`\}[imsx]*`, LiteralStringRegex, Pop(1)}, Include("string-intp"), {`[\\#{}]`, LiteralStringRegex, nil}, {`[^\\#{}]+`, LiteralStringRegex, nil}, }, "sb-intp-string": { {`\\[\[]`, LiteralStringOther, nil}, {`\[`, LiteralStringOther, Push()}, {`\]`, LiteralStringOther, Pop(1)}, Include("string-intp-escaped"), {`[\\#\[\]]`, LiteralStringOther, nil}, {`[^\\#\[\]]+`, LiteralStringOther, nil}, }, "sb-string": { {`\\[\\\[\]]`, LiteralStringOther, nil}, {`\[`, LiteralStringOther, Push()}, {`\]`, LiteralStringOther, Pop(1)}, {`[\\#\[\]]`, LiteralStringOther, nil}, {`[^\\#\[\]]+`, LiteralStringOther, nil}, }, "sb-regex": { {`\\[\\\[\]]`, LiteralStringRegex, nil}, {`\[`, LiteralStringRegex, Push()}, {`\][imsx]*`, LiteralStringRegex, Pop(1)}, Include("string-intp"), {`[\\#\[\]]`, LiteralStringRegex, nil}, {`[^\\#\[\]]+`, LiteralStringRegex, nil}, }, "pa-intp-string": { {`\\[\(]`, LiteralStringOther, nil}, {`\(`, LiteralStringOther, Push()}, {`\)`, LiteralStringOther, Pop(1)}, Include("string-intp-escaped"), {`[\\#()]`, LiteralStringOther, nil}, {`[^\\#()]+`, LiteralStringOther, nil}, }, "pa-string": { {`\\[\\()]`, LiteralStringOther, nil}, {`\(`, LiteralStringOther, Push()}, {`\)`, LiteralStringOther, Pop(1)}, {`[\\#()]`, LiteralStringOther, nil}, {`[^\\#()]+`, LiteralStringOther, nil}, }, "pa-regex": { {`\\[\\()]`, LiteralStringRegex, nil}, {`\(`, LiteralStringRegex, Push()}, {`\)[imsx]*`, LiteralStringRegex, Pop(1)}, Include("string-intp"), {`[\\#()]`, LiteralStringRegex, nil}, {`[^\\#()]+`, LiteralStringRegex, nil}, }, "ab-intp-string": { {`\\[<]`, LiteralStringOther, nil}, {`<`, LiteralStringOther, Push()}, {`>`, LiteralStringOther, Pop(1)}, Include("string-intp-escaped"), {`[\\#<>]`, LiteralStringOther, nil}, {`[^\\#<>]+`, LiteralStringOther, nil}, }, "ab-string": { {`\\[\\<>]`, LiteralStringOther, nil}, {`<`, LiteralStringOther, Push()}, {`>`, LiteralStringOther, Pop(1)}, {`[\\#<>]`, LiteralStringOther, nil}, {`[^\\#<>]+`, LiteralStringOther, nil}, }, "ab-regex": { {`\\[\\<>]`, LiteralStringRegex, nil}, {`<`, LiteralStringRegex, Push()}, {`>[imsx]*`, LiteralStringRegex, Pop(1)}, Include("string-intp"), {`[\\#<>]`, LiteralStringRegex, nil}, {`[^\\#<>]+`, LiteralStringRegex, nil}, }, }, ))
Crystal lexer.
var Cython = Register(MustNewLexer( &Config{ Name: "Cython", Aliases: []string{"cython", "pyx", "pyrex"}, Filenames: []string{"*.pyx", "*.pxd", "*.pxi"}, MimeTypes: []string{"text/x-cython", "application/x-cython"}, }, Rules{ "root": { {`\n`, Text, nil}, {`^(\s*)("""(?:.|\n)*?""")`, ByGroups(Text, LiteralStringDoc), nil}, {`^(\s*)('''(?:.|\n)*?''')`, ByGroups(Text, LiteralStringDoc), nil}, {`[^\S\n]+`, Text, nil}, {`#.*$`, Comment, nil}, {`[]{}:(),;[]`, Punctuation, nil}, {`\\\n`, Text, nil}, {`\\`, Text, nil}, {`(in|is|and|or|not)\b`, OperatorWord, nil}, {`(<)([a-zA-Z0-9.?]+)(>)`, ByGroups(Punctuation, KeywordType, Punctuation), nil}, {`!=|==|<<|>>|[-~+/*%=<>&^|.?]`, Operator, nil}, {`(from)(\d+)(<=)(\s+)(<)(\d+)(:)`, ByGroups(Keyword, LiteralNumberInteger, Operator, Name, Operator, Name, Punctuation), nil}, Include("keywords"), {`(def|property)(\s+)`, ByGroups(Keyword, Text), Push("funcname")}, {`(cp?def)(\s+)`, ByGroups(Keyword, Text), Push("cdef")}, {`(cdef)(:)`, ByGroups(Keyword, Punctuation), nil}, {`(class|struct)(\s+)`, ByGroups(Keyword, Text), Push("classname")}, {`(from)(\s+)`, ByGroups(Keyword, Text), Push("fromimport")}, {`(c?import)(\s+)`, ByGroups(Keyword, Text), Push("import")}, Include("builtins"), Include("backtick"), {`(?:[rR]|[uU][rR]|[rR][uU])"""`, LiteralString, Push("tdqs")}, {`(?:[rR]|[uU][rR]|[rR][uU])'''`, LiteralString, Push("tsqs")}, {`(?:[rR]|[uU][rR]|[rR][uU])"`, LiteralString, Push("dqs")}, {`(?:[rR]|[uU][rR]|[rR][uU])'`, LiteralString, Push("sqs")}, {`[uU]?"""`, LiteralString, Combined("stringescape", "tdqs")}, {`[uU]?'''`, LiteralString, Combined("stringescape", "tsqs")}, {`[uU]?"`, LiteralString, Combined("stringescape", "dqs")}, {`[uU]?'`, LiteralString, Combined("stringescape", "sqs")}, Include("name"), Include("numbers"), }, "keywords": { {Words(``, `\b`, `assert`, `break`, `by`, `continue`, `ctypedef`, `del`, `elif`, `else`, `except`, `except?`, `exec`, `finally`, `for`, `fused`, `gil`, `global`, `if`, `include`, `lambda`, `nogil`, `pass`, `print`, `raise`, `return`, `try`, `while`, `yield`, `as`, `with`), Keyword, nil}, {`(DEF|IF|ELIF|ELSE)\b`, CommentPreproc, nil}, }, "builtins": { {Words(`(?<!\.)`, `\b`, `__import__`, `abs`, `all`, `any`, `apply`, `basestring`, `bin`, `bool`, `buffer`, `bytearray`, `bytes`, `callable`, `chr`, `classmethod`, `cmp`, `coerce`, `compile`, `complex`, `delattr`, `dict`, `dir`, `divmod`, `enumerate`, `eval`, `execfile`, `exit`, `file`, `filter`, `float`, `frozenset`, `getattr`, `globals`, `hasattr`, `hash`, `hex`, `id`, `input`, `int`, `intern`, `isinstance`, `issubclass`, `iter`, `len`, `list`, `locals`, `long`, `map`, `max`, `min`, `next`, `object`, `oct`, `open`, `ord`, `pow`, `property`, `range`, `raw_input`, `reduce`, `reload`, `repr`, `reversed`, `round`, `set`, `setattr`, `slice`, `sorted`, `staticmethod`, `str`, `sum`, `super`, `tuple`, `type`, `unichr`, `unicode`, `unsigned`, `vars`, `xrange`, `zip`), NameBuiltin, nil}, {`(?<!\.)(self|None|Ellipsis|NotImplemented|False|True|NULL)\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`, `Warning`, `ZeroDivisionError`), NameException, nil}, }, "numbers": { {`(\d+\.?\d*|\d*\.\d+)([eE][+-]?[0-9]+)?`, LiteralNumberFloat, nil}, {`0\d+`, LiteralNumberOct, nil}, {`0[xX][a-fA-F0-9]+`, LiteralNumberHex, nil}, {`\d+L`, LiteralNumberIntegerLong, nil}, {`\d+`, LiteralNumberInteger, nil}, }, "backtick": { {"`.*?`", LiteralStringBacktick, nil}, }, "name": { {`@\w+`, NameDecorator, nil}, {`[a-zA-Z_]\w*`, Name, nil}, }, "funcname": { {`[a-zA-Z_]\w*`, NameFunction, Pop(1)}, }, "cdef": { {`(public|readonly|extern|api|inline)\b`, KeywordReserved, nil}, {`(struct|enum|union|class)\b`, Keyword, nil}, {`([a-zA-Z_]\w*)(\s*)(?=[(:#=]|$)`, ByGroups(NameFunction, Text), Pop(1)}, {`([a-zA-Z_]\w*)(\s*)(,)`, ByGroups(NameFunction, Text, Punctuation), nil}, {`from\b`, Keyword, Pop(1)}, {`as\b`, Keyword, nil}, {`:`, Punctuation, Pop(1)}, {`(?=["\'])`, Text, Pop(1)}, {`[a-zA-Z_]\w*`, KeywordType, nil}, {`.`, Text, nil}, }, "classname": { {`[a-zA-Z_]\w*`, NameClass, Pop(1)}, }, "import": { {`(\s+)(as)(\s+)`, ByGroups(Text, Keyword, Text), nil}, {`[a-zA-Z_][\w.]*`, NameNamespace, nil}, {`(\s*)(,)(\s*)`, ByGroups(Text, Operator, Text), nil}, Default(Pop(1)), }, "fromimport": { {`(\s+)(c?import)\b`, ByGroups(Text, Keyword), Pop(1)}, {`[a-zA-Z_.][\w.]*`, NameNamespace, nil}, Default(Pop(1)), }, "stringescape": { {`\\([\\abfnrtv"\']|\n|N\{.*?\}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})`, LiteralStringEscape, nil}, }, "strings": { {`%(\([a-zA-Z0-9]+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[E-GXc-giorsux%]`, LiteralStringInterpol, nil}, {`[^\\\'"%\n]+`, LiteralString, nil}, {`[\'"\\]`, LiteralString, nil}, {`%`, LiteralString, nil}, }, "nl": { {`\n`, LiteralString, nil}, }, "dqs": { {`"`, LiteralString, Pop(1)}, {`\\\\|\\"|\\\n`, LiteralStringEscape, nil}, Include("strings"), }, "sqs": { {`'`, LiteralString, Pop(1)}, {`\\\\|\\'|\\\n`, LiteralStringEscape, nil}, Include("strings"), }, "tdqs": { {`"""`, LiteralString, Pop(1)}, Include("strings"), Include("nl"), }, "tsqs": { {`'''`, LiteralString, Pop(1)}, Include("strings"), Include("nl"), }, }, ))
Cython lexer.
var Dart = Register(MustNewLexer( &Config{ Name: "Dart", Aliases: []string{"dart"}, Filenames: []string{"*.dart"}, MimeTypes: []string{"text/x-dart"}, DotAll: true, }, Rules{ "root": { Include("string_literal"), {`#!(.*?)$`, CommentPreproc, nil}, {`\b(import|export)\b`, Keyword, Push("import_decl")}, {`\b(library|source|part of|part)\b`, Keyword, nil}, {`[^\S\n]+`, Text, nil}, {`//.*?\n`, CommentSingle, nil}, {`/\*.*?\*/`, CommentMultiline, nil}, {`\b(class)\b(\s+)`, ByGroups(KeywordDeclaration, Text), Push("class")}, {`\b(assert|break|case|catch|continue|default|do|else|finally|for|if|in|is|new|return|super|switch|this|throw|try|while)\b`, Keyword, nil}, {`\b(abstract|async|await|const|extends|factory|final|get|implements|native|operator|set|static|sync|typedef|var|with|yield)\b`, KeywordDeclaration, nil}, {`\b(bool|double|dynamic|int|num|Object|String|void)\b`, KeywordType, nil}, {`\b(false|null|true)\b`, KeywordConstant, nil}, {`[~!%^&*+=|?:<>/-]|as\b`, Operator, nil}, {`[a-zA-Z_$]\w*:`, NameLabel, nil}, {`[a-zA-Z_$]\w*`, Name, nil}, {`[(){}\[\],.;]`, Punctuation, nil}, {`0[xX][0-9a-fA-F]+`, LiteralNumberHex, nil}, {`\d+(\.\d*)?([eE][+-]?\d+)?`, LiteralNumber, nil}, {`\.\d+([eE][+-]?\d+)?`, LiteralNumber, nil}, {`\n`, Text, nil}, }, "class": { {`[a-zA-Z_$]\w*`, NameClass, Pop(1)}, }, "import_decl": { Include("string_literal"), {`\s+`, Text, nil}, {`\b(as|show|hide)\b`, Keyword, nil}, {`[a-zA-Z_$]\w*`, Name, nil}, {`\,`, Punctuation, nil}, {`\;`, Punctuation, Pop(1)}, }, "string_literal": { {`r"""([\w\W]*?)"""`, LiteralStringDouble, nil}, {`r'''([\w\W]*?)'''`, LiteralStringSingle, nil}, {`r"(.*?)"`, LiteralStringDouble, nil}, {`r'(.*?)'`, LiteralStringSingle, nil}, {`"""`, LiteralStringDouble, Push("string_double_multiline")}, {`'''`, LiteralStringSingle, Push("string_single_multiline")}, {`"`, LiteralStringDouble, Push("string_double")}, {`'`, LiteralStringSingle, Push("string_single")}, }, "string_common": { {`\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|u\{[0-9A-Fa-f]*\}|[a-z'\"$\\])`, LiteralStringEscape, nil}, {`(\$)([a-zA-Z_]\w*)`, ByGroups(LiteralStringInterpol, Name), nil}, {`(\$\{)(.*?)(\})`, ByGroups(LiteralStringInterpol, UsingSelf("root"), LiteralStringInterpol), nil}, }, "string_double": { {`"`, LiteralStringDouble, Pop(1)}, {`[^"$\\\n]+`, LiteralStringDouble, nil}, Include("string_common"), {`\$+`, LiteralStringDouble, nil}, }, "string_double_multiline": { {`"""`, LiteralStringDouble, Pop(1)}, {`[^"$\\]+`, LiteralStringDouble, nil}, Include("string_common"), {`(\$|\")+`, LiteralStringDouble, nil}, }, "string_single": { {`'`, LiteralStringSingle, Pop(1)}, {`[^'$\\\n]+`, LiteralStringSingle, nil}, Include("string_common"), {`\$+`, LiteralStringSingle, nil}, }, "string_single_multiline": { {`'''`, LiteralStringSingle, Pop(1)}, {`[^\'$\\]+`, LiteralStringSingle, nil}, Include("string_common"), {`(\$|\')+`, LiteralStringSingle, nil}, }, }, ))
Dart lexer.
var Diff = Register(MustNewLexer( &Config{ Name: "Diff", Aliases: []string{"diff", "udiff"}, EnsureNL: true, Filenames: []string{"*.diff", "*.patch"}, MimeTypes: []string{"text/x-diff", "text/x-patch"}, }, Rules{ "root": { {` .*\n`, Text, nil}, {`\+.*\n`, GenericInserted, nil}, {`-.*\n`, GenericDeleted, nil}, {`!.*\n`, GenericStrong, nil}, {`@.*\n`, GenericSubheading, nil}, {`([Ii]ndex|diff).*\n`, GenericHeading, nil}, {`=.*\n`, GenericHeading, nil}, {`.*\n`, Text, nil}, }, }, ))
Diff lexer.
var DjangoJinja = Register(MustNewLexer( &Config{ Name: "Django/Jinja", Aliases: []string{"django", "jinja"}, Filenames: []string{}, MimeTypes: []string{"application/x-django-templating", "application/x-jinja"}, DotAll: true, }, Rules{ "root": { {`[^{]+`, Other, nil}, {`\{\{`, CommentPreproc, Push("var")}, {`\{[*#].*?[*#]\}`, Comment, nil}, {`(\{%)(-?\s*)(comment)(\s*-?)(%\})(.*?)(\{%)(-?\s*)(endcomment)(\s*-?)(%\})`, ByGroups(CommentPreproc, Text, Keyword, Text, CommentPreproc, Comment, CommentPreproc, Text, Keyword, Text, CommentPreproc), nil}, {`(\{%)(-?\s*)(raw)(\s*-?)(%\})(.*?)(\{%)(-?\s*)(endraw)(\s*-?)(%\})`, ByGroups(CommentPreproc, Text, Keyword, Text, CommentPreproc, Text, CommentPreproc, Text, Keyword, Text, CommentPreproc), nil}, {`(\{%)(-?\s*)(filter)(\s+)([a-zA-Z_]\w*)`, ByGroups(CommentPreproc, Text, Keyword, Text, NameFunction), Push("block")}, {`(\{%)(-?\s*)([a-zA-Z_]\w*)`, ByGroups(CommentPreproc, Text, Keyword), Push("block")}, {`\{`, Other, nil}, }, "varnames": { {`(\|)(\s*)([a-zA-Z_]\w*)`, ByGroups(Operator, Text, NameFunction), nil}, {`(is)(\s+)(not)?(\s+)?([a-zA-Z_]\w*)`, ByGroups(Keyword, Text, Keyword, Text, NameFunction), nil}, {`(_|true|false|none|True|False|None)\b`, KeywordPseudo, nil}, {`(in|as|reversed|recursive|not|and|or|is|if|else|import|with(?:(?:out)?\s*context)?|scoped|ignore\s+missing)\b`, Keyword, nil}, {`(loop|block|super|forloop)\b`, NameBuiltin, nil}, {`[a-zA-Z_][\w-]*`, NameVariable, nil}, {`\.\w+`, NameVariable, nil}, {`:?"(\\\\|\\"|[^"])*"`, LiteralStringDouble, nil}, {`:?'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil}, {`([{}()\[\]+\-*/,:~]|[><=]=?)`, Operator, nil}, {`[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?`, LiteralNumber, nil}, }, "var": { {`\s+`, Text, nil}, {`(-?)(\}\})`, ByGroups(Text, CommentPreproc), Pop(1)}, Include("varnames"), }, "block": { {`\s+`, Text, nil}, {`(-?)(%\})`, ByGroups(Text, CommentPreproc), Pop(1)}, Include("varnames"), {`.`, Punctuation, nil}, }, }, ))
Django/Jinja lexer.
var Docker = Register(MustNewLexer( &Config{ Name: "Docker", Aliases: []string{"docker", "dockerfile"}, Filenames: []string{"Dockerfile", "*.docker"}, MimeTypes: []string{"text/x-dockerfile-config"}, CaseInsensitive: true, }, Rules{ "root": { {`^(ONBUILD)(\s+)((?:FROM|MAINTAINER|CMD|EXPOSE|ENV|ADD|ENTRYPOINT|VOLUME|WORKDIR))\b`, ByGroups(NameKeyword, TextWhitespace, Keyword), nil}, {`^((?:FROM|MAINTAINER|CMD|EXPOSE|ENV|ADD|ENTRYPOINT|VOLUME|WORKDIR))\b(.*)`, ByGroups(Keyword, LiteralString), nil}, {`#.*`, Comment, nil}, {`RUN`, Keyword, nil}, {`(.*\\\n)*.+`, Using(Bash, nil), nil}, }, }, ))
Docker lexer.
var Dtd = Register(MustNewLexer( &Config{ Name: "DTD", Aliases: []string{"dtd"}, Filenames: []string{"*.dtd"}, MimeTypes: []string{"application/xml-dtd"}, DotAll: true, }, Rules{ "root": { Include("common"), {`(<!ELEMENT)(\s+)(\S+)`, ByGroups(Keyword, Text, NameTag), Push("element")}, {`(<!ATTLIST)(\s+)(\S+)`, ByGroups(Keyword, Text, NameTag), Push("attlist")}, {`(<!ENTITY)(\s+)(\S+)`, ByGroups(Keyword, Text, NameEntity), Push("entity")}, {`(<!NOTATION)(\s+)(\S+)`, ByGroups(Keyword, Text, NameTag), Push("notation")}, {`(<!\[)([^\[\s]+)(\s*)(\[)`, ByGroups(Keyword, NameEntity, Text, Keyword), nil}, {`(<!DOCTYPE)(\s+)([^>\s]+)`, ByGroups(Keyword, Text, NameTag), nil}, {`PUBLIC|SYSTEM`, KeywordConstant, nil}, {`[\[\]>]`, Keyword, nil}, }, "common": { {`\s+`, Text, nil}, {`(%|&)[^;]*;`, NameEntity, nil}, {`<!--`, Comment, Push("comment")}, {`[(|)*,?+]`, Operator, nil}, {`"[^"]*"`, LiteralStringDouble, nil}, {`\'[^\']*\'`, LiteralStringSingle, nil}, }, "comment": { {`[^-]+`, Comment, nil}, {`-->`, Comment, Pop(1)}, {`-`, Comment, nil}, }, "element": { Include("common"), {`EMPTY|ANY|#PCDATA`, KeywordConstant, nil}, {`[^>\s|()?+*,]+`, NameTag, nil}, {`>`, Keyword, Pop(1)}, }, "attlist": { Include("common"), {`CDATA|IDREFS|IDREF|ID|NMTOKENS|NMTOKEN|ENTITIES|ENTITY|NOTATION`, KeywordConstant, nil}, {`#REQUIRED|#IMPLIED|#FIXED`, KeywordConstant, nil}, {`xml:space|xml:lang`, KeywordReserved, nil}, {`[^>\s|()?+*,]+`, NameAttribute, nil}, {`>`, Keyword, Pop(1)}, }, "entity": { Include("common"), {`SYSTEM|PUBLIC|NDATA`, KeywordConstant, nil}, {`[^>\s|()?+*,]+`, NameEntity, nil}, {`>`, Keyword, Pop(1)}, }, "notation": { Include("common"), {`SYSTEM|PUBLIC`, KeywordConstant, nil}, {`[^>\s|()?+*,]+`, NameAttribute, nil}, {`>`, Keyword, Pop(1)}, }, }, ))
Dtd lexer.
var Ebnf = Register(MustNewLexer( &Config{ Name: "EBNF", Aliases: []string{"ebnf"}, Filenames: []string{"*.ebnf"}, MimeTypes: []string{"text/x-ebnf"}, }, Rules{ "root": { Include("whitespace"), Include("comment_start"), Include("identifier"), {`=`, Operator, Push("production")}, }, "production": { Include("whitespace"), Include("comment_start"), Include("identifier"), {`"[^"]*"`, LiteralStringDouble, nil}, {`'[^']*'`, LiteralStringSingle, nil}, {`(\?[^?]*\?)`, NameEntity, nil}, {`[\[\]{}(),|]`, Punctuation, nil}, {`-`, Operator, nil}, {`;`, Punctuation, Pop(1)}, {`\.`, Punctuation, Pop(1)}, }, "whitespace": { {`\s+`, Text, nil}, }, "comment_start": { {`\(\*`, CommentMultiline, Push("comment")}, }, "comment": { {`[^*)]`, CommentMultiline, nil}, Include("comment_start"), {`\*\)`, CommentMultiline, Pop(1)}, {`[*)]`, CommentMultiline, nil}, }, "identifier": { {`([a-zA-Z][\w \-]*)`, Keyword, nil}, }, }, ))
Ebnf lexer.
var Elixir = Register(MustNewLexer( &Config{ Name: "Elixir", Aliases: []string{"elixir", "ex", "exs"}, Filenames: []string{"*.ex", "*.exs"}, MimeTypes: []string{"text/x-elixir"}, }, Rules{ "root": { {`\s+`, Text, nil}, {`#.*$`, CommentSingle, nil}, {`(\?)(\\x\{)([\da-fA-F]+)(\})`, ByGroups(LiteralStringChar, LiteralStringEscape, LiteralNumberHex, LiteralStringEscape), nil}, {`(\?)(\\x[\da-fA-F]{1,2})`, ByGroups(LiteralStringChar, LiteralStringEscape), nil}, {`(\?)(\\[abdefnrstv])`, ByGroups(LiteralStringChar, LiteralStringEscape), nil}, {`\?\\?.`, LiteralStringChar, nil}, {`:::`, LiteralStringSymbol, nil}, {`::`, Operator, nil}, {`:(?:\.\.\.|<<>>|%\{\}|%|\{\})`, LiteralStringSymbol, nil}, {"" /* 255 byte string literal not displayed */, LiteralStringSymbol, nil}, {`:"`, LiteralStringSymbol, Push("string_double_atom")}, {`:'`, LiteralStringSymbol, Push("string_single_atom")}, {"" /* 297 byte string literal not displayed */, ByGroups(LiteralStringSymbol, Punctuation), nil}, {`@(?:\.\.\.|[a-z_]\w*[!?]?)`, NameAttribute, nil}, {`(?:\.\.\.|[a-z_]\w*[!?]?)`, Name, nil}, {`(%?)([A-Z]\w*(?:\.[A-Z]\w*)*)`, ByGroups(Punctuation, NameClass), nil}, {`\<\<\<|\>\>\>|\|\|\||\&\&\&|\^\^\^|\~\~\~|\=\=\=|\!\=\=|\~\>\>|\<\~\>|\|\~\>|\<\|\>`, Operator, nil}, {`\=\=|\!\=|\<\=|\>\=|\&\&|\|\||\<\>|\+\+|\-\-|\|\>|\=\~|\-\>|\<\-|\||\.|\=|\~\>|\<\~`, Operator, nil}, {`\\\\|\<\<|\>\>|\=\>|\(|\)|\:|\;|\,|\[|\]`, Punctuation, nil}, {`&\d`, NameEntity, nil}, {`\<|\>|\+|\-|\*|\/|\!|\^|\&`, Operator, nil}, {`0b[01]+`, LiteralNumberBin, nil}, {`0o[0-7]+`, LiteralNumberOct, nil}, {`0x[\da-fA-F]+`, LiteralNumberHex, nil}, {`\d(_?\d)*\.\d(_?\d)*([eE][-+]?\d(_?\d)*)?`, LiteralNumberFloat, nil}, {`\d(_?\d)*`, LiteralNumberInteger, nil}, {`"""\s*`, LiteralStringHeredoc, Push("heredoc_double")}, {`'''\s*$`, LiteralStringHeredoc, Push("heredoc_single")}, {`"`, LiteralStringDouble, Push("string_double")}, {`'`, LiteralStringSingle, Push("string_single")}, Include("sigils"), {`%\{`, Punctuation, Push("map_key")}, {`\{`, Punctuation, Push("tuple")}, }, "heredoc_double": { {`^\s*"""`, LiteralStringHeredoc, Pop(1)}, Include("heredoc_interpol"), }, "heredoc_single": { {`^\s*'''`, LiteralStringHeredoc, Pop(1)}, Include("heredoc_interpol"), }, "heredoc_interpol": { {`[^#\\\n]+`, LiteralStringHeredoc, nil}, Include("escapes"), {`\\.`, LiteralStringHeredoc, nil}, {`\n+`, LiteralStringHeredoc, nil}, Include("interpol"), }, "heredoc_no_interpol": { {`[^\\\n]+`, LiteralStringHeredoc, nil}, {`\\.`, LiteralStringHeredoc, nil}, {`\n+`, LiteralStringHeredoc, nil}, }, "escapes": { {`(\\x\{)([\da-fA-F]+)(\})`, ByGroups(LiteralStringEscape, LiteralNumberHex, LiteralStringEscape), nil}, {`(\\x[\da-fA-F]{1,2})`, LiteralStringEscape, nil}, {`(\\[abdefnrstv])`, LiteralStringEscape, nil}, }, "interpol": { {`#\{`, LiteralStringInterpol, Push("interpol_string")}, }, "interpol_string": { {`\}`, LiteralStringInterpol, Pop(1)}, Include("root"), }, "map_key": { Include("root"), {`:`, Punctuation, Push("map_val")}, {`=>`, Punctuation, Push("map_val")}, {`\}`, Punctuation, Pop(1)}, }, "map_val": { Include("root"), {`,`, Punctuation, Pop(1)}, {`(?=\})`, Punctuation, Pop(1)}, }, "tuple": { Include("root"), {`\}`, Punctuation, Pop(1)}, }, "string_double": { {`[^#"\\]+`, LiteralStringDouble, nil}, Include("escapes"), {`\\.`, LiteralStringDouble, nil}, {`(")`, ByGroups(LiteralStringDouble), Pop(1)}, Include("interpol"), }, "string_single": { {`[^#'\\]+`, LiteralStringSingle, nil}, Include("escapes"), {`\\.`, LiteralStringSingle, nil}, {`(')`, ByGroups(LiteralStringSingle), Pop(1)}, Include("interpol"), }, "string_double_atom": { {`[^#"\\]+`, LiteralStringSymbol, nil}, Include("escapes"), {`\\.`, LiteralStringSymbol, nil}, {`(")`, ByGroups(LiteralStringSymbol), Pop(1)}, Include("interpol"), }, "string_single_atom": { {`[^#'\\]+`, LiteralStringSymbol, nil}, Include("escapes"), {`\\.`, LiteralStringSymbol, nil}, {`(')`, ByGroups(LiteralStringSymbol), Pop(1)}, Include("interpol"), }, "sigils": { {`(~[a-z])(""")`, ByGroups(LiteralStringOther, LiteralStringHeredoc), Push("triquot-end", "triquot-intp")}, {`(~[A-Z])(""")`, ByGroups(LiteralStringOther, LiteralStringHeredoc), Push("triquot-end", "triquot-no-intp")}, {`(~[a-z])(''')`, ByGroups(LiteralStringOther, LiteralStringHeredoc), Push("triapos-end", "triapos-intp")}, {`(~[A-Z])(''')`, ByGroups(LiteralStringOther, LiteralStringHeredoc), Push("triapos-end", "triapos-no-intp")}, {`~[a-z]\{`, LiteralStringOther, Push("cb-intp")}, {`~[A-Z]\{`, LiteralStringOther, Push("cb-no-intp")}, {`~[a-z]\[`, LiteralStringOther, Push("sb-intp")}, {`~[A-Z]\[`, LiteralStringOther, Push("sb-no-intp")}, {`~[a-z]\(`, LiteralStringOther, Push("pa-intp")}, {`~[A-Z]\(`, LiteralStringOther, Push("pa-no-intp")}, {`~[a-z]<`, LiteralStringOther, Push("ab-intp")}, {`~[A-Z]<`, LiteralStringOther, Push("ab-no-intp")}, {`~[a-z]/`, LiteralStringOther, Push("slas-intp")}, {`~[A-Z]/`, LiteralStringOther, Push("slas-no-intp")}, {`~[a-z]\|`, LiteralStringOther, Push("pipe-intp")}, {`~[A-Z]\|`, LiteralStringOther, Push("pipe-no-intp")}, {`~[a-z]"`, LiteralStringOther, Push("quot-intp")}, {`~[A-Z]"`, LiteralStringOther, Push("quot-no-intp")}, {`~[a-z]'`, LiteralStringOther, Push("apos-intp")}, {`~[A-Z]'`, LiteralStringOther, Push("apos-no-intp")}, }, "triquot-end": { {`[a-zA-Z]+`, LiteralStringOther, Pop(1)}, Default(Pop(1)), }, "triquot-intp": { {`^\s*"""`, LiteralStringHeredoc, Pop(1)}, Include("heredoc_interpol"), }, "triquot-no-intp": { {`^\s*"""`, LiteralStringHeredoc, Pop(1)}, Include("heredoc_no_interpol"), }, "triapos-end": { {`[a-zA-Z]+`, LiteralStringOther, Pop(1)}, Default(Pop(1)), }, "triapos-intp": { {`^\s*'''`, LiteralStringHeredoc, Pop(1)}, Include("heredoc_interpol"), }, "triapos-no-intp": { {`^\s*'''`, LiteralStringHeredoc, Pop(1)}, Include("heredoc_no_interpol"), }, "cb-intp": { {`[^#\}\\]+`, LiteralStringOther, nil}, Include("escapes"), {`\\.`, LiteralStringOther, nil}, {`\}[a-zA-Z]*`, LiteralStringOther, Pop(1)}, Include("interpol"), }, "cb-no-intp": { {`[^\}\\]+`, LiteralStringOther, nil}, {`\\.`, LiteralStringOther, nil}, {`\}[a-zA-Z]*`, LiteralStringOther, Pop(1)}, }, "sb-intp": { {`[^#\]\\]+`, LiteralStringOther, nil}, Include("escapes"), {`\\.`, LiteralStringOther, nil}, {`\][a-zA-Z]*`, LiteralStringOther, Pop(1)}, Include("interpol"), }, "sb-no-intp": { {`[^\]\\]+`, LiteralStringOther, nil}, {`\\.`, LiteralStringOther, nil}, {`\][a-zA-Z]*`, LiteralStringOther, Pop(1)}, }, "pa-intp": { {`[^#\)\\]+`, LiteralStringOther, nil}, Include("escapes"), {`\\.`, LiteralStringOther, nil}, {`\)[a-zA-Z]*`, LiteralStringOther, Pop(1)}, Include("interpol"), }, "pa-no-intp": { {`[^\)\\]+`, LiteralStringOther, nil}, {`\\.`, LiteralStringOther, nil}, {`\)[a-zA-Z]*`, LiteralStringOther, Pop(1)}, }, "ab-intp": { {`[^#>\\]+`, LiteralStringOther, nil}, Include("escapes"), {`\\.`, LiteralStringOther, nil}, {`>[a-zA-Z]*`, LiteralStringOther, Pop(1)}, Include("interpol"), }, "ab-no-intp": { {`[^>\\]+`, LiteralStringOther, nil}, {`\\.`, LiteralStringOther, nil}, {`>[a-zA-Z]*`, LiteralStringOther, Pop(1)}, }, "slas-intp": { {`[^#/\\]+`, LiteralStringOther, nil}, Include("escapes"), {`\\.`, LiteralStringOther, nil}, {`/[a-zA-Z]*`, LiteralStringOther, Pop(1)}, Include("interpol"), }, "slas-no-intp": { {`[^/\\]+`, LiteralStringOther, nil}, {`\\.`, LiteralStringOther, nil}, {`/[a-zA-Z]*`, LiteralStringOther, Pop(1)}, }, "pipe-intp": { {`[^#\|\\]+`, LiteralStringOther, nil}, Include("escapes"), {`\\.`, LiteralStringOther, nil}, {`\|[a-zA-Z]*`, LiteralStringOther, Pop(1)}, Include("interpol"), }, "pipe-no-intp": { {`[^\|\\]+`, LiteralStringOther, nil}, {`\\.`, LiteralStringOther, nil}, {`\|[a-zA-Z]*`, LiteralStringOther, Pop(1)}, }, "quot-intp": { {`[^#"\\]+`, LiteralStringOther, nil}, Include("escapes"), {`\\.`, LiteralStringOther, nil}, {`"[a-zA-Z]*`, LiteralStringOther, Pop(1)}, Include("interpol"), }, "quot-no-intp": { {`[^"\\]+`, LiteralStringOther, nil}, {`\\.`, LiteralStringOther, nil}, {`"[a-zA-Z]*`, LiteralStringOther, Pop(1)}, }, "apos-intp": { {`[^#'\\]+`, LiteralStringOther, nil}, Include("escapes"), {`\\.`, LiteralStringOther, nil}, {`'[a-zA-Z]*`, LiteralStringOther, Pop(1)}, Include("interpol"), }, "apos-no-intp": { {`[^'\\]+`, LiteralStringOther, nil}, {`\\.`, LiteralStringOther, nil}, {`'[a-zA-Z]*`, LiteralStringOther, Pop(1)}, }, }, ))
Elixir lexer.
var Elm = Register(MustNewLexer( &Config{ Name: "Elm", Aliases: []string{"elm"}, Filenames: []string{"*.elm"}, MimeTypes: []string{"text/x-elm"}, }, Rules{ "root": { {`\{-`, CommentMultiline, Push("comment")}, {`--.*`, CommentSingle, nil}, {`\s+`, Text, nil}, {`"`, LiteralString, Push("doublequote")}, {`^\s*module\s*`, KeywordNamespace, Push("imports")}, {`^\s*import\s*`, KeywordNamespace, Push("imports")}, {`\[glsl\|.*`, NameEntity, Push("shader")}, {Words(``, `\b`, `alias`, `as`, `case`, `else`, `if`, `import`, `in`, `let`, `module`, `of`, `port`, `then`, `type`, `where`), KeywordReserved, nil}, {`[A-Z]\w*`, KeywordType, nil}, {`^main `, KeywordReserved, nil}, {Words(`\(`, `\)`, `~`, `||`, `|>`, `|`, "`", `^`, `\`, `'`, `>>`, `>=`, `>`, `==`, `=`, `<~`, `<|`, `<=`, `<<`, `<-`, `<`, `::`, `:`, `/=`, `//`, `/`, `..`, `.`, `->`, `-`, `++`, `+`, `*`, `&&`, `%`), NameFunction, nil}, {Words(``, ``, `~`, `||`, `|>`, `|`, "`", `^`, `\`, `'`, `>>`, `>=`, `>`, `==`, `=`, `<~`, `<|`, `<=`, `<<`, `<-`, `<`, `::`, `:`, `/=`, `//`, `/`, `..`, `.`, `->`, `-`, `++`, `+`, `*`, `&&`, `%`), NameFunction, nil}, Include("numbers"), {`[a-z_][a-zA-Z_\']*`, NameVariable, nil}, {`[,()\[\]{}]`, Punctuation, nil}, }, "comment": { {`-(?!\})`, CommentMultiline, nil}, {`\{-`, CommentMultiline, Push("comment")}, {`[^-}]`, CommentMultiline, nil}, {`-\}`, CommentMultiline, Pop(1)}, }, "doublequote": { {`\\u[0-9a-fA-F]{4}`, LiteralStringEscape, nil}, {`\\[nrfvb\\"]`, LiteralStringEscape, nil}, {`[^"]`, LiteralString, nil}, {`"`, LiteralString, Pop(1)}, }, "imports": { {`\w+(\.\w+)*`, NameClass, Pop(1)}, }, "numbers": { {`_?\d+\.(?=\d+)`, LiteralNumberFloat, nil}, {`_?\d+`, LiteralNumberInteger, nil}, }, "shader": { {`\|(?!\])`, NameEntity, nil}, {`\|\]`, NameEntity, Pop(1)}, {`.*\n`, NameEntity, nil}, }, }, ))
Elm lexer.
var EmacsLisp = Register(TypeRemappingLexer(MustNewLexer( &Config{ Name: "EmacsLisp", Aliases: []string{"emacs", "elisp", "emacs-lisp"}, Filenames: []string{"*.el"}, MimeTypes: []string{"text/x-elisp", "application/x-elisp"}, }, Rules{ "root": { Default(Push("body")), }, "body": { {`\s+`, Text, nil}, {`;.*$`, CommentSingle, nil}, {`"`, LiteralString, Push("string")}, {`\?([^\\]|\\.)`, LiteralStringChar, nil}, {`:((?:\\.|[\w!$%&*+-/<=>?@^{}~|])(?:\\.|[\w!$%&*+-/<=>?@^{}~|]|[#.:])*)`, NameBuiltin, nil}, {`::((?:\\.|[\w!$%&*+-/<=>?@^{}~|])(?:\\.|[\w!$%&*+-/<=>?@^{}~|]|[#.:])*)`, LiteralStringSymbol, nil}, {`'((?:\\.|[\w!$%&*+-/<=>?@^{}~|])(?:\\.|[\w!$%&*+-/<=>?@^{}~|]|[#.:])*)`, LiteralStringSymbol, nil}, {`'`, Operator, nil}, {"`", Operator, nil}, {"[-+]?\\d+\\.?(?=[ \"()\\]\\'\\n,;`])", LiteralNumberInteger, nil}, {"[-+]?\\d+/\\d+(?=[ \"()\\]\\'\\n,;`])", LiteralNumber, nil}, {"[-+]?(\\d*\\.\\d+([defls][-+]?\\d+)?|\\d+(\\.\\d*)?[defls][-+]?\\d+)(?=[ \"()\\]\\'\\n,;`])", LiteralNumberFloat, nil}, {`\[|\]`, Punctuation, nil}, {`#:((?:\\.|[\w!$%&*+-/<=>?@^{}~|])(?:\\.|[\w!$%&*+-/<=>?@^{}~|]|[#.:])*)`, LiteralStringSymbol, nil}, {`#\^\^?`, Operator, nil}, {`#\'`, NameFunction, nil}, {`#[bB][+-]?[01]+(/[01]+)?`, LiteralNumberBin, nil}, {`#[oO][+-]?[0-7]+(/[0-7]+)?`, LiteralNumberOct, nil}, {`#[xX][+-]?[0-9a-fA-F]+(/[0-9a-fA-F]+)?`, LiteralNumberHex, nil}, {`#\d+r[+-]?[0-9a-zA-Z]+(/[0-9a-zA-Z]+)?`, LiteralNumber, nil}, {`#\d+=`, Operator, nil}, {`#\d+#`, Operator, nil}, {`(,@|,|\.|:)`, Operator, nil}, {"(t|nil)(?=[ \"()\\]\\'\\n,;`])", NameConstant, nil}, {`\*((?:\\.|[\w!$%&*+-/<=>?@^{}~|])(?:\\.|[\w!$%&*+-/<=>?@^{}~|]|[#.:])*)\*`, NameVariableGlobal, nil}, {`((?:\\.|[\w!$%&*+-/<=>?@^{}~|])(?:\\.|[\w!$%&*+-/<=>?@^{}~|]|[#.:])*)`, NameVariable, nil}, {`#\(`, Operator, Push("body")}, {`\(`, Punctuation, Push("body")}, {`\)`, Punctuation, Pop(1)}, }, "string": { {"[^\"\\\\`]+", LiteralString, nil}, {"`((?:\\\\.|[\\w!$%&*+-/<=>?@^{}~|])(?:\\\\.|[\\w!$%&*+-/<=>?@^{}~|]|[#.:])*)\\'", LiteralStringSymbol, nil}, {"`", LiteralString, nil}, {`\\.`, LiteralString, nil}, {`\\\n`, LiteralString, nil}, {`"`, LiteralString, Pop(1)}, }, }, ), TypeMapping{ {NameVariable, NameFunction, emacsBuiltinFunction}, {NameVariable, NameBuiltin, emacsSpecialForms}, {NameVariable, NameException, emacsErrorKeywords}, {NameVariable, NameBuiltin, append(emacsBuiltinFunctionHighlighted, emacsMacros...)}, {NameVariable, KeywordPseudo, emacsLambdaListKeywords}, }))
EmacsLisp lexer.
var Erlang = Register(MustNewLexer( &Config{ Name: "Erlang", Aliases: []string{"erlang"}, Filenames: []string{"*.erl", "*.hrl", "*.es", "*.escript"}, MimeTypes: []string{"text/x-erlang"}, }, Rules{ "root": { {`\s+`, Text, nil}, {`%.*\n`, Comment, nil}, {Words(``, `\b`, `after`, `begin`, `case`, `catch`, `cond`, `end`, `fun`, `if`, `let`, `of`, `query`, `receive`, `try`, `when`), Keyword, nil}, {Words(``, `\b`, `abs`, `append_element`, `apply`, `atom_to_list`, `binary_to_list`, `bitstring_to_list`, `binary_to_term`, `bit_size`, `bump_reductions`, `byte_size`, `cancel_timer`, `check_process_code`, `delete_module`, `demonitor`, `disconnect_node`, `display`, `element`, `erase`, `exit`, `float`, `float_to_list`, `fun_info`, `fun_to_list`, `function_exported`, `garbage_collect`, `get`, `get_keys`, `group_leader`, `hash`, `hd`, `integer_to_list`, `iolist_to_binary`, `iolist_size`, `is_atom`, `is_binary`, `is_bitstring`, `is_boolean`, `is_builtin`, `is_float`, `is_function`, `is_integer`, `is_list`, `is_number`, `is_pid`, `is_port`, `is_process_alive`, `is_record`, `is_reference`, `is_tuple`, `length`, `link`, `list_to_atom`, `list_to_binary`, `list_to_bitstring`, `list_to_existing_atom`, `list_to_float`, `list_to_integer`, `list_to_pid`, `list_to_tuple`, `load_module`, `localtime_to_universaltime`, `make_tuple`, `md5`, `md5_final`, `md5_update`, `memory`, `module_loaded`, `monitor`, `monitor_node`, `node`, `nodes`, `open_port`, `phash`, `phash2`, `pid_to_list`, `port_close`, `port_command`, `port_connect`, `port_control`, `port_call`, `port_info`, `port_to_list`, `process_display`, `process_flag`, `process_info`, `purge_module`, `put`, `read_timer`, `ref_to_list`, `register`, `resume_process`, `round`, `send`, `send_after`, `send_nosuspend`, `set_cookie`, `setelement`, `size`, `spawn`, `spawn_link`, `spawn_monitor`, `spawn_opt`, `split_binary`, `start_timer`, `statistics`, `suspend_process`, `system_flag`, `system_info`, `system_monitor`, `system_profile`, `term_to_binary`, `tl`, `trace`, `trace_delivered`, `trace_info`, `trace_pattern`, `trunc`, `tuple_size`, `tuple_to_list`, `universaltime_to_localtime`, `unlink`, `unregister`, `whereis`), NameBuiltin, nil}, {Words(``, `\b`, `and`, `andalso`, `band`, `bnot`, `bor`, `bsl`, `bsr`, `bxor`, `div`, `not`, `or`, `orelse`, `rem`, `xor`), OperatorWord, nil}, {`^-`, Punctuation, Push("directive")}, {`(\+\+?|--?|\*|/|<|>|/=|=:=|=/=|=<|>=|==?|<-|!|\?)`, Operator, nil}, {`"`, LiteralString, Push("string")}, {`<<`, NameLabel, nil}, {`>>`, NameLabel, nil}, {`((?:[a-z]\w*|'[^\n']*[^\\]'))(:)`, ByGroups(NameNamespace, Punctuation), nil}, {`(?:^|(?<=:))((?:[a-z]\w*|'[^\n']*[^\\]'))(\s*)(\()`, ByGroups(NameFunction, Text, Punctuation), nil}, {`[+-]?(?:[2-9]|[12][0-9]|3[0-6])#[0-9a-zA-Z]+`, LiteralNumberInteger, nil}, {`[+-]?\d+`, LiteralNumberInteger, nil}, {`[+-]?\d+.\d+`, LiteralNumberFloat, nil}, {`[]\[:_@\".{}()|;,]`, Punctuation, nil}, {`(?:[A-Z_]\w*)`, NameVariable, nil}, {`(?:[a-z]\w*|'[^\n']*[^\\]')`, Name, nil}, {`\?(?:(?:[A-Z_]\w*)|(?:[a-z]\w*|'[^\n']*[^\\]'))`, NameConstant, nil}, {`\$(?:(?:\\(?:[bdefnrstv\'"\\]|[0-7][0-7]?[0-7]?|(?:x[0-9a-fA-F]{2}|x\{[0-9a-fA-F]+\})|\^[a-zA-Z]))|\\[ %]|[^\\])`, LiteralStringChar, nil}, {`#(?:[a-z]\w*|'[^\n']*[^\\]')(:?\.(?:[a-z]\w*|'[^\n']*[^\\]'))?`, NameLabel, nil}, {`\A#!.+\n`, CommentHashbang, nil}, {`#\{`, Punctuation, Push("map_key")}, }, "string": { {`(?:\\(?:[bdefnrstv\'"\\]|[0-7][0-7]?[0-7]?|(?:x[0-9a-fA-F]{2}|x\{[0-9a-fA-F]+\})|\^[a-zA-Z]))`, LiteralStringEscape, nil}, {`"`, LiteralString, Pop(1)}, {`~[0-9.*]*[~#+BPWXb-ginpswx]`, LiteralStringInterpol, nil}, {`[^"\\~]+`, LiteralString, nil}, {`~`, LiteralString, nil}, }, "directive": { {`(define)(\s*)(\()((?:(?:[A-Z_]\w*)|(?:[a-z]\w*|'[^\n']*[^\\]')))`, ByGroups(NameEntity, Text, Punctuation, NameConstant), Pop(1)}, {`(record)(\s*)(\()((?:(?:[A-Z_]\w*)|(?:[a-z]\w*|'[^\n']*[^\\]')))`, ByGroups(NameEntity, Text, Punctuation, NameLabel), Pop(1)}, {`(?:[a-z]\w*|'[^\n']*[^\\]')`, NameEntity, Pop(1)}, }, "map_key": { Include("root"), {`=>`, Punctuation, Push("map_val")}, {`:=`, Punctuation, Push("map_val")}, {`\}`, Punctuation, Pop(1)}, }, "map_val": { Include("root"), {`,`, Punctuation, Pop(1)}, {`(?=\})`, Punctuation, Pop(1)}, }, }, ))
Erlang lexer.
var Factor = Register(MustNewLexer( &Config{ Name: "Factor", Aliases: []string{"factor"}, Filenames: []string{"*.factor"}, MimeTypes: []string{"text/x-factor"}, }, Rules{ "root": { {`#!.*$`, CommentPreproc, nil}, Default(Push("base")), }, "base": { {`\s+`, Text, nil}, {`((?:MACRO|MEMO|TYPED)?:[:]?)(\s+)(\S+)`, ByGroups(Keyword, Text, NameFunction), nil}, {`(M:[:]?)(\s+)(\S+)(\s+)(\S+)`, ByGroups(Keyword, Text, NameClass, Text, NameFunction), nil}, {`(C:)(\s+)(\S+)(\s+)(\S+)`, ByGroups(Keyword, Text, NameFunction, Text, NameClass), nil}, {`(GENERIC:)(\s+)(\S+)`, ByGroups(Keyword, Text, NameFunction), nil}, {`(HOOK:|GENERIC#)(\s+)(\S+)(\s+)(\S+)`, ByGroups(Keyword, Text, NameFunction, Text, NameFunction), nil}, {`\(\s`, NameFunction, Push("stackeffect")}, {`;\s`, Keyword, nil}, {`(USING:)(\s+)`, ByGroups(KeywordNamespace, Text), Push("vocabs")}, {`(USE:|UNUSE:|IN:|QUALIFIED:)(\s+)(\S+)`, ByGroups(KeywordNamespace, Text, NameNamespace), nil}, {`(QUALIFIED-WITH:)(\s+)(\S+)(\s+)(\S+)`, ByGroups(KeywordNamespace, Text, NameNamespace, Text, NameNamespace), nil}, {`(FROM:|EXCLUDE:)(\s+)(\S+)(\s+=>\s)`, ByGroups(KeywordNamespace, Text, NameNamespace, Text), Push("words")}, {`(RENAME:)(\s+)(\S+)(\s+)(\S+)(\s+=>\s+)(\S+)`, ByGroups(KeywordNamespace, Text, NameFunction, Text, NameNamespace, Text, NameFunction), nil}, {`(ALIAS:|TYPEDEF:)(\s+)(\S+)(\s+)(\S+)`, ByGroups(KeywordNamespace, Text, NameFunction, Text, NameFunction), nil}, {`(DEFER:|FORGET:|POSTPONE:)(\s+)(\S+)`, ByGroups(KeywordNamespace, Text, NameFunction), nil}, {`(TUPLE:|ERROR:)(\s+)(\S+)(\s+<\s+)(\S+)`, ByGroups(Keyword, Text, NameClass, Text, NameClass), Push("slots")}, {`(TUPLE:|ERROR:|BUILTIN:)(\s+)(\S+)`, ByGroups(Keyword, Text, NameClass), Push("slots")}, {`(MIXIN:|UNION:|INTERSECTION:)(\s+)(\S+)`, ByGroups(Keyword, Text, NameClass), nil}, {`(PREDICATE:)(\s+)(\S+)(\s+<\s+)(\S+)`, ByGroups(Keyword, Text, NameClass, Text, NameClass), nil}, {`(C:)(\s+)(\S+)(\s+)(\S+)`, ByGroups(Keyword, Text, NameFunction, Text, NameClass), nil}, {`(INSTANCE:)(\s+)(\S+)(\s+)(\S+)`, ByGroups(Keyword, Text, NameClass, Text, NameClass), nil}, {`(SLOT:)(\s+)(\S+)`, ByGroups(Keyword, Text, NameFunction), nil}, {`(SINGLETON:)(\s+)(\S+)`, ByGroups(Keyword, Text, NameClass), nil}, {`SINGLETONS:`, Keyword, Push("classes")}, {`(CONSTANT:|SYMBOL:|MAIN:|HELP:)(\s+)(\S+)`, ByGroups(Keyword, Text, NameFunction), nil}, {`SYMBOLS:\s`, Keyword, Push("words")}, {`SYNTAX:\s`, Keyword, nil}, {`ALIEN:\s`, Keyword, nil}, {`(STRUCT:)(\s+)(\S+)`, ByGroups(Keyword, Text, NameClass), nil}, {`(FUNCTION:)(\s+\S+\s+)(\S+)(\s+\(\s+[^)]+\)\s)`, ByGroups(KeywordNamespace, Text, NameFunction, Text), nil}, {`(FUNCTION-ALIAS:)(\s+)(\S+)(\s+\S+\s+)(\S+)(\s+\(\s+[^)]+\)\s)`, ByGroups(KeywordNamespace, Text, NameFunction, Text, NameFunction, Text), nil}, {`(?:<PRIVATE|PRIVATE>)\s`, KeywordNamespace, nil}, {`"""\s+(?:.|\n)*?\s+"""`, LiteralString, nil}, {`"(?:\\\\|\\"|[^"])*"`, LiteralString, nil}, {`\S+"\s+(?:\\\\|\\"|[^"])*"`, LiteralString, nil}, {`CHAR:\s+(?:\\[\\abfnrstv]|[^\\]\S*)\s`, LiteralStringChar, nil}, {`!\s+.*$`, Comment, nil}, {`#!\s+.*$`, Comment, nil}, {`/\*\s+(?:.|\n)*?\s\*/\s`, Comment, nil}, {`[tf]\s`, NameConstant, nil}, {`[\\$]\s+\S+`, NameConstant, nil}, {`M\\\s+\S+\s+\S+`, NameConstant, nil}, {`[+-]?(?:[\d,]*\d)?\.(?:\d([\d,]*\d)?)?(?:[eE][+-]?\d+)?\s`, LiteralNumber, nil}, {`[+-]?\d(?:[\d,]*\d)?(?:[eE][+-]?\d+)?\s`, LiteralNumber, nil}, {`0x[a-fA-F\d](?:[a-fA-F\d,]*[a-fA-F\d])?(?:p\d([\d,]*\d)?)?\s`, LiteralNumber, nil}, {`NAN:\s+[a-fA-F\d](?:[a-fA-F\d,]*[a-fA-F\d])?(?:p\d([\d,]*\d)?)?\s`, LiteralNumber, nil}, {`0b[01]+\s`, LiteralNumberBin, nil}, {`0o[0-7]+\s`, LiteralNumberOct, nil}, {`(?:\d([\d,]*\d)?)?\+\d(?:[\d,]*\d)?/\d(?:[\d,]*\d)?\s`, LiteralNumber, nil}, {`(?:\-\d([\d,]*\d)?)?\-\d(?:[\d,]*\d)?/\d(?:[\d,]*\d)?\s`, LiteralNumber, nil}, {`(?:deprecated|final|foldable|flushable|inline|recursive)\s`, Keyword, nil}, {Words(``, `\s`, `-rot`, `2bi`, `2bi@`, `2bi*`, `2curry`, `2dip`, `2drop`, `2dup`, `2keep`, `2nip`, `2over`, `2tri`, `2tri@`, `2tri*`, `3bi`, `3curry`, `3dip`, `3drop`, `3dup`, `3keep`, `3tri`, `4dip`, `4drop`, `4dup`, `4keep`, `<wrapper>`, `=`, `>boolean`, `clone`, `?`, `?execute`, `?if`, `and`, `assert`, `assert=`, `assert?`, `bi`, `bi-curry`, `bi-curry@`, `bi-curry*`, `bi@`, `bi*`, `boa`, `boolean`, `boolean?`, `both?`, `build`, `call`, `callstack`, `callstack>array`, `callstack?`, `clear`, `(clone)`, `compose`, `compose?`, `curry`, `curry?`, `datastack`, `die`, `dip`, `do`, `drop`, `dup`, `dupd`, `either?`, `eq?`, `equal?`, `execute`, `hashcode`, `hashcode*`, `identity-hashcode`, `identity-tuple`, `identity-tuple?`, `if`, `if*`, `keep`, `loop`, `most`, `new`, `nip`, `not`, `null`, `object`, `or`, `over`, `pick`, `prepose`, `retainstack`, `rot`, `same?`, `swap`, `swapd`, `throw`, `tri`, `tri-curry`, `tri-curry@`, `tri-curry*`, `tri@`, `tri*`, `tuple`, `tuple?`, `unless`, `unless*`, `until`, `when`, `when*`, `while`, `with`, `wrapper`, `wrapper?`, `xor`), NameBuiltin, nil}, {Words(``, `\s`, `2cache`, `<enum>`, `>alist`, `?at`, `?of`, `assoc`, `assoc-all?`, `assoc-any?`, `assoc-clone-like`, `assoc-combine`, `assoc-diff`, `assoc-diff!`, `assoc-differ`, `assoc-each`, `assoc-empty?`, `assoc-filter`, `assoc-filter!`, `assoc-filter-as`, `assoc-find`, `assoc-hashcode`, `assoc-intersect`, `assoc-like`, `assoc-map`, `assoc-map-as`, `assoc-partition`, `assoc-refine`, `assoc-size`, `assoc-stack`, `assoc-subset?`, `assoc-union`, `assoc-union!`, `assoc=`, `assoc>map`, `assoc?`, `at`, `at+`, `at*`, `cache`, `change-at`, `clear-assoc`, `delete-at`, `delete-at*`, `enum`, `enum?`, `extract-keys`, `inc-at`, `key?`, `keys`, `map>assoc`, `maybe-set-at`, `new-assoc`, `of`, `push-at`, `rename-at`, `set-at`, `sift-keys`, `sift-values`, `substitute`, `unzip`, `value-at`, `value-at*`, `value?`, `values`, `zip`), NameBuiltin, nil}, {Words(``, `\s`, `2cleave`, `2cleave>quot`, `3cleave`, `3cleave>quot`, `4cleave`, `4cleave>quot`, `alist>quot`, `call-effect`, `case`, `case-find`, `case>quot`, `cleave`, `cleave>quot`, `cond`, `cond>quot`, `deep-spread>quot`, `execute-effect`, `linear-case-quot`, `no-case`, `no-case?`, `no-cond`, `no-cond?`, `recursive-hashcode`, `shallow-spread>quot`, `spread`, `to-fixed-point`, `wrong-values`, `wrong-values?`), NameBuiltin, nil}, {Words(``, `\s`, `-`, `/`, `/f`, `/i`, `/mod`, `2/`, `2^`, `<`, `<=`, `<fp-nan>`, `>`, `>=`, `>bignum`, `>fixnum`, `>float`, `>integer`, `(all-integers?)`, `(each-integer)`, `(find-integer)`, `*`, `+`, `?1+`, `abs`, `align`, `all-integers?`, `bignum`, `bignum?`, `bit?`, `bitand`, `bitnot`, `bitor`, `bits>double`, `bits>float`, `bitxor`, `complex`, `complex?`, `denominator`, `double>bits`, `each-integer`, `even?`, `find-integer`, `find-last-integer`, `fixnum`, `fixnum?`, `float`, `float>bits`, `float?`, `fp-bitwise=`, `fp-infinity?`, `fp-nan-payload`, `fp-nan?`, `fp-qnan?`, `fp-sign`, `fp-snan?`, `fp-special?`, `if-zero`, `imaginary-part`, `integer`, `integer>fixnum`, `integer>fixnum-strict`, `integer?`, `log2`, `log2-expects-positive`, `log2-expects-positive?`, `mod`, `neg`, `neg?`, `next-float`, `next-power-of-2`, `number`, `number=`, `number?`, `numerator`, `odd?`, `out-of-fixnum-range`, `out-of-fixnum-range?`, `power-of-2?`, `prev-float`, `ratio`, `ratio?`, `rational`, `rational?`, `real`, `real-part`, `real?`, `recip`, `rem`, `sgn`, `shift`, `sq`, `times`, `u<`, `u<=`, `u>`, `u>=`, `unless-zero`, `unordered?`, `when-zero`, `zero?`), NameBuiltin, nil}, {Words(``, `\s`, `1sequence`, `2all?`, `2each`, `2map`, `2map-as`, `2map-reduce`, `2reduce`, `2selector`, `2sequence`, `3append`, `3append-as`, `3each`, `3map`, `3map-as`, `3sequence`, `4sequence`, `<repetition>`, `<reversed>`, `<slice>`, `?first`, `?last`, `?nth`, `?second`, `?set-nth`, `accumulate`, `accumulate!`, `accumulate-as`, `all?`, `any?`, `append`, `append!`, `append-as`, `assert-sequence`, `assert-sequence=`, `assert-sequence?`, `binary-reduce`, `bounds-check`, `bounds-check?`, `bounds-error`, `bounds-error?`, `but-last`, `but-last-slice`, `cartesian-each`, `cartesian-map`, `cartesian-product`, `change-nth`, `check-slice`, `check-slice-error`, `clone-like`, `collapse-slice`, `collector`, `collector-for`, `concat`, `concat-as`, `copy`, `count`, `cut`, `cut-slice`, `cut*`, `delete-all`, `delete-slice`, `drop-prefix`, `each`, `each-from`, `each-index`, `empty?`, `exchange`, `filter`, `filter!`, `filter-as`, `find`, `find-from`, `find-index`, `find-index-from`, `find-last`, `find-last-from`, `first`, `first2`, `first3`, `first4`, `flip`, `follow`, `fourth`, `glue`, `halves`, `harvest`, `head`, `head-slice`, `head-slice*`, `head*`, `head?`, `if-empty`, `immutable`, `immutable-sequence`, `immutable-sequence?`, `immutable?`, `index`, `index-from`, `indices`, `infimum`, `infimum-by`, `insert-nth`, `interleave`, `iota`, `iota-tuple`, `iota-tuple?`, `join`, `join-as`, `last`, `last-index`, `last-index-from`, `length`, `lengthen`, `like`, `longer`, `longer?`, `longest`, `map`, `map!`, `map-as`, `map-find`, `map-find-last`, `map-index`, `map-integers`, `map-reduce`, `map-sum`, `max-length`, `member-eq?`, `member?`, `midpoint@`, `min-length`, `mismatch`, `move`, `new-like`, `new-resizable`, `new-sequence`, `non-negative-integer-expected`, `non-negative-integer-expected?`, `nth`, `nths`, `pad-head`, `pad-tail`, `padding`, `partition`, `pop`, `pop*`, `prefix`, `prepend`, `prepend-as`, `produce`, `produce-as`, `product`, `push`, `push-all`, `push-either`, `push-if`, `reduce`, `reduce-index`, `remove`, `remove!`, `remove-eq`, `remove-eq!`, `remove-nth`, `remove-nth!`, `repetition`, `repetition?`, `replace-slice`, `replicate`, `replicate-as`, `rest`, `rest-slice`, `reverse`, `reverse!`, `reversed`, `reversed?`, `second`, `selector`, `selector-for`, `sequence`, `sequence-hashcode`, `sequence=`, `sequence?`, `set-first`, `set-fourth`, `set-last`, `set-length`, `set-nth`, `set-second`, `set-third`, `short`, `shorten`, `shorter`, `shorter?`, `shortest`, `sift`, `slice`, `slice-error`, `slice-error?`, `slice?`, `snip`, `snip-slice`, `start`, `start*`, `subseq`, `subseq?`, `suffix`, `suffix!`, `sum`, `sum-lengths`, `supremum`, `supremum-by`, `surround`, `tail`, `tail-slice`, `tail-slice*`, `tail*`, `tail?`, `third`, `trim`, `trim-head`, `trim-head-slice`, `trim-slice`, `trim-tail`, `trim-tail-slice`, `unclip`, `unclip-last`, `unclip-last-slice`, `unclip-slice`, `unless-empty`, `virtual-exemplar`, `virtual-sequence`, `virtual-sequence?`, `virtual@`, `when-empty`), NameBuiltin, nil}, {Words(``, `\s`, `+@`, `change`, `change-global`, `counter`, `dec`, `get`, `get-global`, `global`, `inc`, `init-namespaces`, `initialize`, `is-global`, `make-assoc`, `namespace`, `namestack`, `off`, `on`, `set`, `set-global`, `set-namestack`, `toggle`, `with-global`, `with-scope`, `with-variable`, `with-variables`), NameBuiltin, nil}, {Words(``, `\s`, `1array`, `2array`, `3array`, `4array`, `<array>`, `>array`, `array`, `array?`, `pair`, `pair?`, `resize-array`), NameBuiltin, nil}, {Words(``, `\s`, `(each-stream-block-slice)`, `(each-stream-block)`, `(stream-contents-by-block)`, `(stream-contents-by-element)`, `(stream-contents-by-length-or-block)`, `(stream-contents-by-length)`, `+byte+`, `+character+`, `bad-seek-type`, `bad-seek-type?`, `bl`, `contents`, `each-block`, `each-block-size`, `each-block-slice`, `each-line`, `each-morsel`, `each-stream-block`, `each-stream-block-slice`, `each-stream-line`, `error-stream`, `flush`, `input-stream`, `input-stream?`, `invalid-read-buffer`, `invalid-read-buffer?`, `lines`, `nl`, `output-stream`, `output-stream?`, `print`, `read`, `read-into`, `read-partial`, `read-partial-into`, `read-until`, `read1`, `readln`, `seek-absolute`, `seek-absolute?`, `seek-end`, `seek-end?`, `seek-input`, `seek-output`, `seek-relative`, `seek-relative?`, `stream-bl`, `stream-contents`, `stream-contents*`, `stream-copy`, `stream-copy*`, `stream-element-type`, `stream-flush`, `stream-length`, `stream-lines`, `stream-nl`, `stream-print`, `stream-read`, `stream-read-into`, `stream-read-partial`, `stream-read-partial-into`, `stream-read-partial-unsafe`, `stream-read-unsafe`, `stream-read-until`, `stream-read1`, `stream-readln`, `stream-seek`, `stream-seekable?`, `stream-tell`, `stream-write`, `stream-write1`, `tell-input`, `tell-output`, `with-error-stream`, `with-error-stream*`, `with-error>output`, `with-input-output+error-streams`, `with-input-output+error-streams*`, `with-input-stream`, `with-input-stream*`, `with-output-stream`, `with-output-stream*`, `with-output>error`, `with-output+error-stream`, `with-output+error-stream*`, `with-streams`, `with-streams*`, `write`, `write1`), NameBuiltin, nil}, {Words(``, `\s`, `1string`, `<string>`, `>string`, `resize-string`, `string`, `string?`), NameBuiltin, nil}, {Words(``, `\s`, `1vector`, `<vector>`, `>vector`, `?push`, `vector`, `vector?`), NameBuiltin, nil}, {Words(``, `\s`, `<condition>`, `<continuation>`, `<restart>`, `attempt-all`, `attempt-all-error`, `attempt-all-error?`, `callback-error-hook`, `callcc0`, `callcc1`, `cleanup`, `compute-restarts`, `condition`, `condition?`, `continuation`, `continuation?`, `continue`, `continue-restart`, `continue-with`, `current-continuation`, `error`, `error-continuation`, `error-in-thread`, `error-thread`, `ifcc`, `ignore-errors`, `in-callback?`, `original-error`, `recover`, `restart`, `restart?`, `restarts`, `rethrow`, `rethrow-restarts`, `return`, `return-continuation`, `thread-error-hook`, `throw-continue`, `throw-restarts`, `with-datastack`, `with-return`), NameBuiltin, nil}, {`\S+`, Text, nil}, }, "stackeffect": { {`\s+`, Text, nil}, {`\(\s+`, NameFunction, Push("stackeffect")}, {`\)\s`, NameFunction, Pop(1)}, {`--\s`, NameFunction, nil}, {`\S+`, NameVariable, nil}, }, "slots": { {`\s+`, Text, nil}, {`;\s`, Keyword, Pop(1)}, {`(\{\s+)(\S+)(\s+[^}]+\s+\}\s)`, ByGroups(Text, NameVariable, Text), nil}, {`\S+`, NameVariable, nil}, }, "vocabs": { {`\s+`, Text, nil}, {`;\s`, Keyword, Pop(1)}, {`\S+`, NameNamespace, nil}, }, "classes": { {`\s+`, Text, nil}, {`;\s`, Keyword, Pop(1)}, {`\S+`, NameClass, nil}, }, "words": { {`\s+`, Text, nil}, {`;\s`, Keyword, Pop(1)}, {`\S+`, NameFunction, nil}, }, }, ))
Factor lexer.
var Fallback chroma.Lexer = chroma.MustNewLexer(&chroma.Config{ Name: "fallback", Filenames: []string{"*"}, }, chroma.Rules{ "root": []chroma.Rule{ {`.+`, chroma.Text, nil}, {`\n`, chroma.Text, nil}, }, })
Fallback lexer if no other is found.
var Fish = Register(MustNewLexer( &Config{ Name: "Fish", Aliases: []string{"fish", "fishshell"}, Filenames: []string{"*.fish", "*.load"}, MimeTypes: []string{"application/x-fish"}, }, Rules{ "root": { Include("basic"), Include("data"), Include("interp"), }, "interp": { {`\$\(\(`, Keyword, Push("math")}, {`\(`, Keyword, Push("paren")}, {`\$#?(\w+|.)`, NameVariable, nil}, }, "basic": { {"" /* 146 byte string literal not displayed */, ByGroups(Keyword, Text), nil}, {"" /* 414 byte string literal not displayed */, NameBuiltin, nil}, {`#.*\n`, Comment, nil}, {`\\[\w\W]`, LiteralStringEscape, nil}, {`(\b\w+)(\s*)(=)`, ByGroups(NameVariable, Text, Operator), nil}, {`[\[\]()=]`, Operator, nil}, {`<<-?\s*(\'?)\\?(\w+)[\w\W]+?\2`, LiteralString, nil}, }, "data": { {`(?s)\$?"(\\\\|\\[0-7]+|\\.|[^"\\$])*"`, LiteralStringDouble, nil}, {`"`, LiteralStringDouble, Push("string")}, {`(?s)\$'(\\\\|\\[0-7]+|\\.|[^'\\])*'`, LiteralStringSingle, nil}, {`(?s)'.*?'`, LiteralStringSingle, nil}, {`;`, Punctuation, nil}, {`&|\||\^|<|>`, Operator, nil}, {`\s+`, Text, nil}, {`\d+(?= |\Z)`, LiteralNumber, nil}, {"[^=\\s\\[\\]{}()$\"\\'`\\\\<&|;]+", Text, nil}, }, "string": { {`"`, LiteralStringDouble, Pop(1)}, {`(?s)(\\\\|\\[0-7]+|\\.|[^"\\$])+`, LiteralStringDouble, nil}, Include("interp"), }, "paren": { {`\)`, Keyword, Pop(1)}, Include("root"), }, "math": { {`\)\)`, Keyword, Pop(1)}, {`[-+*/%^|&]|\*\*|\|\|`, Operator, nil}, {`\d+#\d+`, LiteralNumber, nil}, {`\d+#(?! )`, LiteralNumber, nil}, {`\d+`, LiteralNumber, nil}, Include("root"), }, }, ))
Fish lexer.
var Forth = Register(MustNewLexer( &Config{ Name: "Forth", Aliases: []string{"forth"}, Filenames: []string{"*.frt", "*.fs"}, MimeTypes: []string{"application/x-forth"}, CaseInsensitive: true, }, Rules{ "root": { {`\s+`, Text, nil}, {`\\.*?\n`, CommentSingle, nil}, {`\([\s].*?\)`, CommentSingle, nil}, {`(:|variable|constant|value|buffer:)(\s+)`, ByGroups(KeywordNamespace, Text), Push("worddef")}, {`([.sc]")(\s+?)`, ByGroups(LiteralString, Text), Push("stringdef")}, {"" /* 2419 byte string literal not displayed */, Keyword, nil}, {`(\$[0-9A-F]+)`, LiteralNumberHex, nil}, {`(\#|%|&|\-|\+)?[0-9]+`, LiteralNumberInteger, nil}, {`(\#|%|&|\-|\+)?[0-9.]+`, KeywordType, nil}, {"" /* 170 byte string literal not displayed */, NameConstant, nil}, {"" /* 180 byte string literal not displayed */, NameDecorator, nil}, {`(Evalue|Rvalue|Uvalue|Edefer|Rdefer|Udefer)(\s+)`, ByGroups(KeywordNamespace, Text), Push("worddef")}, {`[^\s]+(?=[\s])`, NameFunction, nil}, }, "worddef": { {`\S+`, NameClass, Pop(1)}, }, "stringdef": { {`[^"]+`, LiteralString, Pop(1)}, }, }, ))
Forth lexer.
var Fortran = Register(MustNewLexer( &Config{ Name: "Fortran", Aliases: []string{"fortran"}, Filenames: []string{"*.f03", "*.f90", "*.F03", "*.F90"}, MimeTypes: []string{"text/x-fortran"}, CaseInsensitive: true, }, Rules{ "root": { {`^#.*\n`, CommentPreproc, nil}, {`!.*\n`, Comment, nil}, Include("strings"), Include("core"), {`[a-z][\w$]*`, Name, nil}, Include("nums"), {`[\s]+`, Text, nil}, }, "core": { {Words(`\b`, `\s*\b`, `ABSTRACT`, `ACCEPT`, `ALL`, `ALLSTOP`, `ALLOCATABLE`, `ALLOCATE`, `ARRAY`, `ASSIGN`, `ASSOCIATE`, `ASYNCHRONOUS`, `BACKSPACE`, `BIND`, `BLOCK`, `BLOCKDATA`, `BYTE`, `CALL`, `CASE`, `CLASS`, `CLOSE`, `CODIMENSION`, `COMMON`, `CONCURRRENT`, `CONTIGUOUS`, `CONTAINS`, `CONTINUE`, `CRITICAL`, `CYCLE`, `DATA`, `DEALLOCATE`, `DECODE`, `DEFERRED`, `DIMENSION`, `DO`, `ELEMENTAL`, `ELSE`, `ENCODE`, `END`, `ENTRY`, `ENUM`, `ENUMERATOR`, `EQUIVALENCE`, `EXIT`, `EXTENDS`, `EXTERNAL`, `EXTRINSIC`, `FILE`, `FINAL`, `FORALL`, `FORMAT`, `FUNCTION`, `GENERIC`, `GOTO`, `IF`, `IMAGES`, `IMPLICIT`, `IMPORT`, `IMPURE`, `INCLUDE`, `INQUIRE`, `INTENT`, `INTERFACE`, `INTRINSIC`, `IS`, `LOCK`, `MEMORY`, `MODULE`, `NAMELIST`, `NULLIFY`, `NONE`, `NON_INTRINSIC`, `NON_OVERRIDABLE`, `NOPASS`, `OPEN`, `OPTIONAL`, `OPTIONS`, `PARAMETER`, `PASS`, `PAUSE`, `POINTER`, `PRINT`, `PRIVATE`, `PROGRAM`, `PROCEDURE`, `PROTECTED`, `PUBLIC`, `PURE`, `READ`, `RECURSIVE`, `RESULT`, `RETURN`, `REWIND`, `SAVE`, `SELECT`, `SEQUENCE`, `STOP`, `SUBMODULE`, `SUBROUTINE`, `SYNC`, `SYNCALL`, `SYNCIMAGES`, `SYNCMEMORY`, `TARGET`, `THEN`, `TYPE`, `UNLOCK`, `USE`, `VALUE`, `VOLATILE`, `WHERE`, `WRITE`, `WHILE`), Keyword, nil}, {Words(`\b`, `\s*\b`, `CHARACTER`, `COMPLEX`, `DOUBLE PRECISION`, `DOUBLE COMPLEX`, `INTEGER`, `LOGICAL`, `REAL`, `C_INT`, `C_SHORT`, `C_LONG`, `C_LONG_LONG`, `C_SIGNED_CHAR`, `C_SIZE_T`, `C_INT8_T`, `C_INT16_T`, `C_INT32_T`, `C_INT64_T`, `C_INT_LEAST8_T`, `C_INT_LEAST16_T`, `C_INT_LEAST32_T`, `C_INT_LEAST64_T`, `C_INT_FAST8_T`, `C_INT_FAST16_T`, `C_INT_FAST32_T`, `C_INT_FAST64_T`, `C_INTMAX_T`, `C_INTPTR_T`, `C_FLOAT`, `C_DOUBLE`, `C_LONG_DOUBLE`, `C_FLOAT_COMPLEX`, `C_DOUBLE_COMPLEX`, `C_LONG_DOUBLE_COMPLEX`, `C_BOOL`, `C_CHAR`, `C_PTR`, `C_FUNPTR`), KeywordType, nil}, {`(\*\*|\*|\+|-|\/|<|>|<=|>=|==|\/=|=)`, Operator, nil}, {`(::)`, KeywordDeclaration, nil}, {`[()\[\],:&%;.]`, Punctuation, nil}, {Words(`\b`, `\s*\b`, `Abort`, `Abs`, `Access`, `AChar`, `ACos`, `ACosH`, `AdjustL`, `AdjustR`, `AImag`, `AInt`, `Alarm`, `All`, `Allocated`, `ALog`, `AMax`, `AMin`, `AMod`, `And`, `ANInt`, `Any`, `ASin`, `ASinH`, `Associated`, `ATan`, `ATanH`, `Atomic_Define`, `Atomic_Ref`, `BesJ`, `BesJN`, `Bessel_J0`, `Bessel_J1`, `Bessel_JN`, `Bessel_Y0`, `Bessel_Y1`, `Bessel_YN`, `BesY`, `BesYN`, `BGE`, `BGT`, `BLE`, `BLT`, `Bit_Size`, `BTest`, `CAbs`, `CCos`, `Ceiling`, `CExp`, `Char`, `ChDir`, `ChMod`, `CLog`, `Cmplx`, `Command_Argument_Count`, `Complex`, `Conjg`, `Cos`, `CosH`, `Count`, `CPU_Time`, `CShift`, `CSin`, `CSqRt`, `CTime`, `C_Loc`, `C_Associated`, `C_Null_Ptr`, `C_Null_Funptr`, `C_F_Pointer`, `C_F_ProcPointer`, `C_Null_Char`, `C_Alert`, `C_Backspace`, `C_Form_Feed`, `C_FunLoc`, `C_Sizeof`, `C_New_Line`, `C_Carriage_Return`, `C_Horizontal_Tab`, `C_Vertical_Tab`, `DAbs`, `DACos`, `DASin`, `DATan`, `Date_and_Time`, `DbesJ`, `DbesJN`, `DbesY`, `DbesYN`, `Dble`, `DCos`, `DCosH`, `DDiM`, `DErF`, `DErFC`, `DExp`, `Digits`, `DiM`, `DInt`, `DLog`, `DMax`, `DMin`, `DMod`, `DNInt`, `Dot_Product`, `DProd`, `DSign`, `DSinH`, `DShiftL`, `DShiftR`, `DSin`, `DSqRt`, `DTanH`, `DTan`, `DTime`, `EOShift`, `Epsilon`, `ErF`, `ErFC`, `ErFC_Scaled`, `ETime`, `Execute_Command_Line`, `Exit`, `Exp`, `Exponent`, `Extends_Type_Of`, `FDate`, `FGet`, `FGetC`, `FindLoc`, `Float`, `Floor`, `Flush`, `FNum`, `FPutC`, `FPut`, `Fraction`, `FSeek`, `FStat`, `FTell`, `Gamma`, `GError`, `GetArg`, `Get_Command`, `Get_Command_Argument`, `Get_Environment_Variable`, `GetCWD`, `GetEnv`, `GetGId`, `GetLog`, `GetPId`, `GetUId`, `GMTime`, `HostNm`, `Huge`, `Hypot`, `IAbs`, `IAChar`, `IAll`, `IAnd`, `IAny`, `IArgC`, `IBClr`, `IBits`, `IBSet`, `IChar`, `IDate`, `IDiM`, `IDInt`, `IDNInt`, `IEOr`, `IErrNo`, `IFix`, `Imag`, `ImagPart`, `Image_Index`, `Index`, `Int`, `IOr`, `IParity`, `IRand`, `IsaTty`, `IShft`, `IShftC`, `ISign`, `Iso_C_Binding`, `Is_Contiguous`, `Is_Iostat_End`, `Is_Iostat_Eor`, `ITime`, `Kill`, `Kind`, `LBound`, `LCoBound`, `Len`, `Len_Trim`, `LGe`, `LGt`, `Link`, `LLe`, `LLt`, `LnBlnk`, `Loc`, `Log`, `Log_Gamma`, `Logical`, `Long`, `LShift`, `LStat`, `LTime`, `MaskL`, `MaskR`, `MatMul`, `Max`, `MaxExponent`, `MaxLoc`, `MaxVal`, `MClock`, `Merge`, `Merge_Bits`, `Move_Alloc`, `Min`, `MinExponent`, `MinLoc`, `MinVal`, `Mod`, `Modulo`, `MvBits`, `Nearest`, `New_Line`, `NInt`, `Norm2`, `Not`, `Null`, `Num_Images`, `Or`, `Pack`, `Parity`, `PError`, `Precision`, `Present`, `Product`, `Radix`, `Rand`, `Random_Number`, `Random_Seed`, `Range`, `Real`, `RealPart`, `Rename`, `Repeat`, `Reshape`, `RRSpacing`, `RShift`, `Same_Type_As`, `Scale`, `Scan`, `Second`, `Selected_Char_Kind`, `Selected_Int_Kind`, `Selected_Real_Kind`, `Set_Exponent`, `Shape`, `ShiftA`, `ShiftL`, `ShiftR`, `Short`, `Sign`, `Signal`, `SinH`, `Sin`, `Sleep`, `Sngl`, `Spacing`, `Spread`, `SqRt`, `SRand`, `Stat`, `Storage_Size`, `Sum`, `SymLnk`, `System`, `System_Clock`, `Tan`, `TanH`, `Time`, `This_Image`, `Tiny`, `TrailZ`, `Transfer`, `Transpose`, `Trim`, `TtyNam`, `UBound`, `UCoBound`, `UMask`, `Unlink`, `Unpack`, `Verify`, `XOr`, `ZAbs`, `ZCos`, `ZExp`, `ZLog`, `ZSin`, `ZSqRt`), NameBuiltin, nil}, {`\.(true|false)\.`, NameBuiltin, nil}, {`\.(eq|ne|lt|le|gt|ge|not|and|or|eqv|neqv)\.`, OperatorWord, nil}, }, "strings": { {`(?s)"(\\\\|\\[0-7]+|\\.|[^"\\])*"`, LiteralStringDouble, nil}, {`(?s)'(\\\\|\\[0-7]+|\\.|[^'\\])*'`, LiteralStringSingle, nil}, }, "nums": { {`\d+(?![.e])(_[a-z]\w+)?`, LiteralNumberInteger, nil}, {`[+-]?\d*\.\d+([ed][-+]?\d+)?(_[a-z]\w+)?`, LiteralNumberFloat, nil}, {`[+-]?\d+\.\d*([ed][-+]?\d+)?(_[a-z]\w+)?`, LiteralNumberFloat, nil}, }, }, ))
Fortran lexer.
var Fsharp = Register(MustNewLexer( &Config{ Name: "FSharp", Aliases: []string{"fsharp"}, Filenames: []string{"*.fs", "*.fsi"}, MimeTypes: []string{"text/x-fsharp"}, }, Rules{ "escape-sequence": { {`\\[\\"\'ntbrafv]`, LiteralStringEscape, nil}, {`\\[0-9]{3}`, LiteralStringEscape, nil}, {`\\u[0-9a-fA-F]{4}`, LiteralStringEscape, nil}, {`\\U[0-9a-fA-F]{8}`, LiteralStringEscape, nil}, }, "root": { {`\s+`, Text, nil}, {`\(\)|\[\]`, NameBuiltinPseudo, nil}, {`\b(?<!\.)([A-Z][\w\']*)(?=\s*\.)`, NameNamespace, Push("dotted")}, {`\b([A-Z][\w\']*)`, Name, nil}, {`///.*?\n`, LiteralStringDoc, nil}, {`//.*?\n`, CommentSingle, nil}, {`\(\*(?!\))`, Comment, Push("comment")}, {`@"`, LiteralString, Push("lstring")}, {`"""`, LiteralString, Push("tqs")}, {`"`, LiteralString, Push("string")}, {`\b(open|module)(\s+)([\w.]+)`, ByGroups(Keyword, Text, NameNamespace), nil}, {`\b(let!?)(\s+)(\w+)`, ByGroups(Keyword, Text, NameVariable), nil}, {`\b(type)(\s+)(\w+)`, ByGroups(Keyword, Text, NameClass), nil}, {`\b(member|override)(\s+)(\w+)(\.)(\w+)`, ByGroups(Keyword, Text, Name, Punctuation, NameFunction), nil}, {"" /* 609 byte string literal not displayed */, Keyword, nil}, {"``([^`\\n\\r\\t]|`[^`\\n\\r\\t])+``", Name, nil}, {"" /* 157 byte string literal not displayed */, Operator, nil}, {`([=<>@^|&+\*/$%-]|[!?~])?[!$%&*+\./:<=>?@^|~-]`, Operator, nil}, {`\b(and|or|not)\b`, OperatorWord, nil}, {"" /* 165 byte string literal not displayed */, KeywordType, nil}, {`#[ \t]*(if|endif|else|line|nowarn|light|\d+)\b.*?\n`, CommentPreproc, nil}, {`[^\W\d][\w']*`, Name, nil}, {`\d[\d_]*[uU]?[yslLnQRZINGmM]?`, LiteralNumberInteger, nil}, {`0[xX][\da-fA-F][\da-fA-F_]*[uU]?[yslLn]?[fF]?`, LiteralNumberHex, nil}, {`0[oO][0-7][0-7_]*[uU]?[yslLn]?`, LiteralNumberOct, nil}, {`0[bB][01][01_]*[uU]?[yslLn]?`, LiteralNumberBin, nil}, {`-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)[fFmM]?`, LiteralNumberFloat, nil}, {`'(?:(\\[\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))'B?`, LiteralStringChar, nil}, {`'.'`, LiteralStringChar, nil}, {`'`, Keyword, nil}, {`@?"`, LiteralStringDouble, Push("string")}, {`[~?][a-z][\w\']*:`, NameVariable, nil}, }, "dotted": { {`\s+`, Text, nil}, {`\.`, Punctuation, nil}, {`[A-Z][\w\']*(?=\s*\.)`, NameNamespace, nil}, {`[A-Z][\w\']*`, Name, Pop(1)}, {`[a-z_][\w\']*`, Name, Pop(1)}, Default(Pop(1)), }, "comment": { {`[^(*)@"]+`, Comment, nil}, {`\(\*`, Comment, Push()}, {`\*\)`, Comment, Pop(1)}, {`@"`, LiteralString, Push("lstring")}, {`"""`, LiteralString, Push("tqs")}, {`"`, LiteralString, Push("string")}, {`[(*)@]`, Comment, nil}, }, "string": { {`[^\\"]+`, LiteralString, nil}, Include("escape-sequence"), {`\\\n`, LiteralString, nil}, {`\n`, LiteralString, nil}, {`"B?`, LiteralString, Pop(1)}, }, "lstring": { {`[^"]+`, LiteralString, nil}, {`\n`, LiteralString, nil}, {`""`, LiteralString, nil}, {`"B?`, LiteralString, Pop(1)}, }, "tqs": { {`[^"]+`, LiteralString, nil}, {`\n`, LiteralString, nil}, {`"""B?`, LiteralString, Pop(1)}, {`"`, LiteralString, nil}, }, }, ))
Fsharp lexer.
var GDScript = Register(MustNewLexer( &Config{ Name: "GDScript", Aliases: []string{"gdscript", "gd"}, Filenames: []string{"*.gd"}, MimeTypes: []string{"text/x-gdscript", "application/x-gdscript"}, }, Rules{ "root": { {`\n`, Text, nil}, {`^(\s*)([rRuUbB]{,2})("""(?:.|\n)*?""")`, ByGroups(Text, LiteralStringAffix, LiteralStringDoc), nil}, {`^(\s*)([rRuUbB]{,2})('''(?:.|\n)*?''')`, ByGroups(Text, LiteralStringAffix, LiteralStringDoc), nil}, {`[^\S\n]+`, Text, nil}, {`#.*$`, CommentSingle, nil}, {`[]{}:(),;[]`, Punctuation, nil}, {`\\\n`, Text, nil}, {`\\`, Text, nil}, {`(in|and|or|not)\b`, OperatorWord, nil}, {`!=|==|<<|>>|&&|\+=|-=|\*=|/=|%=|&=|\|=|\|\||[-~+/*%=<>&^.!|$]`, Operator, nil}, Include("keywords"), {`(def)((?:\s|\\\s)+)`, ByGroups(Keyword, Text), Push("funcname")}, {`(class)((?:\s|\\\s)+)`, ByGroups(Keyword, Text), Push("classname")}, Include("builtins"), {`([rR]|[uUbB][rR]|[rR][uUbB])(""")`, ByGroups(LiteralStringAffix, LiteralStringDouble), Push("tdqs")}, {`([rR]|[uUbB][rR]|[rR][uUbB])(''')`, ByGroups(LiteralStringAffix, LiteralStringSingle), Push("tsqs")}, {`([rR]|[uUbB][rR]|[rR][uUbB])(")`, ByGroups(LiteralStringAffix, LiteralStringDouble), Push("dqs")}, {`([rR]|[uUbB][rR]|[rR][uUbB])(')`, ByGroups(LiteralStringAffix, LiteralStringSingle), Push("sqs")}, {`([uUbB]?)(""")`, ByGroups(LiteralStringAffix, LiteralStringDouble), Combined("stringescape", "tdqs")}, {`([uUbB]?)(''')`, ByGroups(LiteralStringAffix, LiteralStringSingle), Combined("stringescape", "tsqs")}, {`([uUbB]?)(")`, ByGroups(LiteralStringAffix, LiteralStringDouble), Combined("stringescape", "dqs")}, {`([uUbB]?)(')`, ByGroups(LiteralStringAffix, LiteralStringSingle), Combined("stringescape", "sqs")}, Include("name"), Include("numbers"), }, "keywords": { {Words(``, `\b`, `if`, `elif`, `else`, `for`, `do`, `while`, `switch`, `case`, `break`, `continue`, `pass`, `return`, `class`, `extends`, `tool`, `signal`, `func`, `static`, `const`, `enum`, `var`, `onready`, `export`, `setget`, `breakpoint`), Keyword, nil}, }, "builtins": { {Words(`(?<!\.)`, `\b`, `Color8`, `ColorN`, `abs`, `acos`, `asin`, `assert`, `atan`, `atan2`, `bytes2var`, `ceil`, `clamp`, `convert`, `cos`, `cosh`, `db2linear`, `decimals`, `dectime`, `deg2rad`, `dict2inst`, `ease`, `exp`, `floor`, `fmod`, `fposmod`, `funcref`, `hash`, `inst2dict`, `instance_from_id`, `is_inf`, `is_nan`, `lerp`, `linear2db`, `load`, `log`, `max`, `min`, `nearest_po2`, `pow`, `preload`, `print`, `print_stack`, `printerr`, `printraw`, `prints`, `printt`, `rad2deg`, `rand_range`, `rand_seed`, `randf`, `randi`, `randomize`, `range`, `round`, `seed`, `sign`, `sin`, `sinh`, `sqrt`, `stepify`, `str`, `str2var`, `tan`, `tanh`, `type_exist`, `typeof`, `var2bytes`, `var2str`, `weakref`, `yield`, ), NameBuiltin, nil}, {`(?<!\.)(self|false|true|PI|NAN|INF)\b`, NameBuiltinPseudo, nil}, {Words(`(?<!\.)`, `\b`, `AABB`, `AcceptDialog`, `AnimatedSprite`, `AnimatedSprite3D`, `Animation`, `AnimationPlayer`, `AnimationTreePlayer`, `Area`, `Area2D`, `Array`, `AtlasTexture`, `AudioServer`, `AudioServerSW`, `AudioStream`, `AudioStreamMPC`, `AudioStreamOGGVorbis`, `AudioStreamOpus`, `AudioStreamPlayback`, `AudioStreamSpeex`, `BackBufferCopy`, `BakedLight`, `BakedLightInstance`, `BakedLightSampler`, `BaseButton`, `BitMap`, `BoneAttachment`, `bool`, `BoxContainer`, `BoxShape`, `Button`, `ButtonArray`, `ButtonGroup`, `Camera`, `Camera2D`, `CanvasItem`, `CanvasItemMaterial`, `CanvasItemShader`, `CanvasItemShaderGraph`, `CanvasLayer`, `CanvasModulate`, `CapsuleShape`, `CapsuleShape2D`, `CenterContainer`, `CheckBox`, `CheckButton`, `CircleShape2D`, `CollisionObject`, `CollisionObject2D`, `CollisionPolygon`, `CollisionPolygon2D`, `CollisionShape`, `CollisionShape2D`, `Color`, `ColorArray`, `ColorPicker`, `ColorPickerButton`, `ColorRamp`, `ConcavePolygonShape`, `ConcavePolygonShape2D`, `ConeTwistJoint`, `ConfigFile`, `ConfirmationDialog`, `Container`, `Control`, `ConvexPolygonShape`, `ConvexPolygonShape2D`, `CubeMap`, `Curve2D`, `Curve3D`, `DampedSpringJoint2D`, `Dictionary`, `DirectionalLight`, `Directory`, `EditorFileDialog`, `EditorImportPlugin`, `EditorPlugin`, `EditorScenePostImport`, `EditorScript`, `Environment`, `EventPlayer`, `EventStream`, `EventStreamChibi`, `File`, `FileDialog`, `FixedMaterial`, `float`, `Font`, `FuncRef`, `GDFunctionState`, `GDNativeClass`, `GDScript`, `Generic6DOFJoint`, `Geometry`, `GeometryInstance`, `Globals`, `GraphEdit`, `GraphNode`, `GridContainer`, `GridMap`, `GrooveJoint2D`, `HBoxContainer`, `HButtonArray`, `HingeJoint`, `HScrollBar`, `HSeparator`, `HSlider`, `HSplitContainer`, `HTTPClient`, `Image`, `ImageTexture`, `ImmediateGeometry`, `Input`, `InputDefault`, `InputEvent`, `InputEventAction`, `InputEventJoystickButton`, `InputEventJoystickMotion`, `InputEventKey`, `InputEventMouseButton`, `InputEventMouseMotion`, `InputEventScreenDrag`, `InputEventScreenTouch`, `InputMap`, `InstancePlaceholder`, `int`, `IntArray`, `InterpolatedCamera`, `IP`, `IP_Unix`, `ItemList`, `Joint`, `Joint2D`, `KinematicBody`, `KinematicBody2D`, `Label`, `LargeTexture`, `Light`, `Light2D`, `LightOccluder2D`, `LineEdit`, `LineShape2D`, `MainLoop`, `MarginContainer`, `Marshalls`, `Material`, `MaterialShader`, `MaterialShaderGraph`, `Matrix3`, `Matrix32`, `MenuButton`, `Mesh`, `MeshDataTool`, `MeshInstance`, `MeshLibrary`, `MultiMesh`, `MultiMeshInstance`, `Mutex`, `Navigation`, `Navigation2D`, `NavigationMesh`, `NavigationMeshInstance`, `NavigationPolygon`, `NavigationPolygonInstance`, `Nil`, `Node`, `Node2D`, `NodePath`, `Object`, `OccluderPolygon2D`, `OmniLight`, `OptionButton`, `OS`, `PackedDataContainer`, `PackedDataContainerRef`, `PackedScene`, `PacketPeer`, `PacketPeerStream`, `PacketPeerUDP`, `Panel`, `PanelContainer`, `ParallaxBackground`, `ParallaxLayer`, `ParticleAttractor2D`, `Particles`, `Particles2D`, `Patch9Frame`, `Path`, `Path2D`, `PathFollow`, `PathFollow2D`, `PathRemap`, `PCKPacker`, `Performance`, `PHashTranslation`, `Physics2DDirectBodyState`, `Physics2DDirectBodyStateSW`, `Physics2DDirectSpaceState`, `Physics2DServer`, `Physics2DServerSW`, `Physics2DShapeQueryParameters`, `Physics2DShapeQueryResult`, `Physics2DTestMotionResult`, `PhysicsBody`, `PhysicsBody2D`, `PhysicsDirectBodyState`, `PhysicsDirectBodyStateSW`, `PhysicsDirectSpaceState`, `PhysicsServer`, `PhysicsServerSW`, `PhysicsShapeQueryParameters`, `PhysicsShapeQueryResult`, `PinJoint`, `PinJoint2D`, `Plane`, `PlaneShape`, `Polygon2D`, `PolygonPathFinder`, `Popup`, `PopupDialog`, `PopupMenu`, `PopupPanel`, `Portal`, `Position2D`, `Position3D`, `ProgressBar`, `ProximityGroup`, `Quad`, `Quat`, `Range`, `RawArray`, `RayCast`, `RayCast2D`, `RayShape`, `RayShape2D`, `RealArray`, `Rect2`, `RectangleShape2D`, `Reference`, `ReferenceFrame`, `RegEx`, `RemoteTransform2D`, `RenderTargetTexture`, `Resource`, `ResourceImportMetadata`, `ResourceInteractiveLoader`, `ResourceLoader`, `ResourcePreloader`, `ResourceSaver`, `RichTextLabel`, `RID`, `RigidBody`, `RigidBody2D`, `Room`, `RoomBounds`, `Sample`, `SampleLibrary`, `SamplePlayer`, `SamplePlayer2D`, `SceneState`, `SceneTree`, `Script`, `ScrollBar`, `ScrollContainer`, `SegmentShape2D`, `Semaphore`, `Separator`, `Shader`, `ShaderGraph`, `ShaderMaterial`, `Shape`, `Shape2D`, `Skeleton`, `Slider`, `SliderJoint`, `SoundPlayer2D`, `SoundRoomParams`, `Spatial`, `SpatialPlayer`, `SpatialSamplePlayer`, `SpatialSound2DServer`, `SpatialSound2DServerSW`, `SpatialSoundServer`, `SpatialSoundServerSW`, `SpatialStreamPlayer`, `SphereShape`, `SpinBox`, `SplitContainer`, `SpotLight`, `Sprite`, `Sprite3D`, `SpriteBase3D`, `SpriteFrames`, `StaticBody`, `StaticBody2D`, `StreamPeer`, `StreamPeerSSL`, `StreamPeerTCP`, `StreamPlayer`, `String`, `StringArray`, `StyleBox`, `StyleBoxEmpty`, `StyleBoxFlat`, `StyleBoxImageMask`, `StyleBoxTexture`, `SurfaceTool`, `TabContainer`, `Tabs`, `TCP_Server`, `TestCube`, `TextEdit`, `Texture`, `TextureButton`, `TextureFrame`, `TextureProgress`, `Theme`, `Thread`, `TileMap`, `TileSet`, `Timer`, `ToolButton`, `TouchScreenButton`, `Transform`, `Translation`, `TranslationServer`, `Tree`, `TreeItem`, `Tween`, `UndoRedo`, `VBoxContainer`, `VButtonArray`, `Vector2`, `Vector2Array`, `Vector3`, `Vector3Array`, `VehicleBody`, `VehicleWheel`, `VideoPlayer`, `VideoStream`, `VideoStreamTheora`, `Viewport`, `ViewportSprite`, `VisibilityEnabler`, `VisibilityEnabler2D`, `VisibilityNotifier`, `VisibilityNotifier2D`, `VisualInstance`, `VisualServer`, `VScrollBar`, `VSeparator`, `VSlider`, `VSplitContainer`, `WeakRef`, `WindowDialog`, `World`, `World2D`, `WorldEnvironment`, `XMLParser`, `YSort`), NameException, nil}, }, "numbers": { {`(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?j?`, LiteralNumberFloat, nil}, {`\d+[eE][+-]?[0-9]+j?`, LiteralNumberFloat, nil}, {`0[xX][a-fA-F0-9]+`, LiteralNumberHex, nil}, {`\d+j?`, LiteralNumberInteger, nil}, }, "name": { {`[a-zA-Z_]\w*`, Name, nil}, }, "funcname": { {`[a-zA-Z_]\w*`, NameFunction, Pop(1)}, Default(Pop(1)), }, "classname": { {`[a-zA-Z_]\w*`, NameClass, Pop(1)}, }, "stringescape": { {`\\([\\abfnrtv"\']|\n|N\{.*?\}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})`, LiteralStringEscape, nil}, }, "strings-single": { {`%(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[E-GXc-giorsux%]`, LiteralStringInterpol, nil}, {`[^\\\'"%\n]+`, LiteralStringSingle, nil}, {`[\'"\\]`, LiteralStringSingle, nil}, {`%`, LiteralStringSingle, nil}, }, "strings-double": { {`%(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[E-GXc-giorsux%]`, LiteralStringInterpol, nil}, {`[^\\\'"%\n]+`, LiteralStringDouble, nil}, {`[\'"\\]`, LiteralStringDouble, nil}, {`%`, LiteralStringDouble, nil}, }, "dqs": { {`"`, LiteralStringDouble, Pop(1)}, {`\\\\|\\"|\\\n`, LiteralStringEscape, nil}, Include("strings-double"), }, "sqs": { {`'`, LiteralStringSingle, Pop(1)}, {`\\\\|\\'|\\\n`, LiteralStringEscape, nil}, Include("strings-single"), }, "tdqs": { {`"""`, LiteralStringDouble, Pop(1)}, Include("strings-double"), {`\n`, LiteralStringDouble, nil}, }, "tsqs": { {`'''`, LiteralStringSingle, Pop(1)}, Include("strings-single"), {`\n`, LiteralStringSingle, nil}, }, }, ))
GDScript lexer.
var GLSL = Register(MustNewLexer( &Config{ Name: "GLSL", Aliases: []string{"glsl"}, Filenames: []string{"*.vert", "*.frag", "*.geo"}, MimeTypes: []string{"text/x-glslsrc"}, }, Rules{ "root": { {`^#.*`, CommentPreproc, nil}, {`//.*`, CommentSingle, nil}, {`/(\\\n)?[*](.|\n)*?[*](\\\n)?/`, CommentMultiline, nil}, {`\+|-|~|!=?|\*|/|%|<<|>>|<=?|>=?|==?|&&?|\^|\|\|?`, Operator, nil}, {`[?:]`, Operator, nil}, {`\bdefined\b`, Operator, nil}, {`[;{}(),\[\]]`, Punctuation, nil}, {`[+-]?\d*\.\d+([eE][-+]?\d+)?`, LiteralNumberFloat, nil}, {`[+-]?\d+\.\d*([eE][-+]?\d+)?`, LiteralNumberFloat, nil}, {`0[xX][0-9a-fA-F]*`, LiteralNumberHex, nil}, {`0[0-7]*`, LiteralNumberOct, nil}, {`[1-9][0-9]*`, LiteralNumberInteger, nil}, {Words(`\b`, `\b`, `attribute`, `const`, `uniform`, `varying`, `centroid`, `break`, `continue`, `do`, `for`, `while`, `if`, `else`, `in`, `out`, `inout`, `float`, `int`, `void`, `bool`, `true`, `false`, `invariant`, `discard`, `return`, `mat2`, `mat3mat4`, `mat2x2`, `mat3x2`, `mat4x2`, `mat2x3`, `mat3x3`, `mat4x3`, `mat2x4`, `mat3x4`, `mat4x4`, `vec2`, `vec3`, `vec4`, `ivec2`, `ivec3`, `ivec4`, `bvec2`, `bvec3`, `bvec4`, `sampler1D`, `sampler2D`, `sampler3DsamplerCube`, `sampler1DShadow`, `sampler2DShadow`, `struct`), Keyword, nil}, {Words(`\b`, `\b`, `asm`, `class`, `union`, `enum`, `typedef`, `template`, `this`, `packed`, `goto`, `switch`, `default`, `inline`, `noinline`, `volatile`, `public`, `static`, `extern`, `external`, `interface`, `long`, `short`, `double`, `half`, `fixed`, `unsigned`, `lowp`, `mediump`, `highp`, `precision`, `input`, `output`, `hvec2`, `hvec3`, `hvec4`, `dvec2`, `dvec3`, `dvec4`, `fvec2`, `fvec3`, `fvec4`, `sampler2DRect`, `sampler3DRect`, `sampler2DRectShadow`, `sizeof`, `cast`, `namespace`, `using`), Keyword, nil}, {`[a-zA-Z_]\w*`, Name, nil}, {`\.`, Punctuation, nil}, {`\s+`, Text, nil}, }, }, ))
GLSL lexer.
var Gas = Register(MustNewLexer( &Config{ Name: "GAS", Aliases: []string{"gas", "asm"}, Filenames: []string{"*.s", "*.S"}, MimeTypes: []string{"text/x-gas"}, }, Rules{ "root": { Include("whitespace"), {`(?:[a-zA-Z$_][\w$.@-]*|\.[\w$.@-]+):`, NameLabel, nil}, {`\.(?:[a-zA-Z$_][\w$.@-]*|\.[\w$.@-]+)`, NameAttribute, Push("directive-args")}, {`lock|rep(n?z)?|data\d+`, NameAttribute, nil}, {`(?:[a-zA-Z$_][\w$.@-]*|\.[\w$.@-]+)`, NameFunction, Push("instruction-args")}, {`[\r\n]+`, Text, nil}, }, "directive-args": { {`(?:[a-zA-Z$_][\w$.@-]*|\.[\w$.@-]+)`, NameConstant, nil}, {`"(\\"|[^"])*"`, LiteralString, nil}, {`@(?:[a-zA-Z$_][\w$.@-]*|\.[\w$.@-]+)`, NameAttribute, nil}, {`(?:0[xX][a-zA-Z0-9]+|\d+)`, LiteralNumberInteger, nil}, {`[\r\n]+`, Text, Pop(1)}, Include("punctuation"), Include("whitespace"), }, "instruction-args": { {`([a-z0-9]+)( )(<)((?:[a-zA-Z$_][\w$.@-]*|\.[\w$.@-]+))(>)`, ByGroups(LiteralNumberHex, Text, Punctuation, NameConstant, Punctuation), nil}, {`([a-z0-9]+)( )(<)((?:[a-zA-Z$_][\w$.@-]*|\.[\w$.@-]+))([-+])((?:0[xX][a-zA-Z0-9]+|\d+))(>)`, ByGroups(LiteralNumberHex, Text, Punctuation, NameConstant, Punctuation, LiteralNumberInteger, Punctuation), nil}, {`(?:[a-zA-Z$_][\w$.@-]*|\.[\w$.@-]+)`, NameConstant, nil}, {`(?:0[xX][a-zA-Z0-9]+|\d+)`, LiteralNumberInteger, nil}, {`%(?:[a-zA-Z$_][\w$.@-]*|\.[\w$.@-]+)`, NameVariable, nil}, {`$(?:0[xX][a-zA-Z0-9]+|\d+)`, LiteralNumberInteger, nil}, {`$'(.|\\')'`, LiteralStringChar, nil}, {`[\r\n]+`, Text, Pop(1)}, Include("punctuation"), Include("whitespace"), }, "whitespace": { {`\n`, Text, nil}, {`\s+`, Text, nil}, {`[;#].*?\n`, Comment, nil}, }, "punctuation": { {`[-*,.()\[\]!:]+`, Punctuation, nil}, }, }, ))
Gas lexer.
var Genshi = Register(MustNewLexer( &Config{ Name: "Genshi", Aliases: []string{"genshi", "kid", "xml+genshi", "xml+kid"}, Filenames: []string{"*.kid"}, MimeTypes: []string{"application/x-genshi", "application/x-kid"}, NotMultiline: true, DotAll: true, }, genshiMarkupRules, ))
Genshi lexer.
var GenshiHTMLTemplate = Register(MustNewLexer( &Config{ Name: "Genshi HTML", Aliases: []string{"html+genshi", "html+kid"}, Filenames: []string{}, MimeTypes: []string{"text/html+genshi"}, NotMultiline: true, DotAll: true, }, genshiMarkupRules, ))
Html+Genshi lexer.
var GenshiText = Register(MustNewLexer( &Config{ Name: "Genshi Text", Aliases: []string{"genshitext"}, Filenames: []string{}, MimeTypes: []string{"application/x-genshi-text", "text/x-genshi"}, }, Rules{ "root": { {`[^#$\s]+`, Other, nil}, {`^(\s*)(##.*)$`, ByGroups(Text, Comment), nil}, {`^(\s*)(#)`, ByGroups(Text, CommentPreproc), Push("directive")}, Include("variable"), {`[#$\s]`, Other, nil}, }, "directive": { {`\n`, Text, Pop(1)}, {`(?:def|for|if)\s+.*`, Using(Python, nil), Pop(1)}, {`(choose|when|with)([^\S\n]+)(.*)`, ByGroups(Keyword, Text, Using(Python, nil)), Pop(1)}, {`(choose|otherwise)\b`, Keyword, Pop(1)}, {`(end\w*)([^\S\n]*)(.*)`, ByGroups(Keyword, Text, Comment), Pop(1)}, }, "variable": { {`(?<!\$)(\$\{)(.+?)(\})`, ByGroups(CommentPreproc, Using(Python, nil), CommentPreproc), nil}, {`(?<!\$)(\$)([a-zA-Z_][\w.]*)`, NameVariable, nil}, }, }, ))
Genshi Text lexer.
var Gnuplot = Register(MustNewLexer( &Config{ Name: "Gnuplot", Aliases: []string{"gnuplot"}, Filenames: []string{"*.plot", "*.plt"}, MimeTypes: []string{"text/x-gnuplot"}, }, Rules{ "root": { Include("whitespace"), {`bind\b|bin\b|bi\b`, Keyword, Push("bind")}, {`exit\b|exi\b|ex\b|quit\b|qui\b|qu\b|q\b`, Keyword, Push("quit")}, {`fit\b|fi\b|f\b`, Keyword, Push("fit")}, {`(if)(\s*)(\()`, ByGroups(Keyword, Text, Punctuation), Push("if")}, {`else\b`, Keyword, nil}, {`pause\b|paus\b|pau\b|pa\b`, Keyword, Push("pause")}, {`plot\b|plo\b|pl\b|p\b|replot\b|replo\b|repl\b|rep\b|splot\b|splo\b|spl\b|sp\b`, Keyword, Push("plot")}, {`save\b|sav\b|sa\b`, Keyword, Push("save")}, {`set\b|se\b`, Keyword, Push("genericargs", "optionarg")}, {`show\b|sho\b|sh\b|unset\b|unse\b|uns\b`, Keyword, Push("noargs", "optionarg")}, {"" /* 446 byte string literal not displayed */, Keyword, Push("genericargs")}, {"" /* 167 byte string literal not displayed */, Keyword, Push("noargs")}, {`([a-zA-Z_]\w*)(\s*)(=)`, ByGroups(NameVariable, Text, Operator), Push("genericargs")}, {`([a-zA-Z_]\w*)(\s*\(.*?\)\s*)(=)`, ByGroups(NameFunction, Text, Operator), Push("genericargs")}, {`@[a-zA-Z_]\w*`, NameConstant, nil}, {`;`, Keyword, nil}, }, "comment": { {`[^\\\n]`, Comment, nil}, {`\\\n`, Comment, nil}, {`\\`, Comment, nil}, Default(Pop(1)), }, "whitespace": { {`#`, Comment, Push("comment")}, {`[ \t\v\f]+`, Text, nil}, }, "noargs": { Include("whitespace"), {`;`, Punctuation, Pop(1)}, {`\n`, Text, Pop(1)}, }, "dqstring": { {`"`, LiteralString, Pop(1)}, {`\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})`, LiteralStringEscape, nil}, {`[^\\"\n]+`, LiteralString, nil}, {`\\\n`, LiteralString, nil}, {`\\`, LiteralString, nil}, {`\n`, LiteralString, Pop(1)}, }, "sqstring": { {`''`, LiteralString, nil}, {`'`, LiteralString, Pop(1)}, {`[^\\'\n]+`, LiteralString, nil}, {`\\\n`, LiteralString, nil}, {`\\`, LiteralString, nil}, {`\n`, LiteralString, Pop(1)}, }, "genericargs": { Include("noargs"), {`"`, LiteralString, Push("dqstring")}, {`'`, LiteralString, Push("sqstring")}, {`(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+`, LiteralNumberFloat, nil}, {`(\d+\.\d*|\.\d+)`, LiteralNumberFloat, nil}, {`-?\d+`, LiteralNumberInteger, nil}, {`[,.~!%^&*+=|?:<>/-]`, Operator, nil}, {`[{}()\[\]]`, Punctuation, nil}, {`(eq|ne)\b`, OperatorWord, nil}, {`([a-zA-Z_]\w*)(\s*)(\()`, ByGroups(NameFunction, Text, Punctuation), nil}, {`[a-zA-Z_]\w*`, Name, nil}, {`@[a-zA-Z_]\w*`, NameConstant, nil}, {`\\\n`, Text, nil}, }, "optionarg": { Include("whitespace"), {"" /* 5359 byte string literal not displayed */, NameBuiltin, Pop(1)}, }, "bind": { {`!`, Keyword, Pop(1)}, {`allwindows\b|allwindow\b|allwindo\b|allwind\b|allwin\b|allwi\b|allw\b|all\b`, NameBuiltin, nil}, Include("genericargs"), }, "quit": { {`gnuplot\b`, Keyword, nil}, Include("noargs"), }, "fit": { {`via\b`, NameBuiltin, nil}, Include("plot"), }, "if": { {`\)`, Punctuation, Pop(1)}, Include("genericargs"), }, "pause": { {`(mouse|any|button1|button2|button3)\b`, NameBuiltin, nil}, {`keypress\b|keypres\b|keypre\b|keypr\b|keyp\b|key\b`, NameBuiltin, nil}, Include("genericargs"), }, "plot": { {"" /* 316 byte string literal not displayed */, NameBuiltin, nil}, Include("genericargs"), }, "save": { {"" /* 220 byte string literal not displayed */, NameBuiltin, nil}, Include("genericargs"), }, }, ))
Gnuplot lexer.
var Go = Register(MustNewLexer( &Config{ Name: "Go", Aliases: []string{"go", "golang"}, Filenames: []string{"*.go"}, MimeTypes: []string{"text/x-gosrc"}, }, Rules{ "root": { {`\n`, Text, nil}, {`\s+`, Text, nil}, {`\\\n`, Text, nil}, {`//(.*?)\n`, CommentSingle, nil}, {`/(\\\n)?[*](.|\n)*?[*](\\\n)?/`, CommentMultiline, nil}, {`(import|package)\b`, KeywordNamespace, nil}, {`(var|func|struct|map|chan|type|interface|const)\b`, KeywordDeclaration, nil}, {Words(``, `\b`, `break`, `default`, `select`, `case`, `defer`, `go`, `else`, `goto`, `switch`, `fallthrough`, `if`, `range`, `continue`, `for`, `return`), Keyword, nil}, {`(true|false|iota|nil)\b`, KeywordConstant, nil}, {Words(``, `\b(\()`, `uint`, `uint8`, `uint16`, `uint32`, `uint64`, `int`, `int8`, `int16`, `int32`, `int64`, `float`, `float32`, `float64`, `complex64`, `complex128`, `byte`, `rune`, `string`, `bool`, `error`, `uintptr`, `print`, `println`, `panic`, `recover`, `close`, `complex`, `real`, `imag`, `len`, `cap`, `append`, `copy`, `delete`, `new`, `make`), ByGroups(NameBuiltin, Punctuation), nil}, {Words(``, `\b`, `uint`, `uint8`, `uint16`, `uint32`, `uint64`, `int`, `int8`, `int16`, `int32`, `int64`, `float`, `float32`, `float64`, `complex64`, `complex128`, `byte`, `rune`, `string`, `bool`, `error`, `uintptr`), KeywordType, 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}, {`"(\\\\|\\"|[^"])*"`, LiteralString, nil}, {`(<<=|>>=|<<|>>|<=|>=|&\^=|&\^|\+=|-=|\*=|/=|%=|&=|\|=|&&|\|\||<-|\+\+|--|==|!=|:=|\.\.\.|[+\-*/%&])`, Operator, nil}, {`[|^<>=!()\[\]{}.,;:]`, 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 }))
Go lexer.
var Groovy = Register(MustNewLexer( &Config{ Name: "Groovy", Aliases: []string{"groovy"}, Filenames: []string{"*.groovy", "*.gradle"}, MimeTypes: []string{"text/x-groovy"}, DotAll: true, }, Rules{ "root": { {`#!(.*?)$`, CommentPreproc, Push("base")}, Default(Push("base")), }, "base": { {`^(\s*(?:[a-zA-Z_][\w.\[\]]*\s+)+?)([a-zA-Z_]\w*)(\s*)(\()`, ByGroups(UsingSelf("root"), NameFunction, Text, Operator), nil}, {`[^\S\n]+`, Text, nil}, {`//.*?\n`, CommentSingle, nil}, {`/\*.*?\*/`, CommentMultiline, nil}, {`@[a-zA-Z_][\w.]*`, NameDecorator, nil}, {"" /* 136 byte string literal not displayed */, Keyword, nil}, {"" /* 143 byte string literal not displayed */, KeywordDeclaration, nil}, {`(def|boolean|byte|char|double|float|int|long|short|void)\b`, KeywordType, nil}, {`(package)(\s+)`, ByGroups(KeywordNamespace, Text), nil}, {`(true|false|null)\b`, KeywordConstant, nil}, {`(class|interface)(\s+)`, ByGroups(KeywordDeclaration, Text), Push("class")}, {`(import)(\s+)`, ByGroups(KeywordNamespace, Text), Push("import")}, {`""".*?"""`, LiteralStringDouble, nil}, {`'''.*?'''`, LiteralStringSingle, nil}, {`"(\\\\|\\"|[^"])*"`, LiteralStringDouble, nil}, {`'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil}, {`\$/((?!/\$).)*/\$`, LiteralString, nil}, {`/(\\\\|\\"|[^/])*/`, LiteralString, nil}, {`'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'`, LiteralStringChar, nil}, {`(\.)([a-zA-Z_]\w*)`, ByGroups(Operator, NameAttribute), nil}, {`[a-zA-Z_]\w*:`, NameLabel, nil}, {`[a-zA-Z_$]\w*`, Name, nil}, {`[~^*!%&\[\](){}<>|+=:;,./?-]`, Operator, nil}, {`[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?`, LiteralNumberFloat, nil}, {`0x[0-9a-fA-F]+`, LiteralNumberHex, nil}, {`[0-9]+L?`, LiteralNumberInteger, nil}, {`\n`, Text, nil}, }, "class": { {`[a-zA-Z_]\w*`, NameClass, Pop(1)}, }, "import": { {`[\w.]+\*?`, NameNamespace, Pop(1)}, }, }, ))
Groovy lexer.
var HTML = Register(MustNewLexer( &Config{ Name: "HTML", Aliases: []string{"html"}, Filenames: []string{"*.html", "*.htm", "*.xhtml", "*.xslt"}, MimeTypes: []string{"text/html", "application/xhtml+xml"}, NotMultiline: true, DotAll: true, CaseInsensitive: true, }, Rules{ "root": { {`[^<&]+`, Text, nil}, {`&\S*?;`, NameEntity, nil}, {`\<\!\[CDATA\[.*?\]\]\>`, CommentPreproc, nil}, {`<!--`, Comment, Push("comment")}, {`<\?.*?\?>`, CommentPreproc, nil}, {`<![^>]*>`, CommentPreproc, nil}, {`(<)(\s*)(script)(\s*)`, ByGroups(Punctuation, Text, NameTag, Text), Push("script-content", "tag")}, {`(<)(\s*)(style)(\s*)`, ByGroups(Punctuation, Text, NameTag, Text), Push("style-content", "tag")}, {`(<)(\s*)([\w:.-]+)`, ByGroups(Punctuation, Text, NameTag), Push("tag")}, {`(<)(\s*)(/)(\s*)([\w:.-]+)(\s*)(>)`, ByGroups(Punctuation, Text, Punctuation, Text, NameTag, Text, Punctuation), nil}, }, "comment": { {`[^-]+`, Comment, nil}, {`-->`, Comment, Pop(1)}, {`-`, Comment, nil}, }, "tag": { {`\s+`, Text, nil}, {`([\w:-]+\s*)(=)(\s*)`, ByGroups(NameAttribute, Operator, Text), Push("attr")}, {`[\w:-]+`, NameAttribute, nil}, {`(/?)(\s*)(>)`, ByGroups(Punctuation, Text, Punctuation), Pop(1)}, }, "script-content": { {`(<)(\s*)(/)(\s*)(script)(\s*)(>)`, ByGroups(Punctuation, Text, Punctuation, Text, NameTag, Text, Punctuation), Pop(1)}, {`.+?(?=<\s*/\s*script\s*>)`, Using(Javascript, nil), nil}, }, "style-content": { {`(<)(\s*)(/)(\s*)(style)(\s*)(>)`, ByGroups(Punctuation, Text, Punctuation, Text, NameTag, Text, Punctuation), Pop(1)}, {`.+?(?=<\s*/\s*style\s*>)`, Using(CSS, nil), nil}, }, "attr": { {`".*?"`, LiteralString, Pop(1)}, {`'.*?'`, LiteralString, Pop(1)}, {`[^\s>]+`, LiteralString, Pop(1)}, }, }, ))
HTML lexer.
var HTTP = Register(httpBodyContentTypeLexer(MustNewLexer( &Config{ Name: "HTTP", Aliases: []string{"http"}, Filenames: []string{}, MimeTypes: []string{}, NotMultiline: true, DotAll: true, }, Rules{ "root": { {`(GET|POST|PUT|DELETE|HEAD|OPTIONS|TRACE|PATCH)( +)([^ ]+)( +)(HTTP)(/)(1\.[01])(\r?\n|\Z)`, ByGroups(NameFunction, Text, NameNamespace, Text, KeywordReserved, Operator, LiteralNumber, Text), Push("headers")}, {`(HTTP)(/)(1\.[01])( +)(\d{3})( +)([^\r\n]+)(\r?\n|\Z)`, ByGroups(KeywordReserved, Operator, LiteralNumber, Text, LiteralNumber, Text, NameException, Text), Push("headers")}, }, "headers": { {`([^\s:]+)( *)(:)( *)([^\r\n]+)(\r?\n|\Z)`, EmitterFunc(httpHeaderBlock), nil}, {`([\t ]+)([^\r\n]+)(\r?\n|\Z)`, EmitterFunc(httpContinuousHeaderBlock), nil}, {`\r?\n`, Text, Push("content")}, }, "content": { {`.+`, EmitterFunc(httpContentBlock), nil}, }, }, )))
HTTP lexer.
var Handlebars = Register(MustNewLexer( &Config{ Name: "Handlebars", Aliases: []string{"handlebars"}, Filenames: []string{"*.handlebars"}, MimeTypes: []string{}, }, Rules{ "root": { {`[^{]+`, Other, nil}, {`\{\{!.*\}\}`, Comment, nil}, {`(\{\{\{)(\s*)`, ByGroups(CommentSpecial, Text), Push("tag")}, {`(\{\{)(\s*)`, ByGroups(CommentPreproc, Text), Push("tag")}, }, "tag": { {`\s+`, Text, nil}, {`\}\}\}`, CommentSpecial, Pop(1)}, {`\}\}`, CommentPreproc, Pop(1)}, {`([#/]*)(each|if|unless|else|with|log|in(?:line)?)`, ByGroups(Keyword, Keyword), nil}, {`#\*inline`, Keyword, nil}, {`([#/])([\w-]+)`, ByGroups(NameFunction, NameFunction), nil}, {`([\w-]+)(=)`, ByGroups(NameAttribute, Operator), nil}, {`(>)(\s*)(@partial-block)`, ByGroups(Keyword, Text, Keyword), nil}, {`(#?>)(\s*)([\w-]+)`, ByGroups(Keyword, Text, NameVariable), nil}, {`(>)(\s*)(\()`, ByGroups(Keyword, Text, Punctuation), Push("dynamic-partial")}, Include("generic"), }, "dynamic-partial": { {`\s+`, Text, nil}, {`\)`, Punctuation, Pop(1)}, {`(lookup)(\s+)(\.|this)(\s+)`, ByGroups(Keyword, Text, NameVariable, Text), nil}, {`(lookup)(\s+)(\S+)`, ByGroups(Keyword, Text, UsingSelf("variable")), nil}, {`[\w-]+`, NameFunction, nil}, Include("generic"), }, "variable": { {`[a-zA-Z][\w-]*`, NameVariable, nil}, {`\.[\w-]+`, NameVariable, nil}, {`(this\/|\.\/|(\.\.\/)+)[\w-]+`, NameVariable, nil}, }, "generic": { Include("variable"), {`:?"(\\\\|\\"|[^"])*"`, LiteralStringDouble, nil}, {`:?'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil}, {`[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?`, LiteralNumber, nil}, }, }, ))
Handlebars lexer.
var Haskell = Register(MustNewLexer( &Config{ Name: "Haskell", Aliases: []string{"haskell", "hs"}, Filenames: []string{"*.hs"}, MimeTypes: []string{"text/x-haskell"}, }, Rules{ "root": { {`\s+`, Text, nil}, {`--(?![!#$%&*+./<=>?@^|_~:\\]).*?$`, CommentSingle, nil}, {`\{-`, CommentMultiline, Push("comment")}, {`\bimport\b`, KeywordReserved, Push("import")}, {`\bmodule\b`, KeywordReserved, Push("module")}, {`\berror\b`, NameException, nil}, {`\b(case|class|data|default|deriving|do|else|family|if|in|infix[lr]?|instance|let|newtype|of|then|type|where|_)(?!\')\b`, KeywordReserved, nil}, {`'[^\\]'`, LiteralStringChar, nil}, {"" /* 1972 byte string literal not displayed */, NameFunction, nil}, {"" /* 1972 byte string literal not displayed */, Name, nil}, {"" /* 1926 byte string literal not displayed */, KeywordType, nil}, {"" /* 1924 byte string literal not displayed */, KeywordType, nil}, {`(')\[[^\]]*\]`, KeywordType, nil}, {`(')\([^)]*\)`, KeywordType, nil}, {`\\(?![:!#$%&*+.\\/<=>?@^|~-]+)`, NameFunction, nil}, {`(<-|::|->|=>|=)(?![:!#$%&*+.\\/<=>?@^|~-]+)`, OperatorWord, nil}, {`:[:!#$%&*+.\\/<=>?@^|~-]*`, KeywordType, nil}, {`[:!#$%&*+.\\/<=>?@^|~-]+`, Operator, nil}, {`\d+[eE][+-]?\d+`, LiteralNumberFloat, nil}, {`\d+\.\d+([eE][+-]?\d+)?`, LiteralNumberFloat, nil}, {`0[oO][0-7]+`, LiteralNumberOct, nil}, {`0[xX][\da-fA-F]+`, LiteralNumberHex, nil}, {`\d+`, LiteralNumberInteger, nil}, {`'`, LiteralStringChar, Push("character")}, {`"`, LiteralString, Push("string")}, {`\[\]`, KeywordType, nil}, {`\(\)`, NameBuiltin, nil}, {"[][(),;`{}]", Punctuation, nil}, }, "import": { {`\s+`, Text, nil}, {`"`, LiteralString, Push("string")}, {`\)`, Punctuation, Pop(1)}, {`qualified\b`, Keyword, nil}, {"" /* 3856 byte string literal not displayed */, ByGroups(NameNamespace, Text, Keyword, Text, Name), Pop(1)}, {"" /* 1944 byte string literal not displayed */, ByGroups(NameNamespace, Text, Keyword, Text, Punctuation), Push("funclist")}, {"" /* 1931 byte string literal not displayed */, ByGroups(NameNamespace, Text, Punctuation), Push("funclist")}, {`[\w.]+`, NameNamespace, Pop(1)}, }, "module": { {`\s+`, Text, nil}, {"" /* 1931 byte string literal not displayed */, ByGroups(NameNamespace, Text, Punctuation), Push("funclist")}, {"" /* 1920 byte string literal not displayed */, NameNamespace, Pop(1)}, }, "funclist": { {`\s+`, Text, nil}, {"" /* 1917 byte string literal not displayed */, KeywordType, nil}, {"" /* 1981 byte string literal not displayed */, NameFunction, nil}, {`--(?![!#$%&*+./<=>?@^|_~:\\]).*?$`, CommentSingle, nil}, {`\{-`, CommentMultiline, Push("comment")}, {`,`, Punctuation, nil}, {`[:!#$%&*+.\\/<=>?@^|~-]+`, Operator, nil}, {`\(`, Punctuation, Push("funclist", "funclist")}, {`\)`, Punctuation, Pop(2)}, }, "comment": { {`[^-{}]+`, CommentMultiline, nil}, {`\{-`, CommentMultiline, Push()}, {`-\}`, CommentMultiline, Pop(1)}, {`[-{}]`, CommentMultiline, nil}, }, "character": { {`[^\\']'`, LiteralStringChar, Pop(1)}, {`\\`, LiteralStringEscape, Push("escape")}, {`'`, LiteralStringChar, Pop(1)}, }, "string": { {`[^\\"]+`, LiteralString, nil}, {`\\`, LiteralStringEscape, Push("escape")}, {`"`, LiteralString, Pop(1)}, }, "escape": { {`[abfnrtv"\'&\\]`, LiteralStringEscape, Pop(1)}, {"" /* 1921 byte string literal not displayed */, LiteralStringEscape, Pop(1)}, {`NUL|SOH|[SE]TX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|S[OI]|DLE|DC[1-4]|NAK|SYN|ETB|CAN|EM|SUB|ESC|[FGRU]S|SP|DEL`, LiteralStringEscape, Pop(1)}, {`o[0-7]+`, LiteralStringEscape, Pop(1)}, {`x[\da-fA-F]+`, LiteralStringEscape, Pop(1)}, {`\d+`, LiteralStringEscape, Pop(1)}, {`\s+\\`, LiteralStringEscape, Pop(1)}, }, }, ))
Haskell lexer.
var Haxe = Register(MustNewLexer( &Config{ Name: "Haxe", Aliases: []string{"hx", "haxe", "hxsl"}, Filenames: []string{"*.hx", "*.hxsl"}, MimeTypes: []string{"text/haxe", "text/x-haxe", "text/x-hx"}, DotAll: true, }, Rules{ /* 105 elements not displayed */ }, ))
Haxe lexer.
var Hexdump = Register(MustNewLexer( &Config{ Name: "Hexdump", Aliases: []string{"hexdump"}, Filenames: []string{}, MimeTypes: []string{}, }, Rules{ "root": { {`\n`, Text, nil}, Include("offset"), {`([0-9A-Ha-h]{2})(\-)([0-9A-Ha-h]{2})`, ByGroups(LiteralNumberHex, Punctuation, LiteralNumberHex), nil}, {`[0-9A-Ha-h]{2}`, LiteralNumberHex, nil}, {`(\s{2,3})(\>)(.{16})(\<)$`, ByGroups(Text, Punctuation, LiteralString, Punctuation), Push("bracket-strings")}, {`(\s{2,3})(\|)(.{16})(\|)$`, ByGroups(Text, Punctuation, LiteralString, Punctuation), Push("piped-strings")}, {`(\s{2,3})(\>)(.{1,15})(\<)$`, ByGroups(Text, Punctuation, LiteralString, Punctuation), nil}, {`(\s{2,3})(\|)(.{1,15})(\|)$`, ByGroups(Text, Punctuation, LiteralString, Punctuation), nil}, {`(\s{2,3})(.{1,15})$`, ByGroups(Text, LiteralString), nil}, {`(\s{2,3})(.{16}|.{20})$`, ByGroups(Text, LiteralString), Push("nonpiped-strings")}, {`\s`, Text, nil}, {`^\*`, Punctuation, nil}, }, "offset": { {`^([0-9A-Ha-h]+)(:)`, ByGroups(NameLabel, Punctuation), Push("offset-mode")}, {`^[0-9A-Ha-h]+`, NameLabel, nil}, }, "offset-mode": { {`\s`, Text, Pop(1)}, {`[0-9A-Ha-h]+`, NameLabel, nil}, {`:`, Punctuation, nil}, }, "piped-strings": { {`\n`, Text, nil}, Include("offset"), {`[0-9A-Ha-h]{2}`, LiteralNumberHex, nil}, {`(\s{2,3})(\|)(.{1,16})(\|)$`, ByGroups(Text, Punctuation, LiteralString, Punctuation), nil}, {`\s`, Text, nil}, {`^\*`, Punctuation, nil}, }, "bracket-strings": { {`\n`, Text, nil}, Include("offset"), {`[0-9A-Ha-h]{2}`, LiteralNumberHex, nil}, {`(\s{2,3})(\>)(.{1,16})(\<)$`, ByGroups(Text, Punctuation, LiteralString, Punctuation), nil}, {`\s`, Text, nil}, {`^\*`, Punctuation, nil}, }, "nonpiped-strings": { {`\n`, Text, nil}, Include("offset"), {`([0-9A-Ha-h]{2})(\-)([0-9A-Ha-h]{2})`, ByGroups(LiteralNumberHex, Punctuation, LiteralNumberHex), nil}, {`[0-9A-Ha-h]{2}`, LiteralNumberHex, nil}, {`(\s{19,})(.{1,20}?)$`, ByGroups(Text, LiteralString), nil}, {`(\s{2,3})(.{1,20})$`, ByGroups(Text, LiteralString), nil}, {`\s`, Text, nil}, {`^\*`, Punctuation, nil}, }, }, ))
Hexdump lexer.
var Hy = Register(MustNewLexer( &Config{ Name: "Hy", Aliases: []string{"hylang"}, Filenames: []string{"*.hy"}, MimeTypes: []string{"text/x-hy", "application/x-hy"}, }, Rules{ "root": { {`;.*$`, CommentSingle, nil}, {`[,\s]+`, Text, nil}, {`-?\d+\.\d+`, LiteralNumberFloat, nil}, {`-?\d+`, LiteralNumberInteger, nil}, {`0[0-7]+j?`, LiteralNumberOct, nil}, {`0[xX][a-fA-F0-9]+`, LiteralNumberHex, nil}, {`"(\\\\|\\"|[^"])*"`, LiteralString, nil}, {`'(?!#)[\w!$%*+<=>?/.#-]+`, LiteralStringSymbol, nil}, {`\\(.|[a-z]+)`, LiteralStringChar, nil}, {`^(\s*)([rRuU]{,2}"""(?:.|\n)*?""")`, ByGroups(Text, LiteralStringDoc), nil}, {`^(\s*)([rRuU]{,2}'''(?:.|\n)*?''')`, ByGroups(Text, LiteralStringDoc), nil}, {`::?(?!#)[\w!$%*+<=>?/.#-]+`, LiteralStringSymbol, nil}, {"~@|[`\\'#^~&@]", Operator, nil}, Include("py-keywords"), Include("py-builtins"), {Words(``, ` `, `cond`, `for`, `->`, `->>`, `car`, `cdr`, `first`, `rest`, `let`, `when`, `unless`, `import`, `do`, `progn`, `get`, `slice`, `assoc`, `with-decorator`, `,`, `list_comp`, `kwapply`, `~`, `is`, `in`, `is-not`, `not-in`, `quasiquote`, `unquote`, `unquote-splice`, `quote`, `|`, `<<=`, `>>=`, `foreach`, `while`, `eval-and-compile`, `eval-when-compile`), Keyword, nil}, {Words(``, ` `, `def`, `defn`, `defun`, `defmacro`, `defclass`, `lambda`, `fn`, `setv`), KeywordDeclaration, nil}, {Words(``, ` `, `cycle`, `dec`, `distinct`, `drop`, `even?`, `filter`, `inc`, `instance?`, `iterable?`, `iterate`, `iterator?`, `neg?`, `none?`, `nth`, `numeric?`, `odd?`, `pos?`, `remove`, `repeat`, `repeatedly`, `take`, `take_nth`, `take_while`, `zero?`), NameBuiltin, nil}, {`(?<=\()(?!#)[\w!$%*+<=>?/.#-]+`, NameFunction, nil}, {`(?!#)[\w!$%*+<=>?/.#-]+`, NameVariable, nil}, {`(\[|\])`, Punctuation, nil}, {`(\{|\})`, Punctuation, nil}, {`(\(|\))`, Punctuation, nil}, }, "py-keywords": { {Words(``, `\b`, `assert`, `break`, `continue`, `del`, `elif`, `else`, `except`, `exec`, `finally`, `for`, `global`, `if`, `lambda`, `pass`, `print`, `raise`, `return`, `try`, `while`, `yield`, `yield from`, `as`, `with`), Keyword, nil}, }, "py-builtins": { {Words(`(?<!\.)`, `\b`, `__import__`, `abs`, `all`, `any`, `apply`, `basestring`, `bin`, `bool`, `buffer`, `bytearray`, `bytes`, `callable`, `chr`, `classmethod`, `cmp`, `coerce`, `compile`, `complex`, `delattr`, `dict`, `dir`, `divmod`, `enumerate`, `eval`, `execfile`, `exit`, `file`, `filter`, `float`, `frozenset`, `getattr`, `globals`, `hasattr`, `hash`, `hex`, `id`, `input`, `int`, `intern`, `isinstance`, `issubclass`, `iter`, `len`, `list`, `locals`, `long`, `map`, `max`, `min`, `next`, `object`, `oct`, `open`, `ord`, `pow`, `property`, `range`, `raw_input`, `reduce`, `reload`, `repr`, `reversed`, `round`, `set`, `setattr`, `slice`, `sorted`, `staticmethod`, `str`, `sum`, `super`, `tuple`, `type`, `unichr`, `unicode`, `vars`, `xrange`, `zip`), NameBuiltin, nil}, {`(?<!\.)(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}, }, }, ))
Hy lexer.
var Idris = Register(MustNewLexer( &Config{ Name: "Idris", Aliases: []string{"idris", "idr"}, Filenames: []string{"*.idr"}, MimeTypes: []string{"text/x-idris"}, }, 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}, {`(\s*)(\|{3}.*?)$`, ByGroups(Text, CommentSingle), nil}, {`(\s*)(\{-)`, ByGroups(Text, CommentMultiline), Push("comment")}, {`^(\s*)([^\s(){}]+)(\s*)(:)(\s*)`, ByGroups(Text, NameFunction, Text, OperatorWord, Text), nil}, {"" /* 319 byte string literal not displayed */, KeywordReserved, nil}, {`(import|module)(\s+)`, ByGroups(KeywordReserved, Text), Push("module")}, {`('')?[A-Z][\w\']*`, KeywordType, nil}, {`[a-z][\w\']*`, Text, nil}, {`(<-|::|->|=>|=)`, OperatorWord, nil}, {`([(){}\[\]:!#$%&*+.\\/<=>?@^|~-]+)`, OperatorWord, nil}, {`\d+[eE][+-]?\d+`, LiteralNumberFloat, nil}, {`\d+\.\d+([eE][+-]?\d+)?`, LiteralNumberFloat, nil}, {`0[xX][\da-fA-F]+`, LiteralNumberHex, nil}, {`\d+`, LiteralNumberInteger, nil}, {`'`, LiteralStringChar, Push("character")}, {`"`, LiteralString, Push("string")}, {`[^\s(){}]+`, Text, nil}, {`\s+?`, Text, nil}, }, "module": { {`\s+`, Text, nil}, {`([A-Z][\w.]*)(\s+)(\()`, ByGroups(NameNamespace, Text, Punctuation), Push("funclist")}, {`[A-Z][\w.]*`, NameNamespace, Pop(1)}, }, "funclist": { {`\s+`, Text, nil}, {`[A-Z]\w*`, KeywordType, nil}, {`(_[\w\']+|[a-z][\w\']*)`, NameFunction, nil}, {`--.*$`, CommentSingle, nil}, {`\{-`, CommentMultiline, Push("comment")}, {`,`, Punctuation, nil}, {`[:!#$%&*+.\\/<=>?@^|~-]+`, Operator, nil}, {`\(`, Punctuation, Push("funclist", "funclist")}, {`\)`, Punctuation, Pop(2)}, }, "comment": { {`[^-{}]+`, CommentMultiline, nil}, {`\{-`, CommentMultiline, Push()}, {`-\}`, CommentMultiline, Pop(1)}, {`[-{}]`, CommentMultiline, nil}, }, "character": { {`[^\\']`, LiteralStringChar, nil}, {`\\`, LiteralStringEscape, Push("escape")}, {`'`, LiteralStringChar, Pop(1)}, }, "string": { {`[^\\"]+`, LiteralString, nil}, {`\\`, LiteralStringEscape, Push("escape")}, {`"`, LiteralString, Pop(1)}, }, "escape": { {`[abfnrtv"\'&\\]`, LiteralStringEscape, Pop(1)}, {`\^[][A-Z@^_]`, LiteralStringEscape, Pop(1)}, {`NUL|SOH|[SE]TX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|S[OI]|DLE|DC[1-4]|NAK|SYN|ETB|CAN|EM|SUB|ESC|[FGRU]S|SP|DEL`, LiteralStringEscape, Pop(1)}, {`o[0-7]+`, LiteralStringEscape, Pop(1)}, {`x[\da-fA-F]+`, LiteralStringEscape, Pop(1)}, {`\d+`, LiteralStringEscape, Pop(1)}, {`\s+\\`, LiteralStringEscape, Pop(1)}, }, }, ))
Idris lexer.
var Ini = Register(MustNewLexer( &Config{ Name: "INI", Aliases: []string{"ini", "cfg", "dosini"}, Filenames: []string{"*.ini", "*.cfg", "*.inf"}, MimeTypes: []string{"text/x-ini", "text/inf"}, }, Rules{ "root": { {`\s+`, Text, nil}, {`[;#].*`, CommentSingle, nil}, {`\[.*?\]$`, Keyword, nil}, {`(.*?)([ \t]*)(=)([ \t]*)(.*(?:\n[ \t].+)*)`, ByGroups(NameAttribute, Text, Operator, Text, LiteralString), nil}, {`(.+?)$`, NameAttribute, nil}, }, }, ))
Ini lexer.
var Io = Register(MustNewLexer( &Config{ Name: "Io", Aliases: []string{"io"}, Filenames: []string{"*.io"}, MimeTypes: []string{"text/x-iosrc"}, }, Rules{ "root": { {`\n`, Text, nil}, {`\s+`, Text, nil}, {`//(.*?)\n`, CommentSingle, nil}, {`#(.*?)\n`, CommentSingle, nil}, {`/(\\\n)?[*](.|\n)*?[*](\\\n)?/`, CommentMultiline, nil}, {`/\+`, CommentMultiline, Push("nestedcomment")}, {`"(\\\\|\\"|[^"])*"`, LiteralString, nil}, {`::=|:=|=|\(|\)|;|,|\*|-|\+|>|<|@|!|/|\||\^|\.|%|&|\[|\]|\{|\}`, Operator, nil}, {`(clone|do|doFile|doString|method|for|if|else|elseif|then)\b`, Keyword, nil}, {`(nil|false|true)\b`, NameConstant, nil}, {`(Object|list|List|Map|args|Sequence|Coroutine|File)\b`, NameBuiltin, nil}, {`[a-zA-Z_]\w*`, Name, nil}, {`(\d+\.?\d*|\d*\.\d+)([eE][+-]?[0-9]+)?`, LiteralNumberFloat, nil}, {`\d+`, LiteralNumberInteger, nil}, }, "nestedcomment": { {`[^+/]+`, CommentMultiline, nil}, {`/\+`, CommentMultiline, Push()}, {`\+/`, CommentMultiline, Pop(1)}, {`[+/]`, CommentMultiline, nil}, }, }, ))
Io lexer.
var Java = Register(MustNewLexer( &Config{ Name: "Java", Aliases: []string{"java"}, Filenames: []string{"*.java"}, MimeTypes: []string{"text/x-java"}, DotAll: true, }, Rules{ "root": { {`[^\S\n]+`, Text, nil}, {`//.*?\n`, CommentSingle, nil}, {`/\*.*?\*/`, CommentMultiline, nil}, {`(assert|break|case|catch|continue|default|do|else|finally|for|if|goto|instanceof|new|return|switch|this|throw|try|while)\b`, Keyword, nil}, {`((?:(?:[^\W\d]|\$)[\w.\[\]$<>]*\s+)+?)((?:[^\W\d]|\$)[\w$]*)(\s*)(\()`, ByGroups(UsingSelf("root"), NameFunction, Text, Operator), nil}, {`@[^\W\d][\w.]*`, NameDecorator, nil}, {"" /* 143 byte string literal not displayed */, KeywordDeclaration, nil}, {`(boolean|byte|char|double|float|int|long|short|void)\b`, KeywordType, nil}, {`(package)(\s+)`, ByGroups(KeywordNamespace, Text), Push("import")}, {`(true|false|null)\b`, KeywordConstant, nil}, {`(class|interface)(\s+)`, ByGroups(KeywordDeclaration, Text), Push("class")}, {`(import(?:\s+static)?)(\s+)`, ByGroups(KeywordNamespace, Text), Push("import")}, {`"(\\\\|\\"|[^"])*"`, LiteralString, nil}, {`'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'`, LiteralStringChar, nil}, {`(\.)((?:[^\W\d]|\$)[\w$]*)`, ByGroups(Operator, NameAttribute), nil}, {`^\s*([^\W\d]|\$)[\w$]*:`, NameLabel, nil}, {`([^\W\d]|\$)[\w$]*`, Name, nil}, {"" /* 270 byte string literal not displayed */, LiteralNumberFloat, nil}, {`0[xX][0-9a-fA-F][0-9a-fA-F_]*[lL]?`, LiteralNumberHex, nil}, {`0[bB][01][01_]*[lL]?`, LiteralNumberBin, nil}, {`0[0-7_]+[lL]?`, LiteralNumberOct, nil}, {`0|[1-9][0-9_]*[lL]?`, LiteralNumberInteger, nil}, {`[~^*!%&\[\](){}<>|+=:;,./?-]`, Operator, nil}, {`\n`, Text, nil}, }, "class": { {`([^\W\d]|\$)[\w$]*`, NameClass, Pop(1)}, }, "import": { {`[\w.]+\*?`, NameNamespace, Pop(1)}, }, }, ))
Java lexer.
var Javascript = Register(MustNewLexer( &Config{ Name: "JavaScript", Aliases: []string{"js", "javascript"}, Filenames: []string{"*.js", "*.jsm"}, MimeTypes: []string{"application/javascript", "application/x-javascript", "text/x-javascript", "text/javascript"}, DotAll: true, }, Rules{ "commentsandwhitespace": { {`\s+`, Text, nil}, {`<!--`, Comment, nil}, {`//.*?\n`, CommentSingle, nil}, {`/\*.*?\*/`, CommentMultiline, nil}, }, "slashstartsregex": { Include("commentsandwhitespace"), {`/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/([gimuy]+\b|\B)`, LiteralStringRegex, Pop(1)}, {`(?=/)`, Text, Push("#pop", "badregex")}, Default(Pop(1)), }, "badregex": { {`\n`, Text, Pop(1)}, }, "root": { {`\A#! ?/.*?\n`, CommentHashbang, nil}, {`^(?=\s|/|<!--)`, Text, Push("slashstartsregex")}, Include("commentsandwhitespace"), {`(\.\d+|[0-9]+\.[0-9]*)([eE][-+]?[0-9]+)?`, LiteralNumberFloat, nil}, {`0[bB][01]+`, LiteralNumberBin, nil}, {`0[oO][0-7]+`, LiteralNumberOct, nil}, {`0[xX][0-9a-fA-F]+`, LiteralNumberHex, nil}, {`[0-9]+`, LiteralNumberInteger, nil}, {`\.\.\.|=>`, Punctuation, nil}, {`\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|(<<|>>>?|==?|!=?|[-<>+*%&|^/])=?`, Operator, Push("slashstartsregex")}, {`[{(\[;,]`, Punctuation, Push("slashstartsregex")}, {`[})\].]`, Punctuation, nil}, {"" /* 192 byte string literal not displayed */, Keyword, Push("slashstartsregex")}, {`(var|let|with|function)\b`, KeywordDeclaration, Push("slashstartsregex")}, {"" /* 195 byte string literal not displayed */, KeywordReserved, nil}, {`(true|false|null|NaN|Infinity|undefined)\b`, KeywordConstant, nil}, {"" /* 247 byte string literal not displayed */, NameBuiltin, nil}, {"" /* 15604 byte string literal not displayed */, NameOther, nil}, {`"(\\\\|\\"|[^"])*"`, LiteralStringDouble, nil}, {`'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil}, {"`", LiteralStringBacktick, Push("interp")}, }, "interp": { {"`", LiteralStringBacktick, Pop(1)}, {`\\\\`, LiteralStringBacktick, nil}, {"\\\\`", LiteralStringBacktick, nil}, {`\$\{`, LiteralStringInterpol, Push("interp-inside")}, {`\$`, LiteralStringBacktick, nil}, {"[^`\\\\$]+", LiteralStringBacktick, nil}, }, "interp-inside": { {`\}`, LiteralStringInterpol, Pop(1)}, Include("root"), }, }, ))
Javascript lexer.
var Json = Register(MustNewLexer( &Config{ Name: "JSON", Aliases: []string{"json"}, Filenames: []string{"*.json"}, MimeTypes: []string{"application/json"}, NotMultiline: true, DotAll: true, }, Rules{ "whitespace": { {`\s+`, Text, nil}, }, "simplevalue": { {`(true|false|null)\b`, KeywordConstant, nil}, {`-?(0|[1-9]\d*)(\.\d+[eE](\+|-)?\d+|[eE](\+|-)?\d+|\.\d+)`, LiteralNumberFloat, nil}, {`-?(0|[1-9]\d*)`, LiteralNumberInteger, nil}, {`"(\\\\|\\"|[^"])*"`, LiteralStringDouble, nil}, }, "objectattribute": { Include("value"), {`:`, Punctuation, nil}, {`,`, Punctuation, Pop(1)}, {`\}`, Punctuation, Pop(2)}, }, "objectvalue": { Include("whitespace"), {`"(\\\\|\\"|[^"])*"`, NameTag, Push("objectattribute")}, {`\}`, Punctuation, Pop(1)}, }, "arrayvalue": { Include("whitespace"), Include("value"), {`,`, Punctuation, nil}, {`\]`, Punctuation, Pop(1)}, }, "value": { Include("whitespace"), Include("simplevalue"), {`\{`, Punctuation, Push("objectvalue")}, {`\[`, Punctuation, Push("arrayvalue")}, }, "root": { Include("value"), }, }, ))
Json lexer.
var Julia = Register(MustNewLexer( &Config{ Name: "Julia", Aliases: []string{"julia", "jl"}, Filenames: []string{"*.jl"}, MimeTypes: []string{"text/x-julia", "application/x-julia"}, }, Rules{ "root": { {`\n`, Text, nil}, {`[^\S\n]+`, Text, nil}, {`#=`, CommentMultiline, Push("blockcomment")}, {`#.*$`, Comment, nil}, {`[\[\]{}(),;]`, Punctuation, nil}, {`in\b`, KeywordPseudo, nil}, {`(true|false)\b`, KeywordConstant, nil}, {`(local|global|const)\b`, KeywordDeclaration, nil}, {Words(``, `\b`, `function`, `type`, `typealias`, `abstract`, `immutable`, `baremodule`, `begin`, `bitstype`, `break`, `catch`, `ccall`, `continue`, `do`, `else`, `elseif`, `end`, `export`, `finally`, `for`, `if`, `import`, `importall`, `let`, `macro`, `module`, `quote`, `return`, `try`, `using`, `while`), Keyword, nil}, {Words(``, `\b`, `ANY`, `ASCIIString`, `AbstractArray`, `AbstractChannel`, `AbstractFloat`, `AbstractMatrix`, `AbstractRNG`, `AbstractSparseArray`, `AbstractSparseMatrix`, `AbstractSparseVector`, `AbstractString`, `AbstractVecOrMat`, `AbstractVector`, `Any`, `ArgumentError`, `Array`, `AssertionError`, `Associative`, `Base64DecodePipe`, `Base64EncodePipe`, `Bidiagonal`, `BigFloat`, `BigInt`, `BitArray`, `BitMatrix`, `BitVector`, `Bool`, `BoundsError`, `Box`, `BufferStream`, `CapturedException`, `CartesianIndex`, `CartesianRange`, `Cchar`, `Cdouble`, `Cfloat`, `Channel`, `Char`, `Cint`, `Cintmax_t`, `Clong`, `Clonglong`, `ClusterManager`, `Cmd`, `Coff_t`, `Colon`, `Complex`, `Complex128`, `Complex32`, `Complex64`, `CompositeException`, `Condition`, `Cptrdiff_t`, `Cshort`, `Csize_t`, `Cssize_t`, `Cstring`, `Cuchar`, `Cuint`, `Cuintmax_t`, `Culong`, `Culonglong`, `Cushort`, `Cwchar_t`, `Cwstring`, `DataType`, `Date`, `DateTime`, `DenseArray`, `DenseMatrix`, `DenseVecOrMat`, `DenseVector`, `Diagonal`, `Dict`, `DimensionMismatch`, `Dims`, `DirectIndexString`, `Display`, `DivideError`, `DomainError`, `EOFError`, `EachLine`, `Enum`, `Enumerate`, `ErrorException`, `Exception`, `Expr`, `Factorization`, `FileMonitor`, `FileOffset`, `Filter`, `Float16`, `Float32`, `Float64`, `FloatRange`, `Function`, `GenSym`, `GlobalRef`, `GotoNode`, `HTML`, `Hermitian`, `IO`, `IOBuffer`, `IOStream`, `IPv4`, `IPv6`, `InexactError`, `InitError`, `Int`, `Int128`, `Int16`, `Int32`, `Int64`, `Int8`, `IntSet`, `Integer`, `InterruptException`, `IntrinsicFunction`, `InvalidStateException`, `Irrational`, `KeyError`, `LabelNode`, `LambdaStaticData`, `LinSpace`, `LineNumberNode`, `LoadError`, `LocalProcess`, `LowerTriangular`, `MIME`, `Matrix`, `MersenneTwister`, `Method`, `MethodError`, `MethodTable`, `Module`, `NTuple`, `NewvarNode`, `NullException`, `Nullable`, `Number`, `ObjectIdDict`, `OrdinalRange`, `OutOfMemoryError`, `OverflowError`, `Pair`, `ParseError`, `PartialQuickSort`, `Pipe`, `PollingFileWatcher`, `ProcessExitedException`, `ProcessGroup`, `Ptr`, `QuoteNode`, `RandomDevice`, `Range`, `Rational`, `RawFD`, `ReadOnlyMemoryError`, `Real`, `ReentrantLock`, `Ref`, `Regex`, `RegexMatch`, `RemoteException`, `RemoteRef`, `RepString`, `RevString`, `RopeString`, `RoundingMode`, `SegmentationFault`, `SerializationState`, `Set`, `SharedArray`, `SharedMatrix`, `SharedVector`, `Signed`, `SimpleVector`, `SparseMatrixCSC`, `StackOverflowError`, `StatStruct`, `StepRange`, `StridedArray`, `StridedMatrix`, `StridedVecOrMat`, `StridedVector`, `SubArray`, `SubString`, `SymTridiagonal`, `Symbol`, `SymbolNode`, `Symmetric`, `SystemError`, `TCPSocket`, `Task`, `Text`, `TextDisplay`, `Timer`, `TopNode`, `Tridiagonal`, `Tuple`, `Type`, `TypeConstructor`, `TypeError`, `TypeName`, `TypeVar`, `UDPSocket`, `UInt`, `UInt128`, `UInt16`, `UInt32`, `UInt64`, `UInt8`, `UTF16String`, `UTF32String`, `UTF8String`, `UndefRefError`, `UndefVarError`, `UnicodeError`, `UniformScaling`, `Union`, `UnitRange`, `Unsigned`, `UpperTriangular`, `Val`, `Vararg`, `VecOrMat`, `Vector`, `VersionNumber`, `Void`, `WString`, `WeakKeyDict`, `WeakRef`, `WorkerConfig`, `Zip`), KeywordType, nil}, {Words(``, `\b`, `ARGS`, `CPU_CORES`, `C_NULL`, `DevNull`, `ENDIAN_BOM`, `ENV`, `I`, `Inf`, `Inf16`, `Inf32`, `Inf64`, `InsertionSort`, `JULIA_HOME`, `LOAD_PATH`, `MergeSort`, `NaN`, `NaN16`, `NaN32`, `NaN64`, `OS_NAME`, `QuickSort`, `RoundDown`, `RoundFromZero`, `RoundNearest`, `RoundNearestTiesAway`, `RoundNearestTiesUp`, `RoundToZero`, `RoundUp`, `STDERR`, `STDIN`, `STDOUT`, `VERSION`, `WORD_SIZE`, `catalan`, `e`, `eu`, `eulergamma`, `golden`, `im`, `nothing`, `pi`, `γ`, `π`, `φ`), NameBuiltin, nil}, {Words(``, ``, `=`, `:=`, `+=`, `-=`, `*=`, `/=`, `//=`, `.//=`, `.*=`, `./=`, `\=`, `.\=`, `^=`, `.^=`, `÷=`, `.÷=`, `%=`, `.%=`, `|=`, `&=`, `$=`, `=>`, `<<=`, `>>=`, `>>>=`, `~`, `.+=`, `.-=`, `?`, `--`, `-->`, `||`, `&&`, `>`, `<`, `>=`, `≥`, `<=`, `≤`, `==`, `===`, `≡`, `!=`, `≠`, `!==`, `≢`, `.>`, `.<`, `.>=`, `.≥`, `.<=`, `.≤`, `.==`, `.!=`, `.≠`, `.=`, `.!`, `<:`, `>:`, `∈`, `∉`, `∋`, `∌`, `⊆`, `⊈`, `⊂`, `⊄`, `⊊`, `|>`, `<|`, `:`, `+`, `-`, `.+`, `.-`, `|`, `∪`, `$`, `<<`, `>>`, `>>>`, `.<<`, `.>>`, `.>>>`, `*`, `/`, `./`, `÷`, `.÷`, `%`, `⋅`, `.%`, `.*`, `\`, `.\`, `&`, `∩`, `//`, `.//`, `^`, `.^`, `::`, `.`, `+`, `-`, `!`, `~`, `√`, `∛`, `∜`), Operator, nil}, {`'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,3}|\\u[a-fA-F0-9]{1,4}|\\U[a-fA-F0-9]{1,6}|[^\\\'\n])'`, LiteralStringChar, nil}, {`(?<=[.\w)\]])\'+`, Operator, nil}, {`"""`, LiteralString, Push("tqstring")}, {`"`, LiteralString, Push("string")}, {`r"""`, LiteralStringRegex, Push("tqregex")}, {`r"`, LiteralStringRegex, Push("regex")}, {"`", LiteralStringBacktick, Push("command")}, {`(?:[a-zA-Z_¡-]|[𐀀-])(?:[a-zA-Z_0-9¡-]|[𐀀-])*!*`, Name, nil}, {`@(?:[a-zA-Z_¡-]|[𐀀-])(?:[a-zA-Z_0-9¡-]|[𐀀-])*!*`, NameDecorator, nil}, {`(\d+(_\d+)+\.\d*|\d*\.\d+(_\d+)+)([eEf][+-]?[0-9]+)?`, LiteralNumberFloat, nil}, {`(\d+\.\d*|\d*\.\d+)([eEf][+-]?[0-9]+)?`, LiteralNumberFloat, nil}, {`\d+(_\d+)+[eEf][+-]?[0-9]+`, LiteralNumberFloat, nil}, {`\d+[eEf][+-]?[0-9]+`, LiteralNumberFloat, nil}, {`0b[01]+(_[01]+)+`, LiteralNumberBin, nil}, {`0b[01]+`, LiteralNumberBin, nil}, {`0o[0-7]+(_[0-7]+)+`, LiteralNumberOct, nil}, {`0o[0-7]+`, LiteralNumberOct, nil}, {`0x[a-fA-F0-9]+(_[a-fA-F0-9]+)+`, LiteralNumberHex, nil}, {`0x[a-fA-F0-9]+`, LiteralNumberHex, nil}, {`\d+(_\d+)+`, LiteralNumberInteger, nil}, {`\d+`, LiteralNumberInteger, nil}, }, "blockcomment": { {`[^=#]`, CommentMultiline, nil}, {`#=`, CommentMultiline, Push()}, {`=#`, CommentMultiline, Pop(1)}, {`[=#]`, CommentMultiline, nil}, }, "string": { {`"`, LiteralString, Pop(1)}, {`\\([\\"\'$nrbtfav]|(x|u|U)[a-fA-F0-9]+|\d+)`, LiteralStringEscape, nil}, {`\$(?:[a-zA-Z_¡-]|[𐀀-])(?:[a-zA-Z_0-9¡-]|[𐀀-])*!*`, LiteralStringInterpol, nil}, {`(\$)(\()`, ByGroups(LiteralStringInterpol, Punctuation), Push("in-intp")}, {`%[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[E-GXc-giorsux%]`, LiteralStringInterpol, nil}, {`.|\s`, LiteralString, nil}, }, "tqstring": { {`"""`, LiteralString, Pop(1)}, {`\\([\\"\'$nrbtfav]|(x|u|U)[a-fA-F0-9]+|\d+)`, LiteralStringEscape, nil}, {`\$(?:[a-zA-Z_¡-]|[𐀀-])(?:[a-zA-Z_0-9¡-]|[𐀀-])*!*`, LiteralStringInterpol, nil}, {`(\$)(\()`, ByGroups(LiteralStringInterpol, Punctuation), Push("in-intp")}, {`.|\s`, LiteralString, nil}, }, "regex": { {`"`, LiteralStringRegex, Pop(1)}, {`\\"`, LiteralStringRegex, nil}, {`.|\s`, LiteralStringRegex, nil}, }, "tqregex": { {`"""`, LiteralStringRegex, Pop(1)}, {`.|\s`, LiteralStringRegex, nil}, }, "command": { {"`", LiteralStringBacktick, Pop(1)}, {`\$(?:[a-zA-Z_¡-]|[𐀀-])(?:[a-zA-Z_0-9¡-]|[𐀀-])*!*`, LiteralStringInterpol, nil}, {`(\$)(\()`, ByGroups(LiteralStringInterpol, Punctuation), Push("in-intp")}, {`.|\s`, LiteralStringBacktick, nil}, }, "in-intp": { {`\(`, Punctuation, Push()}, {`\)`, Punctuation, Pop(1)}, Include("root"), }, }, ))
Julia lexer.
var Kotlin = Register(MustNewLexer( &Config{ Name: "Kotlin", Aliases: []string{"kotlin"}, Filenames: []string{"*.kt"}, MimeTypes: []string{"text/x-kotlin"}, DotAll: true, }, Rules{ "root": { {`^\s*\[.*?\]`, NameAttribute, nil}, {`[^\S\n]+`, Text, nil}, {`\\\n`, Text, nil}, {`//.*?\n`, CommentSingle, nil}, {`/[*].*?[*]/`, CommentMultiline, nil}, {`\n`, Text, nil}, {`::|!!|\?[:.]`, Operator, nil}, {`[~!%^&*()+=|\[\]:;,.<>/?-]`, Punctuation, nil}, {`[{}]`, Punctuation, nil}, {`@"(""|[^"])*"`, LiteralString, nil}, {`"(\\\\|\\"|[^"\n])*["\n]`, LiteralString, nil}, {`'\\.'|'[^\\]'`, LiteralStringChar, nil}, {`[0-9](\.[0-9]*)?([eE][+-][0-9]+)?[flFL]?|0[xX][0-9a-fA-F]+[Ll]?`, LiteralNumber, nil}, {`(class)(\s+)(object)`, ByGroups(Keyword, Text, Keyword), nil}, {`(class|interface|object)(\s+)`, ByGroups(Keyword, Text), Push("class")}, {`(package|import)(\s+)`, ByGroups(Keyword, Text), Push("package")}, {`(val|var)(\s+)`, ByGroups(Keyword, Text), Push("property")}, {`(fun)(\s+)`, ByGroups(Keyword, Text), Push("function")}, {"" /* 401 byte string literal not displayed */, Keyword, nil}, {"" /* 41011 byte string literal not displayed */, Name, nil}, }, "package": { {`\S+`, NameNamespace, Pop(1)}, }, "class": { {"" /* 41011 byte string literal not displayed */, NameClass, Pop(1)}, }, "property": { {"" /* 41011 byte string literal not displayed */, NameProperty, Pop(1)}, }, "function": { {"" /* 41011 byte string literal not displayed */, NameFunction, Pop(1)}, }, }, ))
Kotlin lexer.
var Lighttpd = Register(MustNewLexer( &Config{ Name: "Lighttpd configuration file", Aliases: []string{"lighty", "lighttpd"}, Filenames: []string{}, MimeTypes: []string{"text/x-lighttpd-conf"}, }, Rules{ "root": { {`#.*\n`, CommentSingle, nil}, {`/\S*`, Name, nil}, {`[a-zA-Z._-]+`, Keyword, nil}, {`\d+\.\d+\.\d+\.\d+(?:/\d+)?`, LiteralNumber, nil}, {`[0-9]+`, LiteralNumber, nil}, {`=>|=~|\+=|==|=|\+`, Operator, nil}, {`\$[A-Z]+`, NameBuiltin, nil}, {`[(){}\[\],]`, Punctuation, nil}, {`"([^"\\]*(?:\\.[^"\\]*)*)"`, LiteralStringDouble, nil}, {`\s+`, Text, nil}, }, }, ))
Lighttpd Configuration File lexer.
var Llvm = Register(MustNewLexer( &Config{ Name: "LLVM", Aliases: []string{"llvm"}, Filenames: []string{"*.ll"}, MimeTypes: []string{"text/x-llvm"}, }, Rules{ "root": { Include("whitespace"), {`([-a-zA-Z$._][\w\-$.]*|"[^"]*?")\s*:`, NameLabel, nil}, Include("keyword"), {`%([-a-zA-Z$._][\w\-$.]*|"[^"]*?")`, NameVariable, nil}, {`@([-a-zA-Z$._][\w\-$.]*|"[^"]*?")`, NameVariableGlobal, nil}, {`%\d+`, NameVariableAnonymous, nil}, {`@\d+`, NameVariableGlobal, nil}, {`#\d+`, NameVariableGlobal, nil}, {`!([-a-zA-Z$._][\w\-$.]*|"[^"]*?")`, NameVariable, nil}, {`!\d+`, NameVariableAnonymous, nil}, {`c?"[^"]*?"`, LiteralString, nil}, {`0[xX][a-fA-F0-9]+`, LiteralNumber, nil}, {`-?\d+(?:[.]\d+)?(?:[eE][-+]?\d+(?:[.]\d+)?)?`, LiteralNumber, nil}, {`[=<>{}\[\]()*.,!]|x\b`, Punctuation, nil}, }, "whitespace": { {`(\n|\s)+`, Text, nil}, {`;.*?\n`, Comment, nil}, }, "keyword": { {Words(``, `\b`, `begin`, `end`, `true`, `false`, `declare`, `define`, `global`, `constant`, `private`, `linker_private`, `internal`, `available_externally`, `linkonce`, `linkonce_odr`, `weak`, `weak_odr`, `appending`, `dllimport`, `dllexport`, `common`, `default`, `hidden`, `protected`, `extern_weak`, `external`, `thread_local`, `zeroinitializer`, `undef`, `null`, `to`, `tail`, `target`, `triple`, `datalayout`, `volatile`, `nuw`, `nsw`, `nnan`, `ninf`, `nsz`, `arcp`, `fast`, `exact`, `inbounds`, `align`, `addrspace`, `section`, `alias`, `module`, `asm`, `sideeffect`, `gc`, `dbg`, `linker_private_weak`, `attributes`, `blockaddress`, `initialexec`, `localdynamic`, `localexec`, `prefix`, `unnamed_addr`, `ccc`, `fastcc`, `coldcc`, `x86_stdcallcc`, `x86_fastcallcc`, `arm_apcscc`, `arm_aapcscc`, `arm_aapcs_vfpcc`, `ptx_device`, `ptx_kernel`, `intel_ocl_bicc`, `msp430_intrcc`, `spir_func`, `spir_kernel`, `x86_64_sysvcc`, `x86_64_win64cc`, `x86_thiscallcc`, `cc`, `c`, `signext`, `zeroext`, `inreg`, `sret`, `nounwind`, `noreturn`, `noalias`, `nocapture`, `byval`, `nest`, `readnone`, `readonly`, `inlinehint`, `noinline`, `alwaysinline`, `optsize`, `ssp`, `sspreq`, `noredzone`, `noimplicitfloat`, `naked`, `builtin`, `cold`, `nobuiltin`, `noduplicate`, `nonlazybind`, `optnone`, `returns_twice`, `sanitize_address`, `sanitize_memory`, `sanitize_thread`, `sspstrong`, `uwtable`, `returned`, `type`, `opaque`, `eq`, `ne`, `slt`, `sgt`, `sle`, `sge`, `ult`, `ugt`, `ule`, `uge`, `oeq`, `one`, `olt`, `ogt`, `ole`, `oge`, `ord`, `uno`, `ueq`, `une`, `x`, `acq_rel`, `acquire`, `alignstack`, `atomic`, `catch`, `cleanup`, `filter`, `inteldialect`, `max`, `min`, `monotonic`, `nand`, `personality`, `release`, `seq_cst`, `singlethread`, `umax`, `umin`, `unordered`, `xchg`, `add`, `fadd`, `sub`, `fsub`, `mul`, `fmul`, `udiv`, `sdiv`, `fdiv`, `urem`, `srem`, `frem`, `shl`, `lshr`, `ashr`, `and`, `or`, `xor`, `icmp`, `fcmp`, `phi`, `call`, `trunc`, `zext`, `sext`, `fptrunc`, `fpext`, `uitofp`, `sitofp`, `fptoui`, `fptosi`, `inttoptr`, `ptrtoint`, `bitcast`, `addrspacecast`, `select`, `va_arg`, `ret`, `br`, `switch`, `invoke`, `unwind`, `unreachable`, `indirectbr`, `landingpad`, `resume`, `malloc`, `alloca`, `free`, `load`, `store`, `getelementptr`, `extractelement`, `insertelement`, `shufflevector`, `getresult`, `extractvalue`, `insertvalue`, `atomicrmw`, `cmpxchg`, `fence`, `allocsize`, `amdgpu_cs`, `amdgpu_gs`, `amdgpu_kernel`, `amdgpu_ps`, `amdgpu_vs`, `any`, `anyregcc`, `argmemonly`, `avr_intrcc`, `avr_signalcc`, `caller`, `catchpad`, `catchret`, `catchswitch`, `cleanuppad`, `cleanupret`, `comdat`, `convergent`, `cxx_fast_tlscc`, `deplibs`, `dereferenceable`, `dereferenceable_or_null`, `distinct`, `exactmatch`, `externally_initialized`, `from`, `ghccc`, `hhvm_ccc`, `hhvmcc`, `ifunc`, `inaccessiblemem_or_argmemonly`, `inaccessiblememonly`, `inalloca`, `jumptable`, `largest`, `local_unnamed_addr`, `minsize`, `musttail`, `noduplicates`, `none`, `nonnull`, `norecurse`, `notail`, `preserve_allcc`, `preserve_mostcc`, `prologue`, `safestack`, `samesize`, `source_filename`, `swiftcc`, `swifterror`, `swiftself`, `webkit_jscc`, `within`, `writeonly`, `x86_intrcc`, `x86_vectorcallcc`), Keyword, nil}, {Words(``, ``, `void`, `half`, `float`, `double`, `x86_fp80`, `fp128`, `ppc_fp128`, `label`, `metadata`, `token`), KeywordType, nil}, {`i[1-9]\d*`, Keyword, nil}, }, }, ))
Llvm lexer.
var Lua = Register(MustNewLexer( &Config{ Name: "Lua", Aliases: []string{"lua"}, Filenames: []string{"*.lua", "*.wlua"}, MimeTypes: []string{"text/x-lua", "application/x-lua"}, }, Rules{ "root": { {`#!.*`, CommentPreproc, nil}, Default(Push("base")), }, "ws": { {`(?:--\[(=*)\[[\w\W]*?\](\1)\])`, CommentMultiline, nil}, {`(?:--.*$)`, CommentSingle, nil}, {`(?:\s+)`, Text, nil}, }, "base": { Include("ws"), {`(?i)0x[\da-f]*(\.[\da-f]*)?(p[+-]?\d+)?`, LiteralNumberHex, nil}, {`(?i)(\d*\.\d+|\d+\.\d*)(e[+-]?\d+)?`, LiteralNumberFloat, nil}, {`(?i)\d+e[+-]?\d+`, LiteralNumberFloat, nil}, {`\d+`, LiteralNumberInteger, nil}, {`(?s)\[(=*)\[.*?\]\1\]`, LiteralString, nil}, {`::`, Punctuation, Push("label")}, {`\.{3}`, Punctuation, nil}, {`[=<>|~&+\-*/%#^]+|\.\.`, Operator, nil}, {`[\[\]{}().,:;]`, Punctuation, nil}, {`(and|or|not)\b`, OperatorWord, nil}, {`(break|do|else|elseif|end|for|if|in|repeat|return|then|until|while)\b`, KeywordReserved, nil}, {`goto\b`, KeywordReserved, Push("goto")}, {`(local)\b`, KeywordDeclaration, nil}, {`(true|false|nil)\b`, KeywordConstant, nil}, {`(function)\b`, KeywordReserved, Push("funcname")}, {`[A-Za-z_]\w*(\.[A-Za-z_]\w*)?`, Name, nil}, {`'`, LiteralStringSingle, Combined("stringescape", "sqs")}, {`"`, LiteralStringDouble, Combined("stringescape", "dqs")}, }, "funcname": { Include("ws"), {`[.:]`, Punctuation, nil}, {`(?:[^\W\d]\w*)(?=(?:(?:--\[(=*)\[[\w\W]*?\](\2)\])|(?:--.*$)|(?:\s+))*[.:])`, NameClass, nil}, {`(?:[^\W\d]\w*)`, NameFunction, Pop(1)}, {`\(`, Punctuation, Pop(1)}, }, "goto": { Include("ws"), {`(?:[^\W\d]\w*)`, NameLabel, Pop(1)}, }, "label": { Include("ws"), {`::`, Punctuation, Pop(1)}, {`(?:[^\W\d]\w*)`, NameLabel, nil}, }, "stringescape": { {`\\([abfnrtv\\"\']|[\r\n]{1,2}|z\s*|x[0-9a-fA-F]{2}|\d{1,3}|u\{[0-9a-fA-F]+\})`, LiteralStringEscape, nil}, }, "sqs": { {`'`, LiteralStringSingle, Pop(1)}, {`[^\\']+`, LiteralStringSingle, nil}, }, "dqs": { {`"`, LiteralStringDouble, Pop(1)}, {`[^\\"]+`, LiteralStringDouble, nil}, }, }, ))
Lua lexer.
var MZN = Register(MustNewLexer( &Config{ Name: "MiniZinc", Aliases: []string{"minizinc", "MZN", "mzn"}, Filenames: []string{"*.mzn", "*.dzn", "*.fzn"}, MimeTypes: []string{"text/minizinc"}, }, Rules{ "root": { {`\n`, Text, nil}, {`\s+`, Text, nil}, {`\\\n`, Text, nil}, {`\%(.*?)\n`, CommentSingle, nil}, {`/(\\\n)?[*](.|\n)*?[*](\\\n)?/`, CommentMultiline, nil}, {`"(\\\\|\\"|[^"])*"`, LiteralString, nil}, {Words(`\b`, `\b`, `ann`, `annotation`, `any`, `constraint`, `function`, `include`, `list`, `of`, `op`, `output`, `minimize`, `maximize`, `par`, `predicate`, `record`, `satisfy`, `solve`, `test`, `type`, `var`), Keyword, nil}, {Words(`\b`, `\b`, `array`, `set`, `bool`, `enum`, `float`, `int`, `string`, `tuple`), KeywordType, nil}, {Words(`\b`, `\b`, `for`, `forall`, `if`, `then`, `else`, `endif`, `where`), Keyword, nil}, {Words(`\b`, `\b`, `abort`, `abs`, `acosh`, `array_intersect`, `array_union`, `array1d`, `array2d`, `array3d`, `array4d`, `array5d`, `array6d`, `asin`, `assert`, `atan`, `bool2int`, `card`, `ceil`, `concat`, `cos`, `cosh`, `dom`, `dom_array`, `dom_size`, `fix`, `exp`, `floor`, `index_set`, `index_set_1of2`, `index_set_2of2`, `index_set_1of3`, `index_set_2of3`, `index_set_3of3`, `int2float`, `is_fixed`, `join`, `lb`, `lb_array`, `length`, `ln`, `log`, `log2`, `log10`, `min`, `max`, `pow`, `product`, `round`, `set2array`, `show`, `show_int`, `show_float`, `sin`, `sinh`, `sqrt`, `sum`, `tan`, `tanh`, `trace`, `ub`, `ub_array`), NameBuiltin, nil}, {`(not|<->|->|<-|\\/|xor|/\\)`, Operator, nil}, {`(<|>|<=|>=|==|=|!=)`, Operator, nil}, {`(\+|-|\*|/|div|mod)`, Operator, nil}, {Words(`\b`, `\b`, `in`, `subset`, `superset`, `union`, `diff`, `symdiff`, `intersect`), Operator, nil}, {`(\\|\.\.|\+\+)`, Operator, nil}, {`[|()\[\]{},:;]`, Punctuation, nil}, {`(true|false)\b`, KeywordConstant, nil}, {`([+-]?)\d+(\.(?!\.)\d*)?([eE][-+]?\d+)?`, LiteralNumber, nil}, {`::\s*([^\W\d]\w*)(\s*\([^\)]*\))?`, NameDecorator, nil}, {`\b([^\W\d]\w*)\b(\()`, ByGroups(NameFunction, Punctuation), nil}, {`[^\W\d]\w*`, NameOther, nil}, }, }, ))
MiniZinc lexer.
var Makefile = Register(MustNewLexer( &Config{ Name: "Base Makefile", Aliases: []string{"make", "makefile", "mf", "bsdmake"}, Filenames: []string{"*.mak", "*.mk", "Makefile", "makefile", "Makefile.*", "GNUmakefile"}, MimeTypes: []string{"text/x-makefile"}, EnsureNL: true, }, Rules{ "root": { {`^(?:[\t ]+.*\n|\n)+`, Using(Bash, nil), nil}, {`\$[<@$+%?|*]`, Keyword, nil}, {`\s+`, Text, nil}, {`#.*?\n`, Comment, nil}, {`(export)(\s+)(?=[\w${}\t -]+\n)`, ByGroups(Keyword, Text), Push("export")}, {`export\s+`, Keyword, nil}, {`([\w${}().-]+)(\s*)([!?:+]?=)([ \t]*)((?:.*\\\n)+|.*\n)`, ByGroups(NameVariable, Text, Operator, Text, Using(Bash, nil)), nil}, {`(?s)"(\\\\|\\.|[^"\\])*"`, LiteralStringDouble, nil}, {`(?s)'(\\\\|\\.|[^'\\])*'`, LiteralStringSingle, nil}, {`([^\n:]+)(:+)([ \t]*)`, ByGroups(NameFunction, Operator, Text), Push("block-header")}, {`\$\(`, Keyword, Push("expansion")}, }, "expansion": { {`[^$a-zA-Z_()]+`, Text, nil}, {`[a-zA-Z_]+`, NameVariable, nil}, {`\$`, Keyword, nil}, {`\(`, Keyword, Push()}, {`\)`, Keyword, Pop(1)}, }, "export": { {`[\w${}-]+`, NameVariable, nil}, {`\n`, Text, Pop(1)}, {`\s+`, Text, nil}, }, "block-header": { {`[,|]`, Punctuation, nil}, {`#.*?\n`, Comment, Pop(1)}, {`\\\n`, Text, nil}, {`\$\(`, Keyword, Push("expansion")}, {`[a-zA-Z_]+`, Name, nil}, {`\n`, Text, Pop(1)}, {`.`, Text, nil}, }, }, ))
Makefile lexer.
var Mako = Register(MustNewLexer( &Config{ Name: "Mako", Aliases: []string{"mako"}, Filenames: []string{"*.mao"}, MimeTypes: []string{"application/x-mako"}, }, Rules{ "root": { {`(\s*)(%)(\s*end(?:\w+))(\n|\Z)`, ByGroups(Text, CommentPreproc, Keyword, Other), nil}, {`(\s*)(%)([^\n]*)(\n|\Z)`, ByGroups(Text, CommentPreproc, Using(Python, nil), Other), nil}, {`(\s*)(##[^\n]*)(\n|\Z)`, ByGroups(Text, CommentPreproc, Other), nil}, {`(?s)<%doc>.*?</%doc>`, CommentPreproc, nil}, {`(<%)([\w.:]+)`, ByGroups(CommentPreproc, NameBuiltin), Push("tag")}, {`(</%)([\w.:]+)(>)`, ByGroups(CommentPreproc, NameBuiltin, CommentPreproc), nil}, {`<%(?=([\w.:]+))`, CommentPreproc, Push("ondeftags")}, {`(<%(?:!?))(.*?)(%>)(?s)`, ByGroups(CommentPreproc, Using(Python, nil), CommentPreproc), nil}, {`(\$\{)(.*?)(\})`, ByGroups(CommentPreproc, Using(Python, nil), CommentPreproc), nil}, {"" /* 606 byte string literal not displayed */, ByGroups(Other, Operator), nil}, {`\s+`, Text, nil}, }, "ondeftags": { {`<%`, CommentPreproc, nil}, {`(?<=<%)(include|inherit|namespace|page)`, NameBuiltin, nil}, Include("tag"), }, "tag": { {`((?:\w+)\s*=)(\s*)(".*?")`, ByGroups(NameAttribute, Text, LiteralString), nil}, {`/?\s*>`, CommentPreproc, Pop(1)}, {`\s+`, Text, nil}, }, "attr": { {`".*?"`, LiteralString, Pop(1)}, {`'.*?'`, LiteralString, Pop(1)}, {`[^\s>]+`, LiteralString, Pop(1)}, }, }, ))
Mako lexer.
var Markdown = Register(MustNewLexer( &Config{ Name: "markdown", Aliases: []string{"md", "mkd"}, Filenames: []string{"*.md", "*.mkd", "*.markdown"}, MimeTypes: []string{"text/x-markdown"}, }, Rules{ "root": { {`^(#)([^#].+\n)`, ByGroups(GenericHeading, Text), nil}, {`^(#{2,6})(.+\n)`, ByGroups(GenericSubheading, Text), nil}, {`^(\s*)([*-] )(\[[ xX]\])( .+\n)`, ByGroups(Text, Keyword, Keyword, UsingSelf("inline")), nil}, {`^(\s*)([*-])(\s)(.+\n)`, ByGroups(Text, Keyword, Text, UsingSelf("inline")), nil}, {`^(\s*)([0-9]+\.)( .+\n)`, ByGroups(Text, Keyword, UsingSelf("inline")), nil}, {`^(\s*>\s)(.+\n)`, ByGroups(Keyword, GenericEmph), nil}, {"^(```\\n)([\\w\\W]*?)(^```$)", ByGroups(LiteralString, Text, LiteralString), nil}, {"^(```)(\\w+)(\\n)([\\w\\W]*?)(^```$)", EmitterFunc(markdownCodeBlock), nil}, Include("inline"), }, "inline": { {`\\.`, Text, nil}, {`(\s)([*_][^*_]+[*_])(\W|\n)`, ByGroups(Text, GenericEmph, Text), nil}, {`(\s)((\*\*|__).*\3)((?=\W|\n))`, ByGroups(Text, GenericStrong, None, Text), nil}, {`(\s)(~~[^~]+~~)((?=\W|\n))`, ByGroups(Text, GenericDeleted, Text), nil}, {"`[^`]+`", LiteralStringBacktick, nil}, {`[@#][\w/:]+`, NameEntity, nil}, {`(!?\[)([^]]+)(\])(\()([^)]+)(\))`, ByGroups(Text, NameTag, Text, Text, NameAttribute, Text), nil}, {`[^\\\s]+`, Text, nil}, {`.`, Text, nil}, }, }, ))
Markdown lexer.
var Mason = Register(MustNewLexer( &Config{ Name: "Mason", Aliases: []string{"mason"}, Filenames: []string{"*.m", "*.mhtml", "*.mc", "*.mi", "autohandler", "dhandler"}, MimeTypes: []string{"application/x-mason"}, Priority: 0.1, }, Rules{ "root": { {`\s+`, Text, nil}, {`(<%doc>)(.*?)(</%doc>)(?s)`, ByGroups(NameTag, CommentMultiline, NameTag), nil}, {`(<%(?:def|method))(\s*)(.*?)(>)(.*?)(</%\2\s*>)(?s)`, ByGroups(NameTag, Text, NameFunction, NameTag, UsingSelf("root"), NameTag), nil}, {`(<%\w+)(.*?)(>)(.*?)(</%\2\s*>)(?s)`, ByGroups(NameTag, NameFunction, NameTag, Using(Perl, nil), NameTag), nil}, {`(<&[^|])(.*?)(,.*?)?(&>)(?s)`, ByGroups(NameTag, NameFunction, Using(Perl, nil), NameTag), nil}, {`(<&\|)(.*?)(,.*?)?(&>)(?s)`, ByGroups(NameTag, NameFunction, Using(Perl, nil), NameTag), nil}, {`</&>`, NameTag, nil}, {`(<%!?)(.*?)(%>)(?s)`, ByGroups(NameTag, Using(Perl, nil), NameTag), nil}, {`(?<=^)#[^\n]*(\n|\Z)`, Comment, nil}, {`(?<=^)(%)([^\n]*)(\n|\Z)`, ByGroups(NameTag, Using(Perl, nil), Other), nil}, {"" /* 461 byte string literal not displayed */, ByGroups(Using(HTML, nil), Operator), nil}, }, }, ))
Mason lexer.
var Mathematica = Register(MustNewLexer( &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{ "root": { {`(?s)\(\*.*?\*\)`, Comment, nil}, {"([a-zA-Z]+[A-Za-z0-9]*`)", NameNamespace, nil}, {`([A-Za-z0-9]*_+[A-Za-z0-9]*)`, NameVariable, nil}, {`#\d*`, NameVariable, nil}, {`([a-zA-Z]+[a-zA-Z0-9]*)`, Name, nil}, {`-?\d+\.\d*`, LiteralNumberFloat, nil}, {`-?\d*\.\d+`, LiteralNumberFloat, nil}, {`-?\d+`, LiteralNumberInteger, nil}, {Words(``, ``, `;;`, `=`, `=.`, `!===`, `:=`, `->`, `:>`, `/.`, `+`, `-`, `*`, `/`, `^`, `&&`, `||`, `!`, `<>`, `|`, `/;`, `?`, `@`, `//`, `/@`, `@@`, `@@@`, `~~`, `===`, `&`, `<`, `>`, `<=`, `>=`), Operator, nil}, {Words(``, ``, `,`, `;`, `(`, `)`, `[`, `]`, `{`, `}`), Punctuation, nil}, {`".*?"`, LiteralString, nil}, {`\s+`, TextWhitespace, nil}, }, }, ))
Mathematica lexer.
var Modula2 = Register(MustNewLexer( &Config{ Name: "Modula-2", Aliases: []string{"modula2", "m2"}, Filenames: []string{"*.def", "*.mod"}, MimeTypes: []string{"text/x-modula2"}, DotAll: true, }, Rules{ "whitespace": { {`\n+`, Text, nil}, {`\s+`, Text, nil}, }, "dialecttags": { {`\(\*!m2pim\*\)`, CommentSpecial, nil}, {`\(\*!m2iso\*\)`, CommentSpecial, nil}, {`\(\*!m2r10\*\)`, CommentSpecial, nil}, {`\(\*!objm2\*\)`, CommentSpecial, nil}, {`\(\*!m2iso\+aglet\*\)`, CommentSpecial, nil}, {`\(\*!m2pim\+gm2\*\)`, CommentSpecial, nil}, {`\(\*!m2iso\+p1\*\)`, CommentSpecial, nil}, {`\(\*!m2iso\+xds\*\)`, CommentSpecial, nil}, }, "identifiers": { {`([a-zA-Z_$][\w$]*)`, Name, nil}, }, "prefixed_number_literals": { {`0b[01]+(\'[01]+)*`, LiteralNumberBin, nil}, {`0[ux][0-9A-F]+(\'[0-9A-F]+)*`, LiteralNumberHex, nil}, }, "plain_number_literals": { {`[0-9]+(\'[0-9]+)*\.[0-9]+(\'[0-9]+)*[eE][+-]?[0-9]+(\'[0-9]+)*`, LiteralNumberFloat, nil}, {`[0-9]+(\'[0-9]+)*\.[0-9]+(\'[0-9]+)*`, LiteralNumberFloat, nil}, {`[0-9]+(\'[0-9]+)*`, LiteralNumberInteger, nil}, }, "suffixed_number_literals": { {`[0-7]+B`, LiteralNumberOct, nil}, {`[0-7]+C`, LiteralNumberOct, nil}, {`[0-9A-F]+H`, LiteralNumberHex, nil}, }, "string_literals": { {`'(\\\\|\\'|[^'])*'`, LiteralString, nil}, {`"(\\\\|\\"|[^"])*"`, LiteralString, nil}, }, "digraph_operators": { {`\*\.`, Operator, nil}, {`\+>`, Operator, nil}, {`<>`, Operator, nil}, {`<=`, Operator, nil}, {`>=`, Operator, nil}, {`==`, Operator, nil}, {`::`, Operator, nil}, {`:=`, Operator, nil}, {`\+\+`, Operator, nil}, {`--`, Operator, nil}, }, "unigraph_operators": { {`[+-]`, Operator, nil}, {`[*/]`, Operator, nil}, {`\\`, Operator, nil}, {`[=#<>]`, Operator, nil}, {`\^`, Operator, nil}, {`@`, Operator, nil}, {`&`, Operator, nil}, {`~`, Operator, nil}, {"`", Operator, nil}, }, "digraph_punctuation": { {`\.\.`, Punctuation, nil}, {`<<`, Punctuation, nil}, {`>>`, Punctuation, nil}, {`->`, Punctuation, nil}, {`\|#`, Punctuation, nil}, {`##`, Punctuation, nil}, {`\|\*`, Punctuation, nil}, }, "unigraph_punctuation": { {`[()\[\]{},.:;|]`, Punctuation, nil}, {`!`, Punctuation, nil}, {`\?`, Punctuation, nil}, }, "comments": { {`^//.*?\n`, CommentSingle, nil}, {`\(\*([^$].*?)\*\)`, CommentMultiline, nil}, {`/\*(.*?)\*/`, CommentMultiline, nil}, }, "pragmas": { {`<\*.*?\*>`, CommentPreproc, nil}, {`\(\*\$.*?\*\)`, CommentPreproc, nil}, }, "root": { Include("whitespace"), Include("dialecttags"), Include("pragmas"), Include("comments"), Include("identifiers"), Include("suffixed_number_literals"), Include("prefixed_number_literals"), Include("plain_number_literals"), Include("string_literals"), Include("digraph_punctuation"), Include("digraph_operators"), Include("unigraph_punctuation"), Include("unigraph_operators"), }, }, ))
Modula-2 lexer.
var MorrowindScript = Register(MustNewLexer( &Config{ Name: "MorrowindScript", Aliases: []string{"morrowind", "mwscript"}, Filenames: []string{}, MimeTypes: []string{}, }, Rules{ "root": { {`\s+`, Text, nil}, {`;.*$`, Comment, nil}, {`(["'])(?:(?=(\\?))\2.)*?\1`, LiteralString, nil}, {`[0-9]+`, LiteralNumberInteger, nil}, {`[0-9]+\.[0-9]*(?!\.)`, LiteralNumberFloat, nil}, Include("keywords"), Include("types"), Include("builtins"), Include("punct"), Include("operators"), {`\n`, Text, nil}, {`\S+\s+`, Text, nil}, {`[a-zA-Z0-9_]\w*`, Name, nil}, }, "keywords": { {`(?i)(begin|if|else|elseif|endif|while|endwhile|return|to)\b`, Keyword, nil}, {`(?i)(end)\b`, Keyword, nil}, {`(?i)(end)\w+.*$`, Text, nil}, {`[\w+]->[\w+]`, Operator, nil}, }, "builtins": { {"" /* 6138 byte string literal not displayed */, NameBuiltin, nil}, {"" /* 2895 byte string literal not displayed */, NameBuiltin, nil}, }, "types": { {`(?i)(short|long|float)\b`, KeywordType, nil}, }, "punct": { {`[()]`, Punctuation, nil}, }, "operators": { {`[#=,./%+\-?]`, Operator, nil}, {`(==|<=|<|>=|>|!=)`, Operator, nil}, }, }, ))
MorrowindScript lexer.
var MySQL = Register(MustNewLexer( &Config{ Name: "MySQL", Aliases: []string{"mysql"}, Filenames: []string{"*.sql"}, MimeTypes: []string{"text/x-mysql"}, NotMultiline: true, CaseInsensitive: true, }, Rules{ "root": { {`\s+`, Text, nil}, {`(#|--\s+).*\n?`, CommentSingle, nil}, {`/\*`, CommentMultiline, Push("multiline-comments")}, {`[0-9]+`, LiteralNumberInteger, nil}, {`[0-9]*\.[0-9]+(e[+-][0-9]+)`, LiteralNumberFloat, nil}, {`((?:_[a-z0-9]+)?)(')`, ByGroups(LiteralStringAffix, LiteralStringSingle), Push("string")}, {`((?:_[a-z0-9]+)?)(")`, ByGroups(LiteralStringAffix, LiteralStringDouble), Push("double-string")}, {"[+*/<>=~!@#%^&|`?-]", Operator, nil}, {"" /* 276 byte string literal not displayed */, ByGroups(KeywordType, Text, Punctuation), nil}, {"" /* 1589 byte string literal not displayed */, Keyword, nil}, {`\b(auto_increment|engine|charset|tables)\b`, KeywordPseudo, nil}, {`(true|false|null)`, NameConstant, nil}, {`([a-z_]\w*)(\s*)(\()`, ByGroups(NameFunction, Text, Punctuation), nil}, {`[a-z_]\w*`, Name, nil}, {`@[a-z0-9]*[._]*[a-z0-9]*`, NameVariable, nil}, {`[;:()\[\],.]`, Punctuation, nil}, }, "multiline-comments": { {`/\*`, CommentMultiline, Push("multiline-comments")}, {`\*/`, CommentMultiline, Pop(1)}, {`[^/*]+`, CommentMultiline, nil}, {`[/*]`, CommentMultiline, nil}, }, "string": { {`[^']+`, LiteralStringSingle, nil}, {`''`, LiteralStringSingle, nil}, {`'`, LiteralStringSingle, Pop(1)}, }, "double-string": { {`[^"]+`, LiteralStringDouble, nil}, {`""`, LiteralStringDouble, nil}, {`"`, LiteralStringDouble, Pop(1)}, }, }, ))
MySQL lexer.
var Myghty = Register(MustNewLexer( &Config{ Name: "Myghty", Aliases: []string{"myghty"}, Filenames: []string{"*.myt", "autodelegate"}, MimeTypes: []string{"application/x-myghty"}, }, Rules{ "root": { {`\s+`, Text, nil}, {`(<%(?:def|method))(\s*)(.*?)(>)(.*?)(</%\2\s*>)(?s)`, ByGroups(NameTag, Text, NameFunction, NameTag, UsingSelf("root"), NameTag), nil}, {`(<%\w+)(.*?)(>)(.*?)(</%\2\s*>)(?s)`, ByGroups(NameTag, NameFunction, NameTag, Using(Python, nil), NameTag), nil}, {`(<&[^|])(.*?)(,.*?)?(&>)`, ByGroups(NameTag, NameFunction, Using(Python, nil), NameTag), nil}, {`(<&\|)(.*?)(,.*?)?(&>)(?s)`, ByGroups(NameTag, NameFunction, Using(Python, nil), NameTag), nil}, {`</&>`, NameTag, nil}, {`(<%!?)(.*?)(%>)(?s)`, ByGroups(NameTag, Using(Python, nil), NameTag), nil}, {`(?<=^)#[^\n]*(\n|\Z)`, Comment, nil}, {`(?<=^)(%)([^\n]*)(\n|\Z)`, ByGroups(NameTag, Using(Python, nil), Other), nil}, {"" /* 461 byte string literal not displayed */, ByGroups(Other, Operator), nil}, }, }, ))
Myghty lexer.
var Nasm = Register(MustNewLexer( &Config{ Name: "NASM", Aliases: []string{"nasm"}, Filenames: []string{"*.asm", "*.ASM"}, MimeTypes: []string{"text/x-nasm"}, CaseInsensitive: true, }, Rules{ "root": { {`^\s*%`, CommentPreproc, Push("preproc")}, Include("whitespace"), {`[a-z$._?][\w$.?#@~]*:`, NameLabel, nil}, {`([a-z$._?][\w$.?#@~]*)(\s+)(equ)`, ByGroups(NameConstant, KeywordDeclaration, KeywordDeclaration), Push("instruction-args")}, {"" /* 138 byte string literal not displayed */, Keyword, Push("instruction-args")}, {`(?:res|d)[bwdqt]|times`, KeywordDeclaration, Push("instruction-args")}, {`[a-z$._?][\w$.?#@~]*`, NameFunction, Push("instruction-args")}, {`[\r\n]+`, Text, nil}, }, "instruction-args": { {"\"(\\\\\"|[^\"\\n])*\"|'(\\\\'|[^'\\n])*'|`(\\\\`|[^`\\n])*`", LiteralString, nil}, {`(?:0x[0-9a-f]+|$0[0-9a-f]*|[0-9]+[0-9a-f]*h)`, LiteralNumberHex, nil}, {`[0-7]+q`, LiteralNumberOct, nil}, {`[01]+b`, LiteralNumberBin, nil}, {`[0-9]+\.e?[0-9]+`, LiteralNumberFloat, nil}, {`[0-9]+`, LiteralNumberInteger, nil}, Include("punctuation"), {`r[0-9][0-5]?[bwd]|[a-d][lh]|[er]?[a-d]x|[er]?[sb]p|[er]?[sd]i|[c-gs]s|st[0-7]|mm[0-7]|cr[0-4]|dr[0-367]|tr[3-7]`, NameBuiltin, nil}, {`[a-z$._?][\w$.?#@~]*`, NameVariable, nil}, {`[\r\n]+`, Text, Pop(1)}, Include("whitespace"), }, "preproc": { {`[^;\n]+`, CommentPreproc, nil}, {`;.*?\n`, CommentSingle, Pop(1)}, {`\n`, CommentPreproc, Pop(1)}, }, "whitespace": { {`\n`, Text, nil}, {`[ \t]+`, Text, nil}, {`;.*`, CommentSingle, nil}, }, "punctuation": { {`[,():\[\]]+`, Punctuation, nil}, {`[&|^<>+*/%~-]+`, Operator, nil}, {`[$]+`, KeywordConstant, nil}, {`seg|wrt|strict`, OperatorWord, nil}, {`byte|[dq]?word`, KeywordType, nil}, }, }, ))
Nasm lexer.
var Newspeak = Register(MustNewLexer( &Config{ Name: "Newspeak", Aliases: []string{"newspeak"}, Filenames: []string{"*.ns2"}, MimeTypes: []string{"text/x-newspeak"}, }, Rules{ "root": { {`\b(Newsqueak2)\b`, KeywordDeclaration, nil}, {`'[^']*'`, LiteralString, nil}, {`\b(class)(\s+)(\w+)(\s*)`, ByGroups(KeywordDeclaration, Text, NameClass, Text), nil}, {`\b(mixin|self|super|private|public|protected|nil|true|false)\b`, Keyword, nil}, {`(\w+\:)(\s*)([a-zA-Z_]\w+)`, ByGroups(NameFunction, Text, NameVariable), nil}, {`(\w+)(\s*)(=)`, ByGroups(NameAttribute, Text, Operator), nil}, {`<\w+>`, CommentSpecial, nil}, Include("expressionstat"), Include("whitespace"), }, "expressionstat": { {`(\d+\.\d*|\.\d+|\d+[fF])[fF]?`, LiteralNumberFloat, nil}, {`\d+`, LiteralNumberInteger, nil}, {`:\w+`, NameVariable, nil}, {`(\w+)(::)`, ByGroups(NameVariable, Operator), nil}, {`\w+:`, NameFunction, nil}, {`\w+`, NameVariable, nil}, {`\(|\)`, Punctuation, nil}, {`\[|\]`, Punctuation, nil}, {`\{|\}`, Punctuation, nil}, {`(\^|\+|\/|~|\*|<|>|=|@|%|\||&|\?|!|,|-|:)`, Operator, nil}, {`\.|;`, Punctuation, nil}, Include("whitespace"), Include("literals"), }, "literals": { {`\$.`, LiteralString, nil}, {`'[^']*'`, LiteralString, nil}, {`#'[^']*'`, LiteralStringSymbol, nil}, {`#\w+:?`, LiteralStringSymbol, nil}, {`#(\+|\/|~|\*|<|>|=|@|%|\||&|\?|!|,|-)+`, LiteralStringSymbol, nil}, }, "whitespace": { {`\s+`, Text, nil}, {`"[^"]*"`, Comment, nil}, }, }, ))
Newspeak lexer.
var Nginx = Register(MustNewLexer( &Config{ Name: "Nginx configuration file", Aliases: []string{"nginx"}, Filenames: []string{"nginx.conf"}, MimeTypes: []string{"text/x-nginx-conf"}, }, Rules{ "root": { {`(include)(\s+)([^\s;]+)`, ByGroups(Keyword, Text, Name), nil}, {`[^\s;#]+`, Keyword, Push("stmt")}, Include("base"), }, "block": { {`\}`, Punctuation, Pop(2)}, {`[^\s;#]+`, KeywordNamespace, Push("stmt")}, Include("base"), }, "stmt": { {`\{`, Punctuation, Push("block")}, {`;`, Punctuation, Pop(1)}, Include("base"), }, "base": { {`#.*\n`, CommentSingle, nil}, {`on|off`, NameConstant, nil}, {`\$[^\s;#()]+`, NameVariable, nil}, {`([a-z0-9.-]+)(:)([0-9]+)`, ByGroups(Name, Punctuation, LiteralNumberInteger), nil}, {`[a-z-]+/[a-z-+]+`, LiteralString, nil}, {`[0-9]+[km]?\b`, LiteralNumberInteger, nil}, {`(~)(\s*)([^\s{]+)`, ByGroups(Punctuation, Text, LiteralStringRegex), nil}, {`[:=~]`, Punctuation, nil}, {`[^\s;#{}$]+`, LiteralString, nil}, {`/[^\s;#]*`, Name, nil}, {`\s+`, Text, nil}, {`[$;]`, Text, nil}, }, }, ))
Nginx Configuration File lexer.
var Nim = Register(MustNewLexer( &Config{ Name: "Nim", Aliases: []string{"nim", "nimrod"}, Filenames: []string{"*.nim", "*.nimrod"}, MimeTypes: []string{"text/x-nim"}, CaseInsensitive: true, }, Rules{ "root": { {`##.*$`, LiteralStringDoc, nil}, {`#.*$`, Comment, nil}, {`[*=><+\-/@$~&%!?|\\\[\]]`, Operator, nil}, {"\\.\\.|\\.|,|\\[\\.|\\.\\]|\\{\\.|\\.\\}|\\(\\.|\\.\\)|\\{|\\}|\\(|\\)|:|\\^|`|;", Punctuation, nil}, {`(?:[\w]+)"`, LiteralString, Push("rdqs")}, {`"""`, LiteralString, Push("tdqs")}, {`"`, LiteralString, Push("dqs")}, {`'`, LiteralStringChar, Push("chars")}, {`(a_?n_?d_?|o_?r_?|n_?o_?t_?|x_?o_?r_?|s_?h_?l_?|s_?h_?r_?|d_?i_?v_?|m_?o_?d_?|i_?n_?|n_?o_?t_?i_?n_?|i_?s_?|i_?s_?n_?o_?t_?)\b`, OperatorWord, nil}, {`(p_?r_?o_?c_?\s)(?![(\[\]])`, Keyword, Push("funcname")}, {"" /* 948 byte string literal not displayed */, Keyword, nil}, {`(f_?r_?o_?m_?|i_?m_?p_?o_?r_?t_?|i_?n_?c_?l_?u_?d_?e_?)\b`, KeywordNamespace, nil}, {`(v_?a_?r)\b`, KeywordDeclaration, nil}, {"" /* 233 byte string literal not displayed */, KeywordType, nil}, {`(n_?i_?l_?|t_?r_?u_?e_?|f_?a_?l_?s_?e_?)\b`, KeywordPseudo, nil}, {`\b((?![_\d])\w)(((?!_)\w)|(_(?!_)\w))*`, Name, nil}, {`[0-9][0-9_]*(?=([e.]|\'f(32|64)))`, LiteralNumberFloat, Push("float-suffix", "float-number")}, {`0x[a-f0-9][a-f0-9_]*`, LiteralNumberHex, Push("int-suffix")}, {`0b[01][01_]*`, LiteralNumberBin, Push("int-suffix")}, {`0o[0-7][0-7_]*`, LiteralNumberOct, Push("int-suffix")}, {`[0-9][0-9_]*`, LiteralNumberInteger, Push("int-suffix")}, {`\s+`, Text, nil}, {`.+$`, Error, nil}, }, "chars": { {`\\([\\abcefnrtvl"\']|x[a-f0-9]{2}|[0-9]{1,3})`, LiteralStringEscape, nil}, {`'`, LiteralStringChar, Pop(1)}, {`.`, LiteralStringChar, nil}, }, "strings": { {`(?<!\$)\$(\d+|#|\w+)+`, LiteralStringInterpol, nil}, {`[^\\\'"$\n]+`, LiteralString, nil}, {`[\'"\\]`, LiteralString, nil}, {`\$`, LiteralString, nil}, }, "dqs": { {`\\([\\abcefnrtvl"\']|\n|x[a-f0-9]{2}|[0-9]{1,3})`, LiteralStringEscape, nil}, {`"`, LiteralString, Pop(1)}, Include("strings"), }, "rdqs": { {`"(?!")`, LiteralString, Pop(1)}, {`""`, LiteralStringEscape, nil}, Include("strings"), }, "tdqs": { {`"""(?!")`, LiteralString, Pop(1)}, Include("strings"), Include("nl"), }, "funcname": { {`((?![\d_])\w)(((?!_)\w)|(_(?!_)\w))*`, NameFunction, Pop(1)}, {"`.+`", NameFunction, Pop(1)}, }, "nl": { {`\n`, LiteralString, nil}, }, "float-number": { {`\.(?!\.)[0-9_]*`, LiteralNumberFloat, nil}, {`e[+-]?[0-9][0-9_]*`, LiteralNumberFloat, nil}, Default(Pop(1)), }, "float-suffix": { {`\'f(32|64)`, LiteralNumberFloat, nil}, Default(Pop(1)), }, "int-suffix": { {`\'i(32|64)`, LiteralNumberIntegerLong, nil}, {`\'i(8|16)`, LiteralNumberInteger, nil}, Default(Pop(1)), }, }, ))
Nim lexer.
var Nix = Register(MustNewLexer( &Config{ Name: "Nix", Aliases: []string{"nixos", "nix"}, Filenames: []string{"*.nix"}, MimeTypes: []string{"text/x-nix"}, }, Rules{ "root": { Include("keywords"), Include("builtins"), Include("literals"), Include("operators"), {`#.*$`, CommentSingle, nil}, {`/\*`, CommentMultiline, Push("comment")}, {`\(`, Punctuation, Push("paren")}, {`\[`, Punctuation, Push("list")}, {`"`, StringDouble, Push("qstring")}, {`''`, StringSingle, Push("istring")}, {`{`, Punctuation, Push("scope")}, {`let` + nixb, Keyword, Push("scope")}, Include("id"), Include("space"), }, "keywords": { {`import` + nixb, KeywordNamespace, nil}, {Words(``, nixb, strings.Fields("rec inherit with if then else assert")...), Keyword, nil}, }, "builtins": { {`throw` + nixb, NameException, nil}, {Words(``, nixb, strings.Fields("" /* 161 byte string literal not displayed */)...), NameBuiltin, nil}, }, "literals": { {Words(``, nixb, strings.Fields("true false null")...), NameConstant, nil}, Include("uri"), Include("path"), Include("int"), Include("float"), }, "operators": { {` [/-] `, Operator, nil}, {`(\.)(\${)`, ByGroups(Operator, StringInterpol), Push("interpol")}, {`(\?)(\s*)(\${)`, ByGroups(Operator, Text, StringInterpol), Push("interpol")}, {Words(``, ``, strings.Fields("@ . ? ++ + != ! // == && || -> <= < >= > *")...), Operator, nil}, {`[;:]`, Punctuation, nil}, }, "comment": { {`\*/`, CommentMultiline, Pop(1)}, {`.|\n`, CommentMultiline, nil}, }, "paren": { {`\)`, Punctuation, Pop(1)}, Include("root"), }, "list": { {`\]`, Punctuation, Pop(1)}, Include("root"), }, "qstring": { {`"`, StringDouble, Pop(1)}, {`\${`, StringInterpol, Push("interpol")}, {`\\.`, StringEscape, nil}, {`.|\n`, StringDouble, nil}, }, "istring": { {`''\$`, StringEscape, nil}, {`'''`, StringEscape, nil}, {`''\\.`, StringEscape, nil}, {`''`, StringSingle, Pop(1)}, {`\${`, StringInterpol, Push("interpol")}, {`\$.`, StringSingle, nil}, {`.|\n`, StringSingle, nil}, }, "scope": { {`}:`, Punctuation, Pop(1)}, {`}`, Punctuation, Pop(1)}, {`in` + nixb, Keyword, Pop(1)}, {`\${`, StringInterpol, Push("interpol")}, Include("root"), {Words(``, ``, strings.Fields("= ? ,")...), Operator, nil}, }, "interpol": { {`}`, StringInterpol, Pop(1)}, Include("root"), }, "id": { {`[a-zA-Z_][a-zA-Z0-9_'-]*`, Name, nil}, }, "uri": { {`[a-zA-Z][a-zA-Z0-9+.-]*:[a-zA-Z0-9%/?:@&=+$,_.!~*'-]+`, StringDoc, nil}, }, "path": { {`[a-zA-Z0-9._+-]*(/[a-zA-Z0-9._+-]+)+`, StringRegex, nil}, {`~(/[a-zA-Z0-9._+-]+)+/?`, StringRegex, nil}, {`<[a-zA-Z0-9._+-]+(/[a-zA-Z0-9._+-]+)*>`, StringRegex, nil}, }, "int": { {`-?[0-9]+` + nixb, NumberInteger, nil}, }, "float": { {`-?(([1-9][0-9]*\.[0-9]*)|(0?\.[0-9]+))([Ee][+-]?[0-9]+)?` + nixb, NumberFloat, nil}, }, "space": { {`[ \t\r\n]+`, Text, nil}, }, }, ))
Nix lexer.
var ObjectiveC = Register(MustNewLexer( &Config{ Name: "Objective-C", Aliases: []string{"objective-c", "objectivec", "obj-c", "objc"}, Filenames: []string{"*.m", "*.h"}, MimeTypes: []string{"text/x-objective-c"}, }, Rules{ "statements": { {`@"`, LiteralString, Push("string")}, {`@(YES|NO)`, LiteralNumber, nil}, {`@'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'`, LiteralStringChar, nil}, {`@(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?`, LiteralNumberFloat, nil}, {`@(\d+\.\d*|\.\d+|\d+[fF])[fF]?`, LiteralNumberFloat, nil}, {`@0x[0-9a-fA-F]+[Ll]?`, LiteralNumberHex, nil}, {`@0[0-7]+[Ll]?`, LiteralNumberOct, nil}, {`@\d+[Ll]?`, LiteralNumberInteger, nil}, {`@\(`, Literal, Push("literal_number")}, {`@\[`, Literal, Push("literal_array")}, {`@\{`, Literal, Push("literal_dictionary")}, {Words(``, `\b`, `@selector`, `@private`, `@protected`, `@public`, `@encode`, `@synchronized`, `@try`, `@throw`, `@catch`, `@finally`, `@end`, `@property`, `@synthesize`, `__bridge`, `__bridge_transfer`, `__autoreleasing`, `__block`, `__weak`, `__strong`, `weak`, `strong`, `copy`, `retain`, `assign`, `unsafe_unretained`, `atomic`, `nonatomic`, `readonly`, `readwrite`, `setter`, `getter`, `typeof`, `in`, `out`, `inout`, `release`, `class`, `@dynamic`, `@optional`, `@required`, `@autoreleasepool`), Keyword, nil}, {Words(``, `\b`, `id`, `instancetype`, `Class`, `IMP`, `SEL`, `BOOL`, `IBOutlet`, `IBAction`, `unichar`), KeywordType, nil}, {`@(true|false|YES|NO)\n`, NameBuiltin, nil}, {`(YES|NO|nil|self|super)\b`, NameBuiltin, nil}, {`(Boolean|UInt8|SInt8|UInt16|SInt16|UInt32|SInt32)\b`, KeywordType, nil}, {`(TRUE|FALSE)\b`, NameBuiltin, nil}, {`(@interface|@implementation)(\s+)`, ByGroups(Keyword, Text), Push("#pop", "oc_classname")}, {`(@class|@protocol)(\s+)`, ByGroups(Keyword, Text), Push("#pop", "oc_forward_classname")}, {`@`, Punctuation, nil}, {`(L?)(")`, ByGroups(LiteralStringAffix, LiteralString), Push("string")}, {`(L?)(')(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])(')`, ByGroups(LiteralStringAffix, LiteralStringChar, LiteralStringChar, LiteralStringChar), nil}, {`(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*`, LiteralNumberFloat, nil}, {`(\d+\.\d*|\.\d+|\d+[fF])[fF]?`, LiteralNumberFloat, nil}, {`0x[0-9a-fA-F]+[LlUu]*`, LiteralNumberHex, nil}, {`0[0-7]+[LlUu]*`, LiteralNumberOct, nil}, {`\d+[LlUu]*`, LiteralNumberInteger, nil}, {`\*/`, Error, nil}, {`[~!%^&*+=|?:<>/-]`, Operator, nil}, {`[()\[\],.]`, Punctuation, nil}, {Words(``, `\b`, `asm`, `auto`, `break`, `case`, `const`, `continue`, `default`, `do`, `else`, `enum`, `extern`, `for`, `goto`, `if`, `register`, `restricted`, `return`, `sizeof`, `static`, `struct`, `switch`, `typedef`, `union`, `volatile`, `while`), Keyword, nil}, {`(bool|int|long|float|short|double|char|unsigned|signed|void)\b`, KeywordType, nil}, {Words(``, `\b`, `inline`, `_inline`, `__inline`, `naked`, `restrict`, `thread`, `typename`), KeywordReserved, nil}, {`(__m(128i|128d|128|64))\b`, KeywordReserved, nil}, {Words(`__`, `\b`, `asm`, `int8`, `based`, `except`, `int16`, `stdcall`, `cdecl`, `fastcall`, `int32`, `declspec`, `finally`, `int64`, `try`, `leave`, `wchar_t`, `w64`, `unaligned`, `raise`, `noop`, `identifier`, `forceinline`, `assume`), KeywordReserved, nil}, {`(true|false|NULL)\b`, NameBuiltin, nil}, {`([a-zA-Z_]\w*)(\s*)(:)(?!:)`, ByGroups(NameLabel, Text, Punctuation), nil}, {`[a-zA-Z_]\w*`, Name, nil}, }, "oc_classname": { {`([a-zA-Z$_][\w$]*)(\s*:\s*)([a-zA-Z$_][\w$]*)?(\s*)(\{)`, ByGroups(NameClass, Text, NameClass, Text, Punctuation), Push("#pop", "oc_ivars")}, {`([a-zA-Z$_][\w$]*)(\s*:\s*)([a-zA-Z$_][\w$]*)?`, ByGroups(NameClass, Text, NameClass), Pop(1)}, {`([a-zA-Z$_][\w$]*)(\s*)(\([a-zA-Z$_][\w$]*\))(\s*)(\{)`, ByGroups(NameClass, Text, NameLabel, Text, Punctuation), Push("#pop", "oc_ivars")}, {`([a-zA-Z$_][\w$]*)(\s*)(\([a-zA-Z$_][\w$]*\))`, ByGroups(NameClass, Text, NameLabel), Pop(1)}, {`([a-zA-Z$_][\w$]*)(\s*)(\{)`, ByGroups(NameClass, Text, Punctuation), Push("#pop", "oc_ivars")}, {`([a-zA-Z$_][\w$]*)`, NameClass, Pop(1)}, }, "oc_forward_classname": { {`([a-zA-Z$_][\w$]*)(\s*,\s*)`, ByGroups(NameClass, Text), Push("oc_forward_classname")}, {`([a-zA-Z$_][\w$]*)(\s*;?)`, ByGroups(NameClass, Text), Pop(1)}, }, "oc_ivars": { Include("whitespace"), Include("statements"), {`;`, Punctuation, nil}, {`\{`, Punctuation, Push()}, {`\}`, Punctuation, Pop(1)}, }, "root": { {`^([-+])(\s*)(\(.*?\))?(\s*)([a-zA-Z$_][\w$]*:?)`, ByGroups(Punctuation, Text, UsingSelf("root"), Text, NameFunction), Push("method")}, Include("whitespace"), {`((?:[\w*\s])+?(?:\s|[*]))([a-zA-Z_]\w*)(\s*\([^;]*?\))([^;{]*)(\{)`, ByGroups(UsingSelf("root"), NameFunction, UsingSelf("root"), UsingSelf("root"), Punctuation), Push("function")}, {`((?:[\w*\s])+?(?:\s|[*]))([a-zA-Z_]\w*)(\s*\([^;]*?\))([^;]*)(;)`, ByGroups(UsingSelf("root"), NameFunction, UsingSelf("root"), UsingSelf("root"), Punctuation), nil}, Default(Push("statement")), }, "method": { Include("whitespace"), {`,`, Punctuation, nil}, {`\.\.\.`, Punctuation, nil}, {`(\(.*?\))(\s*)([a-zA-Z$_][\w$]*)`, ByGroups(UsingSelf("root"), Text, NameVariable), nil}, {`[a-zA-Z$_][\w$]*:`, NameFunction, nil}, {`;`, Punctuation, Pop(1)}, {`\{`, Punctuation, Push("function")}, Default(Pop(1)), }, "literal_number": { {`\(`, Punctuation, Push("literal_number_inner")}, {`\)`, Literal, Pop(1)}, Include("statement"), }, "literal_number_inner": { {`\(`, Punctuation, Push()}, {`\)`, Punctuation, Pop(1)}, Include("statement"), }, "literal_array": { {`\[`, Punctuation, Push("literal_array_inner")}, {`\]`, Literal, Pop(1)}, Include("statement"), }, "literal_array_inner": { {`\[`, Punctuation, Push()}, {`\]`, Punctuation, Pop(1)}, Include("statement"), }, "literal_dictionary": { {`\}`, Literal, Pop(1)}, Include("statement"), }, "whitespace": { {`^#if\s+0`, CommentPreproc, Push("if0")}, {`^#`, CommentPreproc, Push("macro")}, {`^(\s*(?:/[*].*?[*]/\s*)?)(#if\s+0)`, ByGroups(UsingSelf("root"), CommentPreproc), Push("if0")}, {`^(\s*(?:/[*].*?[*]/\s*)?)(#)`, ByGroups(UsingSelf("root"), CommentPreproc), Push("macro")}, {`\n`, Text, nil}, {`\s+`, Text, nil}, {`\\\n`, Text, nil}, {`//(\n|[\w\W]*?[^\\]\n)`, CommentSingle, nil}, {`/(\\\n)?[*][\w\W]*?[*](\\\n)?/`, CommentMultiline, nil}, {`/(\\\n)?[*][\w\W]*`, CommentMultiline, nil}, }, "statement": { Include("whitespace"), Include("statements"), {`[{}]`, Punctuation, nil}, {`;`, Punctuation, Pop(1)}, }, "function": { Include("whitespace"), Include("statements"), {`;`, Punctuation, nil}, {`\{`, Punctuation, Push()}, {`\}`, Punctuation, Pop(1)}, }, "string": { {`"`, LiteralString, Pop(1)}, {`\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|[0-7]{1,3})`, LiteralStringEscape, nil}, {`[^\\"\n]+`, LiteralString, nil}, {`\\\n`, LiteralString, nil}, {`\\`, LiteralString, nil}, }, "macro": { {`(include)(\s*(?:/[*].*?[*]/\s*)?)([^\n]+)`, ByGroups(CommentPreproc, Text, CommentPreprocFile), nil}, {`[^/\n]+`, CommentPreproc, nil}, {`/[*](.|\n)*?[*]/`, CommentMultiline, nil}, {`//.*?\n`, CommentSingle, Pop(1)}, {`/`, CommentPreproc, nil}, {`(?<=\\)\n`, CommentPreproc, nil}, {`\n`, CommentPreproc, Pop(1)}, }, "if0": { {`^\s*#if.*?(?<!\\)\n`, CommentPreproc, Push()}, {`^\s*#el(?:se|if).*\n`, CommentPreproc, Pop(1)}, {`^\s*#endif.*?(?<!\\)\n`, CommentPreproc, Pop(1)}, {`.*?\n`, Comment, nil}, }, }, ))
Objective-C lexer.
var Ocaml = Register(MustNewLexer( &Config{ Name: "OCaml", Aliases: []string{"ocaml"}, Filenames: []string{"*.ml", "*.mli", "*.mll", "*.mly"}, MimeTypes: []string{"text/x-ocaml"}, }, Rules{ "escape-sequence": { {`\\[\\"\'ntbr]`, LiteralStringEscape, nil}, {`\\[0-9]{3}`, LiteralStringEscape, nil}, {`\\x[0-9a-fA-F]{2}`, LiteralStringEscape, nil}, }, "root": { {`\s+`, Text, nil}, {`false|true|\(\)|\[\]`, NameBuiltinPseudo, nil}, {`\b([A-Z][\w\']*)(?=\s*\.)`, NameNamespace, Push("dotted")}, {`\b([A-Z][\w\']*)`, NameClass, nil}, {`\(\*(?![)])`, Comment, Push("comment")}, {"" /* 289 byte string literal not displayed */, Keyword, nil}, {"" /* 147 byte string literal not displayed */, Operator, nil}, {`([=<>@^|&+\*/$%-]|[!?~])?[!$%&*+\./:<=>?@^|~-]`, Operator, nil}, {`\b(and|asr|land|lor|lsl|lxor|mod|or)\b`, OperatorWord, nil}, {`\b(unit|int|float|bool|string|char|list|array)\b`, KeywordType, nil}, {`[^\W\d][\w']*`, Name, nil}, {`-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)`, LiteralNumberFloat, nil}, {`0[xX][\da-fA-F][\da-fA-F_]*`, LiteralNumberHex, nil}, {`0[oO][0-7][0-7_]*`, LiteralNumberOct, nil}, {`0[bB][01][01_]*`, LiteralNumberBin, nil}, {`\d[\d_]*`, LiteralNumberInteger, nil}, {`'(?:(\\[\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))'`, LiteralStringChar, nil}, {`'.'`, LiteralStringChar, nil}, {`'`, Keyword, nil}, {`"`, LiteralStringDouble, Push("string")}, {`[~?][a-z][\w\']*:`, NameVariable, nil}, }, "comment": { {`[^(*)]+`, Comment, nil}, {`\(\*`, Comment, Push()}, {`\*\)`, Comment, Pop(1)}, {`[(*)]`, Comment, nil}, }, "string": { {`[^\\"]+`, LiteralStringDouble, nil}, Include("escape-sequence"), {`\\\n`, LiteralStringDouble, nil}, {`"`, LiteralStringDouble, Pop(1)}, }, "dotted": { {`\s+`, Text, nil}, {`\.`, Punctuation, nil}, {`[A-Z][\w\']*(?=\s*\.)`, NameNamespace, nil}, {`[A-Z][\w\']*`, NameClass, Pop(1)}, {`[a-z_][\w\']*`, Name, Pop(1)}, Default(Pop(1)), }, }, ))
Ocaml lexer.
var Octave = Register(MustNewLexer( &Config{ Name: "Octave", Aliases: []string{"octave"}, Filenames: []string{"*.m"}, MimeTypes: []string{"text/octave"}, }, Rules{ "root": { {`[%#].*$`, Comment, nil}, {`^\s*function`, Keyword, Push("deffunc")}, {Words(``, `\b`, `__FILE__`, `__LINE__`, `break`, `case`, `catch`, `classdef`, `continue`, `do`, `else`, `elseif`, `end`, `end_try_catch`, `end_unwind_protect`, `endclassdef`, `endevents`, `endfor`, `endfunction`, `endif`, `endmethods`, `endproperties`, `endswitch`, `endwhile`, `events`, `for`, `function`, `get`, `global`, `if`, `methods`, `otherwise`, `persistent`, `properties`, `return`, `set`, `static`, `switch`, `try`, `until`, `unwind_protect`, `unwind_protect_cleanup`, `while`), Keyword, nil}, {Words(``, `\b`, `addlistener`, `addpath`, `addproperty`, `all`, `and`, `any`, `argnames`, `argv`, `assignin`, `atexit`, `autoload`, `available_graphics_toolkits`, `beep_on_error`, `bitand`, `bitmax`, `bitor`, `bitshift`, `bitxor`, `cat`, `cell`, `cellstr`, `char`, `class`, `clc`, `columns`, `command_line_path`, `completion_append_char`, `completion_matches`, `complex`, `confirm_recursive_rmdir`, `cputime`, `crash_dumps_octave_core`, `ctranspose`, `cumprod`, `cumsum`, `debug_on_error`, `debug_on_interrupt`, `debug_on_warning`, `default_save_options`, `dellistener`, `diag`, `diff`, `disp`, `doc_cache_file`, `do_string_escapes`, `double`, `drawnow`, `e`, `echo_executing_commands`, `eps`, `eq`, `errno`, `errno_list`, `error`, `eval`, `evalin`, `exec`, `exist`, `exit`, `eye`, `false`, `fclear`, `fclose`, `fcntl`, `fdisp`, `feof`, `ferror`, `feval`, `fflush`, `fgetl`, `fgets`, `fieldnames`, `file_in_loadpath`, `file_in_path`, `filemarker`, `filesep`, `find_dir_in_path`, `fixed_point_format`, `fnmatch`, `fopen`, `fork`, `formula`, `fprintf`, `fputs`, `fread`, `freport`, `frewind`, `fscanf`, `fseek`, `fskipl`, `ftell`, `functions`, `fwrite`, `ge`, `genpath`, `get`, `getegid`, `getenv`, `geteuid`, `getgid`, `getpgrp`, `getpid`, `getppid`, `getuid`, `glob`, `gt`, `gui_mode`, `history_control`, `history_file`, `history_size`, `history_timestamp_format_string`, `home`, `horzcat`, `hypot`, `ifelse`, `ignore_function_time_stamp`, `inferiorto`, `info_file`, `info_program`, `inline`, `input`, `intmax`, `intmin`, `ipermute`, `is_absolute_filename`, `isargout`, `isbool`, `iscell`, `iscellstr`, `ischar`, `iscomplex`, `isempty`, `isfield`, `isfloat`, `isglobal`, `ishandle`, `isieee`, `isindex`, `isinteger`, `islogical`, `ismatrix`, `ismethod`, `isnull`, `isnumeric`, `isobject`, `isreal`, `is_rooted_relative_filename`, `issorted`, `isstruct`, `isvarname`, `kbhit`, `keyboard`, `kill`, `lasterr`, `lasterror`, `lastwarn`, `ldivide`, `le`, `length`, `link`, `linspace`, `logical`, `lstat`, `lt`, `make_absolute_filename`, `makeinfo_program`, `max_recursion_depth`, `merge`, `methods`, `mfilename`, `minus`, `mislocked`, `mkdir`, `mkfifo`, `mkstemp`, `mldivide`, `mlock`, `mouse_wheel_zoom`, `mpower`, `mrdivide`, `mtimes`, `munlock`, `nargin`, `nargout`, `native_float_format`, `ndims`, `ne`, `nfields`, `nnz`, `norm`, `not`, `numel`, `nzmax`, `octave_config_info`, `octave_core_file_limit`, `octave_core_file_name`, `octave_core_file_options`, `ones`, `or`, `output_max_field_width`, `output_precision`, `page_output_immediately`, `page_screen_output`, `path`, `pathsep`, `pause`, `pclose`, `permute`, `pi`, `pipe`, `plus`, `popen`, `power`, `print_empty_dimensions`, `printf`, `print_struct_array_contents`, `prod`, `program_invocation_name`, `program_name`, `putenv`, `puts`, `pwd`, `quit`, `rats`, `rdivide`, `readdir`, `readlink`, `read_readline_init_file`, `realmax`, `realmin`, `rehash`, `rename`, `repelems`, `re_read_readline_init_file`, `reset`, `reshape`, `resize`, `restoredefaultpath`, `rethrow`, `rmdir`, `rmfield`, `rmpath`, `rows`, `save_header_format_string`, `save_precision`, `saving_history`, `scanf`, `set`, `setenv`, `shell_cmd`, `sighup_dumps_octave_core`, `sigterm_dumps_octave_core`, `silent_functions`, `single`, `size`, `size_equal`, `sizemax`, `sizeof`, `sleep`, `source`, `sparse_auto_mutate`, `split_long_rows`, `sprintf`, `squeeze`, `sscanf`, `stat`, `stderr`, `stdin`, `stdout`, `strcmp`, `strcmpi`, `string_fill_char`, `strncmp`, `strncmpi`, `struct`, `struct_levels_to_print`, `strvcat`, `subsasgn`, `subsref`, `sum`, `sumsq`, `superiorto`, `suppress_verbose_help_message`, `symlink`, `system`, `tic`, `tilde_expand`, `times`, `tmpfile`, `tmpnam`, `toc`, `toupper`, `transpose`, `true`, `typeinfo`, `umask`, `uminus`, `uname`, `undo_string_escapes`, `unlink`, `uplus`, `upper`, `usage`, `usleep`, `vec`, `vectorize`, `vertcat`, `waitpid`, `warning`, `warranty`, `whos_line_format`, `yes_or_no`, `zeros`, `inf`, `Inf`, `nan`, `NaN`, `close`, `load`, `who`, `whos`, `accumarray`, `accumdim`, `acosd`, `acotd`, `acscd`, `addtodate`, `allchild`, `ancestor`, `anova`, `arch_fit`, `arch_rnd`, `arch_test`, `area`, `arma_rnd`, `arrayfun`, `ascii`, `asctime`, `asecd`, `asind`, `assert`, `atand`, `autoreg_matrix`, `autumn`, `axes`, `axis`, `bar`, `barh`, `bartlett`, `bartlett_test`, `beep`, `betacdf`, `betainv`, `betapdf`, `betarnd`, `bicgstab`, `bicubic`, `binary`, `binocdf`, `binoinv`, `binopdf`, `binornd`, `bitcmp`, `bitget`, `bitset`, `blackman`, `blanks`, `blkdiag`, `bone`, `box`, `brighten`, `calendar`, `cast`, `cauchy_cdf`, `cauchy_inv`, `cauchy_pdf`, `cauchy_rnd`, `caxis`, `celldisp`, `center`, `cgs`, `chisquare_test_homogeneity`, `chisquare_test_independence`, `circshift`, `cla`, `clabel`, `clf`, `clock`, `cloglog`, `closereq`, `colon`, `colorbar`, `colormap`, `colperm`, `comet`, `common_size`, `commutation_matrix`, `compan`, `compare_versions`, `compass`, `computer`, `cond`, `condest`, `contour`, `contourc`, `contourf`, `contrast`, `conv`, `convhull`, `cool`, `copper`, `copyfile`, `cor`, `corrcoef`, `cor_test`, `cosd`, `cotd`, `cov`, `cplxpair`, `cross`, `cscd`, `cstrcat`, `csvread`, `csvwrite`, `ctime`, `cumtrapz`, `curl`, `cut`, `cylinder`, `date`, `datenum`, `datestr`, `datetick`, `datevec`, `dblquad`, `deal`, `deblank`, `deconv`, `delaunay`, `delaunayn`, `delete`, `demo`, `detrend`, `diffpara`, `diffuse`, `dir`, `discrete_cdf`, `discrete_inv`, `discrete_pdf`, `discrete_rnd`, `display`, `divergence`, `dlmwrite`, `dos`, `dsearch`, `dsearchn`, `duplication_matrix`, `durbinlevinson`, `ellipsoid`, `empirical_cdf`, `empirical_inv`, `empirical_pdf`, `empirical_rnd`, `eomday`, `errorbar`, `etime`, `etreeplot`, `example`, `expcdf`, `expinv`, `expm`, `exppdf`, `exprnd`, `ezcontour`, `ezcontourf`, `ezmesh`, `ezmeshc`, `ezplot`, `ezpolar`, `ezsurf`, `ezsurfc`, `factor`, `factorial`, `fail`, `fcdf`, `feather`, `fftconv`, `fftfilt`, `fftshift`, `figure`, `fileattrib`, `fileparts`, `fill`, `findall`, `findobj`, `findstr`, `finv`, `flag`, `flipdim`, `fliplr`, `flipud`, `fpdf`, `fplot`, `fractdiff`, `freqz`, `freqz_plot`, `frnd`, `fsolve`, `f_test_regression`, `ftp`, `fullfile`, `fzero`, `gamcdf`, `gaminv`, `gampdf`, `gamrnd`, `gca`, `gcbf`, `gcbo`, `gcf`, `genvarname`, `geocdf`, `geoinv`, `geopdf`, `geornd`, `getfield`, `ginput`, `glpk`, `gls`, `gplot`, `gradient`, `graphics_toolkit`, `gray`, `grid`, `griddata`, `griddatan`, `gtext`, `gunzip`, `gzip`, `hadamard`, `hamming`, `hankel`, `hanning`, `hggroup`, `hidden`, `hilb`, `hist`, `histc`, `hold`, `hot`, `hotelling_test`, `housh`, `hsv`, `hurst`, `hygecdf`, `hygeinv`, `hygepdf`, `hygernd`, `idivide`, `ifftshift`, `image`, `imagesc`, `imfinfo`, `imread`, `imshow`, `imwrite`, `index`, `info`, `inpolygon`, `inputname`, `interpft`, `interpn`, `intersect`, `invhilb`, `iqr`, `isa`, `isdefinite`, `isdir`, `is_duplicate_entry`, `isequal`, `isequalwithequalnans`, `isfigure`, `ishermitian`, `ishghandle`, `is_leap_year`, `isletter`, `ismac`, `ismember`, `ispc`, `isprime`, `isprop`, `isscalar`, `issquare`, `isstrprop`, `issymmetric`, `isunix`, `is_valid_file_id`, `isvector`, `jet`, `kendall`, `kolmogorov_smirnov_cdf`, `kolmogorov_smirnov_test`, `kruskal_wallis_test`, `krylov`, `kurtosis`, `laplace_cdf`, `laplace_inv`, `laplace_pdf`, `laplace_rnd`, `legend`, `legendre`, `license`, `line`, `linkprop`, `list_primes`, `loadaudio`, `loadobj`, `logistic_cdf`, `logistic_inv`, `logistic_pdf`, `logistic_rnd`, `logit`, `loglog`, `loglogerr`, `logm`, `logncdf`, `logninv`, `lognpdf`, `lognrnd`, `logspace`, `lookfor`, `ls_command`, `lsqnonneg`, `magic`, `mahalanobis`, `manova`, `matlabroot`, `mcnemar_test`, `mean`, `meansq`, `median`, `menu`, `mesh`, `meshc`, `meshgrid`, `meshz`, `mexext`, `mget`, `mkpp`, `mode`, `moment`, `movefile`, `mpoles`, `mput`, `namelengthmax`, `nargchk`, `nargoutchk`, `nbincdf`, `nbininv`, `nbinpdf`, `nbinrnd`, `nchoosek`, `ndgrid`, `newplot`, `news`, `nonzeros`, `normcdf`, `normest`, `norminv`, `normpdf`, `normrnd`, `now`, `nthroot`, `null`, `ocean`, `ols`, `onenormest`, `optimget`, `optimset`, `orderfields`, `orient`, `orth`, `pack`, `pareto`, `parseparams`, `pascal`, `patch`, `pathdef`, `pcg`, `pchip`, `pcolor`, `pcr`, `peaks`, `periodogram`, `perl`, `perms`, `pie`, `pink`, `planerot`, `playaudio`, `plot`, `plotmatrix`, `plotyy`, `poisscdf`, `poissinv`, `poisspdf`, `poissrnd`, `polar`, `poly`, `polyaffine`, `polyarea`, `polyderiv`, `polyfit`, `polygcd`, `polyint`, `polyout`, `polyreduce`, `polyval`, `polyvalm`, `postpad`, `powerset`, `ppder`, `ppint`, `ppjumps`, `ppplot`, `ppval`, `pqpnonneg`, `prepad`, `primes`, `print`, `print_usage`, `prism`, `probit`, `qp`, `qqplot`, `quadcc`, `quadgk`, `quadl`, `quadv`, `quiver`, `qzhess`, `rainbow`, `randi`, `range`, `rank`, `ranks`, `rat`, `reallog`, `realpow`, `realsqrt`, `record`, `rectangle_lw`, `rectangle_sw`, `rectint`, `refresh`, `refreshdata`, `regexptranslate`, `repmat`, `residue`, `ribbon`, `rindex`, `roots`, `rose`, `rosser`, `rotdim`, `rref`, `run`, `run_count`, `rundemos`, `run_test`, `runtests`, `saveas`, `saveaudio`, `saveobj`, `savepath`, `scatter`, `secd`, `semilogx`, `semilogxerr`, `semilogy`, `semilogyerr`, `setaudio`, `setdiff`, `setfield`, `setxor`, `shading`, `shift`, `shiftdim`, `sign_test`, `sinc`, `sind`, `sinetone`, `sinewave`, `skewness`, `slice`, `sombrero`, `sortrows`, `spaugment`, `spconvert`, `spdiags`, `spearman`, `spectral_adf`, `spectral_xdf`, `specular`, `speed`, `spencer`, `speye`, `spfun`, `sphere`, `spinmap`, `spline`, `spones`, `sprand`, `sprandn`, `sprandsym`, `spring`, `spstats`, `spy`, `sqp`, `stairs`, `statistics`, `std`, `stdnormal_cdf`, `stdnormal_inv`, `stdnormal_pdf`, `stdnormal_rnd`, `stem`, `stft`, `strcat`, `strchr`, `strjust`, `strmatch`, `strread`, `strsplit`, `strtok`, `strtrim`, `strtrunc`, `structfun`, `studentize`, `subplot`, `subsindex`, `subspace`, `substr`, `substruct`, `summer`, `surf`, `surface`, `surfc`, `surfl`, `surfnorm`, `svds`, `swapbytes`, `sylvester_matrix`, `symvar`, `synthesis`, `table`, `tand`, `tar`, `tcdf`, `tempdir`, `tempname`, `test`, `text`, `textread`, `textscan`, `tinv`, `title`, `toeplitz`, `tpdf`, `trace`, `trapz`, `treelayout`, `treeplot`, `triangle_lw`, `triangle_sw`, `tril`, `trimesh`, `triplequad`, `triplot`, `trisurf`, `triu`, `trnd`, `tsearchn`, `t_test`, `t_test_regression`, `type`, `unidcdf`, `unidinv`, `unidpdf`, `unidrnd`, `unifcdf`, `unifinv`, `unifpdf`, `unifrnd`, `union`, `unique`, `unix`, `unmkpp`, `unpack`, `untabify`, `untar`, `unwrap`, `unzip`, `u_test`, `validatestring`, `vander`, `var`, `var_test`, `vech`, `ver`, `version`, `view`, `voronoi`, `voronoin`, `waitforbuttonpress`, `wavread`, `wavwrite`, `wblcdf`, `wblinv`, `wblpdf`, `wblrnd`, `weekday`, `welch_test`, `what`, `white`, `whitebg`, `wienrnd`, `wilcoxon_test`, `wilkinson`, `winter`, `xlabel`, `xlim`, `ylabel`, `yulewalker`, `zip`, `zlabel`, `z_test`, `airy`, `amd`, `balance`, `besselh`, `besseli`, `besselj`, `besselk`, `bessely`, `bitpack`, `bsxfun`, `builtin`, `ccolamd`, `cellfun`, `cellslices`, `chol`, `choldelete`, `cholinsert`, `cholinv`, `cholshift`, `cholupdate`, `colamd`, `colloc`, `convhulln`, `convn`, `csymamd`, `cummax`, `cummin`, `daspk`, `daspk_options`, `dasrt`, `dasrt_options`, `dassl`, `dassl_options`, `dbclear`, `dbdown`, `dbstack`, `dbstatus`, `dbstop`, `dbtype`, `dbup`, `dbwhere`, `det`, `dlmread`, `dmperm`, `dot`, `eig`, `eigs`, `endgrent`, `endpwent`, `etree`, `fft`, `fftn`, `fftw`, `filter`, `find`, `full`, `gcd`, `getgrent`, `getgrgid`, `getgrnam`, `getpwent`, `getpwnam`, `getpwuid`, `getrusage`, `givens`, `gmtime`, `gnuplot_binary`, `hess`, `ifft`, `ifftn`, `inv`, `isdebugmode`, `issparse`, `kron`, `localtime`, `lookup`, `lsode`, `lsode_options`, `lu`, `luinc`, `luupdate`, `matrix_type`, `max`, `min`, `mktime`, `pinv`, `qr`, `qrdelete`, `qrinsert`, `qrshift`, `qrupdate`, `quad`, `quad_options`, `qz`, `rand`, `rande`, `randg`, `randn`, `randp`, `randperm`, `rcond`, `regexp`, `regexpi`, `regexprep`, `schur`, `setgrent`, `setpwent`, `sort`, `spalloc`, `sparse`, `spparms`, `sprank`, `sqrtm`, `strfind`, `strftime`, `strptime`, `strrep`, `svd`, `svd_driver`, `syl`, `symamd`, `symbfact`, `symrcm`, `time`, `tsearch`, `typecast`, `urlread`, `urlwrite`, `abs`, `acos`, `acosh`, `acot`, `acoth`, `acsc`, `acsch`, `angle`, `arg`, `asec`, `asech`, `asin`, `asinh`, `atan`, `atanh`, `beta`, `betainc`, `betaln`, `bincoeff`, `cbrt`, `ceil`, `conj`, `cos`, `cosh`, `cot`, `coth`, `csc`, `csch`, `erf`, `erfc`, `erfcx`, `erfinv`, `exp`, `finite`, `fix`, `floor`, `fmod`, `gamma`, `gammainc`, `gammaln`, `imag`, `isalnum`, `isalpha`, `isascii`, `iscntrl`, `isdigit`, `isfinite`, `isgraph`, `isinf`, `islower`, `isna`, `isnan`, `isprint`, `ispunct`, `isspace`, `isupper`, `isxdigit`, `lcm`, `lgamma`, `log`, `lower`, `mod`, `real`, `rem`, `round`, `roundb`, `sec`, `sech`, `sign`, `sin`, `sinh`, `sqrt`, `tan`, `tanh`, `toascii`, `tolower`, `xor`), NameBuiltin, nil}, {Words(``, `\b`, `EDITOR`, `EXEC_PATH`, `I`, `IMAGE_PATH`, `NA`, `OCTAVE_HOME`, `OCTAVE_VERSION`, `PAGER`, `PAGER_FLAGS`, `SEEK_CUR`, `SEEK_END`, `SEEK_SET`, `SIG`, `S_ISBLK`, `S_ISCHR`, `S_ISDIR`, `S_ISFIFO`, `S_ISLNK`, `S_ISREG`, `S_ISSOCK`, `WCONTINUE`, `WCOREDUMP`, `WEXITSTATUS`, `WIFCONTINUED`, `WIFEXITED`, `WIFSIGNALED`, `WIFSTOPPED`, `WNOHANG`, `WSTOPSIG`, `WTERMSIG`, `WUNTRACED`), NameConstant, nil}, {`-=|!=|!|/=|--`, Operator, nil}, {`-|==|~=|<|>|<=|>=|&&|&|~|\|\|?`, Operator, nil}, {`\*=|\+=|\^=|\/=|\\=|\*\*|\+\+|\.\*\*`, Operator, nil}, {`\.\*|\*|\+|\.\^|\.\\|\.\/|\/|\\`, Operator, nil}, {`[\[\](){}:@.,]`, Punctuation, nil}, {`=|:|;`, Punctuation, nil}, {`"[^"]*"`, LiteralString, nil}, {`(\d+\.\d*|\d*\.\d+)([eEf][+-]?[0-9]+)?`, LiteralNumberFloat, nil}, {`\d+[eEf][+-]?[0-9]+`, LiteralNumberFloat, nil}, {`\d+`, LiteralNumberInteger, nil}, {`(?<=[\w)\].])\'+`, Operator, nil}, {`(?<![\w)\].])\'`, LiteralString, Push("string")}, {`[a-zA-Z_]\w*`, Name, nil}, {`.`, Text, nil}, }, "string": { {`[^']*'`, LiteralString, Pop(1)}, }, "deffunc": { {`(\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)}, }, }, ))
Octave lexer.
var PHP = Register(MustNewLexer( &Config{ Name: "PHP", Aliases: []string{"php", "php3", "php4", "php5"}, Filenames: []string{"*.php", "*.php[345]", "*.inc"}, MimeTypes: []string{"text/x-php"}, DotAll: true, CaseInsensitive: true, }, Rules{ "root": { {`<\?(php)?`, CommentPreproc, Push("php")}, {`[^<]+`, Other, nil}, {`<`, Other, nil}, }, "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}, {"" /* 529 byte string literal not displayed */, 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}, }, }, ))
PHP lexer.
var PLpgSQL = Register(MustNewLexer( &Config{ Name: "PL/pgSQL", Aliases: []string{"plpgsql"}, Filenames: []string{}, MimeTypes: []string{"text/x-plpgsql"}, NotMultiline: true, CaseInsensitive: true, }, Rules{ "root": { {`\%[a-z]\w*\b`, NameBuiltin, nil}, {`:=`, Operator, nil}, {`\<\<[a-z]\w*\>\>`, NameLabel, nil}, {`\#[a-z]\w*\b`, KeywordPseudo, nil}, {`\s+`, Text, nil}, {`--.*\n?`, CommentSingle, nil}, {`/\*`, CommentMultiline, Push("multiline-comments")}, {"" /* 572 byte string literal not displayed */, NameBuiltin, nil}, {Words(``, `\b`, `ABORT`, `ABSOLUTE`, `ACCESS`, `ACTION`, `ADD`, `ADMIN`, `AFTER`, `AGGREGATE`, `ALL`, `ALSO`, `ALTER`, `ALWAYS`, `ANALYSE`, `ANALYZE`, `AND`, `ANY`, `ARRAY`, `AS`, `ASC`, `ASSERTION`, `ASSIGNMENT`, `ASYMMETRIC`, `AT`, `ATTRIBUTE`, `AUTHORIZATION`, `BACKWARD`, `BEFORE`, `BEGIN`, `BETWEEN`, `BIGINT`, `BINARY`, `BIT`, `BOOLEAN`, `BOTH`, `BY`, `CACHE`, `CALLED`, `CASCADE`, `CASCADED`, `CASE`, `CAST`, `CATALOG`, `CHAIN`, `CHAR`, `CHARACTER`, `CHARACTERISTICS`, `CHECK`, `CHECKPOINT`, `CLASS`, `CLOSE`, `CLUSTER`, `COALESCE`, `COLLATE`, `COLLATION`, `COLUMN`, `COMMENT`, `COMMENTS`, `COMMIT`, `COMMITTED`, `CONCURRENTLY`, `CONFIGURATION`, `CONNECTION`, `CONSTRAINT`, `CONSTRAINTS`, `CONTENT`, `CONTINUE`, `CONVERSION`, `COPY`, `COST`, `CREATE`, `CROSS`, `CSV`, `CURRENT`, `CURRENT_CATALOG`, `CURRENT_DATE`, `CURRENT_ROLE`, `CURRENT_SCHEMA`, `CURRENT_TIME`, `CURRENT_TIMESTAMP`, `CURRENT_USER`, `CURSOR`, `CYCLE`, `DATA`, `DATABASE`, `DAY`, `DEALLOCATE`, `DEC`, `DECIMAL`, `DECLARE`, `DEFAULT`, `DEFAULTS`, `DEFERRABLE`, `DEFERRED`, `DEFINER`, `DELETE`, `DELIMITER`, `DELIMITERS`, `DESC`, `DICTIONARY`, `DISABLE`, `DISCARD`, `DISTINCT`, `DO`, `DOCUMENT`, `DOMAIN`, `DOUBLE`, `DROP`, `EACH`, `ELSE`, `ENABLE`, `ENCODING`, `ENCRYPTED`, `END`, `ENUM`, `ESCAPE`, `EVENT`, `EXCEPT`, `EXCLUDE`, `EXCLUDING`, `EXCLUSIVE`, `EXECUTE`, `EXISTS`, `EXPLAIN`, `EXTENSION`, `EXTERNAL`, `EXTRACT`, `FALSE`, `FAMILY`, `FETCH`, `FILTER`, `FIRST`, `FLOAT`, `FOLLOWING`, `FOR`, `FORCE`, `FOREIGN`, `FORWARD`, `FREEZE`, `FROM`, `FULL`, `FUNCTION`, `FUNCTIONS`, `GLOBAL`, `GRANT`, `GRANTED`, `GREATEST`, `GROUP`, `HANDLER`, `HAVING`, `HEADER`, `HOLD`, `HOUR`, `IDENTITY`, `IF`, `ILIKE`, `IMMEDIATE`, `IMMUTABLE`, `IMPLICIT`, `IN`, `INCLUDING`, `INCREMENT`, `INDEX`, `INDEXES`, `INHERIT`, `INHERITS`, `INITIALLY`, `INLINE`, `INNER`, `INOUT`, `INPUT`, `INSENSITIVE`, `INSERT`, `INSTEAD`, `INT`, `INTEGER`, `INTERSECT`, `INTERVAL`, `INTO`, `INVOKER`, `IS`, `ISNULL`, `ISOLATION`, `JOIN`, `KEY`, `LABEL`, `LANGUAGE`, `LARGE`, `LAST`, `LATERAL`, `LC_COLLATE`, `LC_CTYPE`, `LEADING`, `LEAKPROOF`, `LEAST`, `LEFT`, `LEVEL`, `LIKE`, `LIMIT`, `LISTEN`, `LOAD`, `LOCAL`, `LOCALTIME`, `LOCALTIMESTAMP`, `LOCATION`, `LOCK`, `MAPPING`, `MATCH`, `MATERIALIZED`, `MAXVALUE`, `MINUTE`, `MINVALUE`, `MODE`, `MONTH`, `MOVE`, `NAME`, `NAMES`, `NATIONAL`, `NATURAL`, `NCHAR`, `NEXT`, `NO`, `NONE`, `NOT`, `NOTHING`, `NOTIFY`, `NOTNULL`, `NOWAIT`, `NULL`, `NULLIF`, `NULLS`, `NUMERIC`, `OBJECT`, `OF`, `OFF`, `OFFSET`, `OIDS`, `ON`, `ONLY`, `OPERATOR`, `OPTION`, `OPTIONS`, `OR`, `ORDER`, `ORDINALITY`, `OUT`, `OUTER`, `OVER`, `OVERLAPS`, `OVERLAY`, `OWNED`, `OWNER`, `PARSER`, `PARTIAL`, `PARTITION`, `PASSING`, `PASSWORD`, `PLACING`, `PLANS`, `POLICY`, `POSITION`, `PRECEDING`, `PRECISION`, `PREPARE`, `PREPARED`, `PRESERVE`, `PRIMARY`, `PRIOR`, `PRIVILEGES`, `PROCEDURAL`, `PROCEDURE`, `PROGRAM`, `QUOTE`, `RANGE`, `READ`, `REAL`, `REASSIGN`, `RECHECK`, `RECURSIVE`, `REF`, `REFERENCES`, `REFRESH`, `REINDEX`, `RELATIVE`, `RELEASE`, `RENAME`, `REPEATABLE`, `REPLACE`, `REPLICA`, `RESET`, `RESTART`, `RESTRICT`, `RETURNING`, `RETURNS`, `REVOKE`, `RIGHT`, `ROLE`, `ROLLBACK`, `ROW`, `ROWS`, `RULE`, `SAVEPOINT`, `SCHEMA`, `SCROLL`, `SEARCH`, `SECOND`, `SECURITY`, `SELECT`, `SEQUENCE`, `SEQUENCES`, `SERIALIZABLE`, `SERVER`, `SESSION`, `SESSION_USER`, `SET`, `SETOF`, `SHARE`, `SHOW`, `SIMILAR`, `SIMPLE`, `SMALLINT`, `SNAPSHOT`, `SOME`, `STABLE`, `STANDALONE`, `START`, `STATEMENT`, `STATISTICS`, `STDIN`, `STDOUT`, `STORAGE`, `STRICT`, `STRIP`, `SUBSTRING`, `SYMMETRIC`, `SYSID`, `SYSTEM`, `TABLE`, `TABLES`, `TABLESPACE`, `TEMP`, `TEMPLATE`, `TEMPORARY`, `TEXT`, `THEN`, `TIME`, `TIMESTAMP`, `TO`, `TRAILING`, `TRANSACTION`, `TREAT`, `TRIGGER`, `TRIM`, `TRUE`, `TRUNCATE`, `TRUSTED`, `TYPE`, `TYPES`, `UNBOUNDED`, `UNCOMMITTED`, `UNENCRYPTED`, `UNION`, `UNIQUE`, `UNKNOWN`, `UNLISTEN`, `UNLOGGED`, `UNTIL`, `UPDATE`, `USER`, `USING`, `VACUUM`, `VALID`, `VALIDATE`, `VALIDATOR`, `VALUE`, `VALUES`, `VARCHAR`, `VARIADIC`, `VARYING`, `VERBOSE`, `VERSION`, `VIEW`, `VIEWS`, `VOLATILE`, `WHEN`, `WHERE`, `WHITESPACE`, `WINDOW`, `WITH`, `WITHIN`, `WITHOUT`, `WORK`, `WRAPPER`, `WRITE`, `XML`, `XMLATTRIBUTES`, `XMLCONCAT`, `XMLELEMENT`, `XMLEXISTS`, `XMLFOREST`, `XMLPARSE`, `XMLPI`, `XMLROOT`, `XMLSERIALIZE`, `YEAR`, `YES`, `ZONE`, `ALIAS`, `CONSTANT`, `DIAGNOSTICS`, `ELSIF`, `EXCEPTION`, `EXIT`, `FOREACH`, `GET`, `LOOP`, `NOTICE`, `OPEN`, `PERFORM`, `QUERY`, `RAISE`, `RETURN`, `REVERSE`, `SQLSTATE`, `WHILE`), Keyword, nil}, {"[+*/<>=~!@#%^&|`?-]+", Operator, nil}, {`::`, Operator, nil}, {`\$\d+`, NameVariable, nil}, {`([0-9]*\.[0-9]*|[0-9]+)(e[+-]?[0-9]+)?`, LiteralNumberFloat, nil}, {`[0-9]+`, LiteralNumberInteger, nil}, {`((?:E|U&)?)(')`, ByGroups(LiteralStringAffix, LiteralStringSingle), Push("string")}, {`((?:U&)?)(")`, ByGroups(LiteralStringAffix, LiteralStringName), Push("quoted-ident")}, {`[a-z_]\w*`, Name, nil}, {`:(['"]?)[a-z]\w*\b\1`, NameVariable, nil}, {`[;:()\[\]{},.]`, Punctuation, nil}, }, "multiline-comments": { {`/\*`, CommentMultiline, Push("multiline-comments")}, {`\*/`, CommentMultiline, Pop(1)}, {`[^/*]+`, CommentMultiline, nil}, {`[/*]`, CommentMultiline, nil}, }, "string": { {`[^']+`, LiteralStringSingle, nil}, {`''`, LiteralStringSingle, nil}, {`'`, LiteralStringSingle, Pop(1)}, }, "quoted-ident": { {`[^"]+`, LiteralStringName, nil}, {`""`, LiteralStringName, nil}, {`"`, LiteralStringName, Pop(1)}, }, }, ))
Pl/Pgsql lexer.
var Pacmanconf = Register(MustNewLexer( &Config{ Name: "PacmanConf", Aliases: []string{"pacmanconf"}, Filenames: []string{"pacman.conf"}, MimeTypes: []string{}, }, Rules{ "root": { {`#.*$`, CommentSingle, nil}, {`^\s*\[.*?\]\s*$`, Keyword, nil}, {`(\w+)(\s*)(=)`, ByGroups(NameAttribute, Text, Operator), nil}, {`^(\s*)(\w+)(\s*)$`, ByGroups(Text, NameAttribute, Text), nil}, {Words(``, `\b`, `$repo`, `$arch`, `%o`, `%u`), NameVariable, nil}, {`.`, Text, nil}, }, }, ))
Pacmanconf lexer.
var Perl = Register(MustNewLexer( &Config{ Name: "Perl", Aliases: []string{"perl", "pl"}, Filenames: []string{"*.pl", "*.pm", "*.t"}, MimeTypes: []string{"text/x-perl", "application/x-perl"}, DotAll: true, }, Rules{ "balanced-regex": { {`/(\\\\|\\[^\\]|[^\\/])*/[egimosx]*`, LiteralStringRegex, Pop(1)}, {`!(\\\\|\\[^\\]|[^\\!])*![egimosx]*`, LiteralStringRegex, Pop(1)}, {`\\(\\\\|[^\\])*\\[egimosx]*`, LiteralStringRegex, Pop(1)}, {`\{(\\\\|\\[^\\]|[^\\}])*\}[egimosx]*`, LiteralStringRegex, Pop(1)}, {`<(\\\\|\\[^\\]|[^\\>])*>[egimosx]*`, LiteralStringRegex, Pop(1)}, {`\[(\\\\|\\[^\\]|[^\\\]])*\][egimosx]*`, LiteralStringRegex, Pop(1)}, {`\((\\\\|\\[^\\]|[^\\)])*\)[egimosx]*`, LiteralStringRegex, Pop(1)}, {`@(\\\\|\\[^\\]|[^\\@])*@[egimosx]*`, LiteralStringRegex, Pop(1)}, {`%(\\\\|\\[^\\]|[^\\%])*%[egimosx]*`, LiteralStringRegex, Pop(1)}, {`\$(\\\\|\\[^\\]|[^\\$])*\$[egimosx]*`, LiteralStringRegex, Pop(1)}, }, "root": { {`\A\#!.+?$`, CommentHashbang, nil}, {`\#.*?$`, CommentSingle, nil}, {`^=[a-zA-Z0-9]+\s+.*?\n=cut`, CommentMultiline, nil}, {Words(``, `\b`, `case`, `continue`, `do`, `else`, `elsif`, `for`, `foreach`, `if`, `last`, `my`, `next`, `our`, `redo`, `reset`, `then`, `unless`, `until`, `while`, `print`, `new`, `BEGIN`, `CHECK`, `INIT`, `END`, `return`), Keyword, nil}, {`(format)(\s+)(\w+)(\s*)(=)(\s*\n)`, ByGroups(Keyword, Text, Name, Text, Punctuation, Text), Push("format")}, {`(eq|lt|gt|le|ge|ne|not|and|or|cmp)\b`, OperatorWord, nil}, {`s/(\\\\|\\[^\\]|[^\\/])*/(\\\\|\\[^\\]|[^\\/])*/[egimosx]*`, LiteralStringRegex, nil}, {`s!(\\\\|\\!|[^!])*!(\\\\|\\!|[^!])*![egimosx]*`, LiteralStringRegex, nil}, {`s\\(\\\\|[^\\])*\\(\\\\|[^\\])*\\[egimosx]*`, LiteralStringRegex, nil}, {`s@(\\\\|\\[^\\]|[^\\@])*@(\\\\|\\[^\\]|[^\\@])*@[egimosx]*`, LiteralStringRegex, nil}, {`s%(\\\\|\\[^\\]|[^\\%])*%(\\\\|\\[^\\]|[^\\%])*%[egimosx]*`, LiteralStringRegex, nil}, {`s\{(\\\\|\\[^\\]|[^\\}])*\}\s*`, LiteralStringRegex, Push("balanced-regex")}, {`s<(\\\\|\\[^\\]|[^\\>])*>\s*`, LiteralStringRegex, Push("balanced-regex")}, {`s\[(\\\\|\\[^\\]|[^\\\]])*\]\s*`, LiteralStringRegex, Push("balanced-regex")}, {`s\((\\\\|\\[^\\]|[^\\)])*\)\s*`, LiteralStringRegex, Push("balanced-regex")}, {`m?/(\\\\|\\[^\\]|[^\\/\n])*/[gcimosx]*`, LiteralStringRegex, nil}, {`m(?=[/!\\{<\[(@%$])`, LiteralStringRegex, Push("balanced-regex")}, {`((?<==~)|(?<=\())\s*/(\\\\|\\[^\\]|[^\\/])*/[gcimosx]*`, LiteralStringRegex, nil}, {`\s+`, Text, nil}, {Words(``, `\b`, `abs`, `accept`, `alarm`, `atan2`, `bind`, `binmode`, `bless`, `caller`, `chdir`, `chmod`, `chomp`, `chop`, `chown`, `chr`, `chroot`, `close`, `closedir`, `connect`, `continue`, `cos`, `crypt`, `dbmclose`, `dbmopen`, `defined`, `delete`, `die`, `dump`, `each`, `endgrent`, `endhostent`, `endnetent`, `endprotoent`, `endpwent`, `endservent`, `eof`, `eval`, `exec`, `exists`, `exit`, `exp`, `fcntl`, `fileno`, `flock`, `fork`, `format`, `formline`, `getc`, `getgrent`, `getgrgid`, `getgrnam`, `gethostbyaddr`, `gethostbyname`, `gethostent`, `getlogin`, `getnetbyaddr`, `getnetbyname`, `getnetent`, `getpeername`, `getpgrp`, `getppid`, `getpriority`, `getprotobyname`, `getprotobynumber`, `getprotoent`, `getpwent`, `getpwnam`, `getpwuid`, `getservbyname`, `getservbyport`, `getservent`, `getsockname`, `getsockopt`, `glob`, `gmtime`, `goto`, `grep`, `hex`, `import`, `index`, `int`, `ioctl`, `join`, `keys`, `kill`, `last`, `lc`, `lcfirst`, `length`, `link`, `listen`, `local`, `localtime`, `log`, `lstat`, `map`, `mkdir`, `msgctl`, `msgget`, `msgrcv`, `msgsnd`, `my`, `next`, `oct`, `open`, `opendir`, `ord`, `our`, `pack`, `pipe`, `pop`, `pos`, `printf`, `prototype`, `push`, `quotemeta`, `rand`, `read`, `readdir`, `readline`, `readlink`, `readpipe`, `recv`, `redo`, `ref`, `rename`, `reverse`, `rewinddir`, `rindex`, `rmdir`, `scalar`, `seek`, `seekdir`, `select`, `semctl`, `semget`, `semop`, `send`, `setgrent`, `sethostent`, `setnetent`, `setpgrp`, `setpriority`, `setprotoent`, `setpwent`, `setservent`, `setsockopt`, `shift`, `shmctl`, `shmget`, `shmread`, `shmwrite`, `shutdown`, `sin`, `sleep`, `socket`, `socketpair`, `sort`, `splice`, `split`, `sprintf`, `sqrt`, `srand`, `stat`, `study`, `substr`, `symlink`, `syscall`, `sysopen`, `sysread`, `sysseek`, `system`, `syswrite`, `tell`, `telldir`, `tie`, `tied`, `time`, `times`, `tr`, `truncate`, `uc`, `ucfirst`, `umask`, `undef`, `unlink`, `unpack`, `unshift`, `untie`, `utime`, `values`, `vec`, `wait`, `waitpid`, `wantarray`, `warn`, `write`), NameBuiltin, nil}, {`((__(DATA|DIE|WARN)__)|(STD(IN|OUT|ERR)))\b`, NameBuiltinPseudo, nil}, {`(<<)([\'"]?)([a-zA-Z_]\w*)(\2;?\n.*?\n)(\3)(\n)`, ByGroups(LiteralString, LiteralString, LiteralStringDelimiter, LiteralString, LiteralStringDelimiter, Text), nil}, {`__END__`, CommentPreproc, Push("end-part")}, {`\$\^[ADEFHILMOPSTWX]`, NameVariableGlobal, nil}, {"\\$[\\\\\\\"\\[\\]'&`+*.,;=%~?@$!<>(^|/-](?!\\w)", NameVariableGlobal, nil}, {`[$@%#]+`, NameVariable, Push("varname")}, {`0_?[0-7]+(_[0-7]+)*`, LiteralNumberOct, nil}, {`0x[0-9A-Fa-f]+(_[0-9A-Fa-f]+)*`, LiteralNumberHex, nil}, {`0b[01]+(_[01]+)*`, LiteralNumberBin, nil}, {`(?i)(\d*(_\d*)*\.\d+(_\d*)*|\d+(_\d*)*\.\d+(_\d*)*)(e[+-]?\d+)?`, LiteralNumberFloat, nil}, {`(?i)\d+(_\d*)*e[+-]?\d+(_\d*)*`, LiteralNumberFloat, nil}, {`\d+(_\d+)*`, LiteralNumberInteger, nil}, {`'(\\\\|\\[^\\]|[^'\\])*'`, LiteralString, nil}, {`"(\\\\|\\[^\\]|[^"\\])*"`, LiteralString, nil}, {"`(\\\\\\\\|\\\\[^\\\\]|[^`\\\\])*`", LiteralStringBacktick, nil}, {`<([^\s>]+)>`, LiteralStringRegex, nil}, {`(q|qq|qw|qr|qx)\{`, LiteralStringOther, Push("cb-string")}, {`(q|qq|qw|qr|qx)\(`, LiteralStringOther, Push("rb-string")}, {`(q|qq|qw|qr|qx)\[`, LiteralStringOther, Push("sb-string")}, {`(q|qq|qw|qr|qx)\<`, LiteralStringOther, Push("lt-string")}, {`(q|qq|qw|qr|qx)([\W_])(.|\n)*?\2`, LiteralStringOther, nil}, {`(package)(\s+)([a-zA-Z_]\w*(?:::[a-zA-Z_]\w*)*)`, ByGroups(Keyword, Text, NameNamespace), nil}, {`(use|require|no)(\s+)([a-zA-Z_]\w*(?:::[a-zA-Z_]\w*)*)`, ByGroups(Keyword, Text, NameNamespace), nil}, {`(sub)(\s+)`, ByGroups(Keyword, Text), Push("funcname")}, {Words(``, `\b`, `no`, `package`, `require`, `use`), Keyword, nil}, {`(\[\]|\*\*|::|<<|>>|>=|<=>|<=|={3}|!=|=~|!~|&&?|\|\||\.{1,3})`, Operator, nil}, {`[-+/*%=<>&^|!\\~]=?`, Operator, nil}, {`[()\[\]:;,<>/?{}]`, Punctuation, nil}, {`(?=\w)`, Name, Push("name")}, }, "format": { {`\.\n`, LiteralStringInterpol, Pop(1)}, {`[^\n]*\n`, LiteralStringInterpol, nil}, }, "varname": { {`\s+`, Text, nil}, {`\{`, Punctuation, Pop(1)}, {`\)|,`, Punctuation, Pop(1)}, {`\w+::`, NameNamespace, nil}, {`[\w:]+`, NameVariable, Pop(1)}, }, "name": { {`[a-zA-Z_]\w*(::[a-zA-Z_]\w*)*(::)?(?=\s*->)`, NameNamespace, Pop(1)}, {`[a-zA-Z_]\w*(::[a-zA-Z_]\w*)*::`, NameNamespace, Pop(1)}, {`[\w:]+`, Name, Pop(1)}, {`[A-Z_]+(?=\W)`, NameConstant, Pop(1)}, {`(?=\W)`, Text, Pop(1)}, }, "funcname": { {`[a-zA-Z_]\w*[!?]?`, NameFunction, nil}, {`\s+`, Text, nil}, {`(\([$@%]*\))(\s*)`, ByGroups(Punctuation, Text), nil}, {`;`, Punctuation, Pop(1)}, {`.*?\{`, Punctuation, Pop(1)}, }, "cb-string": { {`\\[{}\\]`, LiteralStringOther, nil}, {`\\`, LiteralStringOther, nil}, {`\{`, LiteralStringOther, Push("cb-string")}, {`\}`, LiteralStringOther, Pop(1)}, {`[^{}\\]+`, LiteralStringOther, nil}, }, "rb-string": { {`\\[()\\]`, LiteralStringOther, nil}, {`\\`, LiteralStringOther, nil}, {`\(`, LiteralStringOther, Push("rb-string")}, {`\)`, LiteralStringOther, Pop(1)}, {`[^()]+`, LiteralStringOther, nil}, }, "sb-string": { {`\\[\[\]\\]`, LiteralStringOther, nil}, {`\\`, LiteralStringOther, nil}, {`\[`, LiteralStringOther, Push("sb-string")}, {`\]`, LiteralStringOther, Pop(1)}, {`[^\[\]]+`, LiteralStringOther, nil}, }, "lt-string": { {`\\[<>\\]`, LiteralStringOther, nil}, {`\\`, LiteralStringOther, nil}, {`\<`, LiteralStringOther, Push("lt-string")}, {`\>`, LiteralStringOther, Pop(1)}, {`[^<>]+`, LiteralStringOther, nil}, }, "end-part": { {`.+`, CommentPreproc, Pop(1)}, }, }, ))
Perl lexer.
var Pig = Register(MustNewLexer( &Config{ Name: "Pig", Aliases: []string{"pig"}, Filenames: []string{"*.pig"}, MimeTypes: []string{"text/x-pig"}, CaseInsensitive: true, }, Rules{ "root": { {`\s+`, Text, nil}, {`--.*`, Comment, nil}, {`/\*[\w\W]*?\*/`, CommentMultiline, nil}, {`\\\n`, Text, nil}, {`\\`, Text, nil}, {`\'(?:\\[ntbrf\\\']|\\u[0-9a-f]{4}|[^\'\\\n\r])*\'`, LiteralString, nil}, Include("keywords"), Include("types"), Include("builtins"), Include("punct"), Include("operators"), {`[0-9]*\.[0-9]+(e[0-9]+)?[fd]?`, LiteralNumberFloat, nil}, {`0x[0-9a-f]+`, LiteralNumberHex, nil}, {`[0-9]+L?`, LiteralNumberInteger, nil}, {`\n`, Text, nil}, {`([a-z_]\w*)(\s*)(\()`, ByGroups(NameFunction, Text, Punctuation), nil}, {`[()#:]`, Text, nil}, {`[^(:#\'")\s]+`, Text, nil}, {`\S+\s+`, Text, nil}, }, "keywords": { {"" /* 469 byte string literal not displayed */, Keyword, nil}, }, "builtins": { {"" /* 134 byte string literal not displayed */, NameBuiltin, nil}, }, "types": { {`(bytearray|BIGINTEGER|BIGDECIMAL|chararray|datetime|double|float|int|long|tuple)\b`, KeywordType, nil}, }, "punct": { {`[;(){}\[\]]`, Punctuation, nil}, }, "operators": { {`[#=,./%+\-?]`, Operator, nil}, {`(eq|gt|lt|gte|lte|neq|matches)\b`, Operator, nil}, {`(==|<=|<|>=|>|!=)`, Operator, nil}, }, }, ))
Pig lexer.
var Pkgconfig = Register(MustNewLexer( &Config{ Name: "PkgConfig", Aliases: []string{"pkgconfig"}, Filenames: []string{"*.pc"}, MimeTypes: []string{}, }, Rules{ "root": { {`#.*$`, CommentSingle, nil}, {`^(\w+)(=)`, ByGroups(NameAttribute, Operator), nil}, {`^([\w.]+)(:)`, ByGroups(NameTag, Punctuation), Push("spvalue")}, Include("interp"), {`[^${}#=:\n.]+`, Text, nil}, {`.`, Text, nil}, }, "interp": { {`\$\$`, Text, nil}, {`\$\{`, LiteralStringInterpol, Push("curly")}, }, "curly": { {`\}`, LiteralStringInterpol, Pop(1)}, {`\w+`, NameAttribute, nil}, }, "spvalue": { Include("interp"), {`#.*$`, CommentSingle, Pop(1)}, {`\n`, Text, Pop(1)}, {`[^${}#\n]+`, Text, nil}, {`.`, Text, nil}, }, }, ))
Pkgconfig lexer.
var PostgreSQL = Register(MustNewLexer( &Config{ Name: "PostgreSQL SQL dialect", Aliases: []string{"postgresql", "postgres"}, Filenames: []string{}, MimeTypes: []string{"text/x-postgresql"}, NotMultiline: true, CaseInsensitive: true, }, Rules{ "root": { {`\s+`, Text, nil}, {`--.*\n?`, CommentSingle, nil}, {`/\*`, CommentMultiline, Push("multiline-comments")}, {"" /* 572 byte string literal not displayed */, NameBuiltin, nil}, {Words(``, `\b`, `ABORT`, `ABSOLUTE`, `ACCESS`, `ACTION`, `ADD`, `ADMIN`, `AFTER`, `AGGREGATE`, `ALL`, `ALSO`, `ALTER`, `ALWAYS`, `ANALYSE`, `ANALYZE`, `AND`, `ANY`, `ARRAY`, `AS`, `ASC`, `ASSERTION`, `ASSIGNMENT`, `ASYMMETRIC`, `AT`, `ATTRIBUTE`, `AUTHORIZATION`, `BACKWARD`, `BEFORE`, `BEGIN`, `BETWEEN`, `BIGINT`, `BINARY`, `BIT`, `BOOLEAN`, `BOTH`, `BY`, `CACHE`, `CALLED`, `CASCADE`, `CASCADED`, `CASE`, `CAST`, `CATALOG`, `CHAIN`, `CHAR`, `CHARACTER`, `CHARACTERISTICS`, `CHECK`, `CHECKPOINT`, `CLASS`, `CLOSE`, `CLUSTER`, `COALESCE`, `COLLATE`, `COLLATION`, `COLUMN`, `COMMENT`, `COMMENTS`, `COMMIT`, `COMMITTED`, `CONCURRENTLY`, `CONFIGURATION`, `CONNECTION`, `CONSTRAINT`, `CONSTRAINTS`, `CONTENT`, `CONTINUE`, `CONVERSION`, `COPY`, `COST`, `CREATE`, `CROSS`, `CSV`, `CURRENT`, `CURRENT_CATALOG`, `CURRENT_DATE`, `CURRENT_ROLE`, `CURRENT_SCHEMA`, `CURRENT_TIME`, `CURRENT_TIMESTAMP`, `CURRENT_USER`, `CURSOR`, `CYCLE`, `DATA`, `DATABASE`, `DAY`, `DEALLOCATE`, `DEC`, `DECIMAL`, `DECLARE`, `DEFAULT`, `DEFAULTS`, `DEFERRABLE`, `DEFERRED`, `DEFINER`, `DELETE`, `DELIMITER`, `DELIMITERS`, `DESC`, `DICTIONARY`, `DISABLE`, `DISCARD`, `DISTINCT`, `DO`, `DOCUMENT`, `DOMAIN`, `DOUBLE`, `DROP`, `EACH`, `ELSE`, `ENABLE`, `ENCODING`, `ENCRYPTED`, `END`, `ENUM`, `ESCAPE`, `EVENT`, `EXCEPT`, `EXCLUDE`, `EXCLUDING`, `EXCLUSIVE`, `EXECUTE`, `EXISTS`, `EXPLAIN`, `EXTENSION`, `EXTERNAL`, `EXTRACT`, `FALSE`, `FAMILY`, `FETCH`, `FILTER`, `FIRST`, `FLOAT`, `FOLLOWING`, `FOR`, `FORCE`, `FOREIGN`, `FORWARD`, `FREEZE`, `FROM`, `FULL`, `FUNCTION`, `FUNCTIONS`, `GLOBAL`, `GRANT`, `GRANTED`, `GREATEST`, `GROUP`, `HANDLER`, `HAVING`, `HEADER`, `HOLD`, `HOUR`, `IDENTITY`, `IF`, `ILIKE`, `IMMEDIATE`, `IMMUTABLE`, `IMPLICIT`, `IN`, `INCLUDING`, `INCREMENT`, `INDEX`, `INDEXES`, `INHERIT`, `INHERITS`, `INITIALLY`, `INLINE`, `INNER`, `INOUT`, `INPUT`, `INSENSITIVE`, `INSERT`, `INSTEAD`, `INT`, `INTEGER`, `INTERSECT`, `INTERVAL`, `INTO`, `INVOKER`, `IS`, `ISNULL`, `ISOLATION`, `JOIN`, `KEY`, `LABEL`, `LANGUAGE`, `LARGE`, `LAST`, `LATERAL`, `LC_COLLATE`, `LC_CTYPE`, `LEADING`, `LEAKPROOF`, `LEAST`, `LEFT`, `LEVEL`, `LIKE`, `LIMIT`, `LISTEN`, `LOAD`, `LOCAL`, `LOCALTIME`, `LOCALTIMESTAMP`, `LOCATION`, `LOCK`, `MAPPING`, `MATCH`, `MATERIALIZED`, `MAXVALUE`, `MINUTE`, `MINVALUE`, `MODE`, `MONTH`, `MOVE`, `NAME`, `NAMES`, `NATIONAL`, `NATURAL`, `NCHAR`, `NEXT`, `NO`, `NONE`, `NOT`, `NOTHING`, `NOTIFY`, `NOTNULL`, `NOWAIT`, `NULL`, `NULLIF`, `NULLS`, `NUMERIC`, `OBJECT`, `OF`, `OFF`, `OFFSET`, `OIDS`, `ON`, `ONLY`, `OPERATOR`, `OPTION`, `OPTIONS`, `OR`, `ORDER`, `ORDINALITY`, `OUT`, `OUTER`, `OVER`, `OVERLAPS`, `OVERLAY`, `OWNED`, `OWNER`, `PARSER`, `PARTIAL`, `PARTITION`, `PASSING`, `PASSWORD`, `PLACING`, `PLANS`, `POLICY`, `POSITION`, `PRECEDING`, `PRECISION`, `PREPARE`, `PREPARED`, `PRESERVE`, `PRIMARY`, `PRIOR`, `PRIVILEGES`, `PROCEDURAL`, `PROCEDURE`, `PROGRAM`, `QUOTE`, `RANGE`, `READ`, `REAL`, `REASSIGN`, `RECHECK`, `RECURSIVE`, `REF`, `REFERENCES`, `REFRESH`, `REINDEX`, `RELATIVE`, `RELEASE`, `RENAME`, `REPEATABLE`, `REPLACE`, `REPLICA`, `RESET`, `RESTART`, `RESTRICT`, `RETURNING`, `RETURNS`, `REVOKE`, `RIGHT`, `ROLE`, `ROLLBACK`, `ROW`, `ROWS`, `RULE`, `SAVEPOINT`, `SCHEMA`, `SCROLL`, `SEARCH`, `SECOND`, `SECURITY`, `SELECT`, `SEQUENCE`, `SEQUENCES`, `SERIALIZABLE`, `SERVER`, `SESSION`, `SESSION_USER`, `SET`, `SETOF`, `SHARE`, `SHOW`, `SIMILAR`, `SIMPLE`, `SMALLINT`, `SNAPSHOT`, `SOME`, `STABLE`, `STANDALONE`, `START`, `STATEMENT`, `STATISTICS`, `STDIN`, `STDOUT`, `STORAGE`, `STRICT`, `STRIP`, `SUBSTRING`, `SYMMETRIC`, `SYSID`, `SYSTEM`, `TABLE`, `TABLES`, `TABLESPACE`, `TEMP`, `TEMPLATE`, `TEMPORARY`, `TEXT`, `THEN`, `TIME`, `TIMESTAMP`, `TO`, `TRAILING`, `TRANSACTION`, `TREAT`, `TRIGGER`, `TRIM`, `TRUE`, `TRUNCATE`, `TRUSTED`, `TYPE`, `TYPES`, `UNBOUNDED`, `UNCOMMITTED`, `UNENCRYPTED`, `UNION`, `UNIQUE`, `UNKNOWN`, `UNLISTEN`, `UNLOGGED`, `UNTIL`, `UPDATE`, `USER`, `USING`, `VACUUM`, `VALID`, `VALIDATE`, `VALIDATOR`, `VALUE`, `VALUES`, `VARCHAR`, `VARIADIC`, `VARYING`, `VERBOSE`, `VERSION`, `VIEW`, `VIEWS`, `VOLATILE`, `WHEN`, `WHERE`, `WHITESPACE`, `WINDOW`, `WITH`, `WITHIN`, `WITHOUT`, `WORK`, `WRAPPER`, `WRITE`, `XML`, `XMLATTRIBUTES`, `XMLCONCAT`, `XMLELEMENT`, `XMLEXISTS`, `XMLFOREST`, `XMLPARSE`, `XMLPI`, `XMLROOT`, `XMLSERIALIZE`, `YEAR`, `YES`, `ZONE`), Keyword, nil}, {"[+*/<>=~!@#%^&|`?-]+", Operator, nil}, {`::`, Operator, nil}, {`\$\d+`, NameVariable, nil}, {`([0-9]*\.[0-9]*|[0-9]+)(e[+-]?[0-9]+)?`, LiteralNumberFloat, nil}, {`[0-9]+`, LiteralNumberInteger, nil}, {`((?:E|U&)?)(')`, ByGroups(LiteralStringAffix, LiteralStringSingle), Push("string")}, {`((?:U&)?)(")`, ByGroups(LiteralStringAffix, LiteralStringName), Push("quoted-ident")}, {`[a-z_]\w*`, Name, nil}, {`:(['"]?)[a-z]\w*\b\1`, NameVariable, nil}, {`[;:()\[\]{},.]`, Punctuation, nil}, }, "multiline-comments": { {`/\*`, CommentMultiline, Push("multiline-comments")}, {`\*/`, CommentMultiline, Pop(1)}, {`[^/*]+`, CommentMultiline, nil}, {`[/*]`, CommentMultiline, nil}, }, "string": { {`[^']+`, LiteralStringSingle, nil}, {`''`, LiteralStringSingle, nil}, {`'`, LiteralStringSingle, Pop(1)}, }, "quoted-ident": { {`[^"]+`, LiteralStringName, nil}, {`""`, LiteralStringName, nil}, {`"`, LiteralStringName, Pop(1)}, }, }, ))
Postgresql Sql Dialect lexer.
var Postscript = Register(MustNewLexer( &Config{ Name: "PostScript", Aliases: []string{"postscript", "postscr"}, Filenames: []string{"*.ps", "*.eps"}, MimeTypes: []string{"application/postscript"}, }, Rules{ "root": { {`^%!.+\n`, CommentPreproc, nil}, {`%%.*\n`, CommentSpecial, nil}, {`(^%.*\n){2,}`, CommentMultiline, nil}, {`%.*\n`, CommentSingle, nil}, {`\(`, LiteralString, Push("stringliteral")}, {`[{}<>\[\]]`, Punctuation, nil}, {`<[0-9A-Fa-f]+>(?=[()<>\[\]{}/%\s])`, LiteralNumberHex, nil}, {`[0-9]+\#(\-|\+)?([0-9]+\.?|[0-9]*\.[0-9]+|[0-9]+\.[0-9]*)((e|E)[0-9]+)?(?=[()<>\[\]{}/%\s])`, LiteralNumberOct, nil}, {`(\-|\+)?([0-9]+\.?|[0-9]*\.[0-9]+|[0-9]+\.[0-9]*)((e|E)[0-9]+)?(?=[()<>\[\]{}/%\s])`, LiteralNumberFloat, nil}, {`(\-|\+)?[0-9]+(?=[()<>\[\]{}/%\s])`, LiteralNumberInteger, nil}, {`\/[^()<>\[\]{}/%\s]+(?=[()<>\[\]{}/%\s])`, NameVariable, nil}, {`[^()<>\[\]{}/%\s]+(?=[()<>\[\]{}/%\s])`, NameFunction, nil}, {`(false|true)(?=[()<>\[\]{}/%\s])`, KeywordConstant, nil}, {`(eq|ne|g[et]|l[et]|and|or|not|if(?:else)?|for(?:all)?)(?=[()<>\[\]{}/%\s])`, KeywordReserved, nil}, {Words(``, `(?=[()<>\[\]{}/%\s])`, `abs`, `add`, `aload`, `arc`, `arcn`, `array`, `atan`, `begin`, `bind`, `ceiling`, `charpath`, `clip`, `closepath`, `concat`, `concatmatrix`, `copy`, `cos`, `currentlinewidth`, `currentmatrix`, `currentpoint`, `curveto`, `cvi`, `cvs`, `def`, `defaultmatrix`, `dict`, `dictstackoverflow`, `div`, `dtransform`, `dup`, `end`, `exch`, `exec`, `exit`, `exp`, `fill`, `findfont`, `floor`, `get`, `getinterval`, `grestore`, `gsave`, `gt`, `identmatrix`, `idiv`, `idtransform`, `index`, `invertmatrix`, `itransform`, `length`, `lineto`, `ln`, `load`, `log`, `loop`, `matrix`, `mod`, `moveto`, `mul`, `neg`, `newpath`, `pathforall`, `pathbbox`, `pop`, `print`, `pstack`, `put`, `quit`, `rand`, `rangecheck`, `rcurveto`, `repeat`, `restore`, `rlineto`, `rmoveto`, `roll`, `rotate`, `round`, `run`, `save`, `scale`, `scalefont`, `setdash`, `setfont`, `setgray`, `setlinecap`, `setlinejoin`, `setlinewidth`, `setmatrix`, `setrgbcolor`, `shfill`, `show`, `showpage`, `sin`, `sqrt`, `stack`, `stringwidth`, `stroke`, `strokepath`, `sub`, `syntaxerror`, `transform`, `translate`, `truncate`, `typecheck`, `undefined`, `undefinedfilename`, `undefinedresult`), NameBuiltin, nil}, {`\s+`, Text, nil}, }, "stringliteral": { {`[^()\\]+`, LiteralString, nil}, {`\\`, LiteralStringEscape, Push("escape")}, {`\(`, LiteralString, Push()}, {`\)`, LiteralString, Pop(1)}, }, "escape": { {`[0-8]{3}|n|r|t|b|f|\\|\(|\)`, LiteralStringEscape, Pop(1)}, Default(Pop(1)), }, }, ))
Postscript lexer.
var Povray = Register(MustNewLexer( &Config{ Name: "POVRay", Aliases: []string{"pov"}, Filenames: []string{"*.pov", "*.inc"}, MimeTypes: []string{"text/x-povray"}, }, Rules{ "root": { {`/\*[\w\W]*?\*/`, CommentMultiline, nil}, {`//.*\n`, CommentSingle, nil}, {`(?s)"(?:\\.|[^"\\])+"`, LiteralStringDouble, nil}, {Words(`#`, `\b`, `break`, `case`, `debug`, `declare`, `default`, `define`, `else`, `elseif`, `end`, `error`, `fclose`, `fopen`, `for`, `if`, `ifdef`, `ifndef`, `include`, `local`, `macro`, `range`, `read`, `render`, `statistics`, `switch`, `undef`, `version`, `warning`, `while`, `write`), CommentPreproc, nil}, {Words(`\b`, `\b`, `aa_level`, `aa_threshold`, `abs`, `acos`, `acosh`, `adaptive`, `adc_bailout`, `agate`, `agate_turb`, `all`, `alpha`, `ambient`, `ambient_light`, `angle`, `aperture`, `arc_angle`, `area_light`, `asc`, `asin`, `asinh`, `assumed_gamma`, `atan`, `atan2`, `atanh`, `atmosphere`, `atmospheric_attenuation`, `attenuating`, `average`, `background`, `black_hole`, `blue`, `blur_samples`, `bounded_by`, `box_mapping`, `bozo`, `break`, `brick`, `brick_size`, `brightness`, `brilliance`, `bumps`, `bumpy1`, `bumpy2`, `bumpy3`, `bump_map`, `bump_size`, `case`, `caustics`, `ceil`, `checker`, `chr`, `clipped_by`, `clock`, `color`, `color_map`, `colour`, `colour_map`, `component`, `composite`, `concat`, `confidence`, `conic_sweep`, `constant`, `control0`, `control1`, `cos`, `cosh`, `count`, `crackle`, `crand`, `cube`, `cubic_spline`, `cylindrical_mapping`, `debug`, `declare`, `default`, `degrees`, `dents`, `diffuse`, `direction`, `distance`, `distance_maximum`, `div`, `dust`, `dust_type`, `eccentricity`, `else`, `emitting`, `end`, `error`, `error_bound`, `exp`, `exponent`, `fade_distance`, `fade_power`, `falloff`, `falloff_angle`, `false`, `file_exists`, `filter`, `finish`, `fisheye`, `flatness`, `flip`, `floor`, `focal_point`, `fog`, `fog_alt`, `fog_offset`, `fog_type`, `frequency`, `gif`, `global_settings`, `glowing`, `gradient`, `granite`, `gray_threshold`, `green`, `halo`, `hexagon`, `hf_gray_16`, `hierarchy`, `hollow`, `hypercomplex`, `if`, `ifdef`, `iff`, `image_map`, `incidence`, `include`, `int`, `interpolate`, `inverse`, `ior`, `irid`, `irid_wavelength`, `jitter`, `lambda`, `leopard`, `linear`, `linear_spline`, `linear_sweep`, `location`, `log`, `looks_like`, `look_at`, `low_error_factor`, `mandel`, `map_type`, `marble`, `material_map`, `matrix`, `max`, `max_intersections`, `max_iteration`, `max_trace_level`, `max_value`, `metallic`, `min`, `minimum_reuse`, `mod`, `mortar`, `nearest_count`, `no`, `normal`, `normal_map`, `no_shadow`, `number_of_waves`, `octaves`, `off`, `offset`, `omega`, `omnimax`, `on`, `once`, `onion`, `open`, `orthographic`, `panoramic`, `pattern1`, `pattern2`, `pattern3`, `perspective`, `pgm`, `phase`, `phong`, `phong_size`, `pi`, `pigment`, `pigment_map`, `planar_mapping`, `png`, `point_at`, `pot`, `pow`, `ppm`, `precision`, `pwr`, `quadratic_spline`, `quaternion`, `quick_color`, `quick_colour`, `quilted`, `radial`, `radians`, `radiosity`, `radius`, `rainbow`, `ramp_wave`, `rand`, `range`, `reciprocal`, `recursion_limit`, `red`, `reflection`, `refraction`, `render`, `repeat`, `rgb`, `rgbf`, `rgbft`, `rgbt`, `right`, `ripples`, `rotate`, `roughness`, `samples`, `scale`, `scallop_wave`, `scattering`, `seed`, `shadowless`, `sin`, `sine_wave`, `sinh`, `sky`, `sky_sphere`, `slice`, `slope_map`, `smooth`, `specular`, `spherical_mapping`, `spiral`, `spiral1`, `spiral2`, `spotlight`, `spotted`, `sqr`, `sqrt`, `statistics`, `str`, `strcmp`, `strength`, `strlen`, `strlwr`, `strupr`, `sturm`, `substr`, `switch`, `sys`, `t`, `tan`, `tanh`, `test_camera_1`, `test_camera_2`, `test_camera_3`, `test_camera_4`, `texture`, `texture_map`, `tga`, `thickness`, `threshold`, `tightness`, `tile2`, `tiles`, `track`, `transform`, `translate`, `transmit`, `triangle_wave`, `true`, `ttf`, `turbulence`, `turb_depth`, `type`, `ultra_wide_angle`, `up`, `use_color`, `use_colour`, `use_index`, `u_steps`, `val`, `variance`, `vaxis_rotate`, `vcross`, `vdot`, `version`, `vlength`, `vnormalize`, `volume_object`, `volume_rendered`, `vol_with_light`, `vrotate`, `v_steps`, `warning`, `warp`, `water_level`, `waves`, `while`, `width`, `wood`, `wrinkles`, `yes`), Keyword, nil}, {Words(``, `\b`, `bicubic_patch`, `blob`, `box`, `camera`, `cone`, `cubic`, `cylinder`, `difference`, `disc`, `height_field`, `intersection`, `julia_fractal`, `lathe`, `light_source`, `merge`, `mesh`, `object`, `plane`, `poly`, `polygon`, `prism`, `quadric`, `quartic`, `smooth_triangle`, `sor`, `sphere`, `superellipsoid`, `text`, `torus`, `triangle`, `union`), NameBuiltin, nil}, {`[\[\](){}<>;,]`, Punctuation, nil}, {`[-+*/=]`, Operator, nil}, {`\b(x|y|z|u|v)\b`, NameBuiltinPseudo, nil}, {`[a-zA-Z_]\w*`, Name, nil}, {`[0-9]+\.[0-9]*`, LiteralNumberFloat, nil}, {`\.[0-9]+`, LiteralNumberFloat, nil}, {`[0-9]+`, LiteralNumberInteger, nil}, {`"(\\\\|\\"|[^"])*"`, LiteralString, nil}, {`\s+`, Text, nil}, }, }, ))
Povray lexer.
var Powershell = Register(MustNewLexer( &Config{ Name: "PowerShell", Aliases: []string{"powershell", "posh", "ps1", "psm1"}, Filenames: []string{"*.ps1", "*.psm1"}, MimeTypes: []string{"text/x-powershell"}, DotAll: true, CaseInsensitive: true, }, Rules{ "root": { {`\(`, Punctuation, Push("child")}, {`\s+`, Text, nil}, {"" /* 199 byte string literal not displayed */, ByGroups(Comment, LiteralStringDoc, Comment), nil}, {`#[^\n]*?$`, Comment, nil}, {`(<|<)#`, CommentMultiline, Push("multline")}, {`@"\n`, LiteralStringHeredoc, Push("heredoc-double")}, {`@'\n.*?\n'@`, LiteralStringHeredoc, nil}, {"`[\\'\"$@-]", Punctuation, nil}, {`"`, LiteralStringDouble, Push("string")}, {`'([^']|'')*'`, LiteralStringSingle, nil}, {`(\$|@@|@)((global|script|private|env):)?\w+`, NameVariable, nil}, {"" /* 445 byte string literal not displayed */, Keyword, nil}, {"" /* 341 byte string literal not displayed */, Operator, nil}, {"" /* 461 byte string literal not displayed */, NameBuiltin, nil}, {"\\[[a-z_\\[][\\w. `,\\[\\]]*\\]", NameConstant, nil}, {`-[a-z_]\w*`, Name, nil}, {`\w+`, Name, nil}, {"[.,;@{}\\[\\]$()=+*/\\\\&%!~?^`|<>-]|::", Punctuation, nil}, }, "child": { {`\)`, Punctuation, Pop(1)}, Include("root"), }, "multline": { {`[^#&.]+`, CommentMultiline, nil}, {`#(>|>)`, CommentMultiline, Pop(1)}, {"" /* 173 byte string literal not displayed */, LiteralStringDoc, nil}, {`[#&.]`, CommentMultiline, nil}, }, "string": { {"`[0abfnrtv'\\\"$`]", LiteralStringEscape, nil}, {"[^$`\"]+", LiteralStringDouble, nil}, {`\$\(`, Punctuation, Push("child")}, {`""`, LiteralStringDouble, nil}, {"[`$]", LiteralStringDouble, nil}, {`"`, LiteralStringDouble, Pop(1)}, }, "heredoc-double": { {`\n"@`, LiteralStringHeredoc, Pop(1)}, {`\$\(`, Punctuation, Push("child")}, {`[^@\n]+"]`, LiteralStringHeredoc, nil}, {`.`, LiteralStringHeredoc, nil}, }, }, ))
Powershell lexer.
var Prolog = Register(MustNewLexer( &Config{ Name: "Prolog", Aliases: []string{"prolog"}, Filenames: []string{"*.ecl", "*.prolog", "*.pro", "*.pl"}, MimeTypes: []string{"text/x-prolog"}, }, Rules{ "root": { {`^#.*`, CommentSingle, nil}, {`/\*`, CommentMultiline, Push("nested-comment")}, {`%.*`, CommentSingle, nil}, {`0\'.`, LiteralStringChar, nil}, {`0b[01]+`, LiteralNumberBin, nil}, {`0o[0-7]+`, LiteralNumberOct, nil}, {`0x[0-9a-fA-F]+`, LiteralNumberHex, nil}, {`\d\d?\'[a-zA-Z0-9]+`, LiteralNumberInteger, nil}, {`(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?`, LiteralNumberFloat, nil}, {`\d+`, LiteralNumberInteger, nil}, {`[\[\](){}|.,;!]`, Punctuation, nil}, {`:-|-->`, Punctuation, nil}, {`"(?:\\x[0-9a-fA-F]+\\|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|\\[0-7]+\\|\\["\nabcefnrstv]|[^\\"])*"`, LiteralStringDouble, nil}, {`'(?:''|[^'])*'`, LiteralStringAtom, nil}, {`is\b`, Operator, nil}, {`(<|>|=<|>=|==|=:=|=|/|//|\*|\+|-)(?=\s|[a-zA-Z0-9\[])`, Operator, nil}, {`(mod|div|not)\b`, Operator, nil}, {`_`, Keyword, nil}, {`([a-z]+)(:)`, ByGroups(NameNamespace, Punctuation), nil}, {`([a-zÀ---][\w$À---]*)(\s*)(:-|-->)`, ByGroups(NameFunction, Text, Operator), nil}, {`([a-zÀ---][\w$À---]*)(\s*)(\()`, ByGroups(NameFunction, Text, Punctuation), nil}, {`[a-zÀ---][\w$À---]*`, LiteralStringAtom, nil}, {`[#&*+\-./:<=>?@\\^~¡-¿‐-〿]+`, LiteralStringAtom, nil}, {`[A-Z_]\w*`, NameVariable, nil}, {`\s+|[ --]`, Text, nil}, }, "nested-comment": { {`\*/`, CommentMultiline, Pop(1)}, {`/\*`, CommentMultiline, Push()}, {`[^*/]+`, CommentMultiline, nil}, {`[*/]`, CommentMultiline, nil}, }, }, ))
Prolog lexer.
var ProtocolBuffer = Register(MustNewLexer( &Config{ Name: "Protocol Buffer", Aliases: []string{"protobuf", "proto"}, Filenames: []string{"*.proto"}, MimeTypes: []string{}, }, Rules{ "root": { {`[ \t]+`, Text, nil}, {`[,;{}\[\]()<>]`, Punctuation, nil}, {`/(\\\n)?/(\n|(.|\n)*?[^\\]\n)`, CommentSingle, nil}, {`/(\\\n)?\*(.|\n)*?\*(\\\n)?/`, CommentMultiline, nil}, {Words(`\b`, `\b`, `import`, `option`, `optional`, `required`, `repeated`, `default`, `packed`, `ctype`, `extensions`, `to`, `max`, `rpc`, `returns`, `oneof`), Keyword, nil}, {Words(``, `\b`, `int32`, `int64`, `uint32`, `uint64`, `sint32`, `sint64`, `fixed32`, `fixed64`, `sfixed32`, `sfixed64`, `float`, `double`, `bool`, `string`, `bytes`), KeywordType, nil}, {`(true|false)\b`, KeywordConstant, nil}, {`(package)(\s+)`, ByGroups(KeywordNamespace, Text), Push("package")}, {`(message|extend)(\s+)`, ByGroups(KeywordDeclaration, Text), Push("message")}, {`(enum|group|service)(\s+)`, ByGroups(KeywordDeclaration, Text), Push("type")}, {`\".*?\"`, LiteralString, nil}, {`\'.*?\'`, LiteralString, nil}, {`(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*`, LiteralNumberFloat, nil}, {`(\d+\.\d*|\.\d+|\d+[fF])[fF]?`, LiteralNumberFloat, nil}, {`(\-?(inf|nan))\b`, LiteralNumberFloat, nil}, {`0x[0-9a-fA-F]+[LlUu]*`, LiteralNumberHex, nil}, {`0[0-7]+[LlUu]*`, LiteralNumberOct, nil}, {`\d+[LlUu]*`, LiteralNumberInteger, nil}, {`[+-=]`, Operator, nil}, {`([a-zA-Z_][\w.]*)([ \t]*)(=)`, ByGroups(NameAttribute, Text, Operator), nil}, {`[a-zA-Z_][\w.]*`, Name, nil}, }, "package": { {`[a-zA-Z_]\w*`, NameNamespace, Pop(1)}, Default(Pop(1)), }, "message": { {`[a-zA-Z_]\w*`, NameClass, Pop(1)}, Default(Pop(1)), }, "type": { {`[a-zA-Z_]\w*`, Name, Pop(1)}, Default(Pop(1)), }, }, ))
ProtocolBuffer lexer.
var Puppet = Register(MustNewLexer( &Config{ Name: "Puppet", Aliases: []string{"puppet"}, Filenames: []string{"*.pp"}, MimeTypes: []string{}, }, Rules{ "root": { Include("comments"), Include("keywords"), Include("names"), Include("numbers"), Include("operators"), Include("strings"), {`[]{}:(),;[]`, Punctuation, nil}, {`[^\S\n]+`, Text, nil}, }, "comments": { {`\s*#.*$`, Comment, nil}, {`/(\\\n)?[*](.|\n)*?[*](\\\n)?/`, CommentMultiline, nil}, }, "operators": { {`(=>|\?|<|>|=|\+|-|/|\*|~|!|\|)`, Operator, nil}, {`(in|and|or|not)\b`, OperatorWord, nil}, }, "names": { {`[a-zA-Z_]\w*`, NameAttribute, nil}, {`(\$\S+)(\[)(\S+)(\])`, ByGroups(NameVariable, Punctuation, LiteralString, Punctuation), nil}, {`\$\S+`, NameVariable, nil}, }, "numbers": { {`(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?j?`, LiteralNumberFloat, nil}, {`\d+[eE][+-]?[0-9]+j?`, LiteralNumberFloat, nil}, {`0[0-7]+j?`, LiteralNumberOct, nil}, {`0[xX][a-fA-F0-9]+`, LiteralNumberHex, nil}, {`\d+L`, LiteralNumberIntegerLong, nil}, {`\d+j?`, LiteralNumberInteger, nil}, }, "keywords": { {Words(`(?i)`, `\b`, `absent`, `alert`, `alias`, `audit`, `augeas`, `before`, `case`, `check`, `class`, `computer`, `configured`, `contained`, `create_resources`, `crit`, `cron`, `debug`, `default`, `define`, `defined`, `directory`, `else`, `elsif`, `emerg`, `err`, `exec`, `extlookup`, `fail`, `false`, `file`, `filebucket`, `fqdn_rand`, `generate`, `host`, `if`, `import`, `include`, `info`, `inherits`, `inline_template`, `installed`, `interface`, `k5login`, `latest`, `link`, `loglevel`, `macauthorization`, `mailalias`, `maillist`, `mcx`, `md5`, `mount`, `mounted`, `nagios_command`, `nagios_contact`, `nagios_contactgroup`, `nagios_host`, `nagios_hostdependency`, `nagios_hostescalation`, `nagios_hostextinfo`, `nagios_hostgroup`, `nagios_service`, `nagios_servicedependency`, `nagios_serviceescalation`, `nagios_serviceextinfo`, `nagios_servicegroup`, `nagios_timeperiod`, `node`, `noop`, `notice`, `notify`, `package`, `present`, `purged`, `realize`, `regsubst`, `resources`, `role`, `router`, `running`, `schedule`, `scheduled_task`, `search`, `selboolean`, `selmodule`, `service`, `sha1`, `shellquote`, `split`, `sprintf`, `ssh_authorized_key`, `sshkey`, `stage`, `stopped`, `subscribe`, `tag`, `tagged`, `template`, `tidy`, `true`, `undef`, `unmounted`, `user`, `versioncmp`, `vlan`, `warning`, `yumrepo`, `zfs`, `zone`, `zpool`), Keyword, nil}, }, "strings": { {`"([^"])*"`, LiteralString, nil}, {`'(\\'|[^'])*'`, LiteralString, nil}, }, }, ))
Puppet lexer.
var Python = Register(MustNewLexer( &Config{ Name: "Python", Aliases: []string{"python", "py", "sage"}, Filenames: []string{"*.py", "*.pyw", "*.sc", "SConstruct", "SConscript", "*.tac", "*.sage"}, MimeTypes: []string{"text/x-python", "application/x-python"}, }, Rules{ "root": { {`\n`, Text, nil}, {`^(\s*)([rRuUbB]{,2})("""(?:.|\n)*?""")`, ByGroups(Text, LiteralStringAffix, LiteralStringDoc), nil}, {`^(\s*)([rRuUbB]{,2})('''(?:.|\n)*?''')`, ByGroups(Text, LiteralStringAffix, LiteralStringDoc), nil}, {`[^\S\n]+`, Text, nil}, {`\A#!.+$`, CommentHashbang, nil}, {`#.*$`, CommentSingle, nil}, {`[]{}:(),;[]`, Punctuation, nil}, {`\\\n`, Text, nil}, {`\\`, Text, nil}, {`(in|is|and|or|not)\b`, OperatorWord, nil}, {`!=|==|<<|>>|[-~+/*%=<>&^|.]`, Operator, nil}, Include("keywords"), {`(def)((?:\s|\\\s)+)`, ByGroups(Keyword, Text), Push("funcname")}, {`(class)((?:\s|\\\s)+)`, ByGroups(Keyword, Text), Push("classname")}, {`(from)((?:\s|\\\s)+)`, ByGroups(KeywordNamespace, Text), Push("fromimport")}, {`(import)((?:\s|\\\s)+)`, ByGroups(KeywordNamespace, Text), Push("import")}, Include("builtins"), Include("magicfuncs"), Include("magicvars"), Include("backtick"), {`([rR]|[uUbB][rR]|[rR][uUbB])(""")`, ByGroups(LiteralStringAffix, LiteralStringDouble), Push("tdqs")}, {`([rR]|[uUbB][rR]|[rR][uUbB])(''')`, ByGroups(LiteralStringAffix, LiteralStringSingle), Push("tsqs")}, {`([rR]|[uUbB][rR]|[rR][uUbB])(")`, ByGroups(LiteralStringAffix, LiteralStringDouble), Push("dqs")}, {`([rR]|[uUbB][rR]|[rR][uUbB])(')`, ByGroups(LiteralStringAffix, LiteralStringSingle), Push("sqs")}, {`([uUbB]?)(""")`, ByGroups(LiteralStringAffix, LiteralStringDouble), Combined("stringescape", "tdqs")}, {`([uUbB]?)(''')`, ByGroups(LiteralStringAffix, LiteralStringSingle), Combined("stringescape", "tsqs")}, {`([uUbB]?)(")`, ByGroups(LiteralStringAffix, LiteralStringDouble), Combined("stringescape", "dqs")}, {`([uUbB]?)(')`, ByGroups(LiteralStringAffix, LiteralStringSingle), Combined("stringescape", "sqs")}, Include("name"), Include("numbers"), }, "keywords": { {Words(``, `\b`, `assert`, `break`, `continue`, `del`, `elif`, `else`, `except`, `exec`, `finally`, `for`, `global`, `if`, `lambda`, `pass`, `print`, `raise`, `return`, `try`, `while`, `yield`, `yield from`, `as`, `with`), Keyword, nil}, }, "builtins": { {Words(`(?<!\.)`, `\b`, `__import__`, `abs`, `all`, `any`, `apply`, `basestring`, `bin`, `bool`, `buffer`, `bytearray`, `bytes`, `callable`, `chr`, `classmethod`, `cmp`, `coerce`, `compile`, `complex`, `delattr`, `dict`, `dir`, `divmod`, `enumerate`, `eval`, `execfile`, `exit`, `file`, `filter`, `float`, `frozenset`, `getattr`, `globals`, `hasattr`, `hash`, `hex`, `id`, `input`, `int`, `intern`, `isinstance`, `issubclass`, `iter`, `len`, `list`, `locals`, `long`, `map`, `max`, `min`, `next`, `object`, `oct`, `open`, `ord`, `pow`, `property`, `range`, `raw_input`, `reduce`, `reload`, `repr`, `reversed`, `round`, `set`, `setattr`, `slice`, `sorted`, `staticmethod`, `str`, `sum`, `super`, `tuple`, `type`, `unichr`, `unicode`, `vars`, `xrange`, `zip`), NameBuiltin, nil}, {`(?<!\.)(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}, }, "magicfuncs": { {Words(``, `\b`, `__abs__`, `__add__`, `__and__`, `__call__`, `__cmp__`, `__coerce__`, `__complex__`, `__contains__`, `__del__`, `__delattr__`, `__delete__`, `__delitem__`, `__delslice__`, `__div__`, `__divmod__`, `__enter__`, `__eq__`, `__exit__`, `__float__`, `__floordiv__`, `__ge__`, `__get__`, `__getattr__`, `__getattribute__`, `__getitem__`, `__getslice__`, `__gt__`, `__hash__`, `__hex__`, `__iadd__`, `__iand__`, `__idiv__`, `__ifloordiv__`, `__ilshift__`, `__imod__`, `__imul__`, `__index__`, `__init__`, `__instancecheck__`, `__int__`, `__invert__`, `__iop__`, `__ior__`, `__ipow__`, `__irshift__`, `__isub__`, `__iter__`, `__itruediv__`, `__ixor__`, `__le__`, `__len__`, `__long__`, `__lshift__`, `__lt__`, `__missing__`, `__mod__`, `__mul__`, `__ne__`, `__neg__`, `__new__`, `__nonzero__`, `__oct__`, `__op__`, `__or__`, `__pos__`, `__pow__`, `__radd__`, `__rand__`, `__rcmp__`, `__rdiv__`, `__rdivmod__`, `__repr__`, `__reversed__`, `__rfloordiv__`, `__rlshift__`, `__rmod__`, `__rmul__`, `__rop__`, `__ror__`, `__rpow__`, `__rrshift__`, `__rshift__`, `__rsub__`, `__rtruediv__`, `__rxor__`, `__set__`, `__setattr__`, `__setitem__`, `__setslice__`, `__str__`, `__sub__`, `__subclasscheck__`, `__truediv__`, `__unicode__`, `__xor__`), NameFunctionMagic, nil}, }, "magicvars": { {Words(``, `\b`, `__bases__`, `__class__`, `__closure__`, `__code__`, `__defaults__`, `__dict__`, `__doc__`, `__file__`, `__func__`, `__globals__`, `__metaclass__`, `__module__`, `__mro__`, `__name__`, `__self__`, `__slots__`, `__weakref__`), NameVariableMagic, nil}, }, "numbers": { {`(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?j?`, LiteralNumberFloat, nil}, {`\d+[eE][+-]?[0-9]+j?`, LiteralNumberFloat, nil}, {`0[0-7]+j?`, LiteralNumberOct, nil}, {`0[bB][01]+`, LiteralNumberBin, nil}, {`0[xX][a-fA-F0-9]+`, LiteralNumberHex, nil}, {`\d+L`, LiteralNumberIntegerLong, nil}, {`\d+j?`, LiteralNumberInteger, nil}, }, "backtick": { {"`.*?`", LiteralStringBacktick, nil}, }, "name": { {`@[\w.]+`, NameDecorator, nil}, {`[a-zA-Z_]\w*`, Name, nil}, }, "funcname": { Include("magicfuncs"), {`[a-zA-Z_]\w*`, NameFunction, Pop(1)}, Default(Pop(1)), }, "classname": { {`[a-zA-Z_]\w*`, NameClass, Pop(1)}, }, "import": { {`(?:[ \t]|\\\n)+`, Text, nil}, {`as\b`, KeywordNamespace, nil}, {`,`, Operator, nil}, {`[a-zA-Z_][\w.]*`, NameNamespace, nil}, Default(Pop(1)), }, "fromimport": { {`(?:[ \t]|\\\n)+`, Text, nil}, {`import\b`, KeywordNamespace, Pop(1)}, {`None\b`, NameBuiltinPseudo, Pop(1)}, {`[a-zA-Z_.][\w.]*`, NameNamespace, nil}, Default(Pop(1)), }, "stringescape": { {`\\([\\abfnrtv"\']|\n|N\{.*?\}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})`, LiteralStringEscape, nil}, }, "strings-single": { {`%(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[E-GXc-giorsux%]`, LiteralStringInterpol, nil}, {`[^\\\'"%\n]+`, LiteralStringSingle, nil}, {`[\'"\\]`, LiteralStringSingle, nil}, {`%`, LiteralStringSingle, nil}, }, "strings-double": { {`%(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[E-GXc-giorsux%]`, LiteralStringInterpol, nil}, {`[^\\\'"%\n]+`, LiteralStringDouble, nil}, {`[\'"\\]`, LiteralStringDouble, nil}, {`%`, LiteralStringDouble, nil}, }, "dqs": { {`"`, LiteralStringDouble, Pop(1)}, {`\\\\|\\"|\\\n`, LiteralStringEscape, nil}, Include("strings-double"), }, "sqs": { {`'`, LiteralStringSingle, Pop(1)}, {`\\\\|\\'|\\\n`, LiteralStringEscape, nil}, Include("strings-single"), }, "tdqs": { {`"""`, LiteralStringDouble, Pop(1)}, Include("strings-double"), {`\n`, LiteralStringDouble, nil}, }, "tsqs": { {`'''`, LiteralStringSingle, Pop(1)}, Include("strings-single"), {`\n`, LiteralStringSingle, nil}, }, }, ))
Python lexer.
var Python3 = Register(MustNewLexer( &Config{ Name: "Python 3", Aliases: []string{"python3", "py3"}, Filenames: []string{}, MimeTypes: []string{"text/x-python3", "application/x-python3"}, }, Rules{ "root": { {`\n`, Text, nil}, {`^(\s*)([rRuUbB]{,2})("""(?:.|\n)*?""")`, ByGroups(Text, LiteralStringAffix, LiteralStringDoc), nil}, {`^(\s*)([rRuUbB]{,2})('''(?:.|\n)*?''')`, ByGroups(Text, LiteralStringAffix, LiteralStringDoc), nil}, {`[^\S\n]+`, Text, nil}, {`\A#!.+$`, CommentHashbang, nil}, {`#.*$`, CommentSingle, nil}, {`[]{}:(),;[]`, Punctuation, nil}, {`\\\n`, Text, nil}, {`\\`, Text, nil}, {`(in|is|and|or|not)\b`, OperatorWord, nil}, {`!=|==|<<|>>|[-~+/*%=<>&^|.]`, Operator, nil}, Include("keywords"), {`(def)((?:\s|\\\s)+)`, ByGroups(Keyword, Text), Push("funcname")}, {`(class)((?:\s|\\\s)+)`, ByGroups(Keyword, Text), Push("classname")}, {`(from)((?:\s|\\\s)+)`, ByGroups(KeywordNamespace, Text), Push("fromimport")}, {`(import)((?:\s|\\\s)+)`, ByGroups(KeywordNamespace, Text), Push("import")}, Include("builtins"), Include("magicfuncs"), Include("magicvars"), Include("backtick"), {`([rR]|[uUbB][rR]|[rR][uUbB])(""")`, ByGroups(LiteralStringAffix, LiteralStringDouble), Push("tdqs")}, {`([rR]|[uUbB][rR]|[rR][uUbB])(''')`, ByGroups(LiteralStringAffix, LiteralStringSingle), Push("tsqs")}, {`([rR]|[uUbB][rR]|[rR][uUbB])(")`, ByGroups(LiteralStringAffix, LiteralStringDouble), Push("dqs")}, {`([rR]|[uUbB][rR]|[rR][uUbB])(')`, ByGroups(LiteralStringAffix, LiteralStringSingle), Push("sqs")}, {`([uUbB]?)(""")`, ByGroups(LiteralStringAffix, LiteralStringDouble), Combined("stringescape", "tdqs")}, {`([uUbB]?)(''')`, ByGroups(LiteralStringAffix, LiteralStringSingle), Combined("stringescape", "tsqs")}, {`([uUbB]?)(")`, ByGroups(LiteralStringAffix, LiteralStringDouble), Combined("stringescape", "dqs")}, {`([uUbB]?)(')`, ByGroups(LiteralStringAffix, LiteralStringSingle), Combined("stringescape", "sqs")}, Include("name"), Include("numbers"), }, "keywords": { {Words(``, `\b`, `assert`, `async`, `await`, `break`, `continue`, `del`, `elif`, `else`, `except`, `finally`, `for`, `global`, `if`, `lambda`, `pass`, `raise`, `nonlocal`, `return`, `try`, `while`, `yield`, `yield from`, `as`, `with`), Keyword, nil}, {Words(``, `\b`, `True`, `False`, `None`), KeywordConstant, nil}, }, "builtins": { {Words(`(?<!\.)`, `\b`, `__import__`, `abs`, `all`, `any`, `bin`, `bool`, `bytearray`, `bytes`, `chr`, `classmethod`, `cmp`, `compile`, `complex`, `delattr`, `dict`, `dir`, `divmod`, `enumerate`, `eval`, `filter`, `float`, `format`, `frozenset`, `getattr`, `globals`, `hasattr`, `hash`, `hex`, `id`, `input`, `int`, `isinstance`, `issubclass`, `iter`, `len`, `list`, `locals`, `map`, `max`, `memoryview`, `min`, `next`, `object`, `oct`, `open`, `ord`, `pow`, `print`, `property`, `range`, `repr`, `reversed`, `round`, `set`, `setattr`, `slice`, `sorted`, `staticmethod`, `str`, `sum`, `super`, `tuple`, `type`, `vars`, `zip`), NameBuiltin, nil}, {`(?<!\.)(self|Ellipsis|NotImplemented|cls)\b`, NameBuiltinPseudo, nil}, {Words(`(?<!\.)`, `\b`, `ArithmeticError`, `AssertionError`, `AttributeError`, `BaseException`, `BufferError`, `BytesWarning`, `DeprecationWarning`, `EOFError`, `EnvironmentError`, `Exception`, `FloatingPointError`, `FutureWarning`, `GeneratorExit`, `IOError`, `ImportError`, `ImportWarning`, `IndentationError`, `IndexError`, `KeyError`, `KeyboardInterrupt`, `LookupError`, `MemoryError`, `NameError`, `NotImplementedError`, `OSError`, `OverflowError`, `PendingDeprecationWarning`, `ReferenceError`, `ResourceWarning`, `RuntimeError`, `RuntimeWarning`, `StopIteration`, `SyntaxError`, `SyntaxWarning`, `SystemError`, `SystemExit`, `TabError`, `TypeError`, `UnboundLocalError`, `UnicodeDecodeError`, `UnicodeEncodeError`, `UnicodeError`, `UnicodeTranslateError`, `UnicodeWarning`, `UserWarning`, `ValueError`, `VMSError`, `Warning`, `WindowsError`, `ZeroDivisionError`, `BlockingIOError`, `ChildProcessError`, `ConnectionError`, `BrokenPipeError`, `ConnectionAbortedError`, `ConnectionRefusedError`, `ConnectionResetError`, `FileExistsError`, `FileNotFoundError`, `InterruptedError`, `IsADirectoryError`, `NotADirectoryError`, `PermissionError`, `ProcessLookupError`, `TimeoutError`), NameException, nil}, }, "magicfuncs": { {Words(``, `\b`, `__abs__`, `__add__`, `__aenter__`, `__aexit__`, `__aiter__`, `__and__`, `__anext__`, `__await__`, `__bool__`, `__bytes__`, `__call__`, `__complex__`, `__contains__`, `__del__`, `__delattr__`, `__delete__`, `__delitem__`, `__dir__`, `__divmod__`, `__enter__`, `__eq__`, `__exit__`, `__float__`, `__floordiv__`, `__format__`, `__ge__`, `__get__`, `__getattr__`, `__getattribute__`, `__getitem__`, `__gt__`, `__hash__`, `__iadd__`, `__iand__`, `__ifloordiv__`, `__ilshift__`, `__imatmul__`, `__imod__`, `__import__`, `__imul__`, `__index__`, `__init__`, `__instancecheck__`, `__int__`, `__invert__`, `__ior__`, `__ipow__`, `__irshift__`, `__isub__`, `__iter__`, `__itruediv__`, `__ixor__`, `__le__`, `__len__`, `__length_hint__`, `__lshift__`, `__lt__`, `__matmul__`, `__missing__`, `__mod__`, `__mul__`, `__ne__`, `__neg__`, `__new__`, `__next__`, `__or__`, `__pos__`, `__pow__`, `__prepare__`, `__radd__`, `__rand__`, `__rdivmod__`, `__repr__`, `__reversed__`, `__rfloordiv__`, `__rlshift__`, `__rmatmul__`, `__rmod__`, `__rmul__`, `__ror__`, `__round__`, `__rpow__`, `__rrshift__`, `__rshift__`, `__rsub__`, `__rtruediv__`, `__rxor__`, `__set__`, `__setattr__`, `__setitem__`, `__str__`, `__sub__`, `__subclasscheck__`, `__truediv__`, `__xor__`), NameFunctionMagic, nil}, }, "magicvars": { {Words(``, `\b`, `__annotations__`, `__bases__`, `__class__`, `__closure__`, `__code__`, `__defaults__`, `__dict__`, `__doc__`, `__file__`, `__func__`, `__globals__`, `__kwdefaults__`, `__module__`, `__mro__`, `__name__`, `__objclass__`, `__qualname__`, `__self__`, `__slots__`, `__weakref__`), NameVariableMagic, nil}, }, "numbers": { {`(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?`, LiteralNumberFloat, nil}, {`\d+[eE][+-]?[0-9]+j?`, LiteralNumberFloat, nil}, {`0[oO][0-7]+`, LiteralNumberOct, nil}, {`0[bB][01]+`, LiteralNumberBin, nil}, {`0[xX][a-fA-F0-9]+`, LiteralNumberHex, nil}, {`\d+`, LiteralNumberInteger, nil}, }, "backtick": {}, "name": { {`@\w+`, NameDecorator, nil}, {`@`, Operator, nil}, {"" /* 6945 byte string literal not displayed */, Name, nil}, }, "funcname": { {"" /* 6945 byte string literal not displayed */, NameFunction, Pop(1)}, }, "classname": { {"" /* 6945 byte string literal not displayed */, NameClass, Pop(1)}, }, "import": { {`(\s+)(as)(\s+)`, ByGroups(Text, Keyword, Text), nil}, {`\.`, NameNamespace, nil}, {"" /* 6945 byte string literal not displayed */, NameNamespace, nil}, {`(\s*)(,)(\s*)`, ByGroups(Text, Operator, Text), nil}, Default(Pop(1)), }, "fromimport": { {`(\s+)(import)\b`, ByGroups(Text, Keyword), Pop(1)}, {`\.`, NameNamespace, nil}, {"" /* 6945 byte string literal not displayed */, NameNamespace, nil}, Default(Pop(1)), }, "stringescape": { {`\\([\\abfnrtv"\']|\n|N\{.*?\}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})`, LiteralStringEscape, nil}, }, "strings-single": { {`%(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[E-GXc-giorsux%]`, LiteralStringInterpol, nil}, {`\{((\w+)((\.\w+)|(\[[^\]]+\]))*)?(\![sra])?(\:(.?[<>=\^])?[-+ ]?#?0?(\d+)?,?(\.\d+)?[E-GXb-gnosx%]?)?\}`, LiteralStringInterpol, nil}, {`[^\\\'"%{\n]+`, LiteralStringSingle, nil}, {`[\'"\\]`, LiteralStringSingle, nil}, {`%|(\{{1,2})`, LiteralStringSingle, nil}, }, "strings-double": { {`%(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[E-GXc-giorsux%]`, LiteralStringInterpol, nil}, {`\{((\w+)((\.\w+)|(\[[^\]]+\]))*)?(\![sra])?(\:(.?[<>=\^])?[-+ ]?#?0?(\d+)?,?(\.\d+)?[E-GXb-gnosx%]?)?\}`, LiteralStringInterpol, nil}, {`[^\\\'"%{\n]+`, LiteralStringDouble, nil}, {`[\'"\\]`, LiteralStringDouble, nil}, {`%|(\{{1,2})`, LiteralStringDouble, nil}, }, "dqs": { {`"`, LiteralStringDouble, Pop(1)}, {`\\\\|\\"|\\\n`, LiteralStringEscape, nil}, Include("strings-double"), }, "sqs": { {`'`, LiteralStringSingle, Pop(1)}, {`\\\\|\\'|\\\n`, LiteralStringEscape, nil}, Include("strings-single"), }, "tdqs": { {`"""`, LiteralStringDouble, Pop(1)}, Include("strings-double"), {`\n`, LiteralStringDouble, nil}, }, "tsqs": { {`'''`, LiteralStringSingle, Pop(1)}, Include("strings-single"), {`\n`, LiteralStringSingle, nil}, }, }, ))
Python3 lexer.
var Qbasic = Register(MustNewLexer( &Config{ Name: "QBasic", Aliases: []string{"qbasic", "basic"}, Filenames: []string{"*.BAS", "*.bas"}, MimeTypes: []string{"text/basic"}, }, Rules{ "root": { {`\n+`, Text, nil}, {`\s+`, TextWhitespace, nil}, {`^(\s*)(\d*)(\s*)(REM .*)$`, ByGroups(TextWhitespace, NameLabel, TextWhitespace, CommentSingle), nil}, {`^(\s*)(\d+)(\s*)`, ByGroups(TextWhitespace, NameLabel, TextWhitespace), nil}, {`(?=[\s]*)(\w+)(?=[\s]*=)`, NameVariableGlobal, nil}, {`(?=[^"]*)\'.*$`, CommentSingle, nil}, {`"[^\n"]*"`, LiteralStringDouble, nil}, {`(END)(\s+)(FUNCTION|IF|SELECT|SUB)`, ByGroups(KeywordReserved, TextWhitespace, KeywordReserved), nil}, {`(DECLARE)(\s+)([A-Z]+)(\s+)(\S+)`, ByGroups(KeywordDeclaration, TextWhitespace, NameVariable, TextWhitespace, Name), nil}, {`(DIM)(\s+)(SHARED)(\s+)([^\s(]+)`, ByGroups(KeywordDeclaration, TextWhitespace, NameVariable, TextWhitespace, NameVariableGlobal), nil}, {`(DIM)(\s+)([^\s(]+)`, ByGroups(KeywordDeclaration, TextWhitespace, NameVariableGlobal), nil}, {`^(\s*)([a-zA-Z_]+)(\s*)(\=)`, ByGroups(TextWhitespace, NameVariableGlobal, TextWhitespace, Operator), nil}, {`(GOTO|GOSUB)(\s+)(\w+\:?)`, ByGroups(KeywordReserved, TextWhitespace, NameLabel), nil}, {`(SUB)(\s+)(\w+\:?)`, ByGroups(KeywordReserved, TextWhitespace, NameLabel), nil}, Include("declarations"), Include("functions"), Include("metacommands"), Include("operators"), Include("statements"), Include("keywords"), {`[a-zA-Z_]\w*[$@#&!]`, NameVariableGlobal, nil}, {`[a-zA-Z_]\w*\:`, NameLabel, nil}, {`\-?\d*\.\d+[@|#]?`, LiteralNumberFloat, nil}, {`\-?\d+[@|#]`, LiteralNumberFloat, nil}, {`\-?\d+#?`, LiteralNumberIntegerLong, nil}, {`\-?\d+#?`, LiteralNumberInteger, nil}, {`!=|==|:=|\.=|<<|>>|[-~+/\\*%=<>&^|?:!.]`, Operator, nil}, {`[\[\]{}(),;]`, Punctuation, nil}, {`[\w]+`, NameVariableGlobal, nil}, }, "declarations": { {`\b(DATA|LET)(?=\(|\b)`, KeywordDeclaration, nil}, }, "functions": { {"" /* 512 byte string literal not displayed */, KeywordReserved, nil}, }, "metacommands": { {`\b(\$DYNAMIC|\$INCLUDE|\$STATIC)(?=\(|\b)`, KeywordConstant, nil}, }, "operators": { {`\b(AND|EQV|IMP|NOT|OR|XOR)(?=\(|\b)`, OperatorWord, nil}, }, "statements": { {"" /* 846 byte string literal not displayed */, KeywordReserved, nil}, }, "keywords": { {"" /* 201 byte string literal not displayed */, Keyword, nil}, }, }, ))
Qbasic lexer.
var R = Register(MustNewLexer( &Config{ Name: "R", Aliases: []string{"splus", "s", "r"}, Filenames: []string{"*.S", "*.R", "*.r", ".Rhistory", ".Rprofile", ".Renviron"}, MimeTypes: []string{"text/S-plus", "text/S", "text/x-r-source", "text/x-r", "text/x-R", "text/x-r-history", "text/x-r-profile"}, }, Rules{ "comments": { {`#.*$`, CommentSingle, nil}, }, "valid_name": { {`[a-zA-Z][\w.]*`, Text, nil}, {`\.[a-zA-Z_][\w.]*`, Text, nil}, }, "punctuation": { {`\[{1,2}|\]{1,2}|\(|\)|;|,`, Punctuation, nil}, }, "keywords": { {Words(``, `(?![\w. =])`, `Arg`, `Conj`, `Cstack_info`, `Encoding`, `FALSE`, `Filter`, `Find`, `I`, `ISOdate`, `ISOdatetime`, `Im`, `Inf`, `La.svd`, `Map`, `Math.Date`, `Math.POSIXt`, `Math.data.frame`, `Math.difftime`, `Math.factor`, `Mod`, `NA_character_`, `NA_complex_`, `NA_real_`, `NCOL`, `NROW`, `NULLNA_integer_`, `NaN`, `Negate`, `NextMethod`, `Ops.Date`, `Ops.POSIXt`, `Ops.data.frame`, `Ops.difftime`, `Ops.factor`, `Ops.numeric_version`, `Ops.ordered`, `Position`, `R.Version`, `R.home`, `R.version`, `R.version.string`, `RNGkind`, `RNGversion`, `R_system_version`, `Re`, `Recall`, `Reduce`, `Summary.Date`, `Summary.POSIXct`, `Summary.POSIXlt`, `Summary.data.frame`, `Summary.difftime`, `Summary.factor`, `Summary.numeric_version`, `Summary.ordered`, `Sys.Date`, `Sys.chmod`, `Sys.getenv`, `Sys.getlocale`, `Sys.getpid`, `Sys.glob`, `Sys.info`, `Sys.localeconv`, `Sys.readlink`, `Sys.setFileTime`, `Sys.setenv`, `Sys.setlocale`, `Sys.sleep`, `Sys.time`, `Sys.timezone`, `Sys.umask`, `Sys.unsetenv`, `Sys.which`, `TRUE`, `UseMethod`, `Vectorize`, `abbreviate`, `abs`, `acos`, `acosh`, `addNA`, `addTaskCallback`, `agrep`, `alist`, `all`, `all.equal`, `all.equal.POSIXct`, `all.equal.character`, `all.equal.default`, `all.equal.factor`, `all.equal.formula`, `all.equal.language`, `all.equal.list`, `all.equal.numeric`, `all.equal.raw`, `all.names`, `all.vars`, `any`, `anyDuplicated`, `anyDuplicated.array`, `anyDuplicated.data.frame`, `anyDuplicated.default`, `anyDuplicated.matrix`, `aperm`, `aperm.default`, `aperm.table`, `append`, `apply`, `args`, `arrayInd`, `as.Date`, `as.Date.POSIXct`, `as.Date.POSIXlt`, `as.Date.character`, `as.Date.date`, `as.Date.dates`, `as.Date.default`, `as.Date.factor`, `as.Date.numeric`, `as.POSIXct`, `as.POSIXct.Date`, `as.POSIXct.POSIXlt`, `as.POSIXct.date`, `as.POSIXct.dates`, `as.POSIXct.default`, `as.POSIXct.numeric`, `as.POSIXlt`, `as.POSIXlt.Date`, `as.POSIXlt.POSIXct`, `as.POSIXlt.character`, `as.POSIXlt.date`, `as.POSIXlt.dates`, `as.POSIXlt.default`, `as.POSIXlt.factor`, `as.POSIXlt.numeric`, `as.array`, `as.array.default`, `as.call`, `as.character`, `as.character.Date`, `as.character.POSIXt`, `as.character.condition`, `as.character.default`, `as.character.error`, `as.character.factor`, `as.character.hexmode`, `as.character.numeric_version`, `as.character.octmode`, `as.character.srcref`, `as.complex`, `as.data.frame`, `as.data.frame.AsIs`, `as.data.frame.Date`, `as.data.frame.POSIXct`, `as.data.frame.POSIXlt`, `as.data.frame.array`, `as.data.frame.character`, `as.data.frame.complex`, `as.data.frame.data.frame`, `as.data.frame.default`, `as.data.frame.difftime`, `as.data.frame.factor`, `as.data.frame.integer`, `as.data.frame.list`, `as.data.frame.logical`, `as.data.frame.matrix`, `as.data.frame.model.matrix`, `as.data.frame.numeric`, `as.data.frame.numeric_version`, `as.data.frame.ordered`, `as.data.frame.raw`, `as.data.frame.table`, `as.data.frame.ts`, `as.data.frame.vector`, `as.difftime`, `as.double`, `as.double.POSIXlt`, `as.double.difftime`, `as.environment`, `as.expression`, `as.expression.default`, `as.factor`, `as.function`, `as.function.default`, `as.hexmode`, `as.integer`, `as.list`, `as.list.Date`, `as.list.POSIXct`, `as.list.data.frame`, `as.list.default`, `as.list.environment`, `as.list.factor`, `as.list.function`, `as.list.numeric_version`, `as.logical`, `as.logical.factor`, `as.matrix`, `as.matrix.POSIXlt`, `as.matrix.data.frame`, `as.matrix.default`, `as.matrix.noquote`, `as.name`, `as.null`, `as.null.default`, `as.numeric`, `as.numeric_version`, `as.octmode`, `as.ordered`, `as.package_version`, `as.pairlist`, `as.qr`, `as.raw`, `as.single`, `as.single.default`, `as.symbol`, `as.table`, `as.table.default`, `as.vector`, `as.vector.factor`, `asNamespace`, `asS3`, `asS4`, `asin`, `asinh`, `assign`, `atan`, `atan2`, `atanh`, `attachNamespace`, `attr`, `attr.all.equal`, `attributes`, `autoload`, `autoloader`, `backsolve`, `baseenv`, `basename`, `besselI`, `besselJ`, `besselK`, `besselY`, `beta`, `bindingIsActive`, `bindingIsLocked`, `bindtextdomain`, `bitwAnd`, `bitwNot`, `bitwOr`, `bitwShiftL`, `bitwShiftR`, `bitwXor`, `body`, `bquote`, `browser`, `browserCondition`, `browserSetDebug`, `browserText`, `builtins`, `by`, `by.data.frame`, `by.default`, `bzfile`, `c.Date`, `c.POSIXct`, `c.POSIXlt`, `c.noquote`, `c.numeric_version`, `call`, `callCC`, `capabilities`, `casefold`, `cat`, `category`, `cbind`, `cbind.data.frame`, `ceiling`, `char.expand`, `charToRaw`, `charmatch`, `chartr`, `check_tzones`, `chol`, `chol.default`, `chol2inv`, `choose`, `class`, `clearPushBack`, `close`, `close.connection`, `close.srcfile`, `close.srcfilealias`, `closeAllConnections`, `col`, `colMeans`, `colSums`, `colnames`, `commandArgs`, `comment`, `computeRestarts`, `conditionCall`, `conditionCall.condition`, `conditionMessage`, `conditionMessage.condition`, `conflicts`, `contributors`, `cos`, `cosh`, `crossprod`, `cummax`, `cummin`, `cumprod`, `cumsum`, `cut`, `cut.Date`, `cut.POSIXt`, `cut.default`, `dQuote`, `data.class`, `data.matrix`, `date`, `debug`, `debugonce`, `default.stringsAsFactors`, `delayedAssign`, `deparse`, `det`, `determinant`, `determinant.matrix`, `dget`, `diag`, `diff`, `diff.Date`, `diff.POSIXt`, `diff.default`, `difftime`, `digamma`, `dim`, `dim.data.frame`, `dimnames`, `dimnames.data.frame`, `dir`, `dir.create`, `dirname`, `do.call`, `dput`, `drop`, `droplevels`, `droplevels.data.frame`, `droplevels.factor`, `dump`, `duplicated`, `duplicated.POSIXlt`, `duplicated.array`, `duplicated.data.frame`, `duplicated.default`, `duplicated.matrix`, `duplicated.numeric_version`, `dyn.load`, `dyn.unload`, `eapply`, `eigen`, `else`, `emptyenv`, `enc2native`, `enc2utf8`, `encodeString`, `enquote`, `env.profile`, `environment`, `environmentIsLocked`, `environmentName`, `eval`, `eval.parent`, `evalq`, `exists`, `exp`, `expand.grid`, `expm1`, `expression`, `factor`, `factorial`, `fifo`, `file`, `file.access`, `file.append`, `file.choose`, `file.copy`, `file.create`, `file.exists`, `file.info`, `file.link`, `file.path`, `file.remove`, `file.rename`, `file.show`, `file.symlink`, `find.package`, `findInterval`, `findPackageEnv`, `findRestart`, `floor`, `flush`, `flush.connection`, `force`, `formals`, `format`, `format.AsIs`, `format.Date`, `format.POSIXct`, `format.POSIXlt`, `format.data.frame`, `format.default`, `format.difftime`, `format.factor`, `format.hexmode`, `format.info`, `format.libraryIQR`, `format.numeric_version`, `format.octmode`, `format.packageInfo`, `format.pval`, `format.summaryDefault`, `formatC`, `formatDL`, `forwardsolve`, `gamma`, `gc`, `gc.time`, `gcinfo`, `gctorture`, `gctorture2`, `get`, `getAllConnections`, `getCallingDLL`, `getCallingDLLe`, `getConnection`, `getDLLRegisteredRoutines`, `getDLLRegisteredRoutines.DLLInfo`, `getDLLRegisteredRoutines.character`, `getElement`, `getExportedValue`, `getHook`, `getLoadedDLLs`, `getNamespace`, `getNamespaceExports`, `getNamespaceImports`, `getNamespaceInfo`, `getNamespaceName`, `getNamespaceUsers`, `getNamespaceVersion`, `getNativeSymbolInfo`, `getOption`, `getRversion`, `getSrcLines`, `getTaskCallbackNames`, `geterrmessage`, `gettext`, `gettextf`, `getwd`, `gl`, `globalenv`, `gregexpr`, `grep`, `grepRaw`, `grepl`, `gsub`, `gzcon`, `gzfile`, `head`, `iconv`, `iconvlist`, `icuSetCollate`, `identical`, `identity`, `ifelse`, `importIntoEnv`, `in`, `inherits`, `intToBits`, `intToUtf8`, `interaction`, `interactive`, `intersect`, `inverse.rle`, `invisible`, `invokeRestart`, `invokeRestartInteractively`, `is.R`, `is.array`, `is.atomic`, `is.call`, `is.character`, `is.complex`, `is.data.frame`, `is.double`, `is.element`, `is.environment`, `is.expression`, `is.factor`, `is.finite`, `is.function`, `is.infinite`, `is.integer`, `is.language`, `is.list`, `is.loaded`, `is.logical`, `is.matrix`, `is.na`, `is.na.POSIXlt`, `is.na.data.frame`, `is.na.numeric_version`, `is.name`, `is.nan`, `is.null`, `is.numeric`, `is.numeric.Date`, `is.numeric.POSIXt`, `is.numeric.difftime`, `is.numeric_version`, `is.object`, `is.ordered`, `is.package_version`, `is.pairlist`, `is.primitive`, `is.qr`, `is.raw`, `is.recursive`, `is.single`, `is.symbol`, `is.table`, `is.unsorted`, `is.vector`, `isBaseNamespace`, `isIncomplete`, `isNamespace`, `isOpen`, `isRestart`, `isS4`, `isSeekable`, `isSymmetric`, `isSymmetric.matrix`, `isTRUE`, `isatty`, `isdebugged`, `jitter`, `julian`, `julian.Date`, `julian.POSIXt`, `kappa`, `kappa.default`, `kappa.lm`, `kappa.qr`, `kronecker`, `l10n_info`, `labels`, `labels.default`, `lapply`, `lazyLoad`, `lazyLoadDBexec`, `lazyLoadDBfetch`, `lbeta`, `lchoose`, `length`, `length.POSIXlt`, `letters`, `levels`, `levels.default`, `lfactorial`, `lgamma`, `library.dynam`, `library.dynam.unload`, `licence`, `license`, `list.dirs`, `list.files`, `list2env`, `load`, `loadNamespace`, `loadedNamespaces`, `loadingNamespaceInfo`, `local`, `lockBinding`, `lockEnvironment`, `log`, `log10`, `log1p`, `log2`, `logb`, `lower.tri`, `ls`, `make.names`, `make.unique`, `makeActiveBinding`, `mapply`, `margin.table`, `mat.or.vec`, `match`, `match.arg`, `match.call`, `match.fun`, `max`, `max.col`, `mean`, `mean.Date`, `mean.POSIXct`, `mean.POSIXlt`, `mean.default`, `mean.difftime`, `mem.limits`, `memCompress`, `memDecompress`, `memory.profile`, `merge`, `merge.data.frame`, `merge.default`, `message`, `mget`, `min`, `missing`, `mode`, `month.abb`, `month.name`, `months`, `months.Date`, `months.POSIXt`, `months.abb`, `months.nameletters`, `names`, `names.POSIXlt`, `namespaceExport`, `namespaceImport`, `namespaceImportClasses`, `namespaceImportFrom`, `namespaceImportMethods`, `nargs`, `nchar`, `ncol`, `new.env`, `ngettext`, `nlevels`, `noquote`, `norm`, `normalizePath`, `nrow`, `numeric_version`, `nzchar`, `objects`, `oldClass`, `on.exit`, `open`, `open.connection`, `open.srcfile`, `open.srcfilealias`, `open.srcfilecopy`, `options`, `order`, `ordered`, `outer`, `packBits`, `packageEvent`, `packageHasNamespace`, `packageStartupMessage`, `package_version`, `pairlist`, `parent.env`, `parent.frame`, `parse`, `parseNamespaceFile`, `paste`, `paste0`, `path.expand`, `path.package`, `pipe`, `pmatch`, `pmax`, `pmax.int`, `pmin`, `pmin.int`, `polyroot`, `pos.to.env`, `pretty`, `pretty.default`, `prettyNum`, `print`, `print.AsIs`, `print.DLLInfo`, `print.DLLInfoList`, `print.DLLRegisteredRoutines`, `print.Date`, `print.NativeRoutineList`, `print.POSIXct`, `print.POSIXlt`, `print.by`, `print.condition`, `print.connection`, `print.data.frame`, `print.default`, `print.difftime`, `print.factor`, `print.function`, `print.hexmode`, `print.libraryIQR`, `print.listof`, `print.noquote`, `print.numeric_version`, `print.octmode`, `print.packageInfo`, `print.proc_time`, `print.restart`, `print.rle`, `print.simple.list`, `print.srcfile`, `print.srcref`, `print.summary.table`, `print.summaryDefault`, `print.table`, `print.warnings`, `prmatrix`, `proc.time`, `prod`, `prop.table`, `provideDimnames`, `psigamma`, `pushBack`, `pushBackLength`, `q`, `qr`, `qr.Q`, `qr.R`, `qr.X`, `qr.coef`, `qr.default`, `qr.fitted`, `qr.qty`, `qr.qy`, `qr.resid`, `qr.solve`, `quarters`, `quarters.Date`, `quarters.POSIXt`, `quit`, `quote`, `range`, `range.default`, `rank`, `rapply`, `raw`, `rawConnection`, `rawConnectionValue`, `rawShift`, `rawToBits`, `rawToChar`, `rbind`, `rbind.data.frame`, `rcond`, `read.dcf`, `readBin`, `readChar`, `readLines`, `readRDS`, `readRenviron`, `readline`, `reg.finalizer`, `regexec`, `regexpr`, `registerS3method`, `registerS3methods`, `regmatches`, `remove`, `removeTaskCallback`, `rep`, `rep.Date`, `rep.POSIXct`, `rep.POSIXlt`, `rep.factor`, `rep.int`, `rep.numeric_version`, `rep_len`, `replace`, `replicate`, `requireNamespace`, `restartDescription`, `restartFormals`, `retracemem`, `rev`, `rev.default`, `rle`, `rm`, `round`, `round.Date`, `round.POSIXt`, `row`, `row.names`, `row.names.data.frame`, `row.names.default`, `rowMeans`, `rowSums`, `rownames`, `rowsum`, `rowsum.data.frame`, `rowsum.default`, `sQuote`, `sample`, `sample.int`, `sapply`, `save`, `save.image`, `saveRDS`, `scale`, `scale.default`, `scan`, `search`, `searchpaths`, `seek`, `seek.connection`, `seq`, `seq.Date`, `seq.POSIXt`, `seq.default`, `seq.int`, `seq_along`, `seq_len`, `sequence`, `serialize`, `set.seed`, `setHook`, `setNamespaceInfo`, `setSessionTimeLimit`, `setTimeLimit`, `setdiff`, `setequal`, `setwd`, `shQuote`, `showConnections`, `sign`, `signalCondition`, `signif`, `simpleCondition`, `simpleError`, `simpleMessage`, `simpleWarning`, `simplify2array`, `sin`, `single`, `sinh`, `sink`, `sink.number`, `slice.index`, `socketConnection`, `socketSelect`, `solve`, `solve.default`, `solve.qr`, `sort`, `sort.POSIXlt`, `sort.default`, `sort.int`, `sort.list`, `split`, `split.Date`, `split.POSIXct`, `split.data.frame`, `split.default`, `sprintf`, `sqrt`, `srcfile`, `srcfilealias`, `srcfilecopy`, `srcref`, `standardGeneric`, `stderr`, `stdin`, `stdout`, `stop`, `stopifnot`, `storage.mode`, `strftime`, `strptime`, `strsplit`, `strtoi`, `strtrim`, `structure`, `strwrap`, `sub`, `subset`, `subset.data.frame`, `subset.default`, `subset.matrix`, `substitute`, `substr`, `substring`, `sum`, `summary`, `summary.Date`, `summary.POSIXct`, `summary.POSIXlt`, `summary.connection`, `summary.data.frame`, `summary.default`, `summary.factor`, `summary.matrix`, `summary.proc_time`, `summary.srcfile`, `summary.srcref`, `summary.table`, `suppressMessages`, `suppressPackageStartupMessages`, `suppressWarnings`, `svd`, `sweep`, `sys.call`, `sys.calls`, `sys.frame`, `sys.frames`, `sys.function`, `sys.load.image`, `sys.nframe`, `sys.on.exit`, `sys.parent`, `sys.parents`, `sys.save.image`, `sys.source`, `sys.status`, `system`, `system.file`, `system.time`, `system2`, `t`, `t.data.frame`, `t.default`, `table`, `tabulate`, `tail`, `tan`, `tanh`, `tapply`, `taskCallbackManager`, `tcrossprod`, `tempdir`, `tempfile`, `testPlatformEquivalence`, `textConnection`, `textConnectionValue`, `toString`, `toString.default`, `tolower`, `topenv`, `toupper`, `trace`, `traceback`, `tracemem`, `tracingState`, `transform`, `transform.data.frame`, `transform.default`, `trigamma`, `trunc`, `trunc.Date`, `trunc.POSIXt`, `truncate`, `truncate.connection`, `try`, `tryCatch`, `typeof`, `unclass`, `undebug`, `union`, `unique`, `unique.POSIXlt`, `unique.array`, `unique.data.frame`, `unique.default`, `unique.matrix`, `unique.numeric_version`, `units`, `units.difftime`, `unix.time`, `unlink`, `unlist`, `unloadNamespace`, `unlockBinding`, `unname`, `unserialize`, `unsplit`, `untrace`, `untracemem`, `unz`, `upper.tri`, `url`, `utf8ToInt`, `vapply`, `version`, `warning`, `warnings`, `weekdays`, `weekdays.Date`, `weekdays.POSIXt`, `which`, `which.max`, `which.min`, `with`, `with.default`, `withCallingHandlers`, `withRestarts`, `withVisible`, `within`, `within.data.frame`, `within.list`, `write`, `write.dcf`, `writeBin`, `writeChar`, `writeLines`, `xor`, `xor.hexmode`, `xor.octmode`, `xpdrows.data.frame`, `xtfrm`, `xtfrm.AsIs`, `xtfrm.Date`, `xtfrm.POSIXct`, `xtfrm.POSIXlt`, `xtfrm.Surv`, `xtfrm.default`, `xtfrm.difftime`, `xtfrm.factor`, `xtfrm.numeric_version`, `xzfile`, `zapsmall`), KeywordPseudo, nil}, {`(if|else|for|while|repeat|in|next|break|return|switch|function)(?![\w.])`, KeywordReserved, nil}, {`(array|category|character|complex|double|function|integer|list|logical|matrix|numeric|vector|data.frame|c)(?![\w.])`, KeywordType, nil}, {`(library|require|attach|detach|source)(?![\w.])`, KeywordNamespace, nil}, }, "operators": { {`<<?-|->>?|-|==|<=|>=|<|>|&&?|!=|\|\|?|\?`, Operator, nil}, {`\*|\+|\^|/|!|%[^%]*%|=|~|\$|@|:{1,3}`, Operator, nil}, }, "builtin_symbols": { {`(NULL|NA(_(integer|real|complex|character)_)?|letters|LETTERS|Inf|TRUE|FALSE|NaN|pi|\.\.(\.|[0-9]+))(?![\w.])`, KeywordConstant, nil}, {`(T|F)\b`, NameBuiltinPseudo, nil}, }, "numbers": { {`0[xX][a-fA-F0-9]+([pP][0-9]+)?[Li]?`, LiteralNumberHex, nil}, {`[+-]?([0-9]+(\.[0-9]+)?|\.[0-9]+|\.)([eE][+-]?[0-9]+)?[Li]?`, LiteralNumber, nil}, }, "statements": { Include("comments"), {`\s+`, Text, nil}, {"`.*?`", LiteralStringBacktick, nil}, {`\'`, LiteralString, Push("string_squote")}, {`\"`, LiteralString, Push("string_dquote")}, Include("builtin_symbols"), Include("numbers"), Include("keywords"), Include("punctuation"), Include("operators"), Include("valid_name"), }, "root": { Include("statements"), {`\{|\}`, Punctuation, nil}, {`.`, Text, nil}, }, "string_squote": { {`([^\'\\]|\\.)*\'`, LiteralString, Pop(1)}, }, "string_dquote": { {`([^"\\]|\\.)*"`, LiteralString, Pop(1)}, }, }, ))
R/S lexer.
var Racket = Register(MustNewLexer( &Config{ Name: "Racket", Aliases: []string{"racket", "rkt"}, Filenames: []string{"*.rkt", "*.rktd", "*.rktl"}, MimeTypes: []string{"text/x-racket", "application/x-racket"}, }, Rules{ "root": { {`[)\]}]`, Error, nil}, {`(?!\Z)`, Text, Push("unquoted-datum")}, }, "datum": { {`(?s)#;|#*`, Comment, nil}, {`;[^\n\r ]*`, CommentSingle, nil}, {`#\|`, CommentMultiline, Push("block-comment")}, {`\s+`, Text, nil}, {"(?i)(?:#e)?(?:#d)?(?:#e)?[-+]?\\d+(?=[()[\\]{}\",\\'`;\\s])", LiteralNumberInteger, Pop(1)}, {"(?i)(?:#e)?(?:#d)?(?:#e)?[-+]?(\\d+(\\.\\d*)?|\\.\\d+)([deflst][-+]?\\d+)?(?=[()[\\]{}\",\\'`;\\s])", LiteralNumberFloat, Pop(1)}, {"" /* 252 byte string literal not displayed */, LiteralNumber, Pop(1)}, {"" /* 858 byte string literal not displayed */, LiteralNumberFloat, Pop(1)}, {"" /* 171 byte string literal not displayed */, LiteralNumberFloat, Pop(1)}, {"(?i)(#[ei])?#b(?:\\|[^|]*\\||\\\\[\\w\\W]|[^|\\\\()[\\]{}\",\\'`;\\s]+)+", LiteralNumberBin, Pop(1)}, {"(?i)(#[ei])?#o(?:\\|[^|]*\\||\\\\[\\w\\W]|[^|\\\\()[\\]{}\",\\'`;\\s]+)+", LiteralNumberOct, Pop(1)}, {"(?i)(#[ei])?#x(?:\\|[^|]*\\||\\\\[\\w\\W]|[^|\\\\()[\\]{}\",\\'`;\\s]+)+", LiteralNumberHex, Pop(1)}, {"(?i)(#d)?#i(?:\\|[^|]*\\||\\\\[\\w\\W]|[^|\\\\()[\\]{}\",\\'`;\\s]+)+", LiteralNumberFloat, Pop(1)}, {`#?"`, LiteralStringDouble, Push("#pop", "string")}, {`#<<(.+)\n(^(?!\1$).*$\n)*^\1$`, LiteralStringHeredoc, Pop(1)}, {`#\\(u[\da-fA-F]{1,4}|U[\da-fA-F]{1,8})`, LiteralStringChar, Pop(1)}, {`(?is)#\\([0-7]{3}|[a-z]+|.)`, LiteralStringChar, Pop(1)}, {`(?s)#[pr]x#?"(\\?.)*?"`, LiteralStringRegex, Pop(1)}, {`#(true|false|[tTfF])`, NameConstant, Pop(1)}, {"#:(?:\\|[^|]*\\||\\\\[\\w\\W]|[^|\\\\()[\\]{}\",\\'`;\\s]+)+", KeywordDeclaration, Pop(1)}, {`(#lang |#!)(\S+)`, ByGroups(KeywordNamespace, NameNamespace), nil}, {`#reader`, KeywordNamespace, Push("quoted-datum")}, {"(?i)\\.(?=[()[\\]{}\",\\'`;\\s])|#c[is]|#['`]|#,@?", Operator, nil}, {`'|#[s&]|#hash(eqv?)?|#\d*(?=[([{])`, Operator, Push("#pop", "quoted-datum")}, }, "datum*": { {"`|,@?", Operator, nil}, {"(?:\\|[^|]*\\||\\\\[\\w\\W]|[^|\\\\()[\\]{}\",\\'`;\\s]+)+", LiteralStringSymbol, Pop(1)}, {`[|\\]`, Error, nil}, Default(Pop(1)), }, "list": { {`[)\]}]`, Punctuation, Pop(1)}, }, "unquoted-datum": { Include("datum"), {"quote(?=[()[\\]{}\",\\'`;\\s])", Keyword, Push("#pop", "quoted-datum")}, {"`", Operator, Push("#pop", "quasiquoted-datum")}, {"quasiquote(?=[()[\\]{}\",\\'`;\\s])", Keyword, Push("#pop", "quasiquoted-datum")}, {`[([{]`, Punctuation, Push("#pop", "unquoted-list")}, {Words(``, "(?=[()[\\]{}\",\\'`;\\s])", `#%app`, `#%datum`, `#%declare`, `#%expression`, `#%module-begin`, `#%plain-app`, `#%plain-lambda`, `#%plain-module-begin`, `#%printing-module-begin`, `#%provide`, `#%require`, `#%stratified-body`, `#%top`, `#%top-interaction`, `#%variable-reference`, `->`, `->*`, `->*m`, `->d`, `->dm`, `->i`, `->m`, `...`, `:do-in`, `==`, `=>`, `_`, `absent`, `abstract`, `all-defined-out`, `all-from-out`, `and`, `any`, `augment`, `augment*`, `augment-final`, `augment-final*`, `augride`, `augride*`, `begin`, `begin-for-syntax`, `begin0`, `case`, `case->`, `case->m`, `case-lambda`, `class`, `class*`, `class-field-accessor`, `class-field-mutator`, `class/c`, `class/derived`, `combine-in`, `combine-out`, `command-line`, `compound-unit`, `compound-unit/infer`, `cond`, `cons/dc`, `contract`, `contract-out`, `contract-struct`, `contracted`, `define`, `define-compound-unit`, `define-compound-unit/infer`, `define-contract-struct`, `define-custom-hash-types`, `define-custom-set-types`, `define-for-syntax`, `define-local-member-name`, `define-logger`, `define-match-expander`, `define-member-name`, `define-module-boundary-contract`, `define-namespace-anchor`, `define-opt/c`, `define-sequence-syntax`, `define-serializable-class`, `define-serializable-class*`, `define-signature`, `define-signature-form`, `define-struct`, `define-struct/contract`, `define-struct/derived`, `define-syntax`, `define-syntax-rule`, `define-syntaxes`, `define-unit`, `define-unit-binding`, `define-unit-from-context`, `define-unit/contract`, `define-unit/new-import-export`, `define-unit/s`, `define-values`, `define-values-for-export`, `define-values-for-syntax`, `define-values/invoke-unit`, `define-values/invoke-unit/infer`, `define/augment`, `define/augment-final`, `define/augride`, `define/contract`, `define/final-prop`, `define/match`, `define/overment`, `define/override`, `define/override-final`, `define/private`, `define/public`, `define/public-final`, `define/pubment`, `define/subexpression-pos-prop`, `define/subexpression-pos-prop/name`, `delay`, `delay/idle`, `delay/name`, `delay/strict`, `delay/sync`, `delay/thread`, `do`, `else`, `except`, `except-in`, `except-out`, `export`, `extends`, `failure-cont`, `false`, `false/c`, `field`, `field-bound?`, `file`, `flat-murec-contract`, `flat-rec-contract`, `for`, `for*`, `for*/and`, `for*/async`, `for*/first`, `for*/fold`, `for*/fold/derived`, `for*/hash`, `for*/hasheq`, `for*/hasheqv`, `for*/last`, `for*/list`, `for*/lists`, `for*/mutable-set`, `for*/mutable-seteq`, `for*/mutable-seteqv`, `for*/or`, `for*/product`, `for*/set`, `for*/seteq`, `for*/seteqv`, `for*/stream`, `for*/sum`, `for*/vector`, `for*/weak-set`, `for*/weak-seteq`, `for*/weak-seteqv`, `for-label`, `for-meta`, `for-syntax`, `for-template`, `for/and`, `for/async`, `for/first`, `for/fold`, `for/fold/derived`, `for/hash`, `for/hasheq`, `for/hasheqv`, `for/last`, `for/list`, `for/lists`, `for/mutable-set`, `for/mutable-seteq`, `for/mutable-seteqv`, `for/or`, `for/product`, `for/set`, `for/seteq`, `for/seteqv`, `for/stream`, `for/sum`, `for/vector`, `for/weak-set`, `for/weak-seteq`, `for/weak-seteqv`, `gen:custom-write`, `gen:dict`, `gen:equal+hash`, `gen:set`, `gen:stream`, `generic`, `get-field`, `hash/dc`, `if`, `implies`, `import`, `include`, `include-at/relative-to`, `include-at/relative-to/reader`, `include/reader`, `inherit`, `inherit-field`, `inherit/inner`, `inherit/super`, `init`, `init-depend`, `init-field`, `init-rest`, `inner`, `inspect`, `instantiate`, `interface`, `interface*`, `invariant-assertion`, `invoke-unit`, `invoke-unit/infer`, `lambda`, `lazy`, `let`, `let*`, `let*-values`, `let-syntax`, `let-syntaxes`, `let-values`, `let/cc`, `let/ec`, `letrec`, `letrec-syntax`, `letrec-syntaxes`, `letrec-syntaxes+values`, `letrec-values`, `lib`, `link`, `local`, `local-require`, `log-debug`, `log-error`, `log-fatal`, `log-info`, `log-warning`, `match`, `match*`, `match*/derived`, `match-define`, `match-define-values`, `match-lambda`, `match-lambda*`, `match-lambda**`, `match-let`, `match-let*`, `match-let*-values`, `match-let-values`, `match-letrec`, `match-letrec-values`, `match/derived`, `match/values`, `member-name-key`, `mixin`, `module`, `module*`, `module+`, `nand`, `new`, `nor`, `object-contract`, `object/c`, `only`, `only-in`, `only-meta-in`, `open`, `opt/c`, `or`, `overment`, `overment*`, `override`, `override*`, `override-final`, `override-final*`, `parameterize`, `parameterize*`, `parameterize-break`, `parametric->/c`, `place`, `place*`, `place/context`, `planet`, `prefix`, `prefix-in`, `prefix-out`, `private`, `private*`, `prompt-tag/c`, `protect-out`, `provide`, `provide-signature-elements`, `provide/contract`, `public`, `public*`, `public-final`, `public-final*`, `pubment`, `pubment*`, `quasiquote`, `quasisyntax`, `quasisyntax/loc`, `quote`, `quote-syntax`, `quote-syntax/prune`, `recontract-out`, `recursive-contract`, `relative-in`, `rename`, `rename-in`, `rename-inner`, `rename-out`, `rename-super`, `require`, `send`, `send*`, `send+`, `send-generic`, `send/apply`, `send/keyword-apply`, `set!`, `set!-values`, `set-field!`, `shared`, `stream`, `stream*`, `stream-cons`, `struct`, `struct*`, `struct-copy`, `struct-field-index`, `struct-out`, `struct/c`, `struct/ctc`, `struct/dc`, `submod`, `super`, `super-instantiate`, `super-make-object`, `super-new`, `syntax`, `syntax-case`, `syntax-case*`, `syntax-id-rules`, `syntax-rules`, `syntax/loc`, `tag`, `this`, `this%`, `thunk`, `thunk*`, `time`, `unconstrained-domain->`, `unit`, `unit-from-context`, `unit/c`, `unit/new-import-export`, `unit/s`, `unless`, `unquote`, `unquote-splicing`, `unsyntax`, `unsyntax-splicing`, `values/drop`, `when`, `with-continuation-mark`, `with-contract`, `with-contract-continuation-mark`, `with-handlers`, `with-handlers*`, `with-method`, `with-syntax`, `λ`), Keyword, Pop(1)}, {Words(``, "(?=[()[\\]{}\",\\'`;\\s])", `*`, `*list/c`, `+`, `-`, `/`, `<`, `</c`, `<=`, `<=/c`, `=`, `=/c`, `>`, `>/c`, `>=`, `>=/c`, `abort-current-continuation`, `abs`, `absolute-path?`, `acos`, `add-between`, `add1`, `alarm-evt`, `always-evt`, `and/c`, `andmap`, `angle`, `any/c`, `append`, `append*`, `append-map`, `apply`, `argmax`, `argmin`, `arithmetic-shift`, `arity-at-least`, `arity-at-least-value`, `arity-at-least?`, `arity-checking-wrapper`, `arity-includes?`, `arity=?`, `arrow-contract-info`, `arrow-contract-info-accepts-arglist`, `arrow-contract-info-chaperone-procedure`, `arrow-contract-info-check-first-order`, `arrow-contract-info?`, `asin`, `assf`, `assoc`, `assq`, `assv`, `atan`, `bad-number-of-results`, `banner`, `base->-doms/c`, `base->-rngs/c`, `base->?`, `between/c`, `bitwise-and`, `bitwise-bit-field`, `bitwise-bit-set?`, `bitwise-ior`, `bitwise-not`, `bitwise-xor`, `blame-add-car-context`, `blame-add-cdr-context`, `blame-add-context`, `blame-add-missing-party`, `blame-add-nth-arg-context`, `blame-add-range-context`, `blame-add-unknown-context`, `blame-context`, `blame-contract`, `blame-fmt->-string`, `blame-missing-party?`, `blame-negative`, `blame-original?`, `blame-positive`, `blame-replace-negative`, `blame-source`, `blame-swap`, `blame-swapped?`, `blame-update`, `blame-value`, `blame?`, `boolean=?`, `boolean?`, `bound-identifier=?`, `box`, `box-cas!`, `box-immutable`, `box-immutable/c`, `box/c`, `box?`, `break-enabled`, `break-parameterization?`, `break-thread`, `build-chaperone-contract-property`, `build-compound-type-name`, `build-contract-property`, `build-flat-contract-property`, `build-list`, `build-path`, `build-path/convention-type`, `build-string`, `build-vector`, `byte-pregexp`, `byte-pregexp?`, `byte-ready?`, `byte-regexp`, `byte-regexp?`, `byte?`, `bytes`, `bytes->immutable-bytes`, `bytes->list`, `bytes->path`, `bytes->path-element`, `bytes->string/latin-1`, `bytes->string/locale`, `bytes->string/utf-8`, `bytes-append`, `bytes-append*`, `bytes-close-converter`, `bytes-convert`, `bytes-convert-end`, `bytes-converter?`, `bytes-copy`, `bytes-copy!`, `bytes-environment-variable-name?`, `bytes-fill!`, `bytes-join`, `bytes-length`, `bytes-no-nuls?`, `bytes-open-converter`, `bytes-ref`, `bytes-set!`, `bytes-utf-8-index`, `bytes-utf-8-length`, `bytes-utf-8-ref`, `bytes<?`, `bytes=?`, `bytes>?`, `bytes?`, `caaaar`, `caaadr`, `caaar`, `caadar`, `caaddr`, `caadr`, `caar`, `cadaar`, `cadadr`, `cadar`, `caddar`, `cadddr`, `caddr`, `cadr`, `call-in-nested-thread`, `call-with-atomic-output-file`, `call-with-break-parameterization`, `call-with-composable-continuation`, `call-with-continuation-barrier`, `call-with-continuation-prompt`, `call-with-current-continuation`, `call-with-default-reading-parameterization`, `call-with-escape-continuation`, `call-with-exception-handler`, `call-with-file-lock/timeout`, `call-with-immediate-continuation-mark`, `call-with-input-bytes`, `call-with-input-file`, `call-with-input-file*`, `call-with-input-string`, `call-with-output-bytes`, `call-with-output-file`, `call-with-output-file*`, `call-with-output-string`, `call-with-parameterization`, `call-with-semaphore`, `call-with-semaphore/enable-break`, `call-with-values`, `call/cc`, `call/ec`, `car`, `cartesian-product`, `cdaaar`, `cdaadr`, `cdaar`, `cdadar`, `cdaddr`, `cdadr`, `cdar`, `cddaar`, `cddadr`, `cddar`, `cdddar`, `cddddr`, `cdddr`, `cddr`, `cdr`, `ceiling`, `channel-get`, `channel-put`, `channel-put-evt`, `channel-put-evt?`, `channel-try-get`, `channel/c`, `channel?`, `chaperone-box`, `chaperone-channel`, `chaperone-continuation-mark-key`, `chaperone-contract-property?`, `chaperone-contract?`, `chaperone-evt`, `chaperone-hash`, `chaperone-hash-set`, `chaperone-of?`, `chaperone-procedure`, `chaperone-procedure*`, `chaperone-prompt-tag`, `chaperone-struct`, `chaperone-struct-type`, `chaperone-vector`, `chaperone?`, `char->integer`, `char-alphabetic?`, `char-blank?`, `char-ci<=?`, `char-ci<?`, `char-ci=?`, `char-ci>=?`, `char-ci>?`, `char-downcase`, `char-foldcase`, `char-general-category`, `char-graphic?`, `char-in`, `char-in/c`, `char-iso-control?`, `char-lower-case?`, `char-numeric?`, `char-punctuation?`, `char-ready?`, `char-symbolic?`, `char-title-case?`, `char-titlecase`, `char-upcase`, `char-upper-case?`, `char-utf-8-length`, `char-whitespace?`, `char<=?`, `char<?`, `char=?`, `char>=?`, `char>?`, `char?`, `check-duplicate-identifier`, `check-duplicates`, `checked-procedure-check-and-extract`, `choice-evt`, `class->interface`, `class-info`, `class-seal`, `class-unseal`, `class?`, `cleanse-path`, `close-input-port`, `close-output-port`, `coerce-chaperone-contract`, `coerce-chaperone-contracts`, `coerce-contract`, `coerce-contract/f`, `coerce-contracts`, `coerce-flat-contract`, `coerce-flat-contracts`, `collect-garbage`, `collection-file-path`, `collection-path`, `combinations`, `compile`, `compile-allow-set!-undefined`, `compile-context-preservation-enabled`, `compile-enforce-module-constants`, `compile-syntax`, `compiled-expression-recompile`, `compiled-expression?`, `compiled-module-expression?`, `complete-path?`, `complex?`, `compose`, `compose1`, `conjoin`, `conjugate`, `cons`, `cons/c`, `cons?`, `const`, `continuation-mark-key/c`, `continuation-mark-key?`, `continuation-mark-set->context`, `continuation-mark-set->list`, `continuation-mark-set->list*`, `continuation-mark-set-first`, `continuation-mark-set?`, `continuation-marks`, `continuation-prompt-available?`, `continuation-prompt-tag?`, `continuation?`, `contract-continuation-mark-key`, `contract-custom-write-property-proc`, `contract-exercise`, `contract-first-order`, `contract-first-order-passes?`, `contract-late-neg-projection`, `contract-name`, `contract-proc`, `contract-projection`, `contract-property?`, `contract-random-generate`, `contract-random-generate-fail`, `contract-random-generate-fail?`, `contract-random-generate-get-current-environment`, `contract-random-generate-stash`, `contract-random-generate/choose`, `contract-stronger?`, `contract-struct-exercise`, `contract-struct-generate`, `contract-struct-late-neg-projection`, `contract-struct-list-contract?`, `contract-val-first-projection`, `contract?`, `convert-stream`, `copy-directory/files`, `copy-file`, `copy-port`, `cos`, `cosh`, `count`, `current-blame-format`, `current-break-parameterization`, `current-code-inspector`, `current-command-line-arguments`, `current-compile`, `current-compiled-file-roots`, `current-continuation-marks`, `current-contract-region`, `current-custodian`, `current-directory`, `current-directory-for-user`, `current-drive`, `current-environment-variables`, `current-error-port`, `current-eval`, `current-evt-pseudo-random-generator`, `current-force-delete-permissions`, `current-future`, `current-gc-milliseconds`, `current-get-interaction-input-port`, `current-inexact-milliseconds`, `current-input-port`, `current-inspector`, `current-library-collection-links`, `current-library-collection-paths`, `current-load`, `current-load-extension`, `current-load-relative-directory`, `current-load/use-compiled`, `current-locale`, `current-logger`, `current-memory-use`, `current-milliseconds`, `current-module-declare-name`, `current-module-declare-source`, `current-module-name-resolver`, `current-module-path-for-load`, `current-namespace`, `current-output-port`, `current-parameterization`, `current-plumber`, `current-preserved-thread-cell-values`, `current-print`, `current-process-milliseconds`, `current-prompt-read`, `current-pseudo-random-generator`, `current-read-interaction`, `current-reader-guard`, `current-readtable`, `current-seconds`, `current-security-guard`, `current-subprocess-custodian-mode`, `current-thread`, `current-thread-group`, `current-thread-initial-stack-size`, `current-write-relative-directory`, `curry`, `curryr`, `custodian-box-value`, `custodian-box?`, `custodian-limit-memory`, `custodian-managed-list`, `custodian-memory-accounting-available?`, `custodian-require-memory`, `custodian-shutdown-all`, `custodian?`, `custom-print-quotable-accessor`, `custom-print-quotable?`, `custom-write-accessor`, `custom-write-property-proc`, `custom-write?`, `date`, `date*`, `date*-nanosecond`, `date*-time-zone-name`, `date*?`, `date-day`, `date-dst?`, `date-hour`, `date-minute`, `date-month`, `date-second`, `date-time-zone-offset`, `date-week-day`, `date-year`, `date-year-day`, `date?`, `datum->syntax`, `datum-intern-literal`, `default-continuation-prompt-tag`, `degrees->radians`, `delete-directory`, `delete-directory/files`, `delete-file`, `denominator`, `dict->list`, `dict-can-functional-set?`, `dict-can-remove-keys?`, `dict-clear`, `dict-clear!`, `dict-copy`, `dict-count`, `dict-empty?`, `dict-for-each`, `dict-has-key?`, `dict-implements/c`, `dict-implements?`, `dict-iter-contract`, `dict-iterate-first`, `dict-iterate-key`, `dict-iterate-next`, `dict-iterate-value`, `dict-key-contract`, `dict-keys`, `dict-map`, `dict-mutable?`, `dict-ref`, `dict-ref!`, `dict-remove`, `dict-remove!`, `dict-set`, `dict-set!`, `dict-set*`, `dict-set*!`, `dict-update`, `dict-update!`, `dict-value-contract`, `dict-values`, `dict?`, `directory-exists?`, `directory-list`, `disjoin`, `display`, `display-lines`, `display-lines-to-file`, `display-to-file`, `displayln`, `double-flonum?`, `drop`, `drop-common-prefix`, `drop-right`, `dropf`, `dropf-right`, `dump-memory-stats`, `dup-input-port`, `dup-output-port`, `dynamic->*`, `dynamic-get-field`, `dynamic-object/c`, `dynamic-place`, `dynamic-place*`, `dynamic-require`, `dynamic-require-for-syntax`, `dynamic-send`, `dynamic-set-field!`, `dynamic-wind`, `eighth`, `empty`, `empty-sequence`, `empty-stream`, `empty?`, `environment-variables-copy`, `environment-variables-names`, `environment-variables-ref`, `environment-variables-set!`, `environment-variables?`, `eof`, `eof-evt`, `eof-object?`, `ephemeron-value`, `ephemeron?`, `eprintf`, `eq-contract-val`, `eq-contract?`, `eq-hash-code`, `eq?`, `equal-contract-val`, `equal-contract?`, `equal-hash-code`, `equal-secondary-hash-code`, `equal<%>`, `equal?`, `equal?/recur`, `eqv-hash-code`, `eqv?`, `error`, `error-display-handler`, `error-escape-handler`, `error-print-context-length`, `error-print-source-location`, `error-print-width`, `error-value->string-handler`, `eval`, `eval-jit-enabled`, `eval-syntax`, `even?`, `evt/c`, `evt?`, `exact->inexact`, `exact-ceiling`, `exact-floor`, `exact-integer?`, `exact-nonnegative-integer?`, `exact-positive-integer?`, `exact-round`, `exact-truncate`, `exact?`, `executable-yield-handler`, `exit`, `exit-handler`, `exn`, `exn-continuation-marks`, `exn-message`, `exn:break`, `exn:break-continuation`, `exn:break:hang-up`, `exn:break:hang-up?`, `exn:break:terminate`, `exn:break:terminate?`, `exn:break?`, `exn:fail`, `exn:fail:contract`, `exn:fail:contract:arity`, `exn:fail:contract:arity?`, `exn:fail:contract:blame`, `exn:fail:contract:blame-object`, `exn:fail:contract:blame?`, `exn:fail:contract:continuation`, `exn:fail:contract:continuation?`, `exn:fail:contract:divide-by-zero`, `exn:fail:contract:divide-by-zero?`, `exn:fail:contract:non-fixnum-result`, `exn:fail:contract:non-fixnum-result?`, `exn:fail:contract:variable`, `exn:fail:contract:variable-id`, `exn:fail:contract:variable?`, `exn:fail:contract?`, `exn:fail:filesystem`, `exn:fail:filesystem:errno`, `exn:fail:filesystem:errno-errno`, `exn:fail:filesystem:errno?`, `exn:fail:filesystem:exists`, `exn:fail:filesystem:exists?`, `exn:fail:filesystem:missing-module`, `exn:fail:filesystem:missing-module-path`, `exn:fail:filesystem:missing-module?`, `exn:fail:filesystem:version`, `exn:fail:filesystem:version?`, `exn:fail:filesystem?`, `exn:fail:network`, `exn:fail:network:errno`, `exn:fail:network:errno-errno`, `exn:fail:network:errno?`, `exn:fail:network?`, `exn:fail:object`, `exn:fail:object?`, `exn:fail:out-of-memory`, `exn:fail:out-of-memory?`, `exn:fail:read`, `exn:fail:read-srclocs`, `exn:fail:read:eof`, `exn:fail:read:eof?`, `exn:fail:read:non-char`, `exn:fail:read:non-char?`, `exn:fail:read?`, `exn:fail:syntax`, `exn:fail:syntax-exprs`, `exn:fail:syntax:missing-module`, `exn:fail:syntax:missing-module-path`, `exn:fail:syntax:missing-module?`, `exn:fail:syntax:unbound`, `exn:fail:syntax:unbound?`, `exn:fail:syntax?`, `exn:fail:unsupported`, `exn:fail:unsupported?`, `exn:fail:user`, `exn:fail:user?`, `exn:fail?`, `exn:misc:match?`, `exn:missing-module-accessor`, `exn:missing-module?`, `exn:srclocs-accessor`, `exn:srclocs?`, `exn?`, `exp`, `expand`, `expand-once`, `expand-syntax`, `expand-syntax-once`, `expand-syntax-to-top-form`, `expand-to-top-form`, `expand-user-path`, `explode-path`, `expt`, `externalizable<%>`, `failure-result/c`, `false?`, `field-names`, `fifth`, `file->bytes`, `file->bytes-lines`, `file->lines`, `file->list`, `file->string`, `file->value`, `file-exists?`, `file-name-from-path`, `file-or-directory-identity`, `file-or-directory-modify-seconds`, `file-or-directory-permissions`, `file-position`, `file-position*`, `file-size`, `file-stream-buffer-mode`, `file-stream-port?`, `file-truncate`, `filename-extension`, `filesystem-change-evt`, `filesystem-change-evt-cancel`, `filesystem-change-evt?`, `filesystem-root-list`, `filter`, `filter-map`, `filter-not`, `filter-read-input-port`, `find-executable-path`, `find-files`, `find-library-collection-links`, `find-library-collection-paths`, `find-relative-path`, `find-system-path`, `findf`, `first`, `first-or/c`, `fixnum?`, `flat-contract`, `flat-contract-predicate`, `flat-contract-property?`, `flat-contract?`, `flat-named-contract`, `flatten`, `floating-point-bytes->real`, `flonum?`, `floor`, `flush-output`, `fold-files`, `foldl`, `foldr`, `for-each`, `force`, `format`, `fourth`, `fprintf`, `free-identifier=?`, `free-label-identifier=?`, `free-template-identifier=?`, `free-transformer-identifier=?`, `fsemaphore-count`, `fsemaphore-post`, `fsemaphore-try-wait?`, `fsemaphore-wait`, `fsemaphore?`, `future`, `future?`, `futures-enabled?`, `gcd`, `generate-member-key`, `generate-temporaries`, `generic-set?`, `generic?`, `gensym`, `get-output-bytes`, `get-output-string`, `get-preference`, `get/build-late-neg-projection`, `get/build-val-first-projection`, `getenv`, `global-port-print-handler`, `group-by`, `group-execute-bit`, `group-read-bit`, `group-write-bit`, `guard-evt`, `handle-evt`, `handle-evt?`, `has-blame?`, `has-contract?`, `hash`, `hash->list`, `hash-clear`, `hash-clear!`, `hash-copy`, `hash-copy-clear`, `hash-count`, `hash-empty?`, `hash-eq?`, `hash-equal?`, `hash-eqv?`, `hash-for-each`, `hash-has-key?`, `hash-iterate-first`, `hash-iterate-key`, `hash-iterate-key+value`, `hash-iterate-next`, `hash-iterate-pair`, `hash-iterate-value`, `hash-keys`, `hash-map`, `hash-placeholder?`, `hash-ref`, `hash-ref!`, `hash-remove`, `hash-remove!`, `hash-set`, `hash-set!`, `hash-set*`, `hash-set*!`, `hash-update`, `hash-update!`, `hash-values`, `hash-weak?`, `hash/c`, `hash?`, `hasheq`, `hasheqv`, `identifier-binding`, `identifier-binding-symbol`, `identifier-label-binding`, `identifier-prune-lexical-context`, `identifier-prune-to-source-module`, `identifier-remove-from-definition-context`, `identifier-template-binding`, `identifier-transformer-binding`, `identifier?`, `identity`, `if/c`, `imag-part`, `immutable?`, `impersonate-box`, `impersonate-channel`, `impersonate-continuation-mark-key`, `impersonate-hash`, `impersonate-hash-set`, `impersonate-procedure`, `impersonate-procedure*`, `impersonate-prompt-tag`, `impersonate-struct`, `impersonate-vector`, `impersonator-contract?`, `impersonator-ephemeron`, `impersonator-of?`, `impersonator-prop:application-mark`, `impersonator-prop:blame`, `impersonator-prop:contracted`, `impersonator-property-accessor-procedure?`, `impersonator-property?`, `impersonator?`, `implementation?`, `implementation?/c`, `in-bytes`, `in-bytes-lines`, `in-combinations`, `in-cycle`, `in-dict`, `in-dict-keys`, `in-dict-pairs`, `in-dict-values`, `in-directory`, `in-hash`, `in-hash-keys`, `in-hash-pairs`, `in-hash-values`, `in-immutable-hash`, `in-immutable-hash-keys`, `in-immutable-hash-pairs`, `in-immutable-hash-values`, `in-immutable-set`, `in-indexed`, `in-input-port-bytes`, `in-input-port-chars`, `in-lines`, `in-list`, `in-mlist`, `in-mutable-hash`, `in-mutable-hash-keys`, `in-mutable-hash-pairs`, `in-mutable-hash-values`, `in-mutable-set`, `in-naturals`, `in-parallel`, `in-permutations`, `in-port`, `in-producer`, `in-range`, `in-sequences`, `in-set`, `in-slice`, `in-stream`, `in-string`, `in-syntax`, `in-value`, `in-values*-sequence`, `in-values-sequence`, `in-vector`, `in-weak-hash`, `in-weak-hash-keys`, `in-weak-hash-pairs`, `in-weak-hash-values`, `in-weak-set`, `inexact->exact`, `inexact-real?`, `inexact?`, `infinite?`, `input-port-append`, `input-port?`, `inspector?`, `instanceof/c`, `integer->char`, `integer->integer-bytes`, `integer-bytes->integer`, `integer-in`, `integer-length`, `integer-sqrt`, `integer-sqrt/remainder`, `integer?`, `interface->method-names`, `interface-extension?`, `interface?`, `internal-definition-context-binding-identifiers`, `internal-definition-context-introduce`, `internal-definition-context-seal`, `internal-definition-context?`, `is-a?`, `is-a?/c`, `keyword->string`, `keyword-apply`, `keyword<?`, `keyword?`, `keywords-match`, `kill-thread`, `last`, `last-pair`, `lcm`, `length`, `liberal-define-context?`, `link-exists?`, `list`, `list*`, `list*of`, `list->bytes`, `list->mutable-set`, `list->mutable-seteq`, `list->mutable-seteqv`, `list->set`, `list->seteq`, `list->seteqv`, `list->string`, `list->vector`, `list->weak-set`, `list->weak-seteq`, `list->weak-seteqv`, `list-contract?`, `list-prefix?`, `list-ref`, `list-set`, `list-tail`, `list-update`, `list/c`, `list?`, `listen-port-number?`, `listof`, `load`, `load-extension`, `load-on-demand-enabled`, `load-relative`, `load-relative-extension`, `load/cd`, `load/use-compiled`, `local-expand`, `local-expand/capture-lifts`, `local-transformer-expand`, `local-transformer-expand/capture-lifts`, `locale-string-encoding`, `log`, `log-all-levels`, `log-level-evt`, `log-level?`, `log-max-level`, `log-message`, `log-receiver?`, `logger-name`, `logger?`, `magnitude`, `make-arity-at-least`, `make-base-empty-namespace`, `make-base-namespace`, `make-bytes`, `make-channel`, `make-chaperone-contract`, `make-continuation-mark-key`, `make-continuation-prompt-tag`, `make-contract`, `make-custodian`, `make-custodian-box`, `make-custom-hash`, `make-custom-hash-types`, `make-custom-set`, `make-custom-set-types`, `make-date`, `make-date*`, `make-derived-parameter`, `make-directory`, `make-directory*`, `make-do-sequence`, `make-empty-namespace`, `make-environment-variables`, `make-ephemeron`, `make-exn`, `make-exn:break`, `make-exn:break:hang-up`, `make-exn:break:terminate`, `make-exn:fail`, `make-exn:fail:contract`, `make-exn:fail:contract:arity`, `make-exn:fail:contract:blame`, `make-exn:fail:contract:continuation`, `make-exn:fail:contract:divide-by-zero`, `make-exn:fail:contract:non-fixnum-result`, `make-exn:fail:contract:variable`, `make-exn:fail:filesystem`, `make-exn:fail:filesystem:errno`, `make-exn:fail:filesystem:exists`, `make-exn:fail:filesystem:missing-module`, `make-exn:fail:filesystem:version`, `make-exn:fail:network`, `make-exn:fail:network:errno`, `make-exn:fail:object`, `make-exn:fail:out-of-memory`, `make-exn:fail:read`, `make-exn:fail:read:eof`, `make-exn:fail:read:non-char`, `make-exn:fail:syntax`, `make-exn:fail:syntax:missing-module`, `make-exn:fail:syntax:unbound`, `make-exn:fail:unsupported`, `make-exn:fail:user`, `make-file-or-directory-link`, `make-flat-contract`, `make-fsemaphore`, `make-generic`, `make-handle-get-preference-locked`, `make-hash`, `make-hash-placeholder`, `make-hasheq`, `make-hasheq-placeholder`, `make-hasheqv`, `make-hasheqv-placeholder`, `make-immutable-custom-hash`, `make-immutable-hash`, `make-immutable-hasheq`, `make-immutable-hasheqv`, `make-impersonator-property`, `make-input-port`, `make-input-port/read-to-peek`, `make-inspector`, `make-keyword-procedure`, `make-known-char-range-list`, `make-limited-input-port`, `make-list`, `make-lock-file-name`, `make-log-receiver`, `make-logger`, `make-mixin-contract`, `make-mutable-custom-set`, `make-none/c`, `make-object`, `make-output-port`, `make-parameter`, `make-parent-directory*`, `make-phantom-bytes`, `make-pipe`, `make-pipe-with-specials`, `make-placeholder`, `make-plumber`, `make-polar`, `make-prefab-struct`, `make-primitive-class`, `make-proj-contract`, `make-pseudo-random-generator`, `make-reader-graph`, `make-readtable`, `make-rectangular`, `make-rename-transformer`, `make-resolved-module-path`, `make-security-guard`, `make-semaphore`, `make-set!-transformer`, `make-shared-bytes`, `make-sibling-inspector`, `make-special-comment`, `make-srcloc`, `make-string`, `make-struct-field-accessor`, `make-struct-field-mutator`, `make-struct-type`, `make-struct-type-property`, `make-syntax-delta-introducer`, `make-syntax-introducer`, `make-temporary-file`, `make-tentative-pretty-print-output-port`, `make-thread-cell`, `make-thread-group`, `make-vector`, `make-weak-box`, `make-weak-custom-hash`, `make-weak-custom-set`, `make-weak-hash`, `make-weak-hasheq`, `make-weak-hasheqv`, `make-will-executor`, `map`, `match-equality-test`, `matches-arity-exactly?`, `max`, `mcar`, `mcdr`, `mcons`, `member`, `member-name-key-hash-code`, `member-name-key=?`, `member-name-key?`, `memf`, `memq`, `memv`, `merge-input`, `method-in-interface?`, `min`, `mixin-contract`, `module->exports`, `module->imports`, `module->language-info`, `module->namespace`, `module-compiled-cross-phase-persistent?`, `module-compiled-exports`, `module-compiled-imports`, `module-compiled-language-info`, `module-compiled-name`, `module-compiled-submodules`, `module-declared?`, `module-path-index-join`, `module-path-index-resolve`, `module-path-index-split`, `module-path-index-submodule`, `module-path-index?`, `module-path?`, `module-predefined?`, `module-provide-protected?`, `modulo`, `mpair?`, `mutable-set`, `mutable-seteq`, `mutable-seteqv`, `n->th`, `nack-guard-evt`, `namespace-anchor->empty-namespace`, `namespace-anchor->namespace`, `namespace-anchor?`, `namespace-attach-module`, `namespace-attach-module-declaration`, `namespace-base-phase`, `namespace-mapped-symbols`, `namespace-module-identifier`, `namespace-module-registry`, `namespace-require`, `namespace-require/constant`, `namespace-require/copy`, `namespace-require/expansion-time`, `namespace-set-variable-value!`, `namespace-symbol->identifier`, `namespace-syntax-introduce`, `namespace-undefine-variable!`, `namespace-unprotect-module`, `namespace-variable-value`, `namespace?`, `nan?`, `natural-number/c`, `negate`, `negative?`, `never-evt`, `new-∀/c`, `new-∃/c`, `newline`, `ninth`, `non-empty-listof`, `non-empty-string?`, `none/c`, `normal-case-path`, `normalize-arity`, `normalize-path`, `normalized-arity?`, `not`, `not/c`, `null`, `null?`, `number->string`, `number?`, `numerator`, `object%`, `object->vector`, `object-info`, `object-interface`, `object-method-arity-includes?`, `object-name`, `object-or-false=?`, `object=?`, `object?`, `odd?`, `one-of/c`, `open-input-bytes`, `open-input-file`, `open-input-output-file`, `open-input-string`, `open-output-bytes`, `open-output-file`, `open-output-nowhere`, `open-output-string`, `or/c`, `order-of-magnitude`, `ormap`, `other-execute-bit`, `other-read-bit`, `other-write-bit`, `output-port?`, `pair?`, `parameter-procedure=?`, `parameter/c`, `parameter?`, `parameterization?`, `parse-command-line`, `partition`, `path->bytes`, `path->complete-path`, `path->directory-path`, `path->string`, `path-add-suffix`, `path-convention-type`, `path-element->bytes`, `path-element->string`, `path-element?`, `path-for-some-system?`, `path-list-string->path-list`, `path-only`, `path-replace-suffix`, `path-string?`, `path<?`, `path?`, `pathlist-closure`, `peek-byte`, `peek-byte-or-special`, `peek-bytes`, `peek-bytes!`, `peek-bytes!-evt`, `peek-bytes-avail!`, `peek-bytes-avail!*`, `peek-bytes-avail!-evt`, `peek-bytes-avail!/enable-break`, `peek-bytes-evt`, `peek-char`, `peek-char-or-special`, `peek-string`, `peek-string!`, `peek-string!-evt`, `peek-string-evt`, `peeking-input-port`, `permutations`, `phantom-bytes?`, `pi`, `pi.f`, `pipe-content-length`, `place-break`, `place-channel`, `place-channel-get`, `place-channel-put`, `place-channel-put/get`, `place-channel?`, `place-dead-evt`, `place-enabled?`, `place-kill`, `place-location?`, `place-message-allowed?`, `place-sleep`, `place-wait`, `place?`, `placeholder-get`, `placeholder-set!`, `placeholder?`, `plumber-add-flush!`, `plumber-flush-all`, `plumber-flush-handle-remove!`, `plumber-flush-handle?`, `plumber?`, `poll-guard-evt`, `port->bytes`, `port->bytes-lines`, `port->lines`, `port->list`, `port->string`, `port-closed-evt`, `port-closed?`, `port-commit-peeked`, `port-count-lines!`, `port-count-lines-enabled`, `port-counts-lines?`, `port-display-handler`, `port-file-identity`, `port-file-unlock`, `port-next-location`, `port-number?`, `port-print-handler`, `port-progress-evt`, `port-provides-progress-evts?`, `port-read-handler`, `port-try-file-lock?`, `port-write-handler`, `port-writes-atomic?`, `port-writes-special?`, `port?`, `positive?`, `predicate/c`, `prefab-key->struct-type`, `prefab-key?`, `prefab-struct-key`, `preferences-lock-file-mode`, `pregexp`, `pregexp?`, `pretty-display`, `pretty-format`, `pretty-print`, `pretty-print-.-symbol-without-bars`, `pretty-print-abbreviate-read-macros`, `pretty-print-columns`, `pretty-print-current-style-table`, `pretty-print-depth`, `pretty-print-exact-as-decimal`, `pretty-print-extend-style-table`, `pretty-print-handler`, `pretty-print-newline`, `pretty-print-post-print-hook`, `pretty-print-pre-print-hook`, `pretty-print-print-hook`, `pretty-print-print-line`, `pretty-print-remap-stylable`, `pretty-print-show-inexactness`, `pretty-print-size-hook`, `pretty-print-style-table?`, `pretty-printing`, `pretty-write`, `primitive-closure?`, `primitive-result-arity`, `primitive?`, `print`, `print-as-expression`, `print-boolean-long-form`, `print-box`, `print-graph`, `print-hash-table`, `print-mpair-curly-braces`, `print-pair-curly-braces`, `print-reader-abbreviations`, `print-struct`, `print-syntax-width`, `print-unreadable`, `print-vector-length`, `printable/c`, `printable<%>`, `printf`, `println`, `procedure->method`, `procedure-arity`, `procedure-arity-includes/c`, `procedure-arity-includes?`, `procedure-arity?`, `procedure-closure-contents-eq?`, `procedure-extract-target`, `procedure-keywords`, `procedure-reduce-arity`, `procedure-reduce-keyword-arity`, `procedure-rename`, `procedure-result-arity`, `procedure-specialize`, `procedure-struct-type?`, `procedure?`, `process`, `process*`, `process*/ports`, `process/ports`, `processor-count`, `progress-evt?`, `promise-forced?`, `promise-running?`, `promise/c`, `promise/name?`, `promise?`, `prop:arity-string`, `prop:arrow-contract`, `prop:arrow-contract-get-info`, `prop:arrow-contract?`, `prop:blame`, `prop:chaperone-contract`, `prop:checked-procedure`, `prop:contract`, `prop:contracted`, `prop:custom-print-quotable`, `prop:custom-write`, `prop:dict`, `prop:dict/contract`, `prop:equal+hash`, `prop:evt`, `prop:exn:missing-module`, `prop:exn:srclocs`, `prop:expansion-contexts`, `prop:flat-contract`, `prop:impersonator-of`, `prop:input-port`, `prop:liberal-define-context`, `prop:object-name`, `prop:opt-chaperone-contract`, `prop:opt-chaperone-contract-get-test`, `prop:opt-chaperone-contract?`, `prop:orc-contract`, `prop:orc-contract-get-subcontracts`, `prop:orc-contract?`, `prop:output-port`, `prop:place-location`, `prop:procedure`, `prop:recursive-contract`, `prop:recursive-contract-unroll`, `prop:recursive-contract?`, `prop:rename-transformer`, `prop:sequence`, `prop:set!-transformer`, `prop:stream`, `proper-subset?`, `pseudo-random-generator->vector`, `pseudo-random-generator-vector?`, `pseudo-random-generator?`, `put-preferences`, `putenv`, `quotient`, `quotient/remainder`, `radians->degrees`, `raise`, `raise-argument-error`, `raise-arguments-error`, `raise-arity-error`, `raise-blame-error`, `raise-contract-error`, `raise-mismatch-error`, `raise-not-cons-blame-error`, `raise-range-error`, `raise-result-error`, `raise-syntax-error`, `raise-type-error`, `raise-user-error`, `random`, `random-seed`, `range`, `rational?`, `rationalize`, `read`, `read-accept-bar-quote`, `read-accept-box`, `read-accept-compiled`, `read-accept-dot`, `read-accept-graph`, `read-accept-infix-dot`, `read-accept-lang`, `read-accept-quasiquote`, `read-accept-reader`, `read-byte`, `read-byte-or-special`, `read-bytes`, `read-bytes!`, `read-bytes!-evt`, `read-bytes-avail!`, `read-bytes-avail!*`, `read-bytes-avail!-evt`, `read-bytes-avail!/enable-break`, `read-bytes-evt`, `read-bytes-line`, `read-bytes-line-evt`, `read-case-sensitive`, `read-cdot`, `read-char`, `read-char-or-special`, `read-curly-brace-as-paren`, `read-curly-brace-with-tag`, `read-decimal-as-inexact`, `read-eval-print-loop`, `read-language`, `read-line`, `read-line-evt`, `read-on-demand-source`, `read-square-bracket-as-paren`, `read-square-bracket-with-tag`, `read-string`, `read-string!`, `read-string!-evt`, `read-string-evt`, `read-syntax`, `read-syntax/recursive`, `read/recursive`, `readtable-mapping`, `readtable?`, `real->decimal-string`, `real->double-flonum`, `real->floating-point-bytes`, `real->single-flonum`, `real-in`, `real-part`, `real?`, `reencode-input-port`, `reencode-output-port`, `regexp`, `regexp-match`, `regexp-match*`, `regexp-match-evt`, `regexp-match-exact?`, `regexp-match-peek`, `regexp-match-peek-immediate`, `regexp-match-peek-positions`, `regexp-match-peek-positions*`, `regexp-match-peek-positions-immediate`, `regexp-match-peek-positions-immediate/end`, `regexp-match-peek-positions/end`, `regexp-match-positions`, `regexp-match-positions*`, `regexp-match-positions/end`, `regexp-match/end`, `regexp-match?`, `regexp-max-lookbehind`, `regexp-quote`, `regexp-replace`, `regexp-replace*`, `regexp-replace-quote`, `regexp-replaces`, `regexp-split`, `regexp-try-match`, `regexp?`, `relative-path?`, `relocate-input-port`, `relocate-output-port`, `remainder`, `remf`, `remf*`, `remove`, `remove*`, `remove-duplicates`, `remq`, `remq*`, `remv`, `remv*`, `rename-contract`, `rename-file-or-directory`, `rename-transformer-target`, `rename-transformer?`, `replace-evt`, `reroot-path`, `resolve-path`, `resolved-module-path-name`, `resolved-module-path?`, `rest`, `reverse`, `round`, `second`, `seconds->date`, `security-guard?`, `semaphore-peek-evt`, `semaphore-peek-evt?`, `semaphore-post`, `semaphore-try-wait?`, `semaphore-wait`, `semaphore-wait/enable-break`, `semaphore?`, `sequence->list`, `sequence->stream`, `sequence-add-between`, `sequence-andmap`, `sequence-append`, `sequence-count`, `sequence-filter`, `sequence-fold`, `sequence-for-each`, `sequence-generate`, `sequence-generate*`, `sequence-length`, `sequence-map`, `sequence-ormap`, `sequence-ref`, `sequence-tail`, `sequence/c`, `sequence?`, `set`, `set!-transformer-procedure`, `set!-transformer?`, `set->list`, `set->stream`, `set-add`, `set-add!`, `set-box!`, `set-clear`, `set-clear!`, `set-copy`, `set-copy-clear`, `set-count`, `set-empty?`, `set-eq?`, `set-equal?`, `set-eqv?`, `set-first`, `set-for-each`, `set-implements/c`, `set-implements?`, `set-intersect`, `set-intersect!`, `set-map`, `set-mcar!`, `set-mcdr!`, `set-member?`, `set-mutable?`, `set-phantom-bytes!`, `set-port-next-location!`, `set-remove`, `set-remove!`, `set-rest`, `set-some-basic-contracts!`, `set-subtract`, `set-subtract!`, `set-symmetric-difference`, `set-symmetric-difference!`, `set-union`, `set-union!`, `set-weak?`, `set/c`, `set=?`, `set?`, `seteq`, `seteqv`, `seventh`, `sgn`, `shared-bytes`, `shell-execute`, `shrink-path-wrt`, `shuffle`, `simple-form-path`, `simplify-path`, `sin`, `single-flonum?`, `sinh`, `sixth`, `skip-projection-wrapper?`, `sleep`, `some-system-path->string`, `sort`, `special-comment-value`, `special-comment?`, `special-filter-input-port`, `split-at`, `split-at-right`, `split-common-prefix`, `split-path`, `splitf-at`, `splitf-at-right`, `sqr`, `sqrt`, `srcloc`, `srcloc->string`, `srcloc-column`, `srcloc-line`, `srcloc-position`, `srcloc-source`, `srcloc-span`, `srcloc?`, `stop-after`, `stop-before`, `stream->list`, `stream-add-between`, `stream-andmap`, `stream-append`, `stream-count`, `stream-empty?`, `stream-filter`, `stream-first`, `stream-fold`, `stream-for-each`, `stream-length`, `stream-map`, `stream-ormap`, `stream-ref`, `stream-rest`, `stream-tail`, `stream/c`, `stream?`, `string`, `string->bytes/latin-1`, `string->bytes/locale`, `string->bytes/utf-8`, `string->immutable-string`, `string->keyword`, `string->list`, `string->number`, `string->path`, `string->path-element`, `string->some-system-path`, `string->symbol`, `string->uninterned-symbol`, `string->unreadable-symbol`, `string-append`, `string-append*`, `string-ci<=?`, `string-ci<?`, `string-ci=?`, `string-ci>=?`, `string-ci>?`, `string-contains?`, `string-copy`, `string-copy!`, `string-downcase`, `string-environment-variable-name?`, `string-fill!`, `string-foldcase`, `string-join`, `string-len/c`, `string-length`, `string-locale-ci<?`, `string-locale-ci=?`, `string-locale-ci>?`, `string-locale-downcase`, `string-locale-upcase`, `string-locale<?`, `string-locale=?`, `string-locale>?`, `string-no-nuls?`, `string-normalize-nfc`, `string-normalize-nfd`, `string-normalize-nfkc`, `string-normalize-nfkd`, `string-normalize-spaces`, `string-port?`, `string-prefix?`, `string-ref`, `string-replace`, `string-set!`, `string-split`, `string-suffix?`, `string-titlecase`, `string-trim`, `string-upcase`, `string-utf-8-length`, `string<=?`, `string<?`, `string=?`, `string>=?`, `string>?`, `string?`, `struct->vector`, `struct-accessor-procedure?`, `struct-constructor-procedure?`, `struct-info`, `struct-mutator-procedure?`, `struct-predicate-procedure?`, `struct-type-info`, `struct-type-make-constructor`, `struct-type-make-predicate`, `struct-type-property-accessor-procedure?`, `struct-type-property/c`, `struct-type-property?`, `struct-type?`, `struct:arity-at-least`, `struct:arrow-contract-info`, `struct:date`, `struct:date*`, `struct:exn`, `struct:exn:break`, `struct:exn:break:hang-up`, `struct:exn:break:terminate`, `struct:exn:fail`, `struct:exn:fail:contract`, `struct:exn:fail:contract:arity`, `struct:exn:fail:contract:blame`, `struct:exn:fail:contract:continuation`, `struct:exn:fail:contract:divide-by-zero`, `struct:exn:fail:contract:non-fixnum-result`, `struct:exn:fail:contract:variable`, `struct:exn:fail:filesystem`, `struct:exn:fail:filesystem:errno`, `struct:exn:fail:filesystem:exists`, `struct:exn:fail:filesystem:missing-module`, `struct:exn:fail:filesystem:version`, `struct:exn:fail:network`, `struct:exn:fail:network:errno`, `struct:exn:fail:object`, `struct:exn:fail:out-of-memory`, `struct:exn:fail:read`, `struct:exn:fail:read:eof`, `struct:exn:fail:read:non-char`, `struct:exn:fail:syntax`, `struct:exn:fail:syntax:missing-module`, `struct:exn:fail:syntax:unbound`, `struct:exn:fail:unsupported`, `struct:exn:fail:user`, `struct:srcloc`, `struct:wrapped-extra-arg-arrow`, `struct?`, `sub1`, `subbytes`, `subclass?`, `subclass?/c`, `subprocess`, `subprocess-group-enabled`, `subprocess-kill`, `subprocess-pid`, `subprocess-status`, `subprocess-wait`, `subprocess?`, `subset?`, `substring`, `suggest/c`, `symbol->string`, `symbol-interned?`, `symbol-unreadable?`, `symbol<?`, `symbol=?`, `symbol?`, `symbols`, `sync`, `sync/enable-break`, `sync/timeout`, `sync/timeout/enable-break`, `syntax->datum`, `syntax->list`, `syntax-arm`, `syntax-column`, `syntax-debug-info`, `syntax-disarm`, `syntax-e`, `syntax-line`, `syntax-local-bind-syntaxes`, `syntax-local-certifier`, `syntax-local-context`, `syntax-local-expand-expression`, `syntax-local-get-shadower`, `syntax-local-identifier-as-binding`, `syntax-local-introduce`, `syntax-local-lift-context`, `syntax-local-lift-expression`, `syntax-local-lift-module`, `syntax-local-lift-module-end-declaration`, `syntax-local-lift-provide`, `syntax-local-lift-require`, `syntax-local-lift-values-expression`, `syntax-local-make-definition-context`, `syntax-local-make-delta-introducer`, `syntax-local-module-defined-identifiers`, `syntax-local-module-exports`, `syntax-local-module-required-identifiers`, `syntax-local-name`, `syntax-local-phase-level`, `syntax-local-submodules`, `syntax-local-transforming-module-provides?`, `syntax-local-value`, `syntax-local-value/immediate`, `syntax-original?`, `syntax-position`, `syntax-property`, `syntax-property-preserved?`, `syntax-property-symbol-keys`, `syntax-protect`, `syntax-rearm`, `syntax-recertify`, `syntax-shift-phase-level`, `syntax-source`, `syntax-source-module`, `syntax-span`, `syntax-taint`, `syntax-tainted?`, `syntax-track-origin`, `syntax-transforming-module-expression?`, `syntax-transforming-with-lifts?`, `syntax-transforming?`, `syntax/c`, `syntax?`, `system`, `system*`, `system*/exit-code`, `system-big-endian?`, `system-idle-evt`, `system-language+country`, `system-library-subpath`, `system-path-convention-type`, `system-type`, `system/exit-code`, `tail-marks-match?`, `take`, `take-common-prefix`, `take-right`, `takef`, `takef-right`, `tan`, `tanh`, `tcp-abandon-port`, `tcp-accept`, `tcp-accept-evt`, `tcp-accept-ready?`, `tcp-accept/enable-break`, `tcp-addresses`, `tcp-close`, `tcp-connect`, `tcp-connect/enable-break`, `tcp-listen`, `tcp-listener?`, `tcp-port?`, `tentative-pretty-print-port-cancel`, `tentative-pretty-print-port-transfer`, `tenth`, `terminal-port?`, `the-unsupplied-arg`, `third`, `thread`, `thread-cell-ref`, `thread-cell-set!`, `thread-cell-values?`, `thread-cell?`, `thread-dead-evt`, `thread-dead?`, `thread-group?`, `thread-receive`, `thread-receive-evt`, `thread-resume`, `thread-resume-evt`, `thread-rewind-receive`, `thread-running?`, `thread-send`, `thread-suspend`, `thread-suspend-evt`, `thread-try-receive`, `thread-wait`, `thread/suspend-to-kill`, `thread?`, `time-apply`, `touch`, `transplant-input-port`, `transplant-output-port`, `true`, `truncate`, `udp-addresses`, `udp-bind!`, `udp-bound?`, `udp-close`, `udp-connect!`, `udp-connected?`, `udp-multicast-interface`, `udp-multicast-join-group!`, `udp-multicast-leave-group!`, `udp-multicast-loopback?`, `udp-multicast-set-interface!`, `udp-multicast-set-loopback!`, `udp-multicast-set-ttl!`, `udp-multicast-ttl`, `udp-open-socket`, `udp-receive!`, `udp-receive!*`, `udp-receive!-evt`, `udp-receive!/enable-break`, `udp-receive-ready-evt`, `udp-send`, `udp-send*`, `udp-send-evt`, `udp-send-ready-evt`, `udp-send-to`, `udp-send-to*`, `udp-send-to-evt`, `udp-send-to/enable-break`, `udp-send/enable-break`, `udp?`, `unbox`, `uncaught-exception-handler`, `unit?`, `unspecified-dom`, `unsupplied-arg?`, `use-collection-link-paths`, `use-compiled-file-paths`, `use-user-specific-search-paths`, `user-execute-bit`, `user-read-bit`, `user-write-bit`, `value-blame`, `value-contract`, `values`, `variable-reference->empty-namespace`, `variable-reference->module-base-phase`, `variable-reference->module-declaration-inspector`, `variable-reference->module-path-index`, `variable-reference->module-source`, `variable-reference->namespace`, `variable-reference->phase`, `variable-reference->resolved-module-path`, `variable-reference-constant?`, `variable-reference?`, `vector`, `vector->immutable-vector`, `vector->list`, `vector->pseudo-random-generator`, `vector->pseudo-random-generator!`, `vector->values`, `vector-append`, `vector-argmax`, `vector-argmin`, `vector-copy`, `vector-copy!`, `vector-count`, `vector-drop`, `vector-drop-right`, `vector-fill!`, `vector-filter`, `vector-filter-not`, `vector-immutable`, `vector-immutable/c`, `vector-immutableof`, `vector-length`, `vector-map`, `vector-map!`, `vector-member`, `vector-memq`, `vector-memv`, `vector-ref`, `vector-set!`, `vector-set*!`, `vector-set-performance-stats!`, `vector-split-at`, `vector-split-at-right`, `vector-take`, `vector-take-right`, `vector/c`, `vector?`, `vectorof`, `version`, `void`, `void?`, `weak-box-value`, `weak-box?`, `weak-set`, `weak-seteq`, `weak-seteqv`, `will-execute`, `will-executor?`, `will-register`, `will-try-execute`, `with-input-from-bytes`, `with-input-from-file`, `with-input-from-string`, `with-output-to-bytes`, `with-output-to-file`, `with-output-to-string`, `would-be-future`, `wrap-evt`, `wrapped-extra-arg-arrow`, `wrapped-extra-arg-arrow-extra-neg-party-argument`, `wrapped-extra-arg-arrow-real-func`, `wrapped-extra-arg-arrow?`, `writable<%>`, `write`, `write-byte`, `write-bytes`, `write-bytes-avail`, `write-bytes-avail*`, `write-bytes-avail-evt`, `write-bytes-avail/enable-break`, `write-char`, `write-special`, `write-special-avail*`, `write-special-evt`, `write-string`, `write-to-file`, `writeln`, `xor`, `zero?`, `~.a`, `~.s`, `~.v`, `~a`, `~e`, `~r`, `~s`, `~v`), NameBuiltin, Pop(1)}, {"(?:\\|[^|]*\\||\\\\[\\w\\W]|[^|\\\\()[\\]{}\",\\'`;\\s]+)+", Name, Pop(1)}, Include("datum*"), }, "unquoted-list": { Include("list"), {`(?!\Z)`, Text, Push("unquoted-datum")}, }, "quasiquoted-datum": { Include("datum"), {`,@?`, Operator, Push("#pop", "unquoted-datum")}, {"unquote(-splicing)?(?=[()[\\]{}\",\\'`;\\s])", Keyword, Push("#pop", "unquoted-datum")}, {`[([{]`, Punctuation, Push("#pop", "quasiquoted-list")}, Include("datum*"), }, "quasiquoted-list": { Include("list"), {`(?!\Z)`, Text, Push("quasiquoted-datum")}, }, "quoted-datum": { Include("datum"), {`[([{]`, Punctuation, Push("#pop", "quoted-list")}, Include("datum*"), }, "quoted-list": { Include("list"), {`(?!\Z)`, Text, Push("quoted-datum")}, }, "block-comment": { {`#\|`, CommentMultiline, Push()}, {`\|#`, CommentMultiline, Pop(1)}, {`[^#|]+|.`, CommentMultiline, nil}, }, "string": { {`"`, LiteralStringDouble, Pop(1)}, {`(?s)\\([0-7]{1,3}|x[\da-fA-F]{1,2}|u[\da-fA-F]{1,4}|U[\da-fA-F]{1,8}|.)`, LiteralStringEscape, nil}, {`[^\\"]+`, LiteralStringDouble, nil}, }, }, ))
Racket lexer.
var Ragel = Register(MustNewLexer( &Config{ Name: "Ragel", Aliases: []string{"ragel"}, Filenames: []string{}, MimeTypes: []string{}, }, Rules{ "whitespace": { {`\s+`, TextWhitespace, nil}, }, "comments": { {`\#.*$`, Comment, nil}, }, "keywords": { {`(access|action|alphtype)\b`, Keyword, nil}, {`(getkey|write|machine|include)\b`, Keyword, nil}, {`(any|ascii|extend|alpha|digit|alnum|lower|upper)\b`, Keyword, nil}, {`(xdigit|cntrl|graph|print|punct|space|zlen|empty)\b`, Keyword, nil}, }, "numbers": { {`0x[0-9A-Fa-f]+`, LiteralNumberHex, nil}, {`[+-]?[0-9]+`, LiteralNumberInteger, nil}, }, "literals": { {`"(\\\\|\\"|[^"])*"`, LiteralString, nil}, {`'(\\\\|\\'|[^'])*'`, LiteralString, nil}, {`\[(\\\\|\\\]|[^\]])*\]`, LiteralString, nil}, {`/(?!\*)(\\\\|\\/|[^/])*/`, LiteralStringRegex, nil}, }, "identifiers": { {`[a-zA-Z_]\w*`, NameVariable, nil}, }, "operators": { {`,`, Operator, nil}, {`\||&|--?`, Operator, nil}, {`\.|<:|:>>?`, Operator, nil}, {`:`, Operator, nil}, {`->`, Operator, nil}, {`(>|\$|%|<|@|<>)(/|eof\b)`, Operator, nil}, {`(>|\$|%|<|@|<>)(!|err\b)`, Operator, nil}, {`(>|\$|%|<|@|<>)(\^|lerr\b)`, Operator, nil}, {`(>|\$|%|<|@|<>)(~|to\b)`, Operator, nil}, {`(>|\$|%|<|@|<>)(\*|from\b)`, Operator, nil}, {`>|@|\$|%`, Operator, nil}, {`\*|\?|\+|\{[0-9]*,[0-9]*\}`, Operator, nil}, {`!|\^`, Operator, nil}, {`\(|\)`, Operator, nil}, }, "root": { Include("literals"), Include("whitespace"), Include("comments"), Include("keywords"), Include("numbers"), Include("identifiers"), Include("operators"), {`\{`, Punctuation, Push("host")}, {`=`, Operator, nil}, {`;`, Punctuation, nil}, }, "host": { {`([^{}\'"/#]+|[^\\]\\[{}]|"(\\\\|\\"|[^"])*"|'(\\\\|\\'|[^'])*'|//.*$\n?|/\*(.|\n)*?\*/|\#.*$\n?|/(?!\*)(\\\\|\\/|[^/])*/|/)+`, Other, nil}, {`\{`, Punctuation, Push()}, {`\}`, Punctuation, Pop(1)}, }, }, ))
Ragel lexer.
var Reg = Register(MustNewLexer( &Config{ Name: "reg", Aliases: []string{"registry"}, Filenames: []string{"*.reg"}, MimeTypes: []string{"text/x-windows-registry"}, }, Rules{ "root": { {`Windows Registry Editor.*`, Text, nil}, {`\s+`, Text, nil}, {`[;#].*`, CommentSingle, nil}, {`(\[)(-?)(HKEY_[A-Z_]+)(.*?\])$`, ByGroups(Keyword, Operator, NameBuiltin, Keyword), nil}, {`("(?:\\"|\\\\|[^"])+")([ \t]*)(=)([ \t]*)`, ByGroups(NameAttribute, Text, Operator, Text), Push("value")}, {`(.*?)([ \t]*)(=)([ \t]*)`, ByGroups(NameAttribute, Text, Operator, Text), Push("value")}, }, "value": { {`-`, Operator, Pop(1)}, {`(dword|hex(?:\([0-9a-fA-F]\))?)(:)([0-9a-fA-F,]+)`, ByGroups(NameVariable, Punctuation, LiteralNumber), Pop(1)}, {`.+`, LiteralString, Pop(1)}, Default(Pop(1)), }, }, ))
Reg lexer.
var Registry = struct { Lexers chroma.Lexers byName map[string]chroma.Lexer byAlias map[string]chroma.Lexer }{ // contains filtered or unexported fields }
Registry of Lexers.
var Restructuredtext = Register(MustNewLexer( &Config{ Name: "reStructuredText", Aliases: []string{"rst", "rest", "restructuredtext"}, Filenames: []string{"*.rst", "*.rest"}, MimeTypes: []string{"text/x-rst", "text/prs.fallenstein.rst"}, }, Rules{ "root": { {"^(=+|-+|`+|:+|\\.+|\\'+|\"+|~+|\\^+|_+|\\*+|\\++|#+)([ \\t]*\\n)(.+)(\\n)(\\1)(\\n)", ByGroups(GenericHeading, Text, GenericHeading, Text, GenericHeading, Text), nil}, {"^(\\S.*)(\\n)(={3,}|-{3,}|`{3,}|:{3,}|\\.{3,}|\\'{3,}|\"{3,}|~{3,}|\\^{3,}|_{3,}|\\*{3,}|\\+{3,}|#{3,})(\\n)", ByGroups(GenericHeading, Text, GenericHeading, Text), nil}, {`^(\s*)([-*+])( .+\n(?:\1 .+\n)*)`, ByGroups(Text, LiteralNumber, UsingSelf("inline")), nil}, {`^(\s*)([0-9#ivxlcmIVXLCM]+\.)( .+\n(?:\1 .+\n)*)`, ByGroups(Text, LiteralNumber, UsingSelf("inline")), nil}, {`^(\s*)(\(?[0-9#ivxlcmIVXLCM]+\))( .+\n(?:\1 .+\n)*)`, ByGroups(Text, LiteralNumber, UsingSelf("inline")), nil}, {`^(\s*)([A-Z]+\.)( .+\n(?:\1 .+\n)+)`, ByGroups(Text, LiteralNumber, UsingSelf("inline")), nil}, {`^(\s*)(\(?[A-Za-z]+\))( .+\n(?:\1 .+\n)+)`, ByGroups(Text, LiteralNumber, UsingSelf("inline")), nil}, {`^(\s*)(\|)( .+\n(?:\| .+\n)*)`, ByGroups(Text, Operator, UsingSelf("inline")), nil}, {`^( *\.\.)(\s*)((?:source)?code(?:-block)?)(::)([ \t]*)([^\n]+)(\n[ \t]*\n)([ \t]+)(.*)(\n)((?:(?:\8.*|)\n)+)`, EmitterFunc(rstCodeBlock), nil}, {`^( *\.\.)(\s*)([\w:-]+?)(::)(?:([ \t]*)(.*))`, ByGroups(Punctuation, Text, OperatorWord, Punctuation, Text, UsingSelf("inline")), nil}, {`^( *\.\.)(\s*)(_(?:[^:\\]|\\.)+:)(.*?)$`, ByGroups(Punctuation, Text, NameTag, UsingSelf("inline")), nil}, {`^( *\.\.)(\s*)(\[.+\])(.*?)$`, ByGroups(Punctuation, Text, NameTag, UsingSelf("inline")), nil}, {`^( *\.\.)(\s*)(\|.+\|)(\s*)([\w:-]+?)(::)(?:([ \t]*)(.*))`, ByGroups(Punctuation, Text, NameTag, Text, OperatorWord, Punctuation, Text, UsingSelf("inline")), nil}, {`^ *\.\..*(\n( +.*\n|\n)+)?`, CommentPreproc, nil}, {`^( *)(:[a-zA-Z-]+:)(\s*)$`, ByGroups(Text, NameClass, Text), nil}, {`^( *)(:.*?:)([ \t]+)(.*?)$`, ByGroups(Text, NameClass, Text, NameFunction), nil}, {`^(\S.*(?<!::)\n)((?:(?: +.*)\n)+)`, ByGroups(UsingSelf("inline"), UsingSelf("inline")), nil}, {`(::)(\n[ \t]*\n)([ \t]+)(.*)(\n)((?:(?:\3.*|)\n)+)`, ByGroups(LiteralStringEscape, Text, LiteralString, LiteralString, Text, LiteralString), nil}, Include("inline"), }, "inline": { {`\\.`, Text, nil}, {"``", LiteralString, Push("literal")}, {"(`.+?)(<.+?>)(`__?)", ByGroups(LiteralString, LiteralStringInterpol, LiteralString), nil}, {"`.+?`__?", LiteralString, nil}, {"(`.+?`)(:[a-zA-Z0-9:-]+?:)?", ByGroups(NameVariable, NameAttribute), nil}, {"(:[a-zA-Z0-9:-]+?:)(`.+?`)", ByGroups(NameAttribute, NameVariable), nil}, {`\*\*.+?\*\*`, GenericStrong, nil}, {`\*.+?\*`, GenericEmph, nil}, {`\[.*?\]_`, LiteralString, nil}, {`<.+?>`, NameTag, nil}, {"[^\\\\\\n\\[*`:]+", Text, nil}, {`.`, Text, nil}, }, "literal": { {"[^`]+", LiteralString, nil}, {"" /* 130 byte string literal not displayed */, LiteralString, Pop(1)}, {"`", LiteralString, nil}, }, }, ))
Restructuredtext lexer.
var Rexx = Register(MustNewLexer( &Config{ Name: "Rexx", Aliases: []string{"rexx", "arexx"}, Filenames: []string{"*.rexx", "*.rex", "*.rx", "*.arexx"}, MimeTypes: []string{"text/x-rexx"}, NotMultiline: true, CaseInsensitive: true, }, Rules{ "root": { {`\s`, TextWhitespace, nil}, {`/\*`, CommentMultiline, Push("comment")}, {`"`, LiteralString, Push("string_double")}, {`'`, LiteralString, Push("string_single")}, {`[0-9]+(\.[0-9]+)?(e[+-]?[0-9])?`, LiteralNumber, nil}, {`([a-z_]\w*)(\s*)(:)(\s*)(procedure)\b`, ByGroups(NameFunction, TextWhitespace, Operator, TextWhitespace, KeywordDeclaration), nil}, {`([a-z_]\w*)(\s*)(:)`, ByGroups(NameLabel, TextWhitespace, Operator), nil}, Include("function"), Include("keyword"), Include("operator"), {`[a-z_]\w*`, Text, nil}, }, "function": { {Words(``, `(\s*)(\()`, `abbrev`, `abs`, `address`, `arg`, `b2x`, `bitand`, `bitor`, `bitxor`, `c2d`, `c2x`, `center`, `charin`, `charout`, `chars`, `compare`, `condition`, `copies`, `d2c`, `d2x`, `datatype`, `date`, `delstr`, `delword`, `digits`, `errortext`, `form`, `format`, `fuzz`, `insert`, `lastpos`, `left`, `length`, `linein`, `lineout`, `lines`, `max`, `min`, `overlay`, `pos`, `queued`, `random`, `reverse`, `right`, `sign`, `sourceline`, `space`, `stream`, `strip`, `substr`, `subword`, `symbol`, `time`, `trace`, `translate`, `trunc`, `value`, `verify`, `word`, `wordindex`, `wordlength`, `wordpos`, `words`, `x2b`, `x2c`, `x2d`, `xrange`), ByGroups(NameBuiltin, TextWhitespace, Operator), nil}, }, "keyword": { {"" /* 186 byte string literal not displayed */, KeywordReserved, nil}, }, "operator": { {"" /* 142 byte string literal not displayed */, Operator, nil}, }, "string_double": { {`[^"\n]+`, LiteralString, nil}, {`""`, LiteralString, nil}, {`"`, LiteralString, Pop(1)}, {`\n`, Text, Pop(1)}, }, "string_single": { {`[^\'\n]`, LiteralString, nil}, {`\'\'`, LiteralString, nil}, {`\'`, LiteralString, Pop(1)}, {`\n`, Text, Pop(1)}, }, "comment": { {`[^*]+`, CommentMultiline, nil}, {`\*/`, CommentMultiline, Pop(1)}, {`\*`, CommentMultiline, nil}, }, }, ))
Rexx lexer.
var Ruby = Register(MustNewLexer( &Config{ Name: "Ruby", Aliases: []string{"rb", "ruby", "duby"}, Filenames: []string{"*.rb", "*.rbw", "Rakefile", "*.rake", "*.gemspec", "*.rbx", "*.duby", "Gemfile"}, MimeTypes: []string{"text/x-ruby", "application/x-ruby"}, DotAll: true, }, Rules{ "root": { {`\A#!.+?$`, CommentHashbang, nil}, {`#.*?$`, CommentSingle, nil}, {`=begin\s.*?\n=end.*?$`, CommentMultiline, nil}, {Words(``, `\b`, `BEGIN`, `END`, `alias`, `begin`, `break`, `case`, `defined?`, `do`, `else`, `elsif`, `end`, `ensure`, `for`, `if`, `in`, `next`, `redo`, `rescue`, `raise`, `retry`, `return`, `super`, `then`, `undef`, `unless`, `until`, `when`, `while`, `yield`), Keyword, nil}, {`(module)(\s+)([a-zA-Z_]\w*(?:::[a-zA-Z_]\w*)*)`, ByGroups(Keyword, Text, NameNamespace), nil}, {`(def)(\s+)`, ByGroups(Keyword, Text), Push("funcname")}, {"def(?=[*%&^`~+-/\\[<>=])", Keyword, Push("funcname")}, {`(class)(\s+)`, ByGroups(Keyword, Text), Push("classname")}, {Words(``, `\b`, `initialize`, `new`, `loop`, `include`, `extend`, `raise`, `attr_reader`, `attr_writer`, `attr_accessor`, `attr`, `catch`, `throw`, `private`, `module_function`, `public`, `protected`, `true`, `false`, `nil`), KeywordPseudo, nil}, {`(not|and|or)\b`, OperatorWord, nil}, {Words(``, `\?`, `autoload`, `block_given`, `const_defined`, `eql`, `equal`, `frozen`, `include`, `instance_of`, `is_a`, `iterator`, `kind_of`, `method_defined`, `nil`, `private_method_defined`, `protected_method_defined`, `public_method_defined`, `respond_to`, `tainted`), NameBuiltin, nil}, {`(chomp|chop|exit|gsub|sub)!`, NameBuiltin, nil}, {Words(`(?<!\.)`, `\b`, `Array`, `Float`, `Integer`, `String`, `__id__`, `__send__`, `abort`, `ancestors`, `at_exit`, `autoload`, `binding`, `callcc`, `caller`, `catch`, `chomp`, `chop`, `class_eval`, `class_variables`, `clone`, `const_defined?`, `const_get`, `const_missing`, `const_set`, `constants`, `display`, `dup`, `eval`, `exec`, `exit`, `extend`, `fail`, `fork`, `format`, `freeze`, `getc`, `gets`, `global_variables`, `gsub`, `hash`, `id`, `included_modules`, `inspect`, `instance_eval`, `instance_method`, `instance_methods`, `instance_variable_get`, `instance_variable_set`, `instance_variables`, `lambda`, `load`, `local_variables`, `loop`, `method`, `method_missing`, `methods`, `module_eval`, `name`, `object_id`, `open`, `p`, `print`, `printf`, `private_class_method`, `private_instance_methods`, `private_methods`, `proc`, `protected_instance_methods`, `protected_methods`, `public_class_method`, `public_instance_methods`, `public_methods`, `putc`, `puts`, `raise`, `rand`, `readline`, `readlines`, `require`, `scan`, `select`, `self`, `send`, `set_trace_func`, `singleton_methods`, `sleep`, `split`, `sprintf`, `srand`, `sub`, `syscall`, `system`, `taint`, `test`, `throw`, `to_a`, `to_s`, `trace_var`, `trap`, `untaint`, `untrace_var`, `warn`), NameBuiltin, nil}, {`__(FILE|LINE)__\b`, NameBuiltinPseudo, nil}, {"(?<!\\w)(<<-?)([\"`\\']?)([a-zA-Z_]\\w*)(\\2)(.*?\\n)", String, nil}, {`(<<-?)("|\')()(\2)(.*?\n)`, String, nil}, {`__END__`, CommentPreproc, Push("end-part")}, {"" /* 356 byte string literal not displayed */, ByGroups(Text, LiteralStringRegex), Push("multiline-regex")}, {`(?<=\(|,|\[)/`, LiteralStringRegex, Push("multiline-regex")}, {`(\s+)(/)(?![\s=])`, ByGroups(Text, LiteralStringRegex), Push("multiline-regex")}, {`(0_?[0-7]+(?:_[0-7]+)*)(\s*)([/?])?`, ByGroups(LiteralNumberOct, Text, Operator), nil}, {`(0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*)(\s*)([/?])?`, ByGroups(LiteralNumberHex, Text, Operator), nil}, {`(0b[01]+(?:_[01]+)*)(\s*)([/?])?`, ByGroups(LiteralNumberBin, Text, Operator), nil}, {`([\d]+(?:_\d+)*)(\s*)([/?])?`, ByGroups(LiteralNumberInteger, Text, Operator), nil}, {`@@[a-zA-Z_]\w*`, NameVariableClass, nil}, {`@[a-zA-Z_]\w*`, NameVariableInstance, nil}, {`\$\w+`, NameVariableGlobal, nil}, {"\\$[!@&`\\'+~=/\\\\,;.<>_*$?:\"^-]", NameVariableGlobal, nil}, {`\$-[0adFiIlpvw]`, NameVariableGlobal, nil}, {`::`, Operator, nil}, Include("strings"), {`\?(\\[MC]-)*(\\([\\abefnrstv#"\']|x[a-fA-F0-9]{1,2}|[0-7]{1,3})|\S)(?!\w)`, LiteralStringChar, nil}, {`[A-Z]\w+`, NameConstant, nil}, {Words(`(\.|::)`, ``, `*`, `**`, `-`, `+`, `-@`, `+@`, `/`, `%`, `&`, `|`, `^`, "`", `~`, `[]`, `[]=`, `<<`, `>>`, `<`, `<>`, `<=>`, `>`, `>=`, `==`, `===`), ByGroups(Operator, NameOperator), nil}, {"(\\.|::)([a-zA-Z_]\\w*[!?]?|[*%&^`~+\\-/\\[<>=])", ByGroups(Operator, Name), nil}, {`[a-zA-Z_]\w*[!?]?`, Name, nil}, {`(\[|\]|\*\*|<<?|>>?|>=|<=|<=>|=~|={3}|!~|&&?|\|\||\.{1,3})`, Operator, nil}, {`[-+/*%=<>&!^|~]=?`, Operator, nil}, {`[(){};,/?:\\]`, Punctuation, nil}, {`\s+`, Text, nil}, }, "funcname": { {`\(`, Punctuation, Push("defexpr")}, {"(?:([a-zA-Z_]\\w*)(\\.))?([a-zA-Z_]\\w*[!?]?|\\*\\*?|[-+]@?|[/%&|^`~]|\\[\\]=?|<<|>>|<=?>|>=?|===?)", ByGroups(NameClass, Operator, NameFunction), Pop(1)}, Default(Pop(1)), }, "classname": { {`\(`, Punctuation, Push("defexpr")}, {`<<`, Operator, Pop(1)}, {`[A-Z_]\w*`, NameClass, Pop(1)}, Default(Pop(1)), }, "defexpr": { {`(\))(\.|::)?`, ByGroups(Punctuation, Operator), Pop(1)}, {`\(`, Operator, Push()}, Include("root"), }, "in-intp": { {`\{`, LiteralStringInterpol, Push()}, {`\}`, LiteralStringInterpol, Pop(1)}, Include("root"), }, "string-intp": { {`#\{`, LiteralStringInterpol, Push("in-intp")}, {`#@@?[a-zA-Z_]\w*`, LiteralStringInterpol, nil}, {`#\$[a-zA-Z_]\w*`, LiteralStringInterpol, nil}, }, "string-intp-escaped": { Include("string-intp"), {`\\([\\abefnrstv#"\']|x[a-fA-F0-9]{1,2}|[0-7]{1,3})`, LiteralStringEscape, nil}, }, "interpolated-regex": { Include("string-intp"), {`[\\#]`, LiteralStringRegex, nil}, {`[^\\#]+`, LiteralStringRegex, nil}, }, "interpolated-string": { Include("string-intp"), {`[\\#]`, LiteralStringOther, nil}, {`[^\\#]+`, LiteralStringOther, nil}, }, "multiline-regex": { Include("string-intp"), {`\\\\`, LiteralStringRegex, nil}, {`\\/`, LiteralStringRegex, nil}, {`[\\#]`, LiteralStringRegex, nil}, {`[^\\/#]+`, LiteralStringRegex, nil}, {`/[mixounse]*`, LiteralStringRegex, Pop(1)}, }, "end-part": { {`.+`, CommentPreproc, Pop(1)}, }, "strings": { {`\:@{0,2}[a-zA-Z_]\w*[!?]?`, LiteralStringSymbol, nil}, {Words(`\:@{0,2}`, ``, `*`, `**`, `-`, `+`, `-@`, `+@`, `/`, `%`, `&`, `|`, `^`, "`", `~`, `[]`, `[]=`, `<<`, `>>`, `<`, `<>`, `<=>`, `>`, `>=`, `==`, `===`), LiteralStringSymbol, nil}, {`:'(\\\\|\\'|[^'])*'`, LiteralStringSymbol, nil}, {`'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil}, {`:"`, LiteralStringSymbol, Push("simple-sym")}, {`([a-zA-Z_]\w*)(:)(?!:)`, ByGroups(LiteralStringSymbol, Punctuation), nil}, {`"`, LiteralStringDouble, Push("simple-string")}, {"(?<!\\.)`", LiteralStringBacktick, Push("simple-backtick")}, {`%[QWx]?\{`, LiteralStringOther, Push("cb-intp-string")}, {`%[qsw]\{`, LiteralStringOther, Push("cb-string")}, {`%r\{`, LiteralStringRegex, Push("cb-regex")}, {`%[QWx]?\[`, LiteralStringOther, Push("sb-intp-string")}, {`%[qsw]\[`, LiteralStringOther, Push("sb-string")}, {`%r\[`, LiteralStringRegex, Push("sb-regex")}, {`%[QWx]?\(`, LiteralStringOther, Push("pa-intp-string")}, {`%[qsw]\(`, LiteralStringOther, Push("pa-string")}, {`%r\(`, LiteralStringRegex, Push("pa-regex")}, {`%[QWx]?<`, LiteralStringOther, Push("ab-intp-string")}, {`%[qsw]<`, LiteralStringOther, Push("ab-string")}, {`%r<`, LiteralStringRegex, Push("ab-regex")}, {`(%r([\W_]))((?:\\\2|(?!\2).)*)(\2[mixounse]*)`, String, nil}, {`%[qsw]([\W_])((?:\\\1|(?!\1).)*)\1`, LiteralStringOther, nil}, {`(%[QWx]([\W_]))((?:\\\2|(?!\2).)*)(\2)`, String, nil}, {`(?<=[-+/*%=<>&!^|~,(])(\s*)(%([\t ])(?:(?:\\\3|(?!\3).)*)\3)`, ByGroups(Text, LiteralStringOther, None), nil}, {`^(\s*)(%([\t ])(?:(?:\\\3|(?!\3).)*)\3)`, ByGroups(Text, LiteralStringOther, None), nil}, {`(%([^a-zA-Z0-9\s]))((?:\\\2|(?!\2).)*)(\2)`, String, nil}, }, "simple-string": { Include("string-intp-escaped"), {`[^\\"#]+`, LiteralStringDouble, nil}, {`[\\#]`, LiteralStringDouble, nil}, {`"`, LiteralStringDouble, Pop(1)}, }, "simple-sym": { Include("string-intp-escaped"), {`[^\\"#]+`, LiteralStringSymbol, nil}, {`[\\#]`, LiteralStringSymbol, nil}, {`"`, LiteralStringSymbol, Pop(1)}, }, "simple-backtick": { Include("string-intp-escaped"), {"[^\\\\`#]+", LiteralStringBacktick, nil}, {`[\\#]`, LiteralStringBacktick, nil}, {"`", LiteralStringBacktick, Pop(1)}, }, "cb-intp-string": { {`\\[\\{}]`, LiteralStringOther, nil}, {`\{`, LiteralStringOther, Push()}, {`\}`, LiteralStringOther, Pop(1)}, Include("string-intp-escaped"), {`[\\#{}]`, LiteralStringOther, nil}, {`[^\\#{}]+`, LiteralStringOther, nil}, }, "cb-string": { {`\\[\\{}]`, LiteralStringOther, nil}, {`\{`, LiteralStringOther, Push()}, {`\}`, LiteralStringOther, Pop(1)}, {`[\\#{}]`, LiteralStringOther, nil}, {`[^\\#{}]+`, LiteralStringOther, nil}, }, "cb-regex": { {`\\[\\{}]`, LiteralStringRegex, nil}, {`\{`, LiteralStringRegex, Push()}, {`\}[mixounse]*`, LiteralStringRegex, Pop(1)}, Include("string-intp"), {`[\\#{}]`, LiteralStringRegex, nil}, {`[^\\#{}]+`, LiteralStringRegex, nil}, }, "sb-intp-string": { {`\\[\\\[\]]`, LiteralStringOther, nil}, {`\[`, LiteralStringOther, Push()}, {`\]`, LiteralStringOther, Pop(1)}, Include("string-intp-escaped"), {`[\\#\[\]]`, LiteralStringOther, nil}, {`[^\\#\[\]]+`, LiteralStringOther, nil}, }, "sb-string": { {`\\[\\\[\]]`, LiteralStringOther, nil}, {`\[`, LiteralStringOther, Push()}, {`\]`, LiteralStringOther, Pop(1)}, {`[\\#\[\]]`, LiteralStringOther, nil}, {`[^\\#\[\]]+`, LiteralStringOther, nil}, }, "sb-regex": { {`\\[\\\[\]]`, LiteralStringRegex, nil}, {`\[`, LiteralStringRegex, Push()}, {`\][mixounse]*`, LiteralStringRegex, Pop(1)}, Include("string-intp"), {`[\\#\[\]]`, LiteralStringRegex, nil}, {`[^\\#\[\]]+`, LiteralStringRegex, nil}, }, "pa-intp-string": { {`\\[\\()]`, LiteralStringOther, nil}, {`\(`, LiteralStringOther, Push()}, {`\)`, LiteralStringOther, Pop(1)}, Include("string-intp-escaped"), {`[\\#()]`, LiteralStringOther, nil}, {`[^\\#()]+`, LiteralStringOther, nil}, }, "pa-string": { {`\\[\\()]`, LiteralStringOther, nil}, {`\(`, LiteralStringOther, Push()}, {`\)`, LiteralStringOther, Pop(1)}, {`[\\#()]`, LiteralStringOther, nil}, {`[^\\#()]+`, LiteralStringOther, nil}, }, "pa-regex": { {`\\[\\()]`, LiteralStringRegex, nil}, {`\(`, LiteralStringRegex, Push()}, {`\)[mixounse]*`, LiteralStringRegex, Pop(1)}, Include("string-intp"), {`[\\#()]`, LiteralStringRegex, nil}, {`[^\\#()]+`, LiteralStringRegex, nil}, }, "ab-intp-string": { {`\\[\\<>]`, LiteralStringOther, nil}, {`<`, LiteralStringOther, Push()}, {`>`, LiteralStringOther, Pop(1)}, Include("string-intp-escaped"), {`[\\#<>]`, LiteralStringOther, nil}, {`[^\\#<>]+`, LiteralStringOther, nil}, }, "ab-string": { {`\\[\\<>]`, LiteralStringOther, nil}, {`<`, LiteralStringOther, Push()}, {`>`, LiteralStringOther, Pop(1)}, {`[\\#<>]`, LiteralStringOther, nil}, {`[^\\#<>]+`, LiteralStringOther, nil}, }, "ab-regex": { {`\\[\\<>]`, LiteralStringRegex, nil}, {`<`, LiteralStringRegex, Push()}, {`>[mixounse]*`, LiteralStringRegex, Pop(1)}, Include("string-intp"), {`[\\#<>]`, LiteralStringRegex, nil}, {`[^\\#<>]+`, LiteralStringRegex, nil}, }, }, ))
Ruby lexer.
var Rust = Register(MustNewLexer( &Config{ Name: "Rust", Aliases: []string{"rust"}, Filenames: []string{"*.rs", "*.rs.in"}, MimeTypes: []string{"text/rust"}, }, Rules{ "root": { {`#![^[\r\n].*$`, CommentPreproc, nil}, Default(Push("base")), }, "base": { {`\n`, TextWhitespace, nil}, {`\s+`, TextWhitespace, nil}, {`//!.*?\n`, LiteralStringDoc, nil}, {`///(\n|[^/].*?\n)`, LiteralStringDoc, nil}, {`//(.*?)\n`, CommentSingle, nil}, {`/\*\*(\n|[^/*])`, LiteralStringDoc, Push("doccomment")}, {`/\*!`, LiteralStringDoc, Push("doccomment")}, {`/\*`, CommentMultiline, Push("comment")}, {`\$([a-zA-Z_]\w*|\(,?|\),?|,?)`, CommentPreproc, nil}, {Words(``, `\b`, `as`, `box`, `const`, `crate`, `else`, `extern`, `for`, `if`, `impl`, `in`, `loop`, `match`, `move`, `mut`, `pub`, `ref`, `return`, `static`, `super`, `trait`, `unsafe`, `use`, `where`, `while`), Keyword, nil}, {Words(``, `\b`, `abstract`, `alignof`, `become`, `do`, `final`, `macro`, `offsetof`, `override`, `priv`, `proc`, `pure`, `sizeof`, `typeof`, `unsized`, `virtual`, `yield`), KeywordReserved, nil}, {`(true|false)\b`, KeywordConstant, nil}, {`mod\b`, Keyword, Push("modname")}, {`let\b`, KeywordDeclaration, nil}, {`fn\b`, Keyword, Push("funcname")}, {`(struct|enum|type|union)\b`, Keyword, Push("typename")}, {`(default)(\s+)(type|fn)\b`, ByGroups(Keyword, Text, Keyword), nil}, {Words(``, `\b`, `u8`, `u16`, `u32`, `u64`, `i8`, `i16`, `i32`, `i64`, `usize`, `isize`, `f32`, `f64`, `str`, `bool`), KeywordType, nil}, {`self\b`, NameBuiltinPseudo, nil}, {Words(``, `\b`, `Copy`, `Send`, `Sized`, `Sync`, `Drop`, `Fn`, `FnMut`, `FnOnce`, `Box`, `ToOwned`, `Clone`, `PartialEq`, `PartialOrd`, `Eq`, `Ord`, `AsRef`, `AsMut`, `Into`, `From`, `Default`, `Iterator`, `Extend`, `IntoIterator`, `DoubleEndedIterator`, `ExactSizeIterator`, `Option`, `Some`, `None`, `Result`, `Ok`, `Err`, `SliceConcatExt`, `String`, `ToString`, `Vec`), NameBuiltin, nil}, {`::\b`, Text, nil}, {`(?::|->)`, Text, Push("typename")}, {`(break|continue)(\s*)(\'[A-Za-z_]\w*)?`, ByGroups(Keyword, TextWhitespace, NameLabel), nil}, {`'(\\['"\\nrt]|\\x[0-7][0-9a-fA-F]|\\0|\\u\{[0-9a-fA-F]{1,6}\}|.)'`, LiteralStringChar, nil}, {`b'(\\['"\\nrt]|\\x[0-9a-fA-F]{2}|\\0|\\u\{[0-9a-fA-F]{1,6}\}|.)'`, LiteralStringChar, nil}, {`0b[01_]+`, LiteralNumberBin, Push("number_lit")}, {`0o[0-7_]+`, LiteralNumberOct, Push("number_lit")}, {`0[xX][0-9a-fA-F_]+`, LiteralNumberHex, Push("number_lit")}, {`[0-9][0-9_]*(\.[0-9_]+[eE][+\-]?[0-9_]+|\.[0-9_]*(?!\.)|[eE][+\-]?[0-9_]+)`, LiteralNumberFloat, Push("number_lit")}, {`[0-9][0-9_]*`, LiteralNumberInteger, Push("number_lit")}, {`b"`, LiteralString, Push("bytestring")}, {`"`, LiteralString, Push("string")}, {`b?r(#*)".*?"\1`, LiteralString, nil}, {`'static`, NameBuiltin, nil}, {`'[a-zA-Z_]\w*`, NameAttribute, nil}, {`[{}()\[\],.;]`, Punctuation, nil}, {`[+\-*/%&|<>^!~@=:?]`, Operator, nil}, {`[a-zA-Z_]\w*`, Name, nil}, {`#!?\[`, CommentPreproc, Push("attribute[")}, {`([A-Za-z_]\w*)(!)(\s*)([A-Za-z_]\w*)?(\s*)(\{)`, ByGroups(CommentPreproc, Punctuation, TextWhitespace, Name, TextWhitespace, Punctuation), Push("macro{")}, {`([A-Za-z_]\w*)(!)(\s*)([A-Za-z_]\w*)?(\()`, ByGroups(CommentPreproc, Punctuation, TextWhitespace, Name, Punctuation), Push("macro(")}, }, "comment": { {`[^*/]+`, CommentMultiline, nil}, {`/\*`, CommentMultiline, Push()}, {`\*/`, CommentMultiline, Pop(1)}, {`[*/]`, CommentMultiline, nil}, }, "doccomment": { {`[^*/]+`, LiteralStringDoc, nil}, {`/\*`, LiteralStringDoc, Push()}, {`\*/`, LiteralStringDoc, Pop(1)}, {`[*/]`, LiteralStringDoc, nil}, }, "modname": { {`\s+`, Text, nil}, {`[a-zA-Z_]\w*`, NameNamespace, Pop(1)}, Default(Pop(1)), }, "funcname": { {`\s+`, Text, nil}, {`[a-zA-Z_]\w*`, NameFunction, Pop(1)}, Default(Pop(1)), }, "typename": { {`\s+`, Text, nil}, {`&`, KeywordPseudo, nil}, {Words(``, `\b`, `Copy`, `Send`, `Sized`, `Sync`, `Drop`, `Fn`, `FnMut`, `FnOnce`, `Box`, `ToOwned`, `Clone`, `PartialEq`, `PartialOrd`, `Eq`, `Ord`, `AsRef`, `AsMut`, `Into`, `From`, `Default`, `Iterator`, `Extend`, `IntoIterator`, `DoubleEndedIterator`, `ExactSizeIterator`, `Option`, `Some`, `None`, `Result`, `Ok`, `Err`, `SliceConcatExt`, `String`, `ToString`, `Vec`), NameBuiltin, nil}, {Words(``, `\b`, `u8`, `u16`, `u32`, `u64`, `i8`, `i16`, `i32`, `i64`, `usize`, `isize`, `f32`, `f64`, `str`, `bool`), KeywordType, nil}, {`[a-zA-Z_]\w*`, NameClass, Pop(1)}, Default(Pop(1)), }, "number_lit": { {`[ui](8|16|32|64|size)`, Keyword, Pop(1)}, {`f(32|64)`, Keyword, Pop(1)}, Default(Pop(1)), }, "string": { {`"`, LiteralString, Pop(1)}, {`\\['"\\nrt]|\\x[0-7][0-9a-fA-F]|\\0|\\u\{[0-9a-fA-F]{1,6}\}`, LiteralStringEscape, nil}, {`[^\\"]+`, LiteralString, nil}, {`\\`, LiteralString, nil}, }, "bytestring": { {`\\x[89a-fA-F][0-9a-fA-F]`, LiteralStringEscape, nil}, Include("string"), }, "macro{": { {`\{`, Operator, Push()}, {`\}`, Operator, Pop(1)}, }, "macro(": { {`\(`, Operator, Push()}, {`\)`, Operator, Pop(1)}, }, "attribute_common": { {`"`, LiteralString, Push("string")}, {`\[`, CommentPreproc, Push("attribute[")}, {`\(`, CommentPreproc, Push("attribute(")}, }, "attribute[": { Include("attribute_common"), {`\];?`, CommentPreproc, Pop(1)}, {`[^"\]]+`, CommentPreproc, nil}, }, "attribute(": { Include("attribute_common"), {`\);?`, CommentPreproc, Pop(1)}, {`[^")]+`, CommentPreproc, nil}, }, }, ))
Rust lexer.
var Sass = Register(MustNewLexer( &Config{ Name: "Sass", Aliases: []string{"sass"}, Filenames: []string{"*.sass"}, MimeTypes: []string{"text/x-sass"}, CaseInsensitive: true, }, Rules{ "root": { {`[ \t]*\n`, Text, nil}, }, "content": { {`@import`, Keyword, Push("import")}, {`@for`, Keyword, Push("for")}, {`@(debug|warn|if|while)`, Keyword, Push("value")}, {`(@mixin)( [\w-]+)`, ByGroups(Keyword, NameFunction), Push("value")}, {`(@include)( [\w-]+)`, ByGroups(Keyword, NameDecorator), Push("value")}, {`@extend`, Keyword, Push("selector")}, {`@[\w-]+`, Keyword, Push("selector")}, {`=[\w-]+`, NameFunction, Push("value")}, {`\+[\w-]+`, NameDecorator, Push("value")}, {`([!$][\w-]\w*)([ \t]*(?:(?:\|\|)?=|:))`, ByGroups(NameVariable, Operator), Push("value")}, {`:`, NameAttribute, Push("old-style-attr")}, {`(?=.+?[=:]([^a-z]|$))`, NameAttribute, Push("new-style-attr")}, Default(Push("selector")), }, "single-comment": { {`.+`, CommentSingle, nil}, {`\n`, Text, Push("root")}, }, "multi-comment": { {`.+`, CommentMultiline, nil}, {`\n`, Text, Push("root")}, }, "import": { {`[ \t]+`, Text, nil}, {`\S+`, LiteralString, nil}, {`\n`, Text, Push("root")}, }, "old-style-attr": { {`[^\s:="\[]+`, NameAttribute, nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, {`[ \t]*=`, Operator, Push("value")}, Default(Push("value")), }, "new-style-attr": { {`[^\s:="\[]+`, NameAttribute, nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, {`[ \t]*[=:]`, Operator, Push("value")}, }, "inline-comment": { {`(\\#|#(?=[^\n{])|\*(?=[^\n/])|[^\n#*])+`, CommentMultiline, nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, {`\*/`, Comment, Pop(1)}, }, "value": { {`[ \t]+`, Text, nil}, {`[!$][\w-]+`, NameVariable, nil}, {`url\(`, LiteralStringOther, Push("string-url")}, {`[a-z_-][\w-]*(?=\()`, NameFunction, nil}, {Words(``, `\b`, `align-content`, `align-items`, `align-self`, `alignment-baseline`, `all`, `animation`, `animation-delay`, `animation-direction`, `animation-duration`, `animation-fill-mode`, `animation-iteration-count`, `animation-name`, `animation-play-state`, `animation-timing-function`, `appearance`, `azimuth`, `backface-visibility`, `background`, `background-attachment`, `background-blend-mode`, `background-clip`, `background-color`, `background-image`, `background-origin`, `background-position`, `background-repeat`, `background-size`, `baseline-shift`, `bookmark-label`, `bookmark-level`, `bookmark-state`, `border`, `border-bottom`, `border-bottom-color`, `border-bottom-left-radius`, `border-bottom-right-radius`, `border-bottom-style`, `border-bottom-width`, `border-boundary`, `border-collapse`, `border-color`, `border-image`, `border-image-outset`, `border-image-repeat`, `border-image-slice`, `border-image-source`, `border-image-width`, `border-left`, `border-left-color`, `border-left-style`, `border-left-width`, `border-radius`, `border-right`, `border-right-color`, `border-right-style`, `border-right-width`, `border-spacing`, `border-style`, `border-top`, `border-top-color`, `border-top-left-radius`, `border-top-right-radius`, `border-top-style`, `border-top-width`, `border-width`, `bottom`, `box-decoration-break`, `box-shadow`, `box-sizing`, `box-snap`, `box-suppress`, `break-after`, `break-before`, `break-inside`, `caption-side`, `caret`, `caret-animation`, `caret-color`, `caret-shape`, `chains`, `clear`, `clip`, `clip-path`, `clip-rule`, `color`, `color-interpolation-filters`, `column-count`, `column-fill`, `column-gap`, `column-rule`, `column-rule-color`, `column-rule-style`, `column-rule-width`, `column-span`, `column-width`, `columns`, `content`, `counter-increment`, `counter-reset`, `counter-set`, `crop`, `cue`, `cue-after`, `cue-before`, `cursor`, `direction`, `display`, `dominant-baseline`, `elevation`, `empty-cells`, `filter`, `flex`, `flex-basis`, `flex-direction`, `flex-flow`, `flex-grow`, `flex-shrink`, `flex-wrap`, `float`, `float-defer`, `float-offset`, `float-reference`, `flood-color`, `flood-opacity`, `flow`, `flow-from`, `flow-into`, `font`, `font-family`, `font-feature-settings`, `font-kerning`, `font-language-override`, `font-size`, `font-size-adjust`, `font-stretch`, `font-style`, `font-synthesis`, `font-variant`, `font-variant-alternates`, `font-variant-caps`, `font-variant-east-asian`, `font-variant-ligatures`, `font-variant-numeric`, `font-variant-position`, `font-weight`, `footnote-display`, `footnote-policy`, `glyph-orientation-vertical`, `grid`, `grid-area`, `grid-auto-columns`, `grid-auto-flow`, `grid-auto-rows`, `grid-column`, `grid-column-end`, `grid-column-gap`, `grid-column-start`, `grid-gap`, `grid-row`, `grid-row-end`, `grid-row-gap`, `grid-row-start`, `grid-template`, `grid-template-areas`, `grid-template-columns`, `grid-template-rows`, `hanging-punctuation`, `height`, `hyphenate-character`, `hyphenate-limit-chars`, `hyphenate-limit-last`, `hyphenate-limit-lines`, `hyphenate-limit-zone`, `hyphens`, `image-orientation`, `image-resolution`, `initial-letter`, `initial-letter-align`, `initial-letter-wrap`, `isolation`, `justify-content`, `justify-items`, `justify-self`, `left`, `letter-spacing`, `lighting-color`, `line-break`, `line-grid`, `line-height`, `line-snap`, `list-style`, `list-style-image`, `list-style-position`, `list-style-type`, `margin`, `margin-bottom`, `margin-left`, `margin-right`, `margin-top`, `marker-side`, `marquee-direction`, `marquee-loop`, `marquee-speed`, `marquee-style`, `mask`, `mask-border`, `mask-border-mode`, `mask-border-outset`, `mask-border-repeat`, `mask-border-slice`, `mask-border-source`, `mask-border-width`, `mask-clip`, `mask-composite`, `mask-image`, `mask-mode`, `mask-origin`, `mask-position`, `mask-repeat`, `mask-size`, `mask-type`, `max-height`, `max-lines`, `max-width`, `min-height`, `min-width`, `mix-blend-mode`, `motion`, `motion-offset`, `motion-path`, `motion-rotation`, `move-to`, `nav-down`, `nav-left`, `nav-right`, `nav-up`, `object-fit`, `object-position`, `offset-after`, `offset-before`, `offset-end`, `offset-start`, `opacity`, `order`, `orphans`, `outline`, `outline-color`, `outline-offset`, `outline-style`, `outline-width`, `overflow`, `overflow-style`, `overflow-wrap`, `overflow-x`, `overflow-y`, `padding`, `padding-bottom`, `padding-left`, `padding-right`, `padding-top`, `page`, `page-break-after`, `page-break-before`, `page-break-inside`, `page-policy`, `pause`, `pause-after`, `pause-before`, `perspective`, `perspective-origin`, `pitch`, `pitch-range`, `play-during`, `polar-angle`, `polar-distance`, `position`, `presentation-level`, `quotes`, `region-fragment`, `resize`, `rest`, `rest-after`, `rest-before`, `richness`, `right`, `rotation`, `rotation-point`, `ruby-align`, `ruby-merge`, `ruby-position`, `running`, `scroll-snap-coordinate`, `scroll-snap-destination`, `scroll-snap-points-x`, `scroll-snap-points-y`, `scroll-snap-type`, `shape-image-threshold`, `shape-inside`, `shape-margin`, `shape-outside`, `size`, `speak`, `speak-as`, `speak-header`, `speak-numeral`, `speak-punctuation`, `speech-rate`, `stress`, `string-set`, `tab-size`, `table-layout`, `text-align`, `text-align-last`, `text-combine-upright`, `text-decoration`, `text-decoration-color`, `text-decoration-line`, `text-decoration-skip`, `text-decoration-style`, `text-emphasis`, `text-emphasis-color`, `text-emphasis-position`, `text-emphasis-style`, `text-indent`, `text-justify`, `text-orientation`, `text-overflow`, `text-shadow`, `text-space-collapse`, `text-space-trim`, `text-spacing`, `text-transform`, `text-underline-position`, `text-wrap`, `top`, `transform`, `transform-origin`, `transform-style`, `transition`, `transition-delay`, `transition-duration`, `transition-property`, `transition-timing-function`, `unicode-bidi`, `user-select`, `vertical-align`, `visibility`, `voice-balance`, `voice-duration`, `voice-family`, `voice-pitch`, `voice-range`, `voice-rate`, `voice-stress`, `voice-volume`, `volume`, `white-space`, `widows`, `width`, `will-change`, `word-break`, `word-spacing`, `word-wrap`, `wrap-after`, `wrap-before`, `wrap-flow`, `wrap-inside`, `wrap-through`, `writing-mode`, `z-index`, `above`, `absolute`, `always`, `armenian`, `aural`, `auto`, `avoid`, `baseline`, `behind`, `below`, `bidi-override`, `blink`, `block`, `bold`, `bolder`, `both`, `capitalize`, `center-left`, `center-right`, `center`, `circle`, `cjk-ideographic`, `close-quote`, `collapse`, `condensed`, `continuous`, `crop`, `crosshair`, `cross`, `cursive`, `dashed`, `decimal-leading-zero`, `decimal`, `default`, `digits`, `disc`, `dotted`, `double`, `e-resize`, `embed`, `extra-condensed`, `extra-expanded`, `expanded`, `fantasy`, `far-left`, `far-right`, `faster`, `fast`, `fixed`, `georgian`, `groove`, `hebrew`, `help`, `hidden`, `hide`, `higher`, `high`, `hiragana-iroha`, `hiragana`, `icon`, `inherit`, `inline-table`, `inline`, `inset`, `inside`, `invert`, `italic`, `justify`, `katakana-iroha`, `katakana`, `landscape`, `larger`, `large`, `left-side`, `leftwards`, `level`, `lighter`, `line-through`, `list-item`, `loud`, `lower-alpha`, `lower-greek`, `lower-roman`, `lowercase`, `ltr`, `lower`, `low`, `medium`, `message-box`, `middle`, `mix`, `monospace`, `n-resize`, `narrower`, `ne-resize`, `no-close-quote`, `no-open-quote`, `no-repeat`, `none`, `normal`, `nowrap`, `nw-resize`, `oblique`, `once`, `open-quote`, `outset`, `outside`, `overline`, `pointer`, `portrait`, `px`, `relative`, `repeat-x`, `repeat-y`, `repeat`, `rgb`, `ridge`, `right-side`, `rightwards`, `s-resize`, `sans-serif`, `scroll`, `se-resize`, `semi-condensed`, `semi-expanded`, `separate`, `serif`, `show`, `silent`, `slow`, `slower`, `small-caps`, `small-caption`, `smaller`, `soft`, `solid`, `spell-out`, `square`, `static`, `status-bar`, `super`, `sw-resize`, `table-caption`, `table-cell`, `table-column`, `table-column-group`, `table-footer-group`, `table-header-group`, `table-row`, `table-row-group`, `text`, `text-bottom`, `text-top`, `thick`, `thin`, `transparent`, `ultra-condensed`, `ultra-expanded`, `underline`, `upper-alpha`, `upper-latin`, `upper-roman`, `uppercase`, `url`, `visible`, `w-resize`, `wait`, `wider`, `x-fast`, `x-high`, `x-large`, `x-loud`, `x-low`, `x-small`, `x-soft`, `xx-large`, `xx-small`, `yes`), NameConstant, nil}, {Words(``, `\b`, `aliceblue`, `antiquewhite`, `aqua`, `aquamarine`, `azure`, `beige`, `bisque`, `black`, `blanchedalmond`, `blue`, `blueviolet`, `brown`, `burlywood`, `cadetblue`, `chartreuse`, `chocolate`, `coral`, `cornflowerblue`, `cornsilk`, `crimson`, `cyan`, `darkblue`, `darkcyan`, `darkgoldenrod`, `darkgray`, `darkgreen`, `darkgrey`, `darkkhaki`, `darkmagenta`, `darkolivegreen`, `darkorange`, `darkorchid`, `darkred`, `darksalmon`, `darkseagreen`, `darkslateblue`, `darkslategray`, `darkslategrey`, `darkturquoise`, `darkviolet`, `deeppink`, `deepskyblue`, `dimgray`, `dimgrey`, `dodgerblue`, `firebrick`, `floralwhite`, `forestgreen`, `fuchsia`, `gainsboro`, `ghostwhite`, `gold`, `goldenrod`, `gray`, `green`, `greenyellow`, `grey`, `honeydew`, `hotpink`, `indianred`, `indigo`, `ivory`, `khaki`, `lavender`, `lavenderblush`, `lawngreen`, `lemonchiffon`, `lightblue`, `lightcoral`, `lightcyan`, `lightgoldenrodyellow`, `lightgray`, `lightgreen`, `lightgrey`, `lightpink`, `lightsalmon`, `lightseagreen`, `lightskyblue`, `lightslategray`, `lightslategrey`, `lightsteelblue`, `lightyellow`, `lime`, `limegreen`, `linen`, `magenta`, `maroon`, `mediumaquamarine`, `mediumblue`, `mediumorchid`, `mediumpurple`, `mediumseagreen`, `mediumslateblue`, `mediumspringgreen`, `mediumturquoise`, `mediumvioletred`, `midnightblue`, `mintcream`, `mistyrose`, `moccasin`, `navajowhite`, `navy`, `oldlace`, `olive`, `olivedrab`, `orange`, `orangered`, `orchid`, `palegoldenrod`, `palegreen`, `paleturquoise`, `palevioletred`, `papayawhip`, `peachpuff`, `peru`, `pink`, `plum`, `powderblue`, `purple`, `rebeccapurple`, `red`, `rosybrown`, `royalblue`, `saddlebrown`, `salmon`, `sandybrown`, `seagreen`, `seashell`, `sienna`, `silver`, `skyblue`, `slateblue`, `slategray`, `slategrey`, `snow`, `springgreen`, `steelblue`, `tan`, `teal`, `thistle`, `tomato`, `turquoise`, `violet`, `wheat`, `white`, `whitesmoke`, `yellow`, `yellowgreen`, `transparent`), NameEntity, nil}, {Words(``, `\b`, `black`, `silver`, `gray`, `white`, `maroon`, `red`, `purple`, `fuchsia`, `green`, `lime`, `olive`, `yellow`, `navy`, `blue`, `teal`, `aqua`), NameBuiltin, nil}, {`\!(important|default)`, NameException, nil}, {`(true|false)`, NamePseudo, nil}, {`(and|or|not)`, OperatorWord, nil}, {`/\*`, CommentMultiline, Push("inline-comment")}, {`//[^\n]*`, CommentSingle, nil}, {`\#[a-z0-9]{1,6}`, LiteralNumberHex, nil}, {`(-?\d+)(\%|[a-z]+)?`, ByGroups(LiteralNumberInteger, KeywordType), nil}, {`(-?\d*\.\d+)(\%|[a-z]+)?`, ByGroups(LiteralNumberFloat, KeywordType), nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, {`[~^*!&%<>|+=@:,./?-]+`, Operator, nil}, {`[\[\]()]+`, Punctuation, nil}, {`"`, LiteralStringDouble, Push("string-double")}, {`'`, LiteralStringSingle, Push("string-single")}, {`[a-z_-][\w-]*`, Name, nil}, {`\n`, Text, Push("root")}, }, "interpolation": { {`\}`, LiteralStringInterpol, Pop(1)}, Include("value"), }, "selector": { {`[ \t]+`, Text, nil}, {`\:`, NameDecorator, Push("pseudo-class")}, {`\.`, NameClass, Push("class")}, {`\#`, NameNamespace, Push("id")}, {`[\w-]+`, NameTag, nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, {`&`, Keyword, nil}, {`[~^*!&\[\]()<>|+=@:;,./?-]`, Operator, nil}, {`"`, LiteralStringDouble, Push("string-double")}, {`'`, LiteralStringSingle, Push("string-single")}, {`\n`, Text, Push("root")}, }, "string-double": { {`(\\.|#(?=[^\n{])|[^\n"#])+`, LiteralStringDouble, nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, {`"`, LiteralStringDouble, Pop(1)}, }, "string-single": { {`(\\.|#(?=[^\n{])|[^\n'#])+`, LiteralStringDouble, nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, {`'`, LiteralStringDouble, Pop(1)}, }, "string-url": { {`(\\#|#(?=[^\n{])|[^\n#)])+`, LiteralStringOther, nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, {`\)`, LiteralStringOther, Pop(1)}, }, "pseudo-class": { {`[\w-]+`, NameDecorator, nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, Default(Pop(1)), }, "class": { {`[\w-]+`, NameClass, nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, Default(Pop(1)), }, "id": { {`[\w-]+`, NameNamespace, nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, Default(Pop(1)), }, "for": { {`(from|to|through)`, OperatorWord, nil}, Include("value"), }, }, ))
Sass lexer.
var Scala = Register(MustNewLexer( &Config{ Name: "Scala", Aliases: []string{"scala"}, Filenames: []string{"*.scala"}, MimeTypes: []string{"text/x-scala"}, DotAll: true, }, Rules{ "root": { {`(class|trait|object)(\s+)`, ByGroups(Keyword, Text), Push("class")}, {`[^\S\n]+`, Text, nil}, {`//.*?\n`, CommentSingle, nil}, {`/\*`, CommentMultiline, Push("comment")}, {"" /* 2626 byte string literal not displayed */, NameDecorator, nil}, {"" /* 263 byte string literal not displayed */, Keyword, nil}, {"" /* 524 byte string literal not displayed */, Keyword, Push("type")}, {"" /* 4204 byte string literal not displayed */, NameClass, nil}, {`(true|false|null)\b`, KeywordConstant, nil}, {`(import|package)(\s+)`, ByGroups(Keyword, Text), Push("import")}, {`(type)(\s+)`, ByGroups(Keyword, Text), Push("type")}, {`""".*?"""(?!")`, LiteralString, nil}, {`"(\\\\|\\"|[^"])*"`, LiteralString, nil}, {`'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'`, LiteralStringChar, nil}, {"" /* 2626 byte string literal not displayed */, TextSymbol, nil}, {`[fs]"""`, LiteralString, Push("interptriplestring")}, {`[fs]"`, LiteralString, Push("interpstring")}, {`raw"(\\\\|\\"|[^"])*"`, LiteralString, nil}, {"" /* 2625 byte string literal not displayed */, Name, nil}, {"`[^`]+`", Name, nil}, {`\[`, Operator, Push("typeparam")}, {`[(){};,.#]`, Operator, nil}, {"" /* 519 byte string literal not displayed */, Operator, nil}, {`([0-9][0-9]*\.[0-9]*|\.[0-9]+)([eE][+-]?[0-9]+)?[fFdD]?`, LiteralNumberFloat, nil}, {`0x[0-9a-fA-F]+`, LiteralNumberHex, nil}, {`[0-9]+L?`, LiteralNumberInteger, nil}, {`\n`, Text, nil}, }, "class": { {"" /* 6102 byte string literal not displayed */, ByGroups(NameClass, Text, Operator), Push("typeparam")}, {`\s+`, Text, nil}, {`\{`, Operator, Pop(1)}, {`\(`, Operator, Pop(1)}, {`//.*?\n`, CommentSingle, Pop(1)}, {"" /* 6089 byte string literal not displayed */, NameClass, Pop(1)}, }, "type": { {`\s+`, Text, nil}, {`<[%:]|>:|[#_]|forSome|type`, Keyword, nil}, {`([,);}]|=>|=|⇒)(\s*)`, ByGroups(Operator, Text), Pop(1)}, {`[({]`, Operator, Push()}, {"" /* 12205 byte string literal not displayed */, ByGroups(KeywordType, Text, Operator), Push("#pop", "typeparam")}, {"" /* 12201 byte string literal not displayed */, ByGroups(KeywordType, Text), Pop(1)}, {`//.*?\n`, CommentSingle, Pop(1)}, {"" /* 6093 byte string literal not displayed */, KeywordType, nil}, }, "typeparam": { {`[\s,]+`, Text, nil}, {`<[%:]|=>|>:|[#_⇒]|forSome|type`, Keyword, nil}, {`([\])}])`, Operator, Pop(1)}, {`[(\[{]`, Operator, Push()}, {"" /* 6093 byte string literal not displayed */, KeywordType, nil}, }, "comment": { {`[^/*]+`, CommentMultiline, nil}, {`/\*`, CommentMultiline, Push()}, {`\*/`, CommentMultiline, Pop(1)}, {`[*/]`, CommentMultiline, nil}, }, "import": { {"" /* 2631 byte string literal not displayed */, NameNamespace, Pop(1)}, }, "interpstringcommon": { {`[^"$\\]+`, LiteralString, nil}, {`\$\$`, LiteralString, nil}, {"" /* 2096 byte string literal not displayed */, LiteralStringInterpol, nil}, {`\$\{`, LiteralStringInterpol, Push("interpbrace")}, {`\\.`, LiteralString, nil}, }, "interptriplestring": { {`"""(?!")`, LiteralString, Pop(1)}, {`"`, LiteralString, nil}, Include("interpstringcommon"), }, "interpstring": { {`"`, LiteralString, Pop(1)}, Include("interpstringcommon"), }, "interpbrace": { {`\}`, LiteralStringInterpol, Pop(1)}, {`\{`, LiteralStringInterpol, Push()}, Include("root"), }, }, ))
Scala lexer.
var SchemeLang = Register(MustNewLexer( &Config{ Name: "Scheme", Aliases: []string{"scheme", "scm"}, Filenames: []string{"*.scm", "*.ss"}, MimeTypes: []string{"text/x-scheme", "application/x-scheme"}, }, Rules{ "root": { {`;.*$`, CommentSingle, nil}, {`#\|`, CommentMultiline, Push("multiline-comment")}, {`#;\s*\(`, Comment, Push("commented-form")}, {`#!r6rs`, Comment, nil}, {`\s+`, Text, nil}, {`-?\d+\.\d+`, LiteralNumberFloat, nil}, {`-?\d+`, LiteralNumberInteger, nil}, {`"(\\\\|\\"|[^"])*"`, LiteralString, nil}, {`'[\w!$%&*+,/:<=>?@^~|-]+`, LiteralStringSymbol, nil}, {`#\\([()/'\"._!§$%& ?=+-]|[a-zA-Z0-9]+)`, LiteralStringChar, nil}, {`(#t|#f)`, NameConstant, nil}, {"('|#|`|,@|,|\\.)", Operator, nil}, {"" /* 208 byte string literal not displayed */, Keyword, nil}, {`(?<='\()[\w!$%&*+,/:<=>?@^~|-]+`, NameVariable, nil}, {`(?<=#\()[\w!$%&*+,/:<=>?@^~|-]+`, NameVariable, nil}, {"" /* 2291 byte string literal not displayed */, NameBuiltin, nil}, {`(?<=\()[\w!$%&*+,/:<=>?@^~|-]+`, NameFunction, nil}, {`[\w!$%&*+,/:<=>?@^~|-]+`, NameVariable, nil}, {`(\(|\))`, Punctuation, nil}, {`(\[|\])`, Punctuation, nil}, }, "multiline-comment": { {`#\|`, CommentMultiline, Push()}, {`\|#`, CommentMultiline, Pop(1)}, {`[^|#]+`, CommentMultiline, nil}, {`[|#]`, CommentMultiline, nil}, }, "commented-form": { {`\(`, Comment, Push()}, {`\)`, Comment, Pop(1)}, {`[^()]+`, Comment, nil}, }, }, ))
Scheme lexer.
var Scilab = Register(MustNewLexer( &Config{ Name: "Scilab", Aliases: []string{"scilab"}, Filenames: []string{"*.sci", "*.sce", "*.tst"}, MimeTypes: []string{"text/scilab"}, }, Rules{ "root": { {`//.*?$`, CommentSingle, nil}, {`^\s*function`, Keyword, Push("deffunc")}, {Words(``, `\b`, `__FILE__`, `__LINE__`, `break`, `case`, `catch`, `classdef`, `continue`, `do`, `else`, `elseif`, `end`, `end_try_catch`, `end_unwind_protect`, `endclassdef`, `endevents`, `endfor`, `endfunction`, `endif`, `endmethods`, `endproperties`, `endswitch`, `endwhile`, `events`, `for`, `function`, `get`, `global`, `if`, `methods`, `otherwise`, `persistent`, `properties`, `return`, `set`, `static`, `switch`, `try`, `until`, `unwind_protect`, `unwind_protect_cleanup`, `while`), Keyword, nil}, {Words(``, `\b`, `!!_invoke_`, `%H5Object_e`, `%H5Object_fieldnames`, `%H5Object_p`, `%XMLAttr_6`, `%XMLAttr_e`, `%XMLAttr_i_XMLElem`, `%XMLAttr_length`, `%XMLAttr_p`, `%XMLAttr_size`, `%XMLDoc_6`, `%XMLDoc_e`, `%XMLDoc_i_XMLList`, `%XMLDoc_p`, `%XMLElem_6`, `%XMLElem_e`, `%XMLElem_i_XMLDoc`, `%XMLElem_i_XMLElem`, `%XMLElem_i_XMLList`, `%XMLElem_p`, `%XMLList_6`, `%XMLList_e`, `%XMLList_i_XMLElem`, `%XMLList_i_XMLList`, `%XMLList_length`, `%XMLList_p`, `%XMLList_size`, `%XMLNs_6`, `%XMLNs_e`, `%XMLNs_i_XMLElem`, `%XMLNs_p`, `%XMLSet_6`, `%XMLSet_e`, `%XMLSet_length`, `%XMLSet_p`, `%XMLSet_size`, `%XMLValid_p`, `%_EClass_6`, `%_EClass_e`, `%_EClass_p`, `%_EObj_0`, `%_EObj_1__EObj`, `%_EObj_1_b`, `%_EObj_1_c`, `%_EObj_1_i`, `%_EObj_1_s`, `%_EObj_2__EObj`, `%_EObj_2_b`, `%_EObj_2_c`, `%_EObj_2_i`, `%_EObj_2_s`, `%_EObj_3__EObj`, `%_EObj_3_b`, `%_EObj_3_c`, `%_EObj_3_i`, `%_EObj_3_s`, `%_EObj_4__EObj`, `%_EObj_4_b`, `%_EObj_4_c`, `%_EObj_4_i`, `%_EObj_4_s`, `%_EObj_5`, `%_EObj_6`, `%_EObj_a__EObj`, `%_EObj_a_b`, `%_EObj_a_c`, `%_EObj_a_i`, `%_EObj_a_s`, `%_EObj_d__EObj`, `%_EObj_d_b`, `%_EObj_d_c`, `%_EObj_d_i`, `%_EObj_d_s`, `%_EObj_disp`, `%_EObj_e`, `%_EObj_g__EObj`, `%_EObj_g_b`, `%_EObj_g_c`, `%_EObj_g_i`, `%_EObj_g_s`, `%_EObj_h__EObj`, `%_EObj_h_b`, `%_EObj_h_c`, `%_EObj_h_i`, `%_EObj_h_s`, `%_EObj_i__EObj`, `%_EObj_j__EObj`, `%_EObj_j_b`, `%_EObj_j_c`, `%_EObj_j_i`, `%_EObj_j_s`, `%_EObj_k__EObj`, `%_EObj_k_b`, `%_EObj_k_c`, `%_EObj_k_i`, `%_EObj_k_s`, `%_EObj_l__EObj`, `%_EObj_l_b`, `%_EObj_l_c`, `%_EObj_l_i`, `%_EObj_l_s`, `%_EObj_m__EObj`, `%_EObj_m_b`, `%_EObj_m_c`, `%_EObj_m_i`, `%_EObj_m_s`, `%_EObj_n__EObj`, `%_EObj_n_b`, `%_EObj_n_c`, `%_EObj_n_i`, `%_EObj_n_s`, `%_EObj_o__EObj`, `%_EObj_o_b`, `%_EObj_o_c`, `%_EObj_o_i`, `%_EObj_o_s`, `%_EObj_p`, `%_EObj_p__EObj`, `%_EObj_p_b`, `%_EObj_p_c`, `%_EObj_p_i`, `%_EObj_p_s`, `%_EObj_q__EObj`, `%_EObj_q_b`, `%_EObj_q_c`, `%_EObj_q_i`, `%_EObj_q_s`, `%_EObj_r__EObj`, `%_EObj_r_b`, `%_EObj_r_c`, `%_EObj_r_i`, `%_EObj_r_s`, `%_EObj_s__EObj`, `%_EObj_s_b`, `%_EObj_s_c`, `%_EObj_s_i`, `%_EObj_s_s`, `%_EObj_t`, `%_EObj_x__EObj`, `%_EObj_x_b`, `%_EObj_x_c`, `%_EObj_x_i`, `%_EObj_x_s`, `%_EObj_y__EObj`, `%_EObj_y_b`, `%_EObj_y_c`, `%_EObj_y_i`, `%_EObj_y_s`, `%_EObj_z__EObj`, `%_EObj_z_b`, `%_EObj_z_c`, `%_EObj_z_i`, `%_EObj_z_s`, `%_eigs`, `%_load`, `%b_1__EObj`, `%b_2__EObj`, `%b_3__EObj`, `%b_4__EObj`, `%b_a__EObj`, `%b_d__EObj`, `%b_g__EObj`, `%b_h__EObj`, `%b_i_XMLList`, `%b_i__EObj`, `%b_j__EObj`, `%b_k__EObj`, `%b_l__EObj`, `%b_m__EObj`, `%b_n__EObj`, `%b_o__EObj`, `%b_p__EObj`, `%b_q__EObj`, `%b_r__EObj`, `%b_s__EObj`, `%b_x__EObj`, `%b_y__EObj`, `%b_z__EObj`, `%c_1__EObj`, `%c_2__EObj`, `%c_3__EObj`, `%c_4__EObj`, `%c_a__EObj`, `%c_d__EObj`, `%c_g__EObj`, `%c_h__EObj`, `%c_i_XMLAttr`, `%c_i_XMLDoc`, `%c_i_XMLElem`, `%c_i_XMLList`, `%c_i__EObj`, `%c_j__EObj`, `%c_k__EObj`, `%c_l__EObj`, `%c_m__EObj`, `%c_n__EObj`, `%c_o__EObj`, `%c_p__EObj`, `%c_q__EObj`, `%c_r__EObj`, `%c_s__EObj`, `%c_x__EObj`, `%c_y__EObj`, `%c_z__EObj`, `%ce_i_XMLList`, `%fptr_i_XMLList`, `%h_i_XMLList`, `%hm_i_XMLList`, `%i_1__EObj`, `%i_2__EObj`, `%i_3__EObj`, `%i_4__EObj`, `%i_a__EObj`, `%i_abs`, `%i_cumprod`, `%i_cumsum`, `%i_d__EObj`, `%i_diag`, `%i_g__EObj`, `%i_h__EObj`, `%i_i_XMLList`, `%i_i__EObj`, `%i_j__EObj`, `%i_k__EObj`, `%i_l__EObj`, `%i_m__EObj`, `%i_matrix`, `%i_max`, `%i_maxi`, `%i_min`, `%i_mini`, `%i_mput`, `%i_n__EObj`, `%i_o__EObj`, `%i_p`, `%i_p__EObj`, `%i_prod`, `%i_q__EObj`, `%i_r__EObj`, `%i_s__EObj`, `%i_sum`, `%i_tril`, `%i_triu`, `%i_x__EObj`, `%i_y__EObj`, `%i_z__EObj`, `%ip_i_XMLList`, `%l_i_XMLList`, `%l_i__EObj`, `%lss_i_XMLList`, `%mc_i_XMLList`, `%msp_full`, `%msp_i_XMLList`, `%msp_spget`, `%p_i_XMLList`, `%ptr_i_XMLList`, `%r_i_XMLList`, `%s_1__EObj`, `%s_2__EObj`, `%s_3__EObj`, `%s_4__EObj`, `%s_a__EObj`, `%s_d__EObj`, `%s_g__EObj`, `%s_h__EObj`, `%s_i_XMLList`, `%s_i__EObj`, `%s_j__EObj`, `%s_k__EObj`, `%s_l__EObj`, `%s_m__EObj`, `%s_n__EObj`, `%s_o__EObj`, `%s_p__EObj`, `%s_q__EObj`, `%s_r__EObj`, `%s_s__EObj`, `%s_x__EObj`, `%s_y__EObj`, `%s_z__EObj`, `%sp_i_XMLList`, `%spb_i_XMLList`, `%st_i_XMLList`, `Calendar`, `ClipBoard`, `Matplot`, `Matplot1`, `PlaySound`, `TCL_DeleteInterp`, `TCL_DoOneEvent`, `TCL_EvalFile`, `TCL_EvalStr`, `TCL_ExistArray`, `TCL_ExistInterp`, `TCL_ExistVar`, `TCL_GetVar`, `TCL_GetVersion`, `TCL_SetVar`, `TCL_UnsetVar`, `TCL_UpVar`, `_`, `_code2str`, `_d`, `_str2code`, `about`, `abs`, `acos`, `addModulePreferences`, `addcolor`, `addf`, `addhistory`, `addinter`, `addlocalizationdomain`, `amell`, `and`, `argn`, `arl2_ius`, `ascii`, `asin`, `atan`, `backslash`, `balanc`, `banner`, `base2dec`, `basename`, `bdiag`, `beep`, `besselh`, `besseli`, `besselj`, `besselk`, `bessely`, `beta`, `bezout`, `bfinit`, `blkfc1i`, `blkslvi`, `bool2s`, `browsehistory`, `browsevar`, `bsplin3val`, `buildDoc`, `buildouttb`, `bvode`, `c_link`, `call`, `callblk`, `captions`, `cd`, `cdfbet`, `cdfbin`, `cdfchi`, `cdfchn`, `cdff`, `cdffnc`, `cdfgam`, `cdfnbn`, `cdfnor`, `cdfpoi`, `cdft`, `ceil`, `champ`, `champ1`, `chdir`, `chol`, `clc`, `clean`, `clear`, `clearfun`, `clearglobal`, `closeEditor`, `closeEditvar`, `closeXcos`, `code2str`, `coeff`, `color`, `comp`, `completion`, `conj`, `contour2di`, `contr`, `conv2`, `convstr`, `copy`, `copyfile`, `corr`, `cos`, `coserror`, `createdir`, `cshep2d`, `csvDefault`, `csvIsnum`, `csvRead`, `csvStringToDouble`, `csvTextScan`, `csvWrite`, `ctree2`, `ctree3`, `ctree4`, `cumprod`, `cumsum`, `curblock`, `curblockc`, `daskr`, `dasrt`, `dassl`, `data2sig`, `datatipCreate`, `datatipManagerMode`, `datatipMove`, `datatipRemove`, `datatipSetDisplay`, `datatipSetInterp`, `datatipSetOrientation`, `datatipSetStyle`, `datatipToggle`, `dawson`, `dct`, `debug`, `dec2base`, `deff`, `definedfields`, `degree`, `delbpt`, `delete`, `deletefile`, `delip`, `delmenu`, `det`, `dgettext`, `dhinf`, `diag`, `diary`, `diffobjs`, `disp`, `dispbpt`, `displayhistory`, `disposefftwlibrary`, `dlgamma`, `dnaupd`, `dneupd`, `double`, `drawaxis`, `drawlater`, `drawnow`, `driver`, `dsaupd`, `dsearch`, `dseupd`, `dst`, `duplicate`, `editvar`, `emptystr`, `end_scicosim`, `ereduc`, `erf`, `erfc`, `erfcx`, `erfi`, `errcatch`, `errclear`, `error`, `eval_cshep2d`, `exec`, `execstr`, `exists`, `exit`, `exp`, `expm`, `exportUI`, `export_to_hdf5`, `eye`, `fadj2sp`, `fec`, `feval`, `fft`, `fftw`, `fftw_flags`, `fftw_forget_wisdom`, `fftwlibraryisloaded`, `figure`, `file`, `filebrowser`, `fileext`, `fileinfo`, `fileparts`, `filesep`, `find`, `findBD`, `findfiles`, `fire_closing_finished`, `floor`, `format`, `fort`, `fprintfMat`, `freq`, `frexp`, `fromc`, `fromjava`, `fscanfMat`, `fsolve`, `fstair`, `full`, `fullpath`, `funcprot`, `funptr`, `gamma`, `gammaln`, `geom3d`, `get`, `getURL`, `get_absolute_file_path`, `get_fftw_wisdom`, `getblocklabel`, `getcallbackobject`, `getdate`, `getdebuginfo`, `getdefaultlanguage`, `getdrives`, `getdynlibext`, `getenv`, `getfield`, `gethistory`, `gethistoryfile`, `getinstalledlookandfeels`, `getio`, `getlanguage`, `getlongpathname`, `getlookandfeel`, `getmd5`, `getmemory`, `getmodules`, `getos`, `getpid`, `getrelativefilename`, `getscicosvars`, `getscilabmode`, `getshortpathname`, `gettext`, `getvariablesonstack`, `getversion`, `glist`, `global`, `glue`, `grand`, `graphicfunction`, `grayplot`, `grep`, `gsort`, `gstacksize`, `h5attr`, `h5close`, `h5cp`, `h5dataset`, `h5dump`, `h5exists`, `h5flush`, `h5get`, `h5group`, `h5isArray`, `h5isAttr`, `h5isCompound`, `h5isFile`, `h5isGroup`, `h5isList`, `h5isRef`, `h5isSet`, `h5isSpace`, `h5isType`, `h5isVlen`, `h5label`, `h5ln`, `h5ls`, `h5mount`, `h5mv`, `h5open`, `h5read`, `h5readattr`, `h5rm`, `h5umount`, `h5write`, `h5writeattr`, `havewindow`, `helpbrowser`, `hess`, `hinf`, `historymanager`, `historysize`, `host`, `htmlDump`, `htmlRead`, `htmlReadStr`, `htmlWrite`, `iconvert`, `ieee`, `ilib_verbose`, `imag`, `impl`, `import_from_hdf5`, `imult`, `inpnvi`, `int`, `int16`, `int2d`, `int32`, `int3d`, `int8`, `interp`, `interp2d`, `interp3d`, `intg`, `intppty`, `inttype`, `inv`, `invoke_lu`, `is_handle_valid`, `is_hdf5_file`, `isalphanum`, `isascii`, `isdef`, `isdigit`, `isdir`, `isequal`, `isequalbitwise`, `iserror`, `isfile`, `isglobal`, `isletter`, `isnum`, `isreal`, `iswaitingforinput`, `jallowClassReloading`, `jarray`, `jautoTranspose`, `jautoUnwrap`, `javaclasspath`, `javalibrarypath`, `jcast`, `jcompile`, `jconvMatrixMethod`, `jcreatejar`, `jdeff`, `jdisableTrace`, `jenableTrace`, `jexists`, `jgetclassname`, `jgetfield`, `jgetfields`, `jgetinfo`, `jgetmethods`, `jimport`, `jinvoke`, `jinvoke_db`, `jnewInstance`, `jremove`, `jsetfield`, `junwrap`, `junwraprem`, `jwrap`, `jwrapinfloat`, `kron`, `lasterror`, `ldiv`, `ldivf`, `legendre`, `length`, `lib`, `librarieslist`, `libraryinfo`, `light`, `linear_interpn`, `lines`, `link`, `linmeq`, `list`, `listvar_in_hdf5`, `load`, `loadGui`, `loadScicos`, `loadXcos`, `loadfftwlibrary`, `loadhistory`, `log`, `log1p`, `lsq`, `lsq_splin`, `lsqrsolve`, `lsslist`, `lstcat`, `lstsize`, `ltitr`, `lu`, `ludel`, `lufact`, `luget`, `lusolve`, `macr2lst`, `macr2tree`, `matfile_close`, `matfile_listvar`, `matfile_open`, `matfile_varreadnext`, `matfile_varwrite`, `matrix`, `max`, `maxfiles`, `mclearerr`, `mclose`, `meof`, `merror`, `messagebox`, `mfprintf`, `mfscanf`, `mget`, `mgeti`, `mgetl`, `mgetstr`, `min`, `mlist`, `mode`, `model2blk`, `mopen`, `move`, `movefile`, `mprintf`, `mput`, `mputl`, `mputstr`, `mscanf`, `mseek`, `msprintf`, `msscanf`, `mtell`, `mtlb_mode`, `mtlb_sparse`, `mucomp`, `mulf`, `name2rgb`, `nearfloat`, `newaxes`, `newest`, `newfun`, `nnz`, `norm`, `notify`, `number_properties`, `ode`, `odedc`, `ones`, `openged`, `opentk`, `optim`, `or`, `ordmmd`, `parallel_concurrency`, `parallel_run`, `param3d`, `param3d1`, `part`, `pathconvert`, `pathsep`, `phase_simulation`, `plot2d`, `plot2d1`, `plot2d2`, `plot2d3`, `plot2d4`, `plot3d`, `plot3d1`, `plotbrowser`, `pointer_xproperty`, `poly`, `ppol`, `pppdiv`, `predef`, `preferences`, `print`, `printf`, `printfigure`, `printsetupbox`, `prod`, `progressionbar`, `prompt`, `pwd`, `qld`, `qp_solve`, `qr`, `raise_window`, `rand`, `rankqr`, `rat`, `rcond`, `rdivf`, `read`, `read4b`, `read_csv`, `readb`, `readgateway`, `readmps`, `real`, `realtime`, `realtimeinit`, `regexp`, `relocate_handle`, `remez`, `removeModulePreferences`, `removedir`, `removelinehistory`, `res_with_prec`, `resethistory`, `residu`, `resume`, `return`, `ricc`, `rlist`, `roots`, `rotate_axes`, `round`, `rpem`, `rtitr`, `rubberbox`, `save`, `saveGui`, `saveafterncommands`, `saveconsecutivecommands`, `savehistory`, `schur`, `sci_haltscicos`, `sci_tree2`, `sci_tree3`, `sci_tree4`, `sciargs`, `scicos_debug`, `scicos_debug_count`, `scicos_time`, `scicosim`, `scinotes`, `sctree`, `semidef`, `set`, `set_blockerror`, `set_fftw_wisdom`, `set_xproperty`, `setbpt`, `setdefaultlanguage`, `setenv`, `setfield`, `sethistoryfile`, `setlanguage`, `setlookandfeel`, `setmenu`, `sfact`, `sfinit`, `show_window`, `sident`, `sig2data`, `sign`, `simp`, `simp_mode`, `sin`, `size`, `slash`, `sleep`, `sorder`, `sparse`, `spchol`, `spcompack`, `spec`, `spget`, `splin`, `splin2d`, `splin3d`, `splitURL`, `spones`, `sprintf`, `sqrt`, `stacksize`, `str2code`, `strcat`, `strchr`, `strcmp`, `strcspn`, `strindex`, `string`, `stringbox`, `stripblanks`, `strncpy`, `strrchr`, `strrev`, `strsplit`, `strspn`, `strstr`, `strsubst`, `strtod`, `strtok`, `subf`, `sum`, `svd`, `swap_handles`, `symfcti`, `syredi`, `system_getproperty`, `system_setproperty`, `ta2lpd`, `tan`, `taucs_chdel`, `taucs_chfact`, `taucs_chget`, `taucs_chinfo`, `taucs_chsolve`, `tempname`, `testmatrix`, `timer`, `tlist`, `tohome`, `tokens`, `toolbar`, `toprint`, `tr_zer`, `tril`, `triu`, `type`, `typename`, `uiDisplayTree`, `uicontextmenu`, `uicontrol`, `uigetcolor`, `uigetdir`, `uigetfile`, `uigetfont`, `uimenu`, `uint16`, `uint32`, `uint8`, `uipopup`, `uiputfile`, `uiwait`, `ulink`, `umf_ludel`, `umf_lufact`, `umf_luget`, `umf_luinfo`, `umf_lusolve`, `umfpack`, `unglue`, `unix`, `unsetmenu`, `unzoom`, `updatebrowsevar`, `usecanvas`, `useeditor`, `user`, `var2vec`, `varn`, `vec2var`, `waitbar`, `warnBlockByUID`, `warning`, `what`, `where`, `whereis`, `who`, `winsid`, `with_module`, `writb`, `write`, `write4b`, `write_csv`, `x_choose`, `x_choose_modeless`, `x_dialog`, `x_mdialog`, `xarc`, `xarcs`, `xarrows`, `xchange`, `xchoicesi`, `xclick`, `xcos`, `xcosAddToolsMenu`, `xcosConfigureXmlFile`, `xcosDiagramToScilab`, `xcosPalCategoryAdd`, `xcosPalDelete`, `xcosPalDisable`, `xcosPalEnable`, `xcosPalGenerateIcon`, `xcosPalGet`, `xcosPalLoad`, `xcosPalMove`, `xcosSimulationStarted`, `xcosUpdateBlock`, `xdel`, `xend`, `xfarc`, `xfarcs`, `xfpoly`, `xfpolys`, `xfrect`, `xget`, `xgetmouse`, `xgraduate`, `xgrid`, `xinit`, `xlfont`, `xls_open`, `xls_read`, `xmlAddNs`, `xmlAppend`, `xmlAsNumber`, `xmlAsText`, `xmlDTD`, `xmlDelete`, `xmlDocument`, `xmlDump`, `xmlElement`, `xmlFormat`, `xmlGetNsByHref`, `xmlGetNsByPrefix`, `xmlGetOpenDocs`, `xmlIsValidObject`, `xmlName`, `xmlNs`, `xmlRead`, `xmlReadStr`, `xmlRelaxNG`, `xmlRemove`, `xmlSchema`, `xmlSetAttributes`, `xmlValidate`, `xmlWrite`, `xmlXPath`, `xname`, `xpause`, `xpoly`, `xpolys`, `xrect`, `xrects`, `xs2bmp`, `xs2emf`, `xs2eps`, `xs2gif`, `xs2jpg`, `xs2pdf`, `xs2png`, `xs2ppm`, `xs2ps`, `xs2svg`, `xsegs`, `xset`, `xstring`, `xstringb`, `xtitle`, `zeros`, `znaupd`, `zneupd`, `zoom_rect`, `abort`, `apropos`, `break`, `case`, `catch`, `continue`, `do`, `else`, `elseif`, `end`, `endfunction`, `for`, `function`, `help`, `if`, `pause`, `quit`, `select`, `then`, `try`, `while`, `!_deff_wrapper`, `%0_i_st`, `%3d_i_h`, `%Block_xcosUpdateBlock`, `%TNELDER_p`, `%TNELDER_string`, `%TNMPLOT_p`, `%TNMPLOT_string`, `%TOPTIM_p`, `%TOPTIM_string`, `%TSIMPLEX_p`, `%TSIMPLEX_string`, `%_EVoid_p`, `%_gsort`, `%_listvarinfile`, `%_rlist`, `%_save`, `%_sodload`, `%_strsplit`, `%_unwrap`, `%ar_p`, `%asn`, `%b_a_b`, `%b_a_s`, `%b_c_s`, `%b_c_spb`, `%b_cumprod`, `%b_cumsum`, `%b_d_s`, `%b_diag`, `%b_e`, `%b_f_s`, `%b_f_spb`, `%b_g_s`, `%b_g_spb`, `%b_grand`, `%b_h_s`, `%b_h_spb`, `%b_i_b`, `%b_i_ce`, `%b_i_h`, `%b_i_hm`, `%b_i_s`, `%b_i_sp`, `%b_i_spb`, `%b_i_st`, `%b_iconvert`, `%b_l_b`, `%b_l_s`, `%b_m_b`, `%b_m_s`, `%b_matrix`, `%b_n_hm`, `%b_o_hm`, `%b_p_s`, `%b_prod`, `%b_r_b`, `%b_r_s`, `%b_s_b`, `%b_s_s`, `%b_string`, `%b_sum`, `%b_tril`, `%b_triu`, `%b_x_b`, `%b_x_s`, `%bicg`, `%bicgstab`, `%c_a_c`, `%c_b_c`, `%c_b_s`, `%c_diag`, `%c_dsearch`, `%c_e`, `%c_eye`, `%c_f_s`, `%c_grand`, `%c_i_c`, `%c_i_ce`, `%c_i_h`, `%c_i_hm`, `%c_i_lss`, `%c_i_r`, `%c_i_s`, `%c_i_st`, `%c_matrix`, `%c_n_l`, `%c_n_st`, `%c_o_l`, `%c_o_st`, `%c_ones`, `%c_rand`, `%c_tril`, `%c_triu`, `%cblock_c_cblock`, `%cblock_c_s`, `%cblock_e`, `%cblock_f_cblock`, `%cblock_p`, `%cblock_size`, `%ce_6`, `%ce_c_ce`, `%ce_e`, `%ce_f_ce`, `%ce_i_ce`, `%ce_i_s`, `%ce_i_st`, `%ce_matrix`, `%ce_p`, `%ce_size`, `%ce_string`, `%ce_t`, `%cgs`, `%champdat_i_h`, `%choose`, `%diagram_xcos`, `%dir_p`, `%fptr_i_st`, `%grand_perm`, `%grayplot_i_h`, `%h_i_st`, `%hmS_k_hmS_generic`, `%hm_1_hm`, `%hm_1_s`, `%hm_2_hm`, `%hm_2_s`, `%hm_3_hm`, `%hm_3_s`, `%hm_4_hm`, `%hm_4_s`, `%hm_5`, `%hm_a_hm`, `%hm_a_r`, `%hm_a_s`, `%hm_abs`, `%hm_and`, `%hm_bool2s`, `%hm_c_hm`, `%hm_ceil`, `%hm_conj`, `%hm_cos`, `%hm_cumprod`, `%hm_cumsum`, `%hm_d_hm`, `%hm_d_s`, `%hm_degree`, `%hm_dsearch`, `%hm_e`, `%hm_exp`, `%hm_eye`, `%hm_f_hm`, `%hm_find`, `%hm_floor`, `%hm_g_hm`, `%hm_grand`, `%hm_gsort`, `%hm_h_hm`, `%hm_i_b`, `%hm_i_ce`, `%hm_i_h`, `%hm_i_hm`, `%hm_i_i`, `%hm_i_p`, `%hm_i_r`, `%hm_i_s`, `%hm_i_st`, `%hm_iconvert`, `%hm_imag`, `%hm_int`, `%hm_isnan`, `%hm_isreal`, `%hm_j_hm`, `%hm_j_s`, `%hm_k_hm`, `%hm_k_s`, `%hm_log`, `%hm_m_p`, `%hm_m_r`, `%hm_m_s`, `%hm_matrix`, `%hm_max`, `%hm_mean`, `%hm_median`, `%hm_min`, `%hm_n_b`, `%hm_n_c`, `%hm_n_hm`, `%hm_n_i`, `%hm_n_p`, `%hm_n_s`, `%hm_o_b`, `%hm_o_c`, `%hm_o_hm`, `%hm_o_i`, `%hm_o_p`, `%hm_o_s`, `%hm_ones`, `%hm_or`, `%hm_p`, `%hm_prod`, `%hm_q_hm`, `%hm_r_s`, `%hm_rand`, `%hm_real`, `%hm_round`, `%hm_s`, `%hm_s_hm`, `%hm_s_r`, `%hm_s_s`, `%hm_sign`, `%hm_sin`, `%hm_size`, `%hm_sqrt`, `%hm_stdev`, `%hm_string`, `%hm_sum`, `%hm_x_hm`, `%hm_x_p`, `%hm_x_s`, `%hm_zeros`, `%i_1_s`, `%i_2_s`, `%i_3_s`, `%i_4_s`, `%i_Matplot`, `%i_a_i`, `%i_a_s`, `%i_and`, `%i_ascii`, `%i_b_s`, `%i_bezout`, `%i_champ`, `%i_champ1`, `%i_contour`, `%i_contour2d`, `%i_d_i`, `%i_d_s`, `%i_dsearch`, `%i_e`, `%i_fft`, `%i_g_i`, `%i_gcd`, `%i_grand`, `%i_h_i`, `%i_i_ce`, `%i_i_h`, `%i_i_hm`, `%i_i_i`, `%i_i_s`, `%i_i_st`, `%i_j_i`, `%i_j_s`, `%i_l_s`, `%i_lcm`, `%i_length`, `%i_m_i`, `%i_m_s`, `%i_mfprintf`, `%i_mprintf`, `%i_msprintf`, `%i_n_s`, `%i_o_s`, `%i_or`, `%i_p_i`, `%i_p_s`, `%i_plot2d`, `%i_plot2d1`, `%i_plot2d2`, `%i_q_s`, `%i_r_i`, `%i_r_s`, `%i_round`, `%i_s_i`, `%i_s_s`, `%i_sign`, `%i_string`, `%i_x_i`, `%i_x_s`, `%ip_a_s`, `%ip_i_st`, `%ip_m_s`, `%ip_n_ip`, `%ip_o_ip`, `%ip_p`, `%ip_part`, `%ip_s_s`, `%ip_string`, `%k`, `%l_i_h`, `%l_i_s`, `%l_i_st`, `%l_isequal`, `%l_n_c`, `%l_n_l`, `%l_n_m`, `%l_n_p`, `%l_n_s`, `%l_n_st`, `%l_o_c`, `%l_o_l`, `%l_o_m`, `%l_o_p`, `%l_o_s`, `%l_o_st`, `%lss_a_lss`, `%lss_a_p`, `%lss_a_r`, `%lss_a_s`, `%lss_c_lss`, `%lss_c_p`, `%lss_c_r`, `%lss_c_s`, `%lss_e`, `%lss_eye`, `%lss_f_lss`, `%lss_f_p`, `%lss_f_r`, `%lss_f_s`, `%lss_i_ce`, `%lss_i_lss`, `%lss_i_p`, `%lss_i_r`, `%lss_i_s`, `%lss_i_st`, `%lss_inv`, `%lss_l_lss`, `%lss_l_p`, `%lss_l_r`, `%lss_l_s`, `%lss_m_lss`, `%lss_m_p`, `%lss_m_r`, `%lss_m_s`, `%lss_n_lss`, `%lss_n_p`, `%lss_n_r`, `%lss_n_s`, `%lss_norm`, `%lss_o_lss`, `%lss_o_p`, `%lss_o_r`, `%lss_o_s`, `%lss_ones`, `%lss_r_lss`, `%lss_r_p`, `%lss_r_r`, `%lss_r_s`, `%lss_rand`, `%lss_s`, `%lss_s_lss`, `%lss_s_p`, `%lss_s_r`, `%lss_s_s`, `%lss_size`, `%lss_t`, `%lss_v_lss`, `%lss_v_p`, `%lss_v_r`, `%lss_v_s`, `%lt_i_s`, `%m_n_l`, `%m_o_l`, `%mc_i_h`, `%mc_i_s`, `%mc_i_st`, `%mc_n_st`, `%mc_o_st`, `%mc_string`, `%mps_p`, `%mps_string`, `%msp_a_s`, `%msp_abs`, `%msp_e`, `%msp_find`, `%msp_i_s`, `%msp_i_st`, `%msp_length`, `%msp_m_s`, `%msp_maxi`, `%msp_n_msp`, `%msp_nnz`, `%msp_o_msp`, `%msp_p`, `%msp_sparse`, `%msp_spones`, `%msp_t`, `%p_a_lss`, `%p_a_r`, `%p_c_lss`, `%p_c_r`, `%p_cumprod`, `%p_cumsum`, `%p_d_p`, `%p_d_r`, `%p_d_s`, `%p_det`, `%p_e`, `%p_f_lss`, `%p_f_r`, `%p_grand`, `%p_i_ce`, `%p_i_h`, `%p_i_hm`, `%p_i_lss`, `%p_i_p`, `%p_i_r`, `%p_i_s`, `%p_i_st`, `%p_inv`, `%p_j_s`, `%p_k_p`, `%p_k_r`, `%p_k_s`, `%p_l_lss`, `%p_l_p`, `%p_l_r`, `%p_l_s`, `%p_m_hm`, `%p_m_lss`, `%p_m_r`, `%p_matrix`, `%p_n_l`, `%p_n_lss`, `%p_n_r`, `%p_o_l`, `%p_o_lss`, `%p_o_r`, `%p_o_sp`, `%p_p_s`, `%p_part`, `%p_prod`, `%p_q_p`, `%p_q_r`, `%p_q_s`, `%p_r_lss`, `%p_r_p`, `%p_r_r`, `%p_r_s`, `%p_s_lss`, `%p_s_r`, `%p_simp`, `%p_string`, `%p_sum`, `%p_v_lss`, `%p_v_p`, `%p_v_r`, `%p_v_s`, `%p_x_hm`, `%p_x_r`, `%p_y_p`, `%p_y_r`, `%p_y_s`, `%p_z_p`, `%p_z_r`, `%p_z_s`, `%pcg`, `%plist_p`, `%plist_string`, `%r_0`, `%r_a_hm`, `%r_a_lss`, `%r_a_p`, `%r_a_r`, `%r_a_s`, `%r_c_lss`, `%r_c_p`, `%r_c_r`, `%r_c_s`, `%r_clean`, `%r_cumprod`, `%r_cumsum`, `%r_d_p`, `%r_d_r`, `%r_d_s`, `%r_det`, `%r_diag`, `%r_e`, `%r_eye`, `%r_f_lss`, `%r_f_p`, `%r_f_r`, `%r_f_s`, `%r_i_ce`, `%r_i_hm`, `%r_i_lss`, `%r_i_p`, `%r_i_r`, `%r_i_s`, `%r_i_st`, `%r_inv`, `%r_j_s`, `%r_k_p`, `%r_k_r`, `%r_k_s`, `%r_l_lss`, `%r_l_p`, `%r_l_r`, `%r_l_s`, `%r_m_hm`, `%r_m_lss`, `%r_m_p`, `%r_m_r`, `%r_m_s`, `%r_matrix`, `%r_n_lss`, `%r_n_p`, `%r_n_r`, `%r_n_s`, `%r_norm`, `%r_o_lss`, `%r_o_p`, `%r_o_r`, `%r_o_s`, `%r_ones`, `%r_p`, `%r_p_s`, `%r_prod`, `%r_q_p`, `%r_q_r`, `%r_q_s`, `%r_r_lss`, `%r_r_p`, `%r_r_r`, `%r_r_s`, `%r_rand`, `%r_s`, `%r_s_hm`, `%r_s_lss`, `%r_s_p`, `%r_s_r`, `%r_s_s`, `%r_simp`, `%r_size`, `%r_string`, `%r_sum`, `%r_t`, `%r_tril`, `%r_triu`, `%r_v_lss`, `%r_v_p`, `%r_v_r`, `%r_v_s`, `%r_varn`, `%r_x_p`, `%r_x_r`, `%r_x_s`, `%r_y_p`, `%r_y_r`, `%r_y_s`, `%r_z_p`, `%r_z_r`, `%r_z_s`, `%s_1_hm`, `%s_1_i`, `%s_2_hm`, `%s_2_i`, `%s_3_hm`, `%s_3_i`, `%s_4_hm`, `%s_4_i`, `%s_5`, `%s_a_b`, `%s_a_hm`, `%s_a_i`, `%s_a_ip`, `%s_a_lss`, `%s_a_msp`, `%s_a_r`, `%s_a_sp`, `%s_and`, `%s_b_i`, `%s_b_s`, `%s_bezout`, `%s_c_b`, `%s_c_cblock`, `%s_c_lss`, `%s_c_r`, `%s_c_sp`, `%s_d_b`, `%s_d_i`, `%s_d_p`, `%s_d_r`, `%s_d_sp`, `%s_e`, `%s_f_b`, `%s_f_cblock`, `%s_f_lss`, `%s_f_r`, `%s_f_sp`, `%s_g_b`, `%s_g_s`, `%s_gcd`, `%s_grand`, `%s_h_b`, `%s_h_s`, `%s_i_b`, `%s_i_c`, `%s_i_ce`, `%s_i_h`, `%s_i_hm`, `%s_i_i`, `%s_i_lss`, `%s_i_p`, `%s_i_r`, `%s_i_s`, `%s_i_sp`, `%s_i_spb`, `%s_i_st`, `%s_j_i`, `%s_k_hm`, `%s_k_p`, `%s_k_r`, `%s_k_sp`, `%s_l_b`, `%s_l_hm`, `%s_l_i`, `%s_l_lss`, `%s_l_p`, `%s_l_r`, `%s_l_s`, `%s_l_sp`, `%s_lcm`, `%s_m_b`, `%s_m_hm`, `%s_m_i`, `%s_m_ip`, `%s_m_lss`, `%s_m_msp`, `%s_m_r`, `%s_matrix`, `%s_n_hm`, `%s_n_i`, `%s_n_l`, `%s_n_lss`, `%s_n_r`, `%s_n_st`, `%s_o_hm`, `%s_o_i`, `%s_o_l`, `%s_o_lss`, `%s_o_r`, `%s_o_st`, `%s_or`, `%s_p_b`, `%s_p_i`, `%s_pow`, `%s_q_hm`, `%s_q_i`, `%s_q_p`, `%s_q_r`, `%s_q_sp`, `%s_r_b`, `%s_r_i`, `%s_r_lss`, `%s_r_p`, `%s_r_r`, `%s_r_s`, `%s_r_sp`, `%s_s_b`, `%s_s_hm`, `%s_s_i`, `%s_s_ip`, `%s_s_lss`, `%s_s_r`, `%s_s_sp`, `%s_simp`, `%s_v_lss`, `%s_v_p`, `%s_v_r`, `%s_v_s`, `%s_x_b`, `%s_x_hm`, `%s_x_i`, `%s_x_r`, `%s_y_p`, `%s_y_r`, `%s_y_sp`, `%s_z_p`, `%s_z_r`, `%s_z_sp`, `%sn`, `%sp_a_s`, `%sp_a_sp`, `%sp_and`, `%sp_c_s`, `%sp_ceil`, `%sp_conj`, `%sp_cos`, `%sp_cumprod`, `%sp_cumsum`, `%sp_d_s`, `%sp_d_sp`, `%sp_det`, `%sp_diag`, `%sp_e`, `%sp_exp`, `%sp_f_s`, `%sp_floor`, `%sp_grand`, `%sp_gsort`, `%sp_i_ce`, `%sp_i_h`, `%sp_i_s`, `%sp_i_sp`, `%sp_i_st`, `%sp_int`, `%sp_inv`, `%sp_k_s`, `%sp_k_sp`, `%sp_l_s`, `%sp_l_sp`, `%sp_length`, `%sp_max`, `%sp_min`, `%sp_norm`, `%sp_or`, `%sp_p_s`, `%sp_prod`, `%sp_q_s`, `%sp_q_sp`, `%sp_r_s`, `%sp_r_sp`, `%sp_round`, `%sp_s_s`, `%sp_s_sp`, `%sp_sin`, `%sp_sqrt`, `%sp_string`, `%sp_sum`, `%sp_tril`, `%sp_triu`, `%sp_y_s`, `%sp_y_sp`, `%sp_z_s`, `%sp_z_sp`, `%spb_and`, `%spb_c_b`, `%spb_cumprod`, `%spb_cumsum`, `%spb_diag`, `%spb_e`, `%spb_f_b`, `%spb_g_b`, `%spb_g_spb`, `%spb_h_b`, `%spb_h_spb`, `%spb_i_b`, `%spb_i_ce`, `%spb_i_h`, `%spb_i_st`, `%spb_or`, `%spb_prod`, `%spb_sum`, `%spb_tril`, `%spb_triu`, `%st_6`, `%st_c_st`, `%st_e`, `%st_f_st`, `%st_i_b`, `%st_i_c`, `%st_i_fptr`, `%st_i_h`, `%st_i_i`, `%st_i_ip`, `%st_i_lss`, `%st_i_msp`, `%st_i_p`, `%st_i_r`, `%st_i_s`, `%st_i_sp`, `%st_i_spb`, `%st_i_st`, `%st_matrix`, `%st_n_c`, `%st_n_l`, `%st_n_mc`, `%st_n_p`, `%st_n_s`, `%st_o_c`, `%st_o_l`, `%st_o_mc`, `%st_o_p`, `%st_o_s`, `%st_o_tl`, `%st_p`, `%st_size`, `%st_string`, `%st_t`, `%ticks_i_h`, `%xls_e`, `%xls_p`, `%xlssheet_e`, `%xlssheet_p`, `%xlssheet_size`, `%xlssheet_string`, `DominationRank`, `G_make`, `IsAScalar`, `NDcost`, `OS_Version`, `PlotSparse`, `ReadHBSparse`, `TCL_CreateSlave`, `abcd`, `abinv`, `accept_func_default`, `accept_func_vfsa`, `acf`, `acosd`, `acosh`, `acoshm`, `acosm`, `acot`, `acotd`, `acoth`, `acsc`, `acscd`, `acsch`, `add_demo`, `add_help_chapter`, `add_module_help_chapter`, `add_param`, `add_profiling`, `adj2sp`, `aff2ab`, `ana_style`, `analpf`, `analyze`, `aplat`, `arhnk`, `arl2`, `arma2p`, `arma2ss`, `armac`, `armax`, `armax1`, `arobasestring2strings`, `arsimul`, `ascii2string`, `asciimat`, `asec`, `asecd`, `asech`, `asind`, `asinh`, `asinhm`, `asinm`, `assert_checkalmostequal`, `assert_checkequal`, `assert_checkerror`, `assert_checkfalse`, `assert_checkfilesequal`, `assert_checktrue`, `assert_comparecomplex`, `assert_computedigits`, `assert_cond2reltol`, `assert_cond2reqdigits`, `assert_generror`, `atand`, `atanh`, `atanhm`, `atanm`, `atomsAutoload`, `atomsAutoloadAdd`, `atomsAutoloadDel`, `atomsAutoloadList`, `atomsCategoryList`, `atomsCheckModule`, `atomsDepTreeShow`, `atomsGetConfig`, `atomsGetInstalled`, `atomsGetInstalledPath`, `atomsGetLoaded`, `atomsGetLoadedPath`, `atomsInstall`, `atomsIsInstalled`, `atomsIsLoaded`, `atomsList`, `atomsLoad`, `atomsQuit`, `atomsRemove`, `atomsRepositoryAdd`, `atomsRepositoryDel`, `atomsRepositoryList`, `atomsRestoreConfig`, `atomsSaveConfig`, `atomsSearch`, `atomsSetConfig`, `atomsShow`, `atomsSystemInit`, `atomsSystemUpdate`, `atomsTest`, `atomsUpdate`, `atomsVersion`, `augment`, `auread`, `auwrite`, `balreal`, `bench_run`, `bilin`, `bilt`, `bin2dec`, `binomial`, `bitand`, `bitcmp`, `bitget`, `bitor`, `bitset`, `bitxor`, `black`, `blanks`, `bloc2exp`, `bloc2ss`, `block_parameter_error`, `bode`, `bode_asymp`, `bstap`, `buttmag`, `bvodeS`, `bytecode`, `bytecodewalk`, `cainv`, `calendar`, `calerf`, `calfrq`, `canon`, `casc`, `cat`, `cat_code`, `cb_m2sci_gui`, `ccontrg`, `cell`, `cell2mat`, `cellstr`, `center`, `cepstrum`, `cfspec`, `char`, `chart`, `cheb1mag`, `cheb2mag`, `check_gateways`, `check_modules_xml`, `check_versions`, `chepol`, `chfact`, `chsolve`, `classmarkov`, `clean_help`, `clock`, `cls2dls`, `cmb_lin`, `cmndred`, `cmoment`, `coding_ga_binary`, `coding_ga_identity`, `coff`, `coffg`, `colcomp`, `colcompr`, `colinout`, `colregul`, `companion`, `complex`, `compute_initial_temp`, `cond`, `cond2sp`, `condestsp`, `configure_msifort`, `configure_msvc`, `conjgrad`, `cont_frm`, `cont_mat`, `contrss`, `conv`, `convert_to_float`, `convertindex`, `convol`, `convol2d`, `copfac`, `correl`, `cosd`, `cosh`, `coshm`, `cosm`, `cotd`, `cotg`, `coth`, `cothm`, `cov`, `covar`, `createXConfiguration`, `createfun`, `createstruct`, `cross`, `crossover_ga_binary`, `crossover_ga_default`, `csc`, `cscd`, `csch`, `csgn`, `csim`, `cspect`, `ctr_gram`, `czt`, `dae`, `daeoptions`, `damp`, `datafit`, `date`, `datenum`, `datevec`, `dbphi`, `dcf`, `ddp`, `dec2bin`, `dec2hex`, `dec2oct`, `del_help_chapter`, `del_module_help_chapter`, `demo_begin`, `demo_choose`, `demo_compiler`, `demo_end`, `demo_file_choice`, `demo_folder_choice`, `demo_function_choice`, `demo_gui`, `demo_run`, `demo_viewCode`, `denom`, `derivat`, `derivative`, `des2ss`, `des2tf`, `detectmsifort64tools`, `detectmsvc64tools`, `determ`, `detr`, `detrend`, `devtools_run_builder`, `dhnorm`, `diff`, `diophant`, `dir`, `dirname`, `dispfiles`, `dllinfo`, `dscr`, `dsimul`, `dt_ility`, `dtsi`, `edit`, `edit_error`, `editor`, `eigenmarkov`, `eigs`, `ell1mag`, `enlarge_shape`, `entropy`, `eomday`, `epred`, `eqfir`, `eqiir`, `equil`, `equil1`, `erfinv`, `etime`, `eval`, `evans`, `evstr`, `example_run`, `expression2code`, `extract_help_examples`, `factor`, `factorial`, `factors`, `faurre`, `ffilt`, `fft2`, `fftshift`, `fieldnames`, `filt_sinc`, `filter`, `findABCD`, `findAC`, `findBDK`, `findR`, `find_freq`, `find_links`, `find_scicos_version`, `findm`, `findmsifortcompiler`, `findmsvccompiler`, `findx0BD`, `firstnonsingleton`, `fix`, `fixedpointgcd`, `flipdim`, `flts`, `fminsearch`, `formatBlackTip`, `formatBodeMagTip`, `formatBodePhaseTip`, `formatGainplotTip`, `formatHallModuleTip`, `formatHallPhaseTip`, `formatNicholsGainTip`, `formatNicholsPhaseTip`, `formatNyquistTip`, `formatPhaseplotTip`, `formatSgridDampingTip`, `formatSgridFreqTip`, `formatZgridDampingTip`, `formatZgridFreqTip`, `format_txt`, `fourplan`, `frep2tf`, `freson`, `frfit`, `frmag`, `fseek_origin`, `fsfirlin`, `fspec`, `fspecg`, `fstabst`, `ftest`, `ftuneq`, `fullfile`, `fullrf`, `fullrfk`, `fun2string`, `g_margin`, `gainplot`, `gamitg`, `gcare`, `gcd`, `gencompilationflags_unix`, `generateBlockImage`, `generateBlockImages`, `generic_i_ce`, `generic_i_h`, `generic_i_hm`, `generic_i_s`, `generic_i_st`, `genlib`, `genmarkov`, `geomean`, `getDiagramVersion`, `getModelicaPath`, `getPreferencesValue`, `get_file_path`, `get_function_path`, `get_param`, `get_profile`, `get_scicos_version`, `getd`, `getscilabkeywords`, `getshell`, `gettklib`, `gfare`, `gfrancis`, `givens`, `glever`, `gmres`, `group`, `gschur`, `gspec`, `gtild`, `h2norm`, `h_cl`, `h_inf`, `h_inf_st`, `h_norm`, `hallchart`, `halt`, `hank`, `hankelsv`, `harmean`, `haveacompiler`, `head_comments`, `help_from_sci`, `help_skeleton`, `hermit`, `hex2dec`, `hilb`, `hilbert`, `histc`, `horner`, `householder`, `hrmt`, `htrianr`, `hypermat`, `idct`, `idst`, `ifft`, `ifftshift`, `iir`, `iirgroup`, `iirlp`, `iirmod`, `ilib_build`, `ilib_build_jar`, `ilib_compile`, `ilib_for_link`, `ilib_gen_Make`, `ilib_gen_Make_unix`, `ilib_gen_cleaner`, `ilib_gen_gateway`, `ilib_gen_loader`, `ilib_include_flag`, `ilib_mex_build`, `im_inv`, `importScicosDiagram`, `importScicosPal`, `importXcosDiagram`, `imrep2ss`, `ind2sub`, `inistate`, `init_ga_default`, `init_param`, `initial_scicos_tables`, `input`, `instruction2code`, `intc`, `intdec`, `integrate`, `interp1`, `interpln`, `intersect`, `intl`, `intsplin`, `inttrap`, `inv_coeff`, `invr`, `invrs`, `invsyslin`, `iqr`, `isLeapYear`, `is_absolute_path`, `is_param`, `iscell`, `iscellstr`, `iscolumn`, `isempty`, `isfield`, `isinf`, `ismatrix`, `isnan`, `isrow`, `isscalar`, `issparse`, `issquare`, `isstruct`, `isvector`, `jmat`, `justify`, `kalm`, `karmarkar`, `kernel`, `kpure`, `krac2`, `kroneck`, `lattn`, `lattp`, `launchtest`, `lcf`, `lcm`, `lcmdiag`, `leastsq`, `leqe`, `leqr`, `lev`, `levin`, `lex_sort`, `lft`, `lin`, `lin2mu`, `lincos`, `lindquist`, `linf`, `linfn`, `linsolve`, `linspace`, `list2vec`, `list_param`, `listfiles`, `listfunctions`, `listvarinfile`, `lmisolver`, `lmitool`, `loadXcosLibs`, `loadmatfile`, `loadwave`, `log10`, `log2`, `logm`, `logspace`, `lqe`, `lqg`, `lqg2stan`, `lqg_ltr`, `lqr`, `ls`, `lyap`, `m2sci_gui`, `m_circle`, `macglov`, `macrovar`, `mad`, `makecell`, `manedit`, `mapsound`, `markp2ss`, `matfile2sci`, `mdelete`, `mean`, `meanf`, `median`, `members`, `mese`, `meshgrid`, `mfft`, `mfile2sci`, `minreal`, `minss`, `mkdir`, `modulo`, `moment`, `mrfit`, `msd`, `mstr2sci`, `mtlb`, `mtlb_0`, `mtlb_a`, `mtlb_all`, `mtlb_any`, `mtlb_axes`, `mtlb_axis`, `mtlb_beta`, `mtlb_box`, `mtlb_choices`, `mtlb_close`, `mtlb_colordef`, `mtlb_cond`, `mtlb_cov`, `mtlb_cumprod`, `mtlb_cumsum`, `mtlb_dec2hex`, `mtlb_delete`, `mtlb_diag`, `mtlb_diff`, `mtlb_dir`, `mtlb_double`, `mtlb_e`, `mtlb_echo`, `mtlb_error`, `mtlb_eval`, `mtlb_exist`, `mtlb_eye`, `mtlb_false`, `mtlb_fft`, `mtlb_fftshift`, `mtlb_filter`, `mtlb_find`, `mtlb_findstr`, `mtlb_fliplr`, `mtlb_fopen`, `mtlb_format`, `mtlb_fprintf`, `mtlb_fread`, `mtlb_fscanf`, `mtlb_full`, `mtlb_fwrite`, `mtlb_get`, `mtlb_grid`, `mtlb_hold`, `mtlb_i`, `mtlb_ifft`, `mtlb_image`, `mtlb_imp`, `mtlb_int16`, `mtlb_int32`, `mtlb_int8`, `mtlb_is`, `mtlb_isa`, `mtlb_isfield`, `mtlb_isletter`, `mtlb_isspace`, `mtlb_l`, `mtlb_legendre`, `mtlb_linspace`, `mtlb_logic`, `mtlb_logical`, `mtlb_loglog`, `mtlb_lower`, `mtlb_max`, `mtlb_mean`, `mtlb_median`, `mtlb_mesh`, `mtlb_meshdom`, `mtlb_min`, `mtlb_more`, `mtlb_num2str`, `mtlb_ones`, `mtlb_pcolor`, `mtlb_plot`, `mtlb_prod`, `mtlb_qr`, `mtlb_qz`, `mtlb_rand`, `mtlb_randn`, `mtlb_rcond`, `mtlb_realmax`, `mtlb_realmin`, `mtlb_s`, `mtlb_semilogx`, `mtlb_semilogy`, `mtlb_setstr`, `mtlb_size`, `mtlb_sort`, `mtlb_sortrows`, `mtlb_sprintf`, `mtlb_sscanf`, `mtlb_std`, `mtlb_strcmp`, `mtlb_strcmpi`, `mtlb_strfind`, `mtlb_strrep`, `mtlb_subplot`, `mtlb_sum`, `mtlb_t`, `mtlb_toeplitz`, `mtlb_tril`, `mtlb_triu`, `mtlb_true`, `mtlb_type`, `mtlb_uint16`, `mtlb_uint32`, `mtlb_uint8`, `mtlb_upper`, `mtlb_var`, `mtlb_zeros`, `mu2lin`, `mutation_ga_binary`, `mutation_ga_default`, `mvcorrel`, `mvvacov`, `nancumsum`, `nand2mean`, `nanmax`, `nanmean`, `nanmeanf`, `nanmedian`, `nanmin`, `nanreglin`, `nanstdev`, `nansum`, `narsimul`, `ndgrid`, `ndims`, `nehari`, `neigh_func_csa`, `neigh_func_default`, `neigh_func_fsa`, `neigh_func_vfsa`, `neldermead_cget`, `neldermead_configure`, `neldermead_costf`, `neldermead_defaultoutput`, `neldermead_destroy`, `neldermead_function`, `neldermead_get`, `neldermead_log`, `neldermead_new`, `neldermead_restart`, `neldermead_search`, `neldermead_updatesimp`, `nextpow2`, `nfreq`, `nicholschart`, `nlev`, `nmplot_cget`, `nmplot_configure`, `nmplot_contour`, `nmplot_destroy`, `nmplot_function`, `nmplot_get`, `nmplot_historyplot`, `nmplot_log`, `nmplot_new`, `nmplot_outputcmd`, `nmplot_restart`, `nmplot_search`, `nmplot_simplexhistory`, `noisegen`, `nonreg_test_run`, `now`, `nthroot`, `null`, `num2cell`, `numderivative`, `numdiff`, `numer`, `nyquist`, `nyquistfrequencybounds`, `obs_gram`, `obscont`, `observer`, `obsv_mat`, `obsvss`, `oct2dec`, `odeoptions`, `optim_ga`, `optim_moga`, `optim_nsga`, `optim_nsga2`, `optim_sa`, `optimbase_cget`, `optimbase_checkbounds`, `optimbase_checkcostfun`, `optimbase_checkx0`, `optimbase_configure`, `optimbase_destroy`, `optimbase_function`, `optimbase_get`, `optimbase_hasbounds`, `optimbase_hasconstraints`, `optimbase_hasnlcons`, `optimbase_histget`, `optimbase_histset`, `optimbase_incriter`, `optimbase_isfeasible`, `optimbase_isinbounds`, `optimbase_isinnonlincons`, `optimbase_log`, `optimbase_logshutdown`, `optimbase_logstartup`, `optimbase_new`, `optimbase_outputcmd`, `optimbase_outstruct`, `optimbase_proj2bnds`, `optimbase_set`, `optimbase_stoplog`, `optimbase_terminate`, `optimget`, `optimplotfunccount`, `optimplotfval`, `optimplotx`, `optimset`, `optimsimplex_center`, `optimsimplex_check`, `optimsimplex_compsomefv`, `optimsimplex_computefv`, `optimsimplex_deltafv`, `optimsimplex_deltafvmax`, `optimsimplex_destroy`, `optimsimplex_dirmat`, `optimsimplex_fvmean`, `optimsimplex_fvstdev`, `optimsimplex_fvvariance`, `optimsimplex_getall`, `optimsimplex_getallfv`, `optimsimplex_getallx`, `optimsimplex_getfv`, `optimsimplex_getn`, `optimsimplex_getnbve`, `optimsimplex_getve`, `optimsimplex_getx`, `optimsimplex_gradientfv`, `optimsimplex_log`, `optimsimplex_new`, `optimsimplex_reflect`, `optimsimplex_setall`, `optimsimplex_setallfv`, `optimsimplex_setallx`, `optimsimplex_setfv`, `optimsimplex_setn`, `optimsimplex_setnbve`, `optimsimplex_setve`, `optimsimplex_setx`, `optimsimplex_shrink`, `optimsimplex_size`, `optimsimplex_sort`, `optimsimplex_xbar`, `orth`, `output_ga_default`, `output_moga_default`, `output_nsga2_default`, `output_nsga_default`, `p_margin`, `pack`, `pareto_filter`, `parrot`, `pbig`, `pca`, `pcg`, `pdiv`, `pen2ea`, `pencan`, `pencost`, `penlaur`, `perctl`, `perl`, `perms`, `permute`, `pertrans`, `pfactors`, `pfss`, `phasemag`, `phaseplot`, `phc`, `pinv`, `playsnd`, `plotprofile`, `plzr`, `pmodulo`, `pol2des`, `pol2str`, `polar`, `polfact`, `prbs_a`, `prettyprint`, `primes`, `princomp`, `profile`, `proj`, `projsl`, `projspec`, `psmall`, `pspect`, `qmr`, `qpsolve`, `quart`, `quaskro`, `rafiter`, `randpencil`, `range`, `rank`, `readxls`, `recompilefunction`, `recons`, `reglin`, `regress`, `remezb`, `remove_param`, `remove_profiling`, `repfreq`, `replace_Ix_by_Fx`, `repmat`, `reset_profiling`, `resize_matrix`, `returntoscilab`, `rhs2code`, `ric_desc`, `riccati`, `rmdir`, `routh_t`, `rowcomp`, `rowcompr`, `rowinout`, `rowregul`, `rowshuff`, `rref`, `sample`, `samplef`, `samwr`, `savematfile`, `savewave`, `scanf`, `sci2exp`, `sciGUI_init`, `sci_sparse`, `scicos_getvalue`, `scicos_simulate`, `scicos_workspace_init`, `scisptdemo`, `scitest`, `sdiff`, `sec`, `secd`, `sech`, `selection_ga_elitist`, `selection_ga_random`, `sensi`, `setPreferencesValue`, `set_param`, `setdiff`, `sgrid`, `show_margins`, `show_pca`, `showprofile`, `signm`, `sinc`, `sincd`, `sind`, `sinh`, `sinhm`, `sinm`, `sm2des`, `sm2ss`, `smga`, `smooth`, `solve`, `sound`, `soundsec`, `sp2adj`, `spaninter`, `spanplus`, `spantwo`, `specfact`, `speye`, `sprand`, `spzeros`, `sqroot`, `sqrtm`, `squarewave`, `squeeze`, `srfaur`, `srkf`, `ss2des`, `ss2ss`, `ss2tf`, `sskf`, `ssprint`, `ssrand`, `st_deviation`, `st_i_generic`, `st_ility`, `stabil`, `statgain`, `stdev`, `stdevf`, `steadycos`, `strange`, `strcmpi`, `struct`, `sub2ind`, `sva`, `svplot`, `sylm`, `sylv`, `sysconv`, `sysdiag`, `sysfact`, `syslin`, `syssize`, `system`, `systmat`, `tabul`, `tand`, `tanh`, `tanhm`, `tanm`, `tbx_build_blocks`, `tbx_build_cleaner`, `tbx_build_gateway`, `tbx_build_gateway_clean`, `tbx_build_gateway_loader`, `tbx_build_help`, `tbx_build_help_loader`, `tbx_build_loader`, `tbx_build_localization`, `tbx_build_macros`, `tbx_build_pal_loader`, `tbx_build_src`, `tbx_builder`, `tbx_builder_gateway`, `tbx_builder_gateway_lang`, `tbx_builder_help`, `tbx_builder_help_lang`, `tbx_builder_macros`, `tbx_builder_src`, `tbx_builder_src_lang`, `tbx_generate_pofile`, `temp_law_csa`, `temp_law_default`, `temp_law_fsa`, `temp_law_huang`, `temp_law_vfsa`, `test_clean`, `test_on_columns`, `test_run`, `test_run_level`, `testexamples`, `tf2des`, `tf2ss`, `thrownan`, `tic`, `time_id`, `toc`, `toeplitz`, `tokenpos`, `toolboxes`, `trace`, `trans`, `translatepaths`, `tree2code`, `trfmod`, `trianfml`, `trimmean`, `trisolve`, `trzeros`, `typeof`, `ui_observer`, `union`, `unique`, `unit_test_run`, `unix_g`, `unix_s`, `unix_w`, `unix_x`, `unobs`, `unpack`, `unwrap`, `variance`, `variancef`, `vec2list`, `vectorfind`, `ver`, `warnobsolete`, `wavread`, `wavwrite`, `wcenter`, `weekday`, `wfir`, `wfir_gui`, `whereami`, `who_user`, `whos`, `wiener`, `wigner`, `window`, `winlist`, `with_javasci`, `with_macros_source`, `with_modelica_compiler`, `with_tk`, `xcorr`, `xcosBlockEval`, `xcosBlockInterface`, `xcosCodeGeneration`, `xcosConfigureModelica`, `xcosPal`, `xcosPalAdd`, `xcosPalAddBlock`, `xcosPalExport`, `xcosPalGenerateAllIcons`, `xcosShowBlockWarning`, `xcosValidateBlockSet`, `xcosValidateCompareBlock`, `xcos_compile`, `xcos_debug_gui`, `xcos_run`, `xcos_simulate`, `xcov`, `xmltochm`, `xmltoformat`, `xmltohtml`, `xmltojar`, `xmltopdf`, `xmltops`, `xmltoweb`, `yulewalk`, `zeropen`, `zgrid`, `zpbutt`, `zpch1`, `zpch2`, `zpell`), NameBuiltin, nil}, {Words(``, `\b`, `$`, `%F`, `%T`, `%e`, `%eps`, `%f`, `%fftw`, `%gui`, `%i`, `%inf`, `%io`, `%modalWarning`, `%nan`, `%pi`, `%s`, `%t`, `%tk`, `%toolboxes`, `%toolboxes_dir`, `%z`, `PWD`, `SCI`, `SCIHOME`, `TMPDIR`, `arnoldilib`, `assertlib`, `atomslib`, `cacsdlib`, `compatibility_functilib`, `corelib`, `data_structureslib`, `demo_toolslib`, `development_toolslib`, `differential_equationlib`, `dynamic_linklib`, `elementary_functionslib`, `enull`, `evoid`, `external_objectslib`, `fd`, `fileiolib`, `functionslib`, `genetic_algorithmslib`, `helptoolslib`, `home`, `integerlib`, `interpolationlib`, `iolib`, `jnull`, `jvoid`, `linear_algebralib`, `m2scilib`, `matiolib`, `modules_managerlib`, `neldermeadlib`, `optimbaselib`, `optimizationlib`, `optimsimplexlib`, `output_streamlib`, `overloadinglib`, `parameterslib`, `polynomialslib`, `preferenceslib`, `randliblib`, `scicos_autolib`, `scicos_utilslib`, `scinoteslib`, `signal_processinglib`, `simulated_annealinglib`, `soundlib`, `sparselib`, `special_functionslib`, `spreadsheetlib`, `statisticslib`, `stringlib`, `tclscilib`, `timelib`, `umfpacklib`, `xcoslib`), NameConstant, nil}, {`-|==|~=|<|>|<=|>=|&&|&|~|\|\|?`, Operator, nil}, {`\.\*|\*|\+|\.\^|\.\\|\.\/|\/|\\`, Operator, nil}, {`[\[\](){}@.,=:;]`, Punctuation, nil}, {`"[^"]*"`, LiteralString, nil}, {`(?<=[\w)\].])\'+`, Operator, nil}, {`(?<![\w)\].])\'`, LiteralString, Push("string")}, {`(\d+\.\d*|\d*\.\d+)([eEf][+-]?[0-9]+)?`, LiteralNumberFloat, nil}, {`\d+[eEf][+-]?[0-9]+`, LiteralNumberFloat, nil}, {`\d+`, LiteralNumberInteger, nil}, {`[a-zA-Z_]\w*`, Name, nil}, {`.`, Text, nil}, }, "string": { {`[^']*'`, LiteralString, Pop(1)}, {`.`, LiteralString, Pop(1)}, }, "deffunc": { {`(\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)}, }, }, ))
Scilab lexer.
var Scss = Register(MustNewLexer( &Config{ Name: "SCSS", Aliases: []string{"scss"}, Filenames: []string{"*.scss"}, MimeTypes: []string{"text/x-scss"}, NotMultiline: true, DotAll: true, CaseInsensitive: true, }, Rules{ "root": { {`\s+`, Text, nil}, {`//.*?\n`, CommentSingle, nil}, {`/\*.*?\*/`, CommentMultiline, nil}, {`@import`, Keyword, Push("value")}, {`@for`, Keyword, Push("for")}, {`@(debug|warn|if|while)`, Keyword, Push("value")}, {`(@mixin)( [\w-]+)`, ByGroups(Keyword, NameFunction), Push("value")}, {`(@include)( [\w-]+)`, ByGroups(Keyword, NameDecorator), Push("value")}, {`@extend`, Keyword, Push("selector")}, {`(@media)(\s+)`, ByGroups(Keyword, Text), Push("value")}, {`@[\w-]+`, Keyword, Push("selector")}, {`(\$[\w-]*\w)([ \t]*:)`, ByGroups(NameVariable, Operator), Push("value")}, Default(Push("selector")), }, "attr": { {`[^\s:="\[]+`, NameAttribute, nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, {`[ \t]*:`, Operator, Push("value")}, Default(Pop(1)), }, "inline-comment": { {`(\\#|#(?=[^{])|\*(?=[^/])|[^#*])+`, CommentMultiline, nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, {`\*/`, Comment, Pop(1)}, }, "value": { {`[ \t]+`, Text, nil}, {`[!$][\w-]+`, NameVariable, nil}, {`url\(`, LiteralStringOther, Push("string-url")}, {`[a-z_-][\w-]*(?=\()`, NameFunction, nil}, {Words(``, `\b`, `align-content`, `align-items`, `align-self`, `alignment-baseline`, `all`, `animation`, `animation-delay`, `animation-direction`, `animation-duration`, `animation-fill-mode`, `animation-iteration-count`, `animation-name`, `animation-play-state`, `animation-timing-function`, `appearance`, `azimuth`, `backface-visibility`, `background`, `background-attachment`, `background-blend-mode`, `background-clip`, `background-color`, `background-image`, `background-origin`, `background-position`, `background-repeat`, `background-size`, `baseline-shift`, `bookmark-label`, `bookmark-level`, `bookmark-state`, `border`, `border-bottom`, `border-bottom-color`, `border-bottom-left-radius`, `border-bottom-right-radius`, `border-bottom-style`, `border-bottom-width`, `border-boundary`, `border-collapse`, `border-color`, `border-image`, `border-image-outset`, `border-image-repeat`, `border-image-slice`, `border-image-source`, `border-image-width`, `border-left`, `border-left-color`, `border-left-style`, `border-left-width`, `border-radius`, `border-right`, `border-right-color`, `border-right-style`, `border-right-width`, `border-spacing`, `border-style`, `border-top`, `border-top-color`, `border-top-left-radius`, `border-top-right-radius`, `border-top-style`, `border-top-width`, `border-width`, `bottom`, `box-decoration-break`, `box-shadow`, `box-sizing`, `box-snap`, `box-suppress`, `break-after`, `break-before`, `break-inside`, `caption-side`, `caret`, `caret-animation`, `caret-color`, `caret-shape`, `chains`, `clear`, `clip`, `clip-path`, `clip-rule`, `color`, `color-interpolation-filters`, `column-count`, `column-fill`, `column-gap`, `column-rule`, `column-rule-color`, `column-rule-style`, `column-rule-width`, `column-span`, `column-width`, `columns`, `content`, `counter-increment`, `counter-reset`, `counter-set`, `crop`, `cue`, `cue-after`, `cue-before`, `cursor`, `direction`, `display`, `dominant-baseline`, `elevation`, `empty-cells`, `filter`, `flex`, `flex-basis`, `flex-direction`, `flex-flow`, `flex-grow`, `flex-shrink`, `flex-wrap`, `float`, `float-defer`, `float-offset`, `float-reference`, `flood-color`, `flood-opacity`, `flow`, `flow-from`, `flow-into`, `font`, `font-family`, `font-feature-settings`, `font-kerning`, `font-language-override`, `font-size`, `font-size-adjust`, `font-stretch`, `font-style`, `font-synthesis`, `font-variant`, `font-variant-alternates`, `font-variant-caps`, `font-variant-east-asian`, `font-variant-ligatures`, `font-variant-numeric`, `font-variant-position`, `font-weight`, `footnote-display`, `footnote-policy`, `glyph-orientation-vertical`, `grid`, `grid-area`, `grid-auto-columns`, `grid-auto-flow`, `grid-auto-rows`, `grid-column`, `grid-column-end`, `grid-column-gap`, `grid-column-start`, `grid-gap`, `grid-row`, `grid-row-end`, `grid-row-gap`, `grid-row-start`, `grid-template`, `grid-template-areas`, `grid-template-columns`, `grid-template-rows`, `hanging-punctuation`, `height`, `hyphenate-character`, `hyphenate-limit-chars`, `hyphenate-limit-last`, `hyphenate-limit-lines`, `hyphenate-limit-zone`, `hyphens`, `image-orientation`, `image-resolution`, `initial-letter`, `initial-letter-align`, `initial-letter-wrap`, `isolation`, `justify-content`, `justify-items`, `justify-self`, `left`, `letter-spacing`, `lighting-color`, `line-break`, `line-grid`, `line-height`, `line-snap`, `list-style`, `list-style-image`, `list-style-position`, `list-style-type`, `margin`, `margin-bottom`, `margin-left`, `margin-right`, `margin-top`, `marker-side`, `marquee-direction`, `marquee-loop`, `marquee-speed`, `marquee-style`, `mask`, `mask-border`, `mask-border-mode`, `mask-border-outset`, `mask-border-repeat`, `mask-border-slice`, `mask-border-source`, `mask-border-width`, `mask-clip`, `mask-composite`, `mask-image`, `mask-mode`, `mask-origin`, `mask-position`, `mask-repeat`, `mask-size`, `mask-type`, `max-height`, `max-lines`, `max-width`, `min-height`, `min-width`, `mix-blend-mode`, `motion`, `motion-offset`, `motion-path`, `motion-rotation`, `move-to`, `nav-down`, `nav-left`, `nav-right`, `nav-up`, `object-fit`, `object-position`, `offset-after`, `offset-before`, `offset-end`, `offset-start`, `opacity`, `order`, `orphans`, `outline`, `outline-color`, `outline-offset`, `outline-style`, `outline-width`, `overflow`, `overflow-style`, `overflow-wrap`, `overflow-x`, `overflow-y`, `padding`, `padding-bottom`, `padding-left`, `padding-right`, `padding-top`, `page`, `page-break-after`, `page-break-before`, `page-break-inside`, `page-policy`, `pause`, `pause-after`, `pause-before`, `perspective`, `perspective-origin`, `pitch`, `pitch-range`, `play-during`, `polar-angle`, `polar-distance`, `position`, `presentation-level`, `quotes`, `region-fragment`, `resize`, `rest`, `rest-after`, `rest-before`, `richness`, `right`, `rotation`, `rotation-point`, `ruby-align`, `ruby-merge`, `ruby-position`, `running`, `scroll-snap-coordinate`, `scroll-snap-destination`, `scroll-snap-points-x`, `scroll-snap-points-y`, `scroll-snap-type`, `shape-image-threshold`, `shape-inside`, `shape-margin`, `shape-outside`, `size`, `speak`, `speak-as`, `speak-header`, `speak-numeral`, `speak-punctuation`, `speech-rate`, `stress`, `string-set`, `tab-size`, `table-layout`, `text-align`, `text-align-last`, `text-combine-upright`, `text-decoration`, `text-decoration-color`, `text-decoration-line`, `text-decoration-skip`, `text-decoration-style`, `text-emphasis`, `text-emphasis-color`, `text-emphasis-position`, `text-emphasis-style`, `text-indent`, `text-justify`, `text-orientation`, `text-overflow`, `text-shadow`, `text-space-collapse`, `text-space-trim`, `text-spacing`, `text-transform`, `text-underline-position`, `text-wrap`, `top`, `transform`, `transform-origin`, `transform-style`, `transition`, `transition-delay`, `transition-duration`, `transition-property`, `transition-timing-function`, `unicode-bidi`, `user-select`, `vertical-align`, `visibility`, `voice-balance`, `voice-duration`, `voice-family`, `voice-pitch`, `voice-range`, `voice-rate`, `voice-stress`, `voice-volume`, `volume`, `white-space`, `widows`, `width`, `will-change`, `word-break`, `word-spacing`, `word-wrap`, `wrap-after`, `wrap-before`, `wrap-flow`, `wrap-inside`, `wrap-through`, `writing-mode`, `z-index`, `above`, `absolute`, `always`, `armenian`, `aural`, `auto`, `avoid`, `baseline`, `behind`, `below`, `bidi-override`, `blink`, `block`, `bold`, `bolder`, `both`, `capitalize`, `center-left`, `center-right`, `center`, `circle`, `cjk-ideographic`, `close-quote`, `collapse`, `condensed`, `continuous`, `crop`, `crosshair`, `cross`, `cursive`, `dashed`, `decimal-leading-zero`, `decimal`, `default`, `digits`, `disc`, `dotted`, `double`, `e-resize`, `embed`, `extra-condensed`, `extra-expanded`, `expanded`, `fantasy`, `far-left`, `far-right`, `faster`, `fast`, `fixed`, `georgian`, `groove`, `hebrew`, `help`, `hidden`, `hide`, `higher`, `high`, `hiragana-iroha`, `hiragana`, `icon`, `inherit`, `inline-table`, `inline`, `inset`, `inside`, `invert`, `italic`, `justify`, `katakana-iroha`, `katakana`, `landscape`, `larger`, `large`, `left-side`, `leftwards`, `level`, `lighter`, `line-through`, `list-item`, `loud`, `lower-alpha`, `lower-greek`, `lower-roman`, `lowercase`, `ltr`, `lower`, `low`, `medium`, `message-box`, `middle`, `mix`, `monospace`, `n-resize`, `narrower`, `ne-resize`, `no-close-quote`, `no-open-quote`, `no-repeat`, `none`, `normal`, `nowrap`, `nw-resize`, `oblique`, `once`, `open-quote`, `outset`, `outside`, `overline`, `pointer`, `portrait`, `px`, `relative`, `repeat-x`, `repeat-y`, `repeat`, `rgb`, `ridge`, `right-side`, `rightwards`, `s-resize`, `sans-serif`, `scroll`, `se-resize`, `semi-condensed`, `semi-expanded`, `separate`, `serif`, `show`, `silent`, `slow`, `slower`, `small-caps`, `small-caption`, `smaller`, `soft`, `solid`, `spell-out`, `square`, `static`, `status-bar`, `super`, `sw-resize`, `table-caption`, `table-cell`, `table-column`, `table-column-group`, `table-footer-group`, `table-header-group`, `table-row`, `table-row-group`, `text`, `text-bottom`, `text-top`, `thick`, `thin`, `transparent`, `ultra-condensed`, `ultra-expanded`, `underline`, `upper-alpha`, `upper-latin`, `upper-roman`, `uppercase`, `url`, `visible`, `w-resize`, `wait`, `wider`, `x-fast`, `x-high`, `x-large`, `x-loud`, `x-low`, `x-small`, `x-soft`, `xx-large`, `xx-small`, `yes`), NameConstant, nil}, {Words(``, `\b`, `aliceblue`, `antiquewhite`, `aqua`, `aquamarine`, `azure`, `beige`, `bisque`, `black`, `blanchedalmond`, `blue`, `blueviolet`, `brown`, `burlywood`, `cadetblue`, `chartreuse`, `chocolate`, `coral`, `cornflowerblue`, `cornsilk`, `crimson`, `cyan`, `darkblue`, `darkcyan`, `darkgoldenrod`, `darkgray`, `darkgreen`, `darkgrey`, `darkkhaki`, `darkmagenta`, `darkolivegreen`, `darkorange`, `darkorchid`, `darkred`, `darksalmon`, `darkseagreen`, `darkslateblue`, `darkslategray`, `darkslategrey`, `darkturquoise`, `darkviolet`, `deeppink`, `deepskyblue`, `dimgray`, `dimgrey`, `dodgerblue`, `firebrick`, `floralwhite`, `forestgreen`, `fuchsia`, `gainsboro`, `ghostwhite`, `gold`, `goldenrod`, `gray`, `green`, `greenyellow`, `grey`, `honeydew`, `hotpink`, `indianred`, `indigo`, `ivory`, `khaki`, `lavender`, `lavenderblush`, `lawngreen`, `lemonchiffon`, `lightblue`, `lightcoral`, `lightcyan`, `lightgoldenrodyellow`, `lightgray`, `lightgreen`, `lightgrey`, `lightpink`, `lightsalmon`, `lightseagreen`, `lightskyblue`, `lightslategray`, `lightslategrey`, `lightsteelblue`, `lightyellow`, `lime`, `limegreen`, `linen`, `magenta`, `maroon`, `mediumaquamarine`, `mediumblue`, `mediumorchid`, `mediumpurple`, `mediumseagreen`, `mediumslateblue`, `mediumspringgreen`, `mediumturquoise`, `mediumvioletred`, `midnightblue`, `mintcream`, `mistyrose`, `moccasin`, `navajowhite`, `navy`, `oldlace`, `olive`, `olivedrab`, `orange`, `orangered`, `orchid`, `palegoldenrod`, `palegreen`, `paleturquoise`, `palevioletred`, `papayawhip`, `peachpuff`, `peru`, `pink`, `plum`, `powderblue`, `purple`, `rebeccapurple`, `red`, `rosybrown`, `royalblue`, `saddlebrown`, `salmon`, `sandybrown`, `seagreen`, `seashell`, `sienna`, `silver`, `skyblue`, `slateblue`, `slategray`, `slategrey`, `snow`, `springgreen`, `steelblue`, `tan`, `teal`, `thistle`, `tomato`, `turquoise`, `violet`, `wheat`, `white`, `whitesmoke`, `yellow`, `yellowgreen`, `transparent`), NameEntity, nil}, {Words(``, `\b`, `black`, `silver`, `gray`, `white`, `maroon`, `red`, `purple`, `fuchsia`, `green`, `lime`, `olive`, `yellow`, `navy`, `blue`, `teal`, `aqua`), NameBuiltin, nil}, {`\!(important|default)`, NameException, nil}, {`(true|false)`, NamePseudo, nil}, {`(and|or|not)`, OperatorWord, nil}, {`/\*`, CommentMultiline, Push("inline-comment")}, {`//[^\n]*`, CommentSingle, nil}, {`\#[a-z0-9]{1,6}`, LiteralNumberHex, nil}, {`(-?\d+)(\%|[a-z]+)?`, ByGroups(LiteralNumberInteger, KeywordType), nil}, {`(-?\d*\.\d+)(\%|[a-z]+)?`, ByGroups(LiteralNumberFloat, KeywordType), nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, {`[~^*!&%<>|+=@:,./?-]+`, Operator, nil}, {`[\[\]()]+`, Punctuation, nil}, {`"`, LiteralStringDouble, Push("string-double")}, {`'`, LiteralStringSingle, Push("string-single")}, {`[a-z_-][\w-]*`, Name, nil}, {`\n`, Text, nil}, {`[;{}]`, Punctuation, Pop(1)}, }, "interpolation": { {`\}`, LiteralStringInterpol, Pop(1)}, Include("value"), }, "selector": { {`[ \t]+`, Text, nil}, {`\:`, NameDecorator, Push("pseudo-class")}, {`\.`, NameClass, Push("class")}, {`\#`, NameNamespace, Push("id")}, {`[\w-]+`, NameTag, nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, {`&`, Keyword, nil}, {`[~^*!&\[\]()<>|+=@:;,./?-]`, Operator, nil}, {`"`, LiteralStringDouble, Push("string-double")}, {`'`, LiteralStringSingle, Push("string-single")}, {`\n`, Text, nil}, {`[;{}]`, Punctuation, Pop(1)}, }, "string-double": { {`(\\.|#(?=[^\n{])|[^\n"#])+`, LiteralStringDouble, nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, {`"`, LiteralStringDouble, Pop(1)}, }, "string-single": { {`(\\.|#(?=[^\n{])|[^\n'#])+`, LiteralStringDouble, nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, {`'`, LiteralStringDouble, Pop(1)}, }, "string-url": { {`(\\#|#(?=[^\n{])|[^\n#)])+`, LiteralStringOther, nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, {`\)`, LiteralStringOther, Pop(1)}, }, "pseudo-class": { {`[\w-]+`, NameDecorator, nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, Default(Pop(1)), }, "class": { {`[\w-]+`, NameClass, nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, Default(Pop(1)), }, "id": { {`[\w-]+`, NameNamespace, nil}, {`#\{`, LiteralStringInterpol, Push("interpolation")}, Default(Pop(1)), }, "for": { {`(from|to|through)`, OperatorWord, nil}, Include("value"), }, }, ))
Scss lexer.
var Smalltalk = Register(MustNewLexer( &Config{ Name: "Smalltalk", Aliases: []string{"smalltalk", "squeak", "st"}, Filenames: []string{"*.st"}, MimeTypes: []string{"text/x-smalltalk"}, }, Rules{ "root": { {`(<)(\w+:)(.*?)(>)`, ByGroups(Text, Keyword, Text, Text), nil}, Include("squeak fileout"), Include("whitespaces"), Include("method definition"), {`(\|)([\w\s]*)(\|)`, ByGroups(Operator, NameVariable, Operator), nil}, Include("objects"), {`\^|:=|_`, Operator, nil}, {`[\]({}.;!]`, Text, nil}, }, "method definition": { {`([a-zA-Z]+\w*:)(\s*)(\w+)`, ByGroups(NameFunction, Text, NameVariable), nil}, {`^(\b[a-zA-Z]+\w*\b)(\s*)$`, ByGroups(NameFunction, Text), nil}, {`^([-+*/\\~<>=|&!?,@%]+)(\s*)(\w+)(\s*)$`, ByGroups(NameFunction, Text, NameVariable, Text), nil}, }, "blockvariables": { Include("whitespaces"), {`(:)(\s*)(\w+)`, ByGroups(Operator, Text, NameVariable), nil}, {`\|`, Operator, Pop(1)}, Default(Pop(1)), }, "literals": { {`'(''|[^'])*'`, LiteralString, Push("afterobject")}, {`\$.`, LiteralStringChar, Push("afterobject")}, {`#\(`, LiteralStringSymbol, Push("parenth")}, {`\)`, Text, Push("afterobject")}, {`(\d+r)?-?\d+(\.\d+)?(e-?\d+)?`, LiteralNumber, Push("afterobject")}, }, "_parenth_helper": { Include("whitespaces"), {`(\d+r)?-?\d+(\.\d+)?(e-?\d+)?`, LiteralNumber, nil}, {`[-+*/\\~<>=|&#!?,@%\w:]+`, LiteralStringSymbol, nil}, {`'(''|[^'])*'`, LiteralString, nil}, {`\$.`, LiteralStringChar, nil}, {`#*\(`, LiteralStringSymbol, Push("inner_parenth")}, }, "parenth": { {`\)`, LiteralStringSymbol, Push("root", "afterobject")}, Include("_parenth_helper"), }, "inner_parenth": { {`\)`, LiteralStringSymbol, Pop(1)}, Include("_parenth_helper"), }, "whitespaces": { {`\s+`, Text, nil}, {`"(""|[^"])*"`, Comment, nil}, }, "objects": { {`\[`, Text, Push("blockvariables")}, {`\]`, Text, Push("afterobject")}, {`\b(self|super|true|false|nil|thisContext)\b`, NameBuiltinPseudo, Push("afterobject")}, {`\b[A-Z]\w*(?!:)\b`, NameClass, Push("afterobject")}, {`\b[a-z]\w*(?!:)\b`, NameVariable, Push("afterobject")}, {`#("(""|[^"])*"|[-+*/\\~<>=|&!?,@%]+|[\w:]+)`, LiteralStringSymbol, Push("afterobject")}, Include("literals"), }, "afterobject": { {`! !$`, Keyword, Pop(1)}, Include("whitespaces"), {`\b(ifTrue:|ifFalse:|whileTrue:|whileFalse:|timesRepeat:)`, NameBuiltin, Pop(1)}, {`\b(new\b(?!:))`, NameBuiltin, nil}, {`:=|_`, Operator, Pop(1)}, {`\b[a-zA-Z]+\w*:`, NameFunction, Pop(1)}, {`\b[a-zA-Z]+\w*`, NameFunction, nil}, {`\w+:?|[-+*/\\~<>=|&!?,@%]+`, NameFunction, Pop(1)}, {`\.`, Punctuation, Pop(1)}, {`;`, Punctuation, nil}, {`[\])}]`, Text, nil}, {`[\[({]`, Text, Pop(1)}, }, "squeak fileout": { {`^"(""|[^"])*"!`, Keyword, nil}, {`^'(''|[^'])*'!`, Keyword, nil}, {`^(!)(\w+)( commentStamp: )(.*?)( prior: .*?!\n)(.*?)(!)`, ByGroups(Keyword, NameClass, Keyword, LiteralString, Keyword, Text, Keyword), nil}, {`^(!)(\w+(?: class)?)( methodsFor: )('(?:''|[^'])*')(.*?!)`, ByGroups(Keyword, NameClass, Keyword, LiteralString, Keyword), nil}, {"" /* 141 byte string literal not displayed */, ByGroups(NameClass, Keyword, LiteralStringSymbol, Keyword, LiteralString, Keyword, LiteralString, Keyword, LiteralString, Keyword, LiteralString, Keyword), nil}, {`^(\w+(?: class)?)(\s+instanceVariableNames: )(.*?)(!)`, ByGroups(NameClass, Keyword, LiteralString, Keyword), nil}, {`(!\n)(\].*)(! !)$`, ByGroups(Keyword, Text, Keyword), nil}, {`! !$`, Keyword, nil}, }, }, ))
Smalltalk lexer.
var Smarty = Register(MustNewLexer( &Config{ Name: "Smarty", Aliases: []string{"smarty"}, Filenames: []string{"*.tpl"}, MimeTypes: []string{"application/x-smarty"}, DotAll: true, }, Rules{ "root": { {`[^{]+`, Other, nil}, {`(\{)(\*.*?\*)(\})`, ByGroups(CommentPreproc, Comment, CommentPreproc), nil}, {`(\{php\})(.*?)(\{/php\})`, ByGroups(CommentPreproc, Using(PHP, nil), CommentPreproc), nil}, {`(\{)(/?[a-zA-Z_]\w*)(\s*)`, ByGroups(CommentPreproc, NameFunction, Text), Push("smarty")}, {`\{`, CommentPreproc, Push("smarty")}, }, "smarty": { {`\s+`, Text, nil}, {`\{`, CommentPreproc, Push()}, {`\}`, CommentPreproc, Pop(1)}, {`#[a-zA-Z_]\w*#`, NameVariable, nil}, {`\$[a-zA-Z_]\w*(\.\w+)*`, NameVariable, nil}, {`[~!%^&*()+=|\[\]:;,.<>/?@-]`, Operator, nil}, {`(true|false|null)\b`, KeywordConstant, nil}, {`[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?`, LiteralNumber, nil}, {`"(\\\\|\\"|[^"])*"`, LiteralStringDouble, nil}, {`'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil}, {`[a-zA-Z_]\w*`, NameAttribute, nil}, }, }, ))
Smarty lexer.
var Snobol = Register(MustNewLexer( &Config{ Name: "Snobol", Aliases: []string{"snobol"}, Filenames: []string{"*.snobol"}, MimeTypes: []string{"text/x-snobol"}, }, Rules{ "root": { {`\*.*\n`, Comment, nil}, {`[+.] `, Punctuation, Push("statement")}, {`-.*\n`, Comment, nil}, {`END\s*\n`, NameLabel, Push("heredoc")}, {`[A-Za-z$][\w$]*`, NameLabel, Push("statement")}, {`\s+`, Text, Push("statement")}, }, "statement": { {`\s*\n`, Text, Pop(1)}, {`\s+`, Text, nil}, {"" /* 244 byte string literal not displayed */, NameBuiltin, nil}, {`[A-Za-z][\w.]*`, Name, nil}, {`\*\*|[?$.!%*/#+\-@|&\\=]`, Operator, nil}, {`"[^"]*"`, LiteralString, nil}, {`'[^']*'`, LiteralString, nil}, {`[0-9]+(?=[^.EeDd])`, LiteralNumberInteger, nil}, {`[0-9]+(\.[0-9]*)?([EDed][-+]?[0-9]+)?`, LiteralNumberFloat, nil}, {`:`, Punctuation, Push("goto")}, {`[()<>,;]`, Punctuation, nil}, }, "goto": { {`\s*\n`, Text, Pop(2)}, {`\s+`, Text, nil}, {`F|S`, Keyword, nil}, {`(\()([A-Za-z][\w.]*)(\))`, ByGroups(Punctuation, NameLabel, Punctuation), nil}, }, "heredoc": { {`.*\n`, LiteralStringHeredoc, nil}, }, }, ))
Snobol lexer.
var Sparql = Register(MustNewLexer( &Config{ Name: "SPARQL", Aliases: []string{"sparql"}, Filenames: []string{"*.rq", "*.sparql"}, MimeTypes: []string{"application/sparql-query"}, }, Rules{ "root": { {`\s+`, Text, nil}, {"" /* 356 byte string literal not displayed */, Keyword, nil}, {`(a)\b`, Keyword, nil}, {"(<(?:[^<>\"{}|^`\\\\\\x00-\\x20])*>)", NameLabel, nil}, {"" /* 285 byte string literal not displayed */, NameLabel, nil}, {"" /* 181 byte string literal not displayed */, NameVariable, nil}, {"" /* 758 byte string literal not displayed */, ByGroups(NameNamespace, Punctuation, NameTag), nil}, {"" /* 423 byte string literal not displayed */, NameFunction, nil}, {`(true|false)`, KeywordConstant, nil}, {`[+\-]?(\d+\.\d*[eE][+-]?\d+|\.?\d+[eE][+-]?\d+)`, LiteralNumberFloat, nil}, {`[+\-]?(\d+\.\d*|\.\d+)`, LiteralNumberFloat, nil}, {`[+\-]?\d+`, LiteralNumberInteger, nil}, {`(\|\||&&|=|\*|\-|\+|/|!=|<=|>=|!|<|>)`, Operator, nil}, {`[(){}.;,:^\[\]]`, Punctuation, nil}, {`#[^\n]*`, Comment, nil}, {`"""`, LiteralString, Push("triple-double-quoted-string")}, {`"`, LiteralString, Push("single-double-quoted-string")}, {`'''`, LiteralString, Push("triple-single-quoted-string")}, {`'`, LiteralString, Push("single-single-quoted-string")}, }, "triple-double-quoted-string": { {`"""`, LiteralString, Push("end-of-string")}, {`[^\\]+`, LiteralString, nil}, {`\\`, LiteralString, Push("string-escape")}, }, "single-double-quoted-string": { {`"`, LiteralString, Push("end-of-string")}, {`[^"\\\n]+`, LiteralString, nil}, {`\\`, LiteralString, Push("string-escape")}, }, "triple-single-quoted-string": { {`'''`, LiteralString, Push("end-of-string")}, {`[^\\]+`, LiteralString, nil}, {`\\`, LiteralStringEscape, Push("string-escape")}, }, "single-single-quoted-string": { {`'`, LiteralString, Push("end-of-string")}, {`[^'\\\n]+`, LiteralString, nil}, {`\\`, LiteralString, Push("string-escape")}, }, "string-escape": { {`u[0-9A-Fa-f]{4}`, LiteralStringEscape, Pop(1)}, {`U[0-9A-Fa-f]{8}`, LiteralStringEscape, Pop(1)}, {`.`, LiteralStringEscape, Pop(1)}, }, "end-of-string": { {`(@)([a-zA-Z]+(?:-[a-zA-Z0-9]+)*)`, ByGroups(Operator, NameFunction), Pop(2)}, {`\^\^`, Operator, Pop(2)}, Default(Pop(2)), }, }, ))
Sparql lexer.
var Sql = Register(MustNewLexer( &Config{ Name: "SQL", Aliases: []string{"sql"}, Filenames: []string{"*.sql"}, MimeTypes: []string{"text/x-sql"}, NotMultiline: true, CaseInsensitive: true, }, Rules{ "root": { {`\s+`, Text, nil}, {`--.*\n?`, CommentSingle, nil}, {`/\*`, CommentMultiline, Push("multiline-comments")}, {`'`, LiteralStringSingle, Push("string")}, {`"`, LiteralStringDouble, Push("double-string")}, {Words(``, `\b`, `ABORT`, `ABS`, `ABSOLUTE`, `ACCESS`, `ADA`, `ADD`, `ADMIN`, `AFTER`, `AGGREGATE`, `ALIAS`, `ALL`, `ALLOCATE`, `ALTER`, `ANALYSE`, `ANALYZE`, `AND`, `ANY`, `ARE`, `AS`, `ASC`, `ASENSITIVE`, `ASSERTION`, `ASSIGNMENT`, `ASYMMETRIC`, `AT`, `ATOMIC`, `AUTHORIZATION`, `AVG`, `BACKWARD`, `BEFORE`, `BEGIN`, `BETWEEN`, `BITVAR`, `BIT_LENGTH`, `BOTH`, `BREADTH`, `BY`, `C`, `CACHE`, `CALL`, `CALLED`, `CARDINALITY`, `CASCADE`, `CASCADED`, `CASE`, `CAST`, `CATALOG`, `CATALOG_NAME`, `CHAIN`, `CHARACTERISTICS`, `CHARACTER_LENGTH`, `CHARACTER_SET_CATALOG`, `CHARACTER_SET_NAME`, `CHARACTER_SET_SCHEMA`, `CHAR_LENGTH`, `CHECK`, `CHECKED`, `CHECKPOINT`, `CLASS`, `CLASS_ORIGIN`, `CLOB`, `CLOSE`, `CLUSTER`, `COALSECE`, `COBOL`, `COLLATE`, `COLLATION`, `COLLATION_CATALOG`, `COLLATION_NAME`, `COLLATION_SCHEMA`, `COLUMN`, `COLUMN_NAME`, `COMMAND_FUNCTION`, `COMMAND_FUNCTION_CODE`, `COMMENT`, `COMMIT`, `COMMITTED`, `COMPLETION`, `CONDITION_NUMBER`, `CONNECT`, `CONNECTION`, `CONNECTION_NAME`, `CONSTRAINT`, `CONSTRAINTS`, `CONSTRAINT_CATALOG`, `CONSTRAINT_NAME`, `CONSTRAINT_SCHEMA`, `CONSTRUCTOR`, `CONTAINS`, `CONTINUE`, `CONVERSION`, `CONVERT`, `COPY`, `CORRESPONTING`, `COUNT`, `CREATE`, `CREATEDB`, `CREATEUSER`, `CROSS`, `CUBE`, `CURRENT`, `CURRENT_DATE`, `CURRENT_PATH`, `CURRENT_ROLE`, `CURRENT_TIME`, `CURRENT_TIMESTAMP`, `CURRENT_USER`, `CURSOR`, `CURSOR_NAME`, `CYCLE`, `DATA`, `DATABASE`, `DATETIME_INTERVAL_CODE`, `DATETIME_INTERVAL_PRECISION`, `DAY`, `DEALLOCATE`, `DECLARE`, `DEFAULT`, `DEFAULTS`, `DEFERRABLE`, `DEFERRED`, `DEFINED`, `DEFINER`, `DELETE`, `DELIMITER`, `DELIMITERS`, `DEREF`, `DESC`, `DESCRIBE`, `DESCRIPTOR`, `DESTROY`, `DESTRUCTOR`, `DETERMINISTIC`, `DIAGNOSTICS`, `DICTIONARY`, `DISCONNECT`, `DISPATCH`, `DISTINCT`, `DO`, `DOMAIN`, `DROP`, `DYNAMIC`, `DYNAMIC_FUNCTION`, `DYNAMIC_FUNCTION_CODE`, `EACH`, `ELSE`, `ELSIF`, `ENCODING`, `ENCRYPTED`, `END`, `END-EXEC`, `EQUALS`, `ESCAPE`, `EVERY`, `EXCEPTION`, `EXCEPT`, `EXCLUDING`, `EXCLUSIVE`, `EXEC`, `EXECUTE`, `EXISTING`, `EXISTS`, `EXPLAIN`, `EXTERNAL`, `EXTRACT`, `FALSE`, `FETCH`, `FINAL`, `FIRST`, `FOR`, `FORCE`, `FOREIGN`, `FORTRAN`, `FORWARD`, `FOUND`, `FREE`, `FREEZE`, `FROM`, `FULL`, `FUNCTION`, `G`, `GENERAL`, `GENERATED`, `GET`, `GLOBAL`, `GO`, `GOTO`, `GRANT`, `GRANTED`, `GROUP`, `GROUPING`, `HANDLER`, `HAVING`, `HIERARCHY`, `HOLD`, `HOST`, `IDENTITY`, `IF`, `IGNORE`, `ILIKE`, `IMMEDIATE`, `IMMUTABLE`, `IMPLEMENTATION`, `IMPLICIT`, `IN`, `INCLUDING`, `INCREMENT`, `INDEX`, `INDITCATOR`, `INFIX`, `INHERITS`, `INITIALIZE`, `INITIALLY`, `INNER`, `INOUT`, `INPUT`, `INSENSITIVE`, `INSERT`, `INSTANTIABLE`, `INSTEAD`, `INTERSECT`, `INTO`, `INVOKER`, `IS`, `ISNULL`, `ISOLATION`, `ITERATE`, `JOIN`, `KEY`, `KEY_MEMBER`, `KEY_TYPE`, `LANCOMPILER`, `LANGUAGE`, `LARGE`, `LAST`, `LATERAL`, `LEADING`, `LEFT`, `LENGTH`, `LESS`, `LEVEL`, `LIKE`, `LIMIT`, `LISTEN`, `LOAD`, `LOCAL`, `LOCALTIME`, `LOCALTIMESTAMP`, `LOCATION`, `LOCATOR`, `LOCK`, `LOWER`, `MAP`, `MATCH`, `MAX`, `MAXVALUE`, `MESSAGE_LENGTH`, `MESSAGE_OCTET_LENGTH`, `MESSAGE_TEXT`, `METHOD`, `MIN`, `MINUTE`, `MINVALUE`, `MOD`, `MODE`, `MODIFIES`, `MODIFY`, `MONTH`, `MORE`, `MOVE`, `MUMPS`, `NAMES`, `NATIONAL`, `NATURAL`, `NCHAR`, `NCLOB`, `NEW`, `NEXT`, `NO`, `NOCREATEDB`, `NOCREATEUSER`, `NONE`, `NOT`, `NOTHING`, `NOTIFY`, `NOTNULL`, `NULL`, `NULLABLE`, `NULLIF`, `OBJECT`, `OCTET_LENGTH`, `OF`, `OFF`, `OFFSET`, `OIDS`, `OLD`, `ON`, `ONLY`, `OPEN`, `OPERATION`, `OPERATOR`, `OPTION`, `OPTIONS`, `OR`, `ORDER`, `ORDINALITY`, `OUT`, `OUTER`, `OUTPUT`, `OVERLAPS`, `OVERLAY`, `OVERRIDING`, `OWNER`, `PAD`, `PARAMETER`, `PARAMETERS`, `PARAMETER_MODE`, `PARAMATER_NAME`, `PARAMATER_ORDINAL_POSITION`, `PARAMETER_SPECIFIC_CATALOG`, `PARAMETER_SPECIFIC_NAME`, `PARAMATER_SPECIFIC_SCHEMA`, `PARTIAL`, `PASCAL`, `PENDANT`, `PLACING`, `PLI`, `POSITION`, `POSTFIX`, `PRECISION`, `PREFIX`, `PREORDER`, `PREPARE`, `PRESERVE`, `PRIMARY`, `PRIOR`, `PRIVILEGES`, `PROCEDURAL`, `PROCEDURE`, `PUBLIC`, `READ`, `READS`, `RECHECK`, `RECURSIVE`, `REF`, `REFERENCES`, `REFERENCING`, `REINDEX`, `RELATIVE`, `RENAME`, `REPEATABLE`, `REPLACE`, `RESET`, `RESTART`, `RESTRICT`, `RESULT`, `RETURN`, `RETURNED_LENGTH`, `RETURNED_OCTET_LENGTH`, `RETURNED_SQLSTATE`, `RETURNS`, `REVOKE`, `RIGHT`, `ROLE`, `ROLLBACK`, `ROLLUP`, `ROUTINE`, `ROUTINE_CATALOG`, `ROUTINE_NAME`, `ROUTINE_SCHEMA`, `ROW`, `ROWS`, `ROW_COUNT`, `RULE`, `SAVE_POINT`, `SCALE`, `SCHEMA`, `SCHEMA_NAME`, `SCOPE`, `SCROLL`, `SEARCH`, `SECOND`, `SECURITY`, `SELECT`, `SELF`, `SENSITIVE`, `SERIALIZABLE`, `SERVER_NAME`, `SESSION`, `SESSION_USER`, `SET`, `SETOF`, `SETS`, `SHARE`, `SHOW`, `SIMILAR`, `SIMPLE`, `SIZE`, `SOME`, `SOURCE`, `SPACE`, `SPECIFIC`, `SPECIFICTYPE`, `SPECIFIC_NAME`, `SQL`, `SQLCODE`, `SQLERROR`, `SQLEXCEPTION`, `SQLSTATE`, `SQLWARNINIG`, `STABLE`, `START`, `STATE`, `STATEMENT`, `STATIC`, `STATISTICS`, `STDIN`, `STDOUT`, `STORAGE`, `STRICT`, `STRUCTURE`, `STYPE`, `SUBCLASS_ORIGIN`, `SUBLIST`, `SUBSTRING`, `SUM`, `SYMMETRIC`, `SYSID`, `SYSTEM`, `SYSTEM_USER`, `TABLE`, `TABLE_NAME`, ` TEMP`, `TEMPLATE`, `TEMPORARY`, `TERMINATE`, `THAN`, `THEN`, `TIMESTAMP`, `TIMEZONE_HOUR`, `TIMEZONE_MINUTE`, `TO`, `TOAST`, `TRAILING`, `TRANSATION`, `TRANSACTIONS_COMMITTED`, `TRANSACTIONS_ROLLED_BACK`, `TRANSATION_ACTIVE`, `TRANSFORM`, `TRANSFORMS`, `TRANSLATE`, `TRANSLATION`, `TREAT`, `TRIGGER`, `TRIGGER_CATALOG`, `TRIGGER_NAME`, `TRIGGER_SCHEMA`, `TRIM`, `TRUE`, `TRUNCATE`, `TRUSTED`, `TYPE`, `UNCOMMITTED`, `UNDER`, `UNENCRYPTED`, `UNION`, `UNIQUE`, `UNKNOWN`, `UNLISTEN`, `UNNAMED`, `UNNEST`, `UNTIL`, `UPDATE`, `UPPER`, `USAGE`, `USER`, `USER_DEFINED_TYPE_CATALOG`, `USER_DEFINED_TYPE_NAME`, `USER_DEFINED_TYPE_SCHEMA`, `USING`, `VACUUM`, `VALID`, `VALIDATOR`, `VALUES`, `VARIABLE`, `VERBOSE`, `VERSION`, `VIEW`, `VOLATILE`, `WHEN`, `WHENEVER`, `WHERE`, `WITH`, `WITHOUT`, `WORK`, `WRITE`, `YEAR`, `ZONE`), Keyword, nil}, {Words(``, `\b`, `ARRAY`, `BIGINT`, `BINARY`, `BIT`, `BLOB`, `BOOLEAN`, `CHAR`, `CHARACTER`, `DATE`, `DEC`, `DECIMAL`, `FLOAT`, `INT`, `INTEGER`, `INTERVAL`, `NUMBER`, `NUMERIC`, `REAL`, `SERIAL`, `SMALLINT`, `VARCHAR`, `VARYING`, `INT8`, `SERIAL8`, `TEXT`), NameBuiltin, nil}, {"[+*/<>=~!@#%^&|`?-]", Operator, nil}, {`[0-9]+`, LiteralNumberInteger, nil}, {`[a-z_][\w$]*`, Name, nil}, {`[;:()\[\],.]`, Punctuation, nil}, }, "multiline-comments": { {`/\*`, CommentMultiline, Push("multiline-comments")}, {`\*/`, CommentMultiline, Pop(1)}, {`[^/*]+`, CommentMultiline, nil}, {`[/*]`, CommentMultiline, nil}, }, "string": { {`[^']+`, LiteralStringSingle, nil}, {`''`, LiteralStringSingle, nil}, {`'`, LiteralStringSingle, Pop(1)}, }, "double-string": { {`[^"]+`, LiteralStringDouble, nil}, {`""`, LiteralStringDouble, nil}, {`"`, LiteralStringDouble, Pop(1)}, }, }, ))
Sql lexer.
var Squidconf = Register(MustNewLexer( &Config{ Name: "SquidConf", Aliases: []string{"squidconf", "squid.conf", "squid"}, Filenames: []string{"squid.conf"}, MimeTypes: []string{"text/x-squidconf"}, NotMultiline: true, CaseInsensitive: true, }, Rules{ "root": { {`\s+`, TextWhitespace, nil}, {`#`, Comment, Push("comment")}, {Words(`\b`, `\b`, `access_log`, `acl`, `always_direct`, `announce_host`, `announce_period`, `announce_port`, `announce_to`, `anonymize_headers`, `append_domain`, `as_whois_server`, `auth_param_basic`, `authenticate_children`, `authenticate_program`, `authenticate_ttl`, `broken_posts`, `buffered_logs`, `cache_access_log`, `cache_announce`, `cache_dir`, `cache_dns_program`, `cache_effective_group`, `cache_effective_user`, `cache_host`, `cache_host_acl`, `cache_host_domain`, `cache_log`, `cache_mem`, `cache_mem_high`, `cache_mem_low`, `cache_mgr`, `cachemgr_passwd`, `cache_peer`, `cache_peer_access`, `cahce_replacement_policy`, `cache_stoplist`, `cache_stoplist_pattern`, `cache_store_log`, `cache_swap`, `cache_swap_high`, `cache_swap_log`, `cache_swap_low`, `client_db`, `client_lifetime`, `client_netmask`, `connect_timeout`, `coredump_dir`, `dead_peer_timeout`, `debug_options`, `delay_access`, `delay_class`, `delay_initial_bucket_level`, `delay_parameters`, `delay_pools`, `deny_info`, `dns_children`, `dns_defnames`, `dns_nameservers`, `dns_testnames`, `emulate_httpd_log`, `err_html_text`, `fake_user_agent`, `firewall_ip`, `forwarded_for`, `forward_snmpd_port`, `fqdncache_size`, `ftpget_options`, `ftpget_program`, `ftp_list_width`, `ftp_passive`, `ftp_user`, `half_closed_clients`, `header_access`, `header_replace`, `hierarchy_stoplist`, `high_response_time_warning`, `high_page_fault_warning`, `hosts_file`, `htcp_port`, `http_access`, `http_anonymizer`, `httpd_accel`, `httpd_accel_host`, `httpd_accel_port`, `httpd_accel_uses_host_header`, `httpd_accel_with_proxy`, `http_port`, `http_reply_access`, `icp_access`, `icp_hit_stale`, `icp_port`, `icp_query_timeout`, `ident_lookup`, `ident_lookup_access`, `ident_timeout`, `incoming_http_average`, `incoming_icp_average`, `inside_firewall`, `ipcache_high`, `ipcache_low`, `ipcache_size`, `local_domain`, `local_ip`, `logfile_rotate`, `log_fqdn`, `log_icp_queries`, `log_mime_hdrs`, `maximum_object_size`, `maximum_single_addr_tries`, `mcast_groups`, `mcast_icp_query_timeout`, `mcast_miss_addr`, `mcast_miss_encode_key`, `mcast_miss_port`, `memory_pools`, `memory_pools_limit`, `memory_replacement_policy`, `mime_table`, `min_http_poll_cnt`, `min_icp_poll_cnt`, `minimum_direct_hops`, `minimum_object_size`, `minimum_retry_timeout`, `miss_access`, `negative_dns_ttl`, `negative_ttl`, `neighbor_timeout`, `neighbor_type_domain`, `netdb_high`, `netdb_low`, `netdb_ping_period`, `netdb_ping_rate`, `never_direct`, `no_cache`, `passthrough_proxy`, `pconn_timeout`, `pid_filename`, `pinger_program`, `positive_dns_ttl`, `prefer_direct`, `proxy_auth`, `proxy_auth_realm`, `query_icmp`, `quick_abort`, `quick_abort_max`, `quick_abort_min`, `quick_abort_pct`, `range_offset_limit`, `read_timeout`, `redirect_children`, `redirect_program`, `redirect_rewrites_host_header`, `reference_age`, `refresh_pattern`, `reload_into_ims`, `request_body_max_size`, `request_size`, `request_timeout`, `shutdown_lifetime`, `single_parent_bypass`, `siteselect_timeout`, `snmp_access`, `snmp_incoming_address`, `snmp_port`, `source_ping`, `ssl_proxy`, `store_avg_object_size`, `store_objects_per_bucket`, `strip_query_terms`, `swap_level1_dirs`, `swap_level2_dirs`, `tcp_incoming_address`, `tcp_outgoing_address`, `tcp_recv_bufsize`, `test_reachability`, `udp_hit_obj`, `udp_hit_obj_size`, `udp_incoming_address`, `udp_outgoing_address`, `unique_hostname`, `unlinkd_program`, `uri_whitespace`, `useragent_log`, `visible_hostname`, `wais_relay`, `wais_relay_host`, `wais_relay_port`), Keyword, nil}, {Words(`\b`, `\b`, `proxy-only`, `weight`, `ttl`, `no-query`, `default`, `round-robin`, `multicast-responder`, `on`, `off`, `all`, `deny`, `allow`, `via`, `parent`, `no-digest`, `heap`, `lru`, `realm`, `children`, `q1`, `q2`, `credentialsttl`, `none`, `disable`, `offline_toggle`, `diskd`), NameConstant, nil}, {Words(`\b`, `\b`, `shutdown`, `info`, `parameter`, `server_list`, `client_list`, `squid.conf`), LiteralString, nil}, {Words(`stats/`, `\b`, `objects`, `vm_objects`, `utilization`, `ipcache`, `fqdncache`, `dns`, `redirector`, `io`, `reply_headers`, `filedescriptors`, `netdb`), LiteralString, nil}, {Words(`log/`, `=`, `status`, `enable`, `disable`, `clear`), LiteralString, nil}, {Words(`\b`, `\b`, `url_regex`, `urlpath_regex`, `referer_regex`, `port`, `proto`, `req_mime_type`, `rep_mime_type`, `method`, `browser`, `user`, `src`, `dst`, `time`, `dstdomain`, `ident`, `snmp_community`), Keyword, nil}, {"" /* 838 byte string literal not displayed */, LiteralNumberFloat, nil}, {`(?:\b\d+\b(?:-\b\d+|%)?)`, LiteralNumber, nil}, {`\S+`, Text, nil}, }, "comment": { {`\s*TAG:.*`, LiteralStringEscape, Pop(1)}, {`.+`, Comment, Pop(1)}, Default(Pop(1)), }, }, ))
Squidconf lexer.
var Swift = Register(MustNewLexer( &Config{ Name: "Swift", Aliases: []string{"swift"}, Filenames: []string{"*.swift"}, MimeTypes: []string{"text/x-swift"}, }, Rules{ "root": { {`\n`, Text, nil}, {`\s+`, Text, nil}, {`//`, CommentSingle, Push("comment-single")}, {`/\*`, CommentMultiline, Push("comment-multi")}, {`#(if|elseif|else|endif|available)\b`, CommentPreproc, Push("preproc")}, Include("keywords"), {Words(``, `\b`, `Array`, `AutoreleasingUnsafeMutablePointer`, `BidirectionalReverseView`, `Bit`, `Bool`, `CFunctionPointer`, `COpaquePointer`, `CVaListPointer`, `Character`, `ClosedInterval`, `CollectionOfOne`, `ContiguousArray`, `Dictionary`, `DictionaryGenerator`, `DictionaryIndex`, `Double`, `EmptyCollection`, `EmptyGenerator`, `EnumerateGenerator`, `EnumerateSequence`, `FilterCollectionView`, `FilterCollectionViewIndex`, `FilterGenerator`, `FilterSequenceView`, `Float`, `Float80`, `FloatingPointClassification`, `GeneratorOf`, `GeneratorOfOne`, `GeneratorSequence`, `HalfOpenInterval`, `HeapBuffer`, `HeapBufferStorage`, `ImplicitlyUnwrappedOptional`, `IndexingGenerator`, `Int`, `Int16`, `Int32`, `Int64`, `Int8`, `LazyBidirectionalCollection`, `LazyForwardCollection`, `LazyRandomAccessCollection`, `LazySequence`, `MapCollectionView`, `MapSequenceGenerator`, `MapSequenceView`, `MirrorDisposition`, `ObjectIdentifier`, `OnHeap`, `Optional`, `PermutationGenerator`, `QuickLookObject`, `RandomAccessReverseView`, `Range`, `RangeGenerator`, `RawByte`, `Repeat`, `ReverseBidirectionalIndex`, `ReverseRandomAccessIndex`, `SequenceOf`, `SinkOf`, `Slice`, `StaticString`, `StrideThrough`, `StrideThroughGenerator`, `StrideTo`, `StrideToGenerator`, `String`, `UInt`, `UInt16`, `UInt32`, `UInt64`, `UInt8`, `UTF16`, `UTF32`, `UTF8`, `UnicodeDecodingResult`, `UnicodeScalar`, `Unmanaged`, `UnsafeBufferPointer`, `UnsafeBufferPointerGenerator`, `UnsafeMutableBufferPointer`, `UnsafeMutablePointer`, `UnsafePointer`, `Zip2`, `ZipGenerator2`, `AbsoluteValuable`, `AnyObject`, `ArrayLiteralConvertible`, `BidirectionalIndexType`, `BitwiseOperationsType`, `BooleanLiteralConvertible`, `BooleanType`, `CVarArgType`, `CollectionType`, `Comparable`, `DebugPrintable`, `DictionaryLiteralConvertible`, `Equatable`, `ExtendedGraphemeClusterLiteralConvertible`, `ExtensibleCollectionType`, `FloatLiteralConvertible`, `FloatingPointType`, `ForwardIndexType`, `GeneratorType`, `Hashable`, `IntegerArithmeticType`, `IntegerLiteralConvertible`, `IntegerType`, `IntervalType`, `MirrorType`, `MutableCollectionType`, `MutableSliceable`, `NilLiteralConvertible`, `OutputStreamType`, `Printable`, `RandomAccessIndexType`, `RangeReplaceableCollectionType`, `RawOptionSetType`, `RawRepresentable`, `Reflectable`, `SequenceType`, `SignedIntegerType`, `SignedNumberType`, `SinkType`, `Sliceable`, `Streamable`, `Strideable`, `StringInterpolationConvertible`, `StringLiteralConvertible`, `UnicodeCodecType`, `UnicodeScalarLiteralConvertible`, `UnsignedIntegerType`, `_ArrayBufferType`, `_BidirectionalIndexType`, `_CocoaStringType`, `_CollectionType`, `_Comparable`, `_ExtensibleCollectionType`, `_ForwardIndexType`, `_Incrementable`, `_IntegerArithmeticType`, `_IntegerType`, `_ObjectiveCBridgeable`, `_RandomAccessIndexType`, `_RawOptionSetType`, `_SequenceType`, `_Sequence_Type`, `_SignedIntegerType`, `_SignedNumberType`, `_Sliceable`, `_Strideable`, `_SwiftNSArrayRequiredOverridesType`, `_SwiftNSArrayType`, `_SwiftNSCopyingType`, `_SwiftNSDictionaryRequiredOverridesType`, `_SwiftNSDictionaryType`, `_SwiftNSEnumeratorType`, `_SwiftNSFastEnumerationType`, `_SwiftNSStringRequiredOverridesType`, `_SwiftNSStringType`, `_UnsignedIntegerType`, `C_ARGC`, `C_ARGV`, `Process`, `Any`, `AnyClass`, `BooleanLiteralType`, `CBool`, `CChar`, `CChar16`, `CChar32`, `CDouble`, `CFloat`, `CInt`, `CLong`, `CLongLong`, `CShort`, `CSignedChar`, `CUnsignedInt`, `CUnsignedLong`, `CUnsignedShort`, `CWideChar`, `ExtendedGraphemeClusterType`, `Float32`, `Float64`, `FloatLiteralType`, `IntMax`, `IntegerLiteralType`, `StringLiteralType`, `UIntMax`, `UWord`, `UnicodeScalarType`, `Void`, `Word`, `NSErrorPointer`, `NSObjectProtocol`, `Selector`), NameBuiltin, nil}, {Words(``, `\b`, `abs`, `advance`, `alignof`, `alignofValue`, `assert`, `assertionFailure`, `contains`, `count`, `countElements`, `debugPrint`, `debugPrintln`, `distance`, `dropFirst`, `dropLast`, `dump`, `enumerate`, `equal`, `extend`, `fatalError`, `filter`, `find`, `first`, `getVaList`, `indices`, `insert`, `isEmpty`, `join`, `last`, `lazy`, `lexicographicalCompare`, `map`, `max`, `maxElement`, `min`, `minElement`, `numericCast`, `overlaps`, `partition`, `precondition`, `preconditionFailure`, `prefix`, `print`, `println`, `reduce`, `reflect`, `removeAll`, `removeAtIndex`, `removeLast`, `removeRange`, `reverse`, `sizeof`, `sizeofValue`, `sort`, `sorted`, `splice`, `split`, `startsWith`, `stride`, `strideof`, `strideofValue`, `suffix`, `swap`, `toDebugString`, `toString`, `transcode`, `underestimateCount`, `unsafeAddressOf`, `unsafeBitCast`, `unsafeDowncast`, `withExtendedLifetime`, `withUnsafeMutablePointer`, `withUnsafeMutablePointers`, `withUnsafePointer`, `withUnsafePointers`, `withVaList`), NameBuiltinPseudo, nil}, {`\$\d+`, NameVariable, nil}, {`0b[01_]+`, LiteralNumberBin, nil}, {`0o[0-7_]+`, LiteralNumberOct, nil}, {`0x[0-9a-fA-F_]+`, LiteralNumberHex, nil}, {`[0-9][0-9_]*(\.[0-9_]+[eE][+\-]?[0-9_]+|\.[0-9_]*|[eE][+\-]?[0-9_]+)`, LiteralNumberFloat, nil}, {`[0-9][0-9_]*`, LiteralNumberInteger, nil}, {`"`, LiteralString, Push("string")}, {"[(){}\\[\\].,:;=@#`?]|->|[<&?](?=\\w)|(?<=\\w)[>!?]", Punctuation, nil}, {`[/=\-+!*%<>&|^?~]+`, Operator, nil}, {`[a-zA-Z_]\w*`, Name, nil}, }, "keywords": { {Words(``, `\b`, `as`, `break`, `case`, `catch`, `continue`, `default`, `defer`, `do`, `else`, `fallthrough`, `for`, `guard`, `if`, `in`, `is`, `repeat`, `return`, `#selector`, `switch`, `throw`, `try`, `where`, `while`), Keyword, nil}, {`@availability\([^)]+\)`, KeywordReserved, nil}, {Words(``, `\b`, `associativity`, `convenience`, `dynamic`, `didSet`, `final`, `get`, `indirect`, `infix`, `inout`, `lazy`, `left`, `mutating`, `none`, `nonmutating`, `optional`, `override`, `postfix`, `precedence`, `prefix`, `Protocol`, `required`, `rethrows`, `right`, `set`, `throws`, `Type`, `unowned`, `weak`, `willSet`, `@availability`, `@autoclosure`, `@noreturn`, `@NSApplicationMain`, `@NSCopying`, `@NSManaged`, `@objc`, `@UIApplicationMain`, `@IBAction`, `@IBDesignable`, `@IBInspectable`, `@IBOutlet`), KeywordReserved, nil}, {"" /* 129 byte string literal not displayed */, KeywordConstant, nil}, {`import\b`, KeywordDeclaration, Push("module")}, {`(class|enum|extension|struct|protocol)(\s+)([a-zA-Z_]\w*)`, ByGroups(KeywordDeclaration, Text, NameClass), nil}, {`(func)(\s+)([a-zA-Z_]\w*)`, ByGroups(KeywordDeclaration, Text, NameFunction), nil}, {`(var|let)(\s+)([a-zA-Z_]\w*)`, ByGroups(KeywordDeclaration, Text, NameVariable), nil}, {Words(``, `\b`, `class`, `deinit`, `enum`, `extension`, `func`, `import`, `init`, `internal`, `let`, `operator`, `private`, `protocol`, `public`, `static`, `struct`, `subscript`, `typealias`, `var`), KeywordDeclaration, nil}, }, "comment": { {`:param: [a-zA-Z_]\w*|:returns?:|(FIXME|MARK|TODO):`, CommentSpecial, nil}, }, "comment-single": { {`\n`, Text, Pop(1)}, Include("comment"), {`[^\n]`, CommentSingle, nil}, }, "comment-multi": { Include("comment"), {`[^*/]`, CommentMultiline, nil}, {`/\*`, CommentMultiline, Push()}, {`\*/`, CommentMultiline, Pop(1)}, {`[*/]`, CommentMultiline, nil}, }, "module": { {`\n`, Text, Pop(1)}, {`[a-zA-Z_]\w*`, NameClass, nil}, Include("root"), }, "preproc": { {`\n`, Text, Pop(1)}, Include("keywords"), {`[A-Za-z]\w*`, CommentPreproc, nil}, Include("root"), }, "string": { {`\\\(`, LiteralStringInterpol, Push("string-intp")}, {`"`, LiteralString, Pop(1)}, {`\\['"\\nrt]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}`, LiteralStringEscape, nil}, {`[^\\"]+`, LiteralString, nil}, {`\\`, LiteralString, nil}, }, "string-intp": { {`\(`, LiteralStringInterpol, Push()}, {`\)`, LiteralStringInterpol, Pop(1)}, Include("root"), }, }, ))
Swift lexer.
var Systemverilog = Register(MustNewLexer( &Config{ Name: "systemverilog", Aliases: []string{"systemverilog", "sv"}, Filenames: []string{"*.sv", "*.svh"}, MimeTypes: []string{"text/x-systemverilog"}, EnsureNL: true, }, Rules{ "root": { {"^\\s*`define", CommentPreproc, Push("macro")}, {`^(\s*)(package)(\s+)`, ByGroups(Text, KeywordNamespace, Text), nil}, {`^(\s*)(import)(\s+)`, ByGroups(Text, KeywordNamespace, Text), Push("import")}, {`\n`, Text, nil}, {`\s+`, Text, nil}, {`\\\n`, Text, nil}, {`/(\\\n)?/(\n|(.|\n)*?[^\\]\n)`, CommentSingle, nil}, {`/(\\\n)?[*](.|\n)*?[*](\\\n)?/`, CommentMultiline, nil}, {`[{}#@]`, Punctuation, nil}, {`L?"`, LiteralString, Push("string")}, {`L?'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'`, LiteralStringChar, nil}, {`(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?`, LiteralNumberFloat, nil}, {`(\d+\.\d*|\.\d+|\d+[fF])[fF]?`, LiteralNumberFloat, nil}, {`([0-9]+)|(\'h)[0-9a-fA-F]+`, LiteralNumberHex, nil}, {`([0-9]+)|(\'b)[01]+`, LiteralNumberBin, nil}, {`([0-9]+)|(\'d)[0-9]+`, LiteralNumberInteger, nil}, {`([0-9]+)|(\'o)[0-7]+`, LiteralNumberOct, nil}, {`\'[01xz]`, LiteralNumber, nil}, {`\d+[Ll]?`, LiteralNumberInteger, nil}, {`\*/`, Error, nil}, {`[~!%^&*+=|?:<>/-]`, Operator, nil}, {`[()\[\],.;\']`, Punctuation, nil}, {"`[a-zA-Z_]\\w*", NameConstant, nil}, {Words(``, `\b`, `accept_on`, `alias`, `always`, `always_comb`, `always_ff`, `always_latch`, `and`, `assert`, `assign`, `assume`, `automatic`, `before`, `begin`, `bind`, `bins`, `binsof`, `bit`, `break`, `buf`, `bufif0`, `bufif1`, `byte`, `case`, `casex`, `casez`, `cell`, `chandle`, `checker`, `class`, `clocking`, `cmos`, `config`, `const`, `constraint`, `context`, `continue`, `cover`, `covergroup`, `coverpoint`, `cross`, `deassign`, `default`, `defparam`, `design`, `disable`, `dist`, `do`, `edge`, `else`, `end`, `endcase`, `endchecker`, `endclass`, `endclocking`, `endconfig`, `endfunction`, `endgenerate`, `endgroup`, `endinterface`, `endmodule`, `endpackage`, `endprimitive`, `endprogram`, `endproperty`, `endsequence`, `endspecify`, `endtable`, `endtask`, `enum`, `event`, `eventually`, `expect`, `export`, `extends`, `extern`, `final`, `first_match`, `for`, `force`, `foreach`, `forever`, `fork`, `forkjoin`, `function`, `generate`, `genvar`, `global`, `highz0`, `highz1`, `if`, `iff`, `ifnone`, `ignore_bins`, `illegal_bins`, `implies`, `import`, `incdir`, `include`, `initial`, `inout`, `input`, `inside`, `instance`, `int`, `integer`, `interface`, `intersect`, `join`, `join_any`, `join_none`, `large`, `let`, `liblist`, `library`, `local`, `localparam`, `logic`, `longint`, `macromodule`, `matches`, `medium`, `modport`, `module`, `nand`, `negedge`, `new`, `nexttime`, `nmos`, `nor`, `noshowcancelled`, `not`, `notif0`, `notif1`, `null`, `or`, `output`, `package`, `packed`, `parameter`, `pmos`, `posedge`, `primitive`, `priority`, `program`, `property`, `protected`, `pull0`, `pull1`, `pulldown`, `pullup`, `pulsestyle_ondetect`, `pulsestyle_onevent`, `pure`, `rand`, `randc`, `randcase`, `randsequence`, `rcmos`, `real`, `realtime`, `ref`, `reg`, `reject_on`, `release`, `repeat`, `restrict`, `return`, `rnmos`, `rpmos`, `rtran`, `rtranif0`, `rtranif1`, `s_always`, `s_eventually`, `s_nexttime`, `s_until`, `s_until_with`, `scalared`, `sequence`, `shortint`, `shortreal`, `showcancelled`, `signed`, `small`, `solve`, `specify`, `specparam`, `static`, `string`, `strong`, `strong0`, `strong1`, `struct`, `super`, `supply0`, `supply1`, `sync_accept_on`, `sync_reject_on`, `table`, `tagged`, `task`, `this`, `throughout`, `time`, `timeprecision`, `timeunit`, `tran`, `tranif0`, `tranif1`, `tri`, `tri0`, `tri1`, `triand`, `trior`, `trireg`, `type`, `typedef`, `union`, `unique`, `unique0`, `unsigned`, `until`, `until_with`, `untyped`, `use`, `uwire`, `var`, `vectored`, `virtual`, `void`, `wait`, `wait_order`, `wand`, `weak`, `weak0`, `weak1`, `while`, `wildcard`, `wire`, `with`, `within`, `wor`, `xnor`, `xor`), Keyword, nil}, {Words(``, `\b`, "`__FILE__", "`__LINE__", "`begin_keywords", "`celldefine", "`default_nettype", "`define", "`else", "`elsif", "`end_keywords", "`endcelldefine", "`endif", "`ifdef", "`ifndef", "`include", "`line", "`nounconnected_drive", "`pragma", "`resetall", "`timescale", "`unconnected_drive", "`undef", "`undefineall"), CommentPreproc, nil}, {Words(``, `\b`, `$display`, `$displayb`, `$displayh`, `$displayo`, `$dumpall`, `$dumpfile`, `$dumpflush`, `$dumplimit`, `$dumpoff`, `$dumpon`, `$dumpports`, `$dumpportsall`, `$dumpportsflush`, `$dumpportslimit`, `$dumpportsoff`, `$dumpportson`, `$dumpvars`, `$fclose`, `$fdisplay`, `$fdisplayb`, `$fdisplayh`, `$fdisplayo`, `$feof`, `$ferror`, `$fflush`, `$fgetc`, `$fgets`, `$finish`, `$fmonitor`, `$fmonitorb`, `$fmonitorh`, `$fmonitoro`, `$fopen`, `$fread`, `$fscanf`, `$fseek`, `$fstrobe`, `$fstrobeb`, `$fstrobeh`, `$fstrobeo`, `$ftell`, `$fwrite`, `$fwriteb`, `$fwriteh`, `$fwriteo`, `$monitor`, `$monitorb`, `$monitorh`, `$monitoro`, `$monitoroff`, `$monitoron`, `$plusargs`, `$random`, `$readmemb`, `$readmemh`, `$rewind`, `$sformat`, `$sformatf`, `$sscanf`, `$strobe`, `$strobeb`, `$strobeh`, `$strobeo`, `$swrite`, `$swriteb`, `$swriteh`, `$swriteo`, `$test`, `$ungetc`, `$value$plusargs`, `$write`, `$writeb`, `$writeh`, `$writememb`, `$writememh`, `$writeo`), NameBuiltin, nil}, {`(class)(\s+)`, ByGroups(Keyword, Text), Push("classname")}, {Words(``, `\b`, `byte`, `shortint`, `int`, `longint`, `integer`, `time`, `bit`, `logic`, `reg`, `supply0`, `supply1`, `tri`, `triand`, `trior`, `tri0`, `tri1`, `trireg`, `uwire`, `wire`, `wand`, `woshortreal`, `real`, `realtime`), KeywordType, nil}, {`[a-zA-Z_]\w*:(?!:)`, NameLabel, nil}, {`\$?[a-zA-Z_]\w*`, Name, nil}, }, "classname": { {`[a-zA-Z_]\w*`, NameClass, Pop(1)}, }, "string": { {`"`, LiteralString, Pop(1)}, {`\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})`, LiteralStringEscape, nil}, {`[^\\"\n]+`, LiteralString, nil}, {`\\\n`, LiteralString, nil}, {`\\`, LiteralString, nil}, }, "macro": { {`[^/\n]+`, CommentPreproc, nil}, {`/[*](.|\n)*?[*]/`, CommentMultiline, nil}, {`//.*?\n`, CommentSingle, Pop(1)}, {`/`, CommentPreproc, nil}, {`(?<=\\)\n`, CommentPreproc, nil}, {`\n`, CommentPreproc, Pop(1)}, }, "import": { {`[\w:]+\*?`, NameNamespace, Pop(1)}, }, }, ))
Systemverilog lexer.
var TOML = Register(MustNewLexer( &Config{ Name: "TOML", Aliases: []string{"toml"}, Filenames: []string{"*.toml"}, MimeTypes: []string{"text/x-toml"}, }, Rules{ "root": { {`\s+`, Text, nil}, {`#.*`, Comment, nil}, {Words(``, `\b`, `true`, `false`), KeywordConstant, nil}, {`\d\d\d\d-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d\+)?(Z|[+-]\d{2}:\d{2})`, LiteralDate, nil}, {`[+-]?[0-9](_?\d)*\.\d+`, LiteralNumberFloat, nil}, {`[+-]?[0-9](_?\d)*`, LiteralNumberInteger, nil}, {`"(\\\\|\\"|[^"])*"`, StringDouble, nil}, {`'(\\\\|\\'|[^'])*'`, StringSingle, nil}, {`[.,=\[\]]`, Punctuation, nil}, {`[^\W\d]\w*`, NameOther, nil}, }, }, ))
var Tasm = Register(MustNewLexer( &Config{ Name: "TASM", Aliases: []string{"tasm"}, Filenames: []string{"*.asm", "*.ASM", "*.tasm"}, MimeTypes: []string{"text/x-tasm"}, CaseInsensitive: true, }, Rules{ "root": { {`^\s*%`, CommentPreproc, Push("preproc")}, Include("whitespace"), {`[@a-z$._?][\w$.?#@~]*:`, NameLabel, nil}, {"" /* 221 byte string literal not displayed */, Keyword, Push("instruction-args")}, {`([@a-z$._?][\w$.?#@~]*)(\s+)(db|dd|dw|T[A-Z][a-z]+)`, ByGroups(NameConstant, KeywordDeclaration, KeywordDeclaration), Push("instruction-args")}, {`(?:res|d)[bwdqt]|times`, KeywordDeclaration, Push("instruction-args")}, {`[@a-z$._?][\w$.?#@~]*`, NameFunction, Push("instruction-args")}, {`[\r\n]+`, Text, nil}, }, "instruction-args": { {"\"(\\\\\"|[^\"\\n])*\"|'(\\\\'|[^'\\n])*'|`(\\\\`|[^`\\n])*`", LiteralString, nil}, {`(?:0x[0-9a-f]+|$0[0-9a-f]*|[0-9]+[0-9a-f]*h)`, LiteralNumberHex, nil}, {`[0-7]+q`, LiteralNumberOct, nil}, {`[01]+b`, LiteralNumberBin, nil}, {`[0-9]+\.e?[0-9]+`, LiteralNumberFloat, nil}, {`[0-9]+`, LiteralNumberInteger, nil}, Include("punctuation"), {`r[0-9][0-5]?[bwd]|[a-d][lh]|[er]?[a-d]x|[er]?[sb]p|[er]?[sd]i|[c-gs]s|st[0-7]|mm[0-7]|cr[0-4]|dr[0-367]|tr[3-7]`, NameBuiltin, nil}, {`[@a-z$._?][\w$.?#@~]*`, NameVariable, nil}, {`(\\\s*)(;.*)([\r\n])`, ByGroups(Text, CommentSingle, Text), nil}, {`[\r\n]+`, Text, Pop(1)}, Include("whitespace"), }, "preproc": { {`[^;\n]+`, CommentPreproc, nil}, {`;.*?\n`, CommentSingle, Pop(1)}, {`\n`, CommentPreproc, Pop(1)}, }, "whitespace": { {`[\n\r]`, Text, nil}, {`\\[\n\r]`, Text, nil}, {`[ \t]+`, Text, nil}, {`;.*`, CommentSingle, nil}, }, "punctuation": { {`[,():\[\]]+`, Punctuation, nil}, {`[&|^<>+*=/%~-]+`, Operator, nil}, {`[$]+`, KeywordConstant, nil}, {`seg|wrt|strict`, OperatorWord, nil}, {`byte|[dq]?word`, KeywordType, nil}, }, }, ))
Tasm lexer.
var Tcl = Register(MustNewLexer( &Config{ Name: "Tcl", Aliases: []string{"tcl"}, Filenames: []string{"*.tcl", "*.rvt"}, MimeTypes: []string{"text/x-tcl", "text/x-script.tcl", "application/x-tcl"}, }, Rules{ "root": { Include("command"), Include("basic"), Include("data"), {`\}`, Keyword, nil}, }, "command": { {Words(`\b`, `\b`, `after`, `apply`, `array`, `break`, `catch`, `continue`, `elseif`, `else`, `error`, `eval`, `expr`, `for`, `foreach`, `global`, `if`, `namespace`, `proc`, `rename`, `return`, `set`, `switch`, `then`, `trace`, `unset`, `update`, `uplevel`, `upvar`, `variable`, `vwait`, `while`), Keyword, Push("params")}, {Words(`\b`, `\b`, `append`, `bgerror`, `binary`, `cd`, `chan`, `clock`, `close`, `concat`, `dde`, `dict`, `encoding`, `eof`, `exec`, `exit`, `fblocked`, `fconfigure`, `fcopy`, `file`, `fileevent`, `flush`, `format`, `gets`, `glob`, `history`, `http`, `incr`, `info`, `interp`, `join`, `lappend`, `lassign`, `lindex`, `linsert`, `list`, `llength`, `load`, `loadTk`, `lrange`, `lrepeat`, `lreplace`, `lreverse`, `lsearch`, `lset`, `lsort`, `mathfunc`, `mathop`, `memory`, `msgcat`, `open`, `package`, `pid`, `pkg::create`, `pkg_mkIndex`, `platform`, `platform::shell`, `puts`, `pwd`, `re_syntax`, `read`, `refchan`, `regexp`, `registry`, `regsub`, `scan`, `seek`, `socket`, `source`, `split`, `string`, `subst`, `tell`, `time`, `tm`, `unknown`, `unload`), NameBuiltin, Push("params")}, {`([\w.-]+)`, NameVariable, Push("params")}, {`#`, Comment, Push("comment")}, }, "command-in-brace": { {Words(`\b`, `\b`, `after`, `apply`, `array`, `break`, `catch`, `continue`, `elseif`, `else`, `error`, `eval`, `expr`, `for`, `foreach`, `global`, `if`, `namespace`, `proc`, `rename`, `return`, `set`, `switch`, `then`, `trace`, `unset`, `update`, `uplevel`, `upvar`, `variable`, `vwait`, `while`), Keyword, Push("params-in-brace")}, {Words(`\b`, `\b`, `append`, `bgerror`, `binary`, `cd`, `chan`, `clock`, `close`, `concat`, `dde`, `dict`, `encoding`, `eof`, `exec`, `exit`, `fblocked`, `fconfigure`, `fcopy`, `file`, `fileevent`, `flush`, `format`, `gets`, `glob`, `history`, `http`, `incr`, `info`, `interp`, `join`, `lappend`, `lassign`, `lindex`, `linsert`, `list`, `llength`, `load`, `loadTk`, `lrange`, `lrepeat`, `lreplace`, `lreverse`, `lsearch`, `lset`, `lsort`, `mathfunc`, `mathop`, `memory`, `msgcat`, `open`, `package`, `pid`, `pkg::create`, `pkg_mkIndex`, `platform`, `platform::shell`, `puts`, `pwd`, `re_syntax`, `read`, `refchan`, `regexp`, `registry`, `regsub`, `scan`, `seek`, `socket`, `source`, `split`, `string`, `subst`, `tell`, `time`, `tm`, `unknown`, `unload`), NameBuiltin, Push("params-in-brace")}, {`([\w.-]+)`, NameVariable, Push("params-in-brace")}, {`#`, Comment, Push("comment")}, }, "command-in-bracket": { {Words(`\b`, `\b`, `after`, `apply`, `array`, `break`, `catch`, `continue`, `elseif`, `else`, `error`, `eval`, `expr`, `for`, `foreach`, `global`, `if`, `namespace`, `proc`, `rename`, `return`, `set`, `switch`, `then`, `trace`, `unset`, `update`, `uplevel`, `upvar`, `variable`, `vwait`, `while`), Keyword, Push("params-in-bracket")}, {Words(`\b`, `\b`, `append`, `bgerror`, `binary`, `cd`, `chan`, `clock`, `close`, `concat`, `dde`, `dict`, `encoding`, `eof`, `exec`, `exit`, `fblocked`, `fconfigure`, `fcopy`, `file`, `fileevent`, `flush`, `format`, `gets`, `glob`, `history`, `http`, `incr`, `info`, `interp`, `join`, `lappend`, `lassign`, `lindex`, `linsert`, `list`, `llength`, `load`, `loadTk`, `lrange`, `lrepeat`, `lreplace`, `lreverse`, `lsearch`, `lset`, `lsort`, `mathfunc`, `mathop`, `memory`, `msgcat`, `open`, `package`, `pid`, `pkg::create`, `pkg_mkIndex`, `platform`, `platform::shell`, `puts`, `pwd`, `re_syntax`, `read`, `refchan`, `regexp`, `registry`, `regsub`, `scan`, `seek`, `socket`, `source`, `split`, `string`, `subst`, `tell`, `time`, `tm`, `unknown`, `unload`), NameBuiltin, Push("params-in-bracket")}, {`([\w.-]+)`, NameVariable, Push("params-in-bracket")}, {`#`, Comment, Push("comment")}, }, "command-in-paren": { {Words(`\b`, `\b`, `after`, `apply`, `array`, `break`, `catch`, `continue`, `elseif`, `else`, `error`, `eval`, `expr`, `for`, `foreach`, `global`, `if`, `namespace`, `proc`, `rename`, `return`, `set`, `switch`, `then`, `trace`, `unset`, `update`, `uplevel`, `upvar`, `variable`, `vwait`, `while`), Keyword, Push("params-in-paren")}, {Words(`\b`, `\b`, `append`, `bgerror`, `binary`, `cd`, `chan`, `clock`, `close`, `concat`, `dde`, `dict`, `encoding`, `eof`, `exec`, `exit`, `fblocked`, `fconfigure`, `fcopy`, `file`, `fileevent`, `flush`, `format`, `gets`, `glob`, `history`, `http`, `incr`, `info`, `interp`, `join`, `lappend`, `lassign`, `lindex`, `linsert`, `list`, `llength`, `load`, `loadTk`, `lrange`, `lrepeat`, `lreplace`, `lreverse`, `lsearch`, `lset`, `lsort`, `mathfunc`, `mathop`, `memory`, `msgcat`, `open`, `package`, `pid`, `pkg::create`, `pkg_mkIndex`, `platform`, `platform::shell`, `puts`, `pwd`, `re_syntax`, `read`, `refchan`, `regexp`, `registry`, `regsub`, `scan`, `seek`, `socket`, `source`, `split`, `string`, `subst`, `tell`, `time`, `tm`, `unknown`, `unload`), NameBuiltin, Push("params-in-paren")}, {`([\w.-]+)`, NameVariable, Push("params-in-paren")}, {`#`, Comment, Push("comment")}, }, "basic": { {`\(`, Keyword, Push("paren")}, {`\[`, Keyword, Push("bracket")}, {`\{`, Keyword, Push("brace")}, {`"`, LiteralStringDouble, Push("string")}, {`(eq|ne|in|ni)\b`, OperatorWord, nil}, {`!=|==|<<|>>|<=|>=|&&|\|\||\*\*|[-+~!*/%<>&^|?:]`, Operator, nil}, }, "data": { {`\s+`, Text, nil}, {`0x[a-fA-F0-9]+`, LiteralNumberHex, nil}, {`0[0-7]+`, LiteralNumberOct, nil}, {`\d+\.\d+`, LiteralNumberFloat, nil}, {`\d+`, LiteralNumberInteger, nil}, {`\$([\w.:-]+)`, NameVariable, nil}, {`([\w.:-]+)`, Text, nil}, }, "params": { {`;`, Keyword, Pop(1)}, {`\n`, Text, Pop(1)}, {`(else|elseif|then)\b`, Keyword, nil}, Include("basic"), Include("data"), }, "params-in-brace": { {`\}`, Keyword, Push("#pop", "#pop")}, Include("params"), }, "params-in-paren": { {`\)`, Keyword, Push("#pop", "#pop")}, Include("params"), }, "params-in-bracket": { {`\]`, Keyword, Push("#pop", "#pop")}, Include("params"), }, "string": { {`\[`, LiteralStringDouble, Push("string-square")}, {`(?s)(\\\\|\\[0-7]+|\\.|[^"\\])`, LiteralStringDouble, nil}, {`"`, LiteralStringDouble, Pop(1)}, }, "string-square": { {`\[`, LiteralStringDouble, Push("string-square")}, {`(?s)(\\\\|\\[0-7]+|\\.|\\\n|[^\]\\])`, LiteralStringDouble, nil}, {`\]`, LiteralStringDouble, Pop(1)}, }, "brace": { {`\}`, Keyword, Pop(1)}, Include("command-in-brace"), Include("basic"), Include("data"), }, "paren": { {`\)`, Keyword, Pop(1)}, Include("command-in-paren"), Include("basic"), Include("data"), }, "bracket": { {`\]`, Keyword, Pop(1)}, Include("command-in-bracket"), Include("basic"), Include("data"), }, "comment": { {`.*[^\\]\n`, Comment, Pop(1)}, {`.*\\\n`, Comment, nil}, }, }, ))
Tcl lexer.
var Tcsh = Register(MustNewLexer( &Config{ Name: "Tcsh", Aliases: []string{"tcsh", "csh"}, Filenames: []string{"*.tcsh", "*.csh"}, MimeTypes: []string{"application/x-csh"}, }, Rules{ "root": { Include("basic"), {`\$\(`, Keyword, Push("paren")}, {`\$\{#?`, Keyword, Push("curly")}, {"`", LiteralStringBacktick, Push("backticks")}, Include("data"), }, "basic": { {`\b(if|endif|else|while|then|foreach|case|default|continue|goto|breaksw|end|switch|endsw)\s*\b`, Keyword, nil}, {"" /* 507 byte string literal not displayed */, NameBuiltin, nil}, {`#.*`, Comment, nil}, {`\\[\w\W]`, LiteralStringEscape, nil}, {`(\b\w+)(\s*)(=)`, ByGroups(NameVariable, Text, Operator), nil}, {`[\[\]{}()=]+`, Operator, nil}, {`<<\s*(\'?)\\?(\w+)[\w\W]+?\2`, LiteralString, nil}, {`;`, Punctuation, nil}, }, "data": { {`(?s)"(\\\\|\\[0-7]+|\\.|[^"\\])*"`, LiteralStringDouble, nil}, {`(?s)'(\\\\|\\[0-7]+|\\.|[^'\\])*'`, LiteralStringSingle, nil}, {`\s+`, Text, nil}, {"[^=\\s\\[\\]{}()$\"\\'`\\\\;#]+", Text, nil}, {`\d+(?= |\Z)`, LiteralNumber, nil}, {`\$#?(\w+|.)`, NameVariable, nil}, }, "curly": { {`\}`, Keyword, Pop(1)}, {`:-`, Keyword, nil}, {`\w+`, NameVariable, nil}, {"[^}:\"\\'`$]+", Punctuation, nil}, {`:`, Punctuation, nil}, Include("root"), }, "paren": { {`\)`, Keyword, Pop(1)}, Include("root"), }, "backticks": { {"`", LiteralStringBacktick, Pop(1)}, Include("root"), }, }, ))
Tcsh lexer.
var TeX = Register(MustNewLexer( &Config{ Name: "TeX", Aliases: []string{"tex", "latex"}, Filenames: []string{"*.tex", "*.aux", "*.toc"}, MimeTypes: []string{"text/x-tex", "text/x-latex"}, }, Rules{ "general": { {`%.*?\n`, Comment, nil}, {`[{}]`, NameBuiltin, nil}, {`[&_^]`, NameBuiltin, nil}, }, "root": { {`\\\[`, LiteralStringBacktick, Push("displaymath")}, {`\\\(`, LiteralString, Push("inlinemath")}, {`\$\$`, LiteralStringBacktick, Push("displaymath")}, {`\$`, LiteralString, Push("inlinemath")}, {`\\([a-zA-Z]+|.)`, Keyword, Push("command")}, {`\\$`, Keyword, nil}, Include("general"), {`[^\\$%&_^{}]+`, Text, nil}, }, "math": { {`\\([a-zA-Z]+|.)`, NameVariable, nil}, Include("general"), {`[0-9]+`, LiteralNumber, nil}, {`[-=!+*/()\[\]]`, Operator, nil}, {`[^=!+*/()\[\]\\$%&_^{}0-9-]+`, NameBuiltin, nil}, }, "inlinemath": { {`\\\)`, LiteralString, Pop(1)}, {`\$`, LiteralString, Pop(1)}, Include("math"), }, "displaymath": { {`\\\]`, LiteralString, Pop(1)}, {`\$\$`, LiteralString, Pop(1)}, {`\$`, NameBuiltin, nil}, Include("math"), }, "command": { {`\[.*?\]`, NameAttribute, nil}, {`\*`, Keyword, nil}, Default(Pop(1)), }, }, ))
Tex lexer.
var Termcap = Register(MustNewLexer( &Config{ Name: "Termcap", Aliases: []string{"termcap"}, Filenames: []string{"termcap", "termcap.src"}, MimeTypes: []string{}, }, Rules{ "root": { {`^#.*$`, Comment, nil}, {`^[^\s#:|]+`, NameTag, Push("names")}, }, "names": { {`\n`, Text, Pop(1)}, {`:`, Punctuation, Push("defs")}, {`\|`, Punctuation, nil}, {`[^:|]+`, NameAttribute, nil}, }, "defs": { {`\\\n[ \t]*`, Text, nil}, {`\n[ \t]*`, Text, Pop(2)}, {`(#)([0-9]+)`, ByGroups(Operator, LiteralNumber), nil}, {`=`, Operator, Push("data")}, {`:`, Punctuation, nil}, {`[^\s:=#]+`, NameClass, nil}, }, "data": { {`\\072`, Literal, nil}, {`:`, Punctuation, Pop(1)}, {`[^:\\]+`, Literal, nil}, {`.`, Literal, nil}, }, }, ))
Termcap lexer.
var Terminfo = Register(MustNewLexer( &Config{ Name: "Terminfo", Aliases: []string{"terminfo"}, Filenames: []string{"terminfo", "terminfo.src"}, MimeTypes: []string{}, }, Rules{ "root": { {`^#.*$`, Comment, nil}, {`^[^\s#,|]+`, NameTag, Push("names")}, }, "names": { {`\n`, Text, Pop(1)}, {`(,)([ \t]*)`, ByGroups(Punctuation, Text), Push("defs")}, {`\|`, Punctuation, nil}, {`[^,|]+`, NameAttribute, nil}, }, "defs": { {`\n[ \t]+`, Text, nil}, {`\n`, Text, Pop(2)}, {`(#)([0-9]+)`, ByGroups(Operator, LiteralNumber), nil}, {`=`, Operator, Push("data")}, {`(,)([ \t]*)`, ByGroups(Punctuation, Text), nil}, {`[^\s,=#]+`, NameClass, nil}, }, "data": { {`\\[,\\]`, Literal, nil}, {`(,)([ \t]*)`, ByGroups(Punctuation, Text), Pop(1)}, {`[^\\,]+`, Literal, nil}, {`.`, Literal, nil}, }, }, ))
Terminfo lexer.
var Terraform = Register(MustNewLexer( &Config{ Name: "Terraform", Aliases: []string{"terraform", "tf"}, Filenames: []string{"*.tf"}, MimeTypes: []string{"application/x-tf", "application/x-terraform"}, }, Rules{ "root": { Include("string"), Include("punctuation"), Include("curly"), Include("basic"), Include("whitespace"), {`[0-9]+`, LiteralNumber, nil}, }, "basic": { {Words(`\b`, `\b`, `true`, `false`), KeywordType, nil}, {`\s*/\*`, CommentMultiline, Push("comment")}, {`\s*#.*\n`, CommentSingle, nil}, {`(.*?)(\s*)(=)`, ByGroups(NameAttribute, Text, Operator), nil}, {Words(`\b`, `\b`, `variable`, `resource`, `provider`, `provisioner`, `module`), KeywordReserved, Push("function")}, {Words(`\b`, `\b`, `ingress`, `egress`, `listener`, `default`, `connection`, `alias`), KeywordDeclaration, nil}, {`\$\{`, LiteralStringInterpol, Push("var_builtin")}, }, "function": { {`(\s+)(".*")(\s+)`, ByGroups(Text, LiteralString, Text), nil}, Include("punctuation"), Include("curly"), }, "var_builtin": { {`\$\{`, LiteralStringInterpol, Push()}, {Words(`\b`, `\b`, `concat`, `file`, `join`, `lookup`, `element`), NameBuiltin, nil}, Include("string"), Include("punctuation"), {`\s+`, Text, nil}, {`\}`, LiteralStringInterpol, Pop(1)}, }, "string": { {`(".*")`, ByGroups(LiteralStringDouble), nil}, }, "punctuation": { {`[\[\](),.]`, Punctuation, nil}, }, "curly": { {`\{`, TextPunctuation, nil}, {`\}`, TextPunctuation, nil}, }, "comment": { {`[^*/]`, CommentMultiline, nil}, {`/\*`, CommentMultiline, Push()}, {`\*/`, CommentMultiline, Pop(1)}, {`[*/]`, CommentMultiline, nil}, }, "whitespace": { {`\n`, Text, nil}, {`\s+`, Text, nil}, {`\\\n`, Text, nil}, }, }, ))
Terraform lexer.
var Thrift = Register(MustNewLexer( &Config{ Name: "Thrift", Aliases: []string{"thrift"}, Filenames: []string{"*.thrift"}, MimeTypes: []string{"application/x-thrift"}, }, Rules{ "root": { Include("whitespace"), Include("comments"), {`"`, LiteralStringDouble, Combined("stringescape", "dqs")}, {`\'`, LiteralStringSingle, Combined("stringescape", "sqs")}, {`(namespace)(\s+)`, ByGroups(KeywordNamespace, TextWhitespace), Push("namespace")}, {`(enum|union|struct|service|exception)(\s+)`, ByGroups(KeywordDeclaration, TextWhitespace), Push("class")}, {`((?:(?:[^\W\d]|\$)[\w.\[\]$<>]*\s+)+?)((?:[^\W\d]|\$)[\w$]*)(\s*)(\()`, ByGroups(UsingSelf("root"), NameFunction, Text, Operator), nil}, Include("keywords"), Include("numbers"), {`[&=]`, Operator, nil}, {`[:;,{}()<>\[\]]`, Punctuation, nil}, {`[a-zA-Z_](\.\w|\w)*`, Name, nil}, }, "whitespace": { {`\n`, TextWhitespace, nil}, {`\s+`, TextWhitespace, nil}, }, "comments": { {`#.*$`, Comment, nil}, {`//.*?\n`, Comment, nil}, {`/\*[\w\W]*?\*/`, CommentMultiline, nil}, }, "stringescape": { {`\\([\\nrt"\'])`, LiteralStringEscape, nil}, }, "dqs": { {`"`, LiteralStringDouble, Pop(1)}, {`[^\\"\n]+`, LiteralStringDouble, nil}, }, "sqs": { {`'`, LiteralStringSingle, Pop(1)}, {`[^\\\'\n]+`, LiteralStringSingle, nil}, }, "namespace": { {`[a-z*](\.\w|\w)*`, NameNamespace, Pop(1)}, Default(Pop(1)), }, "class": { {`[a-zA-Z_]\w*`, NameClass, Pop(1)}, Default(Pop(1)), }, "keywords": { {`(async|oneway|extends|throws|required|optional)\b`, Keyword, nil}, {`(true|false)\b`, KeywordConstant, nil}, {`(const|typedef)\b`, KeywordDeclaration, nil}, {Words(``, `\b`, `cpp_namespace`, `cpp_include`, `cpp_type`, `java_package`, `cocoa_prefix`, `csharp_namespace`, `delphi_namespace`, `php_namespace`, `py_module`, `perl_package`, `ruby_namespace`, `smalltalk_category`, `smalltalk_prefix`, `xsd_all`, `xsd_optional`, `xsd_nillable`, `xsd_namespace`, `xsd_attrs`, `include`), KeywordNamespace, nil}, {Words(``, `\b`, `void`, `bool`, `byte`, `i16`, `i32`, `i64`, `double`, `string`, `binary`, `map`, `list`, `set`, `slist`, `senum`), KeywordType, nil}, {Words(`\b`, `\b`, `BEGIN`, `END`, `__CLASS__`, `__DIR__`, `__FILE__`, `__FUNCTION__`, `__LINE__`, `__METHOD__`, `__NAMESPACE__`, `abstract`, `alias`, `and`, `args`, `as`, `assert`, `begin`, `break`, `case`, `catch`, `class`, `clone`, `continue`, `declare`, `def`, `default`, `del`, `delete`, `do`, `dynamic`, `elif`, `else`, `elseif`, `elsif`, `end`, `enddeclare`, `endfor`, `endforeach`, `endif`, `endswitch`, `endwhile`, `ensure`, `except`, `exec`, `finally`, `float`, `for`, `foreach`, `function`, `global`, `goto`, `if`, `implements`, `import`, `in`, `inline`, `instanceof`, `interface`, `is`, `lambda`, `module`, `native`, `new`, `next`, `nil`, `not`, `or`, `pass`, `public`, `print`, `private`, `protected`, `raise`, `redo`, `rescue`, `retry`, `register`, `return`, `self`, `sizeof`, `static`, `super`, `switch`, `synchronized`, `then`, `this`, `throw`, `transient`, `try`, `undef`, `unless`, `unsigned`, `until`, `use`, `var`, `virtual`, `volatile`, `when`, `while`, `with`, `xor`, `yield`), KeywordReserved, nil}, }, "numbers": { {`[+-]?(\d+\.\d+([eE][+-]?\d+)?|\.?\d+[eE][+-]?\d+)`, LiteralNumberFloat, nil}, {`[+-]?0x[0-9A-Fa-f]+`, LiteralNumberHex, nil}, {`[+-]?[0-9]+`, LiteralNumberInteger, nil}, }, }, ))
Thrift lexer.
var TransactSQL = Register(MustNewLexer( &Config{ Name: "Transact-SQL", Aliases: []string{"tsql", "t-sql"}, MimeTypes: []string{"text/x-tsql"}, NotMultiline: true, CaseInsensitive: true, }, Rules{ "root": { {`\s+`, TextWhitespace, nil}, {`--(?m).*?$\n?`, CommentSingle, nil}, {`/\*`, CommentMultiline, Push("multiline-comments")}, {`'`, LiteralStringSingle, Push("string")}, {`"`, LiteralStringName, Push("quoted-ident")}, {Words(``, ``, `!<`, `!=`, `!>`, `<`, `<=`, `<>`, `=`, `>`, `>=`, `+`, `+=`, `-`, `-=`, `*`, `*=`, `/`, `/=`, `%`, `%=`, `&`, `&=`, `|`, `|=`, `^`, `^=`, `~`, `::`), Operator, nil}, {Words(``, `\b`, `all`, `and`, `any`, `between`, `except`, `exists`, `in`, `intersect`, `like`, `not`, `or`, `some`, `union`), OperatorWord, nil}, {Words(``, `\b`, `bigint`, `binary`, `bit`, `char`, `cursor`, `date`, `datetime`, `datetime2`, `datetimeoffset`, `decimal`, `float`, `hierarchyid`, `image`, `int`, `money`, `nchar`, `ntext`, `numeric`, `nvarchar`, `real`, `smalldatetime`, `smallint`, `smallmoney`, `sql_variant`, `table`, `text`, `time`, `timestamp`, `tinyint`, `uniqueidentifier`, `varbinary`, `varchar`, `xml`), NameClass, nil}, {Words(``, `\b`, `$partition`, `abs`, `acos`, `app_name`, `applock_mode`, `applock_test`, `ascii`, `asin`, `assemblyproperty`, `atan`, `atn2`, `avg`, `binary_checksum`, `cast`, `ceiling`, `certencoded`, `certprivatekey`, `char`, `charindex`, `checksum`, `checksum_agg`, `choose`, `col_length`, `col_name`, `columnproperty`, `compress`, `concat`, `connectionproperty`, `context_info`, `convert`, `cos`, `cot`, `count`, `count_big`, `current_request_id`, `current_timestamp`, `current_transaction_id`, `current_user`, `cursor_status`, `database_principal_id`, `databasepropertyex`, `dateadd`, `datediff`, `datediff_big`, `datefromparts`, `datename`, `datepart`, `datetime2fromparts`, `datetimefromparts`, `datetimeoffsetfromparts`, `day`, `db_id`, `db_name`, `decompress`, `degrees`, `dense_rank`, `difference`, `eomonth`, `error_line`, `error_message`, `error_number`, `error_procedure`, `error_severity`, `error_state`, `exp`, `file_id`, `file_idex`, `file_name`, `filegroup_id`, `filegroup_name`, `filegroupproperty`, `fileproperty`, `floor`, `format`, `formatmessage`, `fulltextcatalogproperty`, `fulltextserviceproperty`, `get_filestream_transaction_context`, `getansinull`, `getdate`, `getutcdate`, `grouping`, `grouping_id`, `has_perms_by_name`, `host_id`, `host_name`, `iif`, `index_col`, `indexkey_property`, `indexproperty`, `is_member`, `is_rolemember`, `is_srvrolemember`, `isdate`, `isjson`, `isnull`, `isnumeric`, `json_modify`, `json_query`, `json_value`, `left`, `len`, `log`, `log10`, `lower`, `ltrim`, `max`, `min`, `min_active_rowversion`, `month`, `nchar`, `newid`, `newsequentialid`, `ntile`, `object_definition`, `object_id`, `object_name`, `object_schema_name`, `objectproperty`, `objectpropertyex`, `opendatasource`, `openjson`, `openquery`, `openrowset`, `openxml`, `original_db_name`, `original_login`, `parse`, `parsename`, `patindex`, `permissions`, `pi`, `power`, `pwdcompare`, `pwdencrypt`, `quotename`, `radians`, `rand`, `rank`, `replace`, `replicate`, `reverse`, `right`, `round`, `row_number`, `rowcount_big`, `rtrim`, `schema_id`, `schema_name`, `scope_identity`, `serverproperty`, `session_context`, `session_user`, `sign`, `sin`, `smalldatetimefromparts`, `soundex`, `sp_helplanguage`, `space`, `sqrt`, `square`, `stats_date`, `stdev`, `stdevp`, `str`, `string_escape`, `string_split`, `stuff`, `substring`, `sum`, `suser_id`, `suser_name`, `suser_sid`, `suser_sname`, `switchoffset`, `sysdatetime`, `sysdatetimeoffset`, `system_user`, `sysutcdatetime`, `tan`, `textptr`, `textvalid`, `timefromparts`, `todatetimeoffset`, `try_cast`, `try_convert`, `try_parse`, `type_id`, `type_name`, `typeproperty`, `unicode`, `upper`, `user_id`, `user_name`, `var`, `varp`, `xact_state`, `year`), NameFunction, nil}, {`(goto)(\s+)(\w+\b)`, ByGroups(Keyword, TextWhitespace, NameLabel), nil}, {Words(``, `\b`, `absolute`, `action`, `ada`, `add`, `admin`, `after`, `aggregate`, `alias`, `all`, `allocate`, `alter`, `and`, `any`, `are`, `array`, `as`, `asc`, `asensitive`, `assertion`, `asymmetric`, `at`, `atomic`, `authorization`, `avg`, `backup`, `before`, `begin`, `between`, `binary`, `bit`, `bit_length`, `blob`, `boolean`, `both`, `breadth`, `break`, `browse`, `bulk`, `by`, `call`, `called`, `cardinality`, `cascade`, `cascaded`, `case`, `cast`, `catalog`, `catch`, `char`, `char_length`, `character`, `character_length`, `check`, `checkpoint`, `class`, `clob`, `close`, `clustered`, `coalesce`, `collate`, `collation`, `collect`, `column`, `commit`, `completion`, `compute`, `condition`, `connect`, `connection`, `constraint`, `constraints`, `constructor`, `contains`, `containstable`, `continue`, `convert`, `corr`, `corresponding`, `count`, `covar_pop`, `covar_samp`, `create`, `cross`, `cube`, `cume_dist`, `current`, `current_catalog`, `current_date`, `current_default_transform_group`, `current_path`, `current_role`, `current_schema`, `current_time`, `current_timestamp`, `current_transform_group_for_type`, `current_user`, `cursor`, `cycle`, `data`, `database`, `date`, `day`, `dbcc`, `deallocate`, `dec`, `decimal`, `declare`, `default`, `deferrable`, `deferred`, `delete`, `deny`, `depth`, `deref`, `desc`, `describe`, `descriptor`, `destroy`, `destructor`, `deterministic`, `diagnostics`, `dictionary`, `disconnect`, `disk`, `distinct`, `distributed`, `domain`, `double`, `drop`, `dump`, `dynamic`, `each`, `element`, `else`, `end`, `end-exec`, `equals`, `errlvl`, `escape`, `every`, `except`, `exception`, `exec`, `execute`, `exists`, `exit`, `external`, `extract`, `false`, `fetch`, `file`, `fillfactor`, `filter`, `first`, `float`, `for`, `foreign`, `fortran`, `found`, `free`, `freetext`, `freetexttable`, `from`, `full`, `fulltexttable`, `function`, `fusion`, `general`, `get`, `global`, `go`, `goto`, `grant`, `group`, `grouping`, `having`, `hold`, `holdlock`, `host`, `hour`, `identity`, `identity_insert`, `identitycol`, `if`, `ignore`, `immediate`, `in`, `include`, `index`, `indicator`, `initialize`, `initially`, `inner`, `inout`, `input`, `insensitive`, `insert`, `int`, `integer`, `intersect`, `intersection`, `interval`, `into`, `is`, `isolation`, `iterate`, `join`, `key`, `kill`, `language`, `large`, `last`, `lateral`, `leading`, `left`, `less`, `level`, `like`, `like_regex`, `limit`, `lineno`, `ln`, `load`, `local`, `localtime`, `localtimestamp`, `locator`, `lower`, `map`, `match`, `max`, `member`, `merge`, `method`, `min`, `minute`, `mod`, `modifies`, `modify`, `module`, `month`, `multiset`, `names`, `national`, `natural`, `nchar`, `nclob`, `new`, `next`, `no`, `nocheck`, `nonclustered`, `none`, `normalize`, `not`, `null`, `nullif`, `numeric`, `object`, `occurrences_regex`, `octet_length`, `of`, `off`, `offsets`, `old`, `on`, `only`, `open`, `opendatasource`, `openquery`, `openrowset`, `openxml`, `operation`, `option`, `or`, `order`, `ordinality`, `out`, `outer`, `output`, `over`, `overlaps`, `overlay`, `pad`, `parameter`, `parameters`, `partial`, `partition`, `pascal`, `path`, `percent`, `percent_rank`, `percentile_cont`, `percentile_disc`, `pivot`, `plan`, `position`, `position_regex`, `postfix`, `precision`, `prefix`, `preorder`, `prepare`, `preserve`, `primary`, `print`, `prior`, `privileges`, `proc`, `procedure`, `public`, `raiserror`, `range`, `read`, `reads`, `readtext`, `real`, `reconfigure`, `recursive`, `ref`, `references`, `referencing`, `regr_avgx`, `regr_avgy`, `regr_count`, `regr_intercept`, `regr_r2`, `regr_slope`, `regr_sxx`, `regr_sxy`, `regr_syy`, `relative`, `release`, `replication`, `restore`, `restrict`, `result`, `return`, `returns`, `revert`, `revoke`, `right`, `role`, `rollback`, `rollup`, `routine`, `row`, `rowcount`, `rowguidcol`, `rows`, `rule`, `save`, `savepoint`, `schema`, `scope`, `scroll`, `search`, `second`, `section`, `securityaudit`, `select`, `semantickeyphrasetable`, `semanticsimilaritydetailstable`, `semanticsimilaritytable`, `sensitive`, `sequence`, `session`, `session_user`, `set`, `sets`, `setuser`, `shutdown`, `similar`, `size`, `smallint`, `some`, `space`, `specific`, `specifictype`, `sql`, `sqlca`, `sqlcode`, `sqlerror`, `sqlexception`, `sqlstate`, `sqlwarning`, `start`, `state`, `statement`, `static`, `statistics`, `stddev_pop`, `stddev_samp`, `structure`, `submultiset`, `substring`, `substring_regex`, `sum`, `symmetric`, `system`, `system_user`, `table`, `tablesample`, `temporary`, `terminate`, `textsize`, `than`, `then`, `throw`, `time`, `timestamp`, `timezone_hour`, `timezone_minute`, `to`, `top`, `trailing`, `tran`, `transaction`, `translate`, `translate_regex`, `translation`, `treat`, `trigger`, `trim`, `true`, `truncate`, `try`, `try_convert`, `tsequal`, `uescape`, `under`, `union`, `unique`, `unknown`, `unnest`, `unpivot`, `update`, `updatetext`, `upper`, `usage`, `use`, `user`, `using`, `value`, `values`, `var_pop`, `var_samp`, `varchar`, `variable`, `varying`, `view`, `waitfor`, `when`, `whenever`, `where`, `while`, `width_bucket`, `window`, `with`, `within`, `without`, `work`, `write`, `writetext`, `xmlagg`, `xmlattributes`, `xmlbinary`, `xmlcast`, `xmlcomment`, `xmlconcat`, `xmldocument`, `xmlelement`, `xmlexists`, `xmlforest`, `xmliterate`, `xmlnamespaces`, `xmlparse`, `xmlpi`, `xmlquery`, `xmlserialize`, `xmltable`, `xmltext`, `xmlvalidate`, `year`, `zone`), Keyword, nil}, {`(\[)([^]]+)(\])`, ByGroups(Operator, Name, Operator), nil}, {`0x[0-9a-f]+`, LiteralNumberHex, nil}, {`[0-9]+\.[0-9]*(e[+-]?[0-9]+)?`, LiteralNumberFloat, nil}, {`\.[0-9]+(e[+-]?[0-9]+)?`, LiteralNumberFloat, nil}, {`[0-9]+e[+-]?[0-9]+`, LiteralNumberFloat, nil}, {`[0-9]+`, LiteralNumberInteger, nil}, {`[;(),.]`, Punctuation, nil}, {`@@\w+`, NameBuiltin, nil}, {`@\w+`, NameVariable, nil}, {`(\w+)(:)`, ByGroups(NameLabel, Punctuation), nil}, {`#?#?\w+`, Name, nil}, {`\?`, NameVariableMagic, nil}, }, "multiline-comments": { {`/\*`, CommentMultiline, Push("multiline-comments")}, {`\*/`, CommentMultiline, Pop(1)}, {`[^/*]+`, CommentMultiline, nil}, {`[/*]`, CommentMultiline, nil}, }, "string": { {`[^']+`, LiteralStringSingle, nil}, {`''`, LiteralStringSingle, nil}, {`'`, LiteralStringSingle, Pop(1)}, }, "quoted-ident": { {`[^"]+`, LiteralStringName, nil}, {`""`, LiteralStringName, nil}, {`"`, LiteralStringName, Pop(1)}, }, }, ))
TransactSQL lexer.
var Turtle = Register(MustNewLexer( &Config{ Name: "Turtle", Aliases: []string{"turtle"}, Filenames: []string{"*.ttl"}, MimeTypes: []string{"text/turtle", "application/x-turtle"}, NotMultiline: true, CaseInsensitive: true, }, Rules{ "root": { {`\s+`, TextWhitespace, nil}, {"(@base|BASE)(\\s+)(<[^<>\"{}|^`\\\\\\x00-\\x20]*>)(\\s*)(\\.?)", ByGroups(Keyword, TextWhitespace, NameVariable, TextWhitespace, Punctuation), nil}, {"(@prefix|PREFIX)(\\s+)((?:[a-z][\\w-]*)?\\:)(\\s+)(<[^<>\"{}|^`\\\\\\x00-\\x20]*>)(\\s*)(\\.?)", ByGroups(Keyword, TextWhitespace, NameNamespace, TextWhitespace, NameVariable, TextWhitespace, Punctuation), nil}, {`(?<=\s)a(?=\s)`, KeywordType, nil}, {"(<[^<>\"{}|^`\\\\\\x00-\\x20]*>)", NameVariable, nil}, {`((?:[a-z][\w-]*)?\:)([a-z][\w-]*)`, ByGroups(NameNamespace, NameTag), nil}, {`#[^\n]+`, Comment, nil}, {`\b(true|false)\b`, Literal, nil}, {`[+\-]?\d*\.\d+`, LiteralNumberFloat, nil}, {`[+\-]?\d*(:?\.\d+)?E[+\-]?\d+`, LiteralNumberFloat, nil}, {`[+\-]?\d+`, LiteralNumberInteger, nil}, {`[\[\](){}.;,:^]`, Punctuation, nil}, {`"""`, LiteralString, Push("triple-double-quoted-string")}, {`"`, LiteralString, Push("single-double-quoted-string")}, {`'''`, LiteralString, Push("triple-single-quoted-string")}, {`'`, LiteralString, Push("single-single-quoted-string")}, }, "triple-double-quoted-string": { {`"""`, LiteralString, Push("end-of-string")}, {`[^\\]+`, LiteralString, nil}, {`\\`, LiteralString, Push("string-escape")}, }, "single-double-quoted-string": { {`"`, LiteralString, Push("end-of-string")}, {`[^"\\\n]+`, LiteralString, nil}, {`\\`, LiteralString, Push("string-escape")}, }, "triple-single-quoted-string": { {`'''`, LiteralString, Push("end-of-string")}, {`[^\\]+`, LiteralString, nil}, {`\\`, LiteralString, Push("string-escape")}, }, "single-single-quoted-string": { {`'`, LiteralString, Push("end-of-string")}, {`[^'\\\n]+`, LiteralString, nil}, {`\\`, LiteralString, Push("string-escape")}, }, "string-escape": { {`.`, LiteralString, Pop(1)}, }, "end-of-string": { {`(@)([a-z]+(:?-[a-z0-9]+)*)`, ByGroups(Operator, GenericEmph, GenericEmph), Pop(2)}, {"(\\^\\^)(<[^<>\"{}|^`\\\\\\x00-\\x20]*>)", ByGroups(Operator, GenericEmph), Pop(2)}, {`(\^\^)((?:[a-z][\w-]*)?\:)([a-z][\w-]*)`, ByGroups(Operator, GenericEmph, GenericEmph), Pop(2)}, Default(Pop(2)), }, }, ))
Turtle lexer.
var Twig = Register(MustNewLexer( &Config{ Name: "Twig", Aliases: []string{"twig"}, Filenames: []string{}, MimeTypes: []string{"application/x-twig"}, DotAll: true, }, Rules{ "root": { {`[^{]+`, Other, nil}, {`\{\{`, CommentPreproc, Push("var")}, {`\{\#.*?\#\}`, Comment, nil}, {`(\{%)(-?\s*)(raw)(\s*-?)(%\})(.*?)(\{%)(-?\s*)(endraw)(\s*-?)(%\})`, ByGroups(CommentPreproc, Text, Keyword, Text, CommentPreproc, Other, CommentPreproc, Text, Keyword, Text, CommentPreproc), nil}, {`(\{%)(-?\s*)(verbatim)(\s*-?)(%\})(.*?)(\{%)(-?\s*)(endverbatim)(\s*-?)(%\})`, ByGroups(CommentPreproc, Text, Keyword, Text, CommentPreproc, Other, CommentPreproc, Text, Keyword, Text, CommentPreproc), nil}, {`(\{%)(-?\s*)(filter)(\s+)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w-]|[^\x00-\x7f])*)`, ByGroups(CommentPreproc, Text, Keyword, Text, NameFunction), Push("tag")}, {`(\{%)(-?\s*)([a-zA-Z_]\w*)`, ByGroups(CommentPreproc, Text, Keyword), Push("tag")}, {`\{`, Other, nil}, }, "varnames": { {`(\|)(\s*)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w-]|[^\x00-\x7f])*)`, ByGroups(Operator, Text, NameFunction), nil}, {`(is)(\s+)(not)?(\s*)((?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w-]|[^\x00-\x7f])*)`, ByGroups(Keyword, Text, Keyword, Text, NameFunction), nil}, {`(?i)(true|false|none|null)\b`, KeywordPseudo, nil}, {"" /* 152 byte string literal not displayed */, Keyword, nil}, {`(loop|block|parent)\b`, NameBuiltin, nil}, {`(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w-]|[^\x00-\x7f])*`, NameVariable, nil}, {`\.(?:[\\_a-z]|[^\x00-\x7f])(?:[\\\w-]|[^\x00-\x7f])*`, NameVariable, nil}, {`\.[0-9]+`, LiteralNumber, nil}, {`:?"(\\\\|\\"|[^"])*"`, LiteralStringDouble, nil}, {`:?'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil}, {`([{}()\[\]+\-*/,:~%]|\.\.|\?|:|\*\*|\/\/|!=|[><=]=?)`, Operator, nil}, {`[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?`, LiteralNumber, nil}, }, "var": { {`\s+`, Text, nil}, {`(-?)(\}\})`, ByGroups(Text, CommentPreproc), Pop(1)}, Include("varnames"), }, "tag": { {`\s+`, Text, nil}, {`(-?)(%\})`, ByGroups(Text, CommentPreproc), Pop(1)}, Include("varnames"), {`.`, Punctuation, nil}, }, }, ))
Twig lexer.
var TypeScript = Register(MustNewLexer( &Config{ Name: "TypeScript", Aliases: []string{"ts", "typescript"}, Filenames: []string{"*.ts", "*.tsx"}, MimeTypes: []string{"text/x-typescript"}, DotAll: true, }, Rules{ "commentsandwhitespace": { {`\s+`, Text, nil}, {`<!--`, Comment, nil}, {`//.*?\n`, CommentSingle, nil}, {`/\*.*?\*/`, CommentMultiline, nil}, }, "slashstartsregex": { Include("commentsandwhitespace"), {`/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/([gim]+\b|\B)`, LiteralStringRegex, Pop(1)}, {`(?=/)`, Text, Push("#pop", "badregex")}, Default(Pop(1)), }, "badregex": { {`\n`, Text, Pop(1)}, }, "root": { {`^(?=\s|/|<!--)`, Text, Push("slashstartsregex")}, Include("commentsandwhitespace"), {`\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|(<<|>>>?|==?|!=?|[-<>+*%&|^/])=?`, Operator, Push("slashstartsregex")}, {`[{(\[;,]`, Punctuation, Push("slashstartsregex")}, {`[})\].]`, Punctuation, nil}, {"" /* 134 byte string literal not displayed */, Keyword, Push("slashstartsregex")}, {`(var|let|with|function)\b`, KeywordDeclaration, Push("slashstartsregex")}, {"" /* 232 byte string literal not displayed */, KeywordReserved, nil}, {`(true|false|null|NaN|Infinity|undefined)\b`, KeywordConstant, nil}, {"" /* 219 byte string literal not displayed */, NameBuiltin, nil}, {`\b(module)(\s*)(\s*[\w?.$][\w?.$]*)(\s*)`, ByGroups(KeywordReserved, Text, NameOther, Text), Push("slashstartsregex")}, {`\b(string|bool|number)\b`, KeywordType, nil}, {`\b(constructor|declare|interface|as|AS)\b`, KeywordReserved, nil}, {`(super)(\s*)(\([\w,?.$\s]+\s*\))`, ByGroups(KeywordReserved, Text), Push("slashstartsregex")}, {`([a-zA-Z_?.$][\w?.$]*)\(\) \{`, NameOther, Push("slashstartsregex")}, {`([\w?.$][\w?.$]*)(\s*:\s*)([\w?.$][\w?.$]*)`, ByGroups(NameOther, Text, KeywordType), nil}, {`[$a-zA-Z_]\w*`, NameOther, nil}, {`[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?`, LiteralNumberFloat, nil}, {`0x[0-9a-fA-F]+`, LiteralNumberHex, nil}, {`[0-9]+`, LiteralNumberInteger, nil}, {`"(\\\\|\\"|[^"])*"`, LiteralStringDouble, nil}, {`'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil}, {"`", LiteralStringBacktick, Push("interp")}, {`@\w+`, KeywordDeclaration, nil}, }, "interp": { {"`", LiteralStringBacktick, Pop(1)}, {`\\\\`, LiteralStringBacktick, nil}, {"\\\\`", LiteralStringBacktick, nil}, {`\$\{`, LiteralStringInterpol, Push("interp-inside")}, {`\$`, LiteralStringBacktick, nil}, {"[^`\\\\$]+", LiteralStringBacktick, nil}, }, "interp-inside": { {`\}`, LiteralStringInterpol, Pop(1)}, Include("root"), }, }, ))
TypeScript lexer.
var TypoScriptCSSData = Register(MustNewLexer( &Config{ Name: "TypoScriptCssData", Aliases: []string{"typoscriptcssdata"}, Filenames: []string{}, MimeTypes: []string{}, }, Rules{ "root": { {`(.*)(###\w+###)(.*)`, ByGroups(LiteralString, NameConstant, LiteralString), nil}, {`(\{)(\$)((?:[\w\-]+\.)*)([\w\-]+)(\})`, ByGroups(LiteralStringSymbol, Operator, NameConstant, NameConstant, LiteralStringSymbol), nil}, {`(.*)(\{)([\w\-]+)(\s*:\s*)([\w\-]+)(\})(.*)`, ByGroups(LiteralString, LiteralStringSymbol, NameConstant, Operator, NameConstant, LiteralStringSymbol, LiteralString), nil}, {`\s+`, Text, nil}, {`/\*(?:(?!\*/).)*\*/`, Comment, nil}, {`(?<!(#|\'|"))(?:#(?!(?:[a-fA-F0-9]{6}|[a-fA-F0-9]{3}))[^\n#]+|//[^\n]*)`, Comment, nil}, {`[<>,:=.*%+|]`, LiteralString, nil}, {`[\w"\-!/&;(){}]+`, LiteralString, nil}, }, }, ))
TypoScriptCSSData lexer.
var TypoScriptHTMLData = Register(MustNewLexer( &Config{ Name: "TypoScriptHtmlData", Aliases: []string{"typoscripthtmldata"}, Filenames: []string{}, MimeTypes: []string{}, }, Rules{ "root": { {`(INCLUDE_TYPOSCRIPT)`, NameClass, nil}, {`(EXT|FILE|LLL):[^}\n"]*`, LiteralString, nil}, {`(.*)(###\w+###)(.*)`, ByGroups(LiteralString, NameConstant, LiteralString), nil}, {`(\{)(\$)((?:[\w\-]+\.)*)([\w\-]+)(\})`, ByGroups(LiteralStringSymbol, Operator, NameConstant, NameConstant, LiteralStringSymbol), nil}, {`(.*)(\{)([\w\-]+)(\s*:\s*)([\w\-]+)(\})(.*)`, ByGroups(LiteralString, LiteralStringSymbol, NameConstant, Operator, NameConstant, LiteralStringSymbol, LiteralString), nil}, {`\s+`, Text, nil}, {`[<>,:=.*%+|]`, LiteralString, nil}, {`[\w"\-!/&;(){}#]+`, LiteralString, nil}, }, }, ))
TypoScriptHTMLData lexer.
var Typoscript = Register(MustNewLexer( &Config{ Name: "TypoScript", Aliases: []string{"typoscript"}, Filenames: []string{"*.ts", "*.txt"}, MimeTypes: []string{"text/x-typoscript"}, DotAll: true, }, Rules{ "root": { Include("comment"), Include("constant"), Include("html"), Include("label"), Include("whitespace"), Include("keywords"), Include("punctuation"), Include("operator"), Include("structure"), Include("literal"), Include("other"), }, "keywords": { {"" /* 270 byte string literal not displayed */, ByGroups(LiteralStringSymbol, NameConstant, Text, LiteralStringSymbol), nil}, {"" /* 238 byte string literal not displayed */, NameFunction, nil}, {"" /* 261 byte string literal not displayed */, ByGroups(Operator, NameBuiltin), nil}, {"" /* 300 byte string literal not displayed */, NameClass, nil}, {"" /* 144 byte string literal not displayed */, NameClass, nil}, {`(?=[\w\-])(GMENU_FOLDOUT|GMENU_LAYERS|GMENU|IMGMENUITEM|IMGMENU|JSMENUITEM|JSMENU|TMENUITEM|TMENU_LAYERS|TMENU)`, NameClass, nil}, {`(?=[\w\-])(PHP_SCRIPT(_EXT|_INT)?)`, NameClass, nil}, {`(?=[\w\-])(userFunc)(?![\w\-])`, NameFunction, nil}, }, "whitespace": { {`\s+`, Text, nil}, }, "html": { {`<\S[^\n>]*>`, Using(TypoScriptHTMLData, nil), nil}, {`&[^;\n]*;`, LiteralString, nil}, {`(_CSS_DEFAULT_STYLE)(\s*)(\()(?s)(.*(?=\n\)))`, ByGroups(NameClass, Text, LiteralStringSymbol, Using(TypoScriptCSSData, nil)), nil}, }, "literal": { {`0x[0-9A-Fa-f]+t?`, LiteralNumberHex, nil}, {`[0-9]+`, LiteralNumberInteger, nil}, {`(###\w+###)`, NameConstant, nil}, }, "label": { {`(EXT|FILE|LLL):[^}\n"]*`, LiteralString, nil}, {`(?![^\w\-])([\w\-]+(?:/[\w\-]+)+/?)(\S*\n)`, ByGroups(LiteralString, LiteralString), nil}, }, "punctuation": { {`[,.]`, Punctuation, nil}, }, "operator": { {`[<>,:=.*%+|]`, Operator, nil}, }, "structure": { {`[{}()\[\]\\]`, LiteralStringSymbol, nil}, }, "constant": { {`(\{)(\$)((?:[\w\-]+\.)*)([\w\-]+)(\})`, ByGroups(LiteralStringSymbol, Operator, NameConstant, NameConstant, LiteralStringSymbol), nil}, {`(\{)([\w\-]+)(\s*:\s*)([\w\-]+)(\})`, ByGroups(LiteralStringSymbol, NameConstant, Operator, NameConstant, LiteralStringSymbol), nil}, {`(#[a-fA-F0-9]{6}\b|#[a-fA-F0-9]{3}\b)`, LiteralStringChar, nil}, }, "comment": { {`(?<!(#|\'|"))(?:#(?!(?:[a-fA-F0-9]{6}|[a-fA-F0-9]{3}))[^\n#]+|//[^\n]*)`, Comment, nil}, {`/\*(?:(?!\*/).)*\*/`, Comment, nil}, {`(\s*#\s*\n)`, Comment, nil}, }, "other": { {`[\w"\-!/&;]+`, Text, nil}, }, }, ))
Typoscript lexer.
var VHDL = Register(MustNewLexer( &Config{ Name: "VHDL", Aliases: []string{"vhdl"}, Filenames: []string{"*.vhdl", "*.vhd"}, MimeTypes: []string{"text/x-vhdl"}, CaseInsensitive: true, }, Rules{ "root": { {`\n`, Text, nil}, {`\s+`, Text, nil}, {`\\\n`, Text, nil}, {`--.*?$`, CommentSingle, nil}, {`'(U|X|0|1|Z|W|L|H|-)'`, LiteralStringChar, nil}, {`[~!%^&*+=|?:<>/-]`, Operator, nil}, {`'[a-z_]\w*`, NameAttribute, nil}, {`[()\[\],.;\']`, Punctuation, nil}, {`"[^\n\\"]*"`, LiteralString, nil}, {`(library)(\s+)([a-z_]\w*)`, ByGroups(Keyword, Text, NameNamespace), nil}, {`(use)(\s+)(entity)`, ByGroups(Keyword, Text, Keyword), nil}, {`(use)(\s+)([a-z_][\w.]*\.)(all)`, ByGroups(Keyword, Text, NameNamespace, Keyword), nil}, {`(use)(\s+)([a-z_][\w.]*)`, ByGroups(Keyword, Text, NameNamespace), nil}, {`(std|ieee)(\.[a-z_]\w*)`, ByGroups(NameNamespace, NameNamespace), nil}, {Words(``, `\b`, `std`, `ieee`, `work`), NameNamespace, nil}, {`(entity|component)(\s+)([a-z_]\w*)`, ByGroups(Keyword, Text, NameClass), nil}, {`(architecture|configuration)(\s+)([a-z_]\w*)(\s+)(of)(\s+)([a-z_]\w*)(\s+)(is)`, ByGroups(Keyword, Text, NameClass, Text, Keyword, Text, NameClass, Text, Keyword), nil}, {`([a-z_]\w*)(:)(\s+)(process|for)`, ByGroups(NameClass, Operator, Text, Keyword), nil}, {`(end)(\s+)`, ByGroups(Keyword, Text), Push("endblock")}, Include("types"), Include("keywords"), Include("numbers"), {`[a-z_]\w*`, Name, nil}, }, "endblock": { Include("keywords"), {`[a-z_]\w*`, NameClass, nil}, {`(\s+)`, Text, nil}, {`;`, Punctuation, Pop(1)}, }, "types": { {Words(``, `\b`, `boolean`, `bit`, `character`, `severity_level`, `integer`, `time`, `delay_length`, `natural`, `positive`, `string`, `bit_vector`, `file_open_kind`, `file_open_status`, `std_ulogic`, `std_ulogic_vector`, `std_logic`, `std_logic_vector`, `signed`, `unsigned`), KeywordType, nil}, }, "keywords": { {Words(``, `\b`, `abs`, `access`, `after`, `alias`, `all`, `and`, `architecture`, `array`, `assert`, `attribute`, `begin`, `block`, `body`, `buffer`, `bus`, `case`, `component`, `configuration`, `constant`, `disconnect`, `downto`, `else`, `elsif`, `end`, `entity`, `exit`, `file`, `for`, `function`, `generate`, `generic`, `group`, `guarded`, `if`, `impure`, `in`, `inertial`, `inout`, `is`, `label`, `library`, `linkage`, `literal`, `loop`, `map`, `mod`, `nand`, `new`, `next`, `nor`, `not`, `null`, `of`, `on`, `open`, `or`, `others`, `out`, `package`, `port`, `postponed`, `procedure`, `process`, `pure`, `range`, `record`, `register`, `reject`, `rem`, `return`, `rol`, `ror`, `select`, `severity`, `signal`, `shared`, `sla`, `sll`, `sra`, `srl`, `subtype`, `then`, `to`, `transport`, `type`, `units`, `until`, `use`, `variable`, `wait`, `when`, `while`, `with`, `xnor`, `xor`), Keyword, nil}, }, "numbers": { {`\d{1,2}#[0-9a-f_]+#?`, LiteralNumberInteger, nil}, {`\d+`, LiteralNumberInteger, nil}, {`(\d+\.\d*|\.\d+|\d+)E[+-]?\d+`, LiteralNumberFloat, nil}, {`X"[0-9a-f_]+"`, LiteralNumberHex, nil}, {`O"[0-7_]+"`, LiteralNumberOct, nil}, {`B"[01_]+"`, LiteralNumberBin, nil}, }, }, ))
VHDL lexer.
var Verilog = Register(MustNewLexer( &Config{ Name: "verilog", Aliases: []string{"verilog", "v"}, Filenames: []string{"*.v"}, MimeTypes: []string{"text/x-verilog"}, EnsureNL: true, }, Rules{ "root": { {"^\\s*`define", CommentPreproc, Push("macro")}, {`\n`, Text, nil}, {`\s+`, Text, nil}, {`\\\n`, Text, nil}, {`/(\\\n)?/(\n|(.|\n)*?[^\\]\n)`, CommentSingle, nil}, {`/(\\\n)?[*](.|\n)*?[*](\\\n)?/`, CommentMultiline, nil}, {`[{}#@]`, Punctuation, nil}, {`L?"`, LiteralString, Push("string")}, {`L?'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'`, LiteralStringChar, nil}, {`(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?`, LiteralNumberFloat, nil}, {`(\d+\.\d*|\.\d+|\d+[fF])[fF]?`, LiteralNumberFloat, nil}, {`([0-9]+)|(\'h)[0-9a-fA-F]+`, LiteralNumberHex, nil}, {`([0-9]+)|(\'b)[01]+`, LiteralNumberBin, nil}, {`([0-9]+)|(\'d)[0-9]+`, LiteralNumberInteger, nil}, {`([0-9]+)|(\'o)[0-7]+`, LiteralNumberOct, nil}, {`\'[01xz]`, LiteralNumber, nil}, {`\d+[Ll]?`, LiteralNumberInteger, nil}, {`\*/`, Error, nil}, {`[~!%^&*+=|?:<>/-]`, Operator, nil}, {`[()\[\],.;\']`, Punctuation, nil}, {"`[a-zA-Z_]\\w*", NameConstant, nil}, {`^(\s*)(package)(\s+)`, ByGroups(Text, KeywordNamespace, Text), nil}, {`^(\s*)(import)(\s+)`, ByGroups(Text, KeywordNamespace, Text), Push("import")}, {Words(``, `\b`, `always`, `always_comb`, `always_ff`, `always_latch`, `and`, `assign`, `automatic`, `begin`, `break`, `buf`, `bufif0`, `bufif1`, `case`, `casex`, `casez`, `cmos`, `const`, `continue`, `deassign`, `default`, `defparam`, `disable`, `do`, `edge`, `else`, `end`, `endcase`, `endfunction`, `endgenerate`, `endmodule`, `endpackage`, `endprimitive`, `endspecify`, `endtable`, `endtask`, `enum`, `event`, `final`, `for`, `force`, `forever`, `fork`, `function`, `generate`, `genvar`, `highz0`, `highz1`, `if`, `initial`, `inout`, `input`, `integer`, `join`, `large`, `localparam`, `macromodule`, `medium`, `module`, `nand`, `negedge`, `nmos`, `nor`, `not`, `notif0`, `notif1`, `or`, `output`, `packed`, `parameter`, `pmos`, `posedge`, `primitive`, `pull0`, `pull1`, `pulldown`, `pullup`, `rcmos`, `ref`, `release`, `repeat`, `return`, `rnmos`, `rpmos`, `rtran`, `rtranif0`, `rtranif1`, `scalared`, `signed`, `small`, `specify`, `specparam`, `strength`, `string`, `strong0`, `strong1`, `struct`, `table`, `task`, `tran`, `tranif0`, `tranif1`, `type`, `typedef`, `unsigned`, `var`, `vectored`, `void`, `wait`, `weak0`, `weak1`, `while`, `xnor`, `xor`), Keyword, nil}, {Words("`", `\b`, `accelerate`, `autoexpand_vectornets`, `celldefine`, `default_nettype`, `else`, `elsif`, `endcelldefine`, `endif`, `endprotect`, `endprotected`, `expand_vectornets`, `ifdef`, `ifndef`, `include`, `noaccelerate`, `noexpand_vectornets`, `noremove_gatenames`, `noremove_netnames`, `nounconnected_drive`, `protect`, `protected`, `remove_gatenames`, `remove_netnames`, `resetall`, `timescale`, `unconnected_drive`, `undef`), CommentPreproc, nil}, {Words(`\$`, `\b`, `bits`, `bitstoreal`, `bitstoshortreal`, `countdrivers`, `display`, `fclose`, `fdisplay`, `finish`, `floor`, `fmonitor`, `fopen`, `fstrobe`, `fwrite`, `getpattern`, `history`, `incsave`, `input`, `itor`, `key`, `list`, `log`, `monitor`, `monitoroff`, `monitoron`, `nokey`, `nolog`, `printtimescale`, `random`, `readmemb`, `readmemh`, `realtime`, `realtobits`, `reset`, `reset_count`, `reset_value`, `restart`, `rtoi`, `save`, `scale`, `scope`, `shortrealtobits`, `showscopes`, `showvariables`, `showvars`, `sreadmemb`, `sreadmemh`, `stime`, `stop`, `strobe`, `time`, `timeformat`, `write`), NameBuiltin, nil}, {Words(``, `\b`, `byte`, `shortint`, `int`, `longint`, `integer`, `time`, `bit`, `logic`, `reg`, `supply0`, `supply1`, `tri`, `triand`, `trior`, `tri0`, `tri1`, `trireg`, `uwire`, `wire`, `wand`, `woshortreal`, `real`, `realtime`), KeywordType, nil}, {`[a-zA-Z_]\w*:(?!:)`, NameLabel, nil}, {`\$?[a-zA-Z_]\w*`, Name, nil}, }, "string": { {`"`, LiteralString, Pop(1)}, {`\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})`, LiteralStringEscape, nil}, {`[^\\"\n]+`, LiteralString, nil}, {`\\\n`, LiteralString, nil}, {`\\`, LiteralString, nil}, }, "macro": { {`[^/\n]+`, CommentPreproc, nil}, {`/[*](.|\n)*?[*]/`, CommentMultiline, nil}, {`//.*?\n`, CommentSingle, Pop(1)}, {`/`, CommentPreproc, nil}, {`(?<=\\)\n`, CommentPreproc, nil}, {`\n`, CommentPreproc, Pop(1)}, }, "import": { {`[\w:]+\*?`, NameNamespace, Pop(1)}, }, }, ))
Verilog lexer.
var Viml = Register(MustNewLexer( &Config{ Name: "VimL", Aliases: []string{"vim"}, Filenames: []string{"*.vim", ".vimrc", ".exrc", ".gvimrc", "_vimrc", "_exrc", "_gvimrc", "vimrc", "gvimrc"}, MimeTypes: []string{"text/x-vim"}, }, Rules{ "root": { {`^([ \t:]*)(py(?:t(?:h(?:o(?:n)?)?)?)?)([ \t]*)(<<)([ \t]*)(.*)((?:\n|.)*)(\6)`, ByGroups(UsingSelf("root"), Keyword, Text, Operator, Text, Text, Using(Python, nil), Text), nil}, {`^([ \t:]*)(py(?:t(?:h(?:o(?:n)?)?)?)?)([ \t])(.*)`, ByGroups(UsingSelf("root"), Keyword, Text, Using(Python, nil)), nil}, {`^\s*".*`, Comment, nil}, {`[ \t]+`, Text, nil}, {`/(\\\\|\\/|[^\n/])*/`, LiteralStringRegex, nil}, {`"(\\\\|\\"|[^\n"])*"`, LiteralStringDouble, nil}, {`'(''|[^\n'])*'`, LiteralStringSingle, nil}, {`(?<=\s)"[^\-:.%#=*].*`, Comment, nil}, {`-?\d+`, LiteralNumber, nil}, {`#[0-9a-f]{6}`, LiteralNumberHex, nil}, {`^:`, Punctuation, nil}, {`[()<>+=!|,~-]`, Punctuation, nil}, {`\b(let|if|else|endif|elseif|fun|function|endfunction)\b`, Keyword, nil}, {`\b(NONE|bold|italic|underline|dark|light)\b`, NameBuiltin, nil}, {`\b\w+\b`, NameOther, nil}, {`.`, Text, nil}, }, }, ))
Viml lexer.
var WDTE = Register(MustNewLexer( &Config{ Name: "WDTE", Filenames: []string{"*.wdte"}, }, Rules{ "root": { {`\n`, Text, nil}, {`\s+`, Text, nil}, {`\\\n`, Text, nil}, {`#(.*?)\n`, CommentSingle, nil}, {`-?[0-9]+`, LiteralNumberInteger, nil}, {`-?[0-9]*\.[0-9]+`, LiteralNumberFloat, nil}, {`"[^"]*"`, LiteralString, nil}, {`'[^']*'`, LiteralString, nil}, {Words(``, `\b`, `switch`, `default`, `memo`), KeywordReserved, nil}, {`{|}|;|->|=>|\(|\)|\[|\]|\.`, Operator, nil}, {`[^{};()[\].\s]+`, NameVariable, nil}, }, }, ))
WDTE lexer.
var XML = Register(MustNewLexer( &Config{ Name: "XML", Aliases: []string{"xml"}, Filenames: []string{"*.xml", "*.xsl", "*.rss", "*.xslt", "*.xsd", "*.wsdl", "*.wsf", "*.svg"}, MimeTypes: []string{"text/xml", "application/xml", "image/svg+xml", "application/rss+xml", "application/atom+xml"}, DotAll: true, }, Rules{ "root": { {`[^<&]+`, Text, nil}, {`&\S*?;`, NameEntity, nil}, {`\<\!\[CDATA\[.*?\]\]\>`, CommentPreproc, nil}, {`<!--`, Comment, Push("comment")}, {`<\?.*?\?>`, CommentPreproc, nil}, {`<![^>]*>`, CommentPreproc, nil}, {`<\s*[\w:.-]+`, NameTag, Push("tag")}, {`<\s*/\s*[\w:.-]+\s*>`, NameTag, nil}, }, "comment": { {`[^-]+`, Comment, nil}, {`-->`, Comment, Pop(1)}, {`-`, Comment, nil}, }, "tag": { {`\s+`, Text, nil}, {`[\w.:-]+\s*=`, NameAttribute, Push("attr")}, {`/?\s*>`, NameTag, Pop(1)}, }, "attr": { {`\s+`, Text, nil}, {`".*?"`, LiteralString, Pop(1)}, {`'.*?'`, LiteralString, Pop(1)}, {`[^\s>]+`, LiteralString, Pop(1)}, }, }, ))
XML lexer.
var Xorg = Register(MustNewLexer( &Config{ Name: "Xorg", Aliases: []string{"xorg.conf"}, Filenames: []string{"xorg.conf"}, MimeTypes: []string{}, }, Rules{ "root": { {`\s+`, TextWhitespace, nil}, {`#.*$`, Comment, nil}, {`((|Sub)Section)(\s+)("\w+")`, ByGroups(KeywordNamespace, LiteralStringEscape, TextWhitespace, LiteralStringEscape), nil}, {`(End(|Sub)Section)`, KeywordNamespace, nil}, {`(\w+)(\s+)([^\n#]+)`, ByGroups(NameKeyword, TextWhitespace, LiteralString), nil}, }, }, ))
Xorg lexer.
var YAML = Register(MustNewLexer( &Config{ Name: "YAML", Aliases: []string{"yaml"}, Filenames: []string{"*.yaml", "*.yml"}, MimeTypes: []string{"text/x-yaml"}, }, Rules{ "root": { Include("whitespace"), {`#.*`, Comment, nil}, {`![^\s]+`, CommentPreproc, nil}, {`\s&[^\s]+`, CommentPreproc, nil}, {`\s\*[^\s]+`, CommentPreproc, nil}, {`^%include\s+[^\n\r]+`, CommentPreproc, nil}, {`([>|])(\s+)((?:(?:.*?$)(?:[\n\r]*?\2)?)*)`, ByGroups(StringDoc, StringDoc, StringDoc), nil}, Include("value"), {`[?:,\[\]]`, Punctuation, nil}, {`.`, Text, nil}, }, "value": { {Words(``, `\b`, "true", "false", "null"), KeywordConstant, nil}, {`"(?:\\.|[^"])*"`, StringDouble, nil}, {`'(?:\\.|[^'])*'`, StringSingle, nil}, {`\d\d\d\d-\d\d-\d\d([T ]\d\d:\d\d:\d\d(\.\d+)?(Z|\s+[-+]\d+)?)?`, LiteralDate, nil}, {`\b[+\-]?(0x[\da-f]+|0o[0-7]+|(\d+\.?\d*|\.?\d+)(e[\+\-]?\d+)?|\.inf|\.nan)\b`, Number, nil}, }, "whitespace": { {`\s+`, Whitespace, nil}, }, }, ))
Functions ¶
func Analyse ¶
Analyse text content and return the "best" lexer..
func Get ¶
Get a Lexer by name, alias or file extension.
func Match ¶
Match returns the first lexer matching filename.
func MatchMimeType ¶
MatchMimeType attempts to find a lexer for the given MIME type.
func Names ¶
Names of all lexers, optionally including aliases.
func Register ¶
Register a Lexer with the global registry.
Source Files ¶
abnf.go actionscript.go actionscript3.go ada.go angular2.go antlr.go apache.go api.go apl.go applescript.go awk.go bash.go batch.go blitz.go bnf.go brainfuck.go c.go capnproto.go ceylon.go cfengine3.go chaiscript.go cheetah.go cl.go clojure.go cmake.go cobol.go coffee.go coldfusion.go coq.go cpp.go crystal.go csharp.go css.go cython.go dart.go diff.go django.go docker.go dtd.go ebnf.go elixir.go elm.go emacs.go erlang.go factor.go fish.go forth.go fortran.go fsharp.go gas.go gdscript.go genshi.go glsl.go gnuplot.go go.go groovy.go handlebars.go haskell.go haxe.go hexdump.go html.go http.go hy.go idris.go ini.go io.go java.go javascript.go json.go julia.go kotlin.go lighttpd.go llvm.go lua.go make.go mako.go markdown.go mason.go mathematica.go minizinc.go modula2.go mwscript.go myghty.go mysql.go nasm.go newspeak.go nginx.go nim.go nix.go objectivec.go ocaml.go octave.go pacman.go perl.go php.go pig.go pkgconfig.go plsql.go postgres.go postscript.go povray.go powershell.go prolog.go protobuf.go puppet.go python.go python3.go qbasic.go r.go racket.go ragel.go regedit.go rexx.go rst.go ruby.go rust.go sass.go scala.go scheme.go scilab.go scss.go smalltalk.go smarty.go snobol.go sparql.go sql.go squid.go swift.go systemverilog.go tasm.go tcl.go tcsh.go termcap.go terminfo.go terraform.go tex.go thrift.go toml.go transactsql.go turtle.go twig.go typescript.go typoscript.go verilog.go vhdl.go vim.go wdte.go xml.go xorg.go yaml.go
- Version
- v0.2.1
- Published
- Jan 2, 2018
- Platform
- js/wasm
- Imports
- 6 packages
- Last checked
- 8 minutes ago –
Tools for package owners.