broomhlda 0.1.0

data/lib/hl/lexers/imported/autoit.ay

@@ -0,0 +1,64 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "AutoIt"
+  aliases: ["autoit", "Autoit"]
+  extensions: [".au3"]
+  mimetypes: ["text/x-autoit"]
+  start: .root
+  flags: 0
+
+  lex(builtInMarcros):
+    r"(?i)(@appdatacommondir|@appdatadir|@autoitexe|@autoitpid|@autoitversion|@autoitx64|@com_eventobj|@commonfilesdir|@compiled|@computername|@comspec|@cpuarch|@cr|@crlf|@desktopcommondir|@desktopdepth|@desktopdir|@desktopheight|@desktoprefresh|@desktopwidth|@documentscommondir|@error|@exitcode|@exitmethod|@extended|@favoritescommondir|@favoritesdir|@gui_ctrlhandle|@gui_ctrlid|@gui_dragfile|@gui_dragid|@gui_dropid|@gui_winhandle|@homedrive|@homepath|@homeshare|@hotkeypressed|@hour|@ipaddress1|@ipaddress2|@ipaddress3|@ipaddress4|@kblayout|@lf|@logondnsdomain|@logondomain|@logonserver|@mday|@min|@mon|@msec|@muilang|@mydocumentsdir|@numparams|@osarch|@osbuild|@oslang|@osservicepack|@ostype|@osversion|@programfilesdir|@programscommondir|@programsdir|@scriptdir|@scriptfullpath|@scriptlinenumber|@scriptname|@sec|@startmenucommondir|@startmenudir|@startupcommondir|@startupdir|@sw_disable|@sw_enable|@sw_hide|@sw_lock|@sw_maximize|@sw_minimize|@sw_restore|@sw_show|@sw_showdefault|@sw_showmaximized|@sw_showminimized|@sw_showminnoactive|@sw_showna|@sw_shownoactivate|@sw_shownormal|@sw_unlock|@systemdir|@tab|@tempdir|@tray_id|@trayiconflashing|@trayiconvisible|@username|@userprofiledir|@wday|@windowsdir|@workingdir|@yday|@year)\b" is(name.variable.global)
+
+  lex(commands):
+    r"(?i)(\s*)(\#include-once|\#include|\#endregion|\#forcedef|\#forceref|\#region|and|byref|case|continueloop|dim|do|else|elseif|endfunc|endif|endselect|exit|exitloop|for|func|global|if|local|next|not|or|return|select|step|then|to|until|wend|while|exit)\b" is(by-groups(text, name.builtin))
+
+  lex(numbers):
+    r"(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?" is(literal.number.float)
+    r"\d+[eE][+-]?[0-9]+" is(literal.number.float)
+    r"0\d+" is(literal.number.oct)
+    r"0[xX][a-fA-F0-9]+" is(literal.number.hex)
+    r"\d+L" is(literal.number.integer.long)
+    r"\d+" is(literal.number.integer)
+
+  lex(garbage):
+    r"[^\S\n]" is(text)
+
+  lex(dqs):
+    r"\"" is(literal.string) -> pop
+    any-of(strings)
+
+  lex(builtInFunctions):
+    r"(?i)(abs|acos|adlibregister|adlibunregister|asc|ascw|asin|assign|atan|autoitsetoption|autoitwingettitle|autoitwinsettitle|beep|binary|binarylen|binarymid|binarytostring|bitand|bitnot|bitor|bitrotate|bitshift|bitxor|blockinput|break|call|cdtray|ceiling|chr|chrw|clipget|clipput|consoleread|consolewrite|consolewriteerror|controlclick|controlcommand|controldisable|controlenable|controlfocus|controlgetfocus|controlgethandle|controlgetpos|controlgettext|controlhide|controllistview|controlmove|controlsend|controlsettext|controlshow|controltreeview|cos|dec|dircopy|dircreate|dirgetsize|dirmove|dirremove|dllcall|dllcalladdress|dllcallbackfree|dllcallbackgetptr|dllcallbackregister|dllclose|dllopen|dllstructcreate|dllstructgetdata|dllstructgetptr|dllstructgetsize|dllstructsetdata|drivegetdrive|drivegetfilesystem|drivegetlabel|drivegetserial|drivegettype|drivemapadd|drivemapdel|drivemapget|drivesetlabel|drivespacefree|drivespacetotal|drivestatus|envget|envset|envupdate|eval|execute|exp|filechangedir|fileclose|filecopy|filecreatentfslink|filecreateshortcut|filedelete|fileexists|filefindfirstfile|filefindnextfile|fileflush|filegetattrib|filegetencoding|filegetlongname|filegetpos|filegetshortcut|filegetshortname|filegetsize|filegettime|filegetversion|fileinstall|filemove|fileopen|fileopendialog|fileread|filereadline|filerecycle|filerecycleempty|filesavedialog|fileselectfolder|filesetattrib|filesetpos|filesettime|filewrite|filewriteline|floor|ftpsetproxy|guicreate|guictrlcreateavi|guictrlcreatebutton|guictrlcreatecheckbox|guictrlcreatecombo|guictrlcreatecontextmenu|guictrlcreatedate|guictrlcreatedummy|guictrlcreateedit|guictrlcreategraphic|guictrlcreategroup|guictrlcreateicon|guictrlcreateinput|guictrlcreatelabel|guictrlcreatelist|guictrlcreatelistview|guictrlcreatelistviewitem|guictrlcreatemenu|guictrlcreatemenuitem|guictrlcreatemonthcal|guictrlcreateobj|guictrlcreatepic|guictrlcreateprogress|guictrlcreateradio|guictrlcreateslider|guictrlcreatetab|guictrlcreatetabitem|guictrlcreatetreeview|guictrlcreatetreeviewitem|guictrlcreateupdown|guictrldelete|guictrlgethandle|guictrlgetstate|guictrlread|guictrlrecvmsg|guictrlregisterlistviewsort|guictrlsendmsg|guictrlsendtodummy|guictrlsetbkcolor|guictrlsetcolor|guictrlsetcursor|guictrlsetdata|guictrlsetdefbkcolor|guictrlsetdefcolor|guictrlsetfont|guictrlsetgraphic|guictrlsetimage|guictrlsetlimit|guictrlsetonevent|guictrlsetpos|guictrlsetresizing|guictrlsetstate|guictrlsetstyle|guictrlsettip|guidelete|guigetcursorinfo|guigetmsg|guigetstyle|guiregistermsg|guisetaccelerators|guisetbkcolor|guisetcoord|guisetcursor|guisetfont|guisethelp|guiseticon|guisetonevent|guisetstate|guisetstyle|guistartgroup|guiswitch|hex|hotkeyset|httpsetproxy|httpsetuseragent|hwnd|inetclose|inetget|inetgetinfo|inetgetsize|inetread|inidelete|iniread|inireadsection|inireadsectionnames|inirenamesection|iniwrite|iniwritesection|inputbox|int|isadmin|isarray|isbinary|isbool|isdeclared|isdllstruct|isfloat|ishwnd|isint|iskeyword|isnumber|isobj|isptr|isstring|log|memgetstats|mod|mouseclick|mouseclickdrag|mousedown|mousegetcursor|mousegetpos|mousemove|mouseup|mousewheel|msgbox|number|objcreate|objcreateinterface|objevent|objevent|objget|objname|onautoitexitregister|onautoitexitunregister|opt|ping|pixelchecksum|pixelgetcolor|pixelsearch|pluginclose|pluginopen|processclose|processexists|processgetstats|processlist|processsetpriority|processwait|processwaitclose|progressoff|progresson|progressset|ptr|random|regdelete|regenumkey|regenumval|regread|regwrite|round|run|runas|runaswait|runwait|send|sendkeepactive|seterror|setextended|shellexecute|shellexecutewait|shutdown|sin|sleep|soundplay|soundsetwavevolume|splashimageon|splashoff|splashtexton|sqrt|srandom|statusbargettext|stderrread|stdinwrite|stdioclose|stdoutread|string|stringaddcr|stringcompare|stringformat|stringfromasciiarray|stringinstr|stringisalnum|stringisalpha|stringisascii|stringisdigit|stringisfloat|stringisint|stringislower|stringisspace|stringisupper|stringisxdigit|stringleft|stringlen|stringlower|stringmid|stringregexp|stringregexpreplace|stringreplace|stringright|stringsplit|stringstripcr|stringstripws|stringtoasciiarray|stringtobinary|stringtrimleft|stringtrimright|stringupper|tan|tcpaccept|tcpclosesocket|tcpconnect|tcplisten|tcpnametoip|tcprecv|tcpsend|tcpshutdown|tcpstartup|timerdiff|timerinit|tooltip|traycreateitem|traycreatemenu|traygetmsg|trayitemdelete|trayitemgethandle|trayitemgetstate|trayitemgettext|trayitemsetonevent|trayitemsetstate|trayitemsettext|traysetclick|trayseticon|traysetonevent|traysetpauseicon|traysetstate|traysettooltip|traytip|ubound|udpbind|udpclosesocket|udpopen|udprecv|udpsend|udpshutdown|udpstartup|vargettype|winactivate|winactive|winclose|winexists|winflash|wingetcaretpos|wingetclasslist|wingetclientsize|wingethandle|wingetpos|wingetprocess|wingetstate|wingettext|wingettitle|winkill|winlist|winmenuselectitem|winminimizeall|winminimizeallundo|winmove|winsetontop|winsetstate|winsettitle|winsettrans|winwait|winwaitactive|winwaitclose|winwaitnotactive)\b" is(name.function)
+
+  lex(labels):
+    r"(^\s*)({\S+?})" is(by-groups(text, name.label))
+
+  lex(root):
+    r";.*\n" is(comment.single)
+    r"(\#comments-start|\#cs).*?(\#comments-end|\#ce)" is(comment.multiline)
+    r"[\[\]{}(),;]" is(punctuation)
+    r"(and|or|not)\b" is(operator.word)
+    r"[\$|@][a-zA-Z_][a-zA-Z0-9_]*" is(name.variable)
+    r"!=|==|:=|\.=|<<|>>|[-\126+/*%=<>&^|?:!.]" is(operator)
+    any-of(commands)
+    any-of(labels)
+    any-of(builtInFunctions)
+    any-of(builtInMarcros)
+    r"\"" is(literal.string) -> combined(stringescape, dqs)
+    any-of(numbers)
+    r"[a-zA-Z_\#@$][a-zA-Z0-9_\#@$]*" is(name)
+    r"\\|\'" is(text)
+    r"\`([\,\%\`abfnrtv\-\+;])" is(literal.string.escape)
+    r"_\n" is(text)
+    any-of(garbage)
+
+  lex(stringescape):
+    r"\\"\\"|\`([\,\%\`abfnrtv])" is(literal.string.escape)
+
+  lex(strings):
+    r"[^\"\n]+" is(literal.string)
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/imported/awk.ay

