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