py2docfx 0.1.11.dev1869610__py3-none-any.whl → 0.1.11.dev1872139__py3-none-any.whl

py2docfx/venv/1/Lib/site-packages/pygments/lexers/dax.py

@@ -0,0 +1,135 @@
+"""
+    pygments.lexers.dax
+    ~~~~~~~~~~~~~~~~~~~
+
+    Lexer for LilyPond.
+
+    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, words
+from pygments.token import Comment, Punctuation, Whitespace,\
+    Name, Operator, String, Number, Text
+
+__all__ = ['DaxLexer']
+
+
+class DaxLexer(RegexLexer):
+    """
+    Lexer for Power BI DAX
+    Referenced from: https://github.com/sql-bi/SyntaxHighlighterBrushDax
+    """
+    name = 'Dax'
+    aliases = ['dax']
+    filenames = ['*.dax']
+    url = 'https://learn.microsoft.com/en-us/dax/dax-function-reference'
+    mimetypes = []
+    version_added = '2.15'
+
+    tokens = {
+        'root': [
+            (r'\s+', Whitespace),
+            (r"--.*\n?", Comment.Single),	# Comment: Double dash comment
+            (r"//.*\n?", Comment.Single),	# Comment: Double backslash comment
+            (r'/\*', Comment.Multiline, 'multiline-comments'),
+            (words(('abs', 'accrint', 'accrintm', 'acos', 'acosh', 'acot', 'acoth',
+                    'addcolumns', 'addmissingitems', 'all', 'allcrossfiltered',
+                    'allexcept', 'allnoblankrow', 'allselected', 'amordegrc', 'amorlinc',
+                    'and','approximatedistinctcount', 'asin', 'asinh', 'atan', 'atanh',
+                    'average', 'averagea', 'averagex', 'beta.dist', 'beta.inv',
+                    'bitand', 'bitlshift', 'bitor', 'bitrshift', 'bitxor', 'blank',
+                    'calculate', 'calculatetable', 'calendar', 'calendarauto', 'ceiling',
+                    'chisq.dist', 'chisq.dist.rt', 'chisq.inv', 'chisq.inv.rt',
+                    'closingbalancemonth', 'closingbalancequarter', 'closingbalanceyear',
+                    'coalesce', 'columnstatistics', 'combin', 'combina', 'combinevalues',
+                    'concatenate', 'concatenatex', 'confidence.norm', 'confidence.t',
+                    'contains', 'containsrow', 'containsstring', 'containsstringexact',
+                    'convert', 'cos', 'cosh', 'cot', 'coth', 'count', 'counta', 'countax',
+                    'countblank', 'countrows', 'countx', 'coupdaybs', 'coupdays',
+                    'coupdaysnc', 'coupncd', 'coupnum', 'couppcd', 'crossfilter',
+                    'crossjoin', 'cumipmt', 'cumprinc', 'currency', 'currentgroup',
+                    'customdata', 'datatable', 'date', 'dateadd', 'datediff',
+                    'datesbetween', 'datesinperiod', 'datesmtd', 'datesqtd',
+                    'datesytd', 'datevalue', 'day', 'db', 'ddb', 'degrees', 'detailrows',
+                    'disc', 'distinct', 'distinctcount', 'distinctcountnoblank',
+                    'divide', 'dollarde', 'dollarfr', 'duration', 'earlier', 'earliest',
+                    'edate', 'effect', 'endofmonth', 'endofquarter', 'endofyear',
+                    'eomonth', 'error', 'evaluateandlog', 'even', 'exact', 'except',
+                    'exp', 'expon.dist', 'fact', 'false', 'filter', 'filters', 'find',
+                    'firstdate', 'firstnonblank', 'firstnonblankvalue', 'fixed', 'floor',
+                    'format', 'fv', 'gcd', 'generate', 'generateall', 'generateseries',
+                    'geomean', 'geomeanx', 'groupby', 'hash', 'hasonefilter',
+                    'hasonevalue', 'hour', 'if', 'if.eager', 'iferror', 'ignore', 'index',
+                    'int', 'intersect', 'intrate', 'ipmt', 'isafter', 'isblank',
+                    'iscrossfiltered', 'isempty', 'iserror', 'iseven', 'isfiltered',
+                    'isinscope', 'islogical', 'isnontext', 'isnumber', 'iso.ceiling',
+                    'isodd', 'isonorafter', 'ispmt', 'isselectedmeasure', 'issubtotal',
+                    'istext', 'keepfilters', 'keywordmatch', 'lastdate', 'lastnonblank',
+                    'lastnonblankvalue', 'lcm', 'left', 'len', 'linest', 'linestx', 'ln',
+                    'log', 'log10', 'lookupvalue', 'lower', 'max', 'maxa', 'maxx',
+                    'mduration', 'median', 'medianx', 'mid', 'min', 'mina', 'minute',
+                    'minx', 'mod', 'month', 'mround', 'nameof', 'naturalinnerjoin',
+                    'naturalleftouterjoin', 'networkdays', 'nextday', 'nextmonth',
+                    'nextquarter', 'nextyear', 'nominal', 'nonvisual', 'norm.dist',
+                    'norm.inv', 'norm.s.dist', 'norm.s.inv', 'not', 'now', 'nper', 'odd',
+                    'oddfprice', 'oddfyield', 'oddlprice', 'oddlyield', 'offset',
+                    'openingbalancemonth', 'openingbalancequarter', 'openingbalanceyear',
+                    'or', 'orderby', 'parallelperiod', 'partitionby', 'path',
+                    'pathcontains', 'pathitem', 'pathitemreverse', 'pathlength',
+                    'pduration', 'percentile.exc', 'percentile.inc', 'percentilex.exc',
+                    'percentilex.inc', 'permut', 'pi', 'pmt', 'poisson.dist', 'power',
+                    'ppmt', 'previousday', 'previousmonth', 'previousquarter',
+                    'previousyear', 'price', 'pricedisc', 'pricemat', 'product',
+                    'productx', 'pv', 'quarter', 'quotient', 'radians', 'rand',
+                    'randbetween', 'rank.eq', 'rankx', 'rate', 'received', 'related',
+                    'relatedtable', 'removefilters', 'replace', 'rept', 'right',
+                    'rollup', 'rollupaddissubtotal', 'rollupgroup', 'rollupissubtotal',
+                    'round', 'rounddown', 'roundup', 'row', 'rri', 'sameperiodlastyear',
+                    'sample', 'sampleaxiswithlocalminmax', 'search', 'second',
+                    'selectcolumns', 'selectedmeasure', 'selectedmeasureformatstring',
+                    'selectedmeasurename', 'selectedvalue', 'sign', 'sin', 'sinh', 'sln',
+                    'sqrt', 'sqrtpi', 'startofmonth', 'startofquarter', 'startofyear',
+                    'stdev.p', 'stdev.s', 'stdevx.p', 'stdevx.s', 'substitute',
+                    'substitutewithindex', 'sum', 'summarize', 'summarizecolumns', 'sumx',
+                    'switch', 'syd', 't.dist', 't.dist.2t', 't.dist.rt', 't.inv',
+                    't.inv.2t', 'tan', 'tanh', 'tbilleq', 'tbillprice', 'tbillyield',
+                    'time', 'timevalue', 'tocsv', 'today', 'tojson', 'topn',
+                    'topnperlevel', 'topnskip', 'totalmtd', 'totalqtd', 'totalytd',
+                    'treatas', 'trim', 'true', 'trunc', 'unichar', 'unicode', 'union',
+                    'upper', 'userculture', 'userelationship', 'username', 'userobjectid',
+                    'userprincipalname', 'utcnow', 'utctoday', 'value', 'values', 'var.p',
+                    'var.s', 'varx.p', 'varx.s', 'vdb', 'weekday', 'weeknum', 'window',
+                    'xirr', 'xnpv', 'year', 'yearfrac', 'yield', 'yielddisc', 'yieldmat'),
+                 prefix=r'(?i)', suffix=r'\b'), Name.Function), #Functions
+
+            (words(('at','asc','boolean','both','by','create','currency',
+                'datetime','day','define','desc','double',
+                'evaluate','false','integer','measure',
+                'month','none','order','return','single','start','string',
+                'table','true','var','year'),
+                prefix=r'(?i)', suffix=r'\b'), Name.Builtin), # Keyword
+
+            (r':=|[-+*\/=^]', Operator),
+            (r'\b(IN|NOT)\b', Operator.Word),
+            (r'"', String, 'string'), #StringLiteral
+            (r"'(?:[^']|'')*'(?!')(?:\[[ \w]+\])?|\w+\[[ \w]+\]",
+                Name.Attribute),	# Column reference
+            (r"\[[ \w]+\]", Name.Attribute), #Measure reference
+            (r'(?<!\w)(\d+\.?\d*|\.\d+\b)', Number),# Number
+            (r'[\[\](){}`,.]', Punctuation), #Parenthesis
+            (r'.*\n', Text),
+
+        ],
+        'multiline-comments': [
+            (r'/\*', Comment.Multiline, 'multiline-comments'),
+            (r'\*/', Comment.Multiline, '#pop'),
+            (r'[^/*]+', Comment.Multiline),
+            (r'[/*]', Comment.Multiline)
+        ],
+        'string': [
+            (r'""', String.Escape),
+            (r'"', String, '#pop'),
+            (r'[^"]+', String),
+        ]
+    }

py2docfx/venv/1/Lib/site-packages/pygments/lexers/devicetree.py

@@ -0,0 +1,108 @@
+"""
+    pygments.lexers.devicetree
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for Devicetree language.
+
+    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, bygroups, include, default, words
+from pygments.token import Comment, Keyword, Name, Number, Operator, \
+    Punctuation, String, Text, Whitespace
+
+__all__ = ['DevicetreeLexer']
+
+
+class DevicetreeLexer(RegexLexer):
+    """
+    Lexer for Devicetree files.
+    """
+
+    name = 'Devicetree'
+    url = 'https://www.devicetree.org/'
+    aliases = ['devicetree', 'dts']
+    filenames = ['*.dts', '*.dtsi']
+    mimetypes = ['text/x-c']
+    version_added = '2.7'
+
+    #: optional Whitespace or /*...*/ style comment
+    _ws = r'\s*(?:/[*][^*/]*?[*]/\s*)*'
+
+    tokens = {
+        'macro': [
+            # Include preprocessor directives (C style):
+            (r'(#include)(' + _ws + r')([^\n]+)',
+             bygroups(Comment.Preproc, Comment.Multiline, Comment.PreprocFile)),
+            # Define preprocessor directives (C style):
+            (r'(#define)(' + _ws + r')([^\n]+)',
+             bygroups(Comment.Preproc, Comment.Multiline, Comment.Preproc)),
+            # devicetree style with file:
+            (r'(/[^*/{]+/)(' + _ws + r')("[^\n{]+")',
+             bygroups(Comment.Preproc, Comment.Multiline, Comment.PreprocFile)),
+            # devicetree style with property:
+            (r'(/[^*/{]+/)(' + _ws + r')([^\n;{]*)([;]?)',
+             bygroups(Comment.Preproc, Comment.Multiline, Comment.Preproc, Punctuation)),
+        ],
+        'whitespace': [
+            (r'\n', Whitespace),
+            (r'\s+', Whitespace),
+            (r'\\\n', Text),  # line continuation
+            (r'//(\n|[\w\W]*?[^\\]\n)', Comment.Single),
+            (r'/(\\\n)?[*][\w\W]*?[*](\\\n)?/', Comment.Multiline),
+            # Open until EOF, so no ending delimiter
+            (r'/(\\\n)?[*][\w\W]*', Comment.Multiline),
+        ],
+        'statements': [
+            (r'(L?)(")', bygroups(String.Affix, String), 'string'),
+            (r'0x[0-9a-fA-F]+', Number.Hex),
+            (r'\d+', Number.Integer),
+            (r'([^\s{}/*]*)(\s*)(:)', bygroups(Name.Label, Text, Punctuation), '#pop'),
+            (words(('compatible', 'model', 'phandle', 'status', '#address-cells',
+                    '#size-cells', 'reg', 'virtual-reg', 'ranges', 'dma-ranges',
+                    'device_type', 'name'), suffix=r'\b'), Keyword.Reserved),
+            (r'([~!%^&*+=|?:<>/#-])', Operator),
+            (r'[()\[\]{},.]', Punctuation),
+            (r'[a-zA-Z_][\w-]*(?=(?:\s*,\s*[a-zA-Z_][\w-]*|(?:' + _ws + r'))*\s*[=;])',
+             Name),
+            (r'[a-zA-Z_]\w*', Name.Attribute),
+        ],
+        'root': [
+            include('whitespace'),
+            include('macro'),
+
+            # Nodes
+            (r'([^/*@\s&]+|/)(@?)((?:0x)?[0-9a-fA-F,]*)(' + _ws + r')(\{)',
+             bygroups(Name.Function, Operator, Number.Integer,
+                      Comment.Multiline, Punctuation), 'node'),
+
+            default('statement'),
+        ],
+        'statement': [
+            include('whitespace'),
+            include('statements'),
+            (';', Punctuation, '#pop'),
+        ],
+        'node': [
+            include('whitespace'),
+            include('macro'),
+
+            (r'([^/*@\s&]+|/)(@?)((?:0x)?[0-9a-fA-F,]*)(' + _ws + r')(\{)',
+             bygroups(Name.Function, Operator, Number.Integer,
+                      Comment.Multiline, Punctuation), '#push'),
+
+            include('statements'),
+
+            (r'\};', Punctuation, '#pop'),
+            (';', Punctuation),
+        ],
+        'string': [
+            (r'"', String, '#pop'),
+            (r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|'
+             r'u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|[0-7]{1,3})', String.Escape),
+            (r'[^\\"\n]+', String),  # all other characters
+            (r'\\\n', String),  # line continuation
+            (r'\\', String),  # stray backslash
+        ],
+    }

