Replace a-z0-9_ with \w when IGNORECASE is set

7 files changed, 44 insertions, 44 deletions

diff --git a/pygments/lexers/compiled.py b/pygments/lexers/compiled.py
index 54edf9dc..ec3015a5 100644
--- a/pygments/lexers/compiled.py
+++ b/pygments/lexers/compiled.py
@@ -1573,7 +1573,7 @@ class FortranLexer(RegexLexer):
             (r'!.*\n', Comment),
             include('strings'),
             include('core'),
-            (r'[a-z][a-z0-9_]*', Name.Variable),
+            (r'[a-z]\w*', Name.Variable),
             include('nums'),
             (r'[\s]+', Text),
         ],
@@ -1657,9 +1657,9 @@ class FortranLexer(RegexLexer):
         ],
 
         'nums': [
-            (r'\d+(?![.Ee])(_[a-z][a-z0-9_]+)?', Number.Integer),
-            (r'[+-]?\d*\.\d+([eE][-+]?\d+)?(_[a-z][a-z0-9_]+)?', Number.Float),
-            (r'[+-]?\d+\.\d*([eE][-+]?\d+)?(_[a-z][a-z0-9_]+)?', Number.Float),
+            (r'\d+(?![.e])(_[a-z]\w+)?', Number.Integer),
+            (r'[+-]?\d*\.\d+(e[-+]?\d+)?(_[a-z]\w+)?', Number.Float),
+            (r'[+-]?\d+\.\d*(e[-+]?\d+)?(_[a-z]\w+)?', Number.Float),
         ],
     }
 
@@ -2764,7 +2764,7 @@ class BlitzMaxLexer(RegexLexer):
     bmax_vopwords = r'\b(Shl|Shr|Sar|Mod)\b'
     bmax_sktypes = r'@{1,2}|[!#$%]'
     bmax_lktypes = r'\b(Int|Byte|Short|Float|Double|Long)\b'
-    bmax_name = r'[a-z_][a-z0-9_]*'
+    bmax_name = r'[a-z_]\w*'
     bmax_var = (r'(%s)(?:(?:([ \t]*)(%s)|([ \t]*:[ \t]*\b(?:Shl|Shr|Sar|Mod)\b)'
                 r'|([ \t]*)(:)([ \t]*)(?:%s|(%s)))(?:([ \t]*)(Ptr))?)') % \
                 (bmax_name, bmax_sktypes, bmax_lktypes, bmax_name)
@@ -2859,7 +2859,7 @@ class BlitzBasicLexer(RegexLexer):
                    r'Abs|Sgn|Handle|Int|Float|Str|'
                    r'First|Last|Before|After)\b')
     bb_sktypes = r'@{1,2}|[#$%]'
-    bb_name = r'[a-z][a-z0-9_]*'
+    bb_name = r'[a-z]\w*'
     bb_var = (r'(%s)(?:([ \t]*)(%s)|([ \t]*)([.])([ \t]*)(?:(%s)))?') % \
                 (bb_name, bb_sktypes, bb_name)
 
