Mercurial Repositories > eric / file comparison
comparison: ThirdParty/Pygments/pygments/lexers/other.py
ThirdParty/Pygments/pygments/lexers/other.py
- changeset 1705
- b0fbc9300f2b
- parent 808
- 8f85926125ef
- child 2426
- da76c71624de
equal
deleted
inserted
replaced
| 1704:02ae6c55b35b | 1705:b0fbc9300f2b |
|---|---|
| 3 pygments.lexers.other | 3 pygments.lexers.other |
| 4 ~~~~~~~~~~~~~~~~~~~~~ | 4 ~~~~~~~~~~~~~~~~~~~~~ |
| 5 | 5 |
| 6 Lexers for other languages. | 6 Lexers for other languages. |
| 7 | 7 |
| 8 :copyright: Copyright 2006-2010 by the Pygments team, see AUTHORS. | 8 :copyright: Copyright 2006-2012 by the Pygments team, see AUTHORS. |
| 9 :license: BSD, see LICENSE for details. | 9 :license: BSD, see LICENSE for details. |
| 10 """ | 10 """ |
| 11 | 11 |
| 12 import re | 12 import re |
| 13 | 13 |
| 14 from pygments.lexer import Lexer, RegexLexer, include, bygroups, using, \ | 14 from pygments.lexer import RegexLexer, include, bygroups, using, \ |
| 15 this, do_insertions | 15 this, combined, ExtendedRegexLexer |
| 16 from pygments.token import Error, Punctuation, Literal, Token, \ | 16 from pygments.token import Error, Punctuation, Literal, Token, \ |
| 17 Text, Comment, Operator, Keyword, Name, String, Number, Generic | 17 Text, Comment, Operator, Keyword, Name, String, Number, Generic |
| 18 from pygments.util import shebang_matches | |
| 19 from pygments.lexers.web import HtmlLexer | 18 from pygments.lexers.web import HtmlLexer |
| 20 | 19 |
| 21 | 20 |
| 22 __all__ = ['SqlLexer', 'MySqlLexer', 'SqliteConsoleLexer', 'BrainfuckLexer', | 21 # backwards compatibility |
| 23 'BashLexer', 'BatchLexer', 'BefungeLexer', 'RedcodeLexer', | 22 from pygments.lexers.sql import SqlLexer, MySqlLexer, SqliteConsoleLexer |
| 24 'MOOCodeLexer', 'SmalltalkLexer', 'TcshLexer', 'LogtalkLexer', | 23 from pygments.lexers.shell import BashLexer, BashSessionLexer, BatchLexer, \ |
| 25 'GnuplotLexer', 'PovrayLexer', 'AppleScriptLexer', | 24 TcshLexer |
| 26 'BashSessionLexer', 'ModelicaLexer', 'RebolLexer', 'ABAPLexer', | 25 |
| 27 'NewspeakLexer', 'GherkinLexer', 'AsymptoteLexer', | 26 __all__ = ['BrainfuckLexer', 'BefungeLexer', 'RedcodeLexer', 'MOOCodeLexer', |
| 28 'PostScriptLexer', 'AutohotkeyLexer', 'GoodDataCLLexer', | 27 'SmalltalkLexer', 'LogtalkLexer', 'GnuplotLexer', 'PovrayLexer', |
| 29 'MaqlLexer', 'ProtoBufLexer', 'HybrisLexer'] | 28 'AppleScriptLexer', 'ModelicaLexer', 'RebolLexer', 'ABAPLexer', |
| 30 | 29 'NewspeakLexer', 'GherkinLexer', 'AsymptoteLexer', 'PostScriptLexer', |
| 31 line_re = re.compile('.*?\n') | 30 'AutohotkeyLexer', 'GoodDataCLLexer', 'MaqlLexer', 'ProtoBufLexer', |
| 32 | 31 'HybrisLexer', 'AwkLexer', 'Cfengine3Lexer', 'SnobolLexer', |
| 33 | 32 'ECLLexer', 'UrbiscriptLexer', 'OpenEdgeLexer', 'BroLexer'] |
| 34 class SqlLexer(RegexLexer): | 33 |
| 35 """ | 34 |
| 36 Lexer for Structured Query Language. Currently, this lexer does | 35 class ECLLexer(RegexLexer): |
| 37 not recognize any special syntax except ANSI SQL. | 36 """ |
| 38 """ | 37 Lexer for the declarative big-data `ECL |
| 39 | 38 <http://hpccsystems.com/community/docs/ecl-language-reference/html>`_ |
| 40 name = 'SQL' | 39 language. |
| 41 aliases = ['sql'] | 40 |
| 42 filenames = ['*.sql'] | 41 *New in Pygments 1.5.* |
| 43 mimetypes = ['text/x-sql'] | 42 """ |
| 44 | 43 |
| 45 flags = re.IGNORECASE | 44 name = 'ECL' |
| 45 aliases = ['ecl'] | |
| 46 filenames = ['*.ecl'] | |
| 47 mimetypes = ['application/x-ecl'] | |
| 48 | |
| 49 flags = re.IGNORECASE | re.MULTILINE | |
| 50 | |
| 46 tokens = { | 51 tokens = { |
| 47 'root': [ | 52 'root': [ |
| 53 include('whitespace'), | |
| 54 include('statements'), | |
| 55 ], | |
| 56 'whitespace': [ | |
| 48 (r'\s+', Text), | 57 (r'\s+', Text), |
| 49 (r'--.*?\n', Comment.Single), | 58 (r'\/\/.*', Comment.Single), |
| 50 (r'/\*', Comment.Multiline, 'multiline-comments'), | 59 (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline), |
| 51 (r'(ABORT|ABS|ABSOLUTE|ACCESS|ADA|ADD|ADMIN|AFTER|AGGREGATE|' | 60 ], |
| 52 r'ALIAS|ALL|ALLOCATE|ALTER|ANALYSE|ANALYZE|AND|ANY|ARE|AS|' | 61 'statements': [ |
| 53 r'ASC|ASENSITIVE|ASSERTION|ASSIGNMENT|ASYMMETRIC|AT|ATOMIC|' | 62 include('types'), |
| 54 r'AUTHORIZATION|AVG|BACKWARD|BEFORE|BEGIN|BETWEEN|BITVAR|' | 63 include('keywords'), |
| 55 r'BIT_LENGTH|BOTH|BREADTH|BY|C|CACHE|CALL|CALLED|CARDINALITY|' | 64 include('functions'), |
| 56 r'CASCADE|CASCADED|CASE|CAST|CATALOG|CATALOG_NAME|CHAIN|' | 65 include('hash'), |
| 57 r'CHARACTERISTICS|CHARACTER_LENGTH|CHARACTER_SET_CATALOG|' | 66 (r'"', String, 'string'), |
| 58 r'CHARACTER_SET_NAME|CHARACTER_SET_SCHEMA|CHAR_LENGTH|CHECK|' | 67 (r'\'', String, 'string'), |
| 59 r'CHECKED|CHECKPOINT|CLASS|CLASS_ORIGIN|CLOB|CLOSE|CLUSTER|' | 68 (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*', Number.Float), |
| 60 r'COALSECE|COBOL|COLLATE|COLLATION|COLLATION_CATALOG|' | 69 (r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float), |
| 61 r'COLLATION_NAME|COLLATION_SCHEMA|COLUMN|COLUMN_NAME|' | 70 (r'0x[0-9a-fA-F]+[LlUu]*', Number.Hex), |
| 62 r'COMMAND_FUNCTION|COMMAND_FUNCTION_CODE|COMMENT|COMMIT|' | 71 (r'0[0-7]+[LlUu]*', Number.Oct), |
| 63 r'COMMITTED|COMPLETION|CONDITION_NUMBER|CONNECT|CONNECTION|' | 72 (r'\d+[LlUu]*', Number.Integer), |
| 64 r'CONNECTION_NAME|CONSTRAINT|CONSTRAINTS|CONSTRAINT_CATALOG|' | 73 (r'\*/', Error), |
| 65 r'CONSTRAINT_NAME|CONSTRAINT_SCHEMA|CONSTRUCTOR|CONTAINS|' | 74 (r'[~!%^&*+=|?:<>/-]+', Operator), |
| 66 r'CONTINUE|CONVERSION|CONVERT|COPY|CORRESPONTING|COUNT|' | 75 (r'[{}()\[\],.;]', Punctuation), |
| 67 r'CREATE|CREATEDB|CREATEUSER|CROSS|CUBE|CURRENT|CURRENT_DATE|' | |
| 68 r'CURRENT_PATH|CURRENT_ROLE|CURRENT_TIME|CURRENT_TIMESTAMP|' | |
| 69 r'CURRENT_USER|CURSOR|CURSOR_NAME|CYCLE|DATA|DATABASE|' | |
| 70 r'DATETIME_INTERVAL_CODE|DATETIME_INTERVAL_PRECISION|DAY|' | |
| 71 r'DEALLOCATE|DECLARE|DEFAULT|DEFAULTS|DEFERRABLE|DEFERRED|' | |
| 72 r'DEFINED|DEFINER|DELETE|DELIMITER|DELIMITERS|DEREF|DESC|' | |
| 73 r'DESCRIBE|DESCRIPTOR|DESTROY|DESTRUCTOR|DETERMINISTIC|' | |
| 74 r'DIAGNOSTICS|DICTIONARY|DISCONNECT|DISPATCH|DISTINCT|DO|' | |
| 75 r'DOMAIN|DROP|DYNAMIC|DYNAMIC_FUNCTION|DYNAMIC_FUNCTION_CODE|' | |
| 76 r'EACH|ELSE|ENCODING|ENCRYPTED|END|END-EXEC|EQUALS|ESCAPE|EVERY|' | |
| 77 r'EXCEPT|ESCEPTION|EXCLUDING|EXCLUSIVE|EXEC|EXECUTE|EXISTING|' | |
| 78 r'EXISTS|EXPLAIN|EXTERNAL|EXTRACT|FALSE|FETCH|FINAL|FIRST|FOR|' | |
| 79 r'FORCE|FOREIGN|FORTRAN|FORWARD|FOUND|FREE|FREEZE|FROM|FULL|' | |
| 80 r'FUNCTION|G|GENERAL|GENERATED|GET|GLOBAL|GO|GOTO|GRANT|GRANTED|' | |
| 81 r'GROUP|GROUPING|HANDLER|HAVING|HIERARCHY|HOLD|HOST|IDENTITY|' | |
| 82 r'IGNORE|ILIKE|IMMEDIATE|IMMUTABLE|IMPLEMENTATION|IMPLICIT|IN|' | |
| 83 r'INCLUDING|INCREMENT|INDEX|INDITCATOR|INFIX|INHERITS|INITIALIZE|' | |
| 84 r'INITIALLY|INNER|INOUT|INPUT|INSENSITIVE|INSERT|INSTANTIABLE|' | |
| 85 r'INSTEAD|INTERSECT|INTO|INVOKER|IS|ISNULL|ISOLATION|ITERATE|JOIN|' | |
| 86 r'KEY|KEY_MEMBER|KEY_TYPE|LANCOMPILER|LANGUAGE|LARGE|LAST|' | |
| 87 r'LATERAL|LEADING|LEFT|LENGTH|LESS|LEVEL|LIKE|LIMIT|LISTEN|LOAD|' | |
| 88 r'LOCAL|LOCALTIME|LOCALTIMESTAMP|LOCATION|LOCATOR|LOCK|LOWER|' | |
| 89 r'MAP|MATCH|MAX|MAXVALUE|MESSAGE_LENGTH|MESSAGE_OCTET_LENGTH|' | |
| 90 r'MESSAGE_TEXT|METHOD|MIN|MINUTE|MINVALUE|MOD|MODE|MODIFIES|' | |
| 91 r'MODIFY|MONTH|MORE|MOVE|MUMPS|NAMES|NATIONAL|NATURAL|NCHAR|' | |
| 92 r'NCLOB|NEW|NEXT|NO|NOCREATEDB|NOCREATEUSER|NONE|NOT|NOTHING|' | |
| 93 r'NOTIFY|NOTNULL|NULL|NULLABLE|NULLIF|OBJECT|OCTET_LENGTH|OF|OFF|' | |
| 94 r'OFFSET|OIDS|OLD|ON|ONLY|OPEN|OPERATION|OPERATOR|OPTION|OPTIONS|' | |
| 95 r'OR|ORDER|ORDINALITY|OUT|OUTER|OUTPUT|OVERLAPS|OVERLAY|OVERRIDING|' | |
| 96 r'OWNER|PAD|PARAMETER|PARAMETERS|PARAMETER_MODE|PARAMATER_NAME|' | |
| 97 r'PARAMATER_ORDINAL_POSITION|PARAMETER_SPECIFIC_CATALOG|' | |
| 98 r'PARAMETER_SPECIFIC_NAME|PARAMATER_SPECIFIC_SCHEMA|PARTIAL|' | |
| 99 r'PASCAL|PENDANT|PLACING|PLI|POSITION|POSTFIX|PRECISION|PREFIX|' | |
| 100 r'PREORDER|PREPARE|PRESERVE|PRIMARY|PRIOR|PRIVILEGES|PROCEDURAL|' | |
| 101 r'PROCEDURE|PUBLIC|READ|READS|RECHECK|RECURSIVE|REF|REFERENCES|' | |
| 102 r'REFERENCING|REINDEX|RELATIVE|RENAME|REPEATABLE|REPLACE|RESET|' | |
| 103 r'RESTART|RESTRICT|RESULT|RETURN|RETURNED_LENGTH|' | |
| 104 r'RETURNED_OCTET_LENGTH|RETURNED_SQLSTATE|RETURNS|REVOKE|RIGHT|' | |
| 105 r'ROLE|ROLLBACK|ROLLUP|ROUTINE|ROUTINE_CATALOG|ROUTINE_NAME|' | |
| 106 r'ROUTINE_SCHEMA|ROW|ROWS|ROW_COUNT|RULE|SAVE_POINT|SCALE|SCHEMA|' | |
| 107 r'SCHEMA_NAME|SCOPE|SCROLL|SEARCH|SECOND|SECURITY|SELECT|SELF|' | |
| 108 r'SENSITIVE|SERIALIZABLE|SERVER_NAME|SESSION|SESSION_USER|SET|' | |
| 109 r'SETOF|SETS|SHARE|SHOW|SIMILAR|SIMPLE|SIZE|SOME|SOURCE|SPACE|' | |
| 110 r'SPECIFIC|SPECIFICTYPE|SPECIFIC_NAME|SQL|SQLCODE|SQLERROR|' | |
| 111 r'SQLEXCEPTION|SQLSTATE|SQLWARNINIG|STABLE|START|STATE|STATEMENT|' | |
| 112 r'STATIC|STATISTICS|STDIN|STDOUT|STORAGE|STRICT|STRUCTURE|STYPE|' | |
| 113 r'SUBCLASS_ORIGIN|SUBLIST|SUBSTRING|SUM|SYMMETRIC|SYSID|SYSTEM|' | |
| 114 r'SYSTEM_USER|TABLE|TABLE_NAME| TEMP|TEMPLATE|TEMPORARY|TERMINATE|' | |
| 115 r'THAN|THEN|TIMESTAMP|TIMEZONE_HOUR|TIMEZONE_MINUTE|TO|TOAST|' | |
| 116 r'TRAILING|TRANSATION|TRANSACTIONS_COMMITTED|' | |
| 117 r'TRANSACTIONS_ROLLED_BACK|TRANSATION_ACTIVE|TRANSFORM|' | |
| 118 r'TRANSFORMS|TRANSLATE|TRANSLATION|TREAT|TRIGGER|TRIGGER_CATALOG|' | |
| 119 r'TRIGGER_NAME|TRIGGER_SCHEMA|TRIM|TRUE|TRUNCATE|TRUSTED|TYPE|' | |
| 120 r'UNCOMMITTED|UNDER|UNENCRYPTED|UNION|UNIQUE|UNKNOWN|UNLISTEN|' | |
| 121 r'UNNAMED|UNNEST|UNTIL|UPDATE|UPPER|USAGE|USER|' | |
| 122 r'USER_DEFINED_TYPE_CATALOG|USER_DEFINED_TYPE_NAME|' | |
| 123 r'USER_DEFINED_TYPE_SCHEMA|USING|VACUUM|VALID|VALIDATOR|VALUES|' | |
| 124 r'VARIABLE|VERBOSE|VERSION|VIEW|VOLATILE|WHEN|WHENEVER|WHERE|' | |
| 125 r'WITH|WITHOUT|WORK|WRITE|YEAR|ZONE)\b', Keyword), | |
| 126 (r'(ARRAY|BIGINT|BINARY|BIT|BLOB|BOOLEAN|CHAR|CHARACTER|DATE|' | |
| 127 r'DEC|DECIMAL|FLOAT|INT|INTEGER|INTERVAL|NUMBER|NUMERIC|REAL|' | |
| 128 r'SERIAL|SMALLINT|VARCHAR|VARYING|INT8|SERIAL8|TEXT)\b', | |
| 129 Name.Builtin), | |
| 130 (r'[+*/<>=~!@#%^&|`?^-]', Operator), | |
| 131 (r'[0-9]+', Number.Integer), | |
| 132 # TODO: Backslash escapes? | |
| 133 (r"'(''|[^'])*'", String.Single), | |
| 134 (r'"(""|[^"])*"', String.Symbol), # not a real string literal in ANSI SQL | |
| 135 (r'[a-zA-Z_][a-zA-Z0-9_]*', Name), | 76 (r'[a-zA-Z_][a-zA-Z0-9_]*', Name), |
| 136 (r'[;:()\[\],\.]', Punctuation) | 77 ], |
| 137 ], | 78 'hash': [ |
| 138 'multiline-comments': [ | 79 (r'^#.*$', Comment.Preproc), |
| 139 (r'/\*', Comment.Multiline, 'multiline-comments'), | 80 ], |
| 140 (r'\*/', Comment.Multiline, '#pop'), | 81 'types': [ |
| 141 (r'[^/\*]+', Comment.Multiline), | 82 (r'(RECORD|END)\D', Keyword.Declaration), |
| 142 (r'[/*]', Comment.Multiline) | 83 (r'((?:ASCII|BIG_ENDIAN|BOOLEAN|DATA|DECIMAL|EBCDIC|INTEGER|PATTERN|' |
| 143 ] | 84 r'QSTRING|REAL|RECORD|RULE|SET OF|STRING|TOKEN|UDECIMAL|UNICODE|' |
| 85 r'UNSIGNED|VARSTRING|VARUNICODE)\d*)(\s+)', | |
| 86 bygroups(Keyword.Type, Text)), | |
| 87 ], | |
| 88 'keywords': [ | |
| 89 (r'(APPLY|ASSERT|BUILD|BUILDINDEX|EVALUATE|FAIL|KEYDIFF|KEYPATCH|' | |
| 90 r'LOADXML|NOTHOR|NOTIFY|OUTPUT|PARALLEL|SEQUENTIAL|SOAPCALL|WAIT' | |
| 91 r'CHECKPOINT|DEPRECATED|FAILCODE|FAILMESSAGE|FAILURE|GLOBAL|' | |
| 92 r'INDEPENDENT|ONWARNING|PERSIST|PRIORITY|RECOVERY|STORED|SUCCESS|' | |
| 93 r'WAIT|WHEN)\b', Keyword.Reserved), | |
| 94 # These are classed differently, check later | |
| 95 (r'(ALL|AND|ANY|AS|ATMOST|BEFORE|BEGINC\+\+|BEST|BETWEEN|CASE|CONST|' | |
| 96 r'COUNTER|CSV|DESCEND|ENCRYPT|ENDC\+\+|ENDMACRO|EXCEPT|EXCLUSIVE|' | |
| 97 r'EXPIRE|EXPORT|EXTEND|FALSE|FEW|FIRST|FLAT|FULL|FUNCTION|GROUP|' | |
| 98 r'HEADER|HEADING|HOLE|IFBLOCK|IMPORT|IN|JOINED|KEEP|KEYED|LAST|' | |
| 99 r'LEFT|LIMIT|LOAD|LOCAL|LOCALE|LOOKUP|MACRO|MANY|MAXCOUNT|' | |
| 100 r'MAXLENGTH|MIN SKEW|MODULE|INTERFACE|NAMED|NOCASE|NOROOT|NOSCAN|' | |
| 101 r'NOSORT|NOT|OF|ONLY|OPT|OR|OUTER|OVERWRITE|PACKED|PARTITION|' | |
| 102 r'PENALTY|PHYSICALLENGTH|PIPE|QUOTE|RELATIONSHIP|REPEAT|RETURN|' | |
| 103 r'RIGHT|SCAN|SELF|SEPARATOR|SERVICE|SHARED|SKEW|SKIP|SQL|STORE|' | |
| 104 r'TERMINATOR|THOR|THRESHOLD|TOKEN|TRANSFORM|TRIM|TRUE|TYPE|' | |
| 105 r'UNICODEORDER|UNSORTED|VALIDATE|VIRTUAL|WHOLE|WILD|WITHIN|XML|' | |
| 106 r'XPATH|__COMPRESSED__)\b', Keyword.Reserved), | |
| 107 ], | |
| 108 'functions': [ | |
| 109 (r'(ABS|ACOS|ALLNODES|ASCII|ASIN|ASSTRING|ATAN|ATAN2|AVE|CASE|' | |
| 110 r'CHOOSE|CHOOSEN|CHOOSESETS|CLUSTERSIZE|COMBINE|CORRELATION|COS|' | |
| 111 r'COSH|COUNT|COVARIANCE|CRON|DATASET|DEDUP|DEFINE|DENORMALIZE|' | |
| 112 r'DISTRIBUTE|DISTRIBUTED|DISTRIBUTION|EBCDIC|ENTH|ERROR|EVALUATE|' | |
| 113 r'EVENT|EVENTEXTRA|EVENTNAME|EXISTS|EXP|FAILCODE|FAILMESSAGE|' | |
| 114 r'FETCH|FROMUNICODE|GETISVALID|GLOBAL|GRAPH|GROUP|HASH|HASH32|' | |
| 115 r'HASH64|HASHCRC|HASHMD5|HAVING|IF|INDEX|INTFORMAT|ISVALID|' | |
| 116 r'ITERATE|JOIN|KEYUNICODE|LENGTH|LIBRARY|LIMIT|LN|LOCAL|LOG|LOOP|' | |
| 117 r'MAP|MATCHED|MATCHLENGTH|MATCHPOSITION|MATCHTEXT|MATCHUNICODE|' | |
| 118 r'MAX|MERGE|MERGEJOIN|MIN|NOLOCAL|NONEMPTY|NORMALIZE|PARSE|PIPE|' | |
| 119 r'POWER|PRELOAD|PROCESS|PROJECT|PULL|RANDOM|RANGE|RANK|RANKED|' | |
| 120 r'REALFORMAT|RECORDOF|REGEXFIND|REGEXREPLACE|REGROUP|REJECTED|' | |
| 121 r'ROLLUP|ROUND|ROUNDUP|ROW|ROWDIFF|SAMPLE|SET|SIN|SINH|SIZEOF|' | |
| 122 r'SOAPCALL|SORT|SORTED|SQRT|STEPPED|STORED|SUM|TABLE|TAN|TANH|' | |
| 123 r'THISNODE|TOPN|TOUNICODE|TRANSFER|TRIM|TRUNCATE|TYPEOF|UNGROUP|' | |
| 124 r'UNICODEORDER|VARIANCE|WHICH|WORKUNIT|XMLDECODE|XMLENCODE|' | |
| 125 r'XMLTEXT|XMLUNICODE)\b', Name.Function), | |
| 126 ], | |
| 127 'string': [ | |
| 128 (r'"', String, '#pop'), | |
| 129 (r'\'', String, '#pop'), | |
| 130 (r'[^"\']+', String), | |
| 131 ], | |
| 144 } | 132 } |
| 145 | |
| 146 | |
| 147 class MySqlLexer(RegexLexer): | |
| 148 """ | |
| 149 Special lexer for MySQL. | |
| 150 """ | |
| 151 | |
| 152 name = 'MySQL' | |
| 153 aliases = ['mysql'] | |
| 154 mimetypes = ['text/x-mysql'] | |
| 155 | |
| 156 flags = re.IGNORECASE | |
| 157 tokens = { | |
| 158 'root': [ | |
| 159 (r'\s+', Text), | |
| 160 (r'(#|--\s+).*?\n', Comment.Single), | |
| 161 (r'/\*', Comment.Multiline, 'multiline-comments'), | |
| 162 (r'[0-9]+', Number.Integer), | |
| 163 (r'[0-9]*\.[0-9]+(e[+-][0-9]+)', Number.Float), | |
| 164 # TODO: add backslash escapes | |
| 165 (r"'(''|[^'])*'", String.Single), | |
| 166 (r'"(""|[^"])*"', String.Double), | |
| 167 (r"`(``|[^`])*`", String.Symbol), | |
| 168 (r'[+*/<>=~!@#%^&|`?^-]', Operator), | |
| 169 (r'\b(tinyint|smallint|mediumint|int|integer|bigint|date|' | |
| 170 r'datetime|time|bit|bool|tinytext|mediumtext|longtext|text|' | |
| 171 r'tinyblob|mediumblob|longblob|blob|float|double|double\s+' | |
| 172 r'precision|real|numeric|dec|decimal|timestamp|year|char|' | |
| 173 r'varchar|varbinary|varcharacter|enum|set)(\b\s*)(\()?', | |
| 174 bygroups(Keyword.Type, Text, Punctuation)), | |
| 175 (r'\b(add|all|alter|analyze|and|as|asc|asensitive|before|between|' | |
| 176 r'bigint|binary|blob|both|by|call|cascade|case|change|char|' | |
| 177 r'character|check|collate|column|condition|constraint|continue|' | |
| 178 r'convert|create|cross|current_date|current_time|' | |
| 179 r'current_timestamp|current_user|cursor|database|databases|' | |
| 180 r'day_hour|day_microsecond|day_minute|day_second|dec|decimal|' | |
| 181 r'declare|default|delayed|delete|desc|describe|deterministic|' | |
| 182 r'distinct|distinctrow|div|double|drop|dual|each|else|elseif|' | |
| 183 r'enclosed|escaped|exists|exit|explain|fetch|float|float4|float8' | |
| 184 r'|for|force|foreign|from|fulltext|grant|group|having|' | |
| 185 r'high_priority|hour_microsecond|hour_minute|hour_second|if|' | |
| 186 r'ignore|in|index|infile|inner|inout|insensitive|insert|int|' | |
| 187 r'int1|int2|int3|int4|int8|integer|interval|into|is|iterate|' | |
| 188 r'join|key|keys|kill|leading|leave|left|like|limit|lines|load|' | |
| 189 r'localtime|localtimestamp|lock|long|loop|low_priority|match|' | |
| 190 r'minute_microsecond|minute_second|mod|modifies|natural|' | |
| 191 r'no_write_to_binlog|not|numeric|on|optimize|option|optionally|' | |
| 192 r'or|order|out|outer|outfile|precision|primary|procedure|purge|' | |
| 193 r'raid0|read|reads|real|references|regexp|release|rename|repeat|' | |
| 194 r'replace|require|restrict|return|revoke|right|rlike|schema|' | |
| 195 r'schemas|second_microsecond|select|sensitive|separator|set|' | |
| 196 r'show|smallint|soname|spatial|specific|sql|sql_big_result|' | |
| 197 r'sql_calc_found_rows|sql_small_result|sqlexception|sqlstate|' | |
| 198 r'sqlwarning|ssl|starting|straight_join|table|terminated|then|' | |
| 199 r'to|trailing|trigger|undo|union|unique|unlock|unsigned|update|' | |
| 200 r'usage|use|using|utc_date|utc_time|utc_timestamp|values|' | |
| 201 r'varying|when|where|while|with|write|x509|xor|year_month|' | |
| 202 r'zerofill)\b', Keyword), | |
| 203 # TODO: this list is not complete | |
| 204 (r'\b(auto_increment|engine|charset|tables)\b', Keyword.Pseudo), | |
| 205 (r'(true|false|null)', Name.Constant), | |
| 206 (r'([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(\()', | |
| 207 bygroups(Name.Function, Text, Punctuation)), | |
| 208 (r'[a-zA-Z_][a-zA-Z0-9_]*', Name), | |
| 209 (r'@[A-Za-z0-9]*[._]*[A-Za-z0-9]*', Name.Variable), | |
| 210 (r'[;:()\[\],\.]', Punctuation) | |
| 211 ], | |
| 212 'multiline-comments': [ | |
| 213 (r'/\*', Comment.Multiline, 'multiline-comments'), | |
| 214 (r'\*/', Comment.Multiline, '#pop'), | |
| 215 (r'[^/\*]+', Comment.Multiline), | |
| 216 (r'[/*]', Comment.Multiline) | |
| 217 ] | |
| 218 } | |
| 219 | |
| 220 | |
| 221 class SqliteConsoleLexer(Lexer): | |
| 222 """ | |
| 223 Lexer for example sessions using sqlite3. | |
| 224 | |
| 225 *New in Pygments 0.11.* | |
| 226 """ | |
| 227 | |
| 228 name = 'sqlite3con' | |
| 229 aliases = ['sqlite3'] | |
| 230 filenames = ['*.sqlite3-console'] | |
| 231 mimetypes = ['text/x-sqlite3-console'] | |
| 232 | |
| 233 def get_tokens_unprocessed(self, data): | |
| 234 sql = SqlLexer(**self.options) | |
| 235 | |
| 236 curcode = '' | |
| 237 insertions = [] | |
| 238 for match in line_re.finditer(data): | |
| 239 line = match.group() | |
| 240 if line.startswith('sqlite> ') or line.startswith(' ...> '): | |
| 241 insertions.append((len(curcode), | |
| 242 [(0, Generic.Prompt, line[:8])])) | |
| 243 curcode += line[8:] | |
| 244 else: | |
| 245 if curcode: | |
| 246 for item in do_insertions(insertions, | |
| 247 sql.get_tokens_unprocessed(curcode)): | |
| 248 yield item | |
| 249 curcode = '' | |
| 250 insertions = [] | |
| 251 if line.startswith('SQL error: '): | |
| 252 yield (match.start(), Generic.Traceback, line) | |
| 253 else: | |
| 254 yield (match.start(), Generic.Output, line) | |
| 255 if curcode: | |
| 256 for item in do_insertions(insertions, | |
| 257 sql.get_tokens_unprocessed(curcode)): | |
| 258 yield item | |
| 259 | 133 |
| 260 | 134 |
| 261 class BrainfuckLexer(RegexLexer): | 135 class BrainfuckLexer(RegexLexer): |
| 262 """ | 136 """ |
| 263 Lexer for the esoteric `BrainFuck <http://www.muppetlabs.com/~breadbox/bf/>`_ | 137 Lexer for the esoteric `BrainFuck <http://www.muppetlabs.com/~breadbox/bf/>`_ |
| 314 (r'\'.', String.Single), # Single character | 188 (r'\'.', String.Single), # Single character |
| 315 (r'[#;]', Comment), # Trampoline... depends on direction hit | 189 (r'[#;]', Comment), # Trampoline... depends on direction hit |
| 316 (r'[pg&~=@iotsy]', Keyword), # Misc | 190 (r'[pg&~=@iotsy]', Keyword), # Misc |
| 317 (r'[()A-Z]', Comment), # Fingerprints | 191 (r'[()A-Z]', Comment), # Fingerprints |
| 318 (r'\s+', Text), # Whitespace doesn't matter | 192 (r'\s+', Text), # Whitespace doesn't matter |
| 319 ], | |
| 320 } | |
| 321 | |
| 322 | |
| 323 | |
| 324 class BashLexer(RegexLexer): | |
| 325 """ | |
| 326 Lexer for (ba|k|)sh shell scripts. | |
| 327 | |
| 328 *New in Pygments 0.6.* | |
| 329 """ | |
| 330 | |
| 331 name = 'Bash' | |
| 332 aliases = ['bash', 'sh', 'ksh'] | |
| 333 filenames = ['*.sh', '*.ksh', '*.bash', '*.ebuild', '*.eclass'] | |
| 334 mimetypes = ['application/x-sh', 'application/x-shellscript'] | |
| 335 | |
| 336 tokens = { | |
| 337 'root': [ | |
| 338 include('basic'), | |
| 339 (r'\$\(\(', Keyword, 'math'), | |
| 340 (r'\$\(', Keyword, 'paren'), | |
| 341 (r'\${#?', Keyword, 'curly'), | |
| 342 (r'`', String.Backtick, 'backticks'), | |
| 343 include('data'), | |
| 344 ], | |
| 345 'basic': [ | |
| 346 (r'\b(if|fi|else|while|do|done|for|then|return|function|case|' | |
| 347 r'select|continue|until|esac|elif)\s*\b', | |
| 348 Keyword), | |
| 349 (r'\b(alias|bg|bind|break|builtin|caller|cd|command|compgen|' | |
| 350 r'complete|declare|dirs|disown|echo|enable|eval|exec|exit|' | |
| 351 r'export|false|fc|fg|getopts|hash|help|history|jobs|kill|let|' | |
| 352 r'local|logout|popd|printf|pushd|pwd|read|readonly|set|shift|' | |
| 353 r'shopt|source|suspend|test|time|times|trap|true|type|typeset|' | |
| 354 r'ulimit|umask|unalias|unset|wait)\s*\b(?!\.)', | |
| 355 Name.Builtin), | |
| 356 (r'#.*\n', Comment), | |
| 357 (r'\\[\w\W]', String.Escape), | |
| 358 (r'(\b\w+)(\s*)(=)', bygroups(Name.Variable, Text, Operator)), | |
| 359 (r'[\[\]{}()=]', Operator), | |
| 360 (r'<<-?\s*(\'?)\\?(\w+)[\w\W]+?\2', String), | |
| 361 (r'&&|\|\|', Operator), | |
| 362 ], | |
| 363 'data': [ | |
| 364 (r'(?s)\$?"(\\\\|\\[0-7]+|\\.|[^"\\])*"', String.Double), | |
| 365 (r"(?s)\$?'(\\\\|\\[0-7]+|\\.|[^'\\])*'", String.Single), | |
| 366 (r';', Text), | |
| 367 (r'\s+', Text), | |
| 368 (r'[^=\s\n\[\]{}()$"\'`\\<]+', Text), | |
| 369 (r'\d+(?= |\Z)', Number), | |
| 370 (r'\$#?(\w+|.)', Name.Variable), | |
| 371 (r'<', Text), | |
| 372 ], | |
| 373 'curly': [ | |
| 374 (r'}', Keyword, '#pop'), | |
| 375 (r':-', Keyword), | |
| 376 (r'[a-zA-Z0-9_]+', Name.Variable), | |
| 377 (r'[^}:"\'`$]+', Punctuation), | |
| 378 (r':', Punctuation), | |
| 379 include('root'), | |
| 380 ], | |
| 381 'paren': [ | |
| 382 (r'\)', Keyword, '#pop'), | |
| 383 include('root'), | |
| 384 ], | |
| 385 'math': [ | |
| 386 (r'\)\)', Keyword, '#pop'), | |
| 387 (r'[-+*/%^|&]|\*\*|\|\|', Operator), | |
| 388 (r'\d+', Number), | |
| 389 include('root'), | |
| 390 ], | |
| 391 'backticks': [ | |
| 392 (r'`', String.Backtick, '#pop'), | |
| 393 include('root'), | |
| 394 ], | |
| 395 } | |
| 396 | |
| 397 def analyse_text(text): | |
| 398 return shebang_matches(text, r'(ba|z|)sh') | |
| 399 | |
| 400 | |
| 401 class BashSessionLexer(Lexer): | |
| 402 """ | |
| 403 Lexer for simplistic shell sessions. | |
| 404 | |
| 405 *New in Pygments 1.1.* | |
| 406 """ | |
| 407 | |
| 408 name = 'Bash Session' | |
| 409 aliases = ['console'] | |
| 410 filenames = ['*.sh-session'] | |
| 411 mimetypes = ['application/x-shell-session'] | |
| 412 | |
| 413 def get_tokens_unprocessed(self, text): | |
| 414 bashlexer = BashLexer(**self.options) | |
| 415 | |
| 416 pos = 0 | |
| 417 curcode = '' | |
| 418 insertions = [] | |
| 419 | |
| 420 for match in line_re.finditer(text): | |
| 421 line = match.group() | |
| 422 m = re.match(r'^((?:|sh\S*?|\w+\S+[@:]\S+(?:\s+\S+)?|\[\S+[@:]' | |
| 423 r'[^\n]+\].+)[$#%])(.*\n?)', line) | |
| 424 if m: | |
| 425 # To support output lexers (say diff output), the output | |
| 426 # needs to be broken by prompts whenever the output lexer | |
| 427 # changes. | |
| 428 if not insertions: | |
| 429 pos = match.start() | |
| 430 | |
| 431 insertions.append((len(curcode), | |
| 432 [(0, Generic.Prompt, m.group(1))])) | |
| 433 curcode += m.group(2) | |
| 434 elif line.startswith('>'): | |
| 435 insertions.append((len(curcode), | |
| 436 [(0, Generic.Prompt, line[:1])])) | |
| 437 curcode += line[1:] | |
| 438 else: | |
| 439 if insertions: | |
| 440 toks = bashlexer.get_tokens_unprocessed(curcode) | |
| 441 for i, t, v in do_insertions(insertions, toks): | |
| 442 yield pos+i, t, v | |
| 443 yield match.start(), Generic.Output, line | |
| 444 insertions = [] | |
| 445 curcode = '' | |
| 446 if insertions: | |
| 447 for i, t, v in do_insertions(insertions, | |
| 448 bashlexer.get_tokens_unprocessed(curcode)): | |
| 449 yield pos+i, t, v | |
| 450 | |
| 451 | |
| 452 class BatchLexer(RegexLexer): | |
| 453 """ | |
| 454 Lexer for the DOS/Windows Batch file format. | |
| 455 | |
| 456 *New in Pygments 0.7.* | |
| 457 """ | |
| 458 name = 'Batchfile' | |
| 459 aliases = ['bat'] | |
| 460 filenames = ['*.bat', '*.cmd'] | |
| 461 mimetypes = ['application/x-dos-batch'] | |
| 462 | |
| 463 flags = re.MULTILINE | re.IGNORECASE | |
| 464 | |
| 465 tokens = { | |
| 466 'root': [ | |
| 467 # Lines can start with @ to prevent echo | |
| 468 (r'^\s*@', Punctuation), | |
| 469 (r'^(\s*)(rem\s.*)$', bygroups(Text, Comment)), | |
| 470 (r'".*?"', String.Double), | |
| 471 (r"'.*?'", String.Single), | |
| 472 # If made more specific, make sure you still allow expansions | |
| 473 # like %~$VAR:zlt | |
| 474 (r'%%?[~$:\w]+%?', Name.Variable), | |
| 475 (r'::.*', Comment), # Technically :: only works at BOL | |
| 476 (r'(set)(\s+)(\w+)', bygroups(Keyword, Text, Name.Variable)), | |
| 477 (r'(call)(\s+)(:\w+)', bygroups(Keyword, Text, Name.Label)), | |
| 478 (r'(goto)(\s+)(\w+)', bygroups(Keyword, Text, Name.Label)), | |
| 479 (r'\b(set|call|echo|on|off|endlocal|for|do|goto|if|pause|' | |
| 480 r'setlocal|shift|errorlevel|exist|defined|cmdextversion|' | |
| 481 r'errorlevel|else|cd|md|del|deltree|cls|choice)\b', Keyword), | |
| 482 (r'\b(equ|neq|lss|leq|gtr|geq)\b', Operator), | |
| 483 include('basic'), | |
| 484 (r'.', Text), | |
| 485 ], | |
| 486 'echo': [ | |
| 487 # Escapes only valid within echo args? | |
| 488 (r'\^\^|\^<|\^>|\^\|', String.Escape), | |
| 489 (r'\n', Text, '#pop'), | |
| 490 include('basic'), | |
| 491 (r'[^\'"^]+', Text), | |
| 492 ], | |
| 493 'basic': [ | |
| 494 (r'".*?"', String.Double), | |
| 495 (r"'.*?'", String.Single), | |
| 496 (r'`.*?`', String.Backtick), | |
| 497 (r'-?\d+', Number), | |
| 498 (r',', Punctuation), | |
| 499 (r'=', Operator), | |
| 500 (r'/\S+', Name), | |
| 501 (r':\w+', Name.Label), | |
| 502 (r'\w:\w+', Text), | |
| 503 (r'([<>|])(\s*)(\w+)', bygroups(Punctuation, Text, Name)), | |
| 504 ], | 193 ], |
| 505 } | 194 } |
| 506 | 195 |
| 507 | 196 |
| 508 class RedcodeLexer(RegexLexer): | 197 class RedcodeLexer(RegexLexer): |
| 619 (r'^([-+*/\\~<>=|&!?,@%]+)(\s*)(\w+)(\s*)$', | 308 (r'^([-+*/\\~<>=|&!?,@%]+)(\s*)(\w+)(\s*)$', |
| 620 bygroups(Name.Function, Text, Name.Variable, Text)), | 309 bygroups(Name.Function, Text, Name.Variable, Text)), |
| 621 ], | 310 ], |
| 622 'blockvariables' : [ | 311 'blockvariables' : [ |
| 623 include('whitespaces'), | 312 include('whitespaces'), |
| 624 (r'(:)(\s*)([A-Za-z\w]+)', | 313 (r'(:)(\s*)(\w+)', |
| 625 bygroups(Operator, Text, Name.Variable)), | 314 bygroups(Operator, Text, Name.Variable)), |
| 626 (r'\|', Operator, '#pop'), | 315 (r'\|', Operator, '#pop'), |
| 627 (r'', Text, '#pop'), # else pop | 316 (r'', Text, '#pop'), # else pop |
| 628 ], | 317 ], |
| 629 'literals' : [ | 318 'literals' : [ |
| 634 (r'(\d+r)?-?\d+(\.\d+)?(e-?\d+)?', Number, 'afterobject'), | 323 (r'(\d+r)?-?\d+(\.\d+)?(e-?\d+)?', Number, 'afterobject'), |
| 635 ], | 324 ], |
| 636 '_parenth_helper' : [ | 325 '_parenth_helper' : [ |
| 637 include('whitespaces'), | 326 include('whitespaces'), |
| 638 (r'(\d+r)?-?\d+(\.\d+)?(e-?\d+)?', Number), | 327 (r'(\d+r)?-?\d+(\.\d+)?(e-?\d+)?', Number), |
| 639 (r'[-+*/\\~<>=|&#!?,@%\w+:]+', String.Symbol), | 328 (r'[-+*/\\~<>=|&#!?,@%\w:]+', String.Symbol), |
| 640 # literals | 329 # literals |
| 641 (r'\'[^\']*\'', String), | 330 (r'\'[^\']*\'', String), |
| 642 (r'\$.', String.Char), | 331 (r'\$.', String.Char), |
| 643 (r'#*\(', String.Symbol, 'inner_parenth'), | 332 (r'#*\(', String.Symbol, 'inner_parenth'), |
| 644 ], | 333 ], |
| 700 String, Keyword, String, Keyword, String, Keyword)), | 389 String, Keyword, String, Keyword, String, Keyword)), |
| 701 (r'^(\w+(?: class)?)(\s+instanceVariableNames: )(.*?)(!)', | 390 (r'^(\w+(?: class)?)(\s+instanceVariableNames: )(.*?)(!)', |
| 702 bygroups(Name.Class, Keyword, String, Keyword)), | 391 bygroups(Name.Class, Keyword, String, Keyword)), |
| 703 (r'(!\n)(\].*)(! !)$', bygroups(Keyword, Text, Keyword)), | 392 (r'(!\n)(\].*)(! !)$', bygroups(Keyword, Text, Keyword)), |
| 704 (r'! !$', Keyword), | 393 (r'! !$', Keyword), |
| 705 ], | |
| 706 } | |
| 707 | |
| 708 | |
| 709 class TcshLexer(RegexLexer): | |
| 710 """ | |
| 711 Lexer for tcsh scripts. | |
| 712 | |
| 713 *New in Pygments 0.10.* | |
| 714 """ | |
| 715 | |
| 716 name = 'Tcsh' | |
| 717 aliases = ['tcsh', 'csh'] | |
| 718 filenames = ['*.tcsh', '*.csh'] | |
| 719 mimetypes = ['application/x-csh'] | |
| 720 | |
| 721 tokens = { | |
| 722 'root': [ | |
| 723 include('basic'), | |
| 724 (r'\$\(', Keyword, 'paren'), | |
| 725 (r'\${#?', Keyword, 'curly'), | |
| 726 (r'`', String.Backtick, 'backticks'), | |
| 727 include('data'), | |
| 728 ], | |
| 729 'basic': [ | |
| 730 (r'\b(if|endif|else|while|then|foreach|case|default|' | |
| 731 r'continue|goto|breaksw|end|switch|endsw)\s*\b', | |
| 732 Keyword), | |
| 733 (r'\b(alias|alloc|bg|bindkey|break|builtins|bye|caller|cd|chdir|' | |
| 734 r'complete|dirs|echo|echotc|eval|exec|exit|' | |
| 735 r'fg|filetest|getxvers|glob|getspath|hashstat|history|hup|inlib|jobs|kill|' | |
| 736 r'limit|log|login|logout|ls-F|migrate|newgrp|nice|nohup|notify|' | |
| 737 r'onintr|popd|printenv|pushd|rehash|repeat|rootnode|popd|pushd|set|shift|' | |
| 738 r'sched|setenv|setpath|settc|setty|setxvers|shift|source|stop|suspend|' | |
| 739 r'source|suspend|telltc|time|' | |
| 740 r'umask|unalias|uncomplete|unhash|universe|unlimit|unset|unsetenv|' | |
| 741 r'ver|wait|warp|watchlog|where|which)\s*\b', | |
| 742 Name.Builtin), | |
| 743 (r'#.*\n', Comment), | |
| 744 (r'\\[\w\W]', String.Escape), | |
| 745 (r'(\b\w+)(\s*)(=)', bygroups(Name.Variable, Text, Operator)), | |
| 746 (r'[\[\]{}()=]+', Operator), | |
| 747 (r'<<\s*(\'?)\\?(\w+)[\w\W]+?\2', String), | |
| 748 ], | |
| 749 'data': [ | |
| 750 (r'(?s)"(\\\\|\\[0-7]+|\\.|[^"\\])*"', String.Double), | |
| 751 (r"(?s)'(\\\\|\\[0-7]+|\\.|[^'\\])*'", String.Single), | |
| 752 (r'\s+', Text), | |
| 753 (r'[^=\s\n\[\]{}()$"\'`\\]+', Text), | |
| 754 (r'\d+(?= |\Z)', Number), | |
| 755 (r'\$#?(\w+|.)', Name.Variable), | |
| 756 ], | |
| 757 'curly': [ | |
| 758 (r'}', Keyword, '#pop'), | |
| 759 (r':-', Keyword), | |
| 760 (r'[a-zA-Z0-9_]+', Name.Variable), | |
| 761 (r'[^}:"\'`$]+', Punctuation), | |
| 762 (r':', Punctuation), | |
| 763 include('root'), | |
| 764 ], | |
| 765 'paren': [ | |
| 766 (r'\)', Keyword, '#pop'), | |
| 767 include('root'), | |
| 768 ], | |
| 769 'backticks': [ | |
| 770 (r'`', String.Backtick, '#pop'), | |
| 771 include('root'), | |
| 772 ], | 394 ], |
| 773 } | 395 } |
| 774 | 396 |
| 775 | 397 |
| 776 class LogtalkLexer(RegexLexer): | 398 class LogtalkLexer(RegexLexer): |
| 815 # Entity | 437 # Entity |
| 816 (r'(abolish|c(reate|urrent))_(object|protocol|category)(?=[(])', | 438 (r'(abolish|c(reate|urrent))_(object|protocol|category)(?=[(])', |
| 817 Keyword), | 439 Keyword), |
| 818 (r'(object|protocol|category)_property(?=[(])', Keyword), | 440 (r'(object|protocol|category)_property(?=[(])', Keyword), |
| 819 # Entity relations | 441 # Entity relations |
| 820 (r'complements_object(?=[(])', Keyword), | 442 (r'co(mplements_object|nforms_to_protocol)(?=[(])', Keyword), |
| 821 (r'extends_(object|protocol|category)(?=[(])', Keyword), | 443 (r'extends_(object|protocol|category)(?=[(])', Keyword), |
| 822 (r'imp(lements_protocol|orts_category)(?=[(])', Keyword), | 444 (r'imp(lements_protocol|orts_category)(?=[(])', Keyword), |
| 823 (r'(instantiat|specializ)es_class(?=[(])', Keyword), | 445 (r'(instantiat|specializ)es_class(?=[(])', Keyword), |
| 824 # Events | 446 # Events |
| 825 (r'(current_event|(abolish|define)_events)(?=[(])', Keyword), | 447 (r'(current_event|(abolish|define)_events)(?=[(])', Keyword), |
| 826 # Flags | 448 # Flags |
| 827 (r'(current|set)_logtalk_flag(?=[(])', Keyword), | 449 (r'(current|set)_logtalk_flag(?=[(])', Keyword), |
| 828 # Compiling, loading, and library paths | 450 # Compiling, loading, and library paths |
| 829 (r'logtalk_(compile|l(ibrary_path|oad))(?=[(])', Keyword), | 451 (r'logtalk_(compile|l(ibrary_path|oad_context|oad))(?=[(])', |
| 452 Keyword), | |
| 830 # Database | 453 # Database |
| 831 (r'(clause|retract(all)?)(?=[(])', Keyword), | 454 (r'(clause|retract(all)?)(?=[(])', Keyword), |
| 832 (r'a(bolish|ssert(a|z))(?=[(])', Keyword), | 455 (r'a(bolish|ssert(a|z))(?=[(])', Keyword), |
| 833 # Control | 456 # Control constructs |
| 834 (r'(ca(ll|tch)|throw)(?=[(])', Keyword), | 457 (r'(ca(ll|tch)|throw)(?=[(])', Keyword), |
| 835 (r'(fail|true)\b', Keyword), | 458 (r'(fail|true)\b', Keyword), |
| 836 # All solutions | 459 # All solutions |
| 837 (r'((bag|set)of|f(ind|or)all)(?=[(])', Keyword), | 460 (r'((bag|set)of|f(ind|or)all)(?=[(])', Keyword), |
| 838 # Multi-threading meta-predicates | 461 # Multi-threading meta-predicates |
| 839 (r'threaded(_(call|once|ignore|exit|peek|wait|notify))?(?=[(])', | 462 (r'threaded(_(call|once|ignore|exit|peek|wait|notify))?(?=[(])', |
| 840 Keyword), | 463 Keyword), |
| 841 # Term unification | 464 # Term unification |
| 842 (r'unify_with_occurs_check(?=[(])', Keyword), | 465 (r'unify_with_occurs_check(?=[(])', Keyword), |
| 843 # Term creation and decomposition | 466 # Term creation and decomposition |
| 844 (r'(functor|arg|copy_term)(?=[(])', Keyword), | 467 (r'(functor|arg|copy_term|numbervars)(?=[(])', Keyword), |
| 845 # Evaluable functors | 468 # Evaluable functors |
| 846 (r'(rem|mod|abs|sign)(?=[(])', Keyword), | 469 (r'(rem|mod|abs|sign)(?=[(])', Keyword), |
| 847 (r'float(_(integer|fractional)_part)?(?=[(])', Keyword), | 470 (r'float(_(integer|fractional)_part)?(?=[(])', Keyword), |
| 848 (r'(floor|truncate|round|ceiling)(?=[(])', Keyword), | 471 (r'(floor|truncate|round|ceiling)(?=[(])', Keyword), |
| 849 # Other arithmetic functors | 472 # Other arithmetic functors |
| 850 (r'(cos|atan|exp|log|s(in|qrt))(?=[(])', Keyword), | 473 (r'(cos|atan|exp|log|s(in|qrt))(?=[(])', Keyword), |
| 851 # Term testing | 474 # Term testing |
| 852 (r'(var|atom(ic)?|integer|float|compound|n(onvar|umber))(?=[(])', | 475 (r'(var|atom(ic)?|integer|float|c(allable|ompound)|n(onvar|umber)|' |
| 853 Keyword), | 476 r'ground)(?=[(])', Keyword), |
| 477 # Term comparison | |
| 478 (r'compare(?=[(])', Keyword), | |
| 854 # Stream selection and control | 479 # Stream selection and control |
| 855 (r'(curren|se)t_(in|out)put(?=[(])', Keyword), | 480 (r'(curren|se)t_(in|out)put(?=[(])', Keyword), |
| 856 (r'(open|close)(?=[(])', Keyword), | 481 (r'(open|close)(?=[(])', Keyword), |
| 857 (r'flush_output(?=[(])', Keyword), | 482 (r'flush_output(?=[(])', Keyword), |
| 858 (r'(at_end_of_stream|flush_output)\b', Keyword), | 483 (r'(at_end_of_stream|flush_output)\b', Keyword), |
| 877 # Message sending operators | 502 # Message sending operators |
| 878 (r'(::|:|\^\^)', Operator), | 503 (r'(::|:|\^\^)', Operator), |
| 879 # External call | 504 # External call |
| 880 (r'[{}]', Keyword), | 505 (r'[{}]', Keyword), |
| 881 # Logic and control | 506 # Logic and control |
| 882 (r'\bonce(?=[(])', Keyword), | 507 (r'\b(ignore|once)(?=[(])', Keyword), |
| 883 (r'\brepeat\b', Keyword), | 508 (r'\brepeat\b', Keyword), |
| 509 # Sorting | |
| 510 (r'(key)?sort(?=[(])', Keyword), | |
| 884 # Bitwise functors | 511 # Bitwise functors |
| 885 (r'(>>|<<|/\\|\\\\|\\)', Operator), | 512 (r'(>>|<<|/\\|\\\\|\\)', Operator), |
| 886 # Arithemtic evaluation | 513 # Arithemtic evaluation |
| 887 (r'\bis\b', Keyword), | 514 (r'\bis\b', Keyword), |
| 888 # Arithemtic comparison | 515 # Arithemtic comparison |
| 893 (r'(=|\\=)', Operator), | 520 (r'(=|\\=)', Operator), |
| 894 # Term comparison | 521 # Term comparison |
| 895 (r'(==|\\==|@=<|@<|@>=|@>)', Operator), | 522 (r'(==|\\==|@=<|@<|@>=|@>)', Operator), |
| 896 # Evaluable functors | 523 # Evaluable functors |
| 897 (r'(//|[-+*/])', Operator), | 524 (r'(//|[-+*/])', Operator), |
| 898 (r'\b(mod|rem)\b', Operator), | 525 (r'\b(e|pi|mod|rem)\b', Operator), |
| 899 # Other arithemtic functors | 526 # Other arithemtic functors |
| 900 (r'\b\*\*\b', Operator), | 527 (r'\b\*\*\b', Operator), |
| 901 # DCG rules | 528 # DCG rules |
| 902 (r'-->', Operator), | 529 (r'-->', Operator), |
| 903 # Control constructs | 530 # Control constructs |
| 904 (r'([!;]|->)', Operator), | 531 (r'([!;]|->)', Operator), |
| 905 # Logic and control | 532 # Logic and control |
| 906 (r'\\+', Operator), | 533 (r'\\+', Operator), |
| 907 # Mode operators | 534 # Mode operators |
| 908 (r'[?@]', Operator), | 535 (r'[?@]', Operator), |
| 536 # Existential quantifier | |
| 537 (r'\^', Operator), | |
| 909 # Strings | 538 # Strings |
| 910 (r'"(\\\\|\\"|[^"])*"', String), | 539 (r'"(\\\\|\\"|[^"])*"', String), |
| 911 # Ponctuation | 540 # Ponctuation |
| 912 (r'[()\[\],.|]', Text), | 541 (r'[()\[\],.|]', Text), |
| 913 # Atoms | 542 # Atoms |
| 914 (r"[a-z][a-zA-Z0-9_]*", Text), | 543 (r"[a-z][a-zA-Z0-9_]*", Text), |
| 915 (r"[']", String, 'quoted_atom'), | 544 (r"'", String, 'quoted_atom'), |
| 916 ], | 545 ], |
| 917 | 546 |
| 918 'quoted_atom': [ | 547 'quoted_atom': [ |
| 919 (r"['][']", String), | 548 (r"''", String), |
| 920 (r"[']", String, '#pop'), | 549 (r"'", String, '#pop'), |
| 921 (r'\\([\\abfnrtv"\']|(x[a-fA-F0-9]+|[0-7]+)\\)', String.Escape), | 550 (r'\\([\\abfnrtv"\']|(x[a-fA-F0-9]+|[0-7]+)\\)', String.Escape), |
| 922 (r"[^\\'\n]+", String), | 551 (r"[^\\'\n]+", String), |
| 923 (r'\\', String), | 552 (r'\\', String), |
| 924 ], | 553 ], |
| 925 | 554 |
| 935 # Other directives | 564 # Other directives |
| 936 (r'e(n(coding|sure_loaded)|xport)(?=[(])', Keyword, 'root'), | 565 (r'e(n(coding|sure_loaded)|xport)(?=[(])', Keyword, 'root'), |
| 937 (r'in(fo|itialization)(?=[(])', Keyword, 'root'), | 566 (r'in(fo|itialization)(?=[(])', Keyword, 'root'), |
| 938 (r'(dynamic|synchronized|threaded)[.]', Keyword, 'root'), | 567 (r'(dynamic|synchronized|threaded)[.]', Keyword, 'root'), |
| 939 (r'(alias|d(ynamic|iscontiguous)|m(eta_predicate|ode|ultifile)|' | 568 (r'(alias|d(ynamic|iscontiguous)|m(eta_predicate|ode|ultifile)|' |
| 940 r's(et_(logtalk|prolog)_flag|ynchronized))(?=[(])', Keyword, 'root'), | 569 r's(et_(logtalk|prolog)_flag|ynchronized))(?=[(])', |
| 570 Keyword, 'root'), | |
| 941 (r'op(?=[(])', Keyword, 'root'), | 571 (r'op(?=[(])', Keyword, 'root'), |
| 942 (r'(calls|reexport|use(s|_module))(?=[(])', Keyword, 'root'), | 572 (r'(c(alls|oinductive)|reexport|use(s|_module))(?=[(])', |
| 573 Keyword, 'root'), | |
| 943 (r'[a-z][a-zA-Z0-9_]*(?=[(])', Text, 'root'), | 574 (r'[a-z][a-zA-Z0-9_]*(?=[(])', Text, 'root'), |
| 944 (r'[a-z][a-zA-Z0-9_]*[.]', Text, 'root'), | 575 (r'[a-z][a-zA-Z0-9_]*[.]', Text, 'root'), |
| 945 ], | 576 ], |
| 946 | 577 |
| 947 'entityrelations': [ | 578 'entityrelations': [ |
| 948 (r'(extends|i(nstantiates|mp(lements|orts))|specializes)(?=[(])', | 579 (r'(complements|extends|i(nstantiates|mp(lements|orts))|specializes)' |
| 949 Keyword), | 580 r'(?=[(])', Keyword), |
| 950 # Numbers | 581 # Numbers |
| 951 (r"0'.", Number), | 582 (r"0'.", Number), |
| 952 (r'0b[01]+', Number), | 583 (r'0b[01]+', Number), |
| 953 (r'0o[0-7]+', Number), | 584 (r'0o[0-7]+', Number), |
| 954 (r'0x[0-9a-fA-F]+', Number), | 585 (r'0x[0-9a-fA-F]+', Number), |
| 955 (r'\d+\.?\d*((e|E)(\+|-)?\d+)?', Number), | 586 (r'\d+\.?\d*((e|E)(\+|-)?\d+)?', Number), |
| 956 # Variables | 587 # Variables |
| 957 (r'([A-Z_][a-zA-Z0-9_]*)', Name.Variable), | 588 (r'([A-Z_][a-zA-Z0-9_]*)', Name.Variable), |
| 958 # Atoms | 589 # Atoms |
| 959 (r"[a-z][a-zA-Z0-9_]*", Text), | 590 (r"[a-z][a-zA-Z0-9_]*", Text), |
| 960 (r"[']", String, 'quoted_atom'), | 591 (r"'", String, 'quoted_atom'), |
| 961 # Strings | 592 # Strings |
| 962 (r'"(\\\\|\\"|[^"])*"', String), | 593 (r'"(\\\\|\\"|[^"])*"', String), |
| 963 # End of entity-opening directive | 594 # End of entity-opening directive |
| 964 (r'([)]\.)', Text, 'root'), | 595 (r'([)]\.)', Text, 'root'), |
| 965 # Scope operator | 596 # Scope operator |
| 1165 tokens = { | 796 tokens = { |
| 1166 'root': [ | 797 'root': [ |
| 1167 (r'/\*[\w\W]*?\*/', Comment.Multiline), | 798 (r'/\*[\w\W]*?\*/', Comment.Multiline), |
| 1168 (r'//.*\n', Comment.Single), | 799 (r'//.*\n', Comment.Single), |
| 1169 (r'(?s)"(?:\\.|[^"\\])+"', String.Double), | 800 (r'(?s)"(?:\\.|[^"\\])+"', String.Double), |
| 1170 (r'#(debug|default|else|end|error|fclose|fopen|if|ifdef|ifndef|' | 801 (r'#(debug|default|else|end|error|fclose|fopen|ifdef|ifndef|' |
| 1171 r'include|range|read|render|statistics|switch|undef|version|' | 802 r'include|range|read|render|statistics|switch|undef|version|' |
| 1172 r'warning|while|write|define|macro|local|declare)', | 803 r'warning|while|write|define|macro|local|declare)\b', |
| 1173 Comment.Preproc), | 804 Comment.Preproc), |
| 1174 (r'\b(aa_level|aa_threshold|abs|acos|acosh|adaptive|adc_bailout|' | 805 (r'\b(aa_level|aa_threshold|abs|acos|acosh|adaptive|adc_bailout|' |
| 1175 r'agate|agate_turb|all|alpha|ambient|ambient_light|angle|' | 806 r'agate|agate_turb|all|alpha|ambient|ambient_light|angle|' |
| 1176 r'aperture|arc_angle|area_light|asc|asin|asinh|assumed_gamma|' | 807 r'aperture|arc_angle|area_light|asc|asin|asinh|assumed_gamma|' |
| 1177 r'atan|atan2|atanh|atmosphere|atmospheric_attenuation|' | 808 r'atan|atan2|atanh|atmosphere|atmospheric_attenuation|' |
| 1217 r'ultra_wide_angle|up|use_color|use_colour|use_index|u_steps|' | 848 r'ultra_wide_angle|up|use_color|use_colour|use_index|u_steps|' |
| 1218 r'val|variance|vaxis_rotate|vcross|vdot|version|vlength|' | 849 r'val|variance|vaxis_rotate|vcross|vdot|version|vlength|' |
| 1219 r'vnormalize|volume_object|volume_rendered|vol_with_light|' | 850 r'vnormalize|volume_object|volume_rendered|vol_with_light|' |
| 1220 r'vrotate|v_steps|warning|warp|water_level|waves|while|width|' | 851 r'vrotate|v_steps|warning|warp|water_level|waves|while|width|' |
| 1221 r'wood|wrinkles|yes)\b', Keyword), | 852 r'wood|wrinkles|yes)\b', Keyword), |
| 1222 (r'bicubic_patch|blob|box|camera|cone|cubic|cylinder|difference|' | 853 (r'(bicubic_patch|blob|box|camera|cone|cubic|cylinder|difference|' |
| 1223 r'disc|height_field|intersection|julia_fractal|lathe|' | 854 r'disc|height_field|intersection|julia_fractal|lathe|' |
| 1224 r'light_source|merge|mesh|object|plane|poly|polygon|prism|' | 855 r'light_source|merge|mesh|object|plane|poly|polygon|prism|' |
| 1225 r'quadric|quartic|smooth_triangle|sor|sphere|superellipsoid|' | 856 r'quadric|quartic|smooth_triangle|sor|sphere|superellipsoid|' |
| 1226 r'text|torus|triangle|union', Name.Builtin), | 857 r'text|torus|triangle|union)\b', Name.Builtin), |
| 1227 # TODO: <=, etc | 858 # TODO: <=, etc |
| 1228 (r'[\[\](){}<>;,]', Punctuation), | 859 (r'[\[\](){}<>;,]', Punctuation), |
| 1229 (r'[-+*/=]', Operator), | 860 (r'[-+*/=]', Operator), |
| 1230 (r'\b(x|y|z|u|v)\b', Name.Builtin.Pseudo), | 861 (r'\b(x|y|z|u|v)\b', Name.Builtin.Pseudo), |
| 1231 (r'[a-zA-Z_][a-zA-Z_0-9]*', Name), | 862 (r'[a-zA-Z_][a-zA-Z_0-9]*', Name), |
| 1259 'missing value', 'pi','quote', 'result', 'return', 'space', | 890 'missing value', 'pi','quote', 'result', 'return', 'space', |
| 1260 'tab', 'text item delimiters', 'true', 'version'] | 891 'tab', 'text item delimiters', 'true', 'version'] |
| 1261 Classes = ['alias ', 'application ', 'boolean ', 'class ', 'constant ', | 892 Classes = ['alias ', 'application ', 'boolean ', 'class ', 'constant ', |
| 1262 'date ', 'file ', 'integer ', 'list ', 'number ', 'POSIX file ', | 893 'date ', 'file ', 'integer ', 'list ', 'number ', 'POSIX file ', |
| 1263 'real ', 'record ', 'reference ', 'RGB color ', 'script ', | 894 'real ', 'record ', 'reference ', 'RGB color ', 'script ', |
| 1264 'text ', 'unit types', '(Unicode )?text', 'string'] | 895 'text ', 'unit types', '(?:Unicode )?text', 'string'] |
| 1265 BuiltIn = ['attachment', 'attribute run', 'character', 'day', 'month', | 896 BuiltIn = ['attachment', 'attribute run', 'character', 'day', 'month', |
| 1266 'paragraph', 'word', 'year'] | 897 'paragraph', 'word', 'year'] |
| 1267 HandlerParams = ['about', 'above', 'against', 'apart from', 'around', | 898 HandlerParams = ['about', 'above', 'against', 'apart from', 'around', |
| 1268 'aside from', 'at', 'below', 'beneath', 'beside', | 899 'aside from', 'at', 'below', 'beneath', 'beside', |
| 1269 'between', 'for', 'given', 'instead of', 'on', 'onto', | 900 'between', 'for', 'given', 'instead of', 'on', 'onto', |
| 1525 r'numeric strings|punctuation|white space)', | 1156 r'numeric strings|punctuation|white space)', |
| 1526 bygroups(Keyword, Name.Builtin)), | 1157 bygroups(Keyword, Name.Builtin)), |
| 1527 (r'(-|\*|\+|&|≠|>=?|<=?|=|≥|≤|/|÷|\^)', Operator), | 1158 (r'(-|\*|\+|&|≠|>=?|<=?|=|≥|≤|/|÷|\^)', Operator), |
| 1528 (r"\b(%s)\b" % '|'.join(Operators), Operator.Word), | 1159 (r"\b(%s)\b" % '|'.join(Operators), Operator.Word), |
| 1529 (r'^(\s*(?:on|end)\s+)' | 1160 (r'^(\s*(?:on|end)\s+)' |
| 1530 r'(%s)' % '|'.join(StudioEvents), | 1161 r'(%s)' % '|'.join(StudioEvents[::-1]), |
| 1531 bygroups(Keyword, Name.Function)), | 1162 bygroups(Keyword, Name.Function)), |
| 1532 (r'^(\s*)(in|on|script|to)(\s+)', bygroups(Text, Keyword, Text)), | 1163 (r'^(\s*)(in|on|script|to)(\s+)', bygroups(Text, Keyword, Text)), |
| 1533 (r'\b(as )(%s)\b' % '|'.join(Classes), | 1164 (r'\b(as )(%s)\b' % '|'.join(Classes), |
| 1534 bygroups(Keyword, Name.Class)), | 1165 bygroups(Keyword, Name.Class)), |
| 1535 (r'\b(%s)\b' % '|'.join(Literals), Name.Constant), | 1166 (r'\b(%s)\b' % '|'.join(Literals), Name.Constant), |
| 1607 r'protected|public|redeclare|replaceable|stream|time|then|true|' | 1238 r'protected|public|redeclare|replaceable|stream|time|then|true|' |
| 1608 r'when|while|within)\b', Keyword) | 1239 r'when|while|within)\b', Keyword) |
| 1609 ], | 1240 ], |
| 1610 'functions': [ | 1241 'functions': [ |
| 1611 (r'(abs|acos|acosh|asin|asinh|atan|atan2|atan3|ceil|cos|cosh|' | 1242 (r'(abs|acos|acosh|asin|asinh|atan|atan2|atan3|ceil|cos|cosh|' |
| 1612 r'cross|div|exp|floor|log|log10|mod|rem|sign|sin|sinh|size|' | 1243 r'cross|div|exp|floor|log|log10|mod|rem|semiLinear|sign|sin|' |
| 1613 r'sqrt|tan|tanh|zeros)\b', Name.Function) | 1244 r'sinh|size|sqrt|tan|tanh|zeros)\b', Name.Function) |
| 1614 ], | 1245 ], |
| 1615 'operators': [ | 1246 'operators': [ |
| 1616 (r'(and|assert|cardinality|change|delay|der|edge|initial|' | 1247 (r'(and|assert|cardinality|change|delay|der|edge|homotopy|initial|' |
| 1617 r'noEvent|not|or|pre|reinit|return|sample|smooth|' | 1248 r'noEvent|not|or|pre|reinit|return|sample|smooth|' |
| 1618 r'terminal|terminate)\b', Name.Builtin) | 1249 r'terminal|terminate)\b', Name.Builtin) |
| 1619 ], | 1250 ], |
| 1620 'classes': [ | 1251 'classes': [ |
| 1621 (r'(block|class|connector|function|model|package|' | 1252 (r'(block|class|connector|function|model|package|' |
| 1868 (r'^\*.*$', Comment.Single), | 1499 (r'^\*.*$', Comment.Single), |
| 1869 (r'\".*?\n', Comment.Single), | 1500 (r'\".*?\n', Comment.Single), |
| 1870 ], | 1501 ], |
| 1871 'variable-names': [ | 1502 'variable-names': [ |
| 1872 (r'<[\S_]+>', Name.Variable), | 1503 (r'<[\S_]+>', Name.Variable), |
| 1873 (r'[\w][\w_~]*(?:(\[\])|->\*)?', Name.Variable), | 1504 (r'\w[\w~]*(?:(\[\])|->\*)?', Name.Variable), |
| 1874 ], | 1505 ], |
| 1875 'root': [ | 1506 'root': [ |
| 1876 include('common'), | 1507 include('common'), |
| 1877 #function calls | 1508 #function calls |
| 1878 (r'(CALL\s+(?:BADI|CUSTOMER-FUNCTION|FUNCTION))(\s+)(\'?\S+\'?)', | 1509 (r'(CALL\s+(?:BADI|CUSTOMER-FUNCTION|FUNCTION))(\s+)(\'?\S+\'?)', |
| 1879 bygroups(Keyword, Text, Name.Function)), | 1510 bygroups(Keyword, Text, Name.Function)), |
| 1880 (r'(CALL\s+(?:DIALOG|SCREEN|SUBSCREEN|SELECTION-SCREEN|' | 1511 (r'(CALL\s+(?:DIALOG|SCREEN|SUBSCREEN|SELECTION-SCREEN|' |
| 1881 r'TRANSACTION|TRANSFORMATION))\b', | 1512 r'TRANSACTION|TRANSFORMATION))\b', |
| 1882 Keyword), | 1513 Keyword), |
| 1883 (r'(FORM|PERFORM)(\s+)([\w_]+)', | 1514 (r'(FORM|PERFORM)(\s+)(\w+)', |
| 1884 bygroups(Keyword, Text, Name.Function)), | 1515 bygroups(Keyword, Text, Name.Function)), |
| 1885 (r'(PERFORM)(\s+)(\()([\w_]+)(\))', | 1516 (r'(PERFORM)(\s+)(\()(\w+)(\))', |
| 1886 bygroups(Keyword, Text, Punctuation, Name.Variable, Punctuation )), | 1517 bygroups(Keyword, Text, Punctuation, Name.Variable, Punctuation )), |
| 1887 (r'(MODULE)(\s+)(\S+)(\s+)(INPUT|OUTPUT)', | 1518 (r'(MODULE)(\s+)(\S+)(\s+)(INPUT|OUTPUT)', |
| 1888 bygroups(Keyword, Text, Name.Function, Text, Keyword)), | 1519 bygroups(Keyword, Text, Name.Function, Text, Keyword)), |
| 1889 | 1520 |
| 1890 # method implementation | 1521 # method implementation |
| 1891 (r'(METHOD)(\s+)([\w_~]+)', | 1522 (r'(METHOD)(\s+)([\w~]+)', |
| 1892 bygroups(Keyword, Text, Name.Function)), | 1523 bygroups(Keyword, Text, Name.Function)), |
| 1893 # method calls | 1524 # method calls |
| 1894 (r'(\s+)([\w_\-]+)([=\-]>)([\w_\-~]+)', | 1525 (r'(\s+)([\w\-]+)([=\-]>)([\w\-~]+)', |
| 1895 bygroups(Text, Name.Variable, Operator, Name.Function)), | 1526 bygroups(Text, Name.Variable, Operator, Name.Function)), |
| 1896 # call methodnames returning style | 1527 # call methodnames returning style |
| 1897 (r'(?<=(=|-)>)([\w_\-~]+)(?=\()', Name.Function), | 1528 (r'(?<=(=|-)>)([\w\-~]+)(?=\()', Name.Function), |
| 1898 | 1529 |
| 1899 # keywords with dashes in them. | 1530 # keywords with dashes in them. |
| 1900 # these need to be first, because for instance the -ID part | 1531 # these need to be first, because for instance the -ID part |
| 1901 # of MESSAGE-ID wouldn't get highlighted if MESSAGE was | 1532 # of MESSAGE-ID wouldn't get highlighted if MESSAGE was |
| 1902 # first in the list of keywords. | 1533 # first in the list of keywords. |
| 2401 (r'\(', String, '#push'), | 2032 (r'\(', String, '#push'), |
| 2402 (r'\)', String, '#pop'), | 2033 (r'\)', String, '#pop'), |
| 2403 ], | 2034 ], |
| 2404 | 2035 |
| 2405 'escape': [ | 2036 'escape': [ |
| 2406 (r'([0-8]{3}|n|r|t|b|f|\\|\(|\)|)', String.Escape, '#pop'), | 2037 (r'([0-8]{3}|n|r|t|b|f|\\|\(|\))?', String.Escape, '#pop'), |
| 2407 ], | 2038 ], |
| 2408 } | 2039 } |
| 2409 | 2040 |
| 2410 | 2041 |
| 2411 class AutohotkeyLexer(RegexLexer): | 2042 class AutohotkeyLexer(RegexLexer): |
| 2417 name = 'autohotkey' | 2048 name = 'autohotkey' |
| 2418 aliases = ['ahk'] | 2049 aliases = ['ahk'] |
| 2419 filenames = ['*.ahk', '*.ahkl'] | 2050 filenames = ['*.ahk', '*.ahkl'] |
| 2420 mimetypes = ['text/x-autohotkey'] | 2051 mimetypes = ['text/x-autohotkey'] |
| 2421 | 2052 |
| 2422 flags = re.IGNORECASE | re.DOTALL | re.MULTILINE | |
| 2423 | |
| 2424 tokens = { | 2053 tokens = { |
| 2425 'root': [ | 2054 'root': [ |
| 2426 include('whitespace'), | 2055 (r'^(\s*)(/\*)', bygroups(Text, Comment.Multiline), |
| 2427 (r'^\(', String, 'continuation'), | 2056 'incomment'), |
| 2428 include('comments'), | 2057 (r'^(\s*)(\()', bygroups(Text, Generic), 'incontinuation'), |
| 2429 (r'(^\s*)(\w+)(\s*)(=)', | 2058 (r'\s+;.*?$', Comment.Singleline), |
| 2430 bygroups(Text.Whitespace, Name, Text.Whitespace, Operator), | 2059 (r'^;.*?$', Comment.Singleline), |
| 2431 'command'), | 2060 (r'[]{}(),;[]', Punctuation), |
| 2432 (r'([\w#@$?\[\]]+)(\s*)(\()', | 2061 (r'(in|is|and|or|not)\b', Operator.Word), |
| 2433 bygroups(Name.Function, Text.Whitespace, Punctuation), | 2062 (r'\%[a-zA-Z_#@$][a-zA-Z0-9_#@$]*\%', Name.Variable), |
| 2434 'parameters'), | 2063 (r'!=|==|:=|\.=|<<|>>|[-~+/*%=<>&^|?:!.]', Operator), |
| 2435 include('directives'), | 2064 include('commands'), |
| 2436 include('labels'), | 2065 include('labels'), |
| 2437 include('commands'), | 2066 include('builtInFunctions'), |
| 2438 include('expressions'), | 2067 include('builtInVariables'), |
| 2068 (r'"', String, combined('stringescape', 'dqs')), | |
| 2439 include('numbers'), | 2069 include('numbers'), |
| 2440 include('literals'), | 2070 (r'[a-zA-Z_#@$][a-zA-Z0-9_#@$]*', Name), |
| 2441 include('keynames'), | 2071 (r'\\|\'', Text), |
| 2442 include('keywords'), | 2072 (r'\`([\,\%\`abfnrtv\-\+;])', String.Escape), |
| 2443 ], | 2073 include('garbage'), |
| 2444 'command': [ | 2074 ], |
| 2445 include('comments'), | 2075 'incomment': [ |
| 2446 include('whitespace'), | 2076 (r'^\s*\*/', Comment.Multiline, '#pop'), |
| 2447 (r'^\(', String, 'continuation'), | 2077 (r'[^*/]', Comment.Multiline), |
| 2448 (r'[^\n]*?(?=;*|$)', String, '#pop'), | 2078 (r'[*/]', Comment.Multiline) |
| 2449 include('numbers'), | 2079 ], |
| 2450 include('literals'), | 2080 'incontinuation': [ |
| 2451 ], | 2081 (r'^\s*\)', Generic, '#pop'), |
| 2452 | 2082 (r'[^)]', Generic), |
| 2453 'expressions': [ | 2083 (r'[)]', Generic), |
| 2454 include('comments'), | 2084 ], |
| 2455 include('whitespace'), | 2085 'commands': [ |
| 2456 include('numbers'), | 2086 (r'(?i)^(\s*)(global|local|static|' |
| 2457 include('literals'), | 2087 r'#AllowSameLineComments|#ClipboardTimeout|#CommentFlag|' |
| 2458 (r'([]\w#@$?[]+)(\s*)(\()', | 2088 r'#ErrorStdOut|#EscapeChar|#HotkeyInterval|#HotkeyModifierTimeout|' |
| 2459 bygroups(Name.Function, Text.Whitespace, Punctuation), | 2089 r'#Hotstring|#IfWinActive|#IfWinExist|#IfWinNotActive|' |
| 2460 'parameters'), | 2090 r'#IfWinNotExist|#IncludeAgain|#Include|#InstallKeybdHook|' |
| 2461 (r'A_\w+', Name.Builtin), | 2091 r'#InstallMouseHook|#KeyHistory|#LTrim|#MaxHotkeysPerInterval|' |
| 2462 (r'%[]\w#@$?[]+?%', Name.Variable), | 2092 r'#MaxMem|#MaxThreads|#MaxThreadsBuffer|#MaxThreadsPerHotkey|' |
| 2463 # blocks: if, else, function definitions | 2093 r'#NoEnv|#NoTrayIcon|#Persistent|#SingleInstance|#UseHook|' |
| 2464 (r'{', Punctuation, 'block'), | 2094 r'#WinActivateForce|AutoTrim|BlockInput|Break|Click|ClipWait|' |
| 2465 # parameters in function calls | 2095 r'Continue|Control|ControlClick|ControlFocus|ControlGetFocus|' |
| 2466 ], | 2096 r'ControlGetPos|ControlGetText|ControlGet|ControlMove|ControlSend|' |
| 2467 'literals': [ | 2097 r'ControlSendRaw|ControlSetText|CoordMode|Critical|' |
| 2468 (r'"', String, 'string'), | 2098 r'DetectHiddenText|DetectHiddenWindows|Drive|DriveGet|' |
| 2469 (r'A_\w+', Name.Builtin), | 2099 r'DriveSpaceFree|Edit|Else|EnvAdd|EnvDiv|EnvGet|EnvMult|EnvSet|' |
| 2470 (r'%[]\w#@$?[]+?%', Name.Variable), | 2100 r'EnvSub|EnvUpdate|Exit|ExitApp|FileAppend|' |
| 2471 (r'[-~!%^&*+|?:<>/=]=?', Operator, 'expressions'), | 2101 r'FileCopy|FileCopyDir|FileCreateDir|FileCreateShortcut|' |
| 2472 (r'==', Operator, 'expressions'), | 2102 r'FileDelete|FileGetAttrib|FileGetShortcut|FileGetSize|' |
| 2473 ('[{()},.%#`;]', Punctuation), | 2103 r'FileGetTime|FileGetVersion|FileInstall|FileMove|FileMoveDir|' |
| 2474 (r'\\', Punctuation), | 2104 r'FileRead|FileReadLine|FileRecycle|FileRecycleEmpty|' |
| 2475 include('keywords'), | 2105 r'FileRemoveDir|FileSelectFile|FileSelectFolder|FileSetAttrib|' |
| 2476 (r'\w+', Text), | 2106 r'FileSetTime|FormatTime|GetKeyState|Gosub|Goto|GroupActivate|' |
| 2477 ], | 2107 r'GroupAdd|GroupClose|GroupDeactivate|Gui|GuiControl|' |
| 2478 'string': [ | 2108 r'GuiControlGet|Hotkey|IfEqual|IfExist|IfGreaterOrEqual|IfGreater|' |
| 2479 (r'"', String, '#pop'), | 2109 r'IfInString|IfLess|IfLessOrEqual|IfMsgBox|IfNotEqual|IfNotExist|' |
| 2480 (r'""|`.', String.Escape), | 2110 r'IfNotInString|IfWinActive|IfWinExist|IfWinNotActive|' |
| 2481 (r'[^\`"\n]+', String), # all other characters | 2111 r'IfWinNotExist|If |ImageSearch|IniDelete|IniRead|IniWrite|' |
| 2482 ], | 2112 r'InputBox|Input|KeyHistory|KeyWait|ListHotkeys|ListLines|' |
| 2483 'block': [ | 2113 r'ListVars|Loop|Menu|MouseClickDrag|MouseClick|MouseGetPos|' |
| 2484 include('root'), | 2114 r'MouseMove|MsgBox|OnExit|OutputDebug|Pause|PixelGetColor|' |
| 2485 ('{', Punctuation, '#push'), | 2115 r'PixelSearch|PostMessage|Process|Progress|Random|RegDelete|' |
| 2486 ('}', Punctuation, '#pop'), | 2116 r'RegRead|RegWrite|Reload|Repeat|Return|RunAs|RunWait|Run|' |
| 2487 ], | 2117 r'SendEvent|SendInput|SendMessage|SendMode|SendPlay|SendRaw|Send|' |
| 2488 'parameters': [ | 2118 r'SetBatchLines|SetCapslockState|SetControlDelay|' |
| 2489 (r'\)', Punctuation, '#pop'), | 2119 r'SetDefaultMouseSpeed|SetEnv|SetFormat|SetKeyDelay|' |
| 2490 (r'\(', Punctuation, '#push'), | 2120 r'SetMouseDelay|SetNumlockState|SetScrollLockState|' |
| 2491 include('numbers'), | 2121 r'SetStoreCapslockMode|SetTimer|SetTitleMatchMode|' |
| 2492 include('literals'), | 2122 r'SetWinDelay|SetWorkingDir|Shutdown|Sleep|Sort|SoundBeep|' |
| 2493 include('whitespace'), | 2123 r'SoundGet|SoundGetWaveVolume|SoundPlay|SoundSet|' |
| 2494 ], | 2124 r'SoundSetWaveVolume|SplashImage|SplashTextOff|SplashTextOn|' |
| 2495 'keywords': [ | 2125 r'SplitPath|StatusBarGetText|StatusBarWait|StringCaseSense|' |
| 2496 (r'(static|global|local)\b', Keyword.Type), | 2126 r'StringGetPos|StringLeft|StringLen|StringLower|StringMid|' |
| 2497 (r'(if|else|and|or)\b', Keyword.Reserved), | 2127 r'StringReplace|StringRight|StringSplit|StringTrimLeft|' |
| 2498 ], | 2128 r'StringTrimRight|StringUpper|Suspend|SysGet|Thread|ToolTip|' |
| 2499 'directives': [ | 2129 r'Transform|TrayTip|URLDownloadToFile|While|WinActivate|' |
| 2500 (r'#\w+?\s', Keyword), | 2130 r'WinActivateBottom|WinClose|WinGetActiveStats|WinGetActiveTitle|' |
| 2501 ], | 2131 r'WinGetClass|WinGetPos|WinGetText|WinGetTitle|WinGet|WinHide|' |
| 2132 r'WinKill|WinMaximize|WinMenuSelectItem|WinMinimizeAllUndo|' | |
| 2133 r'WinMinimizeAll|WinMinimize|WinMove|WinRestore|WinSetTitle|' | |
| 2134 r'WinSet|WinShow|WinWaitActive|WinWaitClose|WinWaitNotActive|' | |
| 2135 r'WinWait)\b', bygroups(Text, Name.Builtin)), | |
| 2136 ], | |
| 2137 'builtInFunctions': [ | |
| 2138 (r'(?i)(Abs|ACos|Asc|ASin|ATan|Ceil|Chr|Cos|DllCall|Exp|FileExist|' | |
| 2139 r'Floor|GetKeyState|IL_Add|IL_Create|IL_Destroy|InStr|IsFunc|' | |
| 2140 r'IsLabel|Ln|Log|LV_Add|LV_Delete|LV_DeleteCol|LV_GetCount|' | |
| 2141 r'LV_GetNext|LV_GetText|LV_Insert|LV_InsertCol|LV_Modify|' | |
| 2142 r'LV_ModifyCol|LV_SetImageList|Mod|NumGet|NumPut|OnMessage|' | |
| 2143 r'RegExMatch|RegExReplace|RegisterCallback|Round|SB_SetIcon|' | |
| 2144 r'SB_SetParts|SB_SetText|Sin|Sqrt|StrLen|SubStr|Tan|TV_Add|' | |
| 2145 r'TV_Delete|TV_GetChild|TV_GetCount|TV_GetNext|TV_Get|' | |
| 2146 r'TV_GetParent|TV_GetPrev|TV_GetSelection|TV_GetText|TV_Modify|' | |
| 2147 r'VarSetCapacity|WinActive|WinExist|Object|ComObjActive|' | |
| 2148 r'ComObjArray|ComObjEnwrap|ComObjUnwrap|ComObjParameter|' | |
| 2149 r'ComObjType|ComObjConnect|ComObjCreate|ComObjGet|ComObjError|' | |
| 2150 r'ComObjValue|Insert|MinIndex|MaxIndex|Remove|SetCapacity|' | |
| 2151 r'GetCapacity|GetAddress|_NewEnum|FileOpen|Read|Write|ReadLine|' | |
| 2152 r'WriteLine|ReadNumType|WriteNumType|RawRead|RawWrite|Seek|Tell|' | |
| 2153 r'Close|Next|IsObject|StrPut|StrGet|Trim|LTrim|RTrim)\b', | |
| 2154 Name.Function), | |
| 2155 ], | |
| 2156 'builtInVariables': [ | |
| 2157 (r'(?i)(A_AhkPath|A_AhkVersion|A_AppData|A_AppDataCommon|' | |
| 2158 r'A_AutoTrim|A_BatchLines|A_CaretX|A_CaretY|A_ComputerName|' | |
| 2159 r'A_ControlDelay|A_Cursor|A_DDDD|A_DDD|A_DD|A_DefaultMouseSpeed|' | |
| 2160 r'A_Desktop|A_DesktopCommon|A_DetectHiddenText|' | |
| 2161 r'A_DetectHiddenWindows|A_EndChar|A_EventInfo|A_ExitReason|' | |
| 2162 r'A_FormatFloat|A_FormatInteger|A_Gui|A_GuiEvent|A_GuiControl|' | |
| 2163 r'A_GuiControlEvent|A_GuiHeight|A_GuiWidth|A_GuiX|A_GuiY|A_Hour|' | |
| 2164 r'A_IconFile|A_IconHidden|A_IconNumber|A_IconTip|A_Index|' | |
| 2165 r'A_IPAddress1|A_IPAddress2|A_IPAddress3|A_IPAddress4|A_ISAdmin|' | |
| 2166 r'A_IsCompiled|A_IsCritical|A_IsPaused|A_IsSuspended|A_KeyDelay|' | |
| 2167 r'A_Language|A_LastError|A_LineFile|A_LineNumber|A_LoopField|' | |
| 2168 r'A_LoopFileAttrib|A_LoopFileDir|A_LoopFileExt|A_LoopFileFullPath|' | |
| 2169 r'A_LoopFileLongPath|A_LoopFileName|A_LoopFileShortName|' | |
| 2170 r'A_LoopFileShortPath|A_LoopFileSize|A_LoopFileSizeKB|' | |
| 2171 r'A_LoopFileSizeMB|A_LoopFileTimeAccessed|A_LoopFileTimeCreated|' | |
| 2172 r'A_LoopFileTimeModified|A_LoopReadLine|A_LoopRegKey|' | |
| 2173 r'A_LoopRegName|A_LoopRegSubkey|A_LoopRegTimeModified|' | |
| 2174 r'A_LoopRegType|A_MDAY|A_Min|A_MM|A_MMM|A_MMMM|A_Mon|A_MouseDelay|' | |
| 2175 r'A_MSec|A_MyDocuments|A_Now|A_NowUTC|A_NumBatchLines|A_OSType|' | |
| 2176 r'A_OSVersion|A_PriorHotkey|A_ProgramFiles|A_Programs|' | |
| 2177 r'A_ProgramsCommon|A_ScreenHeight|A_ScreenWidth|A_ScriptDir|' | |
| 2178 r'A_ScriptFullPath|A_ScriptName|A_Sec|A_Space|A_StartMenu|' | |
| 2179 r'A_StartMenuCommon|A_Startup|A_StartupCommon|A_StringCaseSense|' | |
| 2180 r'A_Tab|A_Temp|A_ThisFunc|A_ThisHotkey|A_ThisLabel|A_ThisMenu|' | |
| 2181 r'A_ThisMenuItem|A_ThisMenuItemPos|A_TickCount|A_TimeIdle|' | |
| 2182 r'A_TimeIdlePhysical|A_TimeSincePriorHotkey|A_TimeSinceThisHotkey|' | |
| 2183 r'A_TitleMatchMode|A_TitleMatchModeSpeed|A_UserName|A_WDay|' | |
| 2184 r'A_WinDelay|A_WinDir|A_WorkingDir|A_YDay|A_YEAR|A_YWeek|A_YYYY|' | |
| 2185 r'Clipboard|ClipboardAll|ComSpec|ErrorLevel|ProgramFiles|True|' | |
| 2186 r'False|A_IsUnicode|A_FileEncoding|A_OSVersion|A_PtrSize)\b', | |
| 2187 Name.Variable), | |
| 2188 ], | |
| 2502 'labels': [ | 2189 'labels': [ |
| 2503 # hotkeys and labels | 2190 # hotkeys and labels |
| 2504 # technically, hotkey names are limited to named keys and buttons | 2191 # technically, hotkey names are limited to named keys and buttons |
| 2505 (r'(^\s*)([^:\s]+?:{1,2})', bygroups(Text.Whitespace, Name.Label)), | 2192 (r'(^\s*)([^:\s\(\"]+?:{1,2})', bygroups(Text, Name.Label)), |
| 2506 # hotstrings | 2193 (r'(^\s*)(::[^:\s]+?::)', bygroups(Text, Name.Label)), |
| 2507 (r'(^\s*)(::[]\w#@$?[]+?::)', bygroups(Text.Whitespace, Name.Label)), | 2194 ], |
| 2508 ], | |
| 2509 'comments': [ | |
| 2510 (r'^;+.*?$', Comment.Single), # beginning of line comments | |
| 2511 (r'(?<=\s);+.*?$', Comment.Single), # end of line comments | |
| 2512 (r'^/\*.*?\n\*/', Comment.Multiline), | |
| 2513 (r'(?<!\n)/\*.*?\n\*/', Error), # must be at start of line | |
| 2514 ], | |
| 2515 'whitespace': [ | |
| 2516 (r'[ \t]+', Text.Whitespace), | |
| 2517 ], | |
| 2518 'numbers': [ | 2195 'numbers': [ |
| 2519 (r'(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?', Number.Float), | 2196 (r'(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?', Number.Float), |
| 2520 (r'\d+[eE][+-]?[0-9]+', Number.Float), | 2197 (r'\d+[eE][+-]?[0-9]+', Number.Float), |
| 2521 (r'0[0-7]+', Number.Oct), | 2198 (r'0\d+', Number.Oct), |
| 2522 (r'0[xX][a-fA-F0-9]+', Number.Hex), | 2199 (r'0[xX][a-fA-F0-9]+', Number.Hex), |
| 2523 (r'\d+L', Number.Integer.Long), | 2200 (r'\d+L', Number.Integer.Long), |
| 2524 (r'\d+', Number.Integer) | 2201 (r'\d+', Number.Integer) |
| 2525 ], | 2202 ], |
| 2526 'continuation': [ | 2203 'stringescape': [ |
| 2527 (r'\n\)', Punctuation, '#pop'), | 2204 (r'\"\"|\`([\,\%\`abfnrtv])', String.Escape), |
| 2528 (r'\s[^\n\)]+', String), | 2205 ], |
| 2529 ], | 2206 'strings': [ |
| 2530 'keynames': [ | 2207 (r'[^"\n]+', String), |
| 2531 (r'\[[^\]]+\]', Keyword, 'keynames') | 2208 ], |
| 2532 ], | 2209 'dqs': [ |
| 2533 'commands': [ | 2210 (r'"', String, '#pop'), |
| 2534 (r'(autotrim|blockinput|break|click|' | 2211 include('strings') |
| 2535 r'clipwait|continue|control|' | 2212 ], |
| 2536 r'controlclick|controlfocus|controlget|' | 2213 'garbage': [ |
| 2537 r'controlgetfocus|controlgetpos|controlgettext|' | 2214 (r'[^\S\n]', Text), |
| 2538 r'controlmove|controlsend|controlsendraw|' | 2215 # (r'.', Text), # no cheating |
| 2539 r'controlsettext|coordmode|critical|' | 2216 ], |
| 2540 r'detecthiddentext|detecthiddenwindows|' | 2217 } |
| 2541 r'dllcall|drive|' | 2218 |
| 2542 r'driveget|drivespacefree|' | |
| 2543 r'else|envadd|envdiv|' | |
| 2544 r'envget|envmult|envset|' | |
| 2545 r'envsub|envupdate|exit|' | |
| 2546 r'exitapp|fileappend|filecopy|' | |
| 2547 r'filecopydir|filecreatedir|filecreateshortcut|' | |
| 2548 r'filedelete|filegetattrib|filegetshortcut|' | |
| 2549 r'filegetsize|filegettime|filegetversion|' | |
| 2550 r'fileinstall|filemove|filemovedir|' | |
| 2551 r'fileread|filereadline|filerecycle|' | |
| 2552 r'filerecycleempty|fileremovedir|fileselectfile|' | |
| 2553 r'fileselectfolder|filesetattrib|filesettime|' | |
| 2554 r'formattime|gosub|' | |
| 2555 r'goto|groupactivate|groupadd|' | |
| 2556 r'groupclose|groupdeactivate|gui|' | |
| 2557 r'guicontrol|guicontrolget|hotkey|' | |
| 2558 r'ifexist|ifgreater|ifgreaterorequal|' | |
| 2559 r'ifinstring|ifless|iflessorequal|' | |
| 2560 r'ifmsgbox|ifnotequal|ifnotexist|' | |
| 2561 r'ifnotinstring|ifwinactive|ifwinexist|' | |
| 2562 r'ifwinnotactive|ifwinnotexist|imagesearch|' | |
| 2563 r'inidelete|iniread|iniwrite|' | |
| 2564 r'input|inputbox|keyhistory|' | |
| 2565 r'keywait|listhotkeys|listlines|' | |
| 2566 r'listvars|loop|' | |
| 2567 r'menu|mouseclick|mouseclickdrag|' | |
| 2568 r'mousegetpos|mousemove|msgbox|' | |
| 2569 r'onmessage|onexit|outputdebug|' | |
| 2570 r'pixelgetcolor|pixelsearch|postmessage|' | |
| 2571 r'process|progress|random|' | |
| 2572 r'regexmatch|regexreplace|registercallback|' | |
| 2573 r'regdelete|regread|regwrite|' | |
| 2574 r'reload|repeat|return|' | |
| 2575 r'run|runas|runwait|' | |
| 2576 r'send|sendevent|sendinput|' | |
| 2577 r'sendmessage|sendmode|sendplay|' | |
| 2578 r'sendraw|setbatchlines|setcapslockstate|' | |
| 2579 r'setcontroldelay|setdefaultmousespeed|setenv|' | |
| 2580 r'setformat|setkeydelay|setmousedelay|' | |
| 2581 r'setnumlockstate|setscrolllockstate|' | |
| 2582 r'setstorecapslockmode|' | |
| 2583 r'settimer|settitlematchmode|setwindelay|' | |
| 2584 r'setworkingdir|shutdown|sleep|' | |
| 2585 r'sort|soundbeep|soundget|' | |
| 2586 r'soundgetwavevolume|soundplay|soundset|' | |
| 2587 r'soundsetwavevolume|splashimage|splashtextoff|' | |
| 2588 r'splashtexton|splitpath|statusbargettext|' | |
| 2589 r'statusbarwait|stringcasesense|stringgetpos|' | |
| 2590 r'stringleft|stringlen|stringlower|' | |
| 2591 r'stringmid|stringreplace|stringright|' | |
| 2592 r'stringsplit|stringtrimleft|stringtrimright|' | |
| 2593 r'stringupper|suspend|sysget|' | |
| 2594 r'thread|tooltip|transform|' | |
| 2595 r'traytip|urldownloadtofile|while|' | |
| 2596 r'varsetcapacity|' | |
| 2597 r'winactivate|winactivatebottom|winclose|' | |
| 2598 r'winget|wingetactivestats|wingetactivetitle|' | |
| 2599 r'wingetclass|wingetpos|wingettext|' | |
| 2600 r'wingettitle|winhide|winkill|' | |
| 2601 r'winmaximize|winmenuselectitem|winminimize|' | |
| 2602 r'winminimizeall|winminimizeallundo|winmove|' | |
| 2603 r'winrestore|winset|winsettitle|' | |
| 2604 r'winshow|winwait|winwaitactive|' | |
| 2605 r'winwaitclose|winwaitnotactive' | |
| 2606 r'true|false|NULL)\b', Keyword, 'command'), | |
| 2607 ], | |
| 2608 | |
| 2609 } | |
| 2610 | 2219 |
| 2611 class MaqlLexer(RegexLexer): | 2220 class MaqlLexer(RegexLexer): |
| 2612 """ | 2221 """ |
| 2613 Lexer for `GoodData MAQL <https://secure.gooddata.com/docs/html/advanced.metric.tutorial.html>`_ | 2222 Lexer for `GoodData MAQL |
| 2223 <https://secure.gooddata.com/docs/html/advanced.metric.tutorial.html>`_ | |
| 2614 scripts. | 2224 scripts. |
| 2615 | 2225 |
| 2616 *New in Pygments 1.4.* | 2226 *New in Pygments 1.4.* |
| 2617 """ | 2227 """ |
| 2618 | 2228 |
| 2782 tokens = { | 2392 tokens = { |
| 2783 'root': [ | 2393 'root': [ |
| 2784 # method names | 2394 # method names |
| 2785 (r'^(\s*(?:function|method|operator\s+)+?)' | 2395 (r'^(\s*(?:function|method|operator\s+)+?)' |
| 2786 r'([a-zA-Z_][a-zA-Z0-9_]*)' | 2396 r'([a-zA-Z_][a-zA-Z0-9_]*)' |
| 2787 r'(\s*)(\()', bygroups(Name.Function, Text, Operator)), | 2397 r'(\s*)(\()', bygroups(Keyword, Name.Function, Text, Operator)), |
| 2788 (r'[^\S\n]+', Text), | 2398 (r'[^\S\n]+', Text), |
| 2789 (r'//.*?\n', Comment.Single), | 2399 (r'//.*?\n', Comment.Single), |
| 2790 (r'/\*.*?\*/', Comment.Multiline), | 2400 (r'/\*.*?\*/', Comment.Multiline), |
| 2791 (r'@[a-zA-Z_][a-zA-Z0-9_\.]*', Name.Decorator), | 2401 (r'@[a-zA-Z_][a-zA-Z0-9_\.]*', Name.Decorator), |
| 2792 (r'(break|case|catch|next|default|do|else|finally|for|foreach|of|' | 2402 (r'(break|case|catch|next|default|do|else|finally|for|foreach|of|' |
| 2839 ], | 2449 ], |
| 2840 'import': [ | 2450 'import': [ |
| 2841 (r'[a-zA-Z0-9_.]+\*?', Name.Namespace, '#pop') | 2451 (r'[a-zA-Z0-9_.]+\*?', Name.Namespace, '#pop') |
| 2842 ], | 2452 ], |
| 2843 } | 2453 } |
| 2454 | |
| 2455 | |
| 2456 class AwkLexer(RegexLexer): | |
| 2457 """ | |
| 2458 For Awk scripts. | |
| 2459 | |
| 2460 *New in Pygments 1.5.* | |
| 2461 """ | |
| 2462 | |
| 2463 name = 'Awk' | |
| 2464 aliases = ['awk', 'gawk', 'mawk', 'nawk'] | |
| 2465 filenames = ['*.awk'] | |
| 2466 mimetypes = ['application/x-awk'] | |
| 2467 | |
| 2468 tokens = { | |
| 2469 'commentsandwhitespace': [ | |
| 2470 (r'\s+', Text), | |
| 2471 (r'#.*$', Comment.Single) | |
| 2472 ], | |
| 2473 'slashstartsregex': [ | |
| 2474 include('commentsandwhitespace'), | |
| 2475 (r'/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/' | |
| 2476 r'\B', String.Regex, '#pop'), | |
| 2477 (r'(?=/)', Text, ('#pop', 'badregex')), | |
| 2478 (r'', Text, '#pop') | |
| 2479 ], | |
| 2480 'badregex': [ | |
| 2481 (r'\n', Text, '#pop') | |
| 2482 ], | |
| 2483 'root': [ | |
| 2484 (r'^(?=\s|/)', Text, 'slashstartsregex'), | |
| 2485 include('commentsandwhitespace'), | |
| 2486 (r'\+\+|--|\|\||&&|in|\$|!?~|' | |
| 2487 r'(\*\*|[-<>+*%\^/!=])=?', Operator, 'slashstartsregex'), | |
| 2488 (r'[{(\[;,]', Punctuation, 'slashstartsregex'), | |
| 2489 (r'[})\].]', Punctuation), | |
| 2490 (r'(break|continue|do|while|exit|for|if|' | |
| 2491 r'return)\b', Keyword, 'slashstartsregex'), | |
| 2492 (r'function\b', Keyword.Declaration, 'slashstartsregex'), | |
| 2493 (r'(atan2|cos|exp|int|log|rand|sin|sqrt|srand|gensub|gsub|index|' | |
| 2494 r'length|match|split|sprintf|sub|substr|tolower|toupper|close|' | |
| 2495 r'fflush|getline|next|nextfile|print|printf|strftime|systime|' | |
| 2496 r'delete|system)\b', Keyword.Reserved), | |
| 2497 (r'(ARGC|ARGIND|ARGV|CONVFMT|ENVIRON|ERRNO|FIELDWIDTHS|FILENAME|FNR|FS|' | |
| 2498 r'IGNORECASE|NF|NR|OFMT|OFS|ORFS|RLENGTH|RS|RSTART|RT|' | |
| 2499 r'SUBSEP)\b', Name.Builtin), | |
| 2500 (r'[$a-zA-Z_][a-zA-Z0-9_]*', Name.Other), | |
| 2501 (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float), | |
| 2502 (r'0x[0-9a-fA-F]+', Number.Hex), | |
| 2503 (r'[0-9]+', Number.Integer), | |
| 2504 (r'"(\\\\|\\"|[^"])*"', String.Double), | |
| 2505 (r"'(\\\\|\\'|[^'])*'", String.Single), | |
| 2506 ] | |
| 2507 } | |
| 2508 | |
| 2509 | |
| 2510 class Cfengine3Lexer(RegexLexer): | |
| 2511 """ | |
| 2512 Lexer for `CFEngine3 <http://cfengine.org>`_ policy files. | |
| 2513 | |
| 2514 *New in Pygments 1.5.* | |
| 2515 """ | |
| 2516 | |
| 2517 name = 'CFEngine3' | |
| 2518 aliases = ['cfengine3', 'cf3'] | |
| 2519 filenames = ['*.cf'] | |
| 2520 mimetypes = [] | |
| 2521 | |
| 2522 tokens = { | |
| 2523 'root': [ | |
| 2524 (r'#.*?\n', Comment), | |
| 2525 (r'(body)(\s+)(\S+)(\s+)(control)', | |
| 2526 bygroups(Keyword, Text, Keyword, Text, Keyword)), | |
| 2527 (r'(body|bundle)(\s+)(\S+)(\s+)(\w+)(\()', | |
| 2528 bygroups(Keyword, Text, Keyword, Text, Name.Function, Punctuation), | |
| 2529 'arglist'), | |
| 2530 (r'(body|bundle)(\s+)(\S+)(\s+)(\w+)', | |
| 2531 bygroups(Keyword, Text, Keyword, Text, Name.Function)), | |
| 2532 (r'(")([^"]+)(")(\s+)(string|slist|int|real)(\s*)(=>)(\s*)', | |
| 2533 bygroups(Punctuation,Name.Variable,Punctuation, | |
| 2534 Text,Keyword.Type,Text,Operator,Text)), | |
| 2535 (r'(\S+)(\s*)(=>)(\s*)', | |
| 2536 bygroups(Keyword.Reserved,Text,Operator,Text)), | |
| 2537 (r'"', String, 'string'), | |
| 2538 (r'(\w+)(\()', bygroups(Name.Function, Punctuation)), | |
| 2539 (r'([\w.!&|\(\)]+)(::)', bygroups(Name.Class, Punctuation)), | |
| 2540 (r'(\w+)(:)', bygroups(Keyword.Declaration,Punctuation)), | |
| 2541 (r'@[\{\(][^\)\}]+[\}\)]', Name.Variable), | |
| 2542 (r'[(){},;]', Punctuation), | |
| 2543 (r'=>', Operator), | |
| 2544 (r'->', Operator), | |
| 2545 (r'\d+\.\d+', Number.Float), | |
| 2546 (r'\d+', Number.Integer), | |
| 2547 (r'\w+', Name.Function), | |
| 2548 (r'\s+', Text), | |
| 2549 ], | |
| 2550 'string': [ | |
| 2551 (r'\$[\{\(]', String.Interpol, 'interpol'), | |
| 2552 (r'\\.', String.Escape), | |
| 2553 (r'"', String, '#pop'), | |
| 2554 (r'\n', String), | |
| 2555 (r'.', String), | |
| 2556 ], | |
| 2557 'interpol': [ | |
| 2558 (r'\$[\{\(]', String.Interpol, '#push'), | |
| 2559 (r'[\}\)]', String.Interpol, '#pop'), | |
| 2560 (r'[^\$\{\(\)\}]+', String.Interpol), | |
| 2561 ], | |
| 2562 'arglist': [ | |
| 2563 (r'\)', Punctuation, '#pop'), | |
| 2564 (r',', Punctuation), | |
| 2565 (r'\w+', Name.Variable), | |
| 2566 (r'\s+', Text), | |
| 2567 ], | |
| 2568 } | |
| 2569 | |
| 2570 | |
| 2571 class SnobolLexer(RegexLexer): | |
| 2572 """ | |
| 2573 Lexer for the SNOBOL4 programming language. | |
| 2574 | |
| 2575 Recognizes the common ASCII equivalents of the original SNOBOL4 operators. | |
| 2576 Does not require spaces around binary operators. | |
| 2577 | |
| 2578 *New in Pygments 1.5.* | |
| 2579 """ | |
| 2580 | |
| 2581 name = "Snobol" | |
| 2582 aliases = ["snobol"] | |
| 2583 filenames = ['*.snobol'] | |
| 2584 mimetypes = ['text/x-snobol'] | |
| 2585 | |
| 2586 tokens = { | |
| 2587 # root state, start of line | |
| 2588 # comments, continuation lines, and directives start in column 1 | |
| 2589 # as do labels | |
| 2590 'root': [ | |
| 2591 (r'\*.*\n', Comment), | |
| 2592 (r'[\+\.] ', Punctuation, 'statement'), | |
| 2593 (r'-.*\n', Comment), | |
| 2594 (r'END\s*\n', Name.Label, 'heredoc'), | |
| 2595 (r'[A-Za-z\$][\w$]*', Name.Label, 'statement'), | |
| 2596 (r'\s+', Text, 'statement'), | |
| 2597 ], | |
| 2598 # statement state, line after continuation or label | |
| 2599 'statement': [ | |
| 2600 (r'\s*\n', Text, '#pop'), | |
| 2601 (r'\s+', Text), | |
| 2602 (r'(?<=[^\w.])(LT|LE|EQ|NE|GE|GT|INTEGER|IDENT|DIFFER|LGT|SIZE|' | |
| 2603 r'REPLACE|TRIM|DUPL|REMDR|DATE|TIME|EVAL|APPLY|OPSYN|LOAD|UNLOAD|' | |
| 2604 r'LEN|SPAN|BREAK|ANY|NOTANY|TAB|RTAB|REM|POS|RPOS|FAIL|FENCE|' | |
| 2605 r'ABORT|ARB|ARBNO|BAL|SUCCEED|INPUT|OUTPUT|TERMINAL)(?=[^\w.])', | |
| 2606 Name.Builtin), | |
| 2607 (r'[A-Za-z][\w\.]*', Name), | |
| 2608 # ASCII equivalents of original operators | |
| 2609 # | for the EBCDIC equivalent, ! likewise | |
| 2610 # \ for EBCDIC negation | |
| 2611 (r'\*\*|[\?\$\.!%\*/#+\-@\|&\\=]', Operator), | |
| 2612 (r'"[^"]*"', String), | |
| 2613 (r"'[^']*'", String), | |
| 2614 # Accept SPITBOL syntax for real numbers | |
| 2615 # as well as Macro SNOBOL4 | |
| 2616 (r'[0-9]+(?=[^\.EeDd])', Number.Integer), | |
| 2617 (r'[0-9]+(\.[0-9]*)?([EDed][-+]?[0-9]+)?', Number.Float), | |
| 2618 # Goto | |
| 2619 (r':', Punctuation, 'goto'), | |
| 2620 (r'[\(\)<>,;]', Punctuation), | |
| 2621 ], | |
| 2622 # Goto block | |
| 2623 'goto': [ | |
| 2624 (r'\s*\n', Text, "#pop:2"), | |
| 2625 (r'\s+', Text), | |
| 2626 (r'F|S', Keyword), | |
| 2627 (r'(\()([A-Za-z][\w.]*)(\))', | |
| 2628 bygroups(Punctuation, Name.Label, Punctuation)) | |
| 2629 ], | |
| 2630 # everything after the END statement is basically one | |
| 2631 # big heredoc. | |
| 2632 'heredoc': [ | |
| 2633 (r'.*\n', String.Heredoc) | |
| 2634 ] | |
| 2635 } | |
| 2636 | |
| 2637 | |
| 2638 class UrbiscriptLexer(ExtendedRegexLexer): | |
| 2639 """ | |
| 2640 For UrbiScript source code. | |
| 2641 | |
| 2642 *New in Pygments 1.5.* | |
| 2643 """ | |
| 2644 | |
| 2645 name = 'UrbiScript' | |
| 2646 aliases = ['urbiscript'] | |
| 2647 filenames = ['*.u'] | |
| 2648 mimetypes = ['application/x-urbiscript'] | |
| 2649 | |
| 2650 flags = re.DOTALL | |
| 2651 | |
| 2652 ## TODO | |
| 2653 # - handle Experimental and deprecated tags with specific tokens | |
| 2654 # - handle Angles and Durations with specific tokens | |
| 2655 | |
| 2656 def blob_callback(lexer, match, ctx): | |
| 2657 text_before_blob = match.group(1) | |
| 2658 blob_start = match.group(2) | |
| 2659 blob_size_str = match.group(3) | |
| 2660 blob_size = int(blob_size_str) | |
| 2661 yield match.start(), String, text_before_blob | |
| 2662 ctx.pos += len(text_before_blob) | |
| 2663 | |
| 2664 # if blob size doesn't match blob format (example : "\B(2)(aaa)") | |
| 2665 # yield blob as a string | |
| 2666 if ctx.text[match.end() + blob_size] != ")": | |
| 2667 result = "\\B(" + blob_size_str + ")(" | |
| 2668 yield match.start(), String, result | |
| 2669 ctx.pos += len(result) | |
| 2670 return | |
| 2671 | |
| 2672 # if blob is well formated, yield as Escape | |
| 2673 blob_text = blob_start + ctx.text[match.end():match.end()+blob_size] + ")" | |
| 2674 yield match.start(), String.Escape, blob_text | |
| 2675 ctx.pos = match.end() + blob_size + 1 # +1 is the ending ")" | |
| 2676 | |
| 2677 tokens = { | |
| 2678 'root': [ | |
| 2679 (r'\s+', Text), | |
| 2680 # comments | |
| 2681 (r'//.*?\n', Comment), | |
| 2682 (r'/\*', Comment.Multiline, 'comment'), | |
| 2683 (r'(?:every|for|loop|while)(?:;|&|\||,)',Keyword), | |
| 2684 (r'(?:assert|at|break|case|catch|closure|compl|continue|' | |
| 2685 r'default|else|enum|every|external|finally|for|freezeif|if|new|' | |
| 2686 r'onleave|return|stopif|switch|this|throw|timeout|try|' | |
| 2687 r'waituntil|whenever|while)\b', Keyword), | |
| 2688 (r'(?:asm|auto|bool|char|const_cast|delete|double|dynamic_cast|' | |
| 2689 r'explicit|export|extern|float|friend|goto|inline|int|' | |
| 2690 r'long|mutable|namespace|register|reinterpret_cast|short|' | |
| 2691 r'signed|sizeof|static_cast|struct|template|typedef|typeid|' | |
| 2692 r'typename|union|unsigned|using|virtual|volatile|' | |
| 2693 r'wchar_t)\b', Keyword.Reserved), | |
| 2694 # deprecated keywords, use a meaningfull token when available | |
| 2695 (r'(?:emit|foreach|internal|loopn|static)\b', Keyword), | |
| 2696 # ignored keywords, use a meaningfull token when available | |
| 2697 (r'(?:private|protected|public)\b', Keyword), | |
| 2698 (r'(?:var|do|const|function|class)\b', Keyword.Declaration), | |
| 2699 (r'(?:true|false|nil|void)\b', Keyword.Constant), | |
| 2700 (r'(?:Barrier|Binary|Boolean|CallMessage|Channel|Code|' | |
| 2701 r'Comparable|Container|Control|Date|Dictionary|Directory|' | |
| 2702 r'Duration|Enumeration|Event|Exception|Executable|File|Finalizable|' | |
| 2703 r'Float|FormatInfo|Formatter|Global|Group|Hash|InputStream|' | |
| 2704 r'IoService|Job|Kernel|Lazy|List|Loadable|Lobby|Location|Logger|Math|' | |
| 2705 r'Mutex|nil|Object|Orderable|OutputStream|Pair|Path|Pattern|Position|' | |
| 2706 r'Primitive|Process|Profile|PseudoLazy|PubSub|RangeIterable|Regexp|' | |
| 2707 r'Semaphore|Server|Singleton|Socket|StackFrame|Stream|String|System|' | |
| 2708 r'Tag|Timeout|Traceable|TrajectoryGenerator|Triplet|Tuple' | |
| 2709 r'|UObject|UValue|UVar)\b', Name.Builtin), | |
| 2710 (r'(?:this)\b', Name.Builtin.Pseudo), | |
| 2711 # don't match single | and & | |
| 2712 (r'(?:[-=+*%/<>~^:]+|\.&?|\|\||&&)', Operator), | |
| 2713 (r'(?:and_eq|and|bitand|bitor|in|not|not_eq|or_eq|or|xor_eq|xor)\b', | |
| 2714 Operator.Word), | |
| 2715 (r'[{}\[\]()]+', Punctuation), | |
| 2716 (r'(?:;|\||,|&|\?|!)+', Punctuation), | |
| 2717 (r'[$a-zA-Z_][a-zA-Z0-9_]*', Name.Other), | |
| 2718 (r'0x[0-9a-fA-F]+', Number.Hex), | |
| 2719 # Float, Integer, Angle and Duration | |
| 2720 (r'(?:[0-9]+(?:(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?)?' | |
| 2721 r'((?:rad|deg|grad)|(?:ms|s|min|h|d))?)\b', Number.Float), | |
| 2722 # handle binary blob in strings | |
| 2723 (r'"', String.Double, "string.double"), | |
| 2724 (r"'", String.Single, "string.single"), | |
| 2725 ], | |
| 2726 'string.double': [ | |
| 2727 (r'((?:\\\\|\\"|[^"])*?)(\\B\((\d+)\)\()', blob_callback), | |
| 2728 (r'(\\\\|\\"|[^"])*?"', String.Double, '#pop'), | |
| 2729 ], | |
| 2730 'string.single': [ | |
| 2731 (r"((?:\\\\|\\'|[^'])*?)(\\B\((\d+)\)\()", blob_callback), | |
| 2732 (r"(\\\\|\\'|[^'])*?'", String.Single, '#pop'), | |
| 2733 ], | |
| 2734 # from http://pygments.org/docs/lexerdevelopment/#changing-states | |
| 2735 'comment': [ | |
| 2736 (r'[^*/]', Comment.Multiline), | |
| 2737 (r'/\*', Comment.Multiline, '#push'), | |
| 2738 (r'\*/', Comment.Multiline, '#pop'), | |
| 2739 (r'[*/]', Comment.Multiline), | |
| 2740 ] | |
| 2741 } | |
| 2742 | |
| 2743 | |
| 2744 class OpenEdgeLexer(RegexLexer): | |
| 2745 """ | |
| 2746 Lexer for `OpenEdge ABL (formerly Progress) | |
| 2747 <http://web.progress.com/en/openedge/abl.html>`_ source code. | |
| 2748 | |
| 2749 *New in Pygments 1.5.* | |
| 2750 """ | |
| 2751 name = 'OpenEdge ABL' | |
| 2752 aliases = ['openedge', 'abl', 'progress'] | |
| 2753 filenames = ['*.p', '*.cls'] | |
| 2754 mimetypes = ['text/x-openedge', 'application/x-openedge'] | |
| 2755 | |
| 2756 types = (r'(?i)(^|(?<=[^0-9a-z_\-]))(CHARACTER|CHAR|CHARA|CHARAC|CHARACT|CHARACTE|' | |
| 2757 r'COM-HANDLE|DATE|DATETIME|DATETIME-TZ|' | |
| 2758 r'DECIMAL|DEC|DECI|DECIM|DECIMA|HANDLE|' | |
| 2759 r'INT64|INTEGER|INT|INTE|INTEG|INTEGE|' | |
| 2760 r'LOGICAL|LONGCHAR|MEMPTR|RAW|RECID|ROWID)\s*($|(?=[^0-9a-z_\-]))') | |
| 2761 | |
| 2762 keywords = (r'(?i)(^|(?<=[^0-9a-z_\-]))(ABSOLUTE|ABS|ABSO|ABSOL|ABSOLU|ABSOLUT|ACCELERATOR|' | |
| 2763 r'ACCUM|ACCUMULATE|ACCUM|ACCUMU|ACCUMUL|ACCUMULA|ACCUMULAT|' | |
| 2764 r'ACTIVE-FORM|ACTIVE-WINDOW|ADD|ADD-BUFFER|' | |
| 2765 r'ADD-CALC-COLUMN|ADD-COLUMNS-FROM|ADD-EVENTS-PROCEDURE|' | |
| 2766 r'ADD-FIELDS-FROM|ADD-FIRST|ADD-INDEX-FIELD|ADD-LAST|' | |
| 2767 r'ADD-LIKE-COLUMN|ADD-LIKE-FIELD|ADD-LIKE-INDEX|' | |
| 2768 r'ADD-NEW-FIELD|ADD-NEW-INDEX|ADD-SCHEMA-LOCATION|ADD-SUPER-PROCEDURE|' | |
| 2769 r'ADM-DATA|ADVISE|ALERT-BOX|ALIAS|ALL|ALLOW-COLUMN-SEARCHING|' | |
| 2770 r'ALLOW-REPLICATION|ALTER|ALWAYS-ON-TOP|AMBIGUOUS|AMBIG|AMBIGU|AMBIGUO|AMBIGUOU|' | |
| 2771 r'ANALYZE|ANALYZ|AND|ANSI-ONLY|ANY|ANYWHERE|APPEND|APPL-ALERT-BOXES|' | |
| 2772 r'APPL-ALERT|APPL-ALERT-|APPL-ALERT-B|APPL-ALERT-BO|APPL-ALERT-BOX|APPL-ALERT-BOXE|' | |
| 2773 r'APPL-CONTEXT-ID|APPLICATION|APPLY|APPSERVER-INFO|APPSERVER-PASSWORD|' | |
| 2774 r'APPSERVER-USERID|ARRAY-MESSAGE|AS|ASC|ASCENDING|ASCE|ASCEN|' | |
| 2775 r'ASCEND|ASCENDI|ASCENDIN|ASK-OVERWRITE|ASSEMBLY|ASSIGN|' | |
| 2776 r'ASYNCHRONOUS|ASYNC-REQUEST-COUNT|ASYNC-REQUEST-HANDLE|AT|' | |
| 2777 r'ATTACHED-PAIRLIST|ATTR-SPACE|ATTR|ATTRI|ATTRIB|ATTRIBU|ATTRIBUT|' | |
| 2778 r'AUDIT-CONTROL|AUDIT-ENABLED|AUDIT-EVENT-CONTEXT|AUDIT-POLICY|' | |
| 2779 r'AUTHENTICATION-FAILED|AUTHORIZATION|AUTO-COMPLETION|AUTO-COMP|' | |
| 2780 r'AUTO-COMPL|AUTO-COMPLE|AUTO-COMPLET|AUTO-COMPLETI|AUTO-COMPLETIO|' | |
| 2781 r'AUTO-ENDKEY|AUTO-END-KEY|AUTO-GO|AUTO-INDENT|AUTO-IND|' | |
| 2782 r'AUTO-INDE|AUTO-INDEN|AUTOMATIC|AUTO-RESIZE|AUTO-RETURN|AUTO-RET|' | |
| 2783 r'AUTO-RETU|AUTO-RETUR|AUTO-SYNCHRONIZE|AUTO-ZAP|AUTO-Z|AUTO-ZA|' | |
| 2784 r'AVAILABLE|AVAIL|AVAILA|AVAILAB|AVAILABL|AVAILABLE-FORMATS|' | |
| 2785 r'AVERAGE|AVE|AVER|AVERA|AVERAG|AVG|BACKGROUND|BACK|BACKG|' | |
| 2786 r'BACKGR|BACKGRO|BACKGROU|BACKGROUN|BACKWARDS|BACKWARD|' | |
| 2787 r'BASE64-DECODE|BASE64-ENCODE|BASE-ADE|BASE-KEY|BATCH-MODE|BATCH|' | |
| 2788 r'BATCH-|BATCH-M|BATCH-MO|BATCH-MOD|BATCH-SIZE|BEFORE-HIDE|BEFORE-H|' | |
| 2789 r'BEFORE-HI|BEFORE-HID|BEGIN-EVENT-GROUP|BEGINS|BELL|BETWEEN|' | |
| 2790 r'BGCOLOR|BGC|BGCO|BGCOL|BGCOLO|BIG-ENDIAN|BINARY|BIND|BIND-WHERE|' | |
| 2791 r'BLANK|BLOCK-ITERATION-DISPLAY|BORDER-BOTTOM-CHARS|BORDER-B|' | |
| 2792 r'BORDER-BO|BORDER-BOT|BORDER-BOTT|BORDER-BOTTO|BORDER-BOTTOM-PIXELS|' | |
| 2793 r'BORDER-BOTTOM-P|BORDER-BOTTOM-PI|BORDER-BOTTOM-PIX|' | |
| 2794 r'BORDER-BOTTOM-PIXE|BORDER-BOTTOM-PIXEL|BORDER-LEFT-CHARS|BORDER-L|' | |
| 2795 r'BORDER-LE|BORDER-LEF|BORDER-LEFT|BORDER-LEFT-|BORDER-LEFT-C|' | |
| 2796 r'BORDER-LEFT-CH|BORDER-LEFT-CHA|BORDER-LEFT-CHAR|BORDER-LEFT-PIXELS|' | |
| 2797 r'BORDER-LEFT-P|BORDER-LEFT-PI|BORDER-LEFT-PIX|BORDER-LEFT-PIXE|' | |
| 2798 r'BORDER-LEFT-PIXEL|BORDER-RIGHT-CHARS|BORDER-R|BORDER-RI|BORDER-RIG|' | |
| 2799 r'BORDER-RIGH|BORDER-RIGHT|BORDER-RIGHT-|BORDER-RIGHT-C|BORDER-RIGHT-CH|' | |
| 2800 r'BORDER-RIGHT-CHA|BORDER-RIGHT-CHAR|BORDER-RIGHT-PIXELS|BORDER-RIGHT-P|' | |
| 2801 r'BORDER-RIGHT-PI|BORDER-RIGHT-PIX|BORDER-RIGHT-PIXE|BORDER-RIGHT-PIXEL|' | |
| 2802 r'BORDER-TOP-CHARS|BORDER-T|BORDER-TO|BORDER-TOP|BORDER-TOP-|BORDER-TOP-C|' | |
| 2803 r'BORDER-TOP-CH|BORDER-TOP-CHA|BORDER-TOP-CHAR|BORDER-TOP-PIXELS|' | |
| 2804 r'BORDER-TOP-P|BORDER-TOP-PI|BORDER-TOP-PIX|BORDER-TOP-PIXE|BORDER-TOP-PIXEL|' | |
| 2805 r'BOX|BOX-SELECTABLE|BOX-SELECT|BOX-SELECTA|BOX-SELECTAB|BOX-SELECTABL|' | |
| 2806 r'BREAK|BROWSE|BUFFER|BUFFER-CHARS|BUFFER-COMPARE|BUFFER-COPY|BUFFER-CREATE|' | |
| 2807 r'BUFFER-DELETE|BUFFER-FIELD|BUFFER-HANDLE|BUFFER-LINES|BUFFER-NAME|' | |
| 2808 r'BUFFER-RELEASE|BUFFER-VALUE|BUTTON|BUTTONS|BUTTON|BY|BY-POINTER|' | |
| 2809 r'BY-VARIANT-POINTER|CACHE|CACHE-SIZE|CALL|CALL-NAME|CALL-TYPE|CANCEL-BREAK|' | |
| 2810 r'CANCEL-BUTTON|CAN-CREATE|CAN-DELETE|CAN-DO|CAN-FIND|CAN-QUERY|CAN-READ|' | |
| 2811 r'CAN-SET|CAN-WRITE|CAPS|CAREFUL-PAINT|CASE|CASE-SENSITIVE|CASE-SEN|' | |
| 2812 r'CASE-SENS|CASE-SENSI|CASE-SENSIT|CASE-SENSITI|CASE-SENSITIV|' | |
| 2813 r'CAST|CATCH|CDECL|CENTERED|CENTER|CENTERE|CHAINED|CHARACTER_LENGTH|' | |
| 2814 r'CHARSET|CHECK|CHECKED|CHOOSE|CHR|CLASS|CLASS-TYPE|CLEAR|' | |
| 2815 r'CLEAR-APPL-CONTEXT|CLEAR-LOG|CLEAR-SELECTION|CLEAR-SELECT|' | |
| 2816 r'CLEAR-SELECTI|CLEAR-SELECTIO|CLEAR-SORT-ARROWS|CLEAR-SORT-ARROW|' | |
| 2817 r'CLIENT-CONNECTION-ID|CLIENT-PRINCIPAL|CLIENT-TTY|CLIENT-TYPE|' | |
| 2818 r'CLIENT-WORKSTATION|CLIPBOARD|CLOSE|CLOSE-LOG|CODE|CODEBASE-LOCATOR|' | |
| 2819 r'CODEPAGE|CODEPAGE-CONVERT|COLLATE|COL-OF|COLON|COLON-ALIGNED|' | |
| 2820 r'COLON-ALIGN|COLON-ALIGNE|COLOR|COLOR-TABLE|COLUMN|COL|COLU|COLUM|' | |
| 2821 r'COLUMN-BGCOLOR|COLUMN-DCOLOR|COLUMN-FGCOLOR|COLUMN-FONT|COLUMN-LABEL|' | |
| 2822 r'COLUMN-LAB|COLUMN-LABE|COLUMN-MOVABLE|COLUMN-OF|COLUMN-PFCOLOR|' | |
| 2823 r'COLUMN-READ-ONLY|COLUMN-RESIZABLE|COLUMNS|COLUMN-SCROLLING|' | |
| 2824 r'COMBO-BOX|COMMAND|COMPARES|COMPILE|COMPILER|COMPLETE|COM-SELF|' | |
| 2825 r'CONFIG-NAME|CONNECT|CONNECTED|CONSTRUCTOR|CONTAINS|CONTENTS|CONTEXT|' | |
| 2826 r'CONTEXT-HELP|CONTEXT-HELP-FILE|CONTEXT-HELP-ID|CONTEXT-POPUP|' | |
| 2827 r'CONTROL|CONTROL-BOX|CONTROL-FRAME|CONVERT|CONVERT-3D-COLORS|' | |
| 2828 r'CONVERT-TO-OFFSET|CONVERT-TO-OFFS|CONVERT-TO-OFFSE|COPY-DATASET|' | |
| 2829 r'COPY-LOB|COPY-SAX-ATTRIBUTES|COPY-TEMP-TABLE|COUNT|COUNT-OF|' | |
| 2830 r'CPCASE|CPCOLL|CPINTERNAL|CPLOG|CPPRINT|CPRCODEIN|CPRCODEOUT|' | |
| 2831 r'CPSTREAM|CPTERM|CRC-VALUE|CREATE|CREATE-LIKE|CREATE-LIKE-SEQUENTIAL|' | |
| 2832 r'CREATE-NODE-NAMESPACE|CREATE-RESULT-LIST-ENTRY|CREATE-TEST-FILE|' | |
| 2833 r'CURRENT|CURRENT_DATE|CURRENT_DATE|CURRENT-CHANGED|CURRENT-COLUMN|' | |
| 2834 r'CURRENT-ENVIRONMENT|CURRENT-ENV|CURRENT-ENVI|CURRENT-ENVIR|' | |
| 2835 r'CURRENT-ENVIRO|CURRENT-ENVIRON|CURRENT-ENVIRONM|CURRENT-ENVIRONME|' | |
| 2836 r'CURRENT-ENVIRONMEN|CURRENT-ITERATION|CURRENT-LANGUAGE|CURRENT-LANG|' | |
| 2837 r'CURRENT-LANGU|CURRENT-LANGUA|CURRENT-LANGUAG|CURRENT-QUERY|' | |
| 2838 r'CURRENT-RESULT-ROW|CURRENT-ROW-MODIFIED|CURRENT-VALUE|CURRENT-WINDOW|' | |
| 2839 r'CURSOR|CURS|CURSO|CURSOR-CHAR|CURSOR-LINE|CURSOR-OFFSET|DATABASE|' | |
| 2840 r'DATA-BIND|DATA-ENTRY-RETURN|DATA-ENTRY-RET|DATA-ENTRY-RETU|' | |
| 2841 r'DATA-ENTRY-RETUR|DATA-RELATION|DATA-REL|DATA-RELA|DATA-RELAT|' | |
| 2842 r'DATA-RELATI|DATA-RELATIO|DATASERVERS|DATASET|DATASET-HANDLE|DATA-SOURCE|' | |
| 2843 r'DATA-SOURCE-COMPLETE-MAP|DATA-SOURCE-MODIFIED|DATA-SOURCE-ROWID|' | |
| 2844 r'DATA-TYPE|DATA-T|DATA-TY|DATA-TYP|DATE-FORMAT|DATE-F|DATE-FO|' | |
| 2845 r'DATE-FOR|DATE-FORM|DATE-FORMA|DAY|DBCODEPAGE|DBCOLLATION|DBNAME|' | |
| 2846 r'DBPARAM|DB-REFERENCES|DBRESTRICTIONS|DBREST|DBRESTR|DBRESTRI|' | |
| 2847 r'DBRESTRIC|DBRESTRICT|DBRESTRICTI|DBRESTRICTIO|DBRESTRICTION|' | |
| 2848 r'DBTASKID|DBTYPE|DBVERSION|DBVERS|DBVERSI|DBVERSIO|DCOLOR|' | |
| 2849 r'DDE|DDE-ERROR|DDE-ID|DDE-I|DDE-ITEM|DDE-NAME|DDE-TOPIC|DEBLANK|' | |
| 2850 r'DEBUG|DEBU|DEBUG-ALERT|DEBUGGER|DEBUG-LIST|DECIMALS|DECLARE|' | |
| 2851 r'DECLARE-NAMESPACE|DECRYPT|DEFAULT|DEFAULT-BUFFER-HANDLE|' | |
| 2852 r'DEFAULT-BUTTON|DEFAUT-B|DEFAUT-BU|DEFAUT-BUT|DEFAUT-BUTT|DEFAUT-BUTTO|' | |
| 2853 r'DEFAULT-COMMIT|DEFAULT-EXTENSION|DEFAULT-EX|DEFAULT-EXT|DEFAULT-EXTE|' | |
| 2854 r'DEFAULT-EXTEN|DEFAULT-EXTENS|DEFAULT-EXTENSI|DEFAULT-EXTENSIO|' | |
| 2855 r'DEFAULT-NOXLATE|DEFAULT-NOXL|DEFAULT-NOXLA|DEFAULT-NOXLAT|' | |
| 2856 r'DEFAULT-VALUE|DEFAULT-WINDOW|DEFINED|' | |
| 2857 r'DEFINE-USER-EVENT-MANAGER|DELETE|DEL|DELE|DELET|DELETE-CHARACTER|' | |
| 2858 r'DELETE-CHAR|DELETE-CHARA|DELETE-CHARAC|DELETE-CHARACT|DELETE-CHARACTE|' | |
| 2859 r'DELETE-CURRENT-ROW|DELETE-LINE|DELETE-RESULT-LIST-ENTRY|DELETE-SELECTED-ROW|' | |
| 2860 r'DELETE-SELECTED-ROWS|DELIMITER|DESC|DESCENDING|DESC|DESCE|DESCEN|' | |
| 2861 r'DESCEND|DESCENDI|DESCENDIN|DESELECT-FOCUSED-ROW|DESELECTION|' | |
| 2862 r'DESELECT-ROWS|DESELECT-SELECTED-ROW|DESTRUCTOR|DIALOG-BOX|' | |
| 2863 r'DICTIONARY|DICT|DICTI|DICTIO|DICTION|DICTIONA|DICTIONAR|' | |
| 2864 r'DIR|DISABLE|DISABLE-AUTO-ZAP|DISABLED|DISABLE-DUMP-TRIGGERS|' | |
| 2865 r'DISABLE-LOAD-TRIGGERS|DISCONNECT|DISCON|DISCONN|DISCONNE|DISCONNEC|' | |
| 2866 r'DISP|DISPLAY|DISP|DISPL|DISPLA|DISPLAY-MESSAGE|DISPLAY-TYPE|' | |
| 2867 r'DISPLAY-T|DISPLAY-TY|DISPLAY-TYP|DISTINCT|DO|DOMAIN-DESCRIPTION|' | |
| 2868 r'DOMAIN-NAME|DOMAIN-TYPE|DOS|DOUBLE|DOWN|DRAG-ENABLED|DROP|DROP-DOWN|' | |
| 2869 r'DROP-DOWN-LIST|DROP-FILE-NOTIFY|DROP-TARGET|DUMP|DYNAMIC|' | |
| 2870 r'DYNAMIC-FUNCTION|EACH|ECHO|EDGE-CHARS|EDGE|EDGE-|EDGE-C|' | |
| 2871 r'EDGE-CH|EDGE-CHA|EDGE-CHAR|EDGE-PIXELS|EDGE-P|EDGE-PI|EDGE-PIX|' | |
| 2872 r'EDGE-PIXE|EDGE-PIXEL|EDIT-CAN-PASTE|EDIT-CAN-UNDO|EDIT-CLEAR|' | |
| 2873 r'EDIT-COPY|EDIT-CUT|EDITING|EDITOR|EDIT-PASTE|EDIT-UNDO|ELSE|' | |
| 2874 r'EMPTY|EMPTY-TEMP-TABLE|ENABLE|ENABLED-FIELDS|ENCODE|ENCRYPT|' | |
| 2875 r'ENCRYPT-AUDIT-MAC-KEY|ENCRYPTION-SALT|END|END-DOCUMENT|' | |
| 2876 r'END-ELEMENT|END-EVENT-GROUP|END-FILE-DROP|ENDKEY|END-KEY|' | |
| 2877 r'END-MOVE|END-RESIZE|END-ROW-RESIZE|END-USER-PROMPT|ENTERED|' | |
| 2878 r'ENTRY|EQ|ERROR|ERROR-COLUMN|ERROR-COL|ERROR-COLU|ERROR-COLUM|' | |
| 2879 r'ERROR-ROW|ERROR-STACK-TRACE|ERROR-STATUS|ERROR-STAT|ERROR-STATU|' | |
| 2880 r'ESCAPE|ETIME|EVENT-GROUP-ID|EVENT-PROCEDURE|EVENT-PROCEDURE-CONTEXT|' | |
| 2881 r'EVENTS|EVENT|EVENT-TYPE|EVENT-T|EVENT-TY|EVENT-TYP|EXCEPT|' | |
| 2882 r'EXCLUSIVE-ID|EXCLUSIVE-LOCK|EXCLUSIVE|EXCLUSIVE-|EXCLUSIVE-L|' | |
| 2883 r'EXCLUSIVE-LO|EXCLUSIVE-LOC|EXCLUSIVE-WEB-USER|EXECUTE|EXISTS|' | |
| 2884 r'EXP|EXPAND|EXPANDABLE|EXPLICIT|EXPORT|EXPORT-PRINCIPAL|EXTENDED|' | |
| 2885 r'EXTENT|EXTERNAL|FALSE|FETCH|FETCH-SELECTED-ROW|FGCOLOR|FGC|FGCO|' | |
| 2886 r'FGCOL|FGCOLO|FIELD|FIELDS|FIELD|FILE|FILE-CREATE-DATE|' | |
| 2887 r'FILE-CREATE-TIME|FILE-INFORMATION|FILE-INFO|FILE-INFOR|FILE-INFORM|' | |
| 2888 r'FILE-INFORMA|FILE-INFORMAT|FILE-INFORMATI|FILE-INFORMATIO|FILE-MOD-DATE|' | |
| 2889 r'FILE-MOD-TIME|FILENAME|FILE-NAME|FILE-OFFSET|FILE-OFF|FILE-OFFS|FILE-OFFSE|' | |
| 2890 r'FILE-SIZE|FILE-TYPE|FILL|FILLED|FILL-IN|FILTERS|FINAL|FINALLY|FIND|' | |
| 2891 r'FIND-BY-ROWID|FIND-CASE-SENSITIVE|FIND-CURRENT|FINDER|FIND-FIRST|' | |
| 2892 r'FIND-GLOBAL|FIND-LAST|FIND-NEXT-OCCURRENCE|FIND-PREV-OCCURRENCE|' | |
| 2893 r'FIND-SELECT|FIND-UNIQUE|FIND-WRAP-AROUND|FIRST|FIRST-ASYNCH-REQUEST|' | |
| 2894 r'FIRST-CHILD|FIRST-COLUMN|FIRST-FORM|FIRST-OBJECT|FIRST-OF|' | |
| 2895 r'FIRST-PROCEDURE|FIRST-PROC|FIRST-PROCE|FIRST-PROCED|FIRST-PROCEDU|FIRST-PROCEDUR|' | |
| 2896 r'FIRST-SERVER|FIRST-TAB-ITEM|FIRST-TAB-I|FIRST-TAB-IT|FIRST-TAB-ITE|' | |
| 2897 r'FIT-LAST-COLUMN|FIXED-ONLY|FLAT-BUTTON|FLOAT|FOCUS|FOCUSED-ROW|' | |
| 2898 r'FOCUSED-ROW-SELECTED|FONT|FONT-TABLE|FOR|FORCE-FILE|' | |
| 2899 r'FOREGROUND|FORE|FOREG|FOREGR|FOREGRO|FOREGROU|FOREGROUN|' | |
| 2900 r'FORM|FORMAT|FORM|FORMA|FORMATTED|FORMATTE|FORM-LONG-INPUT|' | |
| 2901 r'FORWARD|FORWARDS|FORWARD|FRAGMENT|FRAGMEN|FRAME|FRAM|' | |
| 2902 r'FRAME-COL|FRAME-DB|FRAME-DOWN|FRAME-FIELD|FRAME-FILE|' | |
| 2903 r'FRAME-INDEX|FRAME-INDE|FRAME-LINE|FRAME-NAME|FRAME-ROW|' | |
| 2904 r'FRAME-SPACING|FRAME-SPA|FRAME-SPAC|FRAME-SPACI|FRAME-SPACIN|' | |
| 2905 r'FRAME-VALUE|FRAME-VAL|FRAME-VALU|FRAME-X|FRAME-Y|FREQUENCY|FROM|' | |
| 2906 r'FROM-CHARS|FROM-C|FROM-CH|FROM-CHA|FROM-CHAR|' | |
| 2907 r'FROM-CURRENT|FROM-CUR|FROM-CURR|FROM-CURRE|FROM-CURREN|' | |
| 2908 r'FROM-PIXELS|FROM-P|FROM-PI|FROM-PIX|FROM-PIXE|FROM-PIXEL|' | |
| 2909 r'FULL-HEIGHT-CHARS|FULL-HEIGHT|FULL-HEIGHT-|FULL-HEIGHT-C|FULL-HEIGHT-CH|FULL-HEIGHT-CHA|FULL-HEIGHT-CHAR|' | |
| 2910 r'FULL-HEIGHT-PIXELS|FULL-HEIGHT-P|FULL-HEIGHT-PI|FULL-HEIGHT-PIX|FULL-HEIGHT-PIXE|FULL-HEIGHT-PIXEL|' | |
| 2911 r'FULL-PATHNAME|FULL-PATHN|FULL-PATHNA|FULL-PATHNAM|' | |
| 2912 r'FULL-WIDTH-CHARS|FULL-WIDTH|FULL-WIDTH-|FULL-WIDTH-C|FULL-WIDTH-CH|FULL-WIDTH-CHA|FULL-WIDTH-CHAR|' | |
| 2913 r'FULL-WIDTH-PIXELS|FULL-WIDTH-P|FULL-WIDTH-PI|FULL-WIDTH-PIX|FULL-WIDTH-PIXE|FULL-WIDTH-PIXEL|' | |
| 2914 r'FUNCTION|FUNCTION-CALL-TYPE|GATEWAYS|GATEWAY|GE|GENERATE-MD5|' | |
| 2915 r'GENERATE-PBE-KEY|GENERATE-PBE-SALT|GENERATE-RANDOM-KEY|GENERATE-UUID|GET|' | |
| 2916 r'GET-ATTR-CALL-TYPE|GET-ATTRIBUTE-NODE|GET-BINARY-DATA|' | |
| 2917 r'GET-BLUE-VALUE|GET-BLUE|GET-BLUE-|GET-BLUE-V|GET-BLUE-VA|GET-BLUE-VAL|GET-BLUE-VALU|' | |
| 2918 r'GET-BROWSE-COLUMN|GET-BUFFER-HANDLEGETBYTE|GET-BYTE|GET-CALLBACK-PROC-CONTEXT|' | |
| 2919 r'GET-CALLBACK-PROC-NAME|GET-CGI-LIST|GET-CGI-LONG-VALUE|GET-CGI-VALUE|' | |
| 2920 r'GET-CODEPAGES|GET-COLLATIONS|GET-CONFIG-VALUE|GET-CURRENT|GET-DOUBLE|' | |
| 2921 r'GET-DROPPED-FILE|GET-DYNAMIC|GET-ERROR-COLUMN|GET-ERROR-ROW|GET-FILE|' | |
| 2922 r'GET-FILE-NAME|GET-FILE-OFFSET|GET-FILE-OFFSE|GET-FIRST|GET-FLOAT|' | |
| 2923 r'GET-GREEN-VALUE|GET-GREEN|GET-GREEN-|GET-GREEN-V|GET-GREEN-VA|GET-GREEN-VAL|GET-GREEN-VALU|' | |
| 2924 r'GET-INDEX-BY-NAMESPACE-NAME|GET-INDEX-BY-QNAME|GET-INT64|GET-ITERATION|' | |
| 2925 r'GET-KEY-VALUE|GET-KEY-VAL|GET-KEY-VALU|GET-LAST|GET-LOCALNAME-BY-INDEX|' | |
| 2926 r'GET-LONG|GET-MESSAGE|GET-NEXT|GET-NUMBER|GET-POINTER-VALUE|' | |
| 2927 r'GET-PREV|GET-PRINTERS|GET-PROPERTY|GET-QNAME-BY-INDEX|' | |
| 2928 r'GET-RED-VALUE|GET-RED|GET-RED-|GET-RED-V|GET-RED-VA|GET-RED-VAL|GET-RED-VALU|' | |
| 2929 r'GET-REPOSITIONED-ROW|GET-RGB-VALUE|' | |
| 2930 r'GET-SELECTED-WIDGET|GET-SELECTED|GET-SELECTED-|GET-SELECTED-W|GET-SELECTED-WI|GET-SELECTED-WID|GET-SELECTED-WIDG|GET-SELECTED-WIDGE|' | |
| 2931 r'GET-SHORT|GET-SIGNATURE|GET-SIZE|GET-STRING|GET-TAB-ITEM|' | |
| 2932 r'GET-TEXT-HEIGHT-CHARS|GET-TEXT-HEIGHT|GET-TEXT-HEIGHT-|GET-TEXT-HEIGHT-C|GET-TEXT-HEIGHT-CH|GET-TEXT-HEIGHT-CHA|GET-TEXT-HEIGHT-CHAR|' | |
| 2933 r'GET-TEXT-HEIGHT-PIXELS|GET-TEXT-HEIGHT-P|GET-TEXT-HEIGHT-PI|GET-TEXT-HEIGHT-PIX|GET-TEXT-HEIGHT-PIXE|GET-TEXT-HEIGHT-PIXEL|' | |
| 2934 r'GET-TEXT-WIDTH-CHARS|GET-TEXT-WIDTH|GET-TEXT-WIDTH-|GET-TEXT-WIDTH-C|GET-TEXT-WIDTH-CH|GET-TEXT-WIDTH-CHA|GET-TEXT-WIDTH-CHAR|' | |
| 2935 r'GET-TEXT-WIDTH-PIXELS|GET-TEXT-WIDTH-P|GET-TEXT-WIDTH-PI|GET-TEXT-WIDTH-PIX|GET-TEXT-WIDTH-PIXE|GET-TEXT-WIDTH-PIXEL|' | |
| 2936 r'GET-TYPE-BY-INDEX|GET-TYPE-BY-NAMESPACE-NAME|GET-TYPE-BY-QNAME|GET-UNSIGNED-LONG|' | |
| 2937 r'GET-UNSIGNED-SHORT|GET-URI-BY-INDEX|GET-VALUE-BY-INDEX|GET-VALUE-BY-NAMESPACE-NAME|' | |
| 2938 r'GET-VALUE-BY-QNAME|GET-WAIT-STATE|GLOBAL|GO-ON|' | |
| 2939 r'GO-PENDING|GO-PEND|GO-PENDI|GO-PENDIN|GRANT|' | |
| 2940 r'GRAPHIC-EDGE|GRAPHIC-E|GRAPHIC-ED|GRAPHIC-EDG|' | |
| 2941 r'GRID-FACTOR-HORIZONTAL|GRID-FACTOR-H|GRID-FACTOR-HO|GRID-FACTOR-HOR|GRID-FACTOR-HORI|GRID-FACTOR-HORIZ|GRID-FACTOR-HORIZO|GRID-FACTOR-HORIZON|GRID-FACTOR-HORIZONT|GRID-FACTOR-HORIZONTA|' | |
| 2942 r'GRID-FACTOR-VERTICAL|GRID-FACTOR-V|GRID-FACTOR-VE|GRID-FACTOR-VER|GRID-FACTOR-VERT|GRID-FACTOR-VERT|GRID-FACTOR-VERTI|GRID-FACTOR-VERTIC|GRID-FACTOR-VERTICA|' | |
| 2943 r'GRID-SNAP|' | |
| 2944 r'GRID-UNIT-HEIGHT-CHARS|GRID-UNIT-HEIGHT|GRID-UNIT-HEIGHT-|GRID-UNIT-HEIGHT-C|GRID-UNIT-HEIGHT-CH|GRID-UNIT-HEIGHT-CHA|' | |
| 2945 r'GRID-UNIT-HEIGHT-PIXELS|GRID-UNIT-HEIGHT-P|GRID-UNIT-HEIGHT-PI|GRID-UNIT-HEIGHT-PIX|GRID-UNIT-HEIGHT-PIXE|GRID-UNIT-HEIGHT-PIXEL|' | |
| 2946 r'GRID-UNIT-WIDTH-CHARS|GRID-UNIT-WIDTH|GRID-UNIT-WIDTH-|GRID-UNIT-WIDTH-C|GRID-UNIT-WIDTH-CH|GRID-UNIT-WIDTH-CHA|GRID-UNIT-WIDTH-CHAR|' | |
| 2947 r'GRID-UNIT-WIDTH-PIXELS|GRID-UNIT-WIDTH-P|GRID-UNIT-WIDTH-PI|GRID-UNIT-WIDTH-PIX|GRID-UNIT-WIDTH-PIXE|GRID-UNIT-WIDTH-PIXEL|' | |
| 2948 r'GRID-VISIBLE|GROUP|GT|GUID|HANDLER|HAS-RECORDS|HAVING|HEADER|' | |
| 2949 r'HEIGHT-CHARS|HEIGHT|HEIGHT-|HEIGHT-C|HEIGHT-CH|HEIGHT-CHA|HEIGHT-CHAR|' | |
| 2950 r'HEIGHT-PIXELS|HEIGHT-P|HEIGHT-PI|HEIGHT-PIX|HEIGHT-PIXE|HEIGHT-PIXEL|' | |
| 2951 r'HELP|HEX-DECODE|HEX-ENCODE|HIDDEN|HIDE|' | |
| 2952 r'HORIZONTAL|HORI|HORIZ|HORIZO|HORIZON|HORIZONT|HORIZONTA|' | |
| 2953 r'HOST-BYTE-ORDER|HTML-CHARSET|HTML-END-OF-LINE|HTML-END-OF-PAGE|' | |
| 2954 r'HTML-FRAME-BEGIN|HTML-FRAME-END|HTML-HEADER-BEGIN|HTML-HEADER-END|' | |
| 2955 r'HTML-TITLE-BEGIN|HTML-TITLE-END|HWND|ICON|IF|' | |
| 2956 r'IMAGE|IMAGE-DOWN|IMAGE-INSENSITIVE|IMAGE-SIZE|' | |
| 2957 r'IMAGE-SIZE-CHARS|IMAGE-SIZE-C|IMAGE-SIZE-CH|IMAGE-SIZE-CHA|IMAGE-SIZE-CHAR|' | |
| 2958 r'IMAGE-SIZE-PIXELS|IMAGE-SIZE-P|IMAGE-SIZE-PI|IMAGE-SIZE-PIX|IMAGE-SIZE-PIXE|IMAGE-SIZE-PIXEL|' | |
| 2959 r'IMAGE-UP|IMMEDIATE-DISPLAY|IMPLEMENTS|IMPORT|IMPORT-PRINCIPAL|' | |
| 2960 r'IN|INCREMENT-EXCLUSIVE-ID|INDEX|INDEXED-REPOSITION|INDEX-HINT|' | |
| 2961 r'INDEX-INFORMATION|INDICATOR|' | |
| 2962 r'INFORMATION|INFO|INFOR|INFORM|INFORMA|INFORMAT|INFORMATI|INFORMATIO|' | |
| 2963 r'IN-HANDLE|' | |
| 2964 r'INHERIT-BGCOLOR|INHERIT-BGC|INHERIT-BGCO|INHERIT-BGCOL|INHERIT-BGCOLO|' | |
| 2965 r'INHERIT-FGCOLOR|INHERIT-FGC|INHERIT-FGCO|INHERIT-FGCOL|INHERIT-FGCOLO|' | |
| 2966 r'INHERITS|INITIAL|INIT|INITI|INITIA|INITIAL-DIR|INITIAL-FILTER|' | |
| 2967 r'INITIALIZE-DOCUMENT-TYPE|INITIATE|INNER-CHARS|INNER-LINES|INPUT|' | |
| 2968 r'INPUT-OUTPUT|INPUT-O|INPUT-OU|INPUT-OUT|INPUT-OUTP|INPUT-OUTPU|' | |
| 2969 r'INPUT-VALUE|INSERT|INSERT-ATTRIBUTE|' | |
| 2970 r'INSERT-BACKTAB|INSERT-B|INSERT-BA|INSERT-BAC|INSERT-BACK|INSERT-BACKT|INSERT-BACKTA|' | |
| 2971 r'INSERT-FILE|INSERT-ROW|INSERT-STRING|INSERT-TAB|INSERT-T|INSERT-TA|' | |
| 2972 r'INTERFACE|INTERNAL-ENTRIES|INTO|INVOKE|IS|' | |
| 2973 r'IS-ATTR-SPACE|IS-ATTR|IS-ATTR-|IS-ATTR-S|IS-ATTR-SP|IS-ATTR-SPA|IS-ATTR-SPAC|' | |
| 2974 r'IS-CLASS|IS-CLAS|IS-LEAD-BYTE|IS-ATTR|IS-OPEN|IS-PARAMETER-SET|IS-ROW-SELECTED|' | |
| 2975 r'IS-SELECTED|ITEM|ITEMS-PER-ROW|JOIN|JOIN-BY-SQLDB|KBLABEL|KEEP-CONNECTION-OPEN|' | |
| 2976 r'KEEP-FRAME-Z-ORDER|KEEP-FRAME-Z|KEEP-FRAME-Z-|KEEP-FRAME-Z-O|KEEP-FRAME-Z-OR|KEEP-FRAME-Z-ORD|KEEP-FRAME-Z-ORDE|' | |
| 2977 r'KEEP-MESSAGES|KEEP-SECURITY-CACHE|KEEP-TAB-ORDER|KEY|KEYCODE|KEY-CODE|' | |
| 2978 r'KEYFUNCTION|KEYFUNC|KEYFUNCT|KEYFUNCTI|KEYFUNCTIO|' | |
| 2979 r'KEY-FUNCTION|KEY-FUNC|KEY-FUNCT|KEY-FUNCTI|KEY-FUNCTIO|' | |
| 2980 r'KEYLABEL|KEY-LABEL|KEYS|KEYWORD|KEYWORD-ALL|LABEL|' | |
| 2981 r'LABEL-BGCOLOR|LABEL-BGC|LABEL-BGCO|LABEL-BGCOL|LABEL-BGCOLO|' | |
| 2982 r'LABEL-DCOLOR|LABEL-DC|LABEL-DCO|LABEL-DCOL|LABEL-DCOLO|' | |
| 2983 r'LABEL-FGCOLOR|LABEL-FGC|LABEL-FGCO|LABEL-FGCOL|LABEL-FGCOLO|' | |
| 2984 r'LABEL-FONT|' | |
| 2985 r'LABEL-PFCOLOR|LABEL-PFC|LABEL-PFCO|LABEL-PFCOL|LABEL-PFCOLO|' | |
| 2986 r'LABELS|LANDSCAPE|LANGUAGES|LANGUAGE|LARGE|LARGE-TO-SMALL|LAST|' | |
| 2987 r'LAST-ASYNCH-REQUEST|LAST-BATCH|LAST-CHILD|LAST-EVENT|LAST-EVEN|LAST-FORM|' | |
| 2988 r'LASTKEY|LAST-KEY|LAST-OBJECT|LAST-OF|' | |
| 2989 r'LAST-PROCEDURE|LAST-PROCE|LAST-PROCED|LAST-PROCEDU|LAST-PROCEDUR|' | |
| 2990 r'LAST-SERVER|LAST-TAB-ITEM|LAST-TAB-I|LAST-TAB-IT|LAST-TAB-ITE|' | |
| 2991 r'LC|LDBNAME|LE|LEAVE|LEFT-ALIGNED|LEFT-ALIGN|LEFT-ALIGNE|LEFT-TRIM|' | |
| 2992 r'LENGTH|LIBRARY|LIKE|LIKE-SEQUENTIAL|LINE|LINE-COUNTER|LINE-COUNT|LINE-COUNTE|' | |
| 2993 r'LIST-EVENTS|LISTING|LISTI|LISTIN|LIST-ITEM-PAIRS|LIST-ITEMS|' | |
| 2994 r'LIST-PROPERTY-NAMES|LIST-QUERY-ATTRS|LIST-SET-ATTRS|LIST-WIDGETS|' | |
| 2995 r'LITERAL-QUESTION|LITTLE-ENDIAN|LOAD|LOAD-DOMAINS|LOAD-ICON|' | |
| 2996 r'LOAD-IMAGE|LOAD-IMAGE-DOWN|LOAD-IMAGE-INSENSITIVE|LOAD-IMAGE-UP|' | |
| 2997 r'LOAD-MOUSE-POINTER|LOAD-MOUSE-P|LOAD-MOUSE-PO|LOAD-MOUSE-POI|LOAD-MOUSE-POIN|LOAD-MOUSE-POINT|LOAD-MOUSE-POINTE|' | |
| 2998 r'LOAD-PICTURE|LOAD-SMALL-ICON|LOCAL-NAME|LOCATOR-COLUMN-NUMBER|' | |
| 2999 r'LOCATOR-LINE-NUMBER|LOCATOR-PUBLIC-ID|LOCATOR-SYSTEM-ID|LOCATOR-TYPE|' | |
| 3000 r'LOCKED|LOCK-REGISTRATION|LOG|LOG-AUDIT-EVENT|LOGIN-EXPIRATION-TIMESTAMP|' | |
| 3001 r'LOGIN-HOST|LOGIN-STATE|LOG-MANAGER|LOGOUT|LOOKAHEAD|LOOKUP|LT|' | |
| 3002 r'MACHINE-CLASS|MANDATORY|MANUAL-HIGHLIGHT|MAP|MARGIN-EXTRA|' | |
| 3003 r'MARGIN-HEIGHT-CHARS|MARGIN-HEIGHT|MARGIN-HEIGHT-|MARGIN-HEIGHT-C|MARGIN-HEIGHT-CH|MARGIN-HEIGHT-CHA|MARGIN-HEIGHT-CHAR|' | |
| 3004 r'MARGIN-HEIGHT-PIXELS|MARGIN-HEIGHT-P|MARGIN-HEIGHT-PI|MARGIN-HEIGHT-PIX|MARGIN-HEIGHT-PIXE|MARGIN-HEIGHT-PIXEL|' | |
| 3005 r'MARGIN-WIDTH-CHARS|MARGIN-WIDTH|MARGIN-WIDTH-|MARGIN-WIDTH-C|MARGIN-WIDTH-CH|MARGIN-WIDTH-CHA|MARGIN-WIDTH-CHAR|' | |
| 3006 r'MARGIN-WIDTH-PIXELS|MARGIN-WIDTH-P|MARGIN-WIDTH-PI|MARGIN-WIDTH-PIX|MARGIN-WIDTH-PIXE|MARGIN-WIDTH-PIXEL|' | |
| 3007 r'MARK-NEW|MARK-ROW-STATE|MATCHES|MAX|MAX-BUTTON|' | |
| 3008 r'MAX-CHARS|MAX-DATA-GUESS|MAX-HEIGHT|' | |
| 3009 r'MAX-HEIGHT-CHARS|MAX-HEIGHT-C|MAX-HEIGHT-CH|MAX-HEIGHT-CHA|MAX-HEIGHT-CHAR|' | |
| 3010 r'MAX-HEIGHT-PIXELS|MAX-HEIGHT-P|MAX-HEIGHT-PI|MAX-HEIGHT-PIX|MAX-HEIGHT-PIXE|MAX-HEIGHT-PIXEL|' | |
| 3011 r'MAXIMIZE|MAXIMUM|MAX|MAXI|MAXIM|MAXIMU|MAXIMUM-LEVEL|MAX-ROWS|' | |
| 3012 r'MAX-SIZE|MAX-VALUE|MAX-VAL|MAX-VALU|MAX-WIDTH|' | |
| 3013 r'MAX-WIDTH-CHARS|MAX-WIDTH|MAX-WIDTH-|MAX-WIDTH-C|MAX-WIDTH-CH|MAX-WIDTH-CHA|MAX-WIDTH-CHAR|' | |
| 3014 r'MAX-WIDTH-PIXELS|MAX-WIDTH-P|MAX-WIDTH-PI|MAX-WIDTH-PIX|MAX-WIDTH-PIXE|MAX-WIDTH-PIXEL|' | |
| 3015 r'MD5-DIGEST|MEMBER|MEMPTR-TO-NODE-VALUE|MENU|MENUBAR|MENU-BAR|MENU-ITEM|' | |
| 3016 r'MENU-KEY|MENU-K|MENU-KE|MENU-MOUSE|MENU-M|MENU-MO|MENU-MOU|MENU-MOUS|' | |
| 3017 r'MERGE-BY-FIELD|MESSAGE|MESSAGE-AREA|MESSAGE-AREA-FONT|MESSAGE-LINES|' | |
| 3018 r'METHOD|MIN|MIN-BUTTON|' | |
| 3019 r'MIN-COLUMN-WIDTH-CHARS|MIN-COLUMN-WIDTH-C|MIN-COLUMN-WIDTH-CH|MIN-COLUMN-WIDTH-CHA|MIN-COLUMN-WIDTH-CHAR|' | |
| 3020 r'MIN-COLUMN-WIDTH-PIXELS|MIN-COLUMN-WIDTH-P|MIN-COLUMN-WIDTH-PI|MIN-COLUMN-WIDTH-PIX|MIN-COLUMN-WIDTH-PIXE|MIN-COLUMN-WIDTH-PIXEL|' | |
| 3021 r'MIN-HEIGHT-CHARS|MIN-HEIGHT|MIN-HEIGHT-|MIN-HEIGHT-C|MIN-HEIGHT-CH|MIN-HEIGHT-CHA|MIN-HEIGHT-CHAR|' | |
| 3022 r'MIN-HEIGHT-PIXELS|MIN-HEIGHT-P|MIN-HEIGHT-PI|MIN-HEIGHT-PIX|MIN-HEIGHT-PIXE|MIN-HEIGHT-PIXEL|' | |
| 3023 r'MINIMUM|MIN|MINI|MINIM|MINIMU|MIN-SIZE|' | |
| 3024 r'MIN-VALUE|MIN-VAL|MIN-VALU|' | |
| 3025 r'MIN-WIDTH-CHARS|MIN-WIDTH|MIN-WIDTH-|MIN-WIDTH-C|MIN-WIDTH-CH|MIN-WIDTH-CHA|MIN-WIDTH-CHAR|' | |
| 3026 r'MIN-WIDTH-PIXELS|MIN-WIDTH-P|MIN-WIDTH-PI|MIN-WIDTH-PIX|MIN-WIDTH-PIXE|MIN-WIDTH-PIXEL|' | |
| 3027 r'MODIFIED|MODULO|MOD|MODU|MODUL|MONTH|MOUSE|' | |
| 3028 r'MOUSE-POINTER|MOUSE-P|MOUSE-PO|MOUSE-POI|MOUSE-POIN|MOUSE-POINT|MOUSE-POINTE|' | |
| 3029 r'MOVABLE|' | |
| 3030 r'MOVE-AFTER-TAB-ITEM|MOVE-AFTER|MOVE-AFTER-|MOVE-AFTER-T|MOVE-AFTER-TA|MOVE-AFTER-TAB|MOVE-AFTER-TAB-|MOVE-AFTER-TAB-I|MOVE-AFTER-TAB-IT|MOVE-AFTER-TAB-ITE|' | |
| 3031 r'MOVE-BEFORE-TAB-ITEM|MOVE-BEFOR|MOVE-BEFORE|MOVE-BEFORE-|MOVE-BEFORE-T|MOVE-BEFORE-TA|MOVE-BEFORE-TAB|MOVE-BEFORE-TAB-|MOVE-BEFORE-TAB-I|MOVE-BEFORE-TAB-IT|MOVE-BEFORE-TAB-ITE|' | |
| 3032 r'MOVE-COLUMN|MOVE-COL|MOVE-COLU|MOVE-COLUM|' | |
| 3033 r'MOVE-TO-BOTTOM|MOVE-TO-B|MOVE-TO-BO|MOVE-TO-BOT|MOVE-TO-BOTT|MOVE-TO-BOTTO|' | |
| 3034 r'MOVE-TO-EOF|MOVE-TO-TOP|MOVE-TO-T|MOVE-TO-TO|MPE|MULTI-COMPILE|MULTIPLE|' | |
| 3035 r'MULTIPLE-KEY|MULTITASKING-INTERVAL|MUST-EXIST|NAME|NAMESPACE-PREFIX|' | |
| 3036 r'NAMESPACE-URI|NATIVE|NE|NEEDS-APPSERVER-PROMPT|NEEDS-PROMPT|NEW|' | |
| 3037 r'NEW-INSTANCE|NEW-ROW|NEXT|NEXT-COLUMN|NEXT-PROMPT|NEXT-ROWID|' | |
| 3038 r'NEXT-SIBLING|NEXT-TAB-ITEM|NEXT-TAB-I|NEXT-TAB-IT|NEXT-TAB-ITE|' | |
| 3039 r'NEXT-VALUE|NO|NO-APPLY|NO-ARRAY-MESSAGE|NO-ASSIGN|' | |
| 3040 r'NO-ATTR-LIST|NO-ATTR|NO-ATTR-|NO-ATTR-L|NO-ATTR-LI|NO-ATTR-LIS|' | |
| 3041 r'NO-ATTR-SPACE|NO-ATTR|NO-ATTR-|NO-ATTR-S|NO-ATTR-SP|NO-ATTR-SPA|NO-ATTR-SPAC|' | |
| 3042 r'NO-AUTO-VALIDATE|NO-BIND-WHERE|NO-BOX|NO-CONSOLE|NO-CONVERT|' | |
| 3043 r'NO-CONVERT-3D-COLORS|NO-CURRENT-VALUE|NO-DEBUG|NODE-VALUE-TO-MEMPTR|' | |
| 3044 r'NO-DRAG|NO-ECHO|NO-EMPTY-SPACE|NO-ERROR|NO-FILL|NO-F|NO-FI|' | |
| 3045 r'NO-FIL|NO-FOCUS|NO-HELP|NO-HIDE|NO-INDEX-HINT|' | |
| 3046 r'NO-INHERIT-BGCOLOR|NO-INHERIT-BGC|NO-INHERIT-BGCO|LABEL-BGCOL|LABEL-BGCOLO|' | |
| 3047 r'NO-INHERIT-FGCOLOR|NO-INHERIT-FGC|NO-INHERIT-FGCO|NO-INHERIT-FGCOL|NO-INHERIT-FGCOLO|' | |
| 3048 r'NO-JOIN-BY-SQLDB|NO-LABELS|NO-LABE|NO-LOBS|NO-LOCK|' | |
| 3049 r'NO-LOOKAHEAD|NO-MAP|' | |
| 3050 r'NO-MESSAGE|NO-MES|NO-MESS|NO-MESSA|NO-MESSAG|' | |
| 3051 r'NONAMESPACE-SCHEMA-LOCATION|NONE|NO-PAUSE|' | |
| 3052 r'NO-PREFETCH|NO-PREFE|NO-PREFET|NO-PREFETC|NORMALIZE|' | |
| 3053 r'NO-ROW-MARKERS|NO-SCROLLBAR-VERTICAL|NO-SEPARATE-CONNECTION|' | |
| 3054 r'NO-SEPARATORS|NOT|NO-TAB-STOP|NOT-ACTIVE|' | |
| 3055 r'NO-UNDERLINE|NO-UND|NO-UNDE|NO-UNDER|NO-UNDERL|NO-UNDERLI|NO-UNDERLIN|' | |
| 3056 r'NO-UNDO|' | |
| 3057 r'NO-VALIDATE|NO-VAL|NO-VALI|NO-VALID|NO-VALIDA|NO-VALIDAT|NOW|' | |
| 3058 r'NO-WAIT|NO-WORD-WRAP|NULL|NUM-ALIASES|NUM-ALI|NUM-ALIA|NUM-ALIAS|NUM-ALIASE|' | |
| 3059 r'NUM-BUFFERS|NUM-BUTTONS|NUM-BUT|NUM-BUTT|NUM-BUTTO|NUM-BUTTON|' | |
| 3060 r'NUM-COLUMNS|NUM-COL|NUM-COLU|NUM-COLUM|NUM-COLUMN|NUM-COPIES|' | |
| 3061 r'NUM-DBS|NUM-DROPPED-FILES|NUM-ENTRIES|NUMERIC|' | |
| 3062 r'NUMERIC-FORMAT|NUMERIC-F|NUMERIC-FO|NUMERIC-FOR|NUMERIC-FORM|NUMERIC-FORMA|' | |
| 3063 r'NUM-FIELDS|NUM-FORMATS|NUM-ITEMS|NUM-ITERATIONS|NUM-LINES|' | |
| 3064 r'NUM-LOCKED-COLUMNS|NUM-LOCKED-COL|NUM-LOCKED-COLU|NUM-LOCKED-COLUM|NUM-LOCKED-COLUMN|' | |
| 3065 r'NUM-MESSAGES|NUM-PARAMETERS|NUM-REFERENCES|NUM-REPLACED|NUM-RESULTS|NUM-SELECTED-ROWS|' | |
| 3066 r'NUM-SELECTED-WIDGETS|NUM-SELECTED|NUM-SELECTED-|NUM-SELECTED-W|NUM-SELECTED-WI|NUM-SELECTED-WID|NUM-SELECTED-WIDG|NUM-SELECTED-WIDGE|NUM-SELECTED-WIDGET|' | |
| 3067 r'NUM-TABS|NUM-TO-RETAIN|NUM-VISIBLE-COLUMNS|OCTET-LENGTH|OF|' | |
| 3068 r'OFF|OK|OK-CANCEL|OLD|ON|' | |
| 3069 r'ON-FRAME-BORDER|ON-FRAME|ON-FRAME-|ON-FRAME-B|ON-FRAME-BO|ON-FRAME-BOR|ON-FRAME-BORD|ON-FRAME-BORDE|' | |
| 3070 r'OPEN|OPSYS|OPTION|OR|ORDERED-JOIN|ORDINAL|' | |
| 3071 r'OS-APPEND|OS-COMMAND|OS-COPY|OS-CREATE-DIR|OS-DELETE|OS-DIR|' | |
| 3072 r'OS-DRIVES|OS-DRIVE|OS-ERROR|OS-GETENV|OS-RENAME|OTHERWISE|' | |
| 3073 r'OUTPUT|OVERLAY|OVERRIDE|OWNER|PAGE|' | |
| 3074 r'PAGE-BOTTOM|PAGE-BOT|PAGE-BOTT|PAGE-BOTTO|PAGED|' | |
| 3075 r'PAGE-NUMBER|PAGE-NUM|PAGE-NUMB|PAGE-NUMBE|PAGE-SIZE|' | |
| 3076 r'PAGE-TOP|PAGE-WIDTH|PAGE-WID|PAGE-WIDT|' | |
| 3077 r'PARAMETER|PARAM|PARAME|PARAMET|PARAMETE|' | |
| 3078 r'PARENT|PARSE-STATUS|PARTIAL-KEY|PASCAL|PASSWORD-FIELD|PATHNAME|PAUSE|' | |
| 3079 r'PBE-HASH-ALGORITHM|PBE-HASH-ALG|PBE-HASH-ALGO|PBE-HASH-ALGOR|PBE-HASH-ALGORI|PBE-HASH-ALGORIT|PBE-HASH-ALGORITH|' | |
| 3080 r'PBE-KEY-ROUNDS|PDBNAME|PERSISTENT|PERSIST|PERSISTE|PERSISTEN|' | |
| 3081 r'PERSISTENT-CACHE-DISABLED|PFCOLOR|PFC|PFCO|PFCOL|PFCOLO|PIXELS|' | |
| 3082 r'PIXELS-PER-COLUMN|PIXELS-PER-COL|PIXELS-PER-COLU|PIXELS-PER-COLUM|' | |
| 3083 r'PIXELS-PER-ROW|POPUP-MENU|POPUP-M|POPUP-ME|POPUP-MEN|' | |
| 3084 r'POPUP-ONLY|POPUP-O|POPUP-ON|POPUP-ONL|PORTRAIT|POSITION|' | |
| 3085 r'PRECISION|PREFER-DATASET|PREPARED|PREPARE-STRING|' | |
| 3086 r'PREPROCESS|PREPROC|PREPROCE|PREPROCES|' | |
| 3087 r'PRESELECT|PRESEL|PRESELE|PRESELEC|PREV|PREV-COLUMN|' | |
| 3088 r'PREV-SIBLING|' | |
| 3089 r'PREV-TAB-ITEM|PREV-TAB-I|PREV-TAB-IT|PREV-TAB-ITE|' | |
| 3090 r'PRIMARY|PRINTER|PRINTER-CONTROL-HANDLE|PRINTER-HDC|' | |
| 3091 r'PRINTER-NAME|PRINTER-PORT|PRINTER-SETUP|PRIVATE|' | |
| 3092 r'PRIVATE-DATA|PRIVATE-D|PRIVATE-DA|PRIVATE-DAT|' | |
| 3093 r'PRIVILEGES|' | |
| 3094 r'PROCEDURE|PROCE|PROCED|PROCEDU|PROCEDUR|' | |
| 3095 r'PROCEDURE-CALL-TYPE|' | |
| 3096 r'PROCESS|' | |
| 3097 r'PROC-HANDLE|PROC-HA|PROC-HAN|PROC-HAND|PROC-HANDL|' | |
| 3098 r'PROC-STATUS|PROC-ST|PROC-STA|PROC-STAT|PROC-STATU|' | |
| 3099 r'proc-text|proc-text-buffer|' | |
| 3100 r'PROFILER|PROGRAM-NAME|PROGRESS|' | |
| 3101 r'PROGRESS-SOURCE|PROGRESS-S|PROGRESS-SO|PROGRESS-SOU|PROGRESS-SOUR|PROGRESS-SOURC|' | |
| 3102 r'PROMPT|PROMPT-FOR|PROMPT-F|PROMPT-FO|PROMSGS|PROPATH|' | |
| 3103 r'PROPERTY|PROTECTED|PROVERSION|PROVERS|PROVERSI|PROVERSIO|' | |
| 3104 r'PROXY|PROXY-PASSWORD|PROXY-USERID|PUBLIC|PUBLIC-ID|' | |
| 3105 r'PUBLISH|PUBLISHED-EVENTS|PUT|PUTBYTE|PUT-BYTE|PUT-DOUBLE|' | |
| 3106 r'PUT-FLOAT|PUT-INT64|PUT-KEY-VALUE|PUT-KEY-VAL|PUT-KEY-VALU|PUT-LONG|' | |
| 3107 r'PUT-SHORT|PUT-STRING|PUT-UNSIGNED-LONG|QUERY|QUERY-CLOSE|QUERY-OFF-END|' | |
| 3108 r'QUERY-OPEN|QUERY-PREPARE|QUERY-TUNING|QUESTION|QUIT|QUOTER|' | |
| 3109 r'RADIO-BUTTONS|RADIO-SET|RANDOM|RAW-TRANSFER|' | |
| 3110 r'RCODE-INFORMATION|RCODE-INFO|RCODE-INFOR|RCODE-INFORM|RCODE-INFORMA|RCODE-INFORMAT|RCODE-INFORMATI|RCODE-INFORMATIO|' | |
| 3111 r'READ-AVAILABLE|READ-EXACT-NUM|READ-FILE|READKEY|READ-ONLY|READ-XML|READ-XMLSCHEMA|' | |
| 3112 r'REAL|RECORD-LENGTH|RECTANGLE|RECT|RECTA|RECTAN|RECTANG|RECTANGL|' | |
| 3113 r'RECURSIVE|REFERENCE-ONLY|REFRESH|REFRESHABLE|REFRESH-AUDIT-POLICY|' | |
| 3114 r'REGISTER-DOMAIN|RELEASE|REMOTE|REMOVE-EVENTS-PROCEDURE|REMOVE-SUPER-PROCEDURE|' | |
| 3115 r'REPEAT|REPLACE|REPLACE-SELECTION-TEXT|REPOSITION|REPOSITION-BACKWARD|' | |
| 3116 r'REPOSITION-FORWARD|REPOSITION-MODE|REPOSITION-TO-ROW|REPOSITION-TO-ROWID|' | |
| 3117 r'REQUEST|RESET|RESIZABLE|RESIZA|RESIZAB|RESIZABL|RESIZE|RESTART-ROW|' | |
| 3118 r'RESTART-ROWID|RETAIN|RETAIN-SHAPE|RETRY|RETRY-CANCEL|RETURN|' | |
| 3119 r'RETURN-INSERTED|RETURN-INS|RETURN-INSE|RETURN-INSER|RETURN-INSERT|RETURN-INSERTE|' | |
| 3120 r'RETURNS|RETURN-TO-START-DIR|RETURN-TO-START-DI|' | |
| 3121 r'RETURN-VALUE|RETURN-VAL|RETURN-VALU|' | |
| 3122 r'RETURN-VALUE-DATA-TYPE|REVERSE-FROM|REVERT|' | |
| 3123 r'REVOKE|RGB-VALUE|RIGHT-ALIGNED|RETURN-ALIGN|RETURN-ALIGNE|' | |
| 3124 r'RIGHT-TRIM|R-INDEX|ROLES|ROUND|ROUTINE-LEVEL|ROW|' | |
| 3125 r'ROW-HEIGHT-CHARS|HEIGHT|ROW-HEIGHT-PIXELS|HEIGHT-P|ROW-MARKERS|' | |
| 3126 r'ROW-OF|ROW-RESIZABLE|RULE|RUN|RUN-PROCEDURE|SAVE|SAVE-AS|' | |
| 3127 r'SAVE-FILE|SAX-COMPLETE|SAX-COMPLE|SAX-COMPLET|SAX-PARSE|SAX-PARSE-FIRST|' | |
| 3128 r'SAX-PARSE-NEXT|SAX-PARSER-ERROR|SAX-RUNNING|SAX-UNINITIALIZED|' | |
| 3129 r'SAX-WRITE-BEGIN|SAX-WRITE-COMPLETE|SAX-WRITE-CONTENT|SAX-WRITE-ELEMENT|' | |
| 3130 r'SAX-WRITE-ERROR|SAX-WRITE-IDLE|SAX-WRITER|SAX-WRITE-TAG|SCHEMA|' | |
| 3131 r'SCHEMA-LOCATION|SCHEMA-MARSHAL|SCHEMA-PATH|SCREEN|SCREEN-IO|' | |
| 3132 r'SCREEN-LINES|SCREEN-VALUE|SCREEN-VAL|SCREEN-VALU|SCROLL|SCROLLABLE|' | |
| 3133 r'SCROLLBAR-HORIZONTAL|SCROLLBAR-H|SCROLLBAR-HO|SCROLLBAR-HOR|SCROLLBAR-HORI|SCROLLBAR-HORIZ|SCROLLBAR-HORIZO|SCROLLBAR-HORIZON|SCROLLBAR-HORIZONT|SCROLLBAR-HORIZONTA|' | |
| 3134 r'SCROLL-BARS|' | |
| 3135 r'SCROLLBAR-VERTICAL|SCROLLBAR-V|SCROLLBAR-VE|SCROLLBAR-VER|SCROLLBAR-VERT|SCROLLBAR-VERTI|SCROLLBAR-VERTIC|SCROLLBAR-VERTICA|' | |
| 3136 r'SCROLL-DELTA|' | |
| 3137 r'SCROLLED-ROW-POSITION|SCROLLED-ROW-POS|SCROLLED-ROW-POSI|SCROLLED-ROW-POSIT|SCROLLED-ROW-POSITI|SCROLLED-ROW-POSITIO|' | |
| 3138 r'SCROLLING|SCROLL-OFFSET|SCROLL-TO-CURRENT-ROW|SCROLL-TO-ITEM|SCROLL-TO-I|SCROLL-TO-IT|SCROLL-TO-ITE|' | |
| 3139 r'SCROLL-TO-SELECTED-ROW|SDBNAME|SEAL|SEAL-TIMESTAMP|SEARCH|SEARCH-SELF|SEARCH-TARGET|' | |
| 3140 r'SECTION|SECURITY-POLICY|SEEK|SELECT|SELECTABLE|SELECT-ALL|' | |
| 3141 r'SELECTED|SELECT-FOCUSED-ROW|SELECTION|SELECTION-END|SELECTION-LIST|' | |
| 3142 r'SELECTION-START|SELECTION-TEXT|SELECT-NEXT-ROW|SELECT-PREV-ROW|' | |
| 3143 r'SELECT-ROW|SELF|SEND|send-sql-statement|send-sql|SENSITIVE|' | |
| 3144 r'SEPARATE-CONNECTION|SEPARATOR-FGCOLOR|SEPARATORS|SERVER|' | |
| 3145 r'SERVER-CONNECTION-BOUND|SERVER-CONNECTION-BOUND-REQUEST|' | |
| 3146 r'SERVER-CONNECTION-CONTEXT|SERVER-CONNECTION-ID|SERVER-OPERATING-MODE|' | |
| 3147 r'SESSION|SESSION-ID|SET|SET-APPL-CONTEXT|SET-ATTR-CALL-TYPE|SET-ATTRIBUTE-NODE|' | |
| 3148 r'SET-BLUE-VALUE|SET-BLUE|SET-BLUE-|SET-BLUE-V|SET-BLUE-VA|SET-BLUE-VAL|SET-BLUE-VALU|' | |
| 3149 r'SET-BREAK|SET-BUFFERS|SET-CALLBACK|SET-CLIENT|SET-COMMIT|SET-CONTENTS|' | |
| 3150 r'SET-CURRENT-VALUE|SET-DB-CLIENT|SET-DYNAMIC|SET-EVENT-MANAGER-OPTION|' | |
| 3151 r'SET-GREEN-VALUE|SET-GREEN|SET-GREEN-|SET-GREEN-V|SET-GREEN-VA|SET-GREEN-VAL|SET-GREEN-VALU|' | |
| 3152 r'SET-INPUT-SOURCE|SET-OPTION|SET-OUTPUT-DESTINATION|SET-PARAMETER|SET-POINTER-VALUE|' | |
| 3153 r'SET-PROPERTY|SET-RED-VALUE|SET-RED|SET-RED-|SET-RED-V|SET-RED-VA|SET-RED-VAL|SET-RED-VALU|' | |
| 3154 r'SET-REPOSITIONED-ROW|SET-RGB-VALUE|SET-ROLLBACK|SET-SELECTION|SET-SIZE|' | |
| 3155 r'SET-SORT-ARROW|SETUSERID|SETUSER|SETUSERI|SET-WAIT-STATE|SHA1-DIGEST|SHARED|' | |
| 3156 r'SHARE-LOCK|SHARE|SHARE-|SHARE-L|SHARE-LO|SHARE-LOC|SHOW-IN-TASKBAR|SHOW-STATS|SHOW-STAT|' | |
| 3157 r'SIDE-LABEL-HANDLE|SIDE-LABEL-H|SIDE-LABEL-HA|SIDE-LABEL-HAN|SIDE-LABEL-HAND|SIDE-LABEL-HANDL|' | |
| 3158 r'SIDE-LABELS|SIDE-LAB|SIDE-LABE|SIDE-LABEL|' | |
| 3159 r'SILENT|SIMPLE|SINGLE|SIZE|' | |
| 3160 r'SIZE-CHARS|SIZE-C|SIZE-CH|SIZE-CHA|SIZE-CHAR|' | |
| 3161 r'SIZE-PIXELS|SIZE-P|SIZE-PI|SIZE-PIX|SIZE-PIXE|SIZE-PIXEL|SKIP|' | |
| 3162 r'SKIP-DELETED-RECORD|SLIDER|SMALL-ICON|SMALLINT|SMALL-TITLE|SOME|SORT|' | |
| 3163 r'SORT-ASCENDING|SORT-NUMBER|SOURCE|SOURCE-PROCEDURE|SPACE|SQL|SQRT|' | |
| 3164 r'SSL-SERVER-NAME|STANDALONE|START|START-DOCUMENT|START-ELEMENT|START-MOVE|' | |
| 3165 r'START-RESIZE|START-ROW-RESIZE|STATE-DETAIL|STATIC|STATUS|STATUS-AREA|STATUS-AREA-FONT|' | |
| 3166 r'STDCALL|STOP|STOP-PARSING|STOPPED|STOPPE|' | |
| 3167 r'STORED-PROCEDURE|STORED-PROC|STORED-PROCE|STORED-PROCED|STORED-PROCEDU|STORED-PROCEDUR|' | |
| 3168 r'STREAM|STREAM-HANDLE|STREAM-IO|STRETCH-TO-FIT|STRICT|STRING|STRING-VALUE|STRING-XREF|' | |
| 3169 r'SUB-AVERAGE|SUB-AVE|SUB-AVER|SUB-AVERA|SUB-AVERAG|' | |
| 3170 r'SUB-COUNT|SUB-MAXIMUM|SUM-MAX|SUM-MAXI|SUM-MAXIM|SUM-MAXIMU|SUB-MENU|SUBSUB-|' | |
| 3171 r'MINIMUM|SUB-MIN|SUBSCRIBE|SUBSTITUTE|SUBST|SUBSTI|SUBSTIT|SUBSTITU|SUBSTITUT|' | |
| 3172 r'SUBSTRING|SUBSTR|SUBSTRI|SUBSTRIN|SUB-TOTAL|SUBTYPE|SUM|SUPER|SUPER-PROCEDURES|' | |
| 3173 r'SUPPRESS-NAMESPACE-PROCESSING|' | |
| 3174 r'SUPPRESS-WARNINGS|SUPPRESS-W|SUPPRESS-WA|SUPPRESS-WAR|SUPPRESS-WARN|SUPPRESS-WARNI|SUPPRESS-WARNIN|SUPPRESS-WARNING|' | |
| 3175 r'SYMMETRIC-ENCRYPTION-ALGORITHM|SYMMETRIC-ENCRYPTION-IV|SYMMETRIC-ENCRYPTION-KEY|SYMMETRIC-SUPPORT|' | |
| 3176 r'SYSTEM-ALERT-BOXES|SYSTEM-ALERT|SYSTEM-ALERT-|SYSTEM-ALERT-B|SYSTEM-ALERT-BO|SYSTEM-ALERT-BOX|SYSTEM-ALERT-BOXE|' | |
| 3177 r'SYSTEM-DIALOG|SYSTEM-HELP|SYSTEM-ID|TABLE|TABLE-HANDLE|TABLE-NUMBER|TAB-POSITION|' | |
| 3178 r'TAB-STOP|TARGET|TARGET-PROCEDURE|' | |
| 3179 r'TEMP-DIRECTORY|TEMP-DIR|TEMP-DIRE|TEMP-DIREC|TEMP-DIRECT|TEMP-DIRECTO|TEMP-DIRECTOR|' | |
| 3180 r'TEMP-TABLE|TEMP-TABLE-PREPARE|TERM|TERMINAL|TERM|TERMI|TERMIN|TERMINA|' | |
| 3181 r'TERMINATE|TEXT|TEXT-CURSOR|TEXT-SEG-GROW|TEXT-SELECTED|THEN|' | |
| 3182 r'THIS-OBJECT|THIS-PROCEDURE|THREE-D|THROW|THROUGH|THRU|TIC-MARKS|TIME|' | |
| 3183 r'TIME-SOURCE|TITLE|' | |
| 3184 r'TITLE-BGCOLOR|TITLE-BGC|TITLE-BGCO|TITLE-BGCOL|TITLE-BGCOLO|' | |
| 3185 r'TITLE-DCOLOR|TITLE-DC|TITLE-DCO|TITLE-DCOL|TITLE-DCOLO|' | |
| 3186 r'TITLE-FGCOLOR|TITLE-FGC|TITLE-FGCO|TITLE-FGCOL|TITLE-FGCOLO|' | |
| 3187 r'TITLE-FONT|TITLE-FO|TITLE-FON|' | |
| 3188 r'TO|TODAY|TOGGLE-BOX|TOOLTIP|TOOLTIPS|TOPIC|TOP-NAV-QUERY|TOP-ONLY|' | |
| 3189 r'TO-ROWID|TOTAL|TRAILING|TRANS|TRANSACTION|TRANSACTION-MODE|' | |
| 3190 r'TRANS-INIT-PROCEDURE|TRANSPARENT|TRIGGER|TRIGGERS|TRIM|' | |
| 3191 r'TRUE|TRUNCATE|TRUNC|TRUNCA|TRUNCAT|TYPE|TYPE-OF|' | |
| 3192 r'UNBOX|UNBUFFERED|UNBUFF|UNBUFFE|UNBUFFER|UNBUFFERE|' | |
| 3193 r'UNDERLINE|UNDERL|UNDERLI|UNDERLIN|UNDO|' | |
| 3194 r'UNFORMATTED|UNFORM|UNFORMA|UNFORMAT|UNFORMATT|UNFORMATTE|UNION|' | |
| 3195 r'UNIQUE|UNIQUE-ID|UNIQUE-MATCH|UNIX|UNLESS-HIDDEN|UNLOAD|' | |
| 3196 r'UNSIGNED-LONG|UNSUBSCRIBE|UP|UPDATE|UPDATE-ATTRIBUTE|' | |
| 3197 r'URL|URL-DECODE|URL-ENCODE|URL-PASSWORD|URL-USERID|USE|' | |
| 3198 r'USE-DICT-EXPS|USE-FILENAME|USE-INDEX|USER|USE-REVVIDEO|' | |
| 3199 r'USERID|USER-ID|USE-TEXT|USE-UNDERLINE|USE-WIDGET-POOL|' | |
| 3200 r'USING|V6DISPLAY|V6FRAME|VALIDATE|VALIDATE-EXPRESSION|' | |
| 3201 r'VALIDATE-MESSAGE|VALIDATE-SEAL|VALIDATION-ENABLED|VALID-EVENT|' | |
| 3202 r'VALID-HANDLE|VALID-OBJECT|VALUE|VALUE-CHANGED|VALUES|' | |
| 3203 r'VARIABLE|VAR|VARI|VARIA|VARIAB|VARIABL|VERBOSE|' | |
| 3204 r'VERSION|VERTICAL|VERT|VERTI|VERTIC|VERTICA|' | |
| 3205 r'VIEW|VIEW-AS|VIEW-FIRST-COLUMN-ON-REOPEN|' | |
| 3206 r'VIRTUAL-HEIGHT-CHARS|VIRTUAL-HEIGHT|VIRTUAL-HEIGHT-|VIRTUAL-HEIGHT-C|VIRTUAL-HEIGHT-CH|VIRTUAL-HEIGHT-CHA|VIRTUAL-HEIGHT-CHAR|' | |
| 3207 r'VIRTUAL-HEIGHT-PIXELS|VIRTUAL-HEIGHT-P|VIRTUAL-HEIGHT-PI|VIRTUAL-HEIGHT-PIX|VIRTUAL-HEIGHT-PIXE|VIRTUAL-HEIGHT-PIXEL|' | |
| 3208 r'VIRTUAL-WIDTH-CHARS|VIRTUAL-WIDTH|VIRTUAL-WIDTH-|VIRTUAL-WIDTH-C|VIRTUAL-WIDTH-CH|VIRTUAL-WIDTH-CHA|VIRTUAL-WIDTH-CHAR|' | |
| 3209 r'VIRTUAL-WIDTH-PIXELS|VIRTUAL-WIDTH-P|VIRTUAL-WIDTH-PI|VIRTUAL-WIDTH-PIX|VIRTUAL-WIDTH-PIXE|VIRTUAL-WIDTH-PIXEL|' | |
| 3210 r'VISIBLE|VOID|WAIT|WAIT-FOR|WARNING|WEB-CONTEXT|WEEKDAY|WHEN|' | |
| 3211 r'WHERE|WHILE|WIDGET|' | |
| 3212 r'WIDGET-ENTER|WIDGET-E|WIDGET-EN|WIDGET-ENT|WIDGET-ENTE|' | |
| 3213 r'WIDGET-ID|' | |
| 3214 r'WIDGET-LEAVE|WIDGET-L|WIDGET-LE|WIDGET-LEA|WIDGET-LEAV|' | |
| 3215 r'WIDGET-POOL|WIDTH|' | |
| 3216 r'WIDTH-CHARS|WIDTH|WIDTH-|WIDTH-C|WIDTH-CH|WIDTH-CHA|WIDTH-CHAR|' | |
| 3217 r'WIDTH-PIXELS|WIDTH-P|WIDTH-PI|WIDTH-PIX|WIDTH-PIXE|WIDTH-PIXEL|' | |
| 3218 r'WINDOW|' | |
| 3219 r'WINDOW-MAXIMIZED|WINDOW-MAXIM|WINDOW-MAXIMI|WINDOW-MAXIMIZ|WINDOW-MAXIMIZE|' | |
| 3220 r'WINDOW-MINIMIZED|WINDOW-MINIM|WINDOW-MINIMI|WINDOW-MINIMIZ|WINDOW-MINIMIZE|' | |
| 3221 r'WINDOW-NAME|WINDOW-NORMAL|WINDOW-STATE|WINDOW-STA|WINDOW-STAT|' | |
| 3222 r'WINDOW-SYSTEM|WITH|WORD-INDEX|WORD-WRAP|WORK-AREA-HEIGHT-PIXELS|' | |
| 3223 r'WORK-AREA-WIDTH-PIXELS|WORK-AREA-X|WORK-AREA-Y|WORKFILE|' | |
| 3224 r'WORK-TABLE|WORK-TAB|WORK-TABL|WRITE|WRITE-CDATA|WRITE-CHARACTERS|' | |
| 3225 r'WRITE-COMMENT|WRITE-DATA-ELEMENT|WRITE-EMPTY-ELEMENT|WRITE-ENTITY-REF|' | |
| 3226 r'WRITE-EXTERNAL-DTD|WRITE-FRAGMENT|WRITE-MESSAGE|' | |
| 3227 r'WRITE-PROCESSING-INSTRUCTION|WRITE-STATUS|WRITE-XML|WRITE-XMLSCHEMA|' | |
| 3228 r'X|XCODE|XML-DATA-TYPE|XML-NODE-TYPE|XML-SCHEMA-PATH|' | |
| 3229 r'XML-SUPPRESS-NAMESPACE-PROCESSING|X-OF|XREF|' | |
| 3230 r'XREF-XML|Y|YEAR|YEAR-OFFSET|YES|YES-NO|' | |
| 3231 r'YES-NO-CANCEL|Y-OF)\s*($|(?=[^0-9a-z_\-]))') | |
| 3232 | |
| 3233 tokens = { | |
| 3234 'root': [ | |
| 3235 (r'/\*', Comment.Multiline, 'comment'), | |
| 3236 (r'\{', Comment.Preproc, 'preprocessor'), | |
| 3237 (r'\s*&.*', Comment.Preproc), | |
| 3238 (r'0[xX][0-9a-fA-F]+[LlUu]*', Number.Hex), | |
| 3239 (r'(?i)(DEFINE|DEF|DEFI|DEFIN)\b', Keyword.Declaration), | |
| 3240 (types, Keyword.Type), | |
| 3241 (keywords, Name.Builtin), | |
| 3242 (r'"(\\\\|\\"|[^"])*"', String.Double), | |
| 3243 (r"'(\\\\|\\'|[^'])*'", String.Single), | |
| 3244 (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float), | |
| 3245 (r'[0-9]+', Number.Integer), | |
| 3246 (r'\s+', Text), | |
| 3247 (r'[+*/=-]', Operator), | |
| 3248 (r'[.:()]', Punctuation), | |
| 3249 (r'.', Name.Variable), # Lazy catch-all | |
| 3250 ], | |
| 3251 'comment': [ | |
| 3252 (r'[^*/]', Comment.Multiline), | |
| 3253 (r'/\*', Comment.Multiline, '#push'), | |
| 3254 (r'\*/', Comment.Multiline, '#pop'), | |
| 3255 (r'[*/]', Comment.Multiline) | |
| 3256 ], | |
| 3257 'preprocessor': [ | |
| 3258 (r'[^{}]', Comment.Preproc), | |
| 3259 (r'{', Comment.Preproc, '#push'), | |
| 3260 (r'}', Comment.Preproc, '#pop'), | |
| 3261 ], | |
| 3262 } | |
| 3263 | |
| 3264 | |
| 3265 class BroLexer(RegexLexer): | |
| 3266 """ | |
| 3267 For `Bro <http://bro-ids.org/>`_ scripts. | |
| 3268 | |
| 3269 *New in Pygments 1.5.* | |
| 3270 """ | |
| 3271 name = 'Bro' | |
| 3272 aliases = ['bro'] | |
| 3273 filenames = ['*.bro'] | |
| 3274 | |
| 3275 _hex = r'[0-9a-fA-F_]+' | |
| 3276 _float = r'((\d*\.?\d+)|(\d+\.?\d*))([eE][-+]?\d+)?' | |
| 3277 _h = r'[A-Za-z0-9][-A-Za-z0-9]*' | |
| 3278 | |
| 3279 tokens = { | |
| 3280 'root': [ | |
| 3281 # Whitespace | |
| 3282 (r'^@.*?\n', Comment.Preproc), | |
| 3283 (r'#.*?\n', Comment.Single), | |
| 3284 (r'\n', Text), | |
| 3285 (r'\s+', Text), | |
| 3286 (r'\\\n', Text), | |
| 3287 # Keywords | |
| 3288 (r'(add|alarm|break|case|const|continue|delete|do|else|enum|event' | |
| 3289 r'|export|for|function|if|global|local|module|next' | |
| 3290 r'|of|print|redef|return|schedule|type|when|while)\b', Keyword), | |
| 3291 (r'(addr|any|bool|count|counter|double|file|int|interval|net' | |
| 3292 r'|pattern|port|record|set|string|subnet|table|time|timer' | |
| 3293 r'|vector)\b', Keyword.Type), | |
| 3294 (r'(T|F)\b', Keyword.Constant), | |
| 3295 (r'(&)((?:add|delete|expire)_func|attr|(create|read|write)_expire' | |
| 3296 r'|default|disable_print_hook|raw_output|encrypt|group|log' | |
| 3297 r'|mergeable|optional|persistent|priority|redef' | |
| 3298 r'|rotate_(?:interval|size)|synchronized)\b', bygroups(Punctuation, | |
| 3299 Keyword)), | |
| 3300 (r'\s+module\b', Keyword.Namespace), | |
| 3301 # Addresses, ports and networks | |
| 3302 (r'\d+/(tcp|udp|icmp|unknown)\b', Number), | |
| 3303 (r'(\d+\.){3}\d+', Number), | |
| 3304 (r'(' + _hex + r'){7}' + _hex, Number), | |
| 3305 (r'0x' + _hex + r'(' + _hex + r'|:)*::(' + _hex + r'|:)*', Number), | |
| 3306 (r'((\d+|:)(' + _hex + r'|:)*)?::(' + _hex + r'|:)*', Number), | |
| 3307 (r'(\d+\.\d+\.|(\d+\.){2}\d+)', Number), | |
| 3308 # Hostnames | |
| 3309 (_h + r'(\.' + _h + r')+', String), | |
| 3310 # Numeric | |
| 3311 (_float + r'\s+(day|hr|min|sec|msec|usec)s?\b', Literal.Date), | |
| 3312 (r'0[xX]' + _hex, Number.Hex), | |
| 3313 (_float, Number.Float), | |
| 3314 (r'\d+', Number.Integer), | |
| 3315 (r'/', String.Regex, 'regex'), | |
| 3316 (r'"', String, 'string'), | |
| 3317 # Operators | |
| 3318 (r'[!%*/+:<=>?~|-]', Operator), | |
| 3319 (r'([-+=&|]{2}|[+=!><-]=)', Operator), | |
| 3320 (r'(in|match)\b', Operator.Word), | |
| 3321 (r'[{}()\[\]$.,;]', Punctuation), | |
| 3322 # Identfier | |
| 3323 (r'([_a-zA-Z]\w*)(::)', bygroups(Name, Name.Namespace)), | |
| 3324 (r'[a-zA-Z_][a-zA-Z_0-9]*', Name) | |
| 3325 ], | |
| 3326 'string': [ | |
| 3327 (r'"', String, '#pop'), | |
| 3328 (r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})', String.Escape), | |
| 3329 (r'[^\\"\n]+', String), | |
| 3330 (r'\\\n', String), | |
| 3331 (r'\\', String) | |
| 3332 ], | |
| 3333 'regex': [ | |
| 3334 (r'/', String.Regex, '#pop'), | |
| 3335 (r'\\[\\nt/]', String.Regex), # String.Escape is too intense here. | |
| 3336 (r'[^\\/\n]+', String.Regex), | |
| 3337 (r'\\\n', String.Regex), | |
| 3338 (r'\\', String.Regex) | |
| 3339 ] | |
| 3340 } |