@@ -0,0 +1,42 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Awk"
+  aliases: ["awk", "gawk", "mawk", "nawk"]
+  extensions: [".awk"]
+  mimetypes: ["application/x-awk"]
+  start: .root
+  flags: 0
+
+  lex(commentsandwhitespace):
+    r"\s+" is(text)
+    r"\#.*$" is(comment.single)
+
+  lex(root):
+    r"^(?=\s|/)" is(text) -> go-to(slashstartsregex)
+    any-of(commentsandwhitespace)
+    r"\+\+|--|\|\||&&|in|\$|!?\126|(\*\*|[-<>+*%\^/!=])=?" is(operator) -> go-to(slashstartsregex)
+    r"[{(\[;,]" is(punctuation) -> go-to(slashstartsregex)
+    r"[})\].]" is(punctuation)
+    r"(break|continue|do|while|exit|for|if|return)\b" is(keyword) -> go-to(slashstartsregex)
+    r"function\b" is(keyword.declaration) -> go-to(slashstartsregex)
+    r"(atan2|cos|exp|int|log|rand|sin|sqrt|srand|gensub|gsub|index|length|match|split|sprintf|sub|substr|tolower|toupper|close|fflush|getline|next|nextfile|print|printf|strftime|systime|delete|system)\b" is(keyword.reserved)
+    r"(ARGC|ARGIND|ARGV|CONVFMT|ENVIRON|ERRNO|FIELDWIDTHS|FILENAME|FNR|FS|IGNORECASE|NF|NR|OFMT|OFS|ORFS|RLENGTH|RS|RSTART|RT|SUBSEP)\b" is(name.builtin)
+    r"[$a-zA-Z_][a-zA-Z0-9_]*" is(name.other)
+    r"[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?" is(literal.number.float)
+    r"0x[0-9a-fA-F]+" is(literal.number.hex)
+    r"[0-9]+" is(literal.number.integer)
+    r"\"(\\\\|\\\"|[^\"])*\"" is(literal.string.double)
+    r"'(\\\\|\\'|[^'])*'" is(literal.string.single)
+
+  lex(slashstartsregex):
+    any-of(commentsandwhitespace)
+    r"/(\\.|[^\[/\\\n]|\[(\\.|[^\]\\\n])*])+/\B" is(literal.string.regex) -> pop
+    r"(?=/)" is(text) -> do-all(pop, go-to(badregex))
+    r"" is(text) -> pop
+
+  lex(badregex):
+    r"\n" is(text) -> pop
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/imported/bash.ay