diff --git a/pygments/lexers/dotnet.py b/pygments/lexers/dotnet.py
index 181c1542..5a07cd0d 100644
--- a/pygments/lexers/dotnet.py
+++ b/pygments/lexers/dotnet.py
@@ -439,17 +439,17 @@ class VbNetLexer(RegexLexer):
             (r'[^"]+', String),
         ],
         'dim': [
-            (r'[a-z_][a-z0-9_]*', Name.Variable, '#pop'),
+            (r'[a-z_]\w*', Name.Variable, '#pop'),
             (r'', Text, '#pop'),  # any other syntax
         ],
         'funcname': [
-            (r'[a-z_][a-z0-9_]*', Name.Function, '#pop'),
+            (r'[a-z_]\w*', Name.Function, '#pop'),
         ],
         'classname': [
-            (r'[a-z_][a-z0-9_]*', Name.Class, '#pop'),
+            (r'[a-z_]\w*', Name.Class, '#pop'),
         ],
         'namespace': [
-            (r'[a-z_][a-z0-9_.]*', Name.Namespace, '#pop'),
+            (r'[a-z_][\w.]*', Name.Namespace, '#pop'),
         ],
         'end': [
             (r'\s+', Text),
diff --git a/pygments/lexers/jvm.py b/pygments/lexers/jvm.py
index 24ff79ca..8a0b7ed9 100644
--- a/pygments/lexers/jvm.py
+++ b/pygments/lexers/jvm.py
@@ -1112,7 +1112,7 @@ class PigLexer(RegexLexer):
             (r'0x[0-9a-f]+', Number.Hex),
             (r'[0-9]+L?', Number.Integer),
             (r'\n', Text),
-            (r'([a-z_][a-z0-9_]*)(\s*)(\()',
+            (r'([a-z_]\w*)(\s*)(\()',
              bygroups(Name.Function, Text, Punctuation)),
             (r'[()#:]', Text),
             (r'[^(:#\'\")\s]+', Text),
diff --git a/pygments/lexers/other.py b/pygments/lexers/other.py
index 23580d68..42d02301 100644
--- a/pygments/lexers/other.py
+++ b/pygments/lexers/other.py
@@ -3202,9 +3202,9 @@ class VGLLexer(RegexLexer):
             (r'(true|false|null|empty|error|locked)', Keyword.Constant),
             (r'[~\^\*\#!%&\[\]\(\)<>\|+=:;,./?-]', Operator),
             (r'"[^"]*"', String),
-            (r'(\.)([a-z_\$][a-z0-9_\$]*)', bygroups(Operator, Name.Attribute)),
+            (r'(\.)([a-z_\$][\w\$]*)', bygroups(Operator, Name.Attribute)),
             (r'[0-9][0-9]*(\.[0-9]+(e[+\-]?[0-9]+)?)?', Number),
-            (r'[a-z_\$][a-z0-9_\$]*', Name),
+            (r'[a-z_\$][\w\$]*', Name),
             (r'[\r\n]+', Text),
             (r'\s+', Text)
         ]
@@ -3800,15 +3800,15 @@ class RexxLexer(RegexLexer):
             (r'"', String, 'string_double'),
             (r"'", String, 'string_single'),
             (r'[0-9]+(\.[0-9]+)?(e[+-]?[0-9])?', Number),
-            (r'([a-z_][a-z0-9_]*)(\s*)(:)(\s*)(procedure)\b',
+            (r'([a-z_]\w*)(\s*)(:)(\s*)(procedure)\b',
              bygroups(Name.Function, Whitespace, Operator, Whitespace,
                       Keyword.Declaration)),
-            (r'([a-z_][a-z0-9_]*)(\s*)(:)',
+            (r'([a-z_]\w*)(\s*)(:)',
              bygroups(Name.Label, Whitespace, Operator)),
             include('function'),
             include('keyword'),
             include('operator'),
-            (r'[a-z_][a-z0-9_]*', Text),
+            (r'[a-z_]\w*', Text),
         ],
         'function': [
             (r'(abbrev|abs|address|arg|b2x|bitand|bitor|bitxor|c2d|c2x|'
@@ -3856,7 +3856,7 @@ class RexxLexer(RegexLexer):
     _ADDRESS_PATTERN = _c(r'^\s*address\s+')
     _DO_WHILE_PATTERN = _c(r'^\s*do\s+while\b')
     _IF_THEN_DO_PATTERN = _c(r'^\s*if\b.+\bthen\s+do\s*$')
-    _PROCEDURE_PATTERN = _c(r'^\s*([a-z_][a-z0-9_]*)(\s*)(:)(\s*)(procedure)\b')
+    _PROCEDURE_PATTERN = _c(r'^\s*([a-z_]\w*)(\s*)(:)(\s*)(procedure)\b')
     _ELSE_DO_PATTERN = _c(r'\belse\s+do\s*$')
     _PARSE_ARG_PATTERN = _c(r'^\s*parse\s+(upper\s+)?(arg|value)\b')
     PATTERNS_AND_WEIGHTS = (
diff --git a/pygments/lexers/shell.py b/pygments/lexers/shell.py
index 13201912..df9b56f4 100644
--- a/pygments/lexers/shell.py
+++ b/pygments/lexers/shell.py
@@ -390,13 +390,13 @@ class PowerShellLexer(RegexLexer):
             (r'`[\'"$@-]', Punctuation),
             (r'"', String.Double, 'string'),
             (r"'([^']|'')*'", String.Single),
-            (r'(\$|@@|@)((global|script|private|env):)?[a-z0-9_]+',
+            (r'(\$|@@|@)((global|script|private|env):)?\w+',
              Name.Variable),
             (r'(%s)\b' % '|'.join(keywords), Keyword),
             (r'-(%s)\b' % '|'.join(operators), Operator),
-            (r'(%s)-[a-z_][a-z0-9_]*\b' % '|'.join(verbs), Name.Builtin),
-            (r'\[[a-z_\[][a-z0-9_. `,\[\]]*\]', Name.Constant),  # .net [type]s
-            (r'-[a-z_][a-z0-9_]*', Name),
+            (r'(%s)-[a-z_]\w*\b' % '|'.join(verbs), Name.Builtin),
+            (r'\[[a-z_\[][\w. `,\[\]]*\]', Name.Constant),  # .net [type]s
+            (r'-[a-z_]\w*', Name),
             (r'\w+', Name),
             (r'[.,;@{}\[\]$()=+*/\\&%!~?^`|<>-]|::', Punctuation),
         ],
diff --git a/pygments/lexers/sql.py b/pygments/lexers/sql.py
index d20c15fd..7540f079 100644
--- a/pygments/lexers/sql.py
+++ b/pygments/lexers/sql.py
@@ -192,10 +192,10 @@ class PlPgsqlLexer(PostgresBase, RegexLexer):
 
     # Add specific PL/pgSQL rules (before the SQL ones)
     tokens['root'][:0] = [
-        (r'\%[a-z][a-z0-9_]*\b', Name.Builtin),     # actually, a datatype
+        (r'\%[a-z]\w*\b', Name.Builtin),     # actually, a datatype
         (r':=', Operator),
-        (r'\<\<[a-z][a-z0-9_]*\>\>', Name.Label),
-        (r'\#[a-z][a-z0-9_]*\b', Keyword.Pseudo),   # #variable_conflict
+        (r'\<\<[a-z]\w*\>\>', Name.Label),
+        (r'\#[a-z]\w*\b', Keyword.Pseudo),   # #variable_conflict
     ]
 
 
@@ -219,7 +219,7 @@ class PsqlRegexLexer(PostgresBase, RegexLexer):
         (r'\n', Text, 'root'),
         (r'\s+', Text),
         (r'\\[^\s]+', Keyword.Pseudo),
-        (r""":(['"]?)[a-z][a-z0-9_]*\b\1""", Name.Variable),
+        (r""":(['"]?)[a-z]\w*\b\1""", Name.Variable),
         (r"'(''|[^'])*'", String.Single),
         (r"`([^`])*`", String.Backtick),
         (r"[^\s]+", String.Symbol),
@@ -584,7 +584,7 @@ class RqlLexer(RegexLexer):
             (r'[+*/<>=%-]', Operator),
             (r'(Any|is|instance_of|CWEType|CWRelation)\b', Name.Builtin),
             (r'[0-9]+', Number.Integer),
-            (r'[A-Z_][A-Z0-9_]*\??', Name),
+            (r'[A-Z_]\w*\??', Name),
             (r"'(''|[^'])*'", String.Single),
             (r'"(""|[^"])*"', String.Single),
             (r'[;:()\[\],\.]', Punctuation)
diff --git a/pygments/lexers/web.py b/pygments/lexers/web.py
index 0282499e..5260b9f5 100644
--- a/pygments/lexers/web.py
+++ b/pygments/lexers/web.py
@@ -2344,7 +2344,7 @@ class SassLexer(ExtendedRegexLexer):
             (r'(@mixin)( [\w-]+)', bygroups(Keyword, Name.Function), 'value'),
             (r'(@include)( [\w-]+)', bygroups(Keyword, Name.Decorator), 'value'),
             (r'@extend', Keyword, 'selector'),
-            (r'@[a-z0-9_-]+', Keyword, 'selector'),
+            (r'@[\w-]+', Keyword, 'selector'),
             (r'=[\w-]+', Name.Function, 'value'),
             (r'\+[\w-]+', Name.Decorator, 'value'),
             (r'([!$][\w-]\w*)([ \t]*(?:(?:\|\|)?=|:))',
@@ -2417,7 +2417,7 @@ class ScssLexer(RegexLexer):
             (r'(@mixin)( [\w-]+)', bygroups(Keyword, Name.Function), 'value'),
             (r'(@include)( [\w-]+)', bygroups(Keyword, Name.Decorator), 'value'),
             (r'@extend', Keyword, 'selector'),
-            (r'@[a-z0-9_-]+', Keyword, 'selector'),
+            (r'@[\w-]+', Keyword, 'selector'),
             (r'(\$[\w-]*\w)([ \t]*:)', bygroups(Name.Variable, Operator), 'value'),
             (r'(?=[^;{}][;}])', Name.Attribute, 'attr'),
             (r'(?=[^;{}:]+:[^a-z])', Name.Attribute, 'attr'),
@@ -2837,8 +2837,8 @@ class ScamlLexer(ExtendedRegexLexer):
         ],
 
         'css': [
-            (r'\.[a-z0-9_:-]+', Name.Class, 'tag'),
-            (r'\#[a-z0-9_:-]+', Name.Function, 'tag'),
+            (r'\.[\w:-]+', Name.Class, 'tag'),
+            (r'\#[\w:-]+', Name.Function, 'tag'),
         ],
 
         'eval-or-plain': [
@@ -2851,7 +2851,7 @@ class ScamlLexer(ExtendedRegexLexer):
 
         'content': [
             include('css'),
-            (r'%[a-z0-9_:-]+', Name.Tag, 'tag'),
+            (r'%[\w:-]+', Name.Tag, 'tag'),
             (r'!!!' + _dot + r'*\n', Name.Namespace, '#pop'),
             (r'(/)(\[' + _dot + '*?\])(' + _dot + r'*\n)',
              bygroups(Comment, Comment.Special, Comment),
@@ -2890,16 +2890,16 @@ class ScamlLexer(ExtendedRegexLexer):
 
         'html-attributes': [
             (r'\s+', Text),
-            (r'[a-z0-9_:-]+[ \t]*=', Name.Attribute, 'html-attribute-value'),
-            (r'[a-z0-9_:-]+', Name.Attribute),
+            (r'[\w:-]+[ \t]*=', Name.Attribute, 'html-attribute-value'),
+            (r'[\w:-]+', Name.Attribute),
             (r'\)', Text, '#pop'),
         ],
 
         'html-attribute-value': [
             (r'[ \t]+', Text),
-            (r'[a-z0-9_]+', Name.Variable, '#pop'),
-            (r'@[a-z0-9_]+', Name.Variable.Instance, '#pop'),
-            (r'\$[a-z0-9_]+', Name.Variable.Global, '#pop'),
+            (r'\w+', Name.Variable, '#pop'),
+            (r'@\w+', Name.Variable.Instance, '#pop'),
+            (r'\$\w+', Name.Variable.Global, '#pop'),
             (r"'(\\\\|\\'|[^'\n])*'", String, '#pop'),
             (r'"(\\\\|\\"|[^"\n])*"', String, '#pop'),
         ],
@@ -2947,8 +2947,8 @@ class JadeLexer(ExtendedRegexLexer):
         ],
 
         'css': [
-            (r'\.[a-z0-9_:-]+', Name.Class, 'tag'),
-            (r'\#[a-z0-9_:-]+', Name.Function, 'tag'),
+            (r'\.[\w:-]+', Name.Class, 'tag'),
+            (r'\#[\w:-]+', Name.Function, 'tag'),
         ],
 
         'eval-or-plain': [
@@ -2976,7 +2976,7 @@ class JadeLexer(ExtendedRegexLexer):
              '#pop'),
             (r':' + _dot + r'*\n', _starts_block(Name.Decorator, 'filter-block'),
              '#pop'),
-            (r'[a-z0-9_:-]+', Name.Tag, 'tag'),
+            (r'[\w:-]+', Name.Tag, 'tag'),
             (r'\|', Text, 'eval-or-plain'),
         ],
 
@@ -2999,16 +2999,16 @@ class JadeLexer(ExtendedRegexLexer):
 
         'html-attributes': [
             (r'\s+', Text),
-            (r'[a-z0-9_:-]+[ \t]*=', Name.Attribute, 'html-attribute-value'),
-            (r'[a-z0-9_:-]+', Name.Attribute),
+            (r'[\w:-]+[ \t]*=', Name.Attribute, 'html-attribute-value'),
+            (r'[\w:-]+', Name.Attribute),
             (r'\)', Text, '#pop'),
         ],
 
         'html-attribute-value': [
             (r'[ \t]+', Text),
-            (r'[a-z0-9_]+', Name.Variable, '#pop'),
-            (r'@[a-z0-9_]+', Name.Variable.Instance, '#pop'),
-            (r'\$[a-z0-9_]+', Name.Variable.Global, '#pop'),
+            (r'\w+', Name.Variable, '#pop'),
+            (r'@\w+', Name.Variable.Instance, '#pop'),
+            (r'\$\w+', Name.Variable.Global, '#pop'),
             (r"'(\\\\|\\'|[^'\n])*'", String, '#pop'),
             (r'"(\\\\|\\"|[^"\n])*"', String, '#pop'),
         ],