pygments.rb 0.6.3 → 1.0.0

data/vendor/pygments-main/pygments/lexers/bibtex.py

@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.bibtex
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for BibTeX bibliography data and styles
+
+    :copyright: Copyright 2005-2015 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import RegexLexer, ExtendedRegexLexer, include, default, words
+from pygments.token import Name, Comment, String, Error, Number, Text, Keyword, Punctuation
+
+__all__ = ['BibTeXLexer', 'BSTLexer']
+
+
+class BibTeXLexer(ExtendedRegexLexer):
+    """
+    A lexer for BibTeX bibliography data format.
+
+    .. versionadded:: 2.2
+    """
+
+    name = 'BibTeX'
+    aliases = ['bib', 'bibtex']
+    filenames = ['*.bib']
+    mimetypes = ["text/x-bibtex"]
+    flags = re.IGNORECASE
+
+    ALLOWED_CHARS = r'@!$&*+\-./:;<>?\[\\\]^`|~'
+    IDENTIFIER = '[{0}][{1}]*'.format('a-z_' + ALLOWED_CHARS, r'\w' + ALLOWED_CHARS)
+
+    def open_brace_callback(self, match, ctx):
+        opening_brace = match.group()
+        ctx.opening_brace = opening_brace
+        yield match.start(), Punctuation, opening_brace
+        ctx.pos = match.end()
+
+    def close_brace_callback(self, match, ctx):
+        closing_brace = match.group()
+        if (
+            ctx.opening_brace == '{' and closing_brace != '}' or
+            ctx.opening_brace == '(' and closing_brace != ')'
+        ):
+            yield match.start(), Error, closing_brace
+        else:
+            yield match.start(), Punctuation, closing_brace
+        del ctx.opening_brace
+        ctx.pos = match.end()
+
+    tokens = {
+        'root': [
+            include('whitespace'),
+            ('@comment', Comment),
+            ('@preamble', Name.Class, ('closing-brace', 'value', 'opening-brace')),
+            ('@string', Name.Class, ('closing-brace', 'field', 'opening-brace')),
+            ('@' + IDENTIFIER, Name.Class, ('closing-brace', 'command-body', 'opening-brace')),
+            ('.+', Comment),
+        ],
+        'opening-brace': [
+            include('whitespace'),
+            (r'[{(]', open_brace_callback, '#pop'),
+        ],
+        'closing-brace': [
+            include('whitespace'),
+            (r'[})]', close_brace_callback, '#pop'),
+        ],
+        'command-body': [
+            include('whitespace'),
+            (r'[^\s\,\}]+', Name.Label, ('#pop', 'fields')),
+        ],
+        'fields': [
+            include('whitespace'),
+            (',', Punctuation, 'field'),
+            default('#pop'),
+        ],
+        'field': [
+            include('whitespace'),
+            (IDENTIFIER, Name.Attribute, ('value', '=')),
+            default('#pop'),
+        ],
+        '=': [
+            include('whitespace'),
+            ('=', Punctuation, '#pop'),
+        ],
+        'value': [
+            include('whitespace'),
+            (IDENTIFIER, Name.Variable),
+            ('"', String, 'quoted-string'),
+            (r'\{', String, 'braced-string'),
+            (r'[\d]+', Number),
+            ('#', Punctuation),
+            default('#pop'),
+        ],
+        'quoted-string': [
+            (r'\{', String, 'braced-string'),
+            ('"', String, '#pop'),
+            ('[^\{\"]+', String),
+        ],
+        'braced-string': [
+            (r'\{', String, '#push'),
+            (r'\}', String, '#pop'),
+            ('[^\{\}]+', String),
+        ],
+        'whitespace': [
+            (r'\s+', Text),
+        ],
+    }
+
+
+class BSTLexer(RegexLexer):
+    """
+    A lexer for BibTeX bibliography styles.
+
+    .. versionadded:: 2.2
+    """
+
+    name = 'BST'
+    aliases = ['bst', 'bst-pybtex']
+    filenames = ['*.bst']
+    flags = re.IGNORECASE | re.MULTILINE
+
+    tokens = {
+        'root': [
+            include('whitespace'),
+            (words(['read', 'sort']), Keyword),
+            (words(['execute', 'integers', 'iterate', 'reverse', 'strings']), Keyword, ('group')),
+            (words(['function', 'macro']), Keyword, ('group', 'group')),
+            (words(['entry']), Keyword, ('group', 'group', 'group')),
+        ],
+        'group': [
+            include('whitespace'),
+            (r'\{', Punctuation, ('#pop', 'group-end', 'body')),
+        ],
+        'group-end': [
+            include('whitespace'),
+            (r'\}', Punctuation, '#pop'),
+        ],
+        'body': [
+            include('whitespace'),
+            (r"\'[^#\"\{\}\s]+", Name.Function),
+            (r'[^#\"\{\}\s]+\$', Name.Builtin),
+            (r'[^#\"\{\}\s]+', Name.Variable),
+            (r'"[^\"]*"', String),
+            (r'#-?\d+', Number),
+            (r'\{', Punctuation, ('group-end', 'body')),
+            default('#pop'),
+        ],
+        'whitespace': [
+            ('\s+', Text),
+            ('%.*?$', Comment.SingleLine),
+        ],
+    }

data/vendor/pygments-main/pygments/lexers/business.py

