broomhlda 0.1.0

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

@@ -0,0 +1,116 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "NumPy"
+  aliases: ["numpy"]
+  extensions: []
+  mimetypes: []
+  start: .root
+  flags: 0
+
+  lex(tsqs):
+    r"'''" is(literal.string) -> pop
+    any-of(strings)
+    any-of(nl)
+
+  lex(builtins):
+    r"(?<!\.)(__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)\b" is(name.builtin)
+    r"(?<!\.)(self|None|Ellipsis|NotImplemented|False|True)\b" is(name.builtin.pseudo)
+    r"(?<!\.)(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)\b" is(name.exception)
+
+  lex(name):
+    r"@[a-zA-Z0-9_.]+" is(name.decorator)
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name)
+
+  lex(dqs):
+    r"\"" is(literal.string) -> pop
+    r"\\\\|\\\"|\\\n" is(literal.string.escape)
+    any-of(strings)
+
+  lex(sqs):
+    r"'" is(literal.string) -> pop
+    r"\\\\|\\'|\\\n" is(literal.string.escape)
+    any-of(strings)
+
+  lex(tdqs):
+    r"\"\"\"" is(literal.string) -> pop
+    any-of(strings)
+    any-of(nl)
+
+  lex(backtick):
+    r"`.*?`" is(literal.string.backtick)
+
+  lex(funcname):
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name.function) -> pop
+
+  lex(classname):
+    r"[a-zA-Z_][a-zA-Z0-9_]*" is(name.class) -> pop
+
+  lex(stringescape):
+    r"\\([\\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})" is(literal.string.escape)
+
+  lex(numbers):
+    r"(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?j?" is(literal.number.float)
+    r"\d+[eE][+-]?[0-9]+j?" is(literal.number.float)
+    r"0[0-7]+j?" 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+j?" is(literal.number.integer)
+
+  lex(keywords):
+    r"(assert|break|continue|del|elif|else|except|exec|finally|for|global|if|lambda|pass|print|raise|return|try|while|yield(\s+from)?|as|with)\b" is(keyword)
+
+  lex(import):
+    r"(?:[ \t]|\\\n)+" is(text)
+    r"as\b" is(keyword.namespace)
+    r"," is(operator)
+    r"[a-zA-Z_][a-zA-Z0-9_.]*" is(name.namespace)
+    r"" is(text) -> pop
+
+  lex(nl):
+    r"\n" is(literal.string)
+
+  lex(root):
+    r"\n" is(text)
+    r"^(\s*)([rRuU]{,2}\"\"\"(?:.|\n)*?\"\"\")" is(by-groups(text, literal.string.doc))
+    r"^(\s*)([rRuU]{,2}'''(?:.|\n)*?''')" is(by-groups(text, literal.string.doc))
+    r"[^\S\n]+" is(text)
+    r"\#.*$" is(comment)
+    r"[\]{}:(),;\[]" is(punctuation)
+    r"\\\n" is(text)
+    r"\\" is(text)
+    r"(in|is|and|or|not)\b" is(operator.word)
+    r"!=|==|<<|>>|[-\126+/*%=<>&^|.]" is(operator)
+    any-of(keywords)
+    r"(def)((?:\s|\\\s)+)" is(by-groups(keyword, text)) -> go-to(funcname)
+    r"(class)((?:\s|\\\s)+)" is(by-groups(keyword, text)) -> go-to(classname)
+    r"(from)((?:\s|\\\s)+)" is(by-groups(keyword.namespace, text)) -> go-to(fromimport)
+    r"(import)((?:\s|\\\s)+)" is(by-groups(keyword.namespace, text)) -> go-to(import)
+    any-of(builtins)
+    any-of(backtick)
+    r"(?:[rR]|[uU][rR]|[rR][uU])\"\"\"" is(literal.string) -> go-to(tdqs)
+    r"(?:[rR]|[uU][rR]|[rR][uU])'''" is(literal.string) -> go-to(tsqs)
+    r"(?:[rR]|[uU][rR]|[rR][uU])\"" is(literal.string) -> go-to(dqs)
+    r"(?:[rR]|[uU][rR]|[rR][uU])'" is(literal.string) -> go-to(sqs)
+    r"[uU]?\"\"\"" is(literal.string) -> combined(stringescape, tdqs)
+    r"[uU]?'''" is(literal.string) -> combined(stringescape, tsqs)
+    r"[uU]?\"" is(literal.string) -> combined(stringescape, dqs)
+    r"[uU]?'" is(literal.string) -> combined(stringescape, sqs)
+    any-of(name)
+    any-of(numbers)
+
+  lex(strings):
+    r"%(\([a-zA-Z0-9_]+\))?[-\#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[diouxXeEfFgGcrs%]" is(literal.string.interpol)
+    r"[^\\\'\"%\n]+" is(literal.string)
+    r"[\'\"\\]" is(literal.string)
+    r"%" is(literal.string)
+
+  lex(fromimport):
+    r"(?:[ \t]|\\\n)+" is(text)
+    r"import\b" is(keyword.namespace) -> pop
+    r"None\b" is(name.builtin.pseudo) -> pop
+    r"[a-zA-Z_.][a-zA-Z0-9_.]*" is(name.namespace)
+    r"" is(text) -> pop
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,120 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Objective-J"
+  aliases: ["objective-j", "objectivej", "obj-j", "objj"]
+  extensions: [".j"]
+  mimetypes: ["text/x-objective-j"]
+  start: .root
+  flags: Regexp MULTILINE
+
+  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"\"(\\\\|\\\"|[^\"])*\"" is(literal.string.double)
+    r"'(\\\\|\\'|[^'])*'" is(literal.string.single)
+    r"(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?" is(literal.number.float)
+    r"(\d+\.\d*|\.\d+|\d+[fF])[fF]?" is(literal.number.float)
+    r"0x[0-9a-fA-F]+[Ll]?" is(literal.number.hex)
+    r"0[0-7]+[Ll]?" is(literal.number.oct)
+    r"\d+[Ll]?" is(literal.number.integer)
+    r"^(?=\s|/|<!--)" is(text) -> go-to(slashstartsregex)
+    r"\+\+|--|\126|&&|\?|:|\|\||\\(?=\n)|(<<|>>>?|==?|!=?|[-<>+*%&\|\^/])=?" is(operator) -> go-to(slashstartsregex)
+    r"[{(\[;,]" is(punctuation) -> go-to(slashstartsregex)
+    r"[})\].]" is(punctuation)
+    r"(for|in|while|do|break|return|continue|switch|case|default|if|else|throw|try|catch|finally|new|delete|typeof|instanceof|void|prototype|__proto__)\b" is(keyword) -> go-to(slashstartsregex)
+    r"(var|with|function)\b" is(keyword.declaration) -> go-to(slashstartsregex)
+    r"(@selector|@private|@protected|@public|@encode|@synchronized|@try|@throw|@catch|@finally|@end|@property|@synthesize|@dynamic|@for|@accessors|new)\b" is(keyword)
+    r"(int|long|float|short|double|char|unsigned|signed|void|id|BOOL|bool|boolean|IBOutlet|IBAction|SEL|@outlet|@action)\b" is(keyword.type)
+    r"(self|super)\b" is(name.builtin)
+    r"(TRUE|YES|FALSE|NO|Nil|nil|NULL)\b" is(keyword.constant)
+    r"(true|false|null|NaN|Infinity|undefined)\b" is(keyword.constant)
+    r"(ABS|ASIN|ACOS|ATAN|ATAN2|SIN|COS|TAN|EXP|POW|CEIL|FLOOR|ROUND|MIN|MAX|RAND|SQRT|E|LN2|LN10|LOG2E|LOG10E|PI|PI2|PI_2|SQRT1_2|SQRT2)\b" is(keyword.constant)
+    r"(Array|Boolean|Date|Error|Function|Math|netscape|Number|Object|Packages|RegExp|String|sun|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|Error|eval|isFinite|isNaN|parseFloat|parseInt|document|this|window)\b" is(name.builtin)
+    r"([$a-zA-Z_][a-zA-Z0-9_]*)((?:\s|//.*?\n|/[*].*?[*]/)*)(?=\()" is(by-groups(name.function, using(self class)))
+    r"[$a-zA-Z_][a-zA-Z0-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)
+
+  lex(function-signature):
+    any-of(whitespace)
+    r"(\((?:\s|//.*?\n|/[*].*?[*]/)*)([a-zA-Z_][a-zA-Z0-9_]+)((?:\s|//.*?\n|/[*].*?[*]/)*\)(?:\s|//.*?\n|/[*].*?[*]/)*)([$a-zA-Z_][a-zA-Z0-9_]+(?:\s|//.*?\n|/[*].*?[*]/)*:)" is(by-groups(using(self class), keyword.type, using(self class), name.function)) -> go-to(function-parameters)
+    r"(\((?:\s|//.*?\n|/[*].*?[*]/)*)([a-zA-Z_][a-zA-Z0-9_]+)((?:\s|//.*?\n|/[*].*?[*]/)*\)(?:\s|//.*?\n|/[*].*?[*]/)*)([$a-zA-Z_][a-zA-Z0-9_]+)" is(by-groups(using(self class), keyword.type, using(self class), name.function)) -> pop
+    r"([$a-zA-Z_][a-zA-Z0-9_]+(?:\s|//.*?\n|/[*].*?[*]/)*:)" is(by-groups(name.function)) -> go-to(function-parameters)
+    r"([$a-zA-Z_][a-zA-Z0-9_]+)" is(by-groups(name.function)) -> pop
+    r"" is(text) -> pop
+
+  lex(classname):
+    r"([a-zA-Z_][a-zA-Z0-9_]*)((?:\s|//.*?\n|/[*].*?[*]/)*:(?:\s|//.*?\n|/[*].*?[*]/)*)([a-zA-Z_][a-zA-Z0-9_]*)?" is(by-groups(name.class, using(self class), name.class)) -> pop
+    r"([a-zA-Z_][a-zA-Z0-9_]*)((?:\s|//.*?\n|/[*].*?[*]/)*\()([a-zA-Z_][a-zA-Z0-9_]*)(\))" is(by-groups(name.class, using(self class), name.label, text)) -> pop
+    r"([a-zA-Z_][a-zA-Z0-9_]*)" is(name.class) -> pop
+
+  lex(forward-classname):
+    r"([a-zA-Z_][a-zA-Z0-9_]*)(\s*,\s*)" is(by-groups(name.class, text)) -> push
+    r"([a-zA-Z_][a-zA-Z0-9_]*)(\s*;?)" is(by-groups(name.class, text)) -> pop
+
+  lex(badregex):
+    r"\n" is(text) -> pop
+
+  lex(function-parameters):
+    any-of(whitespace)
+    r"(\((?:\s|//.*?\n|/[*].*?[*]/)*)([^\)]+)((?:\s|//.*?\n|/[*].*?[*]/)*\)(?:\s|//.*?\n|/[*].*?[*]/)*)([$a-zA-Z_][a-zA-Z0-9_]+)" is(by-groups(using(self class), keyword.type, using(self class), text))
+    r"([$a-zA-Z_][a-zA-Z0-9_]+(?:\s|//.*?\n|/[*].*?[*]/)*:)" is(name.function)
+    r"(:)" is(name.function)
+    r"(,(?:\s|//.*?\n|/[*].*?[*]/)*\.\.\.)" is(using(self class))
+    r"([$a-zA-Z_][a-zA-Z0-9_]+)" is(text)
+
+  lex(if0):
+    r"^\s*\#if.*?(?<!\\)\n" is(comment.preproc) -> push
+    r"^\s*\#endif.*?(?<!\\)\n" is(comment.preproc) -> pop
+    r".*?\n" is(comment)
+
+  lex(whitespace):
+    r"(@import)(\s+)(\"(?:\\\\|\\\"|[^\"])*\")" is(by-groups(comment.preproc, text, literal.string.double))
+    r"(@import)(\s+)(<(?:\\\\|\\>|[^>])*>)" is(by-groups(comment.preproc, text, literal.string.double))
+    r"(\#(?:include|import))(\s+)(\"(?:\\\\|\\\"|[^\"])*\")" is(by-groups(comment.preproc, text, literal.string.double))
+    r"(\#(?:include|import))(\s+)(<(?:\\\\|\\>|[^>])*>)" is(by-groups(comment.preproc, text, literal.string.double))
+    r"\#if\s+0" is(comment.preproc) -> go-to(if0)
+    r"\#" is(comment.preproc) -> go-to(macro)
+    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)
+    r"<!--" is(comment)
+
+  lex(root):
+    any-of(whitespace)
+    r"^((?:\s|//.*?\n|/[*].*?[*]/)*[\+-](?:\s|//.*?\n|/[*].*?[*]/)*)([\(a-zA-Z_].*?[^\(])((?:\s|//.*?\n|/[*].*?[*]/)*{)" is(by-groups(using(self class), using(self class), using(self class)))
+    r"(@interface|@implementation)(\s+)" is(by-groups(keyword, text)) -> go-to(classname)
+    r"(@class|@protocol)(\s*)" is(by-groups(keyword, text)) -> go-to(forward-classname)
+    r"(\s*)(@end)(\s*)" is(by-groups(text, keyword, text))
+    any-of(statements)
+    r"[{\(\)}]" is(punctuation)
+    r";" is(punctuation)
+
+  lex(slashstartsregex):
+    any-of(whitespace)
+    r"/(\\.|[^\[/\\\n]|\[(\\.|[^\]\\\n])*])+/([gim]+\b|\B)" is(literal.string.regex) -> pop
+    r"(?=/)" is(text) -> do-all(pop, go-to(badregex))
+    r"" is(text) -> pop
+
+  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(expression):
+    r"([$a-zA-Z_][a-zA-Z0-9_]*)(\()" is(by-groups(name.function, punctuation))
+    r"(\))" is(punctuation) -> pop
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,59 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "OCaml"
+  aliases: ["ocaml"]
+  extensions: [".ml", ".mli", ".mll", ".mly"]
+  mimetypes: ["text/x-ocaml"]
+  start: .root
+  flags: 0
+
+  lex(comment):
+    r"[^(*)]+" is(comment)
+    r"\(\*" is(comment) -> push
+    r"\*\)" is(comment) -> pop
+    r"[(*)]" is(comment)
+
+  lex(root):
+    r"\s+" is(text)
+    r"false|true|\(\)|\[\]" is(name.builtin.pseudo)
+    r"\b([A-Z][A-Za-z0-9_\']*)(?=\s*\.)" is(name.namespace) -> go-to(dotted)
+    r"\b([A-Z][A-Za-z0-9_\']*)" is(name.class)
+    r"\(\*(?![)])" is(comment) -> go-to(comment)
+    r"\b(as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|false|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|match|method|module|mutable|new|object|of|open|private|raise|rec|sig|struct|then|to|true|try|type|value|val|virtual|when|while|with)\b" is(keyword)
+    r"(\126|}|\|]|\||{<|{|`|_|]|\[\||\[>|\[<|\[|\?\?|\?|>}|>]|>|=|<-|<|;;|;|:>|:=|::|:|\.\.|\.|->|-\.|-|,|\+|\*|\)|\(|&&|&|\#|!=)" is(operator)
+    r"([=<>@^|&+\*/$%-]|[!?\126])?[!$%&*+\./:<=>?@^|\126-]" is(operator)
+    r"\b(and|asr|land|lor|lsl|lxor|mod|or)\b" is(operator.word)
+    r"\b(unit|int|float|bool|string|char|list|array)\b" is(keyword.type)
+    r"[^\W\d][\w']*" is(name)
+    r"-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)" is(literal.number.float)
+    r"0[xX][\da-fA-F][\da-fA-F_]*" is(literal.number.hex)
+    r"0[oO][0-7][0-7_]*" is(literal.number.oct)
+    r"0[bB][01][01_]*" is(literal.number.binary)
+    r"\d[\d_]*" is(literal.number.integer)
+    r"'(?:(\\[\\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))'" is(literal.string.char)
+    r"'.'" is(literal.string.char)
+    r"'" is(keyword)
+    r"\"" is(literal.string.double) -> go-to(string)
+    r"[\126?][a-z][\w\']*:" is(name.variable)
+
+  lex(string):
+    r"[^\\\"]+" is(literal.string.double)
+    any-of(escape-sequence)
+    r"\\\n" is(literal.string.double)
+    r"\"" is(literal.string.double) -> pop
+
+  lex(escape-sequence):
+    r"\\[\\\\"\'ntbr]" is(literal.string.escape)
+    r"\\[0-9]{3}" is(literal.string.escape)
+    r"\\x[0-9a-fA-F]{2}" is(literal.string.escape)
+
+  lex(dotted):
+    r"\s+" is(text)
+    r"\." is(punctuation)
+    r"[A-Z][A-Za-z0-9_\']*(?=\s*\.)" is(name.namespace)
+    r"[A-Z][A-Za-z0-9_\']*" is(name.class) -> pop
+    r"[a-z_][A-Za-z0-9_\']*" is(name) -> pop
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,39 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Octave"
+  aliases: ["octave"]
+  extensions: [".m"]
+  mimetypes: ["text/octave"]
+  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(root):
+    r"[%\#].*$" is(comment)
+    r"^\s*function" is(keyword) -> go-to(deffunc)
+    r"(__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)\b" is(keyword)
+    r"(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)\b" is(name.builtin)
+    r"(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)\b" is(name.constant)
+    r"-=|!=|!|/=|--" is(operator)
+    r"-|==|\126=|<|>|<=|>=|&&|&|\126|\|\|?" is(operator)
+    r"\*=|\+=|\^=|\/=|\\=|\*\*|\+\+|\.\*\*" is(operator)
+    r"\.\*|\*|\+|\.\^|\.\\|\.\/|\/|\\" is(operator)
+    r"\[|\]|\(|\)|\{|\}|:|@|\.|," is(punctuation)
+    r"=|:|;" is(punctuation)
+    r"\"[^\"]*\"" is(literal.string)
+    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(operator)
+    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/ooc.ay

