pygments.rb 1.2.0 → 2.1.0

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.webmisc
     ~~~~~~~~~~~~~~~~~~~~~~~
 
     Lexers for misc. web stuff.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -15,7 +14,6 @@ from pygments.lexer import RegexLexer, ExtendedRegexLexer, include, bygroups, \
     default, using
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
     Number, Punctuation, Literal
-from pygments.util import unirange
 
 from pygments.lexers.css import _indentation, _starts_block
 from pygments.lexers.html import HtmlLexer
@@ -74,15 +72,15 @@ class XQueryLexer(ExtendedRegexLexer):
 
     # FIX UNICODE LATER
     # ncnamestartchar = (
-    #    ur"[A-Z]|_|[a-z]|[\u00C0-\u00D6]|[\u00D8-\u00F6]|[\u00F8-\u02FF]|"
-    #    ur"[\u0370-\u037D]|[\u037F-\u1FFF]|[\u200C-\u200D]|[\u2070-\u218F]|"
-    #    ur"[\u2C00-\u2FEF]|[\u3001-\uD7FF]|[\uF900-\uFDCF]|[\uFDF0-\uFFFD]|"
-    #    ur"[\u10000-\uEFFFF]"
+    #    r"[A-Z]|_|[a-z]|[\u00C0-\u00D6]|[\u00D8-\u00F6]|[\u00F8-\u02FF]|"
+    #    r"[\u0370-\u037D]|[\u037F-\u1FFF]|[\u200C-\u200D]|[\u2070-\u218F]|"
+    #    r"[\u2C00-\u2FEF]|[\u3001-\uD7FF]|[\uF900-\uFDCF]|[\uFDF0-\uFFFD]|"
+    #    r"[\u10000-\uEFFFF]"
     # )
     ncnamestartchar = r"(?:[A-Z]|_|[a-z])"
     # FIX UNICODE LATER
-    # ncnamechar = ncnamestartchar + (ur"|-|\.|[0-9]|\u00B7|[\u0300-\u036F]|"
-    #                                 ur"[\u203F-\u2040]")
+    # ncnamechar = ncnamestartchar + (r"|-|\.|[0-9]|\u00B7|[\u0300-\u036F]|"
+    #                                 r"[\u203F-\u2040]")
     ncnamechar = r"(?:" + ncnamestartchar + r"|-|\.|[0-9])"
     ncname = "(?:%s+%s*)" % (ncnamestartchar, ncnamechar)
     pitarget_namestartchar = r"(?:[A-KN-WYZ]|_|:|[a-kn-wyz])"
@@ -99,14 +97,14 @@ class XQueryLexer(ExtendedRegexLexer):
     stringsingle = r"(?:'(?:" + entityref + r"|" + charref + r"|''|[^&'])*')"
 
     # FIX UNICODE LATER
-    # elementcontentchar = (ur'\t|\r|\n|[\u0020-\u0025]|[\u0028-\u003b]|'
-    #                       ur'[\u003d-\u007a]|\u007c|[\u007e-\u007F]')
+    # elementcontentchar = (r'\t|\r|\n|[\u0020-\u0025]|[\u0028-\u003b]|'
+    #                       r'[\u003d-\u007a]|\u007c|[\u007e-\u007F]')
     elementcontentchar = r'[A-Za-z]|\s|\d|[!"#$%()*+,\-./:;=?@\[\\\]^_\'`|~]'
-    # quotattrcontentchar = (ur'\t|\r|\n|[\u0020-\u0021]|[\u0023-\u0025]|'
-    #                        ur'[\u0027-\u003b]|[\u003d-\u007a]|\u007c|[\u007e-\u007F]')
+    # quotattrcontentchar = (r'\t|\r|\n|[\u0020-\u0021]|[\u0023-\u0025]|'
+    #                        r'[\u0027-\u003b]|[\u003d-\u007a]|\u007c|[\u007e-\u007F]')
     quotattrcontentchar = r'[A-Za-z]|\s|\d|[!#$%()*+,\-./:;=?@\[\\\]^_\'`|~]'
-    # aposattrcontentchar = (ur'\t|\r|\n|[\u0020-\u0025]|[\u0028-\u003b]|'
-    #                        ur'[\u003d-\u007a]|\u007c|[\u007e-\u007F]')
+    # aposattrcontentchar = (r'\t|\r|\n|[\u0020-\u0025]|[\u0028-\u003b]|'
+    #                        r'[\u003d-\u007a]|\u007c|[\u007e-\u007F]')
     aposattrcontentchar = r'[A-Za-z]|\s|\d|[!"#$%()*+,\-./:;=?@\[\\\]^_`|~]'
 
     # CHAR elements - fix the above elementcontentchar, quotattrcontentchar,