@@ -0,0 +1,63 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Bash"
+  aliases: ["bash", "sh", "ksh"]
+  extensions: [".sh", ".ksh", ".bash", ".ebuild", ".eclass", ".bashrc", "bashrc", ".bash_", "bash_"]
+  mimetypes: ["application/x-sh", "application/x-shellscript"]
+  start: .root
+  flags: 0
+
+  lex(curly):
+    r"}" is(keyword) -> pop
+    r":-" is(keyword)
+    r"[a-zA-Z0-9_]+" is(name.variable)
+    r"[^}:\"\'`$]+" is(punctuation)
+    r":" is(punctuation)
+    any-of(root)
+
+  lex(backticks):
+    r"`" is(literal.string.backtick) -> pop
+    any-of(root)
+
+  lex(root):
+    any-of(basic)
+    r"\$\(\(" is(keyword) -> go-to(math)
+    r"\$\(" is(keyword) -> go-to(paren)
+    r"\${\#?" is(keyword) -> go-to(curly)
+    r"`" is(literal.string.backtick) -> go-to(backticks)
+    any-of(data)
+
+  lex(basic):
+    r"\b(if|fi|else|while|do|done|for|then|return|function|case|select|continue|until|esac|elif)\s*\b" is(keyword)
+    r"\b(alias|bg|bind|break|builtin|caller|cd|command|compgen|complete|declare|dirs|disown|echo|enable|eval|exec|exit|export|false|fc|fg|getopts|hash|help|history|jobs|kill|let|local|logout|popd|printf|pushd|pwd|read|readonly|set|shift|shopt|source|suspend|test|time|times|trap|true|type|typeset|ulimit|umask|unalias|unset|wait)\s*\b(?!\.)" is(name.builtin)
+    r"\#.*\n" is(comment)
+    r"\\[\w\W]" is(literal.string.escape)
+    r"(\b\w+)(\s*)(=)" is(by-groups(name.variable, text, operator))
+    r"[\[\]{}()=]" is(operator)
+    r"<<<" is(operator)
+    r"<<-?\s*(\'?)\\?(\w+)[\w\W]+?\2" is(literal.string)
+    r"&&|\|\|" is(operator)
+
+  lex(paren):
+    r"\)" is(keyword) -> pop
+    any-of(root)
+
+  lex(data):
+    r"(?m)\$?\"(\\\\|\\[0-7]+|\\.|[^\"\\])*\"" is(literal.string.double)
+    r"(?m)\$?'(\\\\|\\[0-7]+|\\.|[^'\\])*'" is(literal.string.single)
+    r";" is(text)
+    r"\s+" is(text)
+    r"[^=\s\[\]{}()$\"\'`\\<]+" is(text)
+    r"\d+(?= |\Z)" is(literal.number)
+    r"\$\#?(\w+|.)" is(name.variable)
+    r"<" is(text)
+
+  lex(math):
+    r"\)\)" is(keyword) -> pop
+    r"[-+*/%^|&]|\*\*|\|\|" is(operator)
+    r"\d+" is(literal.number)
+    any-of(root)
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/imported/batch.ay