@@ -0,0 +1,594 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.business
+    ~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for "business-oriented" languages.
+
+    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import RegexLexer, include, words, bygroups
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Error
+
+from pygments.lexers._openedge_builtins import OPENEDGEKEYWORDS
+
+__all__ = ['CobolLexer', 'CobolFreeformatLexer', 'ABAPLexer', 'OpenEdgeLexer',
+           'GoodDataCLLexer', 'MaqlLexer']
+
+
+class CobolLexer(RegexLexer):
+    """
+    Lexer for OpenCOBOL code.
+
+    .. versionadded:: 1.6
+    """
+    name = 'COBOL'
+    aliases = ['cobol']
+    filenames = ['*.cob', '*.COB', '*.cpy', '*.CPY']
+    mimetypes = ['text/x-cobol']
+    flags = re.IGNORECASE | re.MULTILINE
+
+    # Data Types: by PICTURE and USAGE
+    # Operators: **, *, +, -, /, <, >, <=, >=, =, <>
+    # Logical (?): NOT, AND, OR
+
+    # Reserved words:
+    # http://opencobol.add1tocobol.com/#reserved-words
+    # Intrinsics:
+    # http://opencobol.add1tocobol.com/#does-opencobol-implement-any-intrinsic-functions
+
+    tokens = {
+        'root': [
+            include('comment'),
+            include('strings'),
+            include('core'),
+            include('nums'),
+            (r'[a-z0-9]([\w\-]*[a-z0-9]+)?', Name.Variable),
+            # (r'[\s]+', Text),
+            (r'[ \t]+', Text),
+        ],
+        'comment': [
+            (r'(^.{6}[*/].*\n|^.{6}|\*>.*\n)', Comment),
+        ],
+        'core': [
+            # Figurative constants
+            (r'(^|(?<=[^\w\-]))(ALL\s+)?'
+             r'((ZEROES)|(HIGH-VALUE|LOW-VALUE|QUOTE|SPACE|ZERO)(S)?)'
+             r'\s*($|(?=[^\w\-]))',
+             Name.Constant),
+
+            # Reserved words STATEMENTS and other bolds
+            (words((
+                'ACCEPT', 'ADD', 'ALLOCATE', 'CALL', 'CANCEL', 'CLOSE', 'COMPUTE',
+                'CONFIGURATION', 'CONTINUE', 'DATA', 'DELETE', 'DISPLAY', 'DIVIDE',
+                'DIVISION', 'ELSE', 'END', 'END-ACCEPT',
+                'END-ADD', 'END-CALL', 'END-COMPUTE', 'END-DELETE', 'END-DISPLAY',
+                'END-DIVIDE', 'END-EVALUATE', 'END-IF', 'END-MULTIPLY', 'END-OF-PAGE',
+                'END-PERFORM', 'END-READ', 'END-RETURN', 'END-REWRITE', 'END-SEARCH',
+                'END-START', 'END-STRING', 'END-SUBTRACT', 'END-UNSTRING', 'END-WRITE',
+                'ENVIRONMENT', 'EVALUATE', 'EXIT', 'FD', 'FILE', 'FILE-CONTROL', 'FOREVER',
+                'FREE', 'GENERATE', 'GO', 'GOBACK', 'IDENTIFICATION', 'IF', 'INITIALIZE',
+                'INITIATE', 'INPUT-OUTPUT', 'INSPECT', 'INVOKE', 'I-O-CONTROL', 'LINKAGE',
+                'LOCAL-STORAGE', 'MERGE', 'MOVE', 'MULTIPLY', 'OPEN', 'PERFORM',
+                'PROCEDURE', 'PROGRAM-ID', 'RAISE', 'READ', 'RELEASE', 'RESUME',
+                'RETURN', 'REWRITE', 'SCREEN', 'SD', 'SEARCH', 'SECTION', 'SET',
+                'SORT', 'START', 'STOP', 'STRING', 'SUBTRACT', 'SUPPRESS',
+                'TERMINATE', 'THEN', 'UNLOCK', 'UNSTRING', 'USE', 'VALIDATE',
+                'WORKING-STORAGE', 'WRITE'), prefix=r'(^|(?<=[^\w\-]))',
+                suffix=r'\s*($|(?=[^\w\-]))'),
+             Keyword.Reserved),
+
+            # Reserved words
+            (words((
+                'ACCESS', 'ADDRESS', 'ADVANCING', 'AFTER', 'ALL',
+                'ALPHABET', 'ALPHABETIC', 'ALPHABETIC-LOWER', 'ALPHABETIC-UPPER',
+                'ALPHANUMERIC', 'ALPHANUMERIC-EDITED', 'ALSO', 'ALTER', 'ALTERNATE'
+                'ANY', 'ARE', 'AREA', 'AREAS', 'ARGUMENT-NUMBER', 'ARGUMENT-VALUE', 'AS',
+                'ASCENDING', 'ASSIGN', 'AT', 'AUTO', 'AUTO-SKIP', 'AUTOMATIC',
+                'AUTOTERMINATE', 'BACKGROUND-COLOR', 'BASED', 'BEEP', 'BEFORE', 'BELL',
+                'BLANK', 'BLINK', 'BLOCK', 'BOTTOM', 'BY', 'BYTE-LENGTH', 'CHAINING',
+                'CHARACTER', 'CHARACTERS', 'CLASS', 'CODE', 'CODE-SET', 'COL',
+                'COLLATING', 'COLS', 'COLUMN', 'COLUMNS', 'COMMA', 'COMMAND-LINE',
+                'COMMIT', 'COMMON', 'CONSTANT', 'CONTAINS', 'CONTENT', 'CONTROL',
+                'CONTROLS', 'CONVERTING', 'COPY', 'CORR', 'CORRESPONDING', 'COUNT', 'CRT',
+                'CURRENCY', 'CURSOR', 'CYCLE', 'DATE', 'DAY', 'DAY-OF-WEEK', 'DE',
+                'DEBUGGING', 'DECIMAL-POINT', 'DECLARATIVES', 'DEFAULT', 'DELIMITED',
+                'DELIMITER', 'DEPENDING', 'DESCENDING', 'DETAIL', 'DISK',
+                'DOWN', 'DUPLICATES', 'DYNAMIC', 'EBCDIC',
+                'ENTRY', 'ENVIRONMENT-NAME', 'ENVIRONMENT-VALUE', 'EOL', 'EOP',
+                'EOS', 'ERASE', 'ERROR', 'ESCAPE', 'EXCEPTION',
+                'EXCLUSIVE', 'EXTEND', 'EXTERNAL', 'FILE-ID', 'FILLER', 'FINAL',
+                'FIRST', 'FIXED', 'FLOAT-LONG', 'FLOAT-SHORT',
+                'FOOTING', 'FOR', 'FOREGROUND-COLOR', 'FORMAT', 'FROM', 'FULL',
+                'FUNCTION', 'FUNCTION-ID', 'GIVING', 'GLOBAL', 'GROUP',
+                'HEADING', 'HIGHLIGHT', 'I-O', 'ID',
+                'IGNORE', 'IGNORING', 'IN', 'INDEX', 'INDEXED', 'INDICATE',
+                'INITIAL', 'INITIALIZED', 'INPUT', 'INTO', 'INTRINSIC', 'INVALID',
+                'IS', 'JUST', 'JUSTIFIED', 'KEY', 'LABEL',
+                'LAST', 'LEADING', 'LEFT', 'LENGTH', 'LIMIT', 'LIMITS', 'LINAGE',
+                'LINAGE-COUNTER', 'LINE', 'LINES', 'LOCALE', 'LOCK',
+                'LOWLIGHT', 'MANUAL', 'MEMORY', 'MINUS', 'MODE', 'MULTIPLE',
+                'NATIONAL', 'NATIONAL-EDITED', 'NATIVE', 'NEGATIVE', 'NEXT', 'NO',
+                'NULL', 'NULLS', 'NUMBER', 'NUMBERS', 'NUMERIC', 'NUMERIC-EDITED',
+                'OBJECT-COMPUTER', 'OCCURS', 'OF', 'OFF', 'OMITTED', 'ON', 'ONLY',
+                'OPTIONAL', 'ORDER', 'ORGANIZATION', 'OTHER', 'OUTPUT', 'OVERFLOW',
+                'OVERLINE', 'PACKED-DECIMAL', 'PADDING', 'PAGE', 'PARAGRAPH',
+                'PLUS', 'POINTER', 'POSITION', 'POSITIVE', 'PRESENT', 'PREVIOUS',
+                'PRINTER', 'PRINTING', 'PROCEDURE-POINTER', 'PROCEDURES',
+                'PROCEED', 'PROGRAM', 'PROGRAM-POINTER', 'PROMPT', 'QUOTE',
+                'QUOTES', 'RANDOM', 'RD', 'RECORD', 'RECORDING', 'RECORDS', 'RECURSIVE',
+                'REDEFINES', 'REEL', 'REFERENCE', 'RELATIVE', 'REMAINDER', 'REMOVAL',
+                'RENAMES', 'REPLACING', 'REPORT', 'REPORTING', 'REPORTS', 'REPOSITORY',
+                'REQUIRED', 'RESERVE', 'RETURNING', 'REVERSE-VIDEO', 'REWIND',
+                'RIGHT', 'ROLLBACK', 'ROUNDED', 'RUN', 'SAME', 'SCROLL',
+                'SECURE', 'SEGMENT-LIMIT', 'SELECT', 'SENTENCE', 'SEPARATE',
+                'SEQUENCE', 'SEQUENTIAL', 'SHARING', 'SIGN', 'SIGNED', 'SIGNED-INT',
+                'SIGNED-LONG', 'SIGNED-SHORT', 'SIZE', 'SORT-MERGE', 'SOURCE',
+                'SOURCE-COMPUTER', 'SPECIAL-NAMES', 'STANDARD',
+                'STANDARD-1', 'STANDARD-2', 'STATUS', 'SUM',
+                'SYMBOLIC', 'SYNC', 'SYNCHRONIZED', 'TALLYING', 'TAPE',
+                'TEST', 'THROUGH', 'THRU', 'TIME', 'TIMES', 'TO', 'TOP', 'TRAILING',
+                'TRANSFORM', 'TYPE', 'UNDERLINE', 'UNIT', 'UNSIGNED',
+                'UNSIGNED-INT', 'UNSIGNED-LONG', 'UNSIGNED-SHORT', 'UNTIL', 'UP',
+                'UPDATE', 'UPON', 'USAGE', 'USING', 'VALUE', 'VALUES', 'VARYING',
+                'WAIT', 'WHEN', 'WITH', 'WORDS', 'YYYYDDD', 'YYYYMMDD'),
+                prefix=r'(^|(?<=[^\w\-]))', suffix=r'\s*($|(?=[^\w\-]))'),
+             Keyword.Pseudo),
+
+            # inactive reserved words
+            (words((
+                'ACTIVE-CLASS', 'ALIGNED', 'ANYCASE', 'ARITHMETIC', 'ATTRIBUTE',
+                'B-AND', 'B-NOT', 'B-OR', 'B-XOR', 'BIT', 'BOOLEAN', 'CD', 'CENTER',
+                'CF', 'CH', 'CHAIN', 'CLASS-ID', 'CLASSIFICATION', 'COMMUNICATION',
+                'CONDITION', 'DATA-POINTER', 'DESTINATION', 'DISABLE', 'EC', 'EGI',
+                'EMI', 'ENABLE', 'END-RECEIVE', 'ENTRY-CONVENTION', 'EO', 'ESI',
+                'EXCEPTION-OBJECT', 'EXPANDS', 'FACTORY', 'FLOAT-BINARY-16',
+                'FLOAT-BINARY-34', 'FLOAT-BINARY-7', 'FLOAT-DECIMAL-16',
+                'FLOAT-DECIMAL-34', 'FLOAT-EXTENDED', 'FORMAT', 'FUNCTION-POINTER',
+                'GET', 'GROUP-USAGE', 'IMPLEMENTS', 'INFINITY', 'INHERITS',
+                'INTERFACE', 'INTERFACE-ID', 'INVOKE', 'LC_ALL', 'LC_COLLATE',
+                'LC_CTYPE', 'LC_MESSAGES', 'LC_MONETARY', 'LC_NUMERIC', 'LC_TIME',
+                'LINE-COUNTER', 'MESSAGE', 'METHOD', 'METHOD-ID', 'NESTED', 'NONE',
+                'NORMAL', 'OBJECT', 'OBJECT-REFERENCE', 'OPTIONS', 'OVERRIDE',
+                'PAGE-COUNTER', 'PF', 'PH', 'PROPERTY', 'PROTOTYPE', 'PURGE',
+                'QUEUE', 'RAISE', 'RAISING', 'RECEIVE', 'RELATION', 'REPLACE',
+                'REPRESENTS-NOT-A-NUMBER', 'RESET', 'RESUME', 'RETRY', 'RF', 'RH',
+                'SECONDS', 'SEGMENT', 'SELF', 'SEND', 'SOURCES', 'STATEMENT',
+                'STEP', 'STRONG', 'SUB-QUEUE-1', 'SUB-QUEUE-2', 'SUB-QUEUE-3',
+                'SUPER', 'SYMBOL', 'SYSTEM-DEFAULT', 'TABLE', 'TERMINAL', 'TEXT',
+                'TYPEDEF', 'UCS-4', 'UNIVERSAL', 'USER-DEFAULT', 'UTF-16', 'UTF-8',
+                'VAL-STATUS', 'VALID', 'VALIDATE', 'VALIDATE-STATUS'),
+                   prefix=r'(^|(?<=[^\w\-]))', suffix=r'\s*($|(?=[^\w\-]))'),
+             Error),
+
+            # Data Types
+            (r'(^|(?<=[^\w\-]))'
+             r'(PIC\s+.+?(?=(\s|\.\s))|PICTURE\s+.+?(?=(\s|\.\s))|'
+             r'(COMPUTATIONAL)(-[1-5X])?|(COMP)(-[1-5X])?|'
+             r'BINARY-C-LONG|'
+             r'BINARY-CHAR|BINARY-DOUBLE|BINARY-LONG|BINARY-SHORT|'
+             r'BINARY)\s*($|(?=[^\w\-]))', Keyword.Type),
+
+            # Operators
+            (r'(\*\*|\*|\+|-|/|<=|>=|<|>|==|/=|=)', Operator),
+
+            # (r'(::)', Keyword.Declaration),
+
+            (r'([(),;:&%.])', Punctuation),
+
+            # Intrinsics
+            (r'(^|(?<=[^\w\-]))(ABS|ACOS|ANNUITY|ASIN|ATAN|BYTE-LENGTH|'
+             r'CHAR|COMBINED-DATETIME|CONCATENATE|COS|CURRENT-DATE|'
+             r'DATE-OF-INTEGER|DATE-TO-YYYYMMDD|DAY-OF-INTEGER|DAY-TO-YYYYDDD|'
+             r'EXCEPTION-(?:FILE|LOCATION|STATEMENT|STATUS)|EXP10|EXP|E|'
+             r'FACTORIAL|FRACTION-PART|INTEGER-OF-(?:DATE|DAY|PART)|INTEGER|'
+             r'LENGTH|LOCALE-(?:DATE|TIME(?:-FROM-SECONDS)?)|LOG(?:10)?|'
+             r'LOWER-CASE|MAX|MEAN|MEDIAN|MIDRANGE|MIN|MOD|NUMVAL(?:-C)?|'
+             r'ORD(?:-MAX|-MIN)?|PI|PRESENT-VALUE|RANDOM|RANGE|REM|REVERSE|'
+             r'SECONDS-FROM-FORMATTED-TIME|SECONDS-PAST-MIDNIGHT|SIGN|SIN|SQRT|'
+             r'STANDARD-DEVIATION|STORED-CHAR-LENGTH|SUBSTITUTE(?:-CASE)?|'
+             r'SUM|TAN|TEST-DATE-YYYYMMDD|TEST-DAY-YYYYDDD|TRIM|'
+             r'UPPER-CASE|VARIANCE|WHEN-COMPILED|YEAR-TO-YYYY)\s*'
+             r'($|(?=[^\w\-]))', Name.Function),
+
+            # Booleans
+            (r'(^|(?<=[^\w\-]))(true|false)\s*($|(?=[^\w\-]))', Name.Builtin),
+            # Comparing Operators
+            (r'(^|(?<=[^\w\-]))(equal|equals|ne|lt|le|gt|ge|'
+             r'greater|less|than|not|and|or)\s*($|(?=[^\w\-]))', Operator.Word),
+        ],
+
+        # \"[^\"\n]*\"|\'[^\'\n]*\'
+        'strings': [
+            # apparently strings can be delimited by EOL if they are continued
+            # in the next line
+            (r'"[^"\n]*("|\n)', String.Double),
+            (r"'[^'\n]*('|\n)", String.Single),
+        ],
+
+        'nums': [
+            (r'\d+(\s*|\.$|$)', Number.Integer),
+            (r'[+-]?\d*\.\d+(E[-+]?\d+)?', Number.Float),
+            (r'[+-]?\d+\.\d*(E[-+]?\d+)?', Number.Float),
+        ],
+    }
+
+
+class CobolFreeformatLexer(CobolLexer):
+    """
+    Lexer for Free format OpenCOBOL code.
+
+    .. versionadded:: 1.6
+    """
+    name = 'COBOLFree'
+    aliases = ['cobolfree']
+    filenames = ['*.cbl', '*.CBL']
+    mimetypes = []
+    flags = re.IGNORECASE | re.MULTILINE
+
+    tokens = {
+        'comment': [
+            (r'(\*>.*\n|^\w*\*.*$)', Comment),
+        ],
+    }
+
+
+class ABAPLexer(RegexLexer):
+    """
+    Lexer for ABAP, SAP's integrated language.
+
+    .. versionadded:: 1.1
+    """
+    name = 'ABAP'
+    aliases = ['abap']
+    filenames = ['*.abap', '*.ABAP']
+    mimetypes = ['text/x-abap']
+
+    flags = re.IGNORECASE | re.MULTILINE
+
+    tokens = {
+        'common': [
+            (r'\s+', Text),
+            (r'^\*.*$', Comment.Single),
+            (r'\".*?\n', Comment.Single),
+        ],
+        'variable-names': [
+            (r'<\S+>', Name.Variable),
+            (r'\w[\w~]*(?:(\[\])|->\*)?', Name.Variable),
+        ],
+        'root': [
+            include('common'),
+            # function calls
+            (r'(CALL\s+(?:BADI|CUSTOMER-FUNCTION|FUNCTION))(\s+)(\'?\S+\'?)',
+             bygroups(Keyword, Text, Name.Function)),
+            (r'(CALL\s+(?:DIALOG|SCREEN|SUBSCREEN|SELECTION-SCREEN|'
+             r'TRANSACTION|TRANSFORMATION))\b',
+             Keyword),
+            (r'(FORM|PERFORM)(\s+)(\w+)',
+             bygroups(Keyword, Text, Name.Function)),
+            (r'(PERFORM)(\s+)(\()(\w+)(\))',
+             bygroups(Keyword, Text, Punctuation, Name.Variable, Punctuation)),
+            (r'(MODULE)(\s+)(\S+)(\s+)(INPUT|OUTPUT)',
+             bygroups(Keyword, Text, Name.Function, Text, Keyword)),
+
+            # method implementation
+            (r'(METHOD)(\s+)([\w~]+)',
+             bygroups(Keyword, Text, Name.Function)),
+            # method calls
+            (r'(\s+)([\w\-]+)([=\-]>)([\w\-~]+)',
+             bygroups(Text, Name.Variable, Operator, Name.Function)),
+            # call methodnames returning style
+            (r'(?<=(=|-)>)([\w\-~]+)(?=\()', Name.Function),
+
+            # keywords with dashes in them.
+            # these need to be first, because for instance the -ID part
+            # of MESSAGE-ID wouldn't get highlighted if MESSAGE was
+            # first in the list of keywords.
+            (r'(ADD-CORRESPONDING|AUTHORITY-CHECK|'
+             r'CLASS-DATA|CLASS-EVENTS|CLASS-METHODS|CLASS-POOL|'
+             r'DELETE-ADJACENT|DIVIDE-CORRESPONDING|'
+             r'EDITOR-CALL|ENHANCEMENT-POINT|ENHANCEMENT-SECTION|EXIT-COMMAND|'
+             r'FIELD-GROUPS|FIELD-SYMBOLS|FUNCTION-POOL|'
+             r'INTERFACE-POOL|INVERTED-DATE|'
+             r'LOAD-OF-PROGRAM|LOG-POINT|'
+             r'MESSAGE-ID|MOVE-CORRESPONDING|MULTIPLY-CORRESPONDING|'
+             r'NEW-LINE|NEW-PAGE|NEW-SECTION|NO-EXTENSION|'
+             r'OUTPUT-LENGTH|PRINT-CONTROL|'
+             r'SELECT-OPTIONS|START-OF-SELECTION|SUBTRACT-CORRESPONDING|'
+             r'SYNTAX-CHECK|SYSTEM-EXCEPTIONS|'
+             r'TYPE-POOL|TYPE-POOLS'
+             r')\b', Keyword),
+
+            # keyword kombinations
+            (r'CREATE\s+(PUBLIC|PRIVATE|DATA|OBJECT)|'
+             r'((PUBLIC|PRIVATE|PROTECTED)\s+SECTION|'
+             r'(TYPE|LIKE)(\s+(LINE\s+OF|REF\s+TO|'
+             r'(SORTED|STANDARD|HASHED)\s+TABLE\s+OF))?|'
+             r'FROM\s+(DATABASE|MEMORY)|CALL\s+METHOD|'
+             r'(GROUP|ORDER) BY|HAVING|SEPARATED BY|'
+             r'GET\s+(BADI|BIT|CURSOR|DATASET|LOCALE|PARAMETER|'
+             r'PF-STATUS|(PROPERTY|REFERENCE)\s+OF|'
+             r'RUN\s+TIME|TIME\s+(STAMP)?)?|'
+             r'SET\s+(BIT|BLANK\s+LINES|COUNTRY|CURSOR|DATASET|EXTENDED\s+CHECK|'
+             r'HANDLER|HOLD\s+DATA|LANGUAGE|LEFT\s+SCROLL-BOUNDARY|'
+             r'LOCALE|MARGIN|PARAMETER|PF-STATUS|PROPERTY\s+OF|'
+             r'RUN\s+TIME\s+(ANALYZER|CLOCK\s+RESOLUTION)|SCREEN|'
+             r'TITLEBAR|UPADTE\s+TASK\s+LOCAL|USER-COMMAND)|'
+             r'CONVERT\s+((INVERTED-)?DATE|TIME|TIME\s+STAMP|TEXT)|'
+             r'(CLOSE|OPEN)\s+(DATASET|CURSOR)|'
+             r'(TO|FROM)\s+(DATA BUFFER|INTERNAL TABLE|MEMORY ID|'
+             r'DATABASE|SHARED\s+(MEMORY|BUFFER))|'
+             r'DESCRIBE\s+(DISTANCE\s+BETWEEN|FIELD|LIST|TABLE)|'
+             r'FREE\s(MEMORY|OBJECT)?|'
+             r'PROCESS\s+(BEFORE\s+OUTPUT|AFTER\s+INPUT|'
+             r'ON\s+(VALUE-REQUEST|HELP-REQUEST))|'
+             r'AT\s+(LINE-SELECTION|USER-COMMAND|END\s+OF|NEW)|'
+             r'AT\s+SELECTION-SCREEN(\s+(ON(\s+(BLOCK|(HELP|VALUE)-REQUEST\s+FOR|'
+             r'END\s+OF|RADIOBUTTON\s+GROUP))?|OUTPUT))?|'
+             r'SELECTION-SCREEN:?\s+((BEGIN|END)\s+OF\s+((TABBED\s+)?BLOCK|LINE|'
+             r'SCREEN)|COMMENT|FUNCTION\s+KEY|'
+             r'INCLUDE\s+BLOCKS|POSITION|PUSHBUTTON|'
+             r'SKIP|ULINE)|'
+             r'LEAVE\s+(LIST-PROCESSING|PROGRAM|SCREEN|'
+             r'TO LIST-PROCESSING|TO TRANSACTION)'
+             r'(ENDING|STARTING)\s+AT|'
+             r'FORMAT\s+(COLOR|INTENSIFIED|INVERSE|HOTSPOT|INPUT|FRAMES|RESET)|'
+             r'AS\s+(CHECKBOX|SUBSCREEN|WINDOW)|'
+             r'WITH\s+(((NON-)?UNIQUE)?\s+KEY|FRAME)|'
+             r'(BEGIN|END)\s+OF|'
+             r'DELETE(\s+ADJACENT\s+DUPLICATES\sFROM)?|'
+             r'COMPARING(\s+ALL\s+FIELDS)?|'
+             r'INSERT(\s+INITIAL\s+LINE\s+INTO|\s+LINES\s+OF)?|'
+             r'IN\s+((BYTE|CHARACTER)\s+MODE|PROGRAM)|'
+             r'END-OF-(DEFINITION|PAGE|SELECTION)|'
+             r'WITH\s+FRAME(\s+TITLE)|'
+
+             # simple kombinations
+             r'AND\s+(MARK|RETURN)|CLIENT\s+SPECIFIED|CORRESPONDING\s+FIELDS\s+OF|'
+             r'IF\s+FOUND|FOR\s+EVENT|INHERITING\s+FROM|LEAVE\s+TO\s+SCREEN|'
+             r'LOOP\s+AT\s+(SCREEN)?|LOWER\s+CASE|MATCHCODE\s+OBJECT|MODIF\s+ID|'
+             r'MODIFY\s+SCREEN|NESTING\s+LEVEL|NO\s+INTERVALS|OF\s+STRUCTURE|'
+             r'RADIOBUTTON\s+GROUP|RANGE\s+OF|REF\s+TO|SUPPRESS DIALOG|'
+             r'TABLE\s+OF|UPPER\s+CASE|TRANSPORTING\s+NO\s+FIELDS|'
+             r'VALUE\s+CHECK|VISIBLE\s+LENGTH|HEADER\s+LINE)\b', Keyword),
+
+            # single word keywords.
+            (r'(^|(?<=(\s|\.)))(ABBREVIATED|ADD|ALIASES|APPEND|ASSERT|'
+             r'ASSIGN(ING)?|AT(\s+FIRST)?|'
+             r'BACK|BLOCK|BREAK-POINT|'
+             r'CASE|CATCH|CHANGING|CHECK|CLASS|CLEAR|COLLECT|COLOR|COMMIT|'
+             r'CREATE|COMMUNICATION|COMPONENTS?|COMPUTE|CONCATENATE|CONDENSE|'
+             r'CONSTANTS|CONTEXTS|CONTINUE|CONTROLS|'
+             r'DATA|DECIMALS|DEFAULT|DEFINE|DEFINITION|DEFERRED|DEMAND|'
+             r'DETAIL|DIRECTORY|DIVIDE|DO|'
+             r'ELSE(IF)?|ENDAT|ENDCASE|ENDCLASS|ENDDO|ENDFORM|ENDFUNCTION|'
+             r'ENDIF|ENDLOOP|ENDMETHOD|ENDMODULE|ENDSELECT|ENDTRY|'
+             r'ENHANCEMENT|EVENTS|EXCEPTIONS|EXIT|EXPORT|EXPORTING|EXTRACT|'
+             r'FETCH|FIELDS?|FIND|FOR|FORM|FORMAT|FREE|FROM|'
+             r'HIDE|'
+             r'ID|IF|IMPORT|IMPLEMENTATION|IMPORTING|IN|INCLUDE|INCLUDING|'
+             r'INDEX|INFOTYPES|INITIALIZATION|INTERFACE|INTERFACES|INTO|'
+             r'LENGTH|LINES|LOAD|LOCAL|'
+             r'JOIN|'
+             r'KEY|'
+             r'MAXIMUM|MESSAGE|METHOD[S]?|MINIMUM|MODULE|MODIFY|MOVE|MULTIPLY|'
+             r'NODES|'
+             r'OBLIGATORY|OF|OFF|ON|OVERLAY|'
+             r'PACK|PARAMETERS|PERCENTAGE|POSITION|PROGRAM|PROVIDE|PUBLIC|PUT|'
+             r'RAISE|RAISING|RANGES|READ|RECEIVE|REFRESH|REJECT|REPORT|RESERVE|'
+             r'RESUME|RETRY|RETURN|RETURNING|RIGHT|ROLLBACK|'
+             r'SCROLL|SEARCH|SELECT|SHIFT|SINGLE|SKIP|SORT|SPLIT|STATICS|STOP|'
+             r'SUBMIT|SUBTRACT|SUM|SUMMARY|SUMMING|SUPPLY|'
+             r'TABLE|TABLES|TIMES|TITLE|TO|TOP-OF-PAGE|TRANSFER|TRANSLATE|TRY|TYPES|'
+             r'ULINE|UNDER|UNPACK|UPDATE|USING|'
+             r'VALUE|VALUES|VIA|'
+             r'WAIT|WHEN|WHERE|WHILE|WITH|WINDOW|WRITE)\b', Keyword),
+
+            # builtins
+            (r'(abs|acos|asin|atan|'
+             r'boolc|boolx|bit_set|'
+             r'char_off|charlen|ceil|cmax|cmin|condense|contains|'
+             r'contains_any_of|contains_any_not_of|concat_lines_of|cos|cosh|'
+             r'count|count_any_of|count_any_not_of|'
+             r'dbmaxlen|distance|'
+             r'escape|exp|'
+             r'find|find_end|find_any_of|find_any_not_of|floor|frac|from_mixed|'
+             r'insert|'
+             r'lines|log|log10|'
+             r'match|matches|'
+             r'nmax|nmin|numofchar|'
+             r'repeat|replace|rescale|reverse|round|'
+             r'segment|shift_left|shift_right|sign|sin|sinh|sqrt|strlen|'
+             r'substring|substring_after|substring_from|substring_before|substring_to|'
+             r'tan|tanh|to_upper|to_lower|to_mixed|translate|trunc|'
+             r'xstrlen)(\()\b', bygroups(Name.Builtin, Punctuation)),
+
+            (r'&[0-9]', Name),
+            (r'[0-9]+', Number.Integer),
+
+            # operators which look like variable names before
+            # parsing variable names.
+            (r'(?<=(\s|.))(AND|EQ|NE|GT|LT|GE|LE|CO|CN|CA|NA|CS|NOT|NS|CP|NP|'
+             r'BYTE-CO|BYTE-CN|BYTE-CA|BYTE-NA|BYTE-CS|BYTE-NS|'
+             r'IS\s+(NOT\s+)?(INITIAL|ASSIGNED|REQUESTED|BOUND))\b', Operator),
+
+            include('variable-names'),
+
+            # standard oparators after variable names,
+            # because < and > are part of field symbols.
+            (r'[?*<>=\-+]', Operator),
+            (r"'(''|[^'])*'", String.Single),
+            (r"`([^`])*`", String.Single),
+            (r'[/;:()\[\],.]', Punctuation)
+        ],
+    }
+
+
+class OpenEdgeLexer(RegexLexer):
+    """
+    Lexer for `OpenEdge ABL (formerly Progress)
+    <http://web.progress.com/en/openedge/abl.html>`_ source code.
+
+    .. versionadded:: 1.5
+    """
+    name = 'OpenEdge ABL'
+    aliases = ['openedge', 'abl', 'progress']
+    filenames = ['*.p', '*.cls']
+    mimetypes = ['text/x-openedge', 'application/x-openedge']
+
+    types = (r'(?i)(^|(?<=[^\w\-]))(CHARACTER|CHAR|CHARA|CHARAC|CHARACT|CHARACTE|'
+             r'COM-HANDLE|DATE|DATETIME|DATETIME-TZ|'
+             r'DECIMAL|DEC|DECI|DECIM|DECIMA|HANDLE|'
+             r'INT64|INTEGER|INT|INTE|INTEG|INTEGE|'
+             r'LOGICAL|LONGCHAR|MEMPTR|RAW|RECID|ROWID)\s*($|(?=[^\w\-]))')
+
+    keywords = words(OPENEDGEKEYWORDS,
+                     prefix=r'(?i)(^|(?<=[^\w\-]))',
+                     suffix=r'\s*($|(?=[^\w\-]))')
+
+    tokens = {
+        'root': [
+            (r'/\*', Comment.Multiline, 'comment'),
+            (r'\{', Comment.Preproc, 'preprocessor'),
+            (r'\s*&.*', Comment.Preproc),
+            (r'0[xX][0-9a-fA-F]+[LlUu]*', Number.Hex),
+            (r'(?i)(DEFINE|DEF|DEFI|DEFIN)\b', Keyword.Declaration),
+            (types, Keyword.Type),
+            (keywords, Name.Builtin),
+            (r'"(\\\\|\\"|[^"])*"', String.Double),
+            (r"'(\\\\|\\'|[^'])*'", String.Single),
+            (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
+            (r'[0-9]+', Number.Integer),
+            (r'\s+', Text),
+            (r'[+*/=-]', Operator),
+            (r'[.:()]', Punctuation),
+            (r'.', Name.Variable),  # Lazy catch-all
+        ],
+        'comment': [
+            (r'[^*/]', Comment.Multiline),
+            (r'/\*', Comment.Multiline, '#push'),
+            (r'\*/', Comment.Multiline, '#pop'),
+            (r'[*/]', Comment.Multiline)
+        ],
+        'preprocessor': [
+            (r'[^{}]', Comment.Preproc),
+            (r'\{', Comment.Preproc, '#push'),
+            (r'\}', Comment.Preproc, '#pop'),
+        ],
+    }
+
+
+class GoodDataCLLexer(RegexLexer):
+    """
+    Lexer for `GoodData-CL
+    <http://github.com/gooddata/GoodData-CL/raw/master/cli/src/main/resources/\
+com/gooddata/processor/COMMANDS.txt>`_
+    script files.
+
+    .. versionadded:: 1.4
+    """
+
+    name = 'GoodData-CL'
+    aliases = ['gooddata-cl']
+    filenames = ['*.gdc']
+    mimetypes = ['text/x-gooddata-cl']
+
+    flags = re.IGNORECASE
+    tokens = {
+        'root': [
+            # Comments
+            (r'#.*', Comment.Single),
+            # Function call
+            (r'[a-z]\w*', Name.Function),
+            # Argument list
+            (r'\(', Punctuation, 'args-list'),
+            # Punctuation
+            (r';', Punctuation),
+            # Space is not significant
+            (r'\s+', Text)
+        ],
+        'args-list': [
+            (r'\)', Punctuation, '#pop'),
+            (r',', Punctuation),
+            (r'[a-z]\w*', Name.Variable),
+            (r'=', Operator),
+            (r'"', String, 'string-literal'),
+            (r'[0-9]+(?:\.[0-9]+)?(?:e[+-]?[0-9]{1,3})?', Number),
+            # Space is not significant
+            (r'\s', Text)
+        ],
+        'string-literal': [
+            (r'\\[tnrfbae"\\]', String.Escape),
+            (r'"', String, '#pop'),
+            (r'[^\\"]+', String)
+        ]
+    }
+
+
+class MaqlLexer(RegexLexer):
+    """
+    Lexer for `GoodData MAQL
+    <https://secure.gooddata.com/docs/html/advanced.metric.tutorial.html>`_
+    scripts.
+
+    .. versionadded:: 1.4
+    """
+
+    name = 'MAQL'
+    aliases = ['maql']
+    filenames = ['*.maql']
+    mimetypes = ['text/x-gooddata-maql', 'application/x-gooddata-maql']
+
+    flags = re.IGNORECASE
+    tokens = {
+        'root': [
+            # IDENTITY
+            (r'IDENTIFIER\b', Name.Builtin),
+            # IDENTIFIER
+            (r'\{[^}]+\}', Name.Variable),
+            # NUMBER
+            (r'[0-9]+(?:\.[0-9]+)?(?:e[+-]?[0-9]{1,3})?', Number),
+            # STRING
+            (r'"', String, 'string-literal'),
+            #  RELATION
+            (r'\<\>|\!\=', Operator),
+            (r'\=|\>\=|\>|\<\=|\<', Operator),
+            # :=
+            (r'\:\=', Operator),
+            # OBJECT
+            (r'\[[^]]+\]', Name.Variable.Class),
+            # keywords
+            (words((
+                'DIMENSION', 'DIMENSIONS', 'BOTTOM', 'METRIC', 'COUNT', 'OTHER',
+                'FACT', 'WITH', 'TOP', 'OR', 'ATTRIBUTE', 'CREATE', 'PARENT',
+                'FALSE', 'ROW', 'ROWS', 'FROM', 'ALL', 'AS', 'PF', 'COLUMN',
+                'COLUMNS', 'DEFINE', 'REPORT', 'LIMIT', 'TABLE', 'LIKE', 'AND',
+                'BY', 'BETWEEN', 'EXCEPT', 'SELECT', 'MATCH', 'WHERE', 'TRUE',
+                'FOR', 'IN', 'WITHOUT', 'FILTER', 'ALIAS', 'WHEN', 'NOT', 'ON',
+                'KEYS', 'KEY', 'FULLSET', 'PRIMARY', 'LABELS', 'LABEL',
+                'VISUAL', 'TITLE', 'DESCRIPTION', 'FOLDER', 'ALTER', 'DROP',
+                'ADD', 'DATASET', 'DATATYPE', 'INT', 'BIGINT', 'DOUBLE', 'DATE',
+                'VARCHAR', 'DECIMAL', 'SYNCHRONIZE', 'TYPE', 'DEFAULT', 'ORDER',
+                'ASC', 'DESC', 'HYPERLINK', 'INCLUDE', 'TEMPLATE', 'MODIFY'),
+                suffix=r'\b'),
+             Keyword),
+            # FUNCNAME
+            (r'[a-z]\w*\b', Name.Function),
+            # Comments
+            (r'#.*', Comment.Single),
+            # Punctuation
+            (r'[,;()]', Punctuation),
+            # Space is not significant
+            (r'\s+', Text)
+        ],
+        'string-literal': [
+            (r'\\[tnrfbae"\\]', String.Escape),
+            (r'"', String, '#pop'),
+            (r'[^\\"]+', String)
+        ],
+    }