@@ -129,7 +127,8 @@ class XQueryLexer(ExtendedRegexLexer):
 
     def popstate_tag_callback(lexer, match, ctx):
         yield match.start(), Name.Tag, match.group(1)
-        ctx.stack.append(lexer.xquery_parse_state.pop())
+        if lexer.xquery_parse_state:
+            ctx.stack.append(lexer.xquery_parse_state.pop())
         ctx.pos = match.end()
 
     def popstate_xmlcomment_callback(lexer, match, ctx):
@@ -158,6 +157,9 @@ class XQueryLexer(ExtendedRegexLexer):
         # state stack
         if len(lexer.xquery_parse_state) == 0:
             ctx.stack.pop()
+            if not ctx.stack:
+                # make sure we have at least the root state on invalid inputs
+                ctx.stack = ['root']
         elif len(ctx.stack) > 1:
             ctx.stack.append(lexer.xquery_parse_state.pop())
         else:
@@ -438,7 +440,7 @@ class XQueryLexer(ExtendedRegexLexer):
         ],
         'varname': [
             (r'\(:', Comment, 'comment'),
-            (r'(' + qname + ')(\()?', bygroups(Name, Punctuation), 'operator'),
+            (r'(' + qname + r')(\()?', bygroups(Name, Punctuation), 'operator'),
         ],
         'singletype': [
             include('whitespace'),
@@ -515,8 +517,8 @@ class XQueryLexer(ExtendedRegexLexer):
         'xml_comment': [
             (r'(-->)', popstate_xmlcomment_callback),
             (r'[^-]{1,2}', Literal),
-            (u'\\t|\\r|\\n|[\u0020-\uD7FF]|[\uE000-\uFFFD]|' +
-             unirange(0x10000, 0x10ffff), Literal),
+            (r'\t|\r|\n|[\u0020-\uD7FF]|[\uE000-\uFFFD]|[\U00010000-\U0010FFFF]',
+             Literal),
         ],
         'processing_instruction': [
             (r'\s+', Text, 'processing_instruction_content'),
@@ -525,13 +527,13 @@ class XQueryLexer(ExtendedRegexLexer):
         ],
         'processing_instruction_content': [
             (r'\?>', String.Doc, '#pop'),
-            (u'\\t|\\r|\\n|[\u0020-\uD7FF]|[\uE000-\uFFFD]|' +
-             unirange(0x10000, 0x10ffff), Literal),
+            (r'\t|\r|\n|[\u0020-\uD7FF]|[\uE000-\uFFFD]|[\U00010000-\U0010FFFF]',
+             Literal),
         ],
         'cdata_section': [
             (r']]>', String.Doc, '#pop'),
-            (u'\\t|\\r|\\n|[\u0020-\uD7FF]|[\uE000-\uFFFD]|' +
-             unirange(0x10000, 0x10ffff), Literal),
+            (r'\t|\r|\n|[\u0020-\uD7FF]|[\uE000-\uFFFD]|[\U00010000-\U0010FFFF]',
+             Literal),
         ],
         'start_tag': [
             include('whitespace'),
@@ -600,8 +602,8 @@ class XQueryLexer(ExtendedRegexLexer):
         ],
         'pragmacontents': [
             (r'#\)', Punctuation, 'operator'),
-            (u'\\t|\\r|\\n|[\u0020-\uD7FF]|[\uE000-\uFFFD]|' +
-             unirange(0x10000, 0x10ffff), Literal),
+            (r'\t|\r|\n|[\u0020-\uD7FF]|[\uE000-\uFFFD]|[\U00010000-\U0010FFFF]',
+             Literal),
             (r'(\s+)', Text),
         ],
         'occurrenceindicator': [
@@ -643,9 +645,9 @@ class XQueryLexer(ExtendedRegexLexer):
              bygroups(Keyword.Declaration, Text, Keyword.Declaration, Text, Keyword.Declaration), 'operator'),
             (r'(declare)(\s+)(context)(\s+)(item)',
              bygroups(Keyword.Declaration, Text, Keyword.Declaration, Text, Keyword.Declaration), 'operator'),
-            (ncname + ':\*', Name, 'operator'),
-            ('\*:'+ncname, Name.Tag, 'operator'),
-            ('\*', Name.Tag, 'operator'),
+            (ncname + r':\*', Name, 'operator'),
+            (r'\*:'+ncname, Name.Tag, 'operator'),
+            (r'\*', Name.Tag, 'operator'),
             (stringdouble, String.Double, 'operator'),
             (stringsingle, String.Single, 'operator'),
 
@@ -661,7 +663,8 @@ class XQueryLexer(ExtendedRegexLexer):
 
             # NAMESPACE KEYWORD
             (r'(declare)(\s+)(default)(\s+)(element|function)',
-             bygroups(Keyword.Declaration, Text, Keyword.Declaration, Text, Keyword.Declaration), 'namespacekeyword'),
+             bygroups(Keyword.Declaration, Text, Keyword.Declaration, Text, Keyword.Declaration),
+             'namespacekeyword'),
             (r'(import)(\s+)(schema|module)',
              bygroups(Keyword.Pseudo, Text, Keyword.Pseudo), 'namespacekeyword'),
             (r'(declare)(\s+)(copy-namespaces)',
@@ -854,14 +857,14 @@ class QmlLexer(RegexLexer):
             (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
             (r'0x[0-9a-fA-F]+', Number.Hex),
             (r'[0-9]+', Number.Integer),
-            (r'"(\\\\|\\"|[^"])*"', String.Double),
-            (r"'(\\\\|\\'|[^'])*'", String.Single),
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
+            (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
         ]
     }
 
 
 class CirruLexer(RegexLexer):
-    """
+    r"""
     Syntax rules of Cirru can be found at:
     http://cirru.org/
 

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.whiley
     ~~~~~~~~~~~~~~~~~~~~~~
 
     Lexers for the Whiley language.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -97,11 +96,11 @@ class WhileyLexer(RegexLexer):
 
             # operators and punctuation
             (r'[{}()\[\],.;]', Punctuation),
-            (u'[+\\-*/%&|<>^!~@=:?'
+            (r'[+\-*/%&|<>^!~@=:?'
              # unicode operators
-             u'\u2200\u2203\u2205\u2282\u2286\u2283\u2287'
-             u'\u222A\u2229\u2264\u2265\u2208\u2227\u2228'
-             u']', Operator),
+             r'\u2200\u2203\u2205\u2282\u2286\u2283\u2287'
+             r'\u222A\u2229\u2264\u2265\u2208\u2227\u2228'
+             r']', Operator),
 
             # identifier
             (r'[a-zA-Z_]\w*', Name),

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.x10
     ~~~~~~~~~~~~~~~~~~~
 
     Lexers for the X10 programming language.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -62,7 +61,7 @@ class X10Lexer(RegexLexer):
             (r'\b(%s)\b' % '|'.join(types), Keyword.Type),
             (r'\b(%s)\b' % '|'.join(values), Keyword.Constant),
             (r'\b(%s)\b' % '|'.join(modifiers), Keyword.Declaration),
-            (r'"(\\\\|\\"|[^"])*"', String),
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
             (r"'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'", String.Char),
             (r'.', Text)
         ],

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.xorg
     ~~~~~~~~~~~~~~~~~~~~
 
     Lexers for Xorg configs.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -16,6 +15,7 @@ __all__ = ['XorgLexer']
 
 
 class XorgLexer(RegexLexer):