@@ -0,0 +1,45 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Batchfile"
+  aliases: ["bat"]
+  extensions: [".bat", ".cmd"]
+  mimetypes: ["application/x-dos-batch"]
+  start: .root
+  flags: Regexp IGNORECASE
+
+  lex(basic):
+    r"\".*?\"" is(literal.string.double)
+    r"'.*?'" is(literal.string.single)
+    r"`.*?`" is(literal.string.backtick)
+    r"-?\d+" is(literal.number)
+    r"," is(punctuation)
+    r"=" is(operator)
+    r"/\S+" is(name)
+    r":\w+" is(name.label)
+    r"\w:\w+" is(text)
+    r"([<>|])(\s*)(\w+)" is(by-groups(punctuation, text, name))
+
+  lex(root):
+    r"^\s*@" is(punctuation)
+    r"^(\s*)(rem\s.*)$" is(by-groups(text, comment))
+    r"\".*?\"" is(literal.string.double)
+    r"'.*?'" is(literal.string.single)
+    r"%%?[\126$:\w]+%?" is(name.variable)
+    r"::.*" is(comment)
+    r"(set)(\s+)(\w+)" is(by-groups(keyword, text, name.variable))
+    r"(call)(\s+)(:\w+)" is(by-groups(keyword, text, name.label))
+    r"(goto)(\s+)(\w+)" is(by-groups(keyword, text, name.label))
+    r"\b(set|call|echo|on|off|endlocal|for|do|goto|if|pause|setlocal|shift|errorlevel|exist|defined|cmdextversion|errorlevel|else|cd|md|del|deltree|cls|choice)\b" is(keyword)
+    r"\b(equ|neq|lss|leq|gtr|geq)\b" is(operator)
+    any-of(basic)
+    r"." is(text)
+
+  lex(echo):
+    r"\^\^|\^<|\^>|\^\|" is(literal.string.escape)
+    r"\n" is(text) -> pop
+    any-of(basic)
+    r"[^\'\"^]+" is(text)
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/imported/bbcode.ay

@@ -0,0 +1,23 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "BBCode"
+  aliases: ["bbcode"]
+  extensions: []
+  mimetypes: ["text/x-bbcode"]
+  start: .root
+  flags: 0
+
+  lex(tag):
+    r"\s+" is(text)
+    r"(\w+)(=)(\"?[^\s\"\]]+\"?)" is(by-groups(name.attribute, operator, literal.string))
+    r"(=)(\"?[^\s\"\]]+\"?)" is(by-groups(operator, literal.string))
+    r"\]" is(keyword) -> pop
+
+  lex(root):
+    r"[^\[]+" is(text)
+    r"\[/?\w+" is(keyword) -> go-to(tag)
+    r"\[" is(text)
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/imported/befunge.ay

@@ -0,0 +1,26 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Befunge"
+  aliases: ["befunge"]
+  extensions: [".befunge"]
+  mimetypes: ["application/x-befunge"]
+  start: .root
+  flags: 0
+
+  lex(root):
+    r"[0-9a-f]" is(literal.number)
+    r"[\+\*/%!`-]" is(operator)
+    r"[<>^v?\[\]rxjk]" is(name.variable)
+    r"[:\\$.,n]" is(name.builtin)
+    r"[|_mw]" is(keyword)
+    r"[{}]" is(name.tag)
+    r"\".*?\"" is(literal.string.double)
+    r"\'." is(literal.string.single)
+    r"[\#;]" is(comment)
+    r"[pg&\126=@iotsy]" is(keyword)
+    r"[()A-Z]" is(comment)
+    r"\s+" is(text)
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/imported/blitzmax.ay

