!56 [sync] PR-53: Use wildcards to include the pygments module.

From: @openeuler-sync-bot 
Reviewed-by: @Charlie_li 
Signed-off-by: @Charlie_li

backport-CVE-2021-20270.patch

@@ -0,0 +1,57 @@
+From f91804ff4772e3ab41f46e28d370f57898700333 Mon Sep 17 00:00:00 2001
+From: Georg Brandl <georg@python.org>
+Date: Thu, 10 Dec 2020 08:19:21 +0100
+Subject: [PATCH] fixes #1625: infinite loop in SML lexer
+
+https://github.com/pygments/pygments/commit/f91804ff4772e3ab41f46e28d370f57898700333
+
+Reason was a lookahead-only pattern which was included in the state
+where the lookahead was transitioning to.
+---
+ pygments/lexers/ml.py | 12 ++++++------
+ 1 file changed, 6 insertions(+), 6 deletions(-)
+
+diff --git a/pygments/lexers/ml.py b/pygments/lexers/ml.py
+index 461af88..b8d78f5 100644
+--- a/pygments/lexers/ml.py
++++ b/pygments/lexers/ml.py
+@@ -142,7 +142,7 @@ class SMLLexer(RegexLexer):
+             (r'#\s+(%s)' % symbolicid_re, Name.Label),
+             # Some reserved words trigger a special, local lexer state change
+             (r'\b(datatype|abstype)\b(?!\')', Keyword.Reserved, 'dname'),
+-            (r'(?=\b(exception)\b(?!\'))', Text, ('ename')),
++            (r'\b(exception)\b(?!\')', Keyword.Reserved, 'ename'),
+             (r'\b(functor|include|open|signature|structure)\b(?!\')',
+              Keyword.Reserved, 'sname'),
+             (r'\b(type|eqtype)\b(?!\')', Keyword.Reserved, 'tname'),
+@@ -315,15 +315,14 @@ class SMLLexer(RegexLexer):
+         'ename': [
+             include('whitespace'),
+ 
+-            (r'(exception|and)\b(\s+)(%s)' % alphanumid_re,
++            (r'(and\b)(\s+)(%s)' % alphanumid_re,
+              bygroups(Keyword.Reserved, Text, Name.Class)),
+-            (r'(exception|and)\b(\s*)(%s)' % symbolicid_re,
++            (r'(and\b)(\s*)(%s)' % symbolicid_re,
+              bygroups(Keyword.Reserved, Text, Name.Class)),
+             (r'\b(of)\b(?!\')', Keyword.Reserved),
++            (r'(%s)|(%s)' % (alphanumid_re, symbolicid_re), Name.Class),
+ 
+-            include('breakout'),
+-            include('core'),
+-            (r'\S+', Error),
++            default('#pop'),
+         ],
+ 
+         'datcon': [
+@@ -446,6 +445,7 @@ class OcamlLexer(RegexLexer):
+     }
+ 
+ 
++
+ class OpaLexer(RegexLexer):
+     """
+     Lexer for the Opa language (http://opalang.org).
+-- 
+2.13.7
+

backport-CVE-2021-27291.patch

@@ -0,0 +1,143 @@
+From 2e7e8c4a7b318f4032493773732754e418279a14 Mon Sep 17 00:00:00 2001
+From: Georg Brandl <georg@python.org>
+Date: Mon, 11 Jan 2021 09:46:34 +0100
+Subject: [PATCH] Fix several exponential/cubic complexity regexes found by Ben
+ Caller/Doyensec
+
+https://github.com/pygments/pygments/commit/2e7e8c4a7b318f4032493773732754e418279a14
+
+---
+ pygments/lexers/archetype.py | 2 +-
+ pygments/lexers/factor.py    | 4 ++--
+ pygments/lexers/jvm.py       | 1 -
+ pygments/lexers/matlab.py    | 6 +++---
+ pygments/lexers/objective.py | 4 ++--
+ pygments/lexers/templates.py | 2 +-
+ pygments/lexers/varnish.py   | 2 +-
+ 7 files changed, 10 insertions(+), 11 deletions(-)
+
+diff --git a/pygments/lexers/archetype.py b/pygments/lexers/archetype.py
+index 68ec5c0..6c36b96 100644
+--- a/pygments/lexers/archetype.py
++++ b/pygments/lexers/archetype.py
+@@ -58,7 +58,7 @@ class AtomsLexer(RegexLexer):
+             (r'P((\d*(\.\d+)?[YyMmWwDd]){1,3}(T(\d*(\.\d+)?[HhMmSs]){,3})?|'
+              r'T(\d*(\.\d+)?[HhMmSs]){,3})', Literal.Date),
+             (r'[+-]?(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+', Number.Float),
+-            (r'[+-]?(\d+)*\.\d+%?', Number.Float),
++            (r'[+-]?\d*\.\d+%?', Number.Float),
+             (r'0x[0-9a-fA-F]+', Number.Hex),
+             (r'[+-]?\d+%?', Number.Integer),
+         ],
+diff --git a/pygments/lexers/factor.py b/pygments/lexers/factor.py
+index 4aed8f6..d9e346e 100644
+--- a/pygments/lexers/factor.py
++++ b/pygments/lexers/factor.py
+@@ -265,7 +265,7 @@ class FactorLexer(RegexLexer):
+             (r'(?:<PRIVATE|PRIVATE>)\s', Keyword.Namespace),
+ 
+             # strings
+-            (r'"""\s+(?:.|\n)*?\s+"""', String),
++            (r'"""\s(?:.|\n)*?\s"""', String),
+             (r'"(?:\\\\|\\"|[^"])*"', String),
+             (r'\S+"\s+(?:\\\\|\\"|[^"])*"', String),
+             (r'CHAR:\s+(?:\\[\\abfnrstv]|[^\\]\S*)\s', String.Char),
+@@ -322,7 +322,7 @@ class FactorLexer(RegexLexer):
+         'slots': [
+             (r'\s+', Text),
+             (r';\s', Keyword, '#pop'),
+-            (r'(\{\s+)(\S+)(\s+[^}]+\s+\}\s)',
++            (r'(\{\s+)(\S+)(\s[^}]+\s\}\s)',
+              bygroups(Text, Name.Variable, Text)),
+             (r'\S+', Name.Variable),
+         ],
+diff --git a/pygments/lexers/jvm.py b/pygments/lexers/jvm.py
+index 5588b79..7f6d166 100644
+--- a/pygments/lexers/jvm.py
++++ b/pygments/lexers/jvm.py
+@@ -975,7 +975,6 @@ class CeylonLexer(RegexLexer):
+             (r'(import)(\s+)', bygroups(Keyword.Namespace, Text), 'import'),
+             (r'"(\\\\|\\"|[^"])*"', String),
+             (r"'\\.'|'[^\\]'|'\\\{#[0-9a-fA-F]{4}\}'", String.Char),
+-            (r'".*``.*``.*"', String.Interpol),
+             (r'(\.)([a-z_]\w*)',
+              bygroups(Operator, Name.Attribute)),
+             (r'[a-zA-Z_]\w*:', Name.Label),
+diff --git a/pygments/lexers/matlab.py b/pygments/lexers/matlab.py
+index 64dd3a3..d8fd77c 100644
+--- a/pygments/lexers/matlab.py
++++ b/pygments/lexers/matlab.py
+@@ -136,7 +136,7 @@ class MatlabLexer(RegexLexer):
+             (r'.', Comment.Multiline),
+         ],
+         'deffunc': [
+-            (r'(\s*)(?:(.+)(\s*)(=)(\s*))?(.+)(\()(.*)(\))(\s*)',
++            (r'(\s*)(?:(\S+)(\s*)(=)(\s*))?(.+)(\()(.*)(\))(\s*)',
+              bygroups(Whitespace, Text, Whitespace, Punctuation,
+                       Whitespace, Name.Function, Punctuation, Text,
+                       Punctuation, Whitespace), '#pop'),
+@@ -613,7 +613,7 @@ class OctaveLexer(RegexLexer):
+             (r"[^']*'", String, '#pop'),
+         ],
+         'deffunc': [
+-            (r'(\s*)(?:(.+)(\s*)(=)(\s*))?(.+)(\()(.*)(\))(\s*)',
++            (r'(\s*)(?:(\S+)(\s*)(=)(\s*))?(.+)(\()(.*)(\))(\s*)',
+              bygroups(Whitespace, Text, Whitespace, Punctuation,
+                       Whitespace, Name.Function, Punctuation, Text,
+                       Punctuation, Whitespace), '#pop'),
+@@ -681,7 +681,7 @@ class ScilabLexer(RegexLexer):
+             (r'.', String, '#pop'),
+         ],
+         'deffunc': [
+-            (r'(\s*)(?:(.+)(\s*)(=)(\s*))?(.+)(\()(.*)(\))(\s*)',
++            (r'(\s*)(?:(\S+)(\s*)(=)(\s*))?(.+)(\()(.*)(\))(\s*)',
+              bygroups(Whitespace, Text, Whitespace, Punctuation,
+                       Whitespace, Name.Function, Punctuation, Text,
+                       Punctuation, Whitespace), '#pop'),
+diff --git a/pygments/lexers/objective.py b/pygments/lexers/objective.py
+index 777d8d4..19f9a54 100644
+--- a/pygments/lexers/objective.py
++++ b/pygments/lexers/objective.py
+@@ -261,11 +261,11 @@ class LogosLexer(ObjectiveCppLexer):
+              'logos_classname'),
+             (r'(%hook|%group)(\s+)([a-zA-Z$_][\w$]+)',
+              bygroups(Keyword, Text, Name.Class)),
+-            (r'(%config)(\s*\(\s*)(\w+)(\s*=\s*)(.*?)(\s*\)\s*)',
++            (r'(%config)(\s*\(\s*)(\w+)(\s*=)(.*?)(\)\s*)',
+              bygroups(Keyword, Text, Name.Variable, Text, String, Text)),
+             (r'(%ctor)(\s*)(\{)', bygroups(Keyword, Text, Punctuation),
+              'function'),
+-            (r'(%new)(\s*)(\()(\s*.*?\s*)(\))',
++            (r'(%new)(\s*)(\()(.*?)(\))',
+              bygroups(Keyword, Text, Keyword, String, Keyword)),
+             (r'(\s*)(%end)(\s*)', bygroups(Text, Keyword, Text)),
+             inherit,
+diff --git a/pygments/lexers/templates.py b/pygments/lexers/templates.py
+index f891242..d909662 100644
+--- a/pygments/lexers/templates.py
++++ b/pygments/lexers/templates.py
+@@ -1428,7 +1428,7 @@ class EvoqueLexer(RegexLexer):
+             # see doc for handling first name arg: /directives/evoque/
+             # + minor inconsistency: the "name" in e.g. $overlay{name=site_base}
+             # should be using(PythonLexer), not passed out as String
+-            (r'(\$)(evoque|overlay)(\{(%)?)(\s*[#\w\-"\'.]+[^=,%}]+?)?'
++            (r'(\$)(evoque|overlay)(\{(%)?)(\s*[#\w\-"\'.]+)?'
+              r'(.*?)((?(4)%)\})',
+              bygroups(Punctuation, Name.Builtin, Punctuation, None,
+                       String, using(PythonLexer), Punctuation)),
+diff --git a/pygments/lexers/varnish.py b/pygments/lexers/varnish.py
+index 4db74e3..b911985 100644
+--- a/pygments/lexers/varnish.py
++++ b/pygments/lexers/varnish.py
+@@ -61,7 +61,7 @@ class VCLLexer(RegexLexer):
+              bygroups(Name.Attribute, Operator, Name.Variable.Global, Punctuation)),
+             (r'(\.probe)(\s*=\s*)(\{)',
+              bygroups(Name.Attribute, Operator, Punctuation), 'probe'),
+-            (r'(\.\w+\b)(\s*=\s*)([^;]*)(\s*;)',
++            (r'(\.\w+\b)(\s*=\s*)([^;\s]*)(\s*;)',
+              bygroups(Name.Attribute, Operator, using(this), Punctuation)),
+             (r'\{', Punctuation, '#push'),
+             (r'\}', Punctuation, '#pop'),
+-- 
+2.13.7
+

backport-Remove-generated-output-directory-when-make-clean-is.patch

@@ -0,0 +1,26 @@
+From dac176fdef4d5f9c16a5ec8ecadb605cd78e6335 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?St=C3=A9phane=20Blondon?= <stephane.blondon@gmail.com>
+Date: Fri, 29 Nov 2019 16:15:47 +0100
+Subject: [PATCH] Remove generated output/ directory when 'make clean' is
+ called
+
+---
+ Makefile | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/Makefile b/Makefile
+index 61ee393e..13813adc 100644
+--- a/Makefile
++++ b/Makefile
+@@ -24,7 +24,7 @@ check:
+ 		   -i docs/build -i pygments/formatters/_mapping.py -i pygments/unistring.py
+ 
+ clean: clean-pyc
+-	-rm -rf build
++	-rm -rf build tests/examplefiles/output
+ 	-rm -f codetags.html
+ 
+ clean-pyc:
+-- 
+2.27.0
+

backport-Use-wildcards-to-include-the-pygments-module.patch

@@ -0,0 +1,26 @@
+From 01f05b4dc5155745d401f31545fc1a089e8a3710 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Matth=C3=A4us=20G=2E=20Chajdas?= <dev@anteru.net>
+Date: Fri, 29 Nov 2019 20:21:03 +0100
+Subject: [PATCH] Use wildcards to include the pygments module.
+
+This should fix PR#1316 properly.
+---
+ setup.py | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/setup.py b/setup.py
+index d4555e3f..9c245215 100755
+--- a/setup.py
++++ b/setup.py
+@@ -35,7 +35,7 @@ setup(
+     description = 'Pygments is a syntax highlighting package written in Python.',
+     long_description = __doc__,
+     keywords = 'syntax highlighting',
+-    packages = find_packages(exclude=['tests']),
++    packages = find_packages(include=['pygments', 'pygments.*']),
+     entry_points = {
+         'console_scripts': ['pygmentize = pygments.cmdline:main'],
+     },
+-- 
+2.42.0.windows.2
+

backport-weed-out-more-backtracking-string-regexes.patch

@@ -0,0 +1,812 @@
+From 681487f82f55fba66f01f9913e4ff103e5b2ef4c Mon Sep 17 00:00:00 2001
+From: Georg Brandl <georg@python.org>
+Date: Fri, 25 Dec 2020 13:16:56 +0100
+Subject: [PATCH] all: weed out more backtracking string regexes
+
+Conflict:do not change test
+Reference:https://github.com/pygments/pygments/commit/681487f82f55fba66f01f9913e4ff103e5b2ef4c
+
+---
+ pygments/lexers/actionscript.py  |  4 ++--
+ pygments/lexers/ambient.py       |  2 +-
+ pygments/lexers/boa.py           |  6 ++---
+ pygments/lexers/configs.py       |  2 +-
+ pygments/lexers/d.py             |  4 ++--
+ pygments/lexers/dotnet.py        |  8 +++----
+ pygments/lexers/dsls.py          |  4 ++--
+ pygments/lexers/go.py            |  2 +-
+ pygments/lexers/graphics.py      |  4 ++--
+ pygments/lexers/haxe.py          |  4 ++--
+ pygments/lexers/iolang.py        |  2 +-
+ pygments/lexers/jvm.py           | 16 +++++++-------
+ pygments/lexers/lisp.py          | 12 +++++-----
+ pygments/lexers/make.py          |  4 ++--
+ pygments/lexers/parsers.py       | 48 ++++++++++++++++++++--------------------
+ pygments/lexers/php.py           |  4 ++--
+ pygments/lexers/prolog.py        |  4 ++--
+ pygments/lexers/ruby.py          | 34 ++++++++++++++--------------
+ pygments/lexers/scripting.py     |  8 +++----
+ pygments/lexers/supercollider.py |  4 ++--
+ pygments/lexers/templates.py     | 24 ++++++++++----------
+ pygments/lexers/textedit.py      |  4 ++--
+ pygments/lexers/urbi.py          |  4 ++--
+ pygments/lexers/webmisc.py       |  4 ++--
+ pygments/lexers/x10.py           |  2 +-
+ 25 files changed, 107 insertions(+), 107 deletions(-)
+
+diff --git a/pygments/lexers/actionscript.py b/pygments/lexers/actionscript.py
+index f4b4964..7992358 100644
+--- a/pygments/lexers/actionscript.py
++++ b/pygments/lexers/actionscript.py
+@@ -37,7 +37,7 @@ class ActionScriptLexer(RegexLexer):
+             (r'\s+', Text),
+             (r'//.*?\n', Comment.Single),
+             (r'/\*.*?\*/', Comment.Multiline),
+-            (r'/(\\\\|\\/|[^/\n])*/[gim]*', String.Regex),
++            (r'/(\\\\|\\[^\\]|[^/\\\n])*/[gim]*', String.Regex),
+             (r'[~^*!%&<>|+=:;,/?\\-]+', Operator),
+             (r'[{}\[\]();.]+', Punctuation),
+             (words((
+@@ -144,7 +144,7 @@ class ActionScript3Lexer(RegexLexer):
+              bygroups(Keyword, Text, Keyword.Type, Text, Operator)),
+             (r'//.*?\n', Comment.Single),
+             (r'/\*.*?\*/', Comment.Multiline),
+-            (r'/(\\\\|\\/|[^\n])*/[gisx]*', String.Regex),
++            (r'/(\\\\|\\[^\\]|[^\\\n])*/[gisx]*', String.Regex),
+             (r'(\.)(' + identifier + r')', bygroups(Operator, Name.Attribute)),
+             (r'(case|default|for|each|in|while|do|break|return|continue|if|else|'
+              r'throw|try|catch|with|new|typeof|arguments|instanceof|this|'
+diff --git a/pygments/lexers/ambient.py b/pygments/lexers/ambient.py
+index 7d42d12..d2cc06a 100644
+--- a/pygments/lexers/ambient.py
++++ b/pygments/lexers/ambient.py
+@@ -44,7 +44,7 @@ class AmbientTalkLexer(RegexLexer):
+             (builtin, Name.Builtin),
+             (r'(true|false|nil)\b', Keyword.Constant),
+             (r'(~|lobby|jlobby|/)\.', Keyword.Constant, 'namespace'),
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             (r'\|', Punctuation, 'arglist'),
+             (r'<:|[*^!%&<>+=,./?-]|:=', Operator),
+             (r"`[a-zA-Z_]\w*", String.Symbol),
+diff --git a/pygments/lexers/boa.py b/pygments/lexers/boa.py
+index a57c0e4..2425583 100644
+--- a/pygments/lexers/boa.py
++++ b/pygments/lexers/boa.py
+@@ -92,9 +92,9 @@ class BoaLexer(RegexLexer):
+             (classes, Name.Classes),
+             (words(operators), Operator),
+             (r'[][(),;{}\\.]', Punctuation),
+-            (r'"(\\\\|\\"|[^"])*"', String),
+-            (r'`(\\\\|\\`|[^`])*`', String),
+-            (words(string_sep), String.Delimeter),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
++            (r"`(\\\\|\\[^\\]|[^`\\])*`", String.Backtick),
++            (words(string_sep), String.Delimiter),
+             (r'[a-zA-Z_]+', Name.Variable),
+             (r'[0-9]+', Number.Integer),
+             (r'\s+?', Text),  # Whitespace
+diff --git a/pygments/lexers/configs.py b/pygments/lexers/configs.py
+index 0911b6e..0bae4eb 100644
+--- a/pygments/lexers/configs.py
++++ b/pygments/lexers/configs.py
+@@ -909,7 +909,7 @@ class TOMLLexer(RegexLexer):
+             (r'\s+', Text),
+             (r'#.*?$', Comment.Single),
+             # Basic string
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             # Literal string
+             (r'\'\'\'(.*)\'\'\'', String),
+             (r'\'[^\']*\'', String),
+diff --git a/pygments/lexers/d.py b/pygments/lexers/d.py
+index b14f7dc..f833e5e 100644
+--- a/pygments/lexers/d.py
++++ b/pygments/lexers/d.py
+@@ -93,7 +93,7 @@ class DLexer(RegexLexer):
+             # -- AlternateWysiwygString
+             (r'`[^`]*`[cwd]?', String),
+             # -- DoubleQuotedString
+-            (r'"(\\\\|\\"|[^"])*"[cwd]?', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"[cwd]?', String),
+             # -- EscapeSequence
+             (r"\\(['\"?\\abfnrtv]|x[0-9a-fA-F]{2}|[0-7]{1,3}"
+              r"|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|&\w+;)",
+@@ -224,7 +224,7 @@ class CrocLexer(RegexLexer):
+             (r'@`(``|[^`])*`', String),
+             (r"@'(''|[^'])*'", String),
+             # -- DoubleQuotedString
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             # Tokens
+             (r'(~=|\^=|%=|\*=|==|!=|>>>=|>>>|>>=|>>|>=|<=>|\?=|-\>'
+              r'|<<=|<<|<=|\+\+|\+=|--|-=|\|\||\|=|&&|&=|\.\.|/=)'
+diff --git a/pygments/lexers/dotnet.py b/pygments/lexers/dotnet.py
+index 458a9eb..c4d2077 100644
+--- a/pygments/lexers/dotnet.py
++++ b/pygments/lexers/dotnet.py
+@@ -88,7 +88,7 @@ class CSharpLexer(RegexLexer):
+                 (r'[~!%^&*()+=|\[\]:;,.<>/?-]', Punctuation),
+                 (r'[{}]', Punctuation),
+                 (r'@"(""|[^"])*"', String),
+-                (r'"(\\\\|\\"|[^"\n])*["\n]', String),
++                (r'"(\\\\|\\[^\\]|[^"\\\n])*["\n]', String),
+                 (r"'\\.'|'[^\\]'", String.Char),
+                 (r"[0-9](\.[0-9]*)?([eE][+-][0-9]+)?"
+                  r"[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?", Number),
+@@ -213,7 +213,7 @@ class NemerleLexer(RegexLexer):
+                 (r'[~!%^&*()+=|\[\]:;,.<>/?-]', Punctuation),
+                 (r'[{}]', Punctuation),
+                 (r'@"(""|[^"])*"', String),
+-                (r'"(\\\\|\\"|[^"\n])*["\n]', String),
++                (r'"(\\\\|\\[^\\]|[^"\\\n])*["\n]', String),
+                 (r"'\\.'|'[^\\]'", String.Char),
+                 (r"0[xX][0-9a-fA-F]+[Ll]?", Number),
+                 (r"[0-9](\.[0-9]*)?([eE][+-][0-9]+)?[flFLdD]?", Number),
+@@ -315,8 +315,8 @@ class BooLexer(RegexLexer):
+             (r'\\\n', Text),
+             (r'\\', Text),
+             (r'(in|is|and|or|not)\b', Operator.Word),
+-            (r'/(\\\\|\\/|[^/\s])/', String.Regex),
+-            (r'@/(\\\\|\\/|[^/])*/', String.Regex),
++            (r'/(\\\\|\\[^\\]|[^/\\\s])/', String.Regex),
++            (r'@/(\\\\|\\[^\\]|[^/\\])*/', String.Regex),
+             (r'=~|!=|==|<<|>>|[-+/*%=<>&^|]', Operator),
+             (r'(as|abstract|callable|constructor|destructor|do|import|'
+              r'enum|event|final|get|interface|internal|of|override|'
+diff --git a/pygments/lexers/dsls.py b/pygments/lexers/dsls.py
+index 0af3c6c..0e4ba40 100644
+--- a/pygments/lexers/dsls.py
++++ b/pygments/lexers/dsls.py
+@@ -632,7 +632,7 @@ class AlloyLexer(RegexLexer):
+             (iden_rex, Name),
+             (r'[:,]', Punctuation),
+             (r'[0-9]+', Number.Integer),
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             (r'\n', Text),
+         ]
+     }
+@@ -827,7 +827,7 @@ class FlatlineLexer(RegexLexer):
+             (r'0x-?[a-f\d]+', Number.Hex),
+ 
+             # strings, symbols and characters
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             (r"\\(.|[a-z]+)", String.Char),
+ 
+             # expression template placeholder
+diff --git a/pygments/lexers/go.py b/pygments/lexers/go.py
+index f6bb7fc..ebb34b5 100644
+--- a/pygments/lexers/go.py
++++ b/pygments/lexers/go.py
+@@ -90,7 +90,7 @@ class GoLexer(RegexLexer):
+             # -- raw_string_lit
+             (r'`[^`]*`', String),
+             # -- interpreted_string_lit
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             # Tokens
+             (r'(<<=|>>=|<<|>>|<=|>=|&\^=|&\^|\+=|-=|\*=|/=|%=|&=|\|=|&&|\|\|'
+              r'|<-|\+\+|--|==|!=|:=|\.\.\.|[+\-*/%&])', Operator),
+diff --git a/pygments/lexers/graphics.py b/pygments/lexers/graphics.py
+index b0b9145..61031a4 100644
+--- a/pygments/lexers/graphics.py
++++ b/pygments/lexers/graphics.py
+@@ -425,7 +425,7 @@ class AsymptoteLexer(RegexLexer):
+         ],
+         'statements': [
+             # simple string (TeX friendly)
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             # C style string (with character escapes)
+             (r"'", String, 'string'),
+             (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?', Number.Float),
+@@ -775,7 +775,7 @@ class PovrayLexer(RegexLexer):
+             (r'[0-9]+\.[0-9]*', Number.Float),
+             (r'\.[0-9]+', Number.Float),
+             (r'[0-9]+', Number.Integer),
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             (r'\s+', Text),
+         ]
+     }
+diff --git a/pygments/lexers/haxe.py b/pygments/lexers/haxe.py
+index b357508..e85e61c 100644
+--- a/pygments/lexers/haxe.py
++++ b/pygments/lexers/haxe.py
+@@ -467,7 +467,7 @@ class HaxeLexer(ExtendedRegexLexer):
+             (r'"', String.Double, ('#pop', 'expr-chain', 'string-double')),
+ 
+             # EReg
+-            (r'~/(\\\\|\\/|[^/\n])*/[gimsu]*', String.Regex, ('#pop', 'expr-chain')),
++            (r'~/(\\\\|\\[^\\]|[^/\\\n])*/[gimsu]*', String.Regex, ('#pop', 'expr-chain')),
+ 
+             # Array
+             (r'\[', Punctuation, ('#pop', 'expr-chain', 'array-decl')),
+@@ -722,7 +722,7 @@ class HaxeLexer(ExtendedRegexLexer):
+             (r'"', String.Double, ('#pop', 'string-double')),
+ 
+             # EReg
+-            (r'~/(\\\\|\\/|[^/\n])*/[gim]*', String.Regex, '#pop'),
++            (r'~/(\\\\|\\[^\\]|[^/\\\n])*/[gim]*', String.Regex, '#pop'),
+ 
+             # Array
+             (r'\[', Operator, ('#pop', 'array-decl')),
+diff --git a/pygments/lexers/iolang.py b/pygments/lexers/iolang.py
+index f33c871..b108939 100644
+--- a/pygments/lexers/iolang.py
++++ b/pygments/lexers/iolang.py
+@@ -37,7 +37,7 @@ class IoLexer(RegexLexer):
+             (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
+             (r'/\+', Comment.Multiline, 'nestedcomment'),
+             # DoubleQuotedString
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             # Operators
+             (r'::=|:=|=|\(|\)|;|,|\*|-|\+|>|<|@|!|/|\||\^|\.|%|&|\[|\]|\{|\}',
+              Operator),
+diff --git a/pygments/lexers/jvm.py b/pygments/lexers/jvm.py
+index 7f6d166..f008c1d 100644
+--- a/pygments/lexers/jvm.py
++++ b/pygments/lexers/jvm.py
+@@ -285,12 +285,12 @@ class ScalaLexer(RegexLexer):
+             (r'(import|package)(\s+)', bygroups(Keyword, Text), 'import'),
+             (r'(type)(\s+)', bygroups(Keyword, Text), 'type'),
+             (r'""".*?"""(?!")', String),
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             (r"'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'", String.Char),
+             (u"'%s" % idrest, Text.Symbol),
+             (r'[fs]"""', String, 'interptriplestring'),  # interpolated strings
+             (r'[fs]"', String, 'interpstring'),  # interpolated strings
+-            (r'raw"(\\\\|\\"|[^"])*"', String),  # raw strings
++            (r'raw"(\\\\|\\[^\\]|[^"\\])*"', String),  # raw strings
+             # (ur'(\.)(%s|%s|`[^`]+`)' % (idrest, op), bygroups(Operator,
+             # Name.Attribute)),
+             (idrest, Name),
+@@ -612,7 +612,7 @@ class IokeLexer(RegexLexer):
+             # Symbols
+             (r':[\w!:?]+', String.Symbol),
+             (r'[\w!:?]+:(?![\w!?])', String.Other),
+-            (r':"(\\\\|\\"|[^"])*"', String.Symbol),
++            (r':"(\\\\|\\[^\\]|[^"\\])*"', String.Symbol),
+ 
+             # Documentation
+             (r'((?<=fn\()|(?<=fnx\()|(?<=method\()|(?<=macro\()|(?<=lecro\()'
+@@ -830,7 +830,7 @@ class ClojureLexer(RegexLexer):
+             (r'0x-?[abcdef\d]+', Number.Hex),
+ 
+             # strings, symbols and characters
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             (r"'" + valid_name, String.Symbol),
+             (r"\\(.|[a-z]+)", String.Char),
+ 
+@@ -973,7 +973,7 @@ class CeylonLexer(RegexLexer):
+             (r'(class|interface|object|alias)(\s+)',
+              bygroups(Keyword.Declaration, Text), 'class'),
+             (r'(import)(\s+)', bygroups(Keyword.Namespace, Text), 'import'),
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             (r"'\\.'|'[^\\]'|'\\\{#[0-9a-fA-F]{4}\}'", String.Char),
+             (r'(\.)([a-z_]\w*)',
+              bygroups(Operator, Name.Attribute)),
+@@ -1049,7 +1049,7 @@ class KotlinLexer(RegexLexer):
+             (r'[~!%^&*()+=|\[\]:;,.<>/?-]', Punctuation),
+             (r'[{}]', Punctuation),
+             (r'@"(""|[^"])*"', String),
+-            (r'"(\\\\|\\"|[^"\n])*["\n]', String),
++            (r'"(\\\\|\\[^\\]|[^"\\\n])*["\n]', String),
+             (r"'\\.'|'[^\\]'", String.Char),
+             (r"[0-9](\.[0-9]*)?([eE][+-][0-9]+)?[flFL]?|"
+              r"0[xX][0-9a-fA-F]+[Ll]?", Number),
+@@ -1646,8 +1646,8 @@ class SarlLexer(RegexLexer):
+ 			 (r'(agent|annotation|artifact|behavior|capacity|class|enum|event|interface|skill|space)(\s+)', bygroups(Keyword.Declaration, Text),
+ 			  'class'),
+ 			 (r'(import)(\s+)', bygroups(Keyword.Namespace, Text), 'import'),
+-			 (r'"(\\\\|\\"|[^"])*"', String),
+-			 (r"'(\\\\|\\'|[^'])*'", String),
++			 (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
++			 (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
+ 			 (r'[a-zA-Z_]\w*:', Name.Label),
+ 			 (r'[a-zA-Z_$]\w*', Name),
+ 			 (r'[~^*!%&\[\](){}<>\|+=:;,./?-]', Operator),
+diff --git a/pygments/lexers/lisp.py b/pygments/lexers/lisp.py
+index 601d5a5..9e9b9ee 100644
+--- a/pygments/lexers/lisp.py
++++ b/pygments/lexers/lisp.py
+@@ -119,7 +119,7 @@ class SchemeLexer(RegexLexer):
+             # (r'(#e|#i|#b|#o|#d|#x)[\d.]+', Number),
+ 
+             # strings, symbols and characters
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             (r"'" + valid_name, String.Symbol),
+             (r"#\\([()/'\"._!§$%& ?=+-]|[a-zA-Z0-9]+)", String.Char),
+ 
+@@ -403,7 +403,7 @@ class HyLexer(RegexLexer):
+             (r'0[xX][a-fA-F0-9]+', Number.Hex),
+ 
+             # strings, symbols and characters
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             (r"'" + valid_name, String.Symbol),
+             (r"\\(.|[a-z]+)", String.Char),
+             (r'^(\s*)([rRuU]{,2}"""(?:.|\n)*?""")', bygroups(Text, String.Doc)),
+@@ -1490,7 +1490,7 @@ class NewLispLexer(RegexLexer):
+             (r'\s+', Text),
+ 
+             # strings, symbols and characters
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+ 
+             # braces
+             (r'\{', String, "bracestring"),
+@@ -2385,7 +2385,7 @@ class CPSALexer(SchemeLexer):
+             # (r'(#e|#i|#b|#o|#d|#x)[\d.]+', Number),
+ 
+             # strings, symbols and characters
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             (r"'" + valid_name, String.Symbol),
+             (r"#\\([()/'\"._!§$%& ?=+-]|[a-zA-Z0-9]+)", String.Char),
+ 
+@@ -2598,7 +2598,7 @@ class XtlangLexer(RegexLexer):
+             (r'(#b|#o|#x)[\d.]+', Number),
+ 
+             # strings
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+ 
+             # true/false constants
+             (r'(#t|#f)', Name.Constant),
+@@ -2669,7 +2669,7 @@ class FennelLexer(RegexLexer):
+             (r'-?\d+\.\d+', Number.Float),
+             (r'-?\d+', Number.Integer),
+ 
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             (r"'(\\\\|\\'|[^'])*'", String),
+ 
+             # these are technically strings, but it's worth visually
+diff --git a/pygments/lexers/make.py b/pygments/lexers/make.py
+index f67f109..8b9477d 100644
+--- a/pygments/lexers/make.py
++++ b/pygments/lexers/make.py
+@@ -93,8 +93,8 @@ class BaseMakefileLexer(RegexLexer):
+             (r'([\w${}().-]+)(\s*)([!?:+]?=)([ \t]*)((?:.*\\\n)+|.*\n)',
+              bygroups(Name.Variable, Text, Operator, Text, using(BashLexer))),
+             # strings
+-            (r'(?s)"(\\\\|\\.|[^"\\])*"', String.Double),
+-            (r"(?s)'(\\\\|\\.|[^'\\])*'", String.Single),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
++            (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
+             # targets
+             (r'([^\n:]+)(:+)([ \t]*)', bygroups(Name.Function, Operator, Text),
+              'block-header'),
+diff --git a/pygments/lexers/parsers.py b/pygments/lexers/parsers.py
+index 8bcbfc5..bada329 100644
+--- a/pygments/lexers/parsers.py
++++ b/pygments/lexers/parsers.py
+@@ -65,10 +65,10 @@ class RagelLexer(RegexLexer):
+             (r'[+-]?[0-9]+', Number.Integer),
+         ],
+         'literals': [
+-            (r'"(\\\\|\\"|[^"])*"', String),              # double quote string
+-            (r"'(\\\\|\\'|[^'])*'", String),              # single quote string
+-            (r'\[(\\\\|\\\]|[^\]])*\]', String),          # square bracket literals
+-            (r'/(?!\*)(\\\\|\\/|[^/])*/', String.Regex),  # regular expressions
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
++            (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
++            (r'\[(\\\\|\\[^\\]|[^\\\]])*\]', String),          # square bracket literals
++            (r'/(?!\*)(\\\\|\\[^\\]|[^/\\])*/', String.Regex),  # regular expressions
+         ],
+         'identifiers': [
+             (r'[a-zA-Z_]\w*', Name.Variable),
+@@ -107,15 +107,15 @@ class RagelLexer(RegexLexer):
+                 r'[^\\]\\[{}]',  # allow escaped { or }
+ 
+                 # strings and comments may safely contain unsafe characters
+-                r'"(\\\\|\\"|[^"])*"',  # double quote string
+-                r"'(\\\\|\\'|[^'])*'",  # single quote string
++                r'"(\\\\|\\[^\\]|[^"\\])*"',
++                r"'(\\\\|\\[^\\]|[^'\\])*'",
+                 r'//.*$\n?',            # single line comment
+                 r'/\*(.|\n)*?\*/',      # multi-line javadoc-style comment
+                 r'\#.*$\n?',            # ruby comment
+ 
+                 # regular expression: There's no reason for it to start
+                 # with a * and this stops confusion with comments.
+-                r'/(?!\*)(\\\\|\\/|[^/])*/',
++                r'/(?!\*)(\\\\|\\[^\\]|[^/\\])*/',
+ 
+                 # / is safe now that we've handled regex and javadoc comments
+                 r'/',
+@@ -148,12 +148,12 @@ class RagelEmbeddedLexer(RegexLexer):
+                 r'%(?=[^%]|$)',   # a single % sign is okay, just not 2 of them
+ 
+                 # strings and comments may safely contain unsafe characters
+-                r'"(\\\\|\\"|[^"])*"',  # double quote string
+-                r"'(\\\\|\\'|[^'])*'",  # single quote string
++                r'"(\\\\|\\[^\\]|[^"\\])*"',
++                r"'(\\\\|\\[^\\]|[^'\\])*'",
+                 r'/\*(.|\n)*?\*/',      # multi-line javadoc-style comment
+                 r'//.*$\n?',  # single line comment
+                 r'\#.*$\n?',  # ruby/ragel comment
+-                r'/(?!\*)(\\\\|\\/|[^/])*/',  # regular expression
++                r'/(?!\*)(\\\\|\\[^\\]|[^/\\])*/',  # regular expression
+ 
+                 # / is safe now that we've handled regex and javadoc comments
+                 r'/',
+@@ -183,7 +183,7 @@ class RagelEmbeddedLexer(RegexLexer):
+ 
+                     # specifically allow regex followed immediately by *
+                     # so it doesn't get mistaken for a comment
+-                    r'/(?!\*)(\\\\|\\/|[^/])*/\*',
++                    r'/(?!\*)(\\\\|\\[^\\]|[^/\\])*/\*',
+ 
+                     # allow / as long as it's not followed by another / or by a *
+                     r'/(?=[^/*]|$)',
+@@ -194,9 +194,9 @@ class RagelEmbeddedLexer(RegexLexer):
+                 )) + r')+',
+ 
+                 # strings and comments may safely contain unsafe characters
+-                r'"(\\\\|\\"|[^"])*"',      # double quote string
+-                r"'(\\\\|\\'|[^'])*'",      # single quote string
+-                r"\[(\\\\|\\\]|[^\]])*\]",  # square bracket literal
++                r'"(\\\\|\\[^\\]|[^"\\])*"',
++                r"'(\\\\|\\[^\\]|[^'\\])*'",
++                r"\[(\\\\|\\[^\\]|[^\]\\])*\]",  # square bracket literal
+                 r'/\*(.|\n)*?\*/',          # multi-line javadoc-style comment
+                 r'//.*$\n?',                # single line comment
+                 r'\#.*$\n?',                # ruby/ragel comment
+@@ -422,8 +422,8 @@ class AntlrLexer(RegexLexer):
+             (r':', Punctuation),
+ 
+             # literals
+-            (r"'(\\\\|\\'|[^'])*'", String),
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
++            (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
+             (r'<<([^>]|>[^>])>>', String),
+             # identifiers
+             # Tokens start with capital letter.
+@@ -462,14 +462,14 @@ class AntlrLexer(RegexLexer):
+                 r'[^${}\'"/\\]+',  # exclude unsafe characters
+ 
+                 # strings and comments may safely contain unsafe characters
+-                r'"(\\\\|\\"|[^"])*"',  # double quote string
+-                r"'(\\\\|\\'|[^'])*'",  # single quote string
++                r'"(\\\\|\\[^\\]|[^"\\])*"',
++                r"'(\\\\|\\[^\\]|[^'\\])*'",
+                 r'//.*$\n?',            # single line comment
+                 r'/\*(.|\n)*?\*/',      # multi-line javadoc-style comment
+ 
+                 # regular expression: There's no reason for it to start
+                 # with a * and this stops confusion with comments.
+-                r'/(?!\*)(\\\\|\\/|[^/])*/',
++                r'/(?!\*)(\\\\|\\[^\\]|[^/\\])*/',
+ 
+                 # backslashes are okay, as long as we are not backslashing a %
+                 r'\\(?!%)',
+@@ -489,14 +489,14 @@ class AntlrLexer(RegexLexer):
+                 r'[^$\[\]\'"/]+',  # exclude unsafe characters
+ 
+                 # strings and comments may safely contain unsafe characters
+-                r'"(\\\\|\\"|[^"])*"',  # double quote string
+-                r"'(\\\\|\\'|[^'])*'",  # single quote string
++                r'"(\\\\|\\[^\\]|[^"\\])*"',
++                r"'(\\\\|\\[^\\]|[^'\\])*'",
+                 r'//.*$\n?',            # single line comment
+                 r'/\*(.|\n)*?\*/',      # multi-line javadoc-style comment
+ 
+                 # regular expression: There's no reason for it to start
+                 # with a * and this stops confusion with comments.
+-                r'/(?!\*)(\\\\|\\/|[^/])*/',
++                r'/(?!\*)(\\\\|\\[^\\]|[^/\\])*/',
+ 
+                 # Now that we've handled regex and javadoc comments
+                 # it's safe to let / through.
+@@ -736,8 +736,8 @@ class TreetopBaseLexer(RegexLexer):
+         'rule': [
+             include('space'),
+             include('end'),
+-            (r'"(\\\\|\\"|[^"])*"', String.Double),
+-            (r"'(\\\\|\\'|[^'])*'", String.Single),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
++            (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
+             (r'([A-Za-z_]\w*)(:)', bygroups(Name.Label, Punctuation)),
+             (r'[A-Za-z_]\w*', Name),
+             (r'[()]', Punctuation),
+diff --git a/pygments/lexers/php.py b/pygments/lexers/php.py
+index bd4a237..8b49de7 100644
+--- a/pygments/lexers/php.py
++++ b/pygments/lexers/php.py
+@@ -79,8 +79,8 @@ class ZephirLexer(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),
+         ]
+     }
+ 
+diff --git a/pygments/lexers/prolog.py b/pygments/lexers/prolog.py
+index 7078362..ee5bf2e 100644
+--- a/pygments/lexers/prolog.py
++++ b/pygments/lexers/prolog.py
+@@ -227,7 +227,7 @@ class LogtalkLexer(RegexLexer):
+             # Existential quantifier
+             (r'\^', Operator),
+             # Strings
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             # Punctuation
+             (r'[()\[\],.|]', Text),
+             # Atoms
+@@ -277,7 +277,7 @@ class LogtalkLexer(RegexLexer):
+             (r"[a-z][a-zA-Z0-9_]*", Text),
+             (r"'", String, 'quoted_atom'),
+             # Strings
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             # End of entity-opening directive
+             (r'([)]\.)', Text, 'root'),
+             # Scope operator
+diff --git a/pygments/lexers/ruby.py b/pygments/lexers/ruby.py
+index 8bcbde6..ac79a58 100644
+--- a/pygments/lexers/ruby.py
++++ b/pygments/lexers/ruby.py
+@@ -108,7 +108,7 @@ class RubyLexer(ExtendedRegexLexer):
+             # easy ones
+             (r'\:@{0,2}[a-zA-Z_]\w*[!?]?', String.Symbol),
+             (words(RUBY_OPERATORS, prefix=r'\:@{0,2}'), String.Symbol),
+-            (r":'(\\\\|\\'|[^'])*'", String.Symbol),
++            (r":'(\\\\|\\[^\\]|[^'\\])*'", String.Symbol),
+             (r"'(\\\\|\\'|[^'])*'", String.Single),
+             (r':"', String.Symbol, 'simple-sym'),
+             (r'([a-zA-Z_]\w*)(:)(?!:)',
+@@ -451,26 +451,26 @@ class FancyLexer(RegexLexer):
+     tokens = {
+         # copied from PerlLexer:
+         'balanced-regex': [
+-            (r'/(\\\\|\\/|[^/])*/[egimosx]*', String.Regex, '#pop'),
+-            (r'!(\\\\|\\!|[^!])*![egimosx]*', String.Regex, '#pop'),
++            (r'/(\\\\|\\[^\\]|[^/\\])*/[egimosx]*', String.Regex, '#pop'),
++            (r'!(\\\\|\\[^\\]|[^!\\])*![egimosx]*', String.Regex, '#pop'),
+             (r'\\(\\\\|[^\\])*\\[egimosx]*', String.Regex, '#pop'),
+-            (r'\{(\\\\|\\\}|[^}])*\}[egimosx]*', String.Regex, '#pop'),
+-            (r'<(\\\\|\\>|[^>])*>[egimosx]*', String.Regex, '#pop'),
+-            (r'\[(\\\\|\\\]|[^\]])*\][egimosx]*', String.Regex, '#pop'),
+-            (r'\((\\\\|\\\)|[^)])*\)[egimosx]*', String.Regex, '#pop'),
+-            (r'@(\\\\|\\@|[^@])*@[egimosx]*', String.Regex, '#pop'),
+-            (r'%(\\\\|\\%|[^%])*%[egimosx]*', String.Regex, '#pop'),
+-            (r'\$(\\\\|\\\$|[^$])*\$[egimosx]*', String.Regex, '#pop'),
++            (r'\{(\\\\|\\[^\\]|[^}\\])*\}[egimosx]*', String.Regex, '#pop'),
++            (r'<(\\\\|\\[^\\]|[^>\\])*>[egimosx]*', String.Regex, '#pop'),
++            (r'\[(\\\\|\\[^\\]|[^\]\\])*\][egimosx]*', String.Regex, '#pop'),
++            (r'\((\\\\|\\[^\\]|[^)\\])*\)[egimosx]*', String.Regex, '#pop'),
++            (r'@(\\\\|\\[^\\]|[^@\\])*@[egimosx]*', String.Regex, '#pop'),
++            (r'%(\\\\|\\[^\\]|[^%\\])*%[egimosx]*', String.Regex, '#pop'),
++            (r'\$(\\\\|\\[^\\]|[^$\\])*\$[egimosx]*', String.Regex, '#pop'),
+         ],
+         'root': [
+             (r'\s+', Text),
+ 
+             # balanced delimiters (copied from PerlLexer):
+-            (r's\{(\\\\|\\\}|[^}])*\}\s*', String.Regex, 'balanced-regex'),
+-            (r's<(\\\\|\\>|[^>])*>\s*', String.Regex, 'balanced-regex'),
+-            (r's\[(\\\\|\\\]|[^\]])*\]\s*', String.Regex, 'balanced-regex'),
+-            (r's\((\\\\|\\\)|[^)])*\)\s*', String.Regex, 'balanced-regex'),
+-            (r'm?/(\\\\|\\/|[^/\n])*/[gcimosx]*', String.Regex),
++            (r's\{(\\\\|\\[^\\]|[^}\\])*\}\s*', String.Regex, 'balanced-regex'),
++            (r's<(\\\\|\\[^\\]|[^>\\])*>\s*', String.Regex, 'balanced-regex'),
++            (r's\[(\\\\|\\[^\\]|[^\]\\])*\]\s*', String.Regex, 'balanced-regex'),
++            (r's\((\\\\|\\[^\\]|[^)\\])*\)\s*', String.Regex, 'balanced-regex'),
++            (r'm?/(\\\\|\\[^\\]|[^///\n])*/[gcimosx]*', String.Regex),
+             (r'm(?=[/!\\{<\[(@%$])', String.Regex, 'balanced-regex'),
+ 
+             # Comments
+@@ -478,9 +478,9 @@ class FancyLexer(RegexLexer):
+             # Symbols
+             (r'\'([^\'\s\[\](){}]+|\[\])', String.Symbol),
+             # Multi-line DoubleQuotedString
+-            (r'"""(\\\\|\\"|[^"])*"""', String),
++            (r'"""(\\\\|\\[^\\]|[^\\])*?"""', String),
+             # DoubleQuotedString
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             # keywords
+             (r'(def|class|try|catch|finally|retry|return|return_local|match|'
+              r'case|->|=>)\b', Keyword),
+diff --git a/pygments/lexers/scripting.py b/pygments/lexers/scripting.py
+index a340f8e..90701e7 100644
+--- a/pygments/lexers/scripting.py
++++ b/pygments/lexers/scripting.py
+@@ -284,7 +284,7 @@ class ChaiscriptLexer(RegexLexer):
+             (r'0x[0-9a-fA-F]+', Number.Hex),
+             (r'[0-9]+', Number.Integer),
+             (r'"', String.Double, 'dqstring'),
+-            (r"'(\\\\|\\'|[^'])*'", String.Single),
++            (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
+         ],
+         'dqstring': [
+             (r'\$\{[^"}]+?\}', String.Interpol),
+@@ -690,7 +690,7 @@ class AppleScriptLexer(RegexLexer):
+             (r'\b(%s)s?\b' % '|'.join(StudioClasses), Name.Builtin),
+             (r'\b(%s)\b' % '|'.join(StudioCommands), Name.Builtin),
+             (r'\b(%s)\b' % '|'.join(References), Name.Builtin),
+-            (r'"(\\\\|\\"|[^"])*"', String.Double),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
+             (r'\b(%s)\b' % Identifiers, Name.Variable),
+             (r'[-+]?(\d+\.\d*|\d*\.\d+)(E[-+][0-9]+)?', Number.Float),
+             (r'[-+]?\d+', Number.Integer),
+@@ -834,7 +834,7 @@ class MOOCodeLexer(RegexLexer):
+             # Numbers
+             (r'(0|[1-9][0-9_]*)', Number.Integer),
+             # Strings
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             # exceptions
+             (r'(E_PERM|E_DIV)', Name.Exception),
+             # db-refs
+@@ -925,7 +925,7 @@ class HybrisLexer(RegexLexer):
+                 'Runnable', 'CGI', 'ClientSocket', 'Socket', 'ServerSocket',
+                 'File', 'Console', 'Directory', 'Exception'), suffix=r'\b'),
+              Keyword.Type),
+-            (r'"(\\\\|\\"|[^"])*"', String),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+             (r"'\\.'|'[^\\]'|'\\u[0-9a-f]{4}'", String.Char),
+             (r'(\.)([a-zA-Z_]\w*)',
+              bygroups(Operator, Name.Attribute)),
+diff --git a/pygments/lexers/supercollider.py b/pygments/lexers/supercollider.py
+index d0d033a..ed4218a 100644
+--- a/pygments/lexers/supercollider.py
++++ b/pygments/lexers/supercollider.py
+@@ -84,7 +84,7 @@ class SuperColliderLexer(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),
+         ]
+     }
+diff --git a/pygments/lexers/templates.py b/pygments/lexers/templates.py
+index d909662..6cfed37 100644
+--- a/pygments/lexers/templates.py
++++ b/pygments/lexers/templates.py
+@@ -179,8 +179,8 @@ class SmartyLexer(RegexLexer):
+             (r'(true|false|null)\b', Keyword.Constant),
+             (r"[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|"
+              r"0[xX][0-9a-fA-F]+[Ll]?", Number),
+-            (r'"(\\\\|\\"|[^"])*"', String.Double),
+-            (r"'(\\\\|\\'|[^'])*'", String.Single),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
++            (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
+             (r'[a-zA-Z_]\w*', Name.Attribute)
+         ]
+     }
+@@ -252,8 +252,8 @@ class VelocityLexer(RegexLexer):
+             (r'\$!?\{?', Punctuation, 'variable'),
+             (r'\s+', Text),
+             (r'[,:]', Punctuation),
+-            (r'"(\\\\|\\"|[^"])*"', String.Double),
+-            (r"'(\\\\|\\'|[^'])*'", String.Single),
++            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
++            (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
+             (r"0[xX][0-9a-fA-F]+[Ll]?", Number),
+             (r"\b[0-9]+\b", Number),
+             (r'(true|false|null)\b', Keyword.Constant),
+@@ -373,8 +373,8 @@ class DjangoLexer(RegexLexer):
+             (r'(loop|block|super|forloop)\b', Name.Builtin),
+             (r'[a-zA-Z_][\w-]*', Name.Variable),
+             (r'\.\w+', Name.Variable),
+-            (r':?"(\\\\|\\"|[^"])*"', String.Double),
+-            (r":?'(\\\\|\\'|[^'])*'", String.Single),
++            (r':?"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
++            (r":?'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
+             (r'([{}()\[\]+\-*/%,:~]|[><=]=?|!=)', Operator),
+             (r"[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|"
+              r"0[xX][0-9a-fA-F]+[Ll]?", Number),
+@@ -1852,8 +1852,8 @@ class HandlebarsLexer(RegexLexer):
+             include('variable'),
+ 
+             # borrowed from DjangoLexer
+-            (r':?"(\\\\|\\"|[^"])*"', String.Double),
+-            (r":?'(\\\\|\\'|[^'])*'", String.Single),
++            (r':?"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
++            (r":?'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
+             (r"[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|"
+              r"0[xX][0-9a-fA-F]+[Ll]?", Number),
+         ]
+@@ -2165,8 +2165,8 @@ class TwigLexer(RegexLexer):
+             (_ident_inner, Name.Variable),
+             (r'\.' + _ident_inner, Name.Variable),
+             (r'\.[0-9]+', Number),
+-            (r':?"(\\\\|\\"|[^"])*"', String.Double),
+-            (r":?'(\\\\|\\'|[^'])*'", String.Single),
++            (r':?"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
++            (r":?'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
+             (r'([{}()\[\]+\-*/,:~%]|\.\.|\?|:|\*\*|\/\/|!=|[><=]=?)', Operator),
+             (r"[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|"
+              r"0[xX][0-9a-fA-F]+[Ll]?", Number),
+@@ -2245,8 +2245,8 @@ class Angular2Lexer(RegexLexer):
+ 
+             # Literals
+             (r':?(true|false)', String.Boolean),
+-            (r':?"(\\\\|\\"|[^"])*"', String.Double),
+-            (r":?'(\\\\|\\'|[^'])*'", String.Single),
++            (r':?"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
++            (r":?'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
+             (r"[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|"
+              r"0[xX][0-9a-fA-F]+[Ll]?", Number),
+ 
+diff --git a/pygments/lexers/textedit.py b/pygments/lexers/textedit.py
+index 3c6fb57..04c8015 100644
+--- a/pygments/lexers/textedit.py
++++ b/pygments/lexers/textedit.py
+@@ -69,8 +69,8 @@ class AwkLexer(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),
+         ]
+     }
+ 
+diff --git a/pygments/lexers/urbi.py b/pygments/lexers/urbi.py
+index 72349cb..28b358d 100644
+--- a/pygments/lexers/urbi.py
++++ b/pygments/lexers/urbi.py
+@@ -117,11 +117,11 @@ class UrbiscriptLexer(ExtendedRegexLexer):
+         ],
+         'string.double': [
+             (r'((?:\\\\|\\"|[^"])*?)(\\B\((\d+)\)\()', blob_callback),
+-            (r'(\\\\|\\"|[^"])*?"', String.Double, '#pop'),
++            (r'(\\\\|\\[^\\]|[^"\\])*?"', String.Double, '#pop'),
+         ],
+         'string.single': [
+             (r"((?:\\\\|\\'|[^'])*?)(\\B\((\d+)\)\()", blob_callback),
+-            (r"(\\\\|\\'|[^'])*?'", String.Single, '#pop'),
++            (r"(\\\\|\\[^\\]|[^'\\])*?'", String.Single, '#pop'),
+         ],
+         # from http://pygments.org/docs/lexerdevelopment/#changing-states
+         'comment': [
+diff --git a/pygments/lexers/webmisc.py b/pygments/lexers/webmisc.py
+index b39334b..a1a73f4 100644
+--- a/pygments/lexers/webmisc.py
++++ b/pygments/lexers/webmisc.py
+@@ -855,8 +855,8 @@ 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),
+         ]
+     }
+ 
+diff --git a/pygments/lexers/x10.py b/pygments/lexers/x10.py
+index eac87b1..317c66c 100644
+--- a/pygments/lexers/x10.py
++++ b/pygments/lexers/x10.py
+@@ -62,7 +62,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)
+         ],
+-- 
+1.8.3.1
+

python-pygments.spec

@@ -16,18 +16,24 @@ need to prettify source code. Highlights are: \
 Name:           python-pygments
 Summary:        Syntax highlighting engine written in Python
 Version:        2.5.2
-Release:        1
+Release:        6
 License:        BSD
 URL:            http://pygments.org/
 Source0:        https://pypi.org/packages/source/P/Pygments/Pygments-%{version}.tar.gz
 BuildArch:      noarch
 
+Patch6000:      backport-CVE-2021-20270.patch
+Patch6001:      backport-CVE-2021-27291.patch
+Patch6002:      backport-weed-out-more-backtracking-string-regexes.patch
+Patch6003:      backport-Remove-generated-output-directory-when-make-clean-is.patch
+Patch6004:      backport-Use-wildcards-to-include-the-pygments-module.patch
+
 %description
 %{_description}
 
 %package -n python2-pygments
 BuildRequires:  python2-devel >= 2.4, python2-setuptools
-BuildRequires:  python2-nose, python2-sphinx
+BuildRequires:  python2-nose, python2-sphinx python2-pytest
 Summary:        Syntax highlighting engine written in Python
 %{?python_provide:%python_provide python2-pygments}
 
@@ -35,7 +41,7 @@ Summary:        Syntax highlighting engine written in Python
 %{_description}
 
 %package -n python3-pygments
-BuildRequires:  python3-devel, python3-setuptools, python3-nose
+BuildRequires:  python3-devel, python3-setuptools, python3-nose python3-pytest
 Summary:        Syntax highlighting engine written in Python
 %{?python_provide:%python_provide python3-pygments}
 
@@ -64,8 +70,8 @@ cp -r doc/docs doc/reST
 %py3_install
 
 %check
-make test PYTHON=%{__python2}
+%{__python2} -m pytest
-make test PYTHON=%{__python3}
+%{__python3} -m pytest
 
 %files -n python2-pygments
 %license LICENSE
@@ -81,6 +87,21 @@ make test PYTHON=%{__python3}
 %lang(en) %{_mandir}/man1/pygmentize.1*
 
 %changelog
+* Wed Dec 27 2023 fandehui <fandehui@xfusion.com> - 2.5.2-6
+- Use wildcards to include the pygments module
+
+* Thu Nov 3 2021 huangduirong<huangduirong@huawei.com> - 2.5.2-5
+- Remove generated output/ directory when 'make clean' is called
+
+* Sun Sep 26 2021 huangduirong<huangduirong@huawei.com> - 2.5.2-4
+- Infinite loop in get_tokens_unprocessed
+
+* Mon Apr 12 2021 shixuantong<shixuantong@huawei.com> - 2.5.2-3
+- fix CVE-2021-20270 CVE-2021-27291
+
+* Sat Dec 05 2020 shixuantong<shixuantong@huawei.com> - 2.5.2-2
+- use pytest to run test suite
+
 * Sat Aug 22 2020 tianwei<tianwei12@huawei.com> - 2.5.2-1
 - Package update to 2.5.2