summaryrefslogtreecommitdiff
path: root/pygments/lexers/qlik.py
blob: bb4defd69e7e02fd0e702c2df9d064449a162190 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
"""
    pygments.lexers.qlik
    ~~~~~~~~~~~~~~~~~~~~

    Lexer for the qlik scripting language

    :copyright: Copyright 2006-2022 by the Pygments team, see AUTHORS.
    :license: BSD, see LICENSE for details.
"""

import re

from pygments.lexer import RegexLexer, include, bygroups, words
from pygments.token import Comment, Keyword, Name, Number, Operator, \
    Punctuation, String, Text
from pygments.lexers._qlik_builtins import OPERATORS_LIST, STATEMENT_LIST, \
    SCRIPT_FUNCTIONS, CONSTANT_LIST

__all__ = ["QlikLexer"]


class QlikLexer(RegexLexer):
    """
    Lexer for qlik code, including .qvs files

    .. versionadded:: 2.12
    """

    name = "Qlik"
    aliases = ["qlik", "qlikview", "qliksense", "qlikscript"]
    filenames = ["*.qvs", "*.qvw"]

    flags = re.IGNORECASE

    tokens = {
        # Handle multi-line comments
        "comment": [
            (r"\*/", Comment.Multiline, "#pop"),
            (r"[^*]+", Comment.Multiline),
        ],
        # Handle numbers
        "numerics": [
            (r"\b\d+\.\d+(e\d+)?[fd]?\b", Number.Float),
            (r"\b\d+\b", Number.Integer),
        ],
        # Handle variable names in things
        "interp": [
            (
                r"(\$\()(\w+)(\))",
                bygroups(String.Interpol, Name.Variable, String.Interpol),
            ),
        ],
        # Handle strings
        "string": [
            (r"'", String, "#pop"),
            include("interp"),
            (r"[^'$]+", String),
            (r"\$", String),
        ],
        #
        "assignment": [
            (r";", Punctuation, "#pop"),
            include("root"),
        ],
        "field_name_quote": [
            (r'"', String.Symbol, "#pop"),
            include("interp"),
            (r"[^\"$]+", String.Symbol),
            (r"\$", String.Symbol),
        ],
        "field_name_bracket": [
            (r"\]", String.Symbol, "#pop"),
            include("interp"),
            (r"[^\]$]+", String.Symbol),
            (r"\$", String.Symbol),
        ],
        "function": [(r"\)", Punctuation, "#pop"), include("root")],
        "root": [
            # Whitespace and comments
            (r"\s+", Text.Whitespace),
            (r"/\*", Comment.Multiline, "comment"),
            (r"//.*\n", Comment.Single),
            # variable assignment
            (r"(let|set)(\s+)", bygroups(Keyword.Declaration, Text.Whitespace),
             "assignment"),
            # Word operators
            (words(OPERATORS_LIST["words"], prefix=r"\b", suffix=r"\b"),
             Operator.Word),
            # Statements
            (words(STATEMENT_LIST, suffix=r"\b"), Keyword),
            # Table names
            (r"[a-z]\w*:", Keyword.Declaration),
            # Constants
            (words(CONSTANT_LIST, suffix=r"\b"), Keyword.Constant),
            # Functions
            (words(SCRIPT_FUNCTIONS, suffix=r"(?=\s*\()"), Name.Builtin,
             "function"),
            # interpolation - e.g. $(variableName)
            include("interp"),
            # Quotes denote a field/file name
            (r'"', String.Symbol, "field_name_quote"),
            # Square brackets denote a field/file name
            (r"\[", String.Symbol, "field_name_bracket"),
            # Strings
            (r"'", String, "string"),
            # Numbers
            include("numerics"),
            # Operator symbols
            (words(OPERATORS_LIST["symbols"]), Operator),
            # Strings denoted by single quotes
            (r"'.+?'", String),
            # Words as text
            (r"\b\w+\b", Text),
            # Basic punctuation
            (r"[,;.()\\/]", Punctuation),
        ],
    }