@@ -0,0 +1,44 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "BlitzMax"
+  aliases: ["blitzmax", "bmax"]
+  extensions: [".bmx"]
+  mimetypes: ["text/x-bmx"]
+  start: .root
+  flags: Regexp IGNORECASE
+
+  lex(root):
+    r"[ \t]+" is(text)
+    r"\.\.\n" is(text)
+    r"'.*?\n" is(comment.single)
+    r"([ \t]*)\bRem\n(\n|.)*?\s*\bEnd([ \t]*)Rem" is(comment.multiline)
+    r"\"" is(literal.string.double) -> go-to(string)
+    r"[0-9]+\.[0-9]*(?!\.)" is(literal.number.float)
+    r"\.[0-9]*(?!\.)" is(literal.number.float)
+    r"[0-9]+" is(literal.number.integer)
+    r"\$[0-9a-f]+" is(literal.number.hex)
+    r"\%[10]+" is(literal.number)
+    r"(?:(?:(:)?([ \t]*)(:?\b(Shl|Shr|Sar|Mod)\b|([+\-*/&|\126]))|Or|And|Not|[=<>^]))" is(operator)
+    r"[(),.:\[\]]" is(punctuation)
+    r"(?:\#[\w \t]*)" is(name.label)
+    r"(?:\?[\w \t]*)" is(comment.preproc)
+    r"\b(New)\b([ \t]?)([(]?)([a-z_][a-z0-9_]*)" is(by-groups(keyword.reserved, text, punctuation, name.class))
+    r"\b(Import|Framework|Module)([ \t]+)([a-z_][a-z0-9_]*\.[a-z_][a-z0-9_]*)" is(by-groups(keyword.reserved, text, keyword.namespace))
+    r"([a-z_][a-z0-9_]*)(?:(?:([ \t]*)(@{1,2}|[!\#$%])|([ \t]*:[ \t]*\b(?:Shl|Shr|Sar|Mod)\b)|([ \t]*)([:])([ \t]*)(?:\b(Int|Byte|Short|Float|Double|Long)\b|([a-z_][a-z0-9_]*)))(?:([ \t]*)(Ptr))?)?((?:[ \t]|\.\.\n)*)([(])" is(by-groups(name.function, text, keyword.type, operator, text, punctuation, text, keyword.type, name.class, text, keyword.type, text, punctuation))
+    r"([a-z_][a-z0-9_]*)(?:(?:([ \t]*)(@{1,2}|[!\#$%])|([ \t]*:[ \t]*\b(?:Shl|Shr|Sar|Mod)\b)|([ \t]*)([:])([ \t]*)(?:\b(Int|Byte|Short|Float|Double|Long)\b|([a-z_][a-z0-9_]*)))(?:([ \t]*)(Ptr))?)" is(by-groups(name.variable, text, keyword.type, operator, text, punctuation, text, keyword.type, name.class, text, keyword.type))
+    r"\b(Type|Extends)([ \t]+)([a-z_][a-z0-9_]*)" is(by-groups(keyword.reserved, text, name.class))
+    r"\b(Ptr)\b" is(keyword.type)
+    r"\b(Pi|True|False|Null|Self|Super)\b" is(keyword.constant)
+    r"\b(Local|Global|Const|Field)\b" is(keyword.declaration)
+    r"\b(TNullMethodException|TNullFunctionException|TNullObjectException|TArrayBoundsException|TRuntimeException)\b" is(name.exception)
+    r"\b(Strict|SuperStrict|Module|ModuleInfo|End|Return|Continue|Exit|Public|Private|Var|VarPtr|Chr|Len|Asc|SizeOf|Sgn|Abs|Min|Max|New|Release|Delete|Incbin|IncbinPtr|IncbinLen|Framework|Include|Import|Extern|EndExtern|Function|EndFunction|Type|EndType|Extends|Method|EndMethod|Abstract|Final|If|Then|Else|ElseIf|EndIf|For|To|Next|Step|EachIn|While|Wend|EndWhile|Repeat|Until|Forever|Select|Case|Default|EndSelect|Try|Catch|EndTry|Throw|Assert|Goto|DefData|ReadData|RestoreData)\b" is(keyword.reserved)
+    r"([a-z_][a-z0-9_]*)" is(name.variable)
+
+  lex(string):
+    r"\"\"" is(literal.string.double)
+    r"\"C?" is(literal.string.double) -> pop
+    r"[^\"]+" is(literal.string.double)
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/imported/boo.ay