py2docfx/venv/1/Lib/site-packages/pygments/lexers/diff.py

@@ -0,0 +1,169 @@
+"""
+    pygments.lexers.diff
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for diff/patch formats.
+
+    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import RegexLexer, include, bygroups
+from pygments.token import Text, Comment, Operator, Keyword, Name, Generic, \
+    Literal, Whitespace
+
+__all__ = ['DiffLexer', 'DarcsPatchLexer', 'WDiffLexer']
+
+
+class DiffLexer(RegexLexer):
+    """
+    Lexer for unified or context-style diffs or patches.
+    """
+
+    name = 'Diff'
+    aliases = ['diff', 'udiff']
+    filenames = ['*.diff', '*.patch']
+    mimetypes = ['text/x-diff', 'text/x-patch']
+    url = 'https://en.wikipedia.org/wiki/Diff'
+    version_added = ''
+
+    tokens = {
+        'root': [
+            (r'( )(.*)(\n)', bygroups(Whitespace, Text, Whitespace)),
+            (r'(!.*|---)(\n)', bygroups(Generic.Strong, Whitespace)),
+            (r'((?:< |-).*)(\n)', bygroups(Generic.Deleted, Whitespace)),
+            (r'((?:> |\+).*)(\n)', bygroups(Generic.Inserted, Whitespace)),
+            (
+                r'(@.*|\d(?:,\d+)?(?:a|c|d)\d+(?:,\d+)?)(\n)',
+                bygroups(Generic.Subheading, Whitespace),
+            ),
+            (r'((?:[Ii]ndex|diff).*)(\n)', bygroups(Generic.Heading, Whitespace)),
+            (r'(=.*)(\n)', bygroups(Generic.Heading, Whitespace)),
+            (r'(.*)(\n)', bygroups(Text, Whitespace)),
+        ]
+    }
+
+    def analyse_text(text):
+        if text[:7] == 'Index: ':
+            return True
+        if text[:5] == 'diff ':
+            return True
+        if text[:4] == '--- ':
+            return 0.9
+
+
+class DarcsPatchLexer(RegexLexer):
+    """
+    DarcsPatchLexer is a lexer for the various versions of the darcs patch
+    format.  Examples of this format are derived by commands such as
+    ``darcs annotate --patch`` and ``darcs send``.
+    """
+
+    name = 'Darcs Patch'
+    aliases = ['dpatch']
+    filenames = ['*.dpatch', '*.darcspatch']
+    url = 'https://darcs.net'
+    version_added = '0.10'
+
+    DPATCH_KEYWORDS = ('hunk', 'addfile', 'adddir', 'rmfile', 'rmdir', 'move',
+                       'replace')
+
+    tokens = {
+        'root': [
+            (r'<', Operator),
+            (r'>', Operator),
+            (r'\{', Operator),
+            (r'\}', Operator),
+            (r'(\[)((?:TAG )?)(.*)(\n)(.*)(\*\*)(\d+)(\s?)(\])',
+             bygroups(Operator, Keyword, Name, Whitespace, Name, Operator,
+                      Literal.Date, Whitespace, Operator)),
+            (r'(\[)((?:TAG )?)(.*)(\n)(.*)(\*\*)(\d+)(\s?)',
+             bygroups(Operator, Keyword, Name, Whitespace, Name, Operator,
+                      Literal.Date, Whitespace), 'comment'),
+            (r'New patches:', Generic.Heading),
+            (r'Context:', Generic.Heading),
+            (r'Patch bundle hash:', Generic.Heading),
+            (r'(\s*)({})(.*)(\n)'.format('|'.join(DPATCH_KEYWORDS)),
+                bygroups(Whitespace, Keyword, Text, Whitespace)),
+            (r'\+', Generic.Inserted, "insert"),
+            (r'-', Generic.Deleted, "delete"),
+            (r'(.*)(\n)', bygroups(Text, Whitespace)),
+        ],
+        'comment': [
+            (r'[^\]].*\n', Comment),
+            (r'\]', Operator, "#pop"),
+        ],
+        'specialText': [            # darcs add [_CODE_] special operators for clarity
+            (r'\n', Whitespace, "#pop"),  # line-based
+            (r'\[_[^_]*_]', Operator),
+        ],
+        'insert': [
+            include('specialText'),
+            (r'\[', Generic.Inserted),
+            (r'[^\n\[]+', Generic.Inserted),
+        ],
+        'delete': [
+            include('specialText'),
+            (r'\[', Generic.Deleted),
+            (r'[^\n\[]+', Generic.Deleted),
+        ],
+    }
+
+
+class WDiffLexer(RegexLexer):
+    """
+    A wdiff lexer.
+
+    Note that:
+
+    * It only works with normal output (without options like ``-l``).
+    * If the target files contain "[-", "-]", "{+", or "+}",
+      especially they are unbalanced, the lexer will get confused.
+    """
+
+    name = 'WDiff'
+    url = 'https://www.gnu.org/software/wdiff/'
+    aliases = ['wdiff']
+    filenames = ['*.wdiff']
+    mimetypes = []
+    version_added = '2.2'
+
+    flags = re.MULTILINE | re.DOTALL
+
+    # We can only assume "[-" after "[-" before "-]" is `nested`,
+    # for instance wdiff to wdiff outputs. We have no way to
+    # distinct these marker is of wdiff output from original text.
+
+    ins_op = r"\{\+"
+    ins_cl = r"\+\}"
+    del_op = r"\[\-"
+    del_cl = r"\-\]"
+    normal = r'[^{}[\]+-]+'  # for performance
+    tokens = {
+        'root': [
+            (ins_op, Generic.Inserted, 'inserted'),
+            (del_op, Generic.Deleted, 'deleted'),
+            (normal, Text),
+            (r'.', Text),
+        ],
+        'inserted': [
+            (ins_op, Generic.Inserted, '#push'),
+            (del_op, Generic.Inserted, '#push'),
+            (del_cl, Generic.Inserted, '#pop'),
+
+            (ins_cl, Generic.Inserted, '#pop'),
+            (normal, Generic.Inserted),
+            (r'.', Generic.Inserted),
+        ],
+        'deleted': [
+            (del_op, Generic.Deleted, '#push'),
+            (ins_op, Generic.Deleted, '#push'),
+            (ins_cl, Generic.Deleted, '#pop'),
+
+            (del_cl, Generic.Deleted, '#pop'),
+            (normal, Generic.Deleted),
+            (r'.', Generic.Deleted),
+        ],
+    }

py2docfx/venv/1/Lib/site-packages/pygments/lexers/dns.py

@@ -0,0 +1,109 @@
+"""
+    pygments.lexers.dns
+    ~~~~~~~~~~~~~~~~~~~
+
+    Pygments lexers for DNS
+
+    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.token import Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Whitespace, Literal
+from pygments.lexer import RegexLexer, bygroups, include
+
+__all__ = ['DnsZoneLexer']
+
+
+CLASSES = [
+    "IN",
+    "CS",
+    "CH",
+    "HS",
+]
+
+CLASSES_RE = "(" + "|".join(CLASSES) + ')'
+
+
+class DnsZoneLexer(RegexLexer):
+
+    """
+    Lexer for DNS zone file
+    """
+
+    flags = re.MULTILINE
+
+    name = 'Zone'
+    aliases = ['zone']
+    filenames = [ "*.zone" ]
+    url = "https://datatracker.ietf.org/doc/html/rfc1035"
+    mimetypes = ['text/dns']
+    version_added = '2.16'
+
+    tokens = {
+       'root': [
+            # Empty/comment line:
+            (r'([ \t]*)(;.*)(\n)', bygroups(Whitespace, Comment.Single, Whitespace)),
+            # Special directives:
+            (r'^\$ORIGIN\b', Keyword, 'values'),
+            (r'^\$TTL\b', Keyword, 'values'),
+            (r'^\$INCLUDE\b', Comment.Preproc, 'include'),
+            # TODO, $GENERATE https://bind9.readthedocs.io/en/v9.18.14/chapter3.html#soa-rr
+            (r'^\$[A-Z]+\b', Keyword, 'values'),
+            # Records:
+            # <domain-name> [<TTL>] [<class>] <type> <RDATA> [<comment>]
+            (r'^(@)([ \t]+)(?:([0-9]+[smhdw]?)([ \t]+))?(?:' + CLASSES_RE + "([ \t]+))?([A-Z]+)([ \t]+)", 
+                bygroups(Operator, Whitespace, Number.Integer, Whitespace, Name.Class, Whitespace, Keyword.Type, Whitespace),
+                "values"),
+            (r'^([^ \t\n]*)([ \t]+)(?:([0-9]+[smhdw]?)([ \t]+))?(?:' + CLASSES_RE + "([ \t]+))?([A-Z]+)([ \t]+)", 
+                bygroups(Name, Whitespace, Number.Integer, Whitespace, Name.Class, Whitespace, Keyword.Type, Whitespace),
+                "values"),
+            # <domain-name> [<class>] [<TTL>] <type> <RDATA> [<comment>]
+            (r'^(Operator)([ \t]+)(?:' + CLASSES_RE + "([ \t]+))?(?:([0-9]+[smhdw]?)([ \t]+))?([A-Z]+)([ \t]+)", 
+                bygroups(Name, Whitespace, Number.Integer, Whitespace, Name.Class, Whitespace, Keyword.Type, Whitespace),
+                "values"),
+            (r'^([^ \t\n]*)([ \t]+)(?:' + CLASSES_RE + "([ \t]+))?(?:([0-9]+[smhdw]?)([ \t]+))?([A-Z]+)([ \t]+)", 
+                bygroups(Name, Whitespace, Number.Integer, Whitespace, Name.Class, Whitespace, Keyword.Type, Whitespace),
+                "values"),
+        ],
+        # Parsing values:
+        'values': [
+            (r'\n', Whitespace, "#pop"),
+            (r'\(', Punctuation, 'nested'),
+            include('simple-value'),
+        ],
+        # Parsing nested values (...):
+        'nested': [
+            (r'\)', Punctuation, "#pop"),
+            include('multiple-simple-values'),
+        ],
+        # Parsing values:
+        'simple-value': [
+            (r'(;.*)', bygroups(Comment.Single)),
+            (r'[ \t]+', Whitespace),
+            (r"@\b", Operator),
+            ('"', String, 'string'),
+            (r'[0-9]+[smhdw]?$', Number.Integer),
+            (r'([0-9]+[smhdw]?)([ \t]+)', bygroups(Number.Integer, Whitespace)),
+            (r'\S+', Literal),
+        ],
+        'multiple-simple-values': [
+            include('simple-value'),
+            (r'[\n]+', Whitespace),
+        ],
+        'include': [
+            (r'([ \t]+)([^ \t\n]+)([ \t]+)([-\._a-zA-Z]+)([ \t]+)(;.*)?$',
+             bygroups(Whitespace, Comment.PreprocFile, Whitespace, Name, Whitespace, Comment.Single), '#pop'),
+            (r'([ \t]+)([^ \t\n]+)([ \t\n]+)$', bygroups(Whitespace, Comment.PreprocFile, Whitespace), '#pop'),
+        ],
+        "string": [
+            (r'\\"', String),
+            (r'"', String, "#pop"),
+            (r'[^"]+', String),
+        ]
+    }
+
+    def analyse_text(text):
+        return text.startswith("$ORIGIN")