Overlap due to case insensitive mode

11 files changed, 63 insertions, 63 deletions

diff --git a/pygments/lexers/asm.py b/pygments/lexers/asm.py
index 13649521..35092f52 100644
--- a/pygments/lexers/asm.py
+++ b/pygments/lexers/asm.py
@@ -318,8 +318,8 @@ class NasmLexer(RegexLexer):
     filenames = ['*.asm', '*.ASM']
     mimetypes = ['text/x-nasm']
 
-    identifier = r'[a-zA-Z$._?][\w$.?#@~]*'
-    hexn = r'(?:0[xX][0-9a-fA-F]+|$0[0-9a-fA-F]*|[0-9]+[0-9a-fA-F]*h)'
+    identifier = r'[a-z$._?][\w$.?#@~]*'
+    hexn = r'(?:0[xX][0-9a-f]+|$0[0-9a-f]*|[0-9]+[0-9a-f]*h)'
     octn = r'[0-7]+q'
     binn = r'[01]+b'
     decn = r'[0-9]+'
diff --git a/pygments/lexers/compiled.py b/pygments/lexers/compiled.py
index c41cd3df..54edf9dc 100644
--- a/pygments/lexers/compiled.py
+++ b/pygments/lexers/compiled.py
@@ -1158,7 +1158,7 @@ class DylanLexer(RegexLexer):
         'type-error-value', 'type-for-copy', 'type-union', 'union', 'values',
         'vector', 'zero?'])
 
-    valid_name = '\\\\?[a-zA-Z0-9' + re.escape('!&*<>|^$%@_-+~?/=') + ']+'
+    valid_name = '\\\\?[a-z0-9' + re.escape('!&*<>|^$%@_-+~?/=') + ']+'
 
     def get_tokens_unprocessed(self, text):
         for index, token, value in RegexLexer.get_tokens_unprocessed(self, text):
@@ -1187,7 +1187,7 @@ class DylanLexer(RegexLexer):
             (r'//.*?\n', Comment.Single),
 
             # lid header
-            (r'([A-Za-z0-9-]+)(:)([ \t]*)(.*(?:\n[ \t].+)*)',
+            (r'([a-z0-9-]+)(:)([ \t]*)(.*(?:\n[ \t].+)*)',
                 bygroups(Name.Attribute, Operator, Text, String)),
 
             ('', Text, 'code') # no header match, switch to code
@@ -1204,7 +1204,7 @@ class DylanLexer(RegexLexer):
 
             # strings and characters
             (r'"', String, 'string'),
-            (r"'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'", String.Char),
+            (r"'(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\\'\n])'", String.Char),
 
             # binary integer
             (r'#[bB][01]+', Number),
@@ -1219,7 +1219,7 @@ class DylanLexer(RegexLexer):
             (r'[-+]?\d+', Number.Integer),
 
             # hex integer
-            (r'#[xX][0-9a-fA-F]+', Number.Hex),
+            (r'#[xX][0-9a-f]+', Number.Hex),
 
             # Macro parameters
             (r'(\?' + valid_name + ')(:)'
@@ -1243,7 +1243,7 @@ class DylanLexer(RegexLexer):
             (r'#"', String.Symbol, 'keyword'),
 
             # #rest, #key, #all-keys, etc.
-            (r'#[a-zA-Z0-9-]+', Keyword),
+            (r'#[a-z0-9-]+', Keyword),
 
             # required-init-keyword: style keywords.
             (valid_name + ':', Keyword),
@@ -1272,7 +1272,7 @@ class DylanLexer(RegexLexer):
         ],
         'string': [
             (r'"', String, '#pop'),
-            (r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})', String.Escape),
+            (r'\\([\\abfnrtv"\']|x[a-f0-9]{2,4}|[0-7]{1,3})', String.Escape),
             (r'[^\\"\n]+', String), # all other characters
             (r'\\\n', String), # line continuation
             (r'\\', String), # stray backslash
@@ -3004,7 +3004,7 @@ class NimrodLexer(RegexLexer):
             # Numbers
             (r'[0-9][0-9_]*(?=([eE.]|\'[fF](32|64)))',
               Number.Float, ('float-suffix', 'float-number')),
-            (r'0[xX][a-fA-F0-9][a-fA-F0-9_]*', Number.Hex, 'int-suffix'),
+            (r'0[xX][a-f0-9][a-f0-9_]*', Number.Hex, 'int-suffix'),
             (r'0[bB][01][01_]*', Number, 'int-suffix'),
             (r'0o[0-7][0-7_]*', Number.Oct, 'int-suffix'),
             (r'[0-9][0-9_]*', Number.Integer, 'int-suffix'),
@@ -3013,7 +3013,7 @@ class NimrodLexer(RegexLexer):
             (r'.+$', Error),
         ],
         'chars': [
-          (r'\\([\\abcefnrtvl"\']|x[a-fA-F0-9]{2}|[0-9]{1,3})', String.Escape),
+          (r'\\([\\abcefnrtvl"\']|x[a-f0-9]{2}|[0-9]{1,3})', String.Escape),
           (r"'", String.Char, '#pop'),
           (r".", String.Char)
         ],