@@ -0,0 +1,55 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Boo"
+  aliases: ["boo"]
+  extensions: [".boo"]
+  mimetypes: ["text/x-boo"]
+  start: .root
+  flags: 0
+
+  lex(comment):
+    r"/[*]" is(comment.multiline) -> push
+    r"[*]/" is(comment.multiline) -> pop
+    r"[^/*]" is(comment.multiline)
+    r"[*/]" is(comment.multiline)
+
+  lex(classname):
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name.class) -> pop
+
+  lex(namespace):
+    r"[a-zA-Z_][a-zA-Z0-9_.]*" is(name.namespace) -> pop
+
+  lex(root):
+    r"\s+" is(text)
+    r"(\#|//).*$" is(comment.single)
+    r"/[*]" is(comment.multiline) -> go-to(comment)
+    r"[\]{}:(),.;\[]" is(punctuation)
+    r"\\\n" is(text)
+    r"\\" is(text)
+    r"(in|is|and|or|not)\b" is(operator.word)
+    r"/(\\\\|\\/|[^/\s])/" is(literal.string.regex)
+    r"@/(\\\\|\\/|[^/])*/" is(literal.string.regex)
+    r"=\126|!=|==|<<|>>|[-+/*%=<>&^|]" is(operator)
+    r"(as|abstract|callable|constructor|destructor|do|import|enum|event|final|get|interface|internal|of|override|partial|private|protected|public|return|set|static|struct|transient|virtual|yield|super|and|break|cast|continue|elif|else|ensure|except|for|given|goto|if|in|is|isa|not|or|otherwise|pass|raise|ref|try|unless|when|while|from|as)\b" is(keyword)
+    r"def(?=\s+\(.*?\))" is(keyword)
+    r"(def)(\s+)" is(by-groups(keyword, text)) -> go-to(funcname)
+    r"(class)(\s+)" is(by-groups(keyword, text)) -> go-to(classname)
+    r"(namespace)(\s+)" is(by-groups(keyword, text)) -> go-to(namespace)
+    r"(?<!\.)(true|false|null|self|__eval__|__switch__|array|assert|checked|enumerate|filter|getter|len|lock|map|matrix|max|min|normalArrayIndexing|print|property|range|rawArrayIndexing|required|typeof|unchecked|using|yieldAll|zip)\b" is(name.builtin)
+    r"\"\"\"(\\\\|\\\"|.*?)\"\"\"" is(literal.string.double)
+    r"\"(\\\\|\\\"|[^\"]*?)\"" is(literal.string.double)
+    r"'(\\\\|\\'|[^']*?)'" is(literal.string.single)
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name)
+    r"(\d+\.\d*|\d*\.\d+)([fF][+-]?[0-9]+)?" is(literal.number.float)
+    r"[0-9][0-9\.]*(ms?|d|h|s)" is(literal.number)
+    r"0\d+" is(literal.number.oct)
+    r"0x[a-fA-F0-9]+" is(literal.number.hex)
+    r"\d+L" is(literal.number.integer.long)
+    r"\d+" is(literal.number.integer)
+
+  lex(funcname):
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name.function) -> pop
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/imported/brainfuck.ay

@@ -0,0 +1,28 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Brainfuck"
+  aliases: ["brainfuck", "bf"]
+  extensions: [".bf", ".b"]
+  mimetypes: ["application/x-brainfuck"]
+  start: .root
+  flags: 0
+
+  lex(root):
+    r"\[" is(keyword) -> go-to(loop)
+    r"\]" is(error)
+    any-of(common)
+
+  lex(common):
+    r"[.,]+" is(name.tag)
+    r"[+-]+" is(name.builtin)
+    r"[<>]+" is(name.variable)
+    r"[^.,+\-<>\[\]]+" is(comment)
+
+  lex(loop):
+    r"\[" is(keyword) -> push
+    r"\]" is(keyword) -> pop
+    any-of(common)
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/imported/bro.ay

@@ -0,0 +1,57 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Bro"
+  aliases: ["bro"]
+  extensions: [".bro"]
+  mimetypes: []
+  start: .root
+  flags: 0
+
+  lex(regex):
+    r"/" is(literal.string.regex) -> pop
+    r"\\[\\nt/]" is(literal.string.regex)
+    r"[^\\/\n]+" is(literal.string.regex)
+    r"\\\n" is(literal.string.regex)
+    r"\\" is(literal.string.regex)
+
+  lex(root):
+    r"^@.*?\n" is(comment.preproc)
+    r"\#.*?\n" is(comment.single)
+    r"\n" is(text)
+    r"\s+" is(text)
+    r"\\\n" is(text)
+    r"(add|alarm|break|case|const|continue|delete|do|else|enum|event|export|for|function|if|global|local|module|next|of|print|redef|return|schedule|type|when|while)\b" is(keyword)
+    r"(addr|any|bool|count|counter|double|file|int|interval|net|pattern|port|record|set|string|subnet|table|time|timer|vector)\b" is(keyword.type)
+    r"(T|F)\b" is(keyword.constant)
+    r"(&)((?:add|delete|expire)_func|attr|(?:create|read|write)_expire|default|disable_print_hook|raw_output|encrypt|group|log|mergeable|optional|persistent|priority|redef|rotate_(?:interval|size)|synchronized)\b" is(by-groups(punctuation, keyword))
+    r"\s+module\b" is(keyword.namespace)
+    r"\d+/(tcp|udp|icmp|unknown)\b" is(literal.number)
+    r"(\d+\.){3}\d+" is(literal.number)
+    r"([0-9a-fA-F_]+){7}[0-9a-fA-F_]+" is(literal.number)
+    r"0x[0-9a-fA-F_]+([0-9a-fA-F_]+|:)*::([0-9a-fA-F_]+|:)*" is(literal.number)
+    r"((\d+|:)([0-9a-fA-F_]+|:)*)?::([0-9a-fA-F_]+|:)*" is(literal.number)
+    r"(\d+\.\d+\.|(\d+\.){2}\d+)" is(literal.number)
+    r"[A-Za-z0-9][-A-Za-z0-9]*(\.[A-Za-z0-9][-A-Za-z0-9]*)+" is(literal.string)
+    r"((\d*\.?\d+)|(\d+\.?\d*))([eE][-+]?\d+)?\s+(day|hr|min|sec|msec|usec)s?\b" is(literal.date)
+    r"0[xX][0-9a-fA-F_]+" is(literal.number.hex)
+    r"((\d*\.?\d+)|(\d+\.?\d*))([eE][-+]?\d+)?" is(literal.number.float)
+    r"\d+" is(literal.number.integer)
+    r"/" is(literal.string.regex) -> go-to(regex)
+    r"\"" is(literal.string) -> go-to(string)
+    r"[!%*/+:<=>?\126|-]" is(operator)
+    r"([-+=&|]{2}|[+=!><-]=)" is(operator)
+    r"(in|match)\b" is(operator.word)
+    r"[{}()\[\]$.,;]" is(punctuation)
+    r"([_a-zA-Z]\w*)(::)" is(by-groups(name, name.namespace))
+    r"[a-zA-Z_][a-zA-Z_0-9]*" is(name)
+
+  lex(string):
+    r"\"" is(literal.string) -> pop
+    r"\\([\\abfnrtv\"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})" is(literal.string.escape)
+    r"[^\\\"\n]+" is(literal.string)
+    r"\\\n" is(literal.string)
+    r"\\" is(literal.string)
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/imported/bugs.ay

