broomhlda 0.1.0

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

@@ -0,0 +1,143 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Lasso"
+  aliases: ["lasso", "lassoscript"]
+  extensions: [".lasso", ".lasso[89]"]
+  mimetypes: ["text/x-lasso"]
+  start: .root
+  flags: Regexp IGNORECASE | Regexp MULTILINE
+
+  lex(anglebrackets):
+    r"\?>" is(comment.preproc) -> pop
+    any-of(lasso)
+
+  lex(nosquarebrackets):
+    r"<\?(LassoScript|lasso|=)" is(comment.preproc) -> go-to(anglebrackets)
+    r"<" is(other)
+    r"[^<]+" is(other)
+
+  lex(delimiters):
+    r"\[no_square_brackets\]" is(comment.preproc) -> go-to(nosquarebrackets)
+    r"\[noprocess\]" is(comment.preproc) -> go-to(noprocess)
+    r"\[" is(comment.preproc) -> go-to(squarebrackets)
+    r"<\?(LassoScript|lasso|=)" is(comment.preproc) -> go-to(anglebrackets)
+    r"<" is(other)
+    r"[^\[<]+" is(other)
+
+  lex(doublestring):
+    r"\"" is(literal.string.double) -> pop
+    r"[^\"\\]+" is(literal.string.double)
+    any-of(escape)
+    r"\\+" is(literal.string.double)
+
+  lex(escape):
+    r"\\(U[\da-f]{8}|u[\da-f]{4}|x[\da-f]{1,2}|[0-7]{1,3}|:[^:]+:|[abefnrtv?\\"\'\\]|$)" is(literal.string.escape)
+
+  lex(squarebrackets):
+    r"\]" is(comment.preproc) -> pop
+    any-of(lasso)
+
+  lex(signature):
+    r"=>" is(operator) -> pop
+    r"\)" is(punctuation) -> pop
+    r"[(,]" is(punctuation) -> go-to(parameter)
+    any-of(lasso)
+
+  lex(lassofile):
+    r"\]" is(comment.preproc) -> pop
+    r"\?>" is(comment.preproc) -> pop
+    any-of(lasso)
+
+  lex(singlestring):
+    r"'" is(literal.string.single) -> pop
+    r"[^'\\]+" is(literal.string.single)
+    any-of(escape)
+    r"\\+" is(literal.string.single)
+
+  lex(whitespacecomments):
+    r"\s+" is(text)
+    r"//.*?\n" is(comment.single)
+    r"/\*\*!.*?\*/" is(literal.string.doc)
+    r"/\*.*?\*/" is(comment.multiline)
+
+  lex(requiresection):
+    r"(([a-z_][\w.]*=?|[-+*/%<>]|==)(?=\s*\())" is(name) -> go-to(requiresignature)
+    r"(([a-z_][\w.]*=?|[-+*/%<>]|==)(?=(\s*::\s*[\w.]+)?\s*,))" is(name)
+    r"[a-z_][\w.]*=?|[-+*/%<>]|==" is(name) -> pop
+    r"(::\s*)([a-z_][\w.]*)" is(by-groups(punctuation, name.label))
+    r"," is(punctuation)
+    any-of(whitespacecomments)
+
+  lex(requiresignature):
+    r"(\)(?=(\s*::\s*[\w.]+)?\s*,))" is(punctuation) -> pop
+    r"\)" is(punctuation) -> pop(2)
+    r"-?[a-z_][\w.]*" is(name.attribute)
+    r"(::\s*)([a-z_][\w.]*)" is(by-groups(punctuation, name.label))
+    r"\.\.\." is(name.builtin.pseudo)
+    r"[(,]" is(punctuation)
+    any-of(whitespacecomments)
+
+  lex(parameter):
+    r"\)" is(punctuation) -> pop
+    r"-?[a-z_][\w.]*" is(name.attribute) -> pop
+    r"\.\.\." is(name.builtin.pseudo)
+    any-of(lasso)
+
+  lex(root):
+    r"^\#!.+lasso9\b" is(comment.preproc) -> go-to(lasso)
+    r"\[no_square_brackets\]" is(comment.preproc) -> go-to(nosquarebrackets)
+    r"\[noprocess\]" is(comment.preproc) -> do-all(go-to(delimiters), go-to(noprocess))
+    r"\[" is(comment.preproc) -> do-all(go-to(delimiters), go-to(squarebrackets))
+    r"<\?(LassoScript|lasso|=)" is(comment.preproc) -> do-all(go-to(delimiters), go-to(anglebrackets))
+    r"<" is(other) -> go-to(delimiters)
+    r"\s+" is(other)
+    r"" is(other) -> do-all(go-to(delimiters), go-to(lassofile))
+
+  lex(noprocess):
+    r"\[/noprocess\]" is(comment.preproc) -> pop
+    r"\[" is(other)
+    r"[^\[]" is(other)
+
+  lex(lasso):
+    any-of(whitespacecomments)
+    r"\d*\.\d+(e[+-]?\d+)?" is(literal.number.float)
+    r"0x[\da-f]+" is(literal.number.hex)
+    r"\d+" is(literal.number.integer)
+    r"([+-]?)(infinity|NaN)\b" is(by-groups(operator, literal.number))
+    r"'" is(literal.string.single) -> go-to(singlestring)
+    r"\"" is(literal.string.double) -> go-to(doublestring)
+    r"`[^`]*`" is(literal.string.backtick)
+    r"\$[a-z_][\w.]*" is(name.variable)
+    r"\#[a-z_][\w.]*|\#\d+" is(name.variable.instance)
+    r"(\.)('[a-z_][\w.]*')" is(by-groups(name.builtin.pseudo, name.variable.class))
+    r"(self)(->)('[a-z_][\w.]*')" is(by-groups(name.builtin.pseudo, operator, name.variable.class))
+    r"(\.\.?)([a-z_][\w.]*)" is(by-groups(name.builtin.pseudo, name.other))
+    r"(self|inherited|global|void)\b" is(name.builtin.pseudo)
+    r"-[a-z_][\w.]*" is(name.attribute)
+    r"(::\s*)([a-z_][\w.]*)" is(by-groups(punctuation, name.label))
+    r"(error_(code|msg)_\w+|Error_AddError|Error_ColumnRestriction|Error_DatabaseConnectionUnavailable|Error_DatabaseTimeout|Error_DeleteError|Error_FieldRestriction|Error_FileNotFound|Error_InvalidDatabase|Error_InvalidPassword|Error_InvalidUsername|Error_ModuleNotFound|Error_NoError|Error_NoPermission|Error_OutOfMemory|Error_ReqColumnMissing|Error_ReqFieldMissing|Error_RequiredColumnMissing|Error_RequiredFieldMissing|Error_UpdateError)\b" is(name.exception)
+    r"(define)(\s+)([a-z_][\w.]*)(\s*)(=>)(\s*)(type|trait|thread)\b" is(by-groups(keyword.declaration, text, name.class, text, operator, text, keyword))
+    r"(define)(\s+)([a-z_][\w.]*)(->)([a-z_][\w.]*=?|[-+*/%<>]|==)" is(by-groups(keyword.declaration, text, name.class, operator, name.function)) -> go-to(signature)
+    r"(define)(\s+)([a-z_][\w.]*)" is(by-groups(keyword.declaration, text, name.function)) -> go-to(signature)
+    r"(public|protected|private|provide)(\s+)(([a-z_][\w.]*=?|[-+*/%<>]|==)(?=\s*\())" is(by-groups(keyword, text, name.function)) -> go-to(signature)
+    r"(public|protected|private)(\s+)([a-z_][\w.]*)" is(by-groups(keyword, text, name.function))
+    r"(true|false|none|minimal|full|all)\b" is(keyword.constant)
+    r"(local|var|variable|data)\b" is(keyword.declaration)
+    r"(array|date|decimal|duration|integer|map|pair|string|tag|xml|null)\b" is(keyword.type)
+    r"([a-z_][\w.]*)(\s+)(in)\b" is(by-groups(name, text, keyword))
+    r"(let|into)(\s+)([a-z_][\w.]*)" is(by-groups(keyword, text, name))
+    r"require\b" is(keyword) -> go-to(requiresection)
+    r"(/?)(Namespace_Using)\b" is(by-groups(punctuation, keyword.namespace))
+    r"(/?)(Cache|Database_Names|Database_SchemaNames|Database_TableNames|Define_Tag|Define_Type|Email_Batch|Encode_Set|HTML_Comment|Handle|Handle_Error|Header|If|Inline|Iterate|LJAX_Target|Link|Link_CurrentAction|Link_CurrentGroup|Link_CurrentRecord|Link_Detail|Link_FirstGroup|Link_FirstRecord|Link_LastGroup|Link_LastRecord|Link_NextGroup|Link_NextRecord|Link_PrevGroup|Link_PrevRecord|Log|Loop|NoProcess|Output_None|Portal|Private|Protect|Records|Referer|Referrer|Repeating|ResultSet|Rows|Search_Args|Search_Arguments|Select|Sort_Args|Sort_Arguments|Thread_Atomic|Value_List|While|Abort|Case|Else|If_Empty|If_False|If_Null|If_True|Loop_Abort|Loop_Continue|Loop_Count|Params|Params_Up|Return|Return_Value|Run_Children|SOAP_DefineTag|SOAP_LastRequest|SOAP_LastResponse|Tag_Name|ascending|average|by|define|descending|do|equals|frozen|group|handle_failure|import|in|into|join|let|match|max|min|on|order|parent|protected|provide|public|require|skip|split_thread|sum|take|thread|to|trait|type|where|with|yield)\b" is(by-groups(punctuation, keyword))
+    r"(([a-z_][\w.]*=?|[-+*/%<>]|==)(?=\s*\([^)]*\)\s*=>))" is(name.function) -> go-to(signature)
+    r"(and|or|not)\b" is(operator.word)
+    r"([a-z_][\w.]*)(\s*)(::\s*)([a-z_][\w.]*)(\s*)(=)" is(by-groups(name, text, punctuation, name.label, text, operator))
+    r"((?<!->)[a-z_][\w.]*)(\s*)(=(?!=))" is(by-groups(name, text, operator))
+    r"(/?)([\w.]+)" is(by-groups(punctuation, name.other))
+    r"(=)(bw|ew|cn|lte?|gte?|n?eq|ft|n?rx)\b" is(by-groups(operator, operator.word))
+    r":=|[-+*/%=<>&|!?\\]+" is(operator)
+    r"[{}():;,@^]" is(punctuation)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,24 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Lighttpd configuration file"
+  aliases: ["lighty", "lighttpd"]
+  extensions: []
+  mimetypes: ["text/x-lighttpd-conf"]
+  start: .root
+  flags: 0
+
+  lex(root):
+    r"\#.*\n" is(comment.single)
+    r"/\S*" is(name)
+    r"[a-zA-Z._-]+" is(keyword)
+    r"\d+\.\d+\.\d+\.\d+(?:/\d+)?" is(literal.number)
+    r"[0-9]+" is(literal.number)
+    r"=>|=\126|\+=|==|=|\+" is(operator)
+    r"\$[A-Z]+" is(name.builtin)
+    r"[(){}\[\],]" is(punctuation)
+    r"\"([^\"\\]*(?:\\.[^\"\\]*)*)\"" is(literal.string.double)
+    r"\s+" is(text)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,82 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "LiveScript"
+  aliases: ["live-script", "livescript"]
+  extensions: [".ls"]
+  mimetypes: ["text/livescript"]
+  start: .root
+  flags: Regexp MULTILINE
+
+  lex(commentsandwhitespace):
+    r"\s+" is(text)
+    r"/\*.*?\*/" is(comment.multiline)
+    r"\#.*?\n" is(comment.single)
+
+  lex(tdqs):
+    r"\"\"\"" is(literal.string) -> pop
+    r"\\.|\'|\"" is(literal.string)
+    r"\#{" is(literal.string.interpol) -> go-to(interpoling-string)
+    r"\#" is(literal.string)
+    any-of(strings)
+
+  lex(interpoling-string):
+    r"}" is(literal.string.interpol) -> pop
+    any-of(root)
+
+  lex(dqs):
+    r"\"" is(literal.string) -> pop
+    r"\\.|\'" is(literal.string)
+    r"\#{" is(literal.string.interpol) -> go-to(interpoling-string)
+    r"\#" is(literal.string)
+    any-of(strings)
+
+  lex(sqs):
+    r"'" is(literal.string) -> pop
+    r"\#|\\.|\"" is(literal.string)
+    any-of(strings)
+
+  lex(root):
+    any-of(commentsandwhitespace)
+    r"(?:\([^()]+\))?[ ]*[\126-]{1,2}>|(?:\(?[^()\n]+\)?)?[ ]*<[\126-]{1,2}" is(name.function)
+    r"\+\+|&&|(?<![\.\$])\b(?:and|x?or|is|isnt|not)\b|\?|:|=|\|\||\\(?=\n)|(<<|>>>?|==?|!=?|\126(?!\\126?>)|-(?!\-?>)|<(?!\[)|(?<!\])>|[+*`%&\|\^/])=?" is(operator) -> go-to(slashstartsregex)
+    r"[{(\[;,]" is(punctuation) -> go-to(slashstartsregex)
+    r"[})\].]" is(punctuation)
+    r"(?<![\.\$])(for|own|in|of|while|until|loop|break|return|continue|switch|when|then|if|unless|else|throw|try|catch|finally|new|delete|typeof|instanceof|super|extends|this|class|by|const|var|to|til)\b" is(keyword) -> go-to(slashstartsregex)
+    r"(?<![\.\$])(true|false|yes|no|on|off|null|NaN|Infinity|undefined|void)\b" is(keyword.constant)
+    r"(Array|Boolean|Date|Error|Function|Math|netscape|Number|Object|Packages|RegExp|String|sun|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|eval|isFinite|isNaN|parseFloat|parseInt|document|window)\b" is(name.builtin)
+    r"[$a-zA-Z_][a-zA-Z0-9_\.\-:\$]*\s*[:=]\s" is(name.variable) -> go-to(slashstartsregex)
+    r"@[$a-zA-Z_][a-zA-Z0-9_\.\-:\$]*\s*[:=]\s" is(name.variable.instance) -> go-to(slashstartsregex)
+    r"@" is(name.other) -> go-to(slashstartsregex)
+    r"@?[$a-zA-Z_][a-zA-Z0-9_\-]*" is(name.other) -> go-to(slashstartsregex)
+    r"[0-9]+\.[0-9]+([eE][0-9]+)?[fd]?(?:[a-zA-Z_]+)?" is(literal.number.float)
+    r"[0-9]+(\126[0-9a-z]+)?(?:[a-zA-Z_]+)?" is(literal.number.integer)
+    r"\"\"\"" is(literal.string) -> go-to(tdqs)
+    r"'''" is(literal.string) -> go-to(tsqs)
+    r"\"" is(literal.string) -> go-to(dqs)
+    r"'" is(literal.string) -> go-to(sqs)
+    r"\\[\w$-]+" is(literal.string)
+    r"<\[.*\]>" is(literal.string)
+
+  lex(multilineregex):
+    any-of(commentsandwhitespace)
+    r"//([gim]+\b|\B)" is(literal.string.regex) -> pop
+    r"/" is(literal.string.regex)
+    r"[^/\#]+" is(literal.string.regex)
+
+  lex(slashstartsregex):
+    any-of(commentsandwhitespace)
+    r"//" is(literal.string.regex) -> do-all(pop, go-to(multilineregex))
+    r"/(?! )(\\.|[^\[/\\\n]|\[(\\.|[^\]\\\n])*])+/([gim]+\b|\B)" is(literal.string.regex) -> pop
+    r"" is(text) -> pop
+
+  lex(tsqs):
+    r"'''" is(literal.string) -> pop
+    r"\#|\\.|\'|\"" is(literal.string)
+    any-of(strings)
+
+  lex(strings):
+    r"[^\#\\\'\"]+" is(literal.string)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,36 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "LLVM"
+  aliases: ["llvm"]
+  extensions: [".ll"]
+  mimetypes: ["text/x-llvm"]
+  start: .root
+  flags: 0
+
+  lex(root):
+    any-of(whitespace)
+    r"([-a-zA-Z$._][-a-zA-Z$._0-9]*|\"[^\"]*?\")\s*:" is(name.label)
+    any-of(keyword)
+    r"%([-a-zA-Z$._][-a-zA-Z$._0-9]*|\"[^\"]*?\")" is(name.variable)
+    r"@([-a-zA-Z$._][-a-zA-Z$._0-9]*|\"[^\"]*?\")" is(name.variable.global)
+    r"%\d+" is(name.variable.anonymous)
+    r"@\d+" is(name.variable.global)
+    r"!([-a-zA-Z$._][-a-zA-Z$._0-9]*|\"[^\"]*?\")" is(name.variable)
+    r"!\d+" is(name.variable.anonymous)
+    r"c?\"[^\"]*?\"" is(literal.string)
+    r"0[xX][a-fA-F0-9]+" is(literal.number)
+    r"-?\d+(?:[.]\d+)?(?:[eE][-+]?\d+(?:[.]\d+)?)?" is(literal.number)
+    r"[=<>{}\[\]()*.,!]|x\b" is(punctuation)
+
+  lex(whitespace):
+    r"(\n|\s)+" is(text)
+    r";.*?\n" is(comment)
+
+  lex(keyword):
+    r"(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|ccc|fastcc|coldcc|x86_stdcallcc|x86_fastcallcc|arm_apcscc|arm_aapcscc|arm_aapcs_vfpcc|cc|c|signext|zeroext|inreg|sret|nounwind|noreturn|noalias|nocapture|byval|nest|readnone|readonly|inlinehint|noinline|alwaysinline|optsize|ssp|sspreq|noredzone|noimplicitfloat|naked|type|opaque|eq|ne|slt|sgt|sle|sge|ult|ugt|ule|uge|oeq|one|olt|ogt|ole|oge|ord|uno|ueq|une|x|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|fptouifptosi|inttoptr|ptrtoint|bitcast|select|va_arg|ret|br|switch|invoke|unwind|unreachable|malloc|alloca|free|load|store|getelementptr|extractelement|insertelement|shufflevector|getresult|extractvalue|insertvalue)\b" is(keyword)
+    r"void|float|double|x86_fp80|fp128|ppc_fp128|label|metadata" is(keyword.type)
+    r"i[1-9]\d*" is(keyword)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,133 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Logtalk"
+  aliases: ["logtalk"]
+  extensions: [".lgt"]
+  mimetypes: ["text/x-logtalk"]
+  start: .root
+  flags: 0
+
+  lex(quoted-atom):
+    r"''" is(literal.string)
+    r"'" is(literal.string) -> pop
+    r"\\([\\abfnrtv\"\']|(x[a-fA-F0-9]+|[0-7]+)\\)" is(literal.string.escape)
+    r"[^\\'\n]+" is(literal.string)
+    r"\\" is(literal.string)
+
+  lex(root):
+    r"^\s*:-\s" is(punctuation) -> go-to(directive)
+    r"%.*?\n" is(comment)
+    r"/\*(.|\n)*?\*/" is(comment)
+    r"\n" is(text)
+    r"\s+" is(text)
+    r"0'." is(literal.number)
+    r"0b[01]+" is(literal.number)
+    r"0o[0-7]+" is(literal.number)
+    r"0x[0-9a-fA-F]+" is(literal.number)
+    r"\d+\.?\d*((e|E)(\+|-)?\d+)?" is(literal.number)
+    r"([A-Z_][a-zA-Z0-9_]*)" is(name.variable)
+    r"(after|before)(?=[(])" is(keyword)
+    r"(parameter|this|se(lf|nder))(?=[(])" is(keyword)
+    r"(current_predicate|predicate_property)(?=[(])" is(keyword)
+    r"(expand_(goal|term)|(goal|term)_expansion|phrase)(?=[(])" is(keyword)
+    r"(abolish|c(reate|urrent))_(object|protocol|category)(?=[(])" is(keyword)
+    r"(object|protocol|category)_property(?=[(])" is(keyword)
+    r"co(mplements_object|nforms_to_protocol)(?=[(])" is(keyword)
+    r"extends_(object|protocol|category)(?=[(])" is(keyword)
+    r"imp(lements_protocol|orts_category)(?=[(])" is(keyword)
+    r"(instantiat|specializ)es_class(?=[(])" is(keyword)
+    r"(current_event|(abolish|define)_events)(?=[(])" is(keyword)
+    r"(current|set)_logtalk_flag(?=[(])" is(keyword)
+    r"logtalk_(compile|l(ibrary_path|oad_context|oad))(?=[(])" is(keyword)
+    r"(clause|retract(all)?)(?=[(])" is(keyword)
+    r"a(bolish|ssert(a|z))(?=[(])" is(keyword)
+    r"(ca(ll|tch)|throw)(?=[(])" is(keyword)
+    r"(fail|true)\b" is(keyword)
+    r"((bag|set)of|f(ind|or)all)(?=[(])" is(keyword)
+    r"threaded(_(call|once|ignore|exit|peek|wait|notify))?(?=[(])" is(keyword)
+    r"unify_with_occurs_check(?=[(])" is(keyword)
+    r"(functor|arg|copy_term|numbervars)(?=[(])" is(keyword)
+    r"(rem|mod|abs|sign)(?=[(])" is(keyword)
+    r"float(_(integer|fractional)_part)?(?=[(])" is(keyword)
+    r"(floor|truncate|round|ceiling)(?=[(])" is(keyword)
+    r"(cos|atan|exp|log|s(in|qrt))(?=[(])" is(keyword)
+    r"(var|atom(ic)?|integer|float|c(allable|ompound)|n(onvar|umber)|ground)(?=[(])" is(keyword)
+    r"compare(?=[(])" is(keyword)
+    r"(curren|se)t_(in|out)put(?=[(])" is(keyword)
+    r"(open|close)(?=[(])" is(keyword)
+    r"flush_output(?=[(])" is(keyword)
+    r"(at_end_of_stream|flush_output)\b" is(keyword)
+    r"(stream_property|at_end_of_stream|set_stream_position)(?=[(])" is(keyword)
+    r"(nl|(get|peek|put)_(byte|c(har|ode)))(?=[(])" is(keyword)
+    r"\bnl\b" is(keyword)
+    r"read(_term)?(?=[(])" is(keyword)
+    r"write(q|_(canonical|term))?(?=[(])" is(keyword)
+    r"(current_)?op(?=[(])" is(keyword)
+    r"(current_)?char_conversion(?=[(])" is(keyword)
+    r"atom_(length|c(hars|o(ncat|des)))(?=[(])" is(keyword)
+    r"(char_code|sub_atom)(?=[(])" is(keyword)
+    r"number_c(har|ode)s(?=[(])" is(keyword)
+    r"(se|curren)t_prolog_flag(?=[(])" is(keyword)
+    r"\bhalt\b" is(keyword)
+    r"halt(?=[(])" is(keyword)
+    r"(::|:|\^\^)" is(operator)
+    r"[{}]" is(keyword)
+    r"\b(ignore|once)(?=[(])" is(keyword)
+    r"\brepeat\b" is(keyword)
+    r"(key)?sort(?=[(])" is(keyword)
+    r"(>>|<<|/\\|\\\\|\\)" is(operator)
+    r"\bis\b" is(keyword)
+    r"(=:=|=\\=|<|=<|>=|>)" is(operator)
+    r"=\.\." is(operator)
+    r"(=|\\=)" is(operator)
+    r"(==|\\==|@=<|@<|@>=|@>)" is(operator)
+    r"(//|[-+*/])" is(operator)
+    r"\b(e|pi|mod|rem)\b" is(operator)
+    r"\b\*\*\b" is(operator)
+    r"-->" is(operator)
+    r"([!;]|->)" is(operator)
+    r"\\+" is(operator)
+    r"[?@]" is(operator)
+    r"\^" is(operator)
+    r"\"(\\\\|\\\"|[^\"])*\"" is(literal.string)
+    r"[()\[\],.|]" is(text)
+    r"[a-z][a-zA-Z0-9_]*" is(text)
+    r"'" is(literal.string) -> go-to(quoted-atom)
+
+  lex(directive):
+    r"(el)?if(?=[(])" is(keyword) -> go-to(root)
+    r"(e(lse|ndif))[.]" is(keyword) -> go-to(root)
+    r"(category|object|protocol)(?=[(])" is(keyword) -> go-to(entityrelations)
+    r"(end_(category|object|protocol))[.]" is(keyword) -> go-to(root)
+    r"(public|protected|private)(?=[(])" is(keyword) -> go-to(root)
+    r"e(n(coding|sure_loaded)|xport)(?=[(])" is(keyword) -> go-to(root)
+    r"in(fo|itialization)(?=[(])" is(keyword) -> go-to(root)
+    r"(dynamic|synchronized|threaded)[.]" is(keyword) -> go-to(root)
+    r"(alias|d(ynamic|iscontiguous)|m(eta_predicate|ode|ultifile)|s(et_(logtalk|prolog)_flag|ynchronized))(?=[(])" is(keyword) -> go-to(root)
+    r"op(?=[(])" is(keyword) -> go-to(root)
+    r"(c(alls|oinductive)|reexport|use(s|_module))(?=[(])" is(keyword) -> go-to(root)
+    r"[a-z][a-zA-Z0-9_]*(?=[(])" is(text) -> go-to(root)
+    r"[a-z][a-zA-Z0-9_]*[.]" is(text) -> go-to(root)
+
+  lex(entityrelations):
+    r"(complements|extends|i(nstantiates|mp(lements|orts))|specializes)(?=[(])" is(keyword)
+    r"0'." is(literal.number)
+    r"0b[01]+" is(literal.number)
+    r"0o[0-7]+" is(literal.number)
+    r"0x[0-9a-fA-F]+" is(literal.number)
+    r"\d+\.?\d*((e|E)(\+|-)?\d+)?" is(literal.number)
+    r"([A-Z_][a-zA-Z0-9_]*)" is(name.variable)
+    r"[a-z][a-zA-Z0-9_]*" is(text)
+    r"'" is(literal.string) -> go-to(quoted-atom)
+    r"\"(\\\\|\\\"|[^\"])*\"" is(literal.string)
+    r"([)]\.)" is(text) -> go-to(root)
+    r"(::)" is(operator)
+    r"[()\[\],.|]" is(text)
+    r"%.*?\n" is(comment)
+    r"/\*(.|\n)*?\*/" is(comment)
+    r"\n" is(text)
+    r"\s+" is(text)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,56 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Lua"
+  aliases: ["lua"]
+  extensions: [".lua", ".wlua"]
+  mimetypes: ["text/x-lua", "application/x-lua"]
+  start: .root
+  flags: 0
+
+  lex(string):
+    r"." is(literal.string)
+
+  lex(dqs):
+    r"\"" is(literal.string) -> pop
+    any-of(string)
+
+  lex(sqs):
+    r"'" is(literal.string) -> pop
+    any-of(string)
+
+  lex(funcname):
+    r"\s+" is(text)
+    r"(?:([A-Za-z_][A-Za-z0-9_]*)(\.))?([A-Za-z_][A-Za-z0-9_]*)" is(by-groups(name.class, punctuation, name.function)) -> pop
+    r"\(" is(punctuation) -> pop
+
+  lex(stringescape):
+    r"\\([abfnrtv\\\"']|\d{1,3})" is(literal.string.escape)
+
+  lex(base):
+    r"(?m)--\[(=*)\[.*?\]\1\]" is(comment.multiline)
+    r"--.*$" is(comment.single)
+    r"(?i)(\d*\.\d+|\d+\.\d*)(e[+-]?\d+)?" is(literal.number.float)
+    r"(?i)\d+e[+-]?\d+" is(literal.number.float)
+    r"(?i)0x[0-9a-f]*" is(literal.number.hex)
+    r"\d+" is(literal.number.integer)
+    r"\n" is(text)
+    r"[^\S\n]" is(text)
+    r"(?m)\[(=*)\[.*?\]\1\]" is(literal.string)
+    r"(==|\126=|<=|>=|\.\.\.|\.\.|[=+\-*/%^<>\#])" is(operator)
+    r"[\[\]\{\}\(\)\.,:;]" is(punctuation)
+    r"(and|or|not)\b" is(operator.word)
+    r"(break|do|else|elseif|end|for|if|in|repeat|return|then|until|while)\b" is(keyword)
+    r"(local)\b" is(keyword.declaration)
+    r"(true|false|nil)\b" is(keyword.constant)
+    r"(function)\b" is(keyword) -> go-to(funcname)
+    r"[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?" is(name)
+    r"'" is(literal.string.single) -> combined(stringescape, sqs)
+    r"\"" is(literal.string.double) -> combined(stringescape, dqs)
+
+  lex(root):
+    r"\#!(.*?)$" is(comment.preproc)
+    r"" is(text) -> go-to(base)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,32 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "MAQL"
+  aliases: ["maql"]
+  extensions: [".maql"]
+  mimetypes: ["text/x-gooddata-maql", "application/x-gooddata-maql"]
+  start: .root
+  flags: Regexp IGNORECASE
+
+  lex(root):
+    r"IDENTIFIER\b" is(name.builtin)
+    r"\{[^}]+\}" is(name.variable)
+    r"[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]{1,3})?" is(literal.number)
+    r"\"" is(literal.string) -> go-to(string-literal)
+    r"\<\>|\!\=" is(operator)
+    r"\=|\>\=|\>|\<\=|\<" is(operator)
+    r"\:\=" is(operator)
+    r"\[[^]]+\]" is(name.variable.class)
+    r"(DIMENSIONS?|BOTTOM|METRIC|COUNT|OTHER|FACT|WITH|TOP|OR|ATTRIBUTE|CREATE|PARENT|FALSE|ROWS?|FROM|ALL|AS|PF|COLUMNS?|DEFINE|REPORT|LIMIT|TABLE|LIKE|AND|BY|BETWEEN|EXCEPT|SELECT|MATCH|WHERE|TRUE|FOR|IN|WITHOUT|FILTER|ALIAS|ORDER|FACT|WHEN|NOT|ON|KEYS|KEY|FULLSET|PRIMARY|LABELS|LABEL|VISUAL|TITLE|DESCRIPTION|FOLDER|ALTER|DROP|ADD|DATASET|DATATYPE|INT|BIGINT|DOUBLE|DATE|VARCHAR|DECIMAL|SYNCHRONIZE|TYPE|DEFAULT|ORDER|ASC|DESC|HYPERLINK|INCLUDE|TEMPLATE|MODIFY)\b" is(keyword)
+    r"[a-zA-Z]\w*\b" is(name.function)
+    r"\#.*" is(comment.single)
+    r"[,;\(\)]" is(punctuation)
+    r"\s+" is(text)
+
+  lex(string-literal):
+    r"\\[tnrfbae\"\\]" is(literal.string.escape)
+    r"\"" is(literal.string) -> pop
+    r"[^\\\"]+" is(literal.string)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,43 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Matlab"
+  aliases: ["matlab"]
+  extensions: [".m"]
+  mimetypes: ["text/matlab"]
+  start: .root
+  flags: 0
+
+  lex(deffunc):
+    r"(\s*)(?:(.+)(\s*)(=)(\s*))?(.+)(\()(.*)(\))(\s*)" is(by-groups(text.whitespace, text, text.whitespace, punctuation, text.whitespace, name.function, punctuation, text, punctuation, text.whitespace)) -> pop
+
+  lex(blockcomment):
+    r"^\s*%\}" is(comment.multiline) -> pop
+    r"^.*\n" is(comment.multiline)
+    r"." is(comment.multiline)
+
+  lex(root):
+    r"^!.*" is(literal.string.other)
+    r"%\{\s*\n" is(comment.multiline) -> go-to(blockcomment)
+    r"%.*$" is(comment)
+    r"^\s*function" is(keyword) -> go-to(deffunc)
+    r"(break|case|catch|classdef|continue|else|elseif|end|enumerated|events|for|function|global|if|methods|otherwise|parfor|persistent|properties|return|spmd|switch|try|while)\b" is(keyword)
+    r"(sin|sind|sinh|asin|asind|asinh|cos|cosd|cosh|acos|acosd|acosh|tan|tand|tanh|atan|atand|atan2|atanh|sec|secd|sech|asec|asecd|asech|csc|cscd|csch|acsc|acscd|acsch|cot|cotd|coth|acot|acotd|acoth|hypot|exp|expm1|log|log1p|log10|log2|pow2|realpow|reallog|realsqrt|sqrt|nthroot|nextpow2|abs|angle|complex|conj|imag|real|unwrap|isreal|cplxpair|fix|floor|ceil|round|mod|rem|sign|airy|besselj|bessely|besselh|besseli|besselk|beta|betainc|betaln|ellipj|ellipke|erf|erfc|erfcx|erfinv|expint|gamma|gammainc|gammaln|psi|legendre|cross|dot|factor|isprime|primes|gcd|lcm|rat|rats|perms|nchoosek|factorial|cart2sph|cart2pol|pol2cart|sph2cart|hsv2rgb|rgb2hsv|zeros|ones|eye|repmat|rand|randn|linspace|logspace|freqspace|meshgrid|accumarray|size|length|ndims|numel|disp|isempty|isequal|isequalwithequalnans|cat|reshape|diag|blkdiag|tril|triu|fliplr|flipud|flipdim|rot90|find|end|sub2ind|ind2sub|bsxfun|ndgrid|permute|ipermute|shiftdim|circshift|squeeze|isscalar|isvector|ans|eps|realmax|realmin|pi|i|inf|nan|isnan|isinf|isfinite|j|why|compan|gallery|hadamard|hankel|hilb|invhilb|magic|pascal|rosser|toeplitz|vander|wilkinson)\b" is(name.builtin)
+    r"\.\.\..*$" is(comment)
+    r"-|==|\126=|<|>|<=|>=|&&|&|\126|\|\|?" is(operator)
+    r"\.\*|\*|\+|\.\^|\.\\|\.\/|\/|\\" is(operator)
+    r"\[|\]|\(|\)|\{|\}|:|@|\.|," is(punctuation)
+    r"=|:|;" is(punctuation)
+    r"(?<=[\w\)\]])\'" is(operator)
+    r"(\d+\.\d*|\d*\.\d+)([eEf][+-]?[0-9]+)?" is(literal.number.float)
+    r"\d+[eEf][+-]?[0-9]+" is(literal.number.float)
+    r"\d+" is(literal.number.integer)
+    r"(?<![\w\)\]])\'" is(literal.string) -> go-to(string)
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name)
+    r"." is(text)
+
+  lex(string):
+    r"[^\']*\'" is(literal.string) -> pop
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,37 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "MiniD"
+  aliases: ["minid"]
+  extensions: [".md"]
+  mimetypes: ["text/x-minidsrc"]
+  start: .root
+  flags: 0
+
+  lex(nestedcomment):
+    r"[^*/]+" is(comment.multiline)
+    r"/\*" is(comment.multiline) -> push
+    r"\*/" is(comment.multiline) -> pop
+    r"[*/]" is(comment.multiline)
+
+  lex(root):
+    r"\n" is(text)
+    r"\s+" is(text)
+    r"//(.*?)\n" is(comment.single)
+    r"/\*" is(comment.multiline) -> go-to(nestedcomment)
+    r"(as|assert|break|case|catch|class|continue|default|do|else|finally|for|foreach|function|global|namespace|if|import|in|is|local|module|return|scope|super|switch|this|throw|try|vararg|while|with|yield)\b" is(keyword)
+    r"(false|true|null)\b" is(keyword.constant)
+    r"([0-9][0-9_]*)(?=[.eE])(\.[0-9][0-9_]*)?([eE][+\-]?[0-9_]+)?" is(literal.number.float)
+    r"0[bB][01][01_]*" is(literal.number)
+    r"0[xX][0-9a-fA-F][0-9a-fA-F_]*" is(literal.number.hex)
+    r"([0-9][0-9_]*)(?![.eE])" is(literal.number.integer)
+    r"'(\\['\"\\nrt]|\\x[0-9a-fA-F]{2}|\\[0-9]{1,3}|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|.)'" is(literal.string.char)
+    r"@\"(\"\"|[^\"])*\"" is(literal.string)
+    r"@`(``|[^`])*`" is(literal.string)
+    r"@'(''|[^'])*'" is(literal.string)
+    r"\"(\\\\|\\\"|[^\"])*\"" is(literal.string)
+    r"(\126=|\^=|%=|\*=|==|!=|>>>=|>>>|>>=|>>|>=|<=>|\?=|-\>|<<=|<<|<=|\+\+|\+=|--|-=|\|\||\|=|&&|&=|\.\.|/=)|[-/.&$@|\+<>!()\[\]{}?,;:=*%^\126\#\\]" is(punctuation)
+    r"[a-zA-Z_]\w*" is(name)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,63 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Modula-2"
+  aliases: ["modula2", "m2"]
+  extensions: [".def", ".mod"]
+  mimetypes: ["text/x-modula2"]
+  start: .root
+  flags: Regexp MULTILINE
+
+  lex(punctuation):
+    r"[\(\)\[\]{},.:;|]" is(punctuation)
+
+  lex(pragmas):
+    r"\(\*\$(.*?)\*\)" is(comment.preproc)
+    r"<\*(.*?)\*>" is(comment.preproc)
+
+  lex(whitespace):
+    r"\n+" is(text)
+    r"\s+" is(text)
+
+  lex(numliterals):
+    r"[01]+B" is(literal.number.binary)
+    r"[0-7]+B" is(literal.number.oct)
+    r"[0-7]+C" is(literal.number.oct)
+    r"[0-9A-F]+C" is(literal.number.hex)
+    r"[0-9A-F]+H" is(literal.number.hex)
+    r"[0-9]+\.[0-9]+E[+-][0-9]+" is(literal.number.float)
+    r"[0-9]+\.[0-9]+" is(literal.number.float)
+    r"[0-9]+" is(literal.number.integer)
+
+  lex(operators):
+    r"[*/+=\#\126&<>\^-]" is(operator)
+    r":=" is(operator)
+    r"@" is(operator)
+    r"\.\." is(operator)
+    r"`" is(operator)
+    r"::" is(operator)
+
+  lex(identifiers):
+    r"([a-zA-Z_\$][a-zA-Z0-9_\$]*)" is(name)
+
+  lex(root):
+    any-of(whitespace)
+    any-of(comments)
+    any-of(pragmas)
+    any-of(identifiers)
+    any-of(numliterals)
+    any-of(strings)
+    any-of(operators)
+    any-of(punctuation)
+
+  lex(strings):
+    r"'(\\\\|\\'|[^'])*'" is(literal.string)
+    r"\"(\\\\|\\\"|[^\"])*\"" is(literal.string)
+
+  lex(comments):
+    r"//.*?\n" is(comment.single)
+    r"/\*(.*?)\*/" is(comment.multiline)
+    r"\(\*([^\$].*?)\*\)" is(comment.multiline)
+
+const-set(.Lexer, lexer)