@@ -0,0 +1,45 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Ooc"
+  aliases: ["ooc"]
+  extensions: [".ooc"]
+  mimetypes: ["text/x-ooc"]
+  start: .root
+  flags: 0
+
+  lex(include):
+    r"[\w/]+" is(name)
+    r"," is(punctuation)
+    r"[ \t]" is(text)
+    r"[;\n]" is(text) -> pop
+
+  lex(root):
+    r"\b(class|interface|implement|abstract|extends|from|this|super|new|const|final|static|import|use|extern|inline|proto|break|continue|fallthrough|operator|if|else|for|while|do|switch|case|as|in|version|return|true|false|null)\b" is(keyword)
+    r"include\b" is(keyword) -> go-to(include)
+    r"(cover)([ \t]+)(from)([ \t]+)([a-zA-Z0-9_]+[*@]?)" is(by-groups(keyword, text, keyword, text, name.class))
+    r"(func)((?:[ \t]|\\\n)+)(\126[a-z_][a-zA-Z0-9_]*)" is(by-groups(keyword, text, name.function))
+    r"\bfunc\b" is(keyword)
+    r"//.*" is(comment)
+    r"(?m)/\*.*?\*/" is(comment.multiline)
+    r"(==?|\+=?|-[=>]?|\*=?|/=?|:=|!=?|%=?|\?|>{1,3}=?|<{1,3}=?|\.\.|&&?|\|\|?|\^=?)" is(operator)
+    r"(\.)([ \t]*)([a-z]\w*)" is(by-groups(operator, text, name.function))
+    r"[A-Z][A-Z0-9_]+" is(name.constant)
+    r"[A-Z][a-zA-Z0-9_]*([@*]|\[[ \t]*\])?" is(name.class)
+    r"([a-z][a-zA-Z0-9_]*(?:\126[a-z][a-zA-Z0-9_]*)?)((?:[ \t]|\\\n)*)(?=\()" is(by-groups(name.function, text))
+    r"[a-z][a-zA-Z0-9_]*" is(name.variable)
+    r"[:(){}\[\];,]" is(punctuation)
+    r"0x[0-9a-fA-F]+" is(literal.number.hex)
+    r"0c[0-9]+" is(literal.number.oct)
+    r"0b[01]+" is(literal.number.binary)
+    r"[0-9_]\.[0-9_]*(?!\.)" is(literal.number.float)
+    r"[0-9_]+" is(literal.number.decimal)
+    r"\"(?:\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\\"])*\"" is(literal.string.double)
+    r"'(?:\\.|\\[0-9]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'" is(literal.string.char)
+    r"@" is(punctuation)
+    r"\." is(punctuation)
+    r"\\[ \t\n]" is(text)
+    r"[ \t]+" is(text)
+
+const-set(.Lexer, lexer)

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