+    """Lexer for xorg.conf file."""
     name = 'Xorg'
     aliases = ['xorg.conf']
     filenames = ['xorg.conf']
@@ -26,9 +26,9 @@ class XorgLexer(RegexLexer):
             (r'\s+', Text),
             (r'#.*$', Comment),
 
-            (r'((|Sub)Section)(\s+)("\w+")',
-             bygroups(String.Escape, String.Escape, Text, String.Escape)),
-            (r'(End(|Sub)Section)', String.Escape),
+            (r'((?:Sub)?Section)(\s+)("\w+")',
+             bygroups(String.Escape, Text, String.Escape)),
+            (r'(End(?:Sub)?Section)', String.Escape),
 
             (r'(\w+)(\s+)([^\n#]+)',
              bygroups(Name.Builtin, Text, Name.Constant)),

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

@@ -0,0 +1,103 @@
+"""
+    pygments.lexers.yang
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for the YANG 1.1 modeling language. See :rfc:`7950`.
+
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import (RegexLexer, bygroups, words)
+from pygments.token import (Text, Token, Name, String, Comment,
+                            Number)
+
+__all__ = ['YangLexer']
+
+class YangLexer(RegexLexer):
+    """
+    Lexer for `YANG <https://tools.ietf.org/html/rfc7950/>`_, based on RFC7950
+
+    .. versionadded:: 2.7
+    """
+    name = 'YANG'
+    aliases = ['yang']
+    filenames = ['*.yang']
+    mimetypes = ['application/yang']
+
+    #Keywords from RFC7950 ; oriented at BNF style
+    TOP_STMTS_KEYWORDS = ("module", "submodule")
+    MODULE_HEADER_STMT_KEYWORDS = ("belongs-to", "namespace", "prefix", "yang-version")
+    META_STMT_KEYWORDS = ("contact", "description", "organization",
+                          "reference", "revision")
+    LINKAGE_STMTS_KEYWORDS = ("import", "include", "revision-date")
+    BODY_STMT_KEYWORDS = ("action", "argument", "augment", "deviation",
+                          "extension", "feature", "grouping", "identity",
+                          "if-feature", "input", "notification", "output",
+                          "rpc", "typedef")
+    DATA_DEF_STMT_KEYWORDS = ("anydata", "anyxml", "case", "choice",
+                              "config", "container", "deviate", "leaf",
+                              "leaf-list", "list", "must", "presence",
+                              "refine", "uses", "when")
+    TYPE_STMT_KEYWORDS = ("base", "bit", "default", "enum", "error-app-tag",
+                          "error-message", "fraction-digits", "length",
+                          "max-elements", "min-elements", "modifier",
+                          "ordered-by", "path", "pattern", "position",
+                          "range", "require-instance", "status", "type",
+                          "units", "value", "yin-element")
+    LIST_STMT_KEYWORDS = ("key", "mandatory", "unique")
+
+    #RFC7950 other keywords
+    CONSTANTS_KEYWORDS = ("add", "current", "delete", "deprecated", "false",
+                          "invert-match", "max", "min", "not-supported",
+                          "obsolete", "replace", "true", "unbounded", "user")
+
+    #RFC7950 Built-In Types
+    TYPES = ("binary", "bits", "boolean", "decimal64", "empty", "enumeration",
+             "identityref", "instance-identifier", "int16", "int32", "int64",
+             "int8", "leafref", "string", "uint16", "uint32", "uint64",
+             "uint8", "union")
+
+    suffix_re_pattern = r'(?=[^\w\-:])'
+
+    tokens = {
+        'comments': [
+            (r'[^*/]', Comment),
+            (r'/\*', Comment, '#push'),
+            (r'\*/', Comment, '#pop'),
+            (r'[*/]', Comment),
+        ],
+        "root": [
+            (r'\s+', Text.Whitespace),
+            (r'[{};]+', Token.Punctuation),
+            (r'(?<![\-\w])(and|or|not|\+|\.)(?![\-\w])', Token.Operator),
+
+            (r'"(?:\\"|[^"])*?"', String.Double),
+            (r"'(?:\\'|[^'])*?'", String.Single),
+
+            (r'/\*', Comment, 'comments'),
+            (r'//.*?$', Comment),
+
+            #match BNF stmt for `node-identifier` with [ prefix ":"]
+            (r'(?:^|(?<=[\s{};]))([\w.-]+)(:)([\w.-]+)(?=[\s{};])',
+             bygroups(Name.Namespace, Token.Punctuation, Name.Variable)),
+
+            #match BNF stmt `date-arg-str`
+            (r'([0-9]{4}\-[0-9]{2}\-[0-9]{2})(?=[\s{};])', Name.Label),
+            (r'([0-9]+\.[0-9]+)(?=[\s{};])', Number.Float),
+            (r'([0-9]+)(?=[\s{};])', Number.Integer),
+
+            (words(TOP_STMTS_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(MODULE_HEADER_STMT_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(META_STMT_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(LINKAGE_STMTS_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(BODY_STMT_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(DATA_DEF_STMT_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(TYPE_STMT_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(LIST_STMT_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(TYPES, suffix=suffix_re_pattern), Name.Class),
+            (words(CONSTANTS_KEYWORDS, suffix=suffix_re_pattern), Name.Class),
+
+            (r'[^;{}\s\'"]+', Name.Variable),
+        ]
+    }

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

@@ -0,0 +1,123 @@
+"""
+    pygments.lexers.zig
+    ~~~~~~~~~~~~~~~~~~~
+
+    Lexers for Zig.
+
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, words
+from pygments.token import Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Whitespace
+
+__all__ = ['ZigLexer']
+
+
+class ZigLexer(RegexLexer):
+    """
+    For `Zig <http://www.ziglang.org>`_ source code.
+
+    grammar: https://ziglang.org/documentation/master/#Grammar
+    """
+    name = 'Zig'
+    aliases = ['zig']
+    filenames = ['*.zig']
+    mimetypes = ['text/zig']
+
+    type_keywords = (
+        words(('bool', 'f16', 'f32', 'f64', 'f128', 'void', 'noreturn', 'type',
+               'anyerror', 'promise', 'i0', 'u0', 'isize',  'usize', 'comptime_int',
+               'comptime_float', 'c_short', 'c_ushort', 'c_int', 'c_uint', 'c_long',
+               'c_ulong', 'c_longlong', 'c_ulonglong', 'c_longdouble', 'c_void'
+               'i8', 'u8', 'i16', 'u16', 'i32', 'u32', 'i64', 'u64', 'i128',
+               'u128'), suffix=r'\b'),
+        Keyword.Type)
+
+    storage_keywords = (
+        words(('const', 'var', 'extern', 'packed', 'export', 'pub', 'noalias',
+               'inline', 'comptime', 'nakedcc', 'stdcallcc', 'volatile', 'allowzero',
+               'align', 'linksection', 'threadlocal'), suffix=r'\b'),
+        Keyword.Reserved)
+
+    structure_keywords = (
+        words(('struct', 'enum', 'union', 'error'), suffix=r'\b'),
+        Keyword)
+
+    statement_keywords = (
+        words(('break', 'return', 'continue', 'asm', 'defer', 'errdefer',
+               'unreachable', 'try', 'catch', 'async', 'await', 'suspend',
+               'resume', 'cancel'), suffix=r'\b'),
+        Keyword)
+
+    conditional_keywords = (
+        words(('if', 'else', 'switch', 'and', 'or', 'orelse'), suffix=r'\b'),
+        Keyword)
+
+    repeat_keywords = (
+        words(('while', 'for'), suffix=r'\b'),
+        Keyword)
+
+    other_keywords = (
+        words(('fn', 'usingnamespace', 'test'), suffix=r'\b'),
+        Keyword)
+
+    constant_keywords = (
+        words(('true', 'false', 'null', 'undefined'), suffix=r'\b'),
+        Keyword.Constant)
+
+    tokens = {
+        'root': [
+            (r'\n', Whitespace),
+            (r'\s+', Whitespace),
+            (r'//.*?\n', Comment.Single),
+
+            # Keywords
+            statement_keywords,
+            storage_keywords,
+            structure_keywords,
+            repeat_keywords,
+            type_keywords,
+            constant_keywords,
+            conditional_keywords,
+            other_keywords,
+
+            # Floats
+            (r'0x[0-9a-fA-F]+\.[0-9a-fA-F]+([pP][\-+]?[0-9a-fA-F]+)?', Number.Float),
+            (r'0x[0-9a-fA-F]+\.?[pP][\-+]?[0-9a-fA-F]+', Number.Float),
+            (r'[0-9]+\.[0-9]+([eE][-+]?[0-9]+)?', Number.Float),
+            (r'[0-9]+\.?[eE][-+]?[0-9]+', Number.Float),
+
+            # Integers
+            (r'0b[01]+', Number.Bin),
+            (r'0o[0-7]+', Number.Oct),
+            (r'0x[0-9a-fA-F]+', Number.Hex),
+            (r'[0-9]+', Number.Integer),
+
+            # Identifier
+            (r'@[a-zA-Z_]\w*', Name.Builtin),
+            (r'[a-zA-Z_]\w*', Name),
+
+            # Characters
+            (r'\'\\\'\'', String.Escape),
+            (r'\'\\(x[a-fA-F0-9]{2}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{6}|[nr\\t\'"])\'',
+             String.Escape),
+            (r'\'[^\\\']\'', String),
+
+            # Strings
+            (r'\\\\[^\n]*', String.Heredoc),
+            (r'c\\\\[^\n]*', String.Heredoc),
+            (r'c?"', String, 'string'),
+
+            # Operators, Punctuation
+            (r'[+%=><|^!?/\-*&~:]', Operator),
+            (r'[{}()\[\],.;]', Punctuation)
+        ],
+        'string': [
+            (r'\\(x[a-fA-F0-9]{2}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{6}|[nr\\t\'"])',
+             String.Escape),
+            (r'[^\\"\n]+', String),
+            (r'"', String, '#pop')
+        ]
+    }