@@ -0,0 +1,31 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "BUGS"
+  aliases: ["bugs", "winbugs", "openbugs"]
+  extensions: [".bug"]
+  mimetypes: []
+  start: .root
+  flags: 0
+
+  lex(root):
+    any-of(comments)
+    any-of(whitespace)
+    r"(model)(\s+)({)" is(by-groups(keyword.namespace, text, punctuation))
+    r"(for|in)(?![0-9a-zA-Z\._])" is(keyword.reserved)
+    r"(abs|arccos|arccosh|arcsin|arcsinh|arctan|arctanh|cloglog|cos|cosh|cumulative|cut|density|deviance|equals|expr|gammap|ilogit|icloglog|integral|log|logfact|loggam|logit|max|min|phi|post.p.value|pow|prior.p.value|probit|replicate.post|replicate.prior|round|sin|sinh|solution|sqrt|step|tan|tanh|trunc|inprod|interp.lin|inverse|logdet|mean|eigen.vals|ode|prod|p.valueM|rank|ranked|replicate.postM|sd|sort|sum|D|I|F|T|C|dbern|dbin|dcat|dnegbin|dpois|dhyper|dbeta|dchisqr|ddexp|dexp|dflat|dgamma|dgev|df|dggamma|dgpar|dloglik|dlnorm|dlogis|dnorm|dpar|dt|dunif|dweib|dmulti|ddirch|dmnorm|dmt|dwish)(?=\s*\()" is(name.builtin)
+    r"[A-Za-z][A-Za-z0-9_.]*" is(name)
+    r"[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?" is(literal.number)
+    r"\[|\]|\(|\)|:|,|;" is(punctuation)
+    r"<-|\126" is(operator)
+    r"\+|-|\*|/" is(operator)
+    r"[{}]" is(punctuation)
+
+  lex(whitespace):
+    r"\s+" is(text)
+
+  lex(comments):
+    r"\#.*$" is(comment.single)
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/imported/c.ay

@@ -0,0 +1,84 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "C"
+  aliases: ["c"]
+  extensions: [".c", ".h", ".idc"]
+  mimetypes: ["text/x-chdr", "text/x-csrc"]
+  start: .root
+  flags: 0
+
+  lex(function):
+    any-of(whitespace)
+    any-of(statements)
+    r";" is(punctuation)
+    r"{" is(punctuation) -> push
+    r"}" is(punctuation) -> pop
+
+  lex(statements):
+    r"L?\"" is(literal.string) -> go-to(string)
+    r"L?'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'" is(literal.string.char)
+    r"(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*" is(literal.number.float)
+    r"(\d+\.\d*|\.\d+|\d+[fF])[fF]?" is(literal.number.float)
+    r"0x[0-9a-fA-F]+[LlUu]*" is(literal.number.hex)
+    r"0[0-7]+[LlUu]*" is(literal.number.oct)
+    r"\d+[LlUu]*" is(literal.number.integer)
+    r"\*/" is(error)
+    r"[\126!%^&*+=|?:<>/-]" is(operator)
+    r"[()\[\],.]" is(punctuation)
+    r"\b(case)(.+?)(:)" is(by-groups(keyword, using(self class), text))
+    r"(auto|break|case|const|continue|default|do|else|enum|extern|for|goto|if|register|restricted|return|sizeof|static|struct|switch|typedef|union|volatile|while)\b" is(keyword)
+    r"(bool|int|long|float|short|double|char|unsigned|signed|void|[a-z_][a-z0-9_]*_t)\b" is(keyword.type)
+    r"(_{0,2}inline|naked|restrict|thread|typename)\b" is(keyword.reserved)
+    r"(__(m128i|m128d|m128|m64))\b" is(keyword.reserved)
+    r"__(asm|int8|based|except|int16|stdcall|cdecl|fastcall|int32|declspec|finally|int64|try|leave|wchar_t|w64|unaligned|raise|noop|identifier|forceinline|assume)\b" is(keyword.reserved)
+    r"(true|false|NULL)\b" is(name.builtin)
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name)
+
+  lex(whitespace):
+    r"^\#if\s+0" is(comment.preproc) -> go-to(if0)
+    r"^\#" is(comment.preproc) -> go-to(macro)
+    r"^(:\s*/[*].*?[*]/\s*)(\#if\s+0)" is(by-groups(using(self class), comment.preproc)) -> go-to(if0)
+    r"^(:\s*/[*].*?[*]/\s*)(\#)" is(by-groups(using(self class), comment.preproc)) -> go-to(macro)
+    r"^(\s*)([a-zA-Z_][a-zA-Z0-9_]*:(?!:))" is(by-groups(text, name.label))
+    r"\n" is(text)
+    r"\s+" is(text)
+    r"\\\n" is(text)
+    r"//(\n|(.|\n)*?[^\\]\n)" is(comment.single)
+    r"/(\\\n)?[*](.|\n)*?[*](\\\n)?/" is(comment.multiline)
+
+  lex(statement):
+    any-of(whitespace)
+    any-of(statements)
+    r"[{}]" is(punctuation)
+    r";" is(punctuation) -> pop
+
+  lex(if0):
+    r"^\s*\#if.*?(?<!\\)\n" is(comment.preproc) -> push
+    r"^\s*\#el(?:se|if).*\n" is(comment.preproc) -> pop
+    r"^\s*\#endif.*?(?<!\\)\n" is(comment.preproc) -> pop
+    r".*?\n" is(comment)
+
+  lex(macro):
+    r"[^/\n]+" is(comment.preproc)
+    r"/[*](.|\n)*?[*]/" is(comment.multiline)
+    r"//.*?\n" is(comment.single) -> pop
+    r"/" is(comment.preproc)
+    r"(?<=\\)\n" is(comment.preproc)
+    r"\n" is(comment.preproc) -> pop
+
+  lex(root):
+    any-of(whitespace)
+    r"((?:[a-zA-Z0-9_*\s])+?(?:\s|[*]))([a-zA-Z_][a-zA-Z0-9_]*)(\s*\([^;]*?\))((?:\s|//.*?\n|/[*].*?[*]/)+)?({)" is(by-groups(using(self class), name.function, using(self class), using(self class), punctuation)) -> go-to(function)
+    r"((?:[a-zA-Z0-9_*\s])+?(?:\s|[*]))([a-zA-Z_][a-zA-Z0-9_]*)(\s*\([^;]*?\))((?:\s|//.*?\n|/[*].*?[*]/)+)?(;)" is(by-groups(using(self class), name.function, using(self class), using(self class), punctuation))
+    r"" is(text) -> go-to(statement)
+
+  lex(string):
+    r"\"" is(literal.string) -> pop
+    r"\\([\\abfnrtv\"\']|x[a-fA-F0-9]{2,4}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|[0-7]{1,3})" is(literal.string.escape)
+    r"[^\\\"\n]+" is(literal.string)
+    r"\\\n" is(literal.string)
+    r"\\" is(literal.string)
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/imported/ca65.ay