@@ -0,0 +1,153 @@
+use(require("atomy"))
+use(require("hl/define"))
+
+lexer = lexer:
+  name: "Opa"
+  aliases: ["opa"]
+  extensions: [".opa"]
+  mimetypes: ["text/x-opa"]
+  start: .root
+  flags: 0
+
+  lex(html-attr):
+    r"\s+" is(text)
+    r"[\w\-:]+=" is(literal.string.single) -> go-to(html-attr-value)
+    r"/>" is(literal.string.single) -> pop
+    r">" is(literal.string.single) -> do-all(pop, go-to(html-content))
+
+  lex(html-open-tag):
+    r"[\w\-:]+" is(literal.string.single) -> do-all(pop, go-to(html-attr))
+    r">" is(literal.string.single) -> do-all(pop, go-to(html-content))
+
+  lex(html-content):
+    r"<!--" is(comment) -> go-to(html-comment)
+    r"</" is(literal.string.single) -> do-all(pop, go-to(html-end-tag))
+    r"<" is(literal.string.single) -> go-to(html-open-tag)
+    r"{" is(operator) -> go-to(root)
+    r"[^<{]+" is(literal.string.single)
+
+  lex(string):
+    r"[^\\\"{]+" is(literal.string.double)
+    r"\"" is(literal.string.double) -> pop
+    r"{" is(operator) -> go-to(root)
+    any-of(escape-sequence)
+
+  lex(html-attr-value):
+    r"'" is(literal.string.single) -> do-all(pop, go-to(single-string))
+    r"\"" is(literal.string.single) -> do-all(pop, go-to(string))
+    r"\#(([a-zA-Z_]\w*)|(`[^`]*`))" is(literal.string.single) -> pop
+    r"\#(?={)" is(literal.string.single) -> do-all(pop, go-to(root))
+    r"[^\"\'{`=<>]+" is(literal.string.single) -> pop
+    r"{" is(operator) -> do-all(pop, go-to(root))
+
+  lex(type-tuple):
+    any-of(comments-and-spaces)
+    r"[^\(\)/*]+" is(keyword.type)
+    r"[/*]" is(keyword.type)
+    r"\(" is(keyword.type) -> push
+    r"\)" is(keyword.type) -> pop
+
+  lex(html-comment):
+    r"-->" is(comment) -> pop
+    r"[^\-]+|-" is(comment)
+
+  lex(comments-and-spaces):
+    any-of(comments)
+    r"\s+" is(text)
+
+  lex(nested-comment):
+    r"[^/*]+" is(comment)
+    r"/\*" is(comment) -> push
+    r"\*/" is(comment) -> pop
+    r"[/*]" is(comment)
+
+  lex(type-lhs-1):
+    any-of(comments-and-spaces)
+    r"->" is(keyword.type) -> do-all(pop, go-to(type))
+    r"(?=,)" is(keyword.type) -> do-all(pop, go-to(type-arrow))
+    r"" is(keyword.type) -> pop
+
+  lex(escape-sequence):
+    r"\\[\\\\"\'ntr}]" is(literal.string.escape)
+    r"\\[0-9]{3}" is(literal.string.escape)
+    r"\\x[0-9a-fA-F]{2}" is(literal.string.escape)
+
+  lex(type-arrow):
+    any-of(comments-and-spaces)
+    r",(?=[^:]*?->)" is(keyword.type) -> go-to(type-with-slash)
+    r"->" is(keyword.type) -> do-all(pop, go-to(type))
+    r"" is(keyword.type) -> pop
+
+  lex(type-record):
+    any-of(comments-and-spaces)
+    r"[^{}/*]+" is(keyword.type)
+    r"[/*]" is(keyword.type)
+    r"{" is(keyword.type) -> push
+    r"}" is(keyword.type) -> pop
+
+  lex(comments):
+    r"/\*" is(comment) -> go-to(nested-comment)
+    r"//.*?$" is(comment)
+
+  lex(slash-type-1):
+    any-of(comments-and-spaces)
+    r"/" is(keyword.type) -> do-all(pop, go-to(type-1))
+    r"" is(keyword.type) -> pop
+
+  lex(type):
+    any-of(comments-and-spaces)
+    r"->" is(keyword.type)
+    r"" is(keyword.type) -> do-all(pop, go-to(type-lhs-1), go-to(type-with-slash))
+
+  lex(type-1):
+    any-of(comments-and-spaces)
+    r"\(" is(keyword.type) -> do-all(pop, go-to(type-tuple))
+    r"\126?{" is(keyword.type) -> do-all(pop, go-to(type-record))
+    r"(([a-zA-Z_]\w*)|(`[^`]*`))\(" is(keyword.type) -> do-all(pop, go-to(type-tuple))
+    r"(([a-zA-Z_]\w*)|(`[^`]*`))" is(keyword.type) -> pop
+    r"'(([a-zA-Z_]\w*)|(`[^`]*`))" is(keyword.type)
+    r"" is(keyword.type) -> pop
+
+  lex(root):
+    any-of(comments-and-spaces)
+    r"\b(and|as|begin|css|database|db|do|else|end|external|forall|if|import|match|package|parser|rec|server|then|type|val|with|xml_parser)\b" is(keyword)
+    r"@(([a-zA-Z_]\w*)|(`[^`]*`))\b" is(name.builtin.pseudo)
+    r"-?.[\d]+([eE][+\-]?\d+)" is(literal.number.float)
+    r"-?\d+.\d*([eE][+\-]?\d+)" is(literal.number.float)
+    r"-?\d+[eE][+\-]?\d+" is(literal.number.float)
+    r"0[xX][\da-fA-F]+" is(literal.number.hex)
+    r"0[oO][0-7]+" is(literal.number.oct)
+    r"0[bB][01]+" is(literal.number.binary)
+    r"\d+" is(literal.number.integer)
+    r"\#[\da-fA-F]{3,6}" is(literal.number.integer)
+    r"\"" is(literal.string.double) -> go-to(string)
+    r"'(?:(\\[\\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2})|.)'" is(literal.string.char)
+    r"{" is(operator) -> push
+    r"}" is(operator) -> pop
+    r"<(?=[a-zA-Z>])" is(literal.string.single) -> go-to(html-open-tag)
+    r"[@?!]?(/\w+)+(\[_\])?" is(name.variable)
+    r"<-(?![.=\-<>,@\126%/+?*&^!])" is(name.variable)
+    r"\b([A-Z]\w*)(?=\.)" is(name.namespace)
+    r"=(?![.=\-<>,@\126%/+?*&^!])" is(keyword)
+    r"([.=\-<>,@\126%/+?*&^!])+" is(operator)
+    r"([()\[\],;|])+" is(operator)
+    r":" is(operator) -> go-to(type)
+    r"'(([a-zA-Z_]\w*)|(`[^`]*`))" is(keyword.type)
+    r"\#(([a-zA-Z_]\w*)|(`[^`]*`))" is(literal.string.single)
+    r"\#(?={)" is(literal.string.single)
+    r"(([a-zA-Z_]\w*)|(`[^`]*`))" is(text)
+
+  lex(html-end-tag):
+    r"[\w\-:]*>" is(literal.string.single) -> pop
+
+  lex(type-with-slash):
+    any-of(comments-and-spaces)
+    r"" is(keyword.type) -> do-all(pop, go-to(slash-type-1), go-to(type-1))
+
+  lex(single-string):
+    r"[^\\\'{]+" is(literal.string.double)
+    r"\'" is(literal.string.double) -> pop
+    r"{" is(operator) -> go-to(root)
+    any-of(escape-sequence)
+
+const-set(.Lexer, lexer)