@@ -3027,7 +3027,7 @@ class NimrodLexer(RegexLexer):
             # newlines are an error (use "nl" state)
         ],
         'dqs': [
-            (r'\\([\\abcefnrtvl"\']|\n|x[a-fA-F0-9]{2}|[0-9]{1,3})',
+            (r'\\([\\abcefnrtvl"\']|\n|x[a-f0-9]{2}|[0-9]{1,3})',
              String.Escape),
             (r'"', String, '#pop'),
             include('strings')
diff --git a/pygments/lexers/dotnet.py b/pygments/lexers/dotnet.py
index bfb42f97..181c1542 100644
--- a/pygments/lexers/dotnet.py
+++ b/pygments/lexers/dotnet.py
@@ -425,7 +425,7 @@ class VbNetLexer(RegexLexer):
              r'<=|>=|<>|[-&*/\\^+=<>]',
              Operator),
             ('"', String, 'string'),
-            ('[a-zA-Z_]\w*[%&@!#$]?', Name),
+            ('[a-z_]\w*[%&@!#$]?', Name),
             ('#.*?#', Literal.Date),
             (r'(\d+\.\d*|\d*\.\d+)([fF][+-]?[0-9]+)?', Number.Float),
             (r'\d+([SILDFR]|US|UI|UL)?', Number.Integer),
diff --git a/pygments/lexers/functional.py b/pygments/lexers/functional.py
index 497f024d..5f19f253 100644
--- a/pygments/lexers/functional.py
+++ b/pygments/lexers/functional.py
@@ -850,10 +850,10 @@ class CommonLispLexer(RegexLexer):
             (r'#[oO][+-]?[0-7]+(/[0-7]+)?', Number.Oct),
 
             # hex rational
-            (r'#[xX][+-]?[0-9a-fA-F]+(/[0-9a-fA-F]+)?', Number.Hex),
+            (r'#[xX][+-]?[0-9a-f]+(/[0-9a-f]+)?', Number.Hex),
 
             # radix rational
-            (r'#\d+[rR][+-]?[0-9a-zA-Z]+(/[0-9a-zA-Z]+)?', Number),
+            (r'#\d+[rR][+-]?[0-9a-z]+(/[0-9a-z]+)?', Number),
 
             # complex
             (r'(#[cC])(\()', bygroups(Number, Punctuation), 'body'),
diff --git a/pygments/lexers/hdl.py b/pygments/lexers/hdl.py
index 55eec252..6240cfe0 100644
--- a/pygments/lexers/hdl.py
+++ b/pygments/lexers/hdl.py
@@ -290,19 +290,19 @@ class VhdlLexer(RegexLexer):
             (r'--(?![!#$%&*+./<=>?@\^|_~]).*?$', Comment.Single),
             (r"'(U|X|0|1|Z|W|L|H|-)'", String.Char),
             (r'[~!%^&*+=|?:<>/-]', Operator),
-            (r"'[a-zA-Z_]\w*", Name.Attribute),
+            (r"'[a-z_]\w*", Name.Attribute),
             (r'[()\[\],.;\']', Punctuation),
             (r'"[^\n\\]*"', String),
 
-            (r'(library)(\s+)([a-zA-Z_]\w*)',
+            (r'(library)(\s+)([a-z_]\w*)',
              bygroups(Keyword, Text, Name.Namespace)),
             (r'(use)(\s+)(entity)', bygroups(Keyword, Text, Keyword)),
-            (r'(use)(\s+)([a-zA-Z_][\.\w]*)',
+            (r'(use)(\s+)([a-z_][\.\w]*)',
              bygroups(Keyword, Text, Name.Namespace)),
-            (r'(entity|component)(\s+)([a-zA-Z_]\w*)',
+            (r'(entity|component)(\s+)([a-z_]\w*)',
              bygroups(Keyword, Text, Name.Class)),
-            (r'(architecture|configuration)(\s+)([a-zA-Z_]\w*)(\s+)'
-             r'(of)(\s+)([a-zA-Z_]\w*)(\s+)(is)',
+            (r'(architecture|configuration)(\s+)([a-z_]\w*)(\s+)'
+             r'(of)(\s+)([a-z_]\w*)(\s+)(is)',
              bygroups(Keyword, Text, Name.Class, Text, Keyword, Text,
                       Name.Class, Text, Keyword)),
 
@@ -312,11 +312,11 @@ class VhdlLexer(RegexLexer):
             include('keywords'),
             include('numbers'),
 
-            (r'[a-zA-Z_]\w*', Name),
+            (r'[a-z_]\w*', Name),
         ],
         'endblock': [
             include('keywords'),
-            (r'[a-zA-Z_]\w*', Name.Class),
+            (r'[a-z_]\w*', Name.Class),
             (r'(\s+)', Text),
             (r';', Punctuation, '#pop'),
         ],
@@ -345,11 +345,11 @@ class VhdlLexer(RegexLexer):
              r'while|with|xnor|xor)\b', Keyword),
         ],
         'numbers': [
-            (r'\d{1,2}#[0-9a-fA-F_]+#?', Number.Integer),
+            (r'\d{1,2}#[0-9a-f_]+#?', Number.Integer),
             (r'[0-1_]+(\.[0-1_])', Number.Integer),
             (r'\d+', Number.Integer),
             (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+', Number.Float),
-            (r'H"[0-9a-fA-F_]+"', Number.Oct),
+            (r'H"[0-9a-f_]+"', Number.Oct),
             (r'O"[0-7_]+"', Number.Oct),
             (r'B"[0-1_]+"', Number.Oct),
         ],
diff --git a/pygments/lexers/math.py b/pygments/lexers/math.py
index cd98a755..de30a449 100644
--- a/pygments/lexers/math.py
+++ b/pygments/lexers/math.py
@@ -2182,7 +2182,7 @@ class IgorLexer(RegexLexer):
             # Compiler directives.
             (r'^#(include|pragma|define|ifdef|ifndef|endif)',
              Name.Decorator),
-            (r'[^a-zA-Z"/]+$', Text),
+            (r'[^a-z"/]+$', Text),
             (r'.', Text),
         ],
     }
diff --git a/pygments/lexers/other.py b/pygments/lexers/other.py
index b7672fda..23580d68 100644
--- a/pygments/lexers/other.py
+++ b/pygments/lexers/other.py
@@ -156,15 +156,15 @@ class ECLLexer(RegexLexer):
             include('hash'),
             (r'"', String, 'string'),
             (r'\'', String, 'string'),
-            (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*', Number.Float),
+            (r'(\d+\.\d*|\.\d+|\d+)e[+-]?\d+[lu]*', Number.Float),
             (r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float),
-            (r'0x[0-9a-fA-F]+[LlUu]*', Number.Hex),
-            (r'0[0-7]+[LlUu]*', Number.Oct),
+            (r'0x[0-9a-f]+[lu]*', Number.Hex),
+            (r'0[0-7]+[lu]*', Number.Oct),
             (r'\d+[LlUu]*', Number.Integer),
             (r'\*/', Error),
             (r'[~!%^&*+=|?:<>/-]+', Operator),
             (r'[{}()\[\],.;]', Punctuation),
-            (r'[a-zA-Z_]\w*', Name),
+            (r'[a-z_]\w*', Name),
         ],
         'hash': [
             (r'^#.*$', Comment.Preproc),
@@ -1306,9 +1306,9 @@ class ModelicaLexer(RegexLexer):
             (r'\d+[Ll]?', Number.Integer),
             (r'[~!%^&*+=|?:<>/-]', Operator),
             (r'(true|false|NULL|Real|Integer|Boolean)\b', Name.Builtin),
-            (r'([a-zA-Z_][\w]*|\'[^\']+\')'
+            (r'([a-z_][\w]*|\'[^\']+\')'
              r'([\[\d,:\]]*)'
-             r'(\.([a-zA-Z_][\w]*|\'[^\']+\'))+'
+             r'(\.([a-z_][\w]*|\'[^\']+\'))+'
              r'([\[\d,:\]]*)', Name.Class),
             (r'(\'[\w\+\-\*\/\^]+\'|\w+)', Name),
             (r'[()\[\]{},.;]', Punctuation),
@@ -1350,7 +1350,7 @@ class ModelicaLexer(RegexLexer):
         'classes': [
             (r'(operator)?(\s+)?(block|class|connector|end|function|model|'
              r'operator|package|record|type)(\s+)'
-             r'((?!if|for|when|while)[A-Za-z_]\w*|\'[^\']+\')([;]?)',
+             r'((?!if|for|when|while)[a-z_]\w*|\'[^\']+\')([;]?)',
              bygroups(Keyword, Text, Keyword, Text, Name.Class, Text))
         ],
         'quoted_ident': [
@@ -1359,7 +1359,7 @@ class ModelicaLexer(RegexLexer):
         ],
         'string': [
             (r'"', String, '#pop'),
-            (r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})',
+            (r'\\([\\abfnrtv"\']|x[a-f0-9]{2,4}|[0-7]{1,3})',
              String.Escape),
             (r'[^\\"\n]+', String), # all other characters
             (r'\\\n', String), # line continuation
@@ -1387,7 +1387,7 @@ class RebolLexer(RegexLexer):
 
     re.IGNORECASE
 
-    escape_re = r'(?:\^\([0-9a-fA-F]{1,4}\)*)'
+    escape_re = r'(?:\^\([0-9a-f]{1,4}\)*)'
 
     def word_callback(lexer, match):
         word = match.group()
@@ -1483,9 +1483,9 @@ class RebolLexer(RegexLexer):
         'script': [
             (r'\s+', Text),
             (r'#"', String.Char, 'char'),
-            (r'#{[0-9a-fA-F]*}', Number.Hex),
+            (r'#{[0-9a-f]*}', Number.Hex),
             (r'2#{', Number.Hex, 'bin2'),
-            (r'64#{[0-9a-zA-Z+/=\s]*}', Number.Hex),
+            (r'64#{[0-9a-z+/=\s]*}', Number.Hex),
             (r'"', String, 'string'),
             (r'{', String, 'string2'),
             (r';#+.*\n', Comment.Special),
@@ -1493,9 +1493,9 @@ class RebolLexer(RegexLexer):
             (r';.*\n', Comment),
             (r'%"', Name.Decorator, 'stringFile'),
             (r'%[^(\^{^")\s\[\]]+', Name.Decorator),
-            (r'[+-]?([a-zA-Z]{1,3})?\$\d+(\.\d+)?', Number.Float), # money
+            (r'[+-]?([a-z]{1,3})?\$\d+(\.\d+)?', Number.Float), # money
             (r'[+-]?\d+\:\d+(\:\d+)?(\.\d+)?', String.Other), # time
-            (r'\d+[\-\/][0-9a-zA-Z]+[\-\/]\d+(\/\d+\:\d+((\:\d+)?'
+            (r'\d+[\-\/][0-9a-z]+[\-\/]\d+(\/\d+\:\d+((\:\d+)?'
              r'([\.\d+]?([+-]?\d+:\d+)?)?)?)?', String.Other), # date
             (r'\d+(\.\d+)+\.\d+', Keyword.Constant), # tuple
             (r'\d+[xX]\d+', Keyword.Constant), # pair
@@ -1503,7 +1503,7 @@ class RebolLexer(RegexLexer):
             (r'[+-]?\d+(\'\d+)?[\.,]\d*', Number.Float),
             (r'[+-]?\d+(\'\d+)?', Number),
             (r'[\[\]\(\)]', Generic.Strong),
-            (r'[a-zA-Z]+[^(\^{"\s:)]*://[^(\^{"\s)]*', Name.Decorator), # url
+            (r'[a-z]+[^(\^{"\s:)]*://[^(\^{"\s)]*', Name.Decorator), # url
             (r'mailto:[^(\^{"@\s)]+@[^(\^{"@\s)]+', Name.Decorator), # url
             (r'[^(\^{"@\s)]+@[^(\^{"@\s)]+', Name.Decorator), # email
             (r'comment\s"', Comment, 'commentString1'),
@@ -1512,7 +1512,7 @@ class RebolLexer(RegexLexer):
             (r'comment\s[^(\s{\"\[]+', Comment),
             (r'/[^(\^{^")\s/[\]]*', Name.Attribute),
             (r'([^(\^{^")\s/[\]]+)(?=[:({"\s/\[\]])', word_callback),
-            (r'<[a-zA-Z0-9:._-]*>', Name.Tag),
+            (r'<[\w:.-]*>', Name.Tag),
             (r'<[^(<>\s")]+', Name.Tag, 'tag'),
             (r'([^(\^{^")\s]+)', Text),
         ],
@@ -2393,7 +2393,7 @@ class MaqlLexer(RegexLexer):
              r'SYNCHRONIZE|TYPE|DEFAULT|ORDER|ASC|DESC|HYPERLINK|'
              r'INCLUDE|TEMPLATE|MODIFY)\b', Keyword),
             # FUNCNAME
-            (r'[a-zA-Z]\w*\b', Name.Function),
+            (r'[a-z]\w*\b', Name.Function),
             # Comments
             (r'#.*', Comment.Single),
             # Punctuation
@@ -2428,7 +2428,7 @@ class GoodDataCLLexer(RegexLexer):
             # Comments
             (r'#.*', Comment.Single),
             # Function call
-            (r'[a-zA-Z]\w*', Name.Function),
+            (r'[a-z]\w*', Name.Function),
             # Argument list
             (r'\(', Token.Punctuation, 'args-list'),
             # Punctuation
@@ -2439,7 +2439,7 @@ class GoodDataCLLexer(RegexLexer):
         'args-list': [
             (r'\)', Token.Punctuation, '#pop'),
             (r',', Token.Punctuation),
-            (r'[a-zA-Z]\w*', Name.Variable),
+            (r'[a-z]\w*', Name.Variable),
             (r'=', Operator),
             (r'"', Literal.String, 'string-literal'),
             (r'[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]{1,3})?', Literal.Number),
@@ -4255,7 +4255,7 @@ class RedLexer(RegexLexer):
 
     flags = re.IGNORECASE | re.MULTILINE
 
-    escape_re = r'(?:\^\([0-9a-fA-F]{1,4}\)*)'
+    escape_re = r'(?:\^\([0-9a-f]{1,4}\)*)'
 
     def word_callback(lexer, match):
         word = match.group()
@@ -4326,10 +4326,10 @@ class RedLexer(RegexLexer):
         'script': [
             (r'\s+', Text),
             (r'#"', String.Char, 'char'),
-            (r'#{[0-9a-fA-F\s]*}', Number.Hex),
+            (r'#{[0-9a-f\s]*}', Number.Hex),
             (r'2#{', Number.Hex, 'bin2'),
-            (r'64#{[0-9a-zA-Z+/=\s]*}', Number.Hex),
-            (r'([0-9a-fA-F]+)(h)((\s)|(?=[\[\]{}""\(\)]))',
+            (r'64#{[0-9a-z+/=\s]*}', Number.Hex),
+            (r'([0-9a-f]+)(h)((\s)|(?=[\[\]{}""\(\)]))',
              bygroups(Number.Hex, Name.Variable, Whitespace)),
             (r'"', String, 'string'),
             (r'{', String, 'string2'),
@@ -4338,9 +4338,9 @@ class RedLexer(RegexLexer):
             (r';.*\n', Comment),
             (r'%"', Name.Decorator, 'stringFile'),
             (r'%[^(\^{^")\s\[\]]+', Name.Decorator),
-            (r'[+-]?([a-zA-Z]{1,3})?\$\d+(\.\d+)?', Number.Float), # money
+            (r'[+-]?([a-z]{1,3})?\$\d+(\.\d+)?', Number.Float), # money
             (r'[+-]?\d+\:\d+(\:\d+)?(\.\d+)?', String.Other), # time
-            (r'\d+[\-\/][0-9a-zA-Z]+[\-\/]\d+(\/\d+\:\d+((\:\d+)?'
+            (r'\d+[\-\/][0-9a-z]+[\-\/]\d+(\/\d+\:\d+((\:\d+)?'
              r'([\.\d+]?([+-]?\d+:\d+)?)?)?)?', String.Other), # date
             (r'\d+(\.\d+)+\.\d+', Keyword.Constant), # tuple
             (r'\d+[xX]\d+', Keyword.Constant), # pair
@@ -4348,7 +4348,7 @@ class RedLexer(RegexLexer):
             (r'[+-]?\d+(\'\d+)?[\.,]\d*', Number.Float),
             (r'[+-]?\d+(\'\d+)?', Number),
             (r'[\[\]\(\)]', Generic.Strong),
-            (r'[a-zA-Z]+[^(\^{"\s:)]*://[^(\^{"\s)]*', Name.Decorator), # url
+            (r'[a-z]+[^(\^{"\s:)]*://[^(\^{"\s)]*', Name.Decorator), # url
             (r'mailto:[^(\^{"@\s)]+@[^(\^{"@\s)]+', Name.Decorator), # url
             (r'[^(\^{"@\s)]+@[^(\^{"@\s)]+', Name.Decorator), # email
             (r'comment\s"', Comment, 'commentString1'),
diff --git a/pygments/lexers/sql.py b/pygments/lexers/sql.py
index 53df0f75..d20c15fd 100644
--- a/pygments/lexers/sql.py
+++ b/pygments/lexers/sql.py
@@ -150,10 +150,10 @@ class PostgresLexer(PostgresBase, RegexLexer):
             (r"(E|U&)?'(''|[^'])*'", String.Single),
             (r'(U&)?"(""|[^"])*"', String.Name), # quoted identifier
             (r'(?s)(\$[^\$]*\$)(.*?)(\1)', language_callback),
-            (r'[a-zA-Z_]\w*', Name),
+            (r'[a-z_]\w*', Name),
 
             # psql variable in SQL
-            (r""":(['"]?)[a-z][a-z0-9_]*\b\1""", Name.Variable),
+            (r""":(['"]?)[a-z]\w*\b\1""", Name.Variable),
 
             (r'[;:()\[\]\{\},\.]', Punctuation),
         ],
@@ -435,7 +435,7 @@ class SqlLexer(RegexLexer):
             # TODO: Backslash escapes?
             (r"'(''|[^'])*'", String.Single),
             (r'"(""|[^"])*"', String.Symbol), # not a real string literal in ANSI SQL
-            (r'[a-zA-Z_]\w*', Name),
+            (r'[a-z_]\w*', Name),
             (r'[;:()\[\],\.]', Punctuation)
         ],
         'multiline-comments': [
@@ -506,10 +506,10 @@ class MySqlLexer(RegexLexer):
             # TODO: this list is not complete
             (r'\b(auto_increment|engine|charset|tables)\b', Keyword.Pseudo),
             (r'(true|false|null)', Name.Constant),
-            (r'([a-zA-Z_]\w*)(\s*)(\()',
+            (r'([a-z_]\w*)(\s*)(\()',
              bygroups(Name.Function, Text, Punctuation)),
-            (r'[a-zA-Z_]\w*', Name),
-            (r'@[A-Za-z0-9]*[._]*[A-Za-z0-9]*', Name.Variable),
+            (r'[a-z_]\w*', Name),
+            (r'@[a-z0-9]*[._]*[a-z0-9]*', Name.Variable),
             (r'[;:()\[\],\.]', Punctuation)
         ],
         'multiline-comments': [
diff --git a/pygments/lexers/templates.py b/pygments/lexers/templates.py
index 25f53585..4d53dca6 100644
--- a/pygments/lexers/templates.py
+++ b/pygments/lexers/templates.py
@@ -1504,9 +1504,9 @@ class ColdfusionLexer(RegexLexer):
             (r'(true|false|null)\b', Keyword.Constant),
             (r'(application|session|client|cookie|super|this|variables|arguments)\b',
              Name.Constant),
-            (r'([A-Za-z_$][\w.]*)(\s*)(\()',
+            (r'([a-z_$][\w.]*)(\s*)(\()',
              bygroups(Name.Function, Text, Punctuation)),
-            (r'[A-Za-z_$][\w.]*', Name.Variable),
+            (r'[a-z_$][\w.]*', Name.Variable),
             (r'[()\[\]{};:,.\\]', Punctuation),
             (r'\s+', Text),
         ],
diff --git a/pygments/lexers/text.py b/pygments/lexers/text.py
index 82c49239..10675654 100644
--- a/pygments/lexers/text.py
+++ b/pygments/lexers/text.py
@@ -589,7 +589,7 @@ class ApacheConfLexer(RegexLexer):
             (r'(#.*?)$', Comment),
             (r'(<[^\s>]+)(?:(\s+)(.*?))?(>)',
              bygroups(Name.Tag, Text, String, Name.Tag)),
-            (r'([a-zA-Z]\w*)(\s+)',
+            (r'([a-z]\w*)(\s+)',
              bygroups(Name.Builtin, Text), 'value'),
             (r'\.+', Text),
         ],
@@ -598,7 +598,7 @@ class ApacheConfLexer(RegexLexer):
             (r'[^\S\n]+', Text),
             (r'\d+\.\d+\.\d+\.\d+(?:/\d+)?', Number),
             (r'\d+', Number),
-            (r'/([a-zA-Z0-9][\w./-]+)', String.Other),
+            (r'/([a-z0-9][\w./-]+)', String.Other),
             (r'(on|off|none|any|all|double|email|dns|min|minimal|'
              r'os|productonly|full|emerg|alert|crit|error|warn|'
              r'notice|info|debug|registry|script|inetd|standalone|'
diff --git a/pygments/lexers/web.py b/pygments/lexers/web.py
index 7fff75dd..0282499e 100644
--- a/pygments/lexers/web.py
+++ b/pygments/lexers/web.py
@@ -802,7 +802,7 @@ class PhpLexer(RegexLexer):
     # Note that a backslash is included in the following two patterns
     # PHP uses a backslash as a namespace separator
     _ident_char = r'[\\\w]|[^\x00-\x7f]'
-    _ident_begin = r'(?:[\\_a-zA-Z]|[^\x00-\x7f])'
+    _ident_begin = r'(?:[\\_a-z]|[^\x00-\x7f])'
     _ident_end = r'(?:' + _ident_char + ')*'
     _ident_inner = _ident_begin + _ident_end
 
@@ -852,7 +852,7 @@ class PhpLexer(RegexLexer):
             (r'(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?', Number.Float),
             (r'\d+[eE][+-]?[0-9]+', Number.Float),
             (r'0[0-7]+', Number.Oct),
-            (r'0[xX][a-fA-F0-9]+', Number.Hex),
+            (r'0[xX][a-f0-9]+', Number.Hex),
             (r'\d+', Number.Integer),
             (r'0b[01]+', Number.Binary),
             (r"'([^'\\]*(?:\\.[^'\\]*)*)'", String.Single),
@@ -868,7 +868,7 @@ class PhpLexer(RegexLexer):
         'string': [
             (r'"', String.Double, '#pop'),
             (r'[^{$"\\]+', String.Double),
-            (r'\\([nrt\"$\\]|[0-7]{1,3}|x[0-9A-Fa-f]{1,2})', String.Escape),
+            (r'\\([nrt\"$\\]|[0-7]{1,3}|x[0-9a-f]{1,2})', String.Escape),
             (r'\$' + _ident_inner + '(\[\S+?\]|->' + _ident_inner + ')?',
              String.Interpol),
             (r'(\{\$\{)(.*?)(\}\})',