Mercurial Repositories > eric / file comparison
comparison: ThirdParty/Pygments/pygments/lexers/business.py
ThirdParty/Pygments/pygments/lexers/business.py
- changeset 4172
- 4f20dba37ab6
- child 4697
- c2e9bf425554
equal
deleted
inserted
replaced
| 4170:8bc578136279 | 4172:4f20dba37ab6 |
|---|---|
| 1 # -*- coding: utf-8 -*- | |
| 2 """ | |
| 3 pygments.lexers.business | |
| 4 ~~~~~~~~~~~~~~~~~~~~~~~~ | |
| 5 | |
| 6 Lexers for "business-oriented" languages. | |
| 7 | |
| 8 :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS. | |
| 9 :license: BSD, see LICENSE for details. | |
| 10 """ | |
| 11 | |
| 12 import re | |
| 13 | |
| 14 from pygments.lexer import RegexLexer, include, words, bygroups | |
| 15 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \ | |
| 16 Number, Punctuation, Error | |
| 17 | |
| 18 from pygments.lexers._openedge_builtins import OPENEDGEKEYWORDS | |
| 19 | |
| 20 __all__ = ['CobolLexer', 'CobolFreeformatLexer', 'ABAPLexer', 'OpenEdgeLexer', | |
| 21 'GoodDataCLLexer', 'MaqlLexer'] | |
| 22 | |
| 23 | |
| 24 class CobolLexer(RegexLexer): | |
| 25 """ | |
| 26 Lexer for OpenCOBOL code. | |
| 27 | |
| 28 .. versionadded:: 1.6 | |
| 29 """ | |
| 30 name = 'COBOL' | |
| 31 aliases = ['cobol'] | |
| 32 filenames = ['*.cob', '*.COB', '*.cpy', '*.CPY'] | |
| 33 mimetypes = ['text/x-cobol'] | |
| 34 flags = re.IGNORECASE | re.MULTILINE | |
| 35 | |
| 36 # Data Types: by PICTURE and USAGE | |
| 37 # Operators: **, *, +, -, /, <, >, <=, >=, =, <> | |
| 38 # Logical (?): NOT, AND, OR | |
| 39 | |
| 40 # Reserved words: | |
| 41 # http://opencobol.add1tocobol.com/#reserved-words | |
| 42 # Intrinsics: | |
| 43 # http://opencobol.add1tocobol.com/#does-opencobol-implement-any-intrinsic-functions | |
| 44 | |
| 45 tokens = { | |
| 46 'root': [ | |
| 47 include('comment'), | |
| 48 include('strings'), | |
| 49 include('core'), | |
| 50 include('nums'), | |
| 51 (r'[a-z0-9]([\w\-]*[a-z0-9]+)?', Name.Variable), | |
| 52 # (r'[\s]+', Text), | |
| 53 (r'[ \t]+', Text), | |
| 54 ], | |
| 55 'comment': [ | |
| 56 (r'(^.{6}[*/].*\n|^.{6}|\*>.*\n)', Comment), | |
| 57 ], | |
| 58 'core': [ | |
| 59 # Figurative constants | |
| 60 (r'(^|(?<=[^0-9a-z_\-]))(ALL\s+)?' | |
| 61 r'((ZEROES)|(HIGH-VALUE|LOW-VALUE|QUOTE|SPACE|ZERO)(S)?)' | |
| 62 r'\s*($|(?=[^0-9a-z_\-]))', | |
| 63 Name.Constant), | |
| 64 | |
| 65 # Reserved words STATEMENTS and other bolds | |
| 66 (words(( | |
| 67 'ACCEPT', 'ADD', 'ALLOCATE', 'CALL', 'CANCEL', 'CLOSE', 'COMPUTE', | |
| 68 'CONFIGURATION', 'CONTINUE', 'DATA', 'DELETE', 'DISPLAY', 'DIVIDE', | |
| 69 'DIVISION', 'ELSE', 'END', 'END-ACCEPT', | |
| 70 'END-ADD', 'END-CALL', 'END-COMPUTE', 'END-DELETE', 'END-DISPLAY', | |
| 71 'END-DIVIDE', 'END-EVALUATE', 'END-IF', 'END-MULTIPLY', 'END-OF-PAGE', | |
| 72 'END-PERFORM', 'END-READ', 'END-RETURN', 'END-REWRITE', 'END-SEARCH', | |
| 73 'END-START', 'END-STRING', 'END-SUBTRACT', 'END-UNSTRING', 'END-WRITE', | |
| 74 'ENVIRONMENT', 'EVALUATE', 'EXIT', 'FD', 'FILE', 'FILE-CONTROL', 'FOREVER', | |
| 75 'FREE', 'GENERATE', 'GO', 'GOBACK', 'IDENTIFICATION', 'IF', 'INITIALIZE', | |
| 76 'INITIATE', 'INPUT-OUTPUT', 'INSPECT', 'INVOKE', 'I-O-CONTROL', 'LINKAGE', | |
| 77 'LOCAL-STORAGE', 'MERGE', 'MOVE', 'MULTIPLY', 'OPEN', 'PERFORM', | |
| 78 'PROCEDURE', 'PROGRAM-ID', 'RAISE', 'READ', 'RELEASE', 'RESUME', | |
| 79 'RETURN', 'REWRITE', 'SCREEN', 'SD', 'SEARCH', 'SECTION', 'SET', | |
| 80 'SORT', 'START', 'STOP', 'STRING', 'SUBTRACT', 'SUPPRESS', | |
| 81 'TERMINATE', 'THEN', 'UNLOCK', 'UNSTRING', 'USE', 'VALIDATE', | |
| 82 'WORKING-STORAGE', 'WRITE'), prefix=r'(^|(?<=[^0-9a-z_\-]))', | |
| 83 suffix=r'\s*($|(?=[^0-9a-z_\-]))'), | |
| 84 Keyword.Reserved), | |
| 85 | |
| 86 # Reserved words | |
| 87 (words(( | |
| 88 'ACCESS', 'ADDRESS', 'ADVANCING', 'AFTER', 'ALL', | |
| 89 'ALPHABET', 'ALPHABETIC', 'ALPHABETIC-LOWER', 'ALPHABETIC-UPPER', | |
| 90 'ALPHANUMERIC', 'ALPHANUMERIC-EDITED', 'ALSO', 'ALTER', 'ALTERNATE' | |
| 91 'ANY', 'ARE', 'AREA', 'AREAS', 'ARGUMENT-NUMBER', 'ARGUMENT-VALUE', 'AS', | |
| 92 'ASCENDING', 'ASSIGN', 'AT', 'AUTO', 'AUTO-SKIP', 'AUTOMATIC', 'AUTOTERMINATE', | |
| 93 'BACKGROUND-COLOR', 'BASED', 'BEEP', 'BEFORE', 'BELL', | |
| 94 'BLANK', 'BLINK', 'BLOCK', 'BOTTOM', 'BY', 'BYTE-LENGTH', 'CHAINING', | |
| 95 'CHARACTER', 'CHARACTERS', 'CLASS', 'CODE', 'CODE-SET', 'COL', 'COLLATING', | |
| 96 'COLS', 'COLUMN', 'COLUMNS', 'COMMA', 'COMMAND-LINE', 'COMMIT', 'COMMON', | |
| 97 'CONSTANT', 'CONTAINS', 'CONTENT', 'CONTROL', | |
| 98 'CONTROLS', 'CONVERTING', 'COPY', 'CORR', 'CORRESPONDING', 'COUNT', 'CRT', | |
| 99 'CURRENCY', 'CURSOR', 'CYCLE', 'DATE', 'DAY', 'DAY-OF-WEEK', 'DE', 'DEBUGGING', | |
| 100 'DECIMAL-POINT', 'DECLARATIVES', 'DEFAULT', 'DELIMITED', | |
| 101 'DELIMITER', 'DEPENDING', 'DESCENDING', 'DETAIL', 'DISK', | |
| 102 'DOWN', 'DUPLICATES', 'DYNAMIC', 'EBCDIC', | |
| 103 'ENTRY', 'ENVIRONMENT-NAME', 'ENVIRONMENT-VALUE', 'EOL', 'EOP', | |
| 104 'EOS', 'ERASE', 'ERROR', 'ESCAPE', 'EXCEPTION', | |
| 105 'EXCLUSIVE', 'EXTEND', 'EXTERNAL', | |
| 106 'FILE-ID', 'FILLER', 'FINAL', 'FIRST', 'FIXED', 'FLOAT-LONG', 'FLOAT-SHORT', | |
| 107 'FOOTING', 'FOR', 'FOREGROUND-COLOR', 'FORMAT', 'FROM', 'FULL', 'FUNCTION', | |
| 108 'FUNCTION-ID', 'GIVING', 'GLOBAL', 'GROUP', | |
| 109 'HEADING', 'HIGHLIGHT', 'I-O', 'ID', | |
| 110 'IGNORE', 'IGNORING', 'IN', 'INDEX', 'INDEXED', 'INDICATE', | |
| 111 'INITIAL', 'INITIALIZED', 'INPUT', | |
| 112 'INTO', 'INTRINSIC', 'INVALID', 'IS', 'JUST', 'JUSTIFIED', 'KEY', 'LABEL', | |
| 113 'LAST', 'LEADING', 'LEFT', 'LENGTH', 'LIMIT', 'LIMITS', 'LINAGE', | |
| 114 'LINAGE-COUNTER', 'LINE', 'LINES', 'LOCALE', 'LOCK', | |
| 115 'LOWLIGHT', 'MANUAL', 'MEMORY', 'MINUS', 'MODE', | |
| 116 'MULTIPLE', 'NATIONAL', 'NATIONAL-EDITED', 'NATIVE', | |
| 117 'NEGATIVE', 'NEXT', 'NO', 'NULL', 'NULLS', 'NUMBER', 'NUMBERS', 'NUMERIC', | |
| 118 'NUMERIC-EDITED', 'OBJECT-COMPUTER', 'OCCURS', 'OF', 'OFF', 'OMITTED', 'ON', 'ONLY', | |
| 119 'OPTIONAL', 'ORDER', 'ORGANIZATION', 'OTHER', 'OUTPUT', 'OVERFLOW', | |
| 120 'OVERLINE', 'PACKED-DECIMAL', 'PADDING', 'PAGE', 'PARAGRAPH', | |
| 121 'PLUS', 'POINTER', 'POSITION', 'POSITIVE', 'PRESENT', 'PREVIOUS', | |
| 122 'PRINTER', 'PRINTING', 'PROCEDURE-POINTER', 'PROCEDURES', | |
| 123 'PROCEED', 'PROGRAM', 'PROGRAM-POINTER', 'PROMPT', 'QUOTE', | |
| 124 'QUOTES', 'RANDOM', 'RD', 'RECORD', 'RECORDING', 'RECORDS', 'RECURSIVE', | |
| 125 'REDEFINES', 'REEL', 'REFERENCE', 'RELATIVE', 'REMAINDER', 'REMOVAL', | |
| 126 'RENAMES', 'REPLACING', 'REPORT', 'REPORTING', 'REPORTS', 'REPOSITORY', | |
| 127 'REQUIRED', 'RESERVE', 'RETURNING', 'REVERSE-VIDEO', 'REWIND', | |
| 128 'RIGHT', 'ROLLBACK', 'ROUNDED', 'RUN', 'SAME', 'SCROLL', | |
| 129 'SECURE', 'SEGMENT-LIMIT', 'SELECT', 'SENTENCE', 'SEPARATE', | |
| 130 'SEQUENCE', 'SEQUENTIAL', 'SHARING', 'SIGN', 'SIGNED', 'SIGNED-INT', | |
| 131 'SIGNED-LONG', 'SIGNED-SHORT', 'SIZE', 'SORT-MERGE', 'SOURCE', | |
| 132 'SOURCE-COMPUTER', 'SPECIAL-NAMES', 'STANDARD', | |
| 133 'STANDARD-1', 'STANDARD-2', 'STATUS', 'SUM', | |
| 134 'SYMBOLIC', 'SYNC', 'SYNCHRONIZED', 'TALLYING', 'TAPE', | |
| 135 'TEST', 'THROUGH', 'THRU', 'TIME', 'TIMES', 'TO', 'TOP', 'TRAILING', | |
| 136 'TRANSFORM', 'TYPE', 'UNDERLINE', 'UNIT', 'UNSIGNED', | |
| 137 'UNSIGNED-INT', 'UNSIGNED-LONG', 'UNSIGNED-SHORT', 'UNTIL', 'UP', | |
| 138 'UPDATE', 'UPON', 'USAGE', 'USING', 'VALUE', 'VALUES', 'VARYING', | |
| 139 'WAIT', 'WHEN', 'WITH', 'WORDS', 'YYYYDDD', 'YYYYMMDD'), | |
| 140 prefix=r'(^|(?<=[^0-9a-z_\-]))', suffix=r'\s*($|(?=[^0-9a-z_\-]))'), | |
| 141 Keyword.Pseudo), | |
| 142 | |
| 143 # inactive reserved words | |
| 144 (words(( | |
| 145 'ACTIVE-CLASS', 'ALIGNED', 'ANYCASE', 'ARITHMETIC', 'ATTRIBUTE', 'B-AND', | |
| 146 'B-NOT', 'B-OR', 'B-XOR', 'BIT', 'BOOLEAN', 'CD', 'CENTER', 'CF', 'CH', 'CHAIN', 'CLASS-ID', | |
| 147 'CLASSIFICATION', 'COMMUNICATION', 'CONDITION', 'DATA-POINTER', | |
| 148 'DESTINATION', 'DISABLE', 'EC', 'EGI', 'EMI', 'ENABLE', 'END-RECEIVE', | |
| 149 'ENTRY-CONVENTION', 'EO', 'ESI', 'EXCEPTION-OBJECT', 'EXPANDS', 'FACTORY', | |
| 150 'FLOAT-BINARY-16', 'FLOAT-BINARY-34', 'FLOAT-BINARY-7', | |
| 151 'FLOAT-DECIMAL-16', 'FLOAT-DECIMAL-34', 'FLOAT-EXTENDED', 'FORMAT', | |
| 152 'FUNCTION-POINTER', 'GET', 'GROUP-USAGE', 'IMPLEMENTS', 'INFINITY', | |
| 153 'INHERITS', 'INTERFACE', 'INTERFACE-ID', 'INVOKE', 'LC_ALL', 'LC_COLLATE', | |
| 154 'LC_CTYPE', 'LC_MESSAGES', 'LC_MONETARY', 'LC_NUMERIC', 'LC_TIME', | |
| 155 'LINE-COUNTER', 'MESSAGE', 'METHOD', 'METHOD-ID', 'NESTED', 'NONE', 'NORMAL', | |
| 156 'OBJECT', 'OBJECT-REFERENCE', 'OPTIONS', 'OVERRIDE', 'PAGE-COUNTER', 'PF', 'PH', | |
| 157 'PROPERTY', 'PROTOTYPE', 'PURGE', 'QUEUE', 'RAISE', 'RAISING', 'RECEIVE', | |
| 158 'RELATION', 'REPLACE', 'REPRESENTS-NOT-A-NUMBER', 'RESET', 'RESUME', 'RETRY', | |
| 159 'RF', 'RH', 'SECONDS', 'SEGMENT', 'SELF', 'SEND', 'SOURCES', 'STATEMENT', 'STEP', | |
| 160 'STRONG', 'SUB-QUEUE-1', 'SUB-QUEUE-2', 'SUB-QUEUE-3', 'SUPER', 'SYMBOL', | |
| 161 'SYSTEM-DEFAULT', 'TABLE', 'TERMINAL', 'TEXT', 'TYPEDEF', 'UCS-4', 'UNIVERSAL', | |
| 162 'USER-DEFAULT', 'UTF-16', 'UTF-8', 'VAL-STATUS', 'VALID', 'VALIDATE', | |
| 163 'VALIDATE-STATUS'), | |
| 164 prefix=r'(^|(?<=[^0-9a-z_\-]))', suffix=r'\s*($|(?=[^0-9a-z_\-]))'), | |
| 165 Error), | |
| 166 | |
| 167 # Data Types | |
| 168 (r'(^|(?<=[^0-9a-z_\-]))' | |
| 169 r'(PIC\s+.+?(?=(\s|\.\s))|PICTURE\s+.+?(?=(\s|\.\s))|' | |
| 170 r'(COMPUTATIONAL)(-[1-5X])?|(COMP)(-[1-5X])?|' | |
| 171 r'BINARY-C-LONG|' | |
| 172 r'BINARY-CHAR|BINARY-DOUBLE|BINARY-LONG|BINARY-SHORT|' | |
| 173 r'BINARY)\s*($|(?=[^0-9a-z_\-]))', Keyword.Type), | |
| 174 | |
| 175 # Operators | |
| 176 (r'(\*\*|\*|\+|-|/|<=|>=|<|>|==|/=|=)', Operator), | |
| 177 | |
| 178 # (r'(::)', Keyword.Declaration), | |
| 179 | |
| 180 (r'([(),;:&%.])', Punctuation), | |
| 181 | |
| 182 # Intrinsics | |
| 183 (r'(^|(?<=[^0-9a-z_\-]))(ABS|ACOS|ANNUITY|ASIN|ATAN|BYTE-LENGTH|' | |
| 184 r'CHAR|COMBINED-DATETIME|CONCATENATE|COS|CURRENT-DATE|' | |
| 185 r'DATE-OF-INTEGER|DATE-TO-YYYYMMDD|DAY-OF-INTEGER|DAY-TO-YYYYDDD|' | |
| 186 r'EXCEPTION-(?:FILE|LOCATION|STATEMENT|STATUS)|EXP10|EXP|E|' | |
| 187 r'FACTORIAL|FRACTION-PART|INTEGER-OF-(?:DATE|DAY|PART)|INTEGER|' | |
| 188 r'LENGTH|LOCALE-(?:DATE|TIME(?:-FROM-SECONDS)?)|LOG(?:10)?|' | |
| 189 r'LOWER-CASE|MAX|MEAN|MEDIAN|MIDRANGE|MIN|MOD|NUMVAL(?:-C)?|' | |
| 190 r'ORD(?:-MAX|-MIN)?|PI|PRESENT-VALUE|RANDOM|RANGE|REM|REVERSE|' | |
| 191 r'SECONDS-FROM-FORMATTED-TIME|SECONDS-PAST-MIDNIGHT|SIGN|SIN|SQRT|' | |
| 192 r'STANDARD-DEVIATION|STORED-CHAR-LENGTH|SUBSTITUTE(?:-CASE)?|' | |
| 193 r'SUM|TAN|TEST-DATE-YYYYMMDD|TEST-DAY-YYYYDDD|TRIM|' | |
| 194 r'UPPER-CASE|VARIANCE|WHEN-COMPILED|YEAR-TO-YYYY)\s*' | |
| 195 r'($|(?=[^0-9a-z_\-]))', Name.Function), | |
| 196 | |
| 197 # Booleans | |
| 198 (r'(^|(?<=[^0-9a-z_\-]))(true|false)\s*($|(?=[^0-9a-z_\-]))', Name.Builtin), | |
| 199 # Comparing Operators | |
| 200 (r'(^|(?<=[^0-9a-z_\-]))(equal|equals|ne|lt|le|gt|ge|' | |
| 201 r'greater|less|than|not|and|or)\s*($|(?=[^0-9a-z_\-]))', Operator.Word), | |
| 202 ], | |
| 203 | |
| 204 # \"[^\"\n]*\"|\'[^\'\n]*\' | |
| 205 'strings': [ | |
| 206 # apparently strings can be delimited by EOL if they are continued | |
| 207 # in the next line | |
| 208 (r'"[^"\n]*("|\n)', String.Double), | |
| 209 (r"'[^'\n]*('|\n)", String.Single), | |
| 210 ], | |
| 211 | |
| 212 'nums': [ | |
| 213 (r'\d+(\s*|\.$|$)', Number.Integer), | |
| 214 (r'[+-]?\d*\.\d+(E[-+]?\d+)?', Number.Float), | |
| 215 (r'[+-]?\d+\.\d*(E[-+]?\d+)?', Number.Float), | |
| 216 ], | |
| 217 } | |
| 218 | |
| 219 | |
| 220 class CobolFreeformatLexer(CobolLexer): | |
| 221 """ | |
| 222 Lexer for Free format OpenCOBOL code. | |
| 223 | |
| 224 .. versionadded:: 1.6 | |
| 225 """ | |
| 226 name = 'COBOLFree' | |
| 227 aliases = ['cobolfree'] | |
| 228 filenames = ['*.cbl', '*.CBL'] | |
| 229 mimetypes = [] | |
| 230 flags = re.IGNORECASE | re.MULTILINE | |
| 231 | |
| 232 tokens = { | |
| 233 'comment': [ | |
| 234 (r'(\*>.*\n|^\w*\*.*$)', Comment), | |
| 235 ], | |
| 236 } | |
| 237 | |
| 238 | |
| 239 class ABAPLexer(RegexLexer): | |
| 240 """ | |
| 241 Lexer for ABAP, SAP's integrated language. | |
| 242 | |
| 243 .. versionadded:: 1.1 | |
| 244 """ | |
| 245 name = 'ABAP' | |
| 246 aliases = ['abap'] | |
| 247 filenames = ['*.abap'] | |
| 248 mimetypes = ['text/x-abap'] | |
| 249 | |
| 250 flags = re.IGNORECASE | re.MULTILINE | |
| 251 | |
| 252 tokens = { | |
| 253 'common': [ | |
| 254 (r'\s+', Text), | |
| 255 (r'^\*.*$', Comment.Single), | |
| 256 (r'\".*?\n', Comment.Single), | |
| 257 ], | |
| 258 'variable-names': [ | |
| 259 (r'<\S+>', Name.Variable), | |
| 260 (r'\w[\w~]*(?:(\[\])|->\*)?', Name.Variable), | |
| 261 ], | |
| 262 'root': [ | |
| 263 include('common'), | |
| 264 # function calls | |
| 265 (r'(CALL\s+(?:BADI|CUSTOMER-FUNCTION|FUNCTION))(\s+)(\'?\S+\'?)', | |
| 266 bygroups(Keyword, Text, Name.Function)), | |
| 267 (r'(CALL\s+(?:DIALOG|SCREEN|SUBSCREEN|SELECTION-SCREEN|' | |
| 268 r'TRANSACTION|TRANSFORMATION))\b', | |
| 269 Keyword), | |
| 270 (r'(FORM|PERFORM)(\s+)(\w+)', | |
| 271 bygroups(Keyword, Text, Name.Function)), | |
| 272 (r'(PERFORM)(\s+)(\()(\w+)(\))', | |
| 273 bygroups(Keyword, Text, Punctuation, Name.Variable, Punctuation)), | |
| 274 (r'(MODULE)(\s+)(\S+)(\s+)(INPUT|OUTPUT)', | |
| 275 bygroups(Keyword, Text, Name.Function, Text, Keyword)), | |
| 276 | |
| 277 # method implementation | |
| 278 (r'(METHOD)(\s+)([\w~]+)', | |
| 279 bygroups(Keyword, Text, Name.Function)), | |
| 280 # method calls | |
| 281 (r'(\s+)([\w\-]+)([=\-]>)([\w\-~]+)', | |
| 282 bygroups(Text, Name.Variable, Operator, Name.Function)), | |
| 283 # call methodnames returning style | |
| 284 (r'(?<=(=|-)>)([\w\-~]+)(?=\()', Name.Function), | |
| 285 | |
| 286 # keywords with dashes in them. | |
| 287 # these need to be first, because for instance the -ID part | |
| 288 # of MESSAGE-ID wouldn't get highlighted if MESSAGE was | |
| 289 # first in the list of keywords. | |
| 290 (r'(ADD-CORRESPONDING|AUTHORITY-CHECK|' | |
| 291 r'CLASS-DATA|CLASS-EVENTS|CLASS-METHODS|CLASS-POOL|' | |
| 292 r'DELETE-ADJACENT|DIVIDE-CORRESPONDING|' | |
| 293 r'EDITOR-CALL|ENHANCEMENT-POINT|ENHANCEMENT-SECTION|EXIT-COMMAND|' | |
| 294 r'FIELD-GROUPS|FIELD-SYMBOLS|FUNCTION-POOL|' | |
| 295 r'INTERFACE-POOL|INVERTED-DATE|' | |
| 296 r'LOAD-OF-PROGRAM|LOG-POINT|' | |
| 297 r'MESSAGE-ID|MOVE-CORRESPONDING|MULTIPLY-CORRESPONDING|' | |
| 298 r'NEW-LINE|NEW-PAGE|NEW-SECTION|NO-EXTENSION|' | |
| 299 r'OUTPUT-LENGTH|PRINT-CONTROL|' | |
| 300 r'SELECT-OPTIONS|START-OF-SELECTION|SUBTRACT-CORRESPONDING|' | |
| 301 r'SYNTAX-CHECK|SYSTEM-EXCEPTIONS|' | |
| 302 r'TYPE-POOL|TYPE-POOLS' | |
| 303 r')\b', Keyword), | |
| 304 | |
| 305 # keyword kombinations | |
| 306 (r'CREATE\s+(PUBLIC|PRIVATE|DATA|OBJECT)|' | |
| 307 r'((PUBLIC|PRIVATE|PROTECTED)\s+SECTION|' | |
| 308 r'(TYPE|LIKE)(\s+(LINE\s+OF|REF\s+TO|' | |
| 309 r'(SORTED|STANDARD|HASHED)\s+TABLE\s+OF))?|' | |
| 310 r'FROM\s+(DATABASE|MEMORY)|CALL\s+METHOD|' | |
| 311 r'(GROUP|ORDER) BY|HAVING|SEPARATED BY|' | |
| 312 r'GET\s+(BADI|BIT|CURSOR|DATASET|LOCALE|PARAMETER|' | |
| 313 r'PF-STATUS|(PROPERTY|REFERENCE)\s+OF|' | |
| 314 r'RUN\s+TIME|TIME\s+(STAMP)?)?|' | |
| 315 r'SET\s+(BIT|BLANK\s+LINES|COUNTRY|CURSOR|DATASET|EXTENDED\s+CHECK|' | |
| 316 r'HANDLER|HOLD\s+DATA|LANGUAGE|LEFT\s+SCROLL-BOUNDARY|' | |
| 317 r'LOCALE|MARGIN|PARAMETER|PF-STATUS|PROPERTY\s+OF|' | |
| 318 r'RUN\s+TIME\s+(ANALYZER|CLOCK\s+RESOLUTION)|SCREEN|' | |
| 319 r'TITLEBAR|UPADTE\s+TASK\s+LOCAL|USER-COMMAND)|' | |
| 320 r'CONVERT\s+((INVERTED-)?DATE|TIME|TIME\s+STAMP|TEXT)|' | |
| 321 r'(CLOSE|OPEN)\s+(DATASET|CURSOR)|' | |
| 322 r'(TO|FROM)\s+(DATA BUFFER|INTERNAL TABLE|MEMORY ID|' | |
| 323 r'DATABASE|SHARED\s+(MEMORY|BUFFER))|' | |
| 324 r'DESCRIBE\s+(DISTANCE\s+BETWEEN|FIELD|LIST|TABLE)|' | |
| 325 r'FREE\s(MEMORY|OBJECT)?|' | |
| 326 r'PROCESS\s+(BEFORE\s+OUTPUT|AFTER\s+INPUT|' | |
| 327 r'ON\s+(VALUE-REQUEST|HELP-REQUEST))|' | |
| 328 r'AT\s+(LINE-SELECTION|USER-COMMAND|END\s+OF|NEW)|' | |
| 329 r'AT\s+SELECTION-SCREEN(\s+(ON(\s+(BLOCK|(HELP|VALUE)-REQUEST\s+FOR|' | |
| 330 r'END\s+OF|RADIOBUTTON\s+GROUP))?|OUTPUT))?|' | |
| 331 r'SELECTION-SCREEN:?\s+((BEGIN|END)\s+OF\s+((TABBED\s+)?BLOCK|LINE|' | |
| 332 r'SCREEN)|COMMENT|FUNCTION\s+KEY|' | |
| 333 r'INCLUDE\s+BLOCKS|POSITION|PUSHBUTTON|' | |
| 334 r'SKIP|ULINE)|' | |
| 335 r'LEAVE\s+(LIST-PROCESSING|PROGRAM|SCREEN|' | |
| 336 r'TO LIST-PROCESSING|TO TRANSACTION)' | |
| 337 r'(ENDING|STARTING)\s+AT|' | |
| 338 r'FORMAT\s+(COLOR|INTENSIFIED|INVERSE|HOTSPOT|INPUT|FRAMES|RESET)|' | |
| 339 r'AS\s+(CHECKBOX|SUBSCREEN|WINDOW)|' | |
| 340 r'WITH\s+(((NON-)?UNIQUE)?\s+KEY|FRAME)|' | |
| 341 r'(BEGIN|END)\s+OF|' | |
| 342 r'DELETE(\s+ADJACENT\s+DUPLICATES\sFROM)?|' | |
| 343 r'COMPARING(\s+ALL\s+FIELDS)?|' | |
| 344 r'INSERT(\s+INITIAL\s+LINE\s+INTO|\s+LINES\s+OF)?|' | |
| 345 r'IN\s+((BYTE|CHARACTER)\s+MODE|PROGRAM)|' | |
| 346 r'END-OF-(DEFINITION|PAGE|SELECTION)|' | |
| 347 r'WITH\s+FRAME(\s+TITLE)|' | |
| 348 | |
| 349 # simple kombinations | |
| 350 r'AND\s+(MARK|RETURN)|CLIENT\s+SPECIFIED|CORRESPONDING\s+FIELDS\s+OF|' | |
| 351 r'IF\s+FOUND|FOR\s+EVENT|INHERITING\s+FROM|LEAVE\s+TO\s+SCREEN|' | |
| 352 r'LOOP\s+AT\s+(SCREEN)?|LOWER\s+CASE|MATCHCODE\s+OBJECT|MODIF\s+ID|' | |
| 353 r'MODIFY\s+SCREEN|NESTING\s+LEVEL|NO\s+INTERVALS|OF\s+STRUCTURE|' | |
| 354 r'RADIOBUTTON\s+GROUP|RANGE\s+OF|REF\s+TO|SUPPRESS DIALOG|' | |
| 355 r'TABLE\s+OF|UPPER\s+CASE|TRANSPORTING\s+NO\s+FIELDS|' | |
| 356 r'VALUE\s+CHECK|VISIBLE\s+LENGTH|HEADER\s+LINE)\b', Keyword), | |
| 357 | |
| 358 # single word keywords. | |
| 359 (r'(^|(?<=(\s|\.)))(ABBREVIATED|ADD|ALIASES|APPEND|ASSERT|' | |
| 360 r'ASSIGN(ING)?|AT(\s+FIRST)?|' | |
| 361 r'BACK|BLOCK|BREAK-POINT|' | |
| 362 r'CASE|CATCH|CHANGING|CHECK|CLASS|CLEAR|COLLECT|COLOR|COMMIT|' | |
| 363 r'CREATE|COMMUNICATION|COMPONENTS?|COMPUTE|CONCATENATE|CONDENSE|' | |
| 364 r'CONSTANTS|CONTEXTS|CONTINUE|CONTROLS|' | |
| 365 r'DATA|DECIMALS|DEFAULT|DEFINE|DEFINITION|DEFERRED|DEMAND|' | |
| 366 r'DETAIL|DIRECTORY|DIVIDE|DO|' | |
| 367 r'ELSE(IF)?|ENDAT|ENDCASE|ENDCLASS|ENDDO|ENDFORM|ENDFUNCTION|' | |
| 368 r'ENDIF|ENDLOOP|ENDMETHOD|ENDMODULE|ENDSELECT|ENDTRY|' | |
| 369 r'ENHANCEMENT|EVENTS|EXCEPTIONS|EXIT|EXPORT|EXPORTING|EXTRACT|' | |
| 370 r'FETCH|FIELDS?|FIND|FOR|FORM|FORMAT|FREE|FROM|' | |
| 371 r'HIDE|' | |
| 372 r'ID|IF|IMPORT|IMPLEMENTATION|IMPORTING|IN|INCLUDE|INCLUDING|' | |
| 373 r'INDEX|INFOTYPES|INITIALIZATION|INTERFACE|INTERFACES|INTO|' | |
| 374 r'LENGTH|LINES|LOAD|LOCAL|' | |
| 375 r'JOIN|' | |
| 376 r'KEY|' | |
| 377 r'MAXIMUM|MESSAGE|METHOD[S]?|MINIMUM|MODULE|MODIFY|MOVE|MULTIPLY|' | |
| 378 r'NODES|' | |
| 379 r'OBLIGATORY|OF|OFF|ON|OVERLAY|' | |
| 380 r'PACK|PARAMETERS|PERCENTAGE|POSITION|PROGRAM|PROVIDE|PUBLIC|PUT|' | |
| 381 r'RAISE|RAISING|RANGES|READ|RECEIVE|REFRESH|REJECT|REPORT|RESERVE|' | |
| 382 r'RESUME|RETRY|RETURN|RETURNING|RIGHT|ROLLBACK|' | |
| 383 r'SCROLL|SEARCH|SELECT|SHIFT|SINGLE|SKIP|SORT|SPLIT|STATICS|STOP|' | |
| 384 r'SUBMIT|SUBTRACT|SUM|SUMMARY|SUMMING|SUPPLY|' | |
| 385 r'TABLE|TABLES|TIMES|TITLE|TO|TOP-OF-PAGE|TRANSFER|TRANSLATE|TRY|TYPES|' | |
| 386 r'ULINE|UNDER|UNPACK|UPDATE|USING|' | |
| 387 r'VALUE|VALUES|VIA|' | |
| 388 r'WAIT|WHEN|WHERE|WHILE|WITH|WINDOW|WRITE)\b', Keyword), | |
| 389 | |
| 390 # builtins | |
| 391 (r'(abs|acos|asin|atan|' | |
| 392 r'boolc|boolx|bit_set|' | |
| 393 r'char_off|charlen|ceil|cmax|cmin|condense|contains|' | |
| 394 r'contains_any_of|contains_any_not_of|concat_lines_of|cos|cosh|' | |
| 395 r'count|count_any_of|count_any_not_of|' | |
| 396 r'dbmaxlen|distance|' | |
| 397 r'escape|exp|' | |
| 398 r'find|find_end|find_any_of|find_any_not_of|floor|frac|from_mixed|' | |
| 399 r'insert|' | |
| 400 r'lines|log|log10|' | |
| 401 r'match|matches|' | |
| 402 r'nmax|nmin|numofchar|' | |
| 403 r'repeat|replace|rescale|reverse|round|' | |
| 404 r'segment|shift_left|shift_right|sign|sin|sinh|sqrt|strlen|' | |
| 405 r'substring|substring_after|substring_from|substring_before|substring_to|' | |
| 406 r'tan|tanh|to_upper|to_lower|to_mixed|translate|trunc|' | |
| 407 r'xstrlen)(\()\b', bygroups(Name.Builtin, Punctuation)), | |
| 408 | |
| 409 (r'&[0-9]', Name), | |
| 410 (r'[0-9]+', Number.Integer), | |
| 411 | |
| 412 # operators which look like variable names before | |
| 413 # parsing variable names. | |
| 414 (r'(?<=(\s|.))(AND|EQ|NE|GT|LT|GE|LE|CO|CN|CA|NA|CS|NOT|NS|CP|NP|' | |
| 415 r'BYTE-CO|BYTE-CN|BYTE-CA|BYTE-NA|BYTE-CS|BYTE-NS|' | |
| 416 r'IS\s+(NOT\s+)?(INITIAL|ASSIGNED|REQUESTED|BOUND))\b', Operator), | |
| 417 | |
| 418 include('variable-names'), | |
| 419 | |
| 420 # standard oparators after variable names, | |
| 421 # because < and > are part of field symbols. | |
| 422 (r'[?*<>=\-+]', Operator), | |
| 423 (r"'(''|[^'])*'", String.Single), | |
| 424 (r"`([^`])*`", String.Single), | |
| 425 (r'[/;:()\[\],.]', Punctuation) | |
| 426 ], | |
| 427 } | |
| 428 | |
| 429 | |
| 430 class OpenEdgeLexer(RegexLexer): | |
| 431 """ | |
| 432 Lexer for `OpenEdge ABL (formerly Progress) | |
| 433 <http://web.progress.com/en/openedge/abl.html>`_ source code. | |
| 434 | |
| 435 .. versionadded:: 1.5 | |
| 436 """ | |
| 437 name = 'OpenEdge ABL' | |
| 438 aliases = ['openedge', 'abl', 'progress'] | |
| 439 filenames = ['*.p', '*.cls'] | |
| 440 mimetypes = ['text/x-openedge', 'application/x-openedge'] | |
| 441 | |
| 442 types = (r'(?i)(^|(?<=[^0-9a-z_\-]))(CHARACTER|CHAR|CHARA|CHARAC|CHARACT|CHARACTE|' | |
| 443 r'COM-HANDLE|DATE|DATETIME|DATETIME-TZ|' | |
| 444 r'DECIMAL|DEC|DECI|DECIM|DECIMA|HANDLE|' | |
| 445 r'INT64|INTEGER|INT|INTE|INTEG|INTEGE|' | |
| 446 r'LOGICAL|LONGCHAR|MEMPTR|RAW|RECID|ROWID)\s*($|(?=[^0-9a-z_\-]))') | |
| 447 | |
| 448 keywords = words(OPENEDGEKEYWORDS, | |
| 449 prefix=r'(?i)(^|(?<=[^0-9a-z_\-]))', | |
| 450 suffix=r'\s*($|(?=[^0-9a-z_\-]))') | |
| 451 | |
| 452 tokens = { | |
| 453 'root': [ | |
| 454 (r'/\*', Comment.Multiline, 'comment'), | |
| 455 (r'\{', Comment.Preproc, 'preprocessor'), | |
| 456 (r'\s*&.*', Comment.Preproc), | |
| 457 (r'0[xX][0-9a-fA-F]+[LlUu]*', Number.Hex), | |
| 458 (r'(?i)(DEFINE|DEF|DEFI|DEFIN)\b', Keyword.Declaration), | |
| 459 (types, Keyword.Type), | |
| 460 (keywords, Name.Builtin), | |
| 461 (r'"(\\\\|\\"|[^"])*"', String.Double), | |
| 462 (r"'(\\\\|\\'|[^'])*'", String.Single), | |
| 463 (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float), | |
| 464 (r'[0-9]+', Number.Integer), | |
| 465 (r'\s+', Text), | |
| 466 (r'[+*/=-]', Operator), | |
| 467 (r'[.:()]', Punctuation), | |
| 468 (r'.', Name.Variable), # Lazy catch-all | |
| 469 ], | |
| 470 'comment': [ | |
| 471 (r'[^*/]', Comment.Multiline), | |
| 472 (r'/\*', Comment.Multiline, '#push'), | |
| 473 (r'\*/', Comment.Multiline, '#pop'), | |
| 474 (r'[*/]', Comment.Multiline) | |
| 475 ], | |
| 476 'preprocessor': [ | |
| 477 (r'[^{}]', Comment.Preproc), | |
| 478 (r'\{', Comment.Preproc, '#push'), | |
| 479 (r'\}', Comment.Preproc, '#pop'), | |
| 480 ], | |
| 481 } | |
| 482 | |
| 483 | |
| 484 class GoodDataCLLexer(RegexLexer): | |
| 485 """ | |
| 486 Lexer for `GoodData-CL | |
| 487 <http://github.com/gooddata/GoodData-CL/raw/master/cli/src/main/resources/\ | |
| 488 com/gooddata/processor/COMMANDS.txt>`_ | |
| 489 script files. | |
| 490 | |
| 491 .. versionadded:: 1.4 | |
| 492 """ | |
| 493 | |
| 494 name = 'GoodData-CL' | |
| 495 aliases = ['gooddata-cl'] | |
| 496 filenames = ['*.gdc'] | |
| 497 mimetypes = ['text/x-gooddata-cl'] | |
| 498 | |
| 499 flags = re.IGNORECASE | |
| 500 tokens = { | |
| 501 'root': [ | |
| 502 # Comments | |
| 503 (r'#.*', Comment.Single), | |
| 504 # Function call | |
| 505 (r'[a-z]\w*', Name.Function), | |
| 506 # Argument list | |
| 507 (r'\(', Punctuation, 'args-list'), | |
| 508 # Punctuation | |
| 509 (r';', Punctuation), | |
| 510 # Space is not significant | |
| 511 (r'\s+', Text) | |
| 512 ], | |
| 513 'args-list': [ | |
| 514 (r'\)', Punctuation, '#pop'), | |
| 515 (r',', Punctuation), | |
| 516 (r'[a-z]\w*', Name.Variable), | |
| 517 (r'=', Operator), | |
| 518 (r'"', String, 'string-literal'), | |
| 519 (r'[0-9]+(?:\.[0-9]+)?(?:e[+-]?[0-9]{1,3})?', Number), | |
| 520 # Space is not significant | |
| 521 (r'\s', Text) | |
| 522 ], | |
| 523 'string-literal': [ | |
| 524 (r'\\[tnrfbae"\\]', String.Escape), | |
| 525 (r'"', String, '#pop'), | |
| 526 (r'[^\\"]+', String) | |
| 527 ] | |
| 528 } | |
| 529 | |
| 530 | |
| 531 class MaqlLexer(RegexLexer): | |
| 532 """ | |
| 533 Lexer for `GoodData MAQL | |
| 534 <https://secure.gooddata.com/docs/html/advanced.metric.tutorial.html>`_ | |
| 535 scripts. | |
| 536 | |
| 537 .. versionadded:: 1.4 | |
| 538 """ | |
| 539 | |
| 540 name = 'MAQL' | |
| 541 aliases = ['maql'] | |
| 542 filenames = ['*.maql'] | |
| 543 mimetypes = ['text/x-gooddata-maql', 'application/x-gooddata-maql'] | |
| 544 | |
| 545 flags = re.IGNORECASE | |
| 546 tokens = { | |
| 547 'root': [ | |
| 548 # IDENTITY | |
| 549 (r'IDENTIFIER\b', Name.Builtin), | |
| 550 # IDENTIFIER | |
| 551 (r'\{[^}]+\}', Name.Variable), | |
| 552 # NUMBER | |
| 553 (r'[0-9]+(?:\.[0-9]+)?(?:e[+-]?[0-9]{1,3})?', Number), | |
| 554 # STRING | |
| 555 (r'"', String, 'string-literal'), | |
| 556 # RELATION | |
| 557 (r'\<\>|\!\=', Operator), | |
| 558 (r'\=|\>\=|\>|\<\=|\<', Operator), | |
| 559 # := | |
| 560 (r'\:\=', Operator), | |
| 561 # OBJECT | |
| 562 (r'\[[^]]+\]', Name.Variable.Class), | |
| 563 # keywords | |
| 564 (words(( | |
| 565 'DIMENSION', 'DIMENSIONS', 'BOTTOM', 'METRIC', 'COUNT', 'OTHER', | |
| 566 'FACT', 'WITH', 'TOP', 'OR', 'ATTRIBUTE', 'CREATE', 'PARENT', | |
| 567 'FALSE', 'ROW', 'ROWS', 'FROM', 'ALL', 'AS', 'PF', 'COLUMN', | |
| 568 'COLUMNS', 'DEFINE', 'REPORT', 'LIMIT', 'TABLE', 'LIKE', 'AND', | |
| 569 'BY', 'BETWEEN', 'EXCEPT', 'SELECT', 'MATCH', 'WHERE', 'TRUE', | |
| 570 'FOR', 'IN', 'WITHOUT', 'FILTER', 'ALIAS', 'WHEN', 'NOT', 'ON', | |
| 571 'KEYS', 'KEY', 'FULLSET', 'PRIMARY', 'LABELS', 'LABEL', | |
| 572 'VISUAL', 'TITLE', 'DESCRIPTION', 'FOLDER', 'ALTER', 'DROP', | |
| 573 'ADD', 'DATASET', 'DATATYPE', 'INT', 'BIGINT', 'DOUBLE', 'DATE', | |
| 574 'VARCHAR', 'DECIMAL', 'SYNCHRONIZE', 'TYPE', 'DEFAULT', 'ORDER', | |
| 575 'ASC', 'DESC', 'HYPERLINK', 'INCLUDE', 'TEMPLATE', 'MODIFY'), | |
| 576 suffix=r'\b'), | |
| 577 Keyword), | |
| 578 # FUNCNAME | |
| 579 (r'[a-z]\w*\b', Name.Function), | |
| 580 # Comments | |
| 581 (r'#.*', Comment.Single), | |
| 582 # Punctuation | |
| 583 (r'[,;()]', Punctuation), | |
| 584 # Space is not significant | |
| 585 (r'\s+', Text) | |
| 586 ], | |
| 587 'string-literal': [ | |
| 588 (r'\\[tnrfbae"\\]', String.Escape), | |
| 589 (r'"', String, '#pop'), | |
| 590 (r'[^\\"]+', String) | |
| 591 ], | |
| 592 } |