@@ -0,0 +1,26 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "ca65"
+  aliases: ["ca65"]
+  extensions: [".s"]
+  mimetypes: []
+  start: .root
+  flags: Regexp IGNORECASE
+
+  lex(root):
+    r";.*" is(comment.single)
+    r"\s+" is(text)
+    r"[a-z_.@$][\w.@$]*:" is(name.label)
+    r"((ld|st)[axy]|(in|de)[cxy]|asl|lsr|ro[lr]|adc|sbc|cmp|cp[xy]|cl[cvdi]|se[cdi]|jmp|jsr|bne|beq|bpl|bmi|bvc|bvs|bcc|bcs|p[lh][ap]|rt[is]|brk|nop|ta[xy]|t[xy]a|txs|tsx|and|ora|eor|bit)\b" is(keyword)
+    r"\.[a-z0-9_]+" is(keyword.pseudo)
+    r"[-+\126*/^&|!<>=]" is(operator)
+    r"\"[^\"\n]*." is(literal.string)
+    r"'[^'\n]*." is(literal.string.char)
+    r"\$[0-9a-f]+|[0-9a-f]+h\b" is(literal.number.hex)
+    r"\d+|%[01]+" is(literal.number.integer)
+    r"[\#,.:()=]" is(punctuation)
+    r"[a-z_.@$][\w.@$]*" is(name)
+
+const-set(.Lexer, lexer)

data/lib/hl/lexers/imported/cbmbasicv2.ay

@@ -0,0 +1,25 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "CBM BASIC V2"
+  aliases: ["cbmbas"]
+  extensions: [".bas"]
+  mimetypes: []
+  start: .root
+  flags: Regexp IGNORECASE
+
+  lex(root):
+    r"rem.*\n" is(comment.single)
+    r"\s+" is(text)
+    r"new|run|end|for|to|next|step|go(to|sub)?|on|return|stop|cont|if|then|input\#?|read|wait|load|save|verify|poke|sys|print\#?|list|clr|cmd|open|close|get\#?" is(keyword.reserved)
+    r"data|restore|dim|let|def|fn" is(keyword.declaration)
+    r"tab|spc|sgn|int|abs|usr|fre|pos|sqr|rnd|log|exp|cos|sin|tan|atn|peek|len|val|asc|(str|chr|left|right|mid)\$" is(name.builtin)
+    r"[-+*/^<>=]" is(operator)
+    r"not|and|or" is(operator.word)
+    r"\"[^\"\n]*." is(literal.string)
+    r"\d+|[-+]?\d*\.\d*(e[-+]?\d+)?" is(literal.number.float)
+    r"[\(\),:;]" is(punctuation)
+    r"\w+[$%]?" is(name)
+
+const-set(.Lexer, lexer)