Merged in PurpleMyst/pygments-main (pull request #727)

Highlight %a in Python3Lexer

Approved-by: PurpleMyst <purplemyst2017@gmail.com>

12 files changed, 272 insertions, 44 deletions

diff --git a/pygments/lexers/_lua_builtins.py b/pygments/lexers/_lua_builtins.py
index c60bf5a2..0561725d 100644
--- a/pygments/lexers/_lua_builtins.py
+++ b/pygments/lexers/_lua_builtins.py
@@ -288,7 +288,7 @@ if __name__ == '__main__':  # pragma: no cover
             print('>> %s' % full_function_name)
             m = get_function_module(full_function_name)
             modules.setdefault(m, []).append(full_function_name)
-        modules = {k: tuple(v) for k, v in modules.iteritems()}
+        modules = dict((k, tuple(v)) for k, v in modules.iteritems())
 
         regenerate(__file__, modules)
 
diff --git a/pygments/lexers/_mapping.py b/pygments/lexers/_mapping.py
index b48ee1d1..f9513e28 100644
--- a/pygments/lexers/_mapping.py
+++ b/pygments/lexers/_mapping.py
@@ -153,6 +153,7 @@ LEXERS = {
     'FancyLexer': ('pygments.lexers.ruby', 'Fancy', ('fancy', 'fy'), ('*.fy', '*.fancypack'), ('text/x-fancysrc',)),
     'FantomLexer': ('pygments.lexers.fantom', 'Fantom', ('fan',), ('*.fan',), ('application/x-fantom',)),
     'FelixLexer': ('pygments.lexers.felix', 'Felix', ('felix', 'flx'), ('*.flx', '*.flxh'), ('text/x-felix',)),
+    'FennelLexer': ('pygments.lexers.lisp', 'Fennel', (), ('*.fnl',), ()),
     'FishShellLexer': ('pygments.lexers.shell', 'Fish', ('fish', 'fishshell'), ('*.fish', '*.load'), ('application/x-fish',)),
     'FlatlineLexer': ('pygments.lexers.dsls', 'Flatline', ('flatline',), (), ('text/x-flatline',)),
     'ForthLexer': ('pygments.lexers.forth', 'Forth', ('forth',), ('*.frt', '*.fs'), ('application/x-forth',)),
@@ -174,6 +175,7 @@ LEXERS = {
     'GosuTemplateLexer': ('pygments.lexers.jvm', 'Gosu Template', ('gst',), ('*.gst',), ('text/x-gosu-template',)),
     'GroffLexer': ('pygments.lexers.markup', 'Groff', ('groff', 'nroff', 'man'), ('*.[1234567]', '*.man'), ('application/x-troff', 'text/troff')),
     'GroovyLexer': ('pygments.lexers.jvm', 'Groovy', ('groovy',), ('*.groovy', '*.gradle'), ('text/x-groovy',)),
+    'HLSLShaderLexer': ('pygments.lexers.graphics', 'HLSL', ('hlsl',), ('*.hlsl', '*.hlsli'), ('text/x-hlsl',)),
     'HamlLexer': ('pygments.lexers.html', 'Haml', ('haml',), ('*.haml',), ('text/x-haml',)),
     'HandlebarsHtmlLexer': ('pygments.lexers.templates', 'HTML+Handlebars', ('html+handlebars',), ('*.handlebars', '*.hbs'), ('text/html+handlebars', 'text/x-handlebars-template')),
     'HandlebarsLexer': ('pygments.lexers.templates', 'Handlebars', ('handlebars',), (), ()),
@@ -367,7 +369,7 @@ LEXERS = {
     'RtsLexer': ('pygments.lexers.trafficscript', 'TrafficScript', ('rts', 'trafficscript'), ('*.rts',), ()),
     'RubyConsoleLexer': ('pygments.lexers.ruby', 'Ruby irb session', ('rbcon', 'irb'), (), ('text/x-ruby-shellsession',)),
     'RubyLexer': ('pygments.lexers.ruby', 'Ruby', ('rb', 'ruby', 'duby'), ('*.rb', '*.rbw', 'Rakefile', '*.rake', '*.gemspec', '*.rbx', '*.duby', 'Gemfile'), ('text/x-ruby', 'application/x-ruby')),
-    'RustLexer': ('pygments.lexers.rust', 'Rust', ('rust',), ('*.rs', '*.rs.in'), ('text/rust',)),
+    'RustLexer': ('pygments.lexers.rust', 'Rust', ('rust', 'rs'), ('*.rs', '*.rs.in'), ('text/rust',)),
     'SASLexer': ('pygments.lexers.sas', 'SAS', ('sas',), ('*.SAS', '*.sas'), ('text/x-sas', 'text/sas', 'application/x-sas')),
     'SLexer': ('pygments.lexers.r', 'S', ('splus', 's', 'r'), ('*.S', '*.R', '.Rhistory', '.Rprofile', '.Renviron'), ('text/S-plus', 'text/S', 'text/x-r-source', 'text/x-r', 'text/x-R', 'text/x-r-history', 'text/x-r-profile')),
     'SMLLexer': ('pygments.lexers.ml', 'Standard ML', ('sml',), ('*.sml', '*.sig', '*.fun'), ('text/x-standardml', 'application/x-standardml')),
diff --git a/pygments/lexers/ampl.py b/pygments/lexers/ampl.py
index d439cb19..638d025d 100644
--- a/pygments/lexers/ampl.py
+++ b/pygments/lexers/ampl.py
@@ -3,7 +3,7 @@
     pygments.lexers.ampl
     ~~~~~~~~~~~~~~~~~~~~
 
-    Lexers for the ampl language. <http://ampl.com/>
+    Lexers for the AMPL language.
 
     :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
@@ -18,7 +18,7 @@ __all__ = ['AmplLexer']
 
 class AmplLexer(RegexLexer):
     """
-    For AMPL source code.
+    For `AMPL <http://ampl.com/>`_ source code.
 
     .. versionadded:: 2.2
     """
diff --git a/pygments/lexers/configs.py b/pygments/lexers/configs.py
index c39b1a52..4af2adb6 100644
--- a/pygments/lexers/configs.py
+++ b/pygments/lexers/configs.py
@@ -15,6 +15,7 @@ from pygments.lexer import RegexLexer, default, words, bygroups, include, using
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
     Number, Punctuation, Whitespace, Literal
 from pygments.lexers.shell import BashLexer
+from pygments.lexers.data import JsonLexer
 
 __all__ = ['IniLexer', 'RegeditLexer', 'PropertiesLexer', 'KconfigLexer',
            'Cfengine3Lexer', 'ApacheConfLexer', 'SquidConfLexer',
@@ -539,20 +540,25 @@ class DockerLexer(RegexLexer):
     filenames = ['Dockerfile', '*.docker']
     mimetypes = ['text/x-dockerfile-config']
 
-    _keywords = (r'(?:FROM|MAINTAINER|CMD|EXPOSE|ENV|ADD|ENTRYPOINT|'
-                 r'VOLUME|WORKDIR)')
-
+    _keywords = (r'(?:FROM|MAINTAINER|EXPOSE|WORKDIR|USER|STOPSIGNAL)')
+    _bash_keywords = (r'(?:RUN|CMD|ENTRYPOINT|ENV|ARG|LABEL|ADD|COPY)')
+    _lb = r'(?:\s*\\?\s*)' # dockerfile line break regex
     flags = re.IGNORECASE | re.MULTILINE
 
     tokens = {
         'root': [
-            (r'^(ONBUILD)(\s+)(%s)\b' % (_keywords,),
-             bygroups(Name.Keyword, Whitespace, Keyword)),
-            (r'^(%s)\b(.*)' % (_keywords,), bygroups(Keyword, String)),
             (r'#.*', Comment),
-            (r'RUN', Keyword),  # Rest of line falls through
+            (r'(ONBUILD)(%s)' % (_lb,), bygroups(Keyword, using(BashLexer))),
+            (r'(HEALTHCHECK)((%s--\w+=\w+%s)*)' % (_lb, _lb),
+                bygroups(Keyword, using(BashLexer))),
+            (r'(VOLUME|ENTRYPOINT|CMD|SHELL)(%s)(\[.*?\])' % (_lb,),
+                bygroups(Keyword, using(BashLexer), using(JsonLexer))),
+            (r'(LABEL|ENV|ARG)((%s\w+=\w+%s)*)' % (_lb, _lb),
+                bygroups(Keyword, using(BashLexer))),
+            (r'(%s|VOLUME)\b(.*)' % (_keywords), bygroups(Keyword, String)),
+            (r'(%s)' % (_bash_keywords,), Keyword),
             (r'(.*\\\n)*.+', using(BashLexer)),
-        ],
+        ]
     }
 
 
diff --git a/pygments/lexers/css.py b/pygments/lexers/css.py
index 29d83707..ce97730e 100644
--- a/pygments/lexers/css.py
+++ b/pygments/lexers/css.py
@@ -125,7 +125,7 @@ _css_properties = (
     'wrap-flow', 'wrap-inside', 'wrap-through', 'writing-mode', 'z-index',
 )
 
-# List of keyword values obtained from: 
+# List of keyword values obtained from:
 # http://cssvalues.com/
 _keyword_values = (
     'absolute', 'alias', 'all', 'all-petite-caps', 'all-scroll',
@@ -263,7 +263,7 @@ _time_units = (
     's', 'ms',
 )
 _all_units = _angle_units + _frequency_units + _length_units + \
-             _resolution_units + _time_units
+    _resolution_units + _time_units
 
 
 class CssLexer(RegexLexer):
@@ -322,16 +322,18 @@ class CssLexer(RegexLexer):
             include('urls'),
             (r'('+r'|'.join(_functional_notation_keyword_values)+r')(\()',
              bygroups(Name.Builtin, Punctuation), 'function-start'),
-            (r'([a-zA-Z_][\w-]+)(\()', bygroups(Name.Function, Punctuation), 'function-start'),
+            (r'([a-zA-Z_][\w-]+)(\()',
+             bygroups(Name.Function, Punctuation), 'function-start'),
             (words(_keyword_values, suffix=r'\b'), Keyword.Constant),
             (words(_other_keyword_values, suffix=r'\b'), Keyword.Constant),
             (words(_color_keywords, suffix=r'\b'), Keyword.Constant),
-            (words(_css_properties, suffix=r'\b'), Keyword), # for transition-property etc.
+            # for transition-property etc.
+            (words(_css_properties, suffix=r'\b'), Keyword),
             (r'\!important', Comment.Preproc),
             (r'/\*(?:.|\n)*?\*/', Comment),
 
             include('numeric-values'),
-            
+
             (r'[~^*!%&<>|+=@:./?-]+', Operator),
             (r'[\[\](),]+', Punctuation),
             (r'"(\\\\|\\"|[^"])*"', String.Double),
@@ -351,7 +353,8 @@ class CssLexer(RegexLexer):
             # function-start may be entered recursively
             (r'(' + r'|'.join(_functional_notation_keyword_values) + r')(\()',
              bygroups(Name.Builtin, Punctuation), 'function-start'),
-            (r'([a-zA-Z_][\w-]+)(\()', bygroups(Name.Function, Punctuation), 'function-start'),
+            (r'([a-zA-Z_][\w-]+)(\()',
+             bygroups(Name.Function, Punctuation), 'function-start'),
 
             (r'/\*(?:.|\n)*?\*/', Comment),
             include('numeric-values'),
@@ -373,8 +376,8 @@ class CssLexer(RegexLexer):
         'numeric-values': [
             (r'\#[a-zA-Z0-9]{1,6}', Number.Hex),
             (r'[+\-]?[0-9]*[.][0-9]+', Number.Float, 'numeric-end'),
-            (r'[+\-]?[0-9]+', Number.Integer, 'numeric-end'),            
-        ],        
+            (r'[+\-]?[0-9]+', Number.Integer, 'numeric-end'),
+        ],
         'numeric-end': [
             (words(_all_units, suffix=r'\b'), Keyword.Type),
             (r'%', Keyword.Type),
@@ -466,9 +469,9 @@ common_sass_tokens = {
     ],
 
     'string-single': [
-        (r"(\\.|#(?=[^\n{])|[^\n'#])+", String.Double),
+        (r"(\\.|#(?=[^\n{])|[^\n'#])+", String.Single),
         (r'#\{', String.Interpol, 'interpolation'),
-        (r"'", String.Double, '#pop'),
+        (r"'", String.Single, '#pop'),
     ],
 
     'string-url': [
diff --git a/pygments/lexers/graphics.py b/pygments/lexers/graphics.py
index c8af9f99..5c3ed7ee 100644
--- a/pygments/lexers/graphics.py
+++ b/pygments/lexers/graphics.py
@@ -15,7 +15,7 @@ from pygments.token import Text, Comment, Operator, Keyword, Name, \
     Number, Punctuation, String
 
 __all__ = ['GLShaderLexer', 'PostScriptLexer', 'AsymptoteLexer', 'GnuplotLexer',
-           'PovrayLexer']
+           'PovrayLexer', 'HLSLShaderLexer']
 
 
 class GLShaderLexer(RegexLexer):
@@ -75,6 +75,160 @@ class GLShaderLexer(RegexLexer):
     }
 
 
+class HLSLShaderLexer(RegexLexer):
+    """
+    HLSL (Microsoft Direct3D Shader) lexer.
+
+    .. versionadded:: 2.2
+    """
+    name = 'HLSL'
+    aliases = ['hlsl']
+    filenames = ['*.hlsl', '*.hlsli']
+    mimetypes = ['text/x-hlsl']
+
+    tokens = {
+        'root': [
+            (r'^#.*', Comment.Preproc),
+            (r'//.*', Comment.Single),
+            (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
+            (r'\+|-|~|!=?|\*|/|%|<<|>>|<=?|>=?|==?|&&?|\^|\|\|?',
+             Operator),
+            (r'[?:]', Operator),  # quick hack for ternary
+            (r'\bdefined\b', Operator),
+            (r'[;{}(),.\[\]]', Punctuation),
+            # FIXME when e is present, no decimal point needed
+            (r'[+-]?\d*\.\d+([eE][-+]?\d+)?f?', Number.Float),
+            (r'[+-]?\d+\.\d*([eE][-+]?\d+)?f?', Number.Float),
+            (r'0[xX][0-9a-fA-F]*', Number.Hex),
+            (r'0[0-7]*', Number.Oct),
+            (r'[1-9][0-9]*', Number.Integer),
+            (r'"', String, 'string'),
+            (words((
+                'asm','asm_fragment','break','case','cbuffer','centroid','class',
+                'column_major','compile','compile_fragment','const','continue',
+                'default','discard','do','else','export','extern','for','fxgroup',
+                'globallycoherent','groupshared','if','in','inline','inout',
+                'interface','line','lineadj','linear','namespace','nointerpolation',
+                'noperspective','NULL','out','packoffset','pass','pixelfragment',
+                'point','precise','return','register','row_major','sample',
+                'sampler','shared','stateblock','stateblock_state','static',
+                'struct','switch','tbuffer','technique','technique10',
+                'technique11','texture','typedef','triangle','triangleadj',
+                'uniform','vertexfragment','volatile','while'),
+                prefix=r'\b', suffix=r'\b'),
+             Keyword),
+            (words(('true','false'), prefix=r'\b', suffix=r'\b'),
+             Keyword.Constant),
+            (words((
+                'auto','catch','char','const_cast','delete','dynamic_cast','enum',
+                'explicit','friend','goto','long','mutable','new','operator',
+                'private','protected','public','reinterpret_cast','short','signed',
+                'sizeof','static_cast','template','this','throw','try','typename',
+                'union','unsigned','using','virtual'),
+                prefix=r'\b', suffix=r'\b'),
+             Keyword.Reserved),
+            (words((
+                'dword','matrix','snorm','string','unorm','unsigned','void','vector',
+                'BlendState','Buffer','ByteAddressBuffer','ComputeShader',
+                'DepthStencilState','DepthStencilView','DomainShader',
+                'GeometryShader','HullShader','InputPatch','LineStream',
+                'OutputPatch','PixelShader','PointStream','RasterizerState',
+                'RenderTargetView','RasterizerOrderedBuffer',
+                'RasterizerOrderedByteAddressBuffer',
+                'RasterizerOrderedStructuredBuffer','RasterizerOrderedTexture1D',
+                'RasterizerOrderedTexture1DArray','RasterizerOrderedTexture2D',
+                'RasterizerOrderedTexture2DArray','RasterizerOrderedTexture3D',
+                'RWBuffer','RWByteAddressBuffer','RWStructuredBuffer',
+                'RWTexture1D','RWTexture1DArray','RWTexture2D','RWTexture2DArray',
+                'RWTexture3D','SamplerState','SamplerComparisonState',
+                'StructuredBuffer','Texture1D','Texture1DArray','Texture2D',
+                'Texture2DArray','Texture2DMS','Texture2DMSArray','Texture3D',
+                'TextureCube','TextureCubeArray','TriangleStream','VertexShader'),
+                prefix=r'\b', suffix=r'\b'),
+             Keyword.Type),
+            (words((
+                'bool','double','float','int','half','min16float','min10float',
+                'min16int','min12int','min16uint','uint'),
+                prefix=r'\b', suffix=r'([1-4](x[1-4])?)?\b'),
+             Keyword.Type),     # vector and matrix types
+            (words((
+                'abort','abs','acos','all','AllMemoryBarrier',
+                'AllMemoryBarrierWithGroupSync','any','AppendStructuredBuffer',
+                'asdouble','asfloat','asin','asint','asuint','asuint','atan',
+                'atan2','ceil','CheckAccessFullyMapped','clamp','clip',
+                'CompileShader','ConsumeStructuredBuffer','cos','cosh','countbits',
+                'cross','D3DCOLORtoUBYTE4','ddx','ddx_coarse','ddx_fine','ddy',
+                'ddy_coarse','ddy_fine','degrees','determinant',
+                'DeviceMemoryBarrier','DeviceMemoryBarrierWithGroupSync','distance',
+                'dot','dst','errorf','EvaluateAttributeAtCentroid',
+                'EvaluateAttributeAtSample','EvaluateAttributeSnapped','exp',
+                'exp2','f16tof32','f32tof16','faceforward','firstbithigh',
+                'firstbitlow','floor','fma','fmod','frac','frexp','fwidth',
+                'GetRenderTargetSampleCount','GetRenderTargetSamplePosition',
+                'GlobalOrderedCountIncrement','GroupMemoryBarrier',
+                'GroupMemoryBarrierWithGroupSync','InterlockedAdd','InterlockedAnd',
+                'InterlockedCompareExchange','InterlockedCompareStore',
+                'InterlockedExchange','InterlockedMax','InterlockedMin',
+                'InterlockedOr','InterlockedXor','isfinite','isinf','isnan',
+                'ldexp','length','lerp','lit','log','log10','log2','mad','max',
+                'min','modf','msad4','mul','noise','normalize','pow','printf',
+                'Process2DQuadTessFactorsAvg','Process2DQuadTessFactorsMax',
+                'Process2DQuadTessFactorsMin','ProcessIsolineTessFactors',
+                'ProcessQuadTessFactorsAvg','ProcessQuadTessFactorsMax',
+                'ProcessQuadTessFactorsMin','ProcessTriTessFactorsAvg',
+                'ProcessTriTessFactorsMax','ProcessTriTessFactorsMin',
+                'QuadReadLaneAt','QuadSwapX','QuadSwapY','radians','rcp',
+                'reflect','refract','reversebits','round','rsqrt','saturate',
+                'sign','sin','sincos','sinh','smoothstep','sqrt','step','tan',
+                'tanh','tex1D','tex1D','tex1Dbias','tex1Dgrad','tex1Dlod',
+                'tex1Dproj','tex2D','tex2D','tex2Dbias','tex2Dgrad','tex2Dlod',
+                'tex2Dproj','tex3D','tex3D','tex3Dbias','tex3Dgrad','tex3Dlod',
+                'tex3Dproj','texCUBE','texCUBE','texCUBEbias','texCUBEgrad',
+                'texCUBElod','texCUBEproj','transpose','trunc','WaveAllBitAnd',
+                'WaveAllMax','WaveAllMin','WaveAllBitOr','WaveAllBitXor',
+                'WaveAllEqual','WaveAllProduct','WaveAllSum','WaveAllTrue',
+                'WaveAnyTrue','WaveBallot','WaveGetLaneCount','WaveGetLaneIndex',
+                'WaveGetOrderedIndex','WaveIsHelperLane','WaveOnce',
+                'WavePrefixProduct','WavePrefixSum','WaveReadFirstLane',
+                'WaveReadLaneAt'),
+                prefix=r'\b', suffix=r'\b'),
+             Name.Builtin),     # built-in functions
+            (words((
+                'SV_ClipDistance','SV_ClipDistance0','SV_ClipDistance1',
+                'SV_Culldistance','SV_CullDistance0','SV_CullDistance1',
+                'SV_Coverage','SV_Depth','SV_DepthGreaterEqual',
+                'SV_DepthLessEqual','SV_DispatchThreadID','SV_DomainLocation',
+                'SV_GroupID','SV_GroupIndex','SV_GroupThreadID','SV_GSInstanceID',
+                'SV_InnerCoverage','SV_InsideTessFactor','SV_InstanceID',
+                'SV_IsFrontFace','SV_OutputControlPointID','SV_Position',
+                'SV_PrimitiveID','SV_RenderTargetArrayIndex','SV_SampleIndex',
+                'SV_StencilRef','SV_TessFactor','SV_VertexID',
+                'SV_ViewportArrayIndex'),
+                prefix=r'\b', suffix=r'\b'),
+             Name.Decorator),   # system-value semantics
+            (r'\bSV_Target[0-7]?\b', Name.Decorator),
+            (words((
+                'allow_uav_condition','branch','call','domain','earlydepthstencil',
+                'fastopt','flatten','forcecase','instance','loop','maxtessfactor',
+                'numthreads','outputcontrolpoints','outputtopology','partitioning',
+                'patchconstantfunc','unroll'),
+                prefix=r'\b', suffix=r'\b'),
+             Name.Decorator),   # attributes
+            (r'[a-zA-Z_]\w*', Name),
+            (r'\\$', Comment.Preproc),  # backslash at end of line -- usually macro continuation
+            (r'\s+', Text),
+        ],
+        '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
+        ],
+    }
+
+
 class PostScriptLexer(RegexLexer):
     """
     Lexer for PostScript files.
diff --git a/pygments/lexers/jvm.py b/pygments/lexers/jvm.py
index f4392839..ccff41c1 100644
--- a/pygments/lexers/jvm.py
+++ b/pygments/lexers/jvm.py
@@ -801,7 +801,7 @@ class ClojureLexer(RegexLexer):
 
     # TODO / should divide keywords/symbols into namespace/rest
     # but that's hard, so just pretend / is part of the name
-    valid_name = r'(?!#)[\w!$%*+<=>?/.#-]+'
+    valid_name = r'(?!#)[\w!$%*+<=>?/.#|-]+'
 
     tokens = {
         'root': [
diff --git a/pygments/lexers/lisp.py b/pygments/lexers/lisp.py
index e258c347..f1494b13 100644
--- a/pygments/lexers/lisp.py
+++ b/pygments/lexers/lisp.py
@@ -19,7 +19,7 @@ from pygments.lexers.python import PythonLexer
 
 __all__ = ['SchemeLexer', 'CommonLispLexer', 'HyLexer', 'RacketLexer',
            'NewLispLexer', 'EmacsLispLexer', 'ShenLexer', 'CPSALexer',
-           'XtlangLexer']
+           'XtlangLexer', 'FennelLexer']
 
 
 class SchemeLexer(RegexLexer):
@@ -2327,13 +2327,13 @@ class ShenLexer(RegexLexer):
             token = Name.Function if token == Literal else token
             yield index, token, value
 
-        raise StopIteration
+        return
 
     def _process_signature(self, tokens):
         for index, token, value in tokens:
             if token == Literal and value == '}':
                 yield index, Punctuation, value
-                raise StopIteration
+                return
             elif token in (Literal, Name.Function):
                 token = Name.Variable if value.istitle() else Keyword.Type
             yield index, token, value
@@ -2619,3 +2619,72 @@ class XtlangLexer(RegexLexer):
             include('scheme')
         ],
     }
+
+class FennelLexer(RegexLexer):
+    """A lexer for the Fennel programming language <https://fennel-lang.org>
+
+    Fennel compiles to Lua, so all the Lua builtins are recognized as well
+    as the special forms that are particular to the Fennel compiler.
+    """
+    name = 'Fennel'
+    aliases = ['fennel', 'fnl']
+    filenames = ['*.fnl']
+
+    # these two lists are taken from fennel-mode.el:
+    # https://gitlab.com/technomancy/fennel-mode
+    # this list is current as of Fennel version 0.1.0.
+    special_forms = (
+        u'require-macros', u'eval-compiler',
+        u'do', u'values', u'if', u'when', u'each', u'for', u'fn', u'lambda',
+        u'λ', u'set', u'global', u'var', u'local', u'let', u'tset', u'doto',
+        u'set-forcibly!', u'defn', u'partial', u'while', u'or', u'and', u'true',
+        u'false', u'nil', u'.', u'+', u'..', u'^', u'-', u'*', u'%', u'/', u'>',
+        u'<', u'>=', u'<=', u'=', u'~=', u'#', u'...', u':', u'->', u'->>',
+    )
+
+    # Might be nicer to use the list from _lua_builtins.py but it's unclear how?
+    builtins = (
+        u'_G', u'_VERSION', u'arg', u'assert', u'bit32', u'collectgarbage',
+        u'coroutine', u'debug', u'dofile', u'error', u'getfenv',
+        u'getmetatable', u'io', u'ipairs', u'load', u'loadfile', u'loadstring',
+        u'math', u'next', u'os', u'package', u'pairs', u'pcall', u'print',
+        u'rawequal', u'rawget', u'rawlen', u'rawset', u'require', u'select',
+        u'setfenv', u'setmetatable', u'string', u'table', u'tonumber',
+        u'tostring', u'type', u'unpack', u'xpcall'
+    )
+
+    # based on the scheme definition, but disallowing leading digits and commas
+    valid_name = r'[a-zA-Z_!$%&*+/:<=>?@^~|-][\w!$%&*+/:<=>?@^~|\.-]*'
+
+    tokens = {
+        'root': [
+            # the only comment form is a semicolon; goes to the end of the line
+            (r';.*$', Comment.Single),
+
+            (r'[,\s]+', Text),
+            (r'-?\d+\.\d+', Number.Float),
+            (r'-?\d+', Number.Integer),
+
+            (r'"(\\\\|\\"|[^"])*"', String),
+            (r"'(\\\\|\\'|[^'])*'", String),
+
+            # these are technically strings, but it's worth visually
+            # distinguishing them because their intent is different
+            # from regular strings.
+            (r':' + valid_name, String.Symbol),
+
+            # special forms are keywords
+            (words(special_forms, suffix=' '), Keyword),
+            # lua standard library are builtins
+            (words(builtins, suffix=' '), Name.Builtin),
+            # special-case the vararg symbol
+            (r'\.\.\.', Name.Variable),
+            # regular identifiers
+            (valid_name, Name.Variable),
+
+            # all your normal paired delimiters for your programming enjoyment
+            (r'(\(|\))', Punctuation),
+            (r'(\[|\])', Punctuation),
+            (r'(\{|\})', Punctuation),
+        ]
+    }
diff --git a/pygments/lexers/markup.py b/pygments/lexers/markup.py
index 92dc9e7a..e6265f40 100644
--- a/pygments/lexers/markup.py
+++ b/pygments/lexers/markup.py
@@ -536,10 +536,9 @@ class MarkdownLexer(RegexLexer):
         # no lexer for this language. handle it like it was a code block
         if lexer is None:
             yield match.start(4), String, code
-            return
-
-        for item in do_insertions([], lexer.get_tokens_unprocessed(code)):
-            yield item
+        else:
+            for item in do_insertions([], lexer.get_tokens_unprocessed(code)):
+                yield item
 
         yield match.start(5), String        , match.group(5)
 
diff --git a/pygments/lexers/rust.py b/pygments/lexers/rust.py
index 6914f54d..10097fba 100644
--- a/pygments/lexers/rust.py
+++ b/pygments/lexers/rust.py
@@ -24,7 +24,7 @@ class RustLexer(RegexLexer):
     """
     name = 'Rust'
     filenames = ['*.rs', '*.rs.in']
-    aliases = ['rust']
+    aliases = ['rust', 'rs']
     mimetypes = ['text/rust']
 
     keyword_types = (
diff --git a/pygments/lexers/sql.py b/pygments/lexers/sql.py
index 7507c0fc..3f7dfdb8 100644
--- a/pygments/lexers/sql.py
+++ b/pygments/lexers/sql.py
@@ -308,14 +308,7 @@ class PostgresConsoleLexer(Lexer):
             # and continue until the end of command is detected
             curcode = ''
             insertions = []
-            while 1:
-                try:
-                    line = next(lines)
-                except StopIteration:
-                    # allow the emission of partially collected items
-                    # the repl loop will be broken below
-                    break
-
+            for line in lines:
                 # Identify a shell prompt in case of psql commandline example
                 if line.startswith('$') and not curcode:
                     lexer = get_lexer_by_name('console', **self.options)
@@ -346,8 +339,7 @@ class PostgresConsoleLexer(Lexer):
 
             # Emit the output lines
             out_token = Generic.Output
-            while 1:
-                line = next(lines)
+            for line in lines:
                 mprompt = re_prompt.match(line)
                 if mprompt is not None:
                     # push the line back to have it processed by the prompt
@@ -363,6 +355,8 @@ class PostgresConsoleLexer(Lexer):
                     yield (mmsg.start(2), out_token, mmsg.group(2))
                 else:
                     yield (0, out_token, line)
+            else:
+                return
 
 
 class SqlLexer(RegexLexer):
diff --git a/pygments/lexers/xorg.py b/pygments/lexers/xorg.py
index 89475a80..3bba930f 100644
--- a/pygments/lexers/xorg.py
+++ b/pygments/lexers/xorg.py
@@ -16,6 +16,7 @@ __all__ = ['XorgLexer']
 
 
 class XorgLexer(RegexLexer):
+    """Lexer for xorg.conf file."""
     name = 'Xorg'
     aliases = ['xorg.conf']
     filenames = ['xorg.conf']
@@ -26,8 +27,8 @@ class XorgLexer(RegexLexer):
             (r'\s+', Text),
             (r'#.*$', Comment),
 
-            (r'((|Sub)Section)(\s+)("\w+")',
-             bygroups(String.Escape, String.Escape, Text, String.Escape)),
+            (r'((?:Sub)?Section)(\s+)("\w+")',
+             bygroups(String.Escape, Text, String.Escape)),
             (r'(End(|Sub)Section)', String.Escape),
 
             (r'(\w+)(\s+)([^\n#]+)',