Add token type Number.Bin

12 files changed, 65 insertions, 54 deletions

diff --git a/doc/docs/tokens.rst b/doc/docs/tokens.rst
index ffd87ab7..9193d5f4 100644
--- a/doc/docs/tokens.rst
+++ b/doc/docs/tokens.rst
@@ -253,6 +253,9 @@ Literals
 `Number`
     Token type for any number literal.
 
+`Number.Bin`
+    Token type for binary literals (e.g. ``0b101010``).
+
 `Number.Float`
     Token type for float literals (e.g. ``42.0``).
 
diff --git a/pygments/lexers/agile.py b/pygments/lexers/agile.py
index 0c2d02ac..576f44ed 100644
--- a/pygments/lexers/agile.py
+++ b/pygments/lexers/agile.py
@@ -1242,7 +1242,7 @@ class CrocLexer(RegexLexer):
              Number.Float),
             # IntegerLiteral
             # -- Binary
-            (r'0[bB][01][01_]*', Number),
+            (r'0[bB][01][01_]*', Number.Bin),
             # -- Hexadecimal
             (r'0[xX][0-9a-fA-F][0-9a-fA-F_]*', Number.Hex),
             # -- Decimal
@@ -1740,8 +1740,8 @@ class FactorLexer(RegexLexer):
             (r'[+-]?\d(?:[\d,]*\d)?(?:[eE][+-]?\d+)?\s', Number),
             (r'0x[a-fA-F\d](?:[a-fA-F\d,]*[a-fA-F\d])?(?:p\d([\d,]*\d)?)?\s', Number),
             (r'NAN:\s+[a-fA-F\d](?:[a-fA-F\d,]*[a-fA-F\d])?(?:p\d([\d,]*\d)?)?\s', Number),
-            (r'0b[01]+\s', Number),
-            (r'0o[0-7]+\s', Number),
+            (r'0b[01]+\s', Number.Bin),
+            (r'0o[0-7]+\s', Number.Oct),
             (r'(?:\d([\d,]*\d)?)?\+\d(?:[\d,]*\d)?/\d(?:[\d,]*\d)?\s', Number),
             (r'(?:\-\d([\d,]*\d)?)?\-\d(?:[\d,]*\d)?/\d(?:[\d,]*\d)?\s', Number),
 
diff --git a/pygments/lexers/asm.py b/pygments/lexers/asm.py
index 35092f52..f995264c 100644
--- a/pygments/lexers/asm.py
+++ b/pygments/lexers/asm.py
@@ -353,7 +353,7 @@ class NasmLexer(RegexLexer):
             (string, String),
             (hexn, Number.Hex),
             (octn, Number.Oct),
-            (binn, Number),
+            (binn, Number.Bin),
             (floatn, Number.Float),
             (decn, Number.Integer),
             include('punctuation'),
@@ -422,7 +422,8 @@ class Ca65Lexer(RegexLexer):
             (r'"[^"\n]*.', String),
             (r"'[^'\n]*.", String.Char),
             (r'\$[0-9a-f]+|[0-9a-f]+h\b', Number.Hex),
-            (r'\d+|%[01]+', Number.Integer),
+            (r'\d+', Number.Integer),
+            (r'%[01]+', Number.Bin),
             (r'[#,.:()=]', Punctuation),
             (r'[a-z_.@$][\w.@$]*', Name),
         ]
diff --git a/pygments/lexers/compiled.py b/pygments/lexers/compiled.py
index b0b95c62..77b11bf1 100644
--- a/pygments/lexers/compiled.py
+++ b/pygments/lexers/compiled.py
@@ -498,7 +498,7 @@ class DLexer(RegexLexer):
             (r'\.(0|[1-9][0-9_]*)([eE][+\-]?[0-9_]+)?[fFL]?[i]?', Number.Float),
             # IntegerLiteral
             # -- Binary
-            (r'0[Bb][01_]+', Number),
+            (r'0[Bb][01_]+', Number.Bin),
             # -- Octal
             (r'0[0-7_]+', Number.Oct),
             # -- Hexadecimal
@@ -1207,7 +1207,7 @@ class DylanLexer(RegexLexer):
             (r"'(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\\'\n])'", String.Char),
 
             # binary integer
-            (r'#[bB][01]+', Number),
+            (r'#[bB][01]+', Number.Bin),
 
             # octal integer
             (r'#[oO][0-7]+', Number.Oct),
@@ -2074,7 +2074,7 @@ class OocLexer(RegexLexer):
 
             (r'0x[0-9a-fA-F]+', Number.Hex),
             (r'0c[0-9]+', Number.Oct),
-            (r'0b[01]+', Number.Binary),
+            (r'0b[01]+', Number.Bin),
             (r'[0-9_]\.[0-9_]*(?!\.)', Number.Float),
             (r'[0-9_]+', Number.Decimal),
 
@@ -2279,7 +2279,7 @@ class FelixLexer(RegexLexer):
 
             # IntegerLiteral
             # -- Binary
-            (r'0[Bb][01_]+%s' % decimal_suffixes, Number),
+            (r'0[Bb][01_]+%s' % decimal_suffixes, Number.Bin),
             # -- Octal
             (r'0[0-7_]+%s' % decimal_suffixes, Number.Oct),
             # -- Hexadecimal
@@ -2589,7 +2589,7 @@ class Modula2Lexer(RegexLexer):
             (r'([a-zA-Z_\$][\w\$]*)', Name),
         ],
         'numliterals': [
-            (r'[01]+B', Number.Binary),        # binary number (ObjM2)
+            (r'[01]+B', Number.Bin),           # binary number (ObjM2)
             (r'[0-7]+B', Number.Oct),          # octal number (PIM + ISO)
             (r'[0-7]+C', Number.Oct),          # char code (PIM + ISO)
             (r'[0-9A-F]+C', Number.Hex),       # char code (ObjM2)
@@ -2786,7 +2786,7 @@ class BlitzMaxLexer(RegexLexer):
             (r'\.[0-9]*(?!\.)', Number.Float),
             (r'[0-9]+', Number.Integer),
             (r'\$[0-9a-f]+', Number.Hex),
-            (r'\%[10]+', Number), # Binary
+            (r'\%[10]+', Number.Bin),
             # Other
             (r'(?:(?:(:)?([ \t]*)(:?%s|([+\-*/&|~]))|Or|And|Not|[=<>^]))' %
              (bmax_vopwords), Operator),
@@ -2877,7 +2877,7 @@ class BlitzBasicLexer(RegexLexer):
             (r'\.[0-9]+(?!\.)', Number.Float),
             (r'[0-9]+', Number.Integer),
             (r'\$[0-9a-f]+', Number.Hex),
-            (r'\%[10]+', Number), # Binary
+            (r'\%[10]+', Number.Bin),
             # Other
             (r'(?:%s|([+\-*/~=<>^]))' % (bb_vopwords), Operator),
             (r'[(),:\[\]\\]', Punctuation),
@@ -3005,7 +3005,7 @@ class NimrodLexer(RegexLexer):
             (r'[0-9][0-9_]*(?=([eE.]|\'[fF](32|64)))',
               Number.Float, ('float-suffix', 'float-number')),
             (r'0[xX][a-f0-9][a-f0-9_]*', Number.Hex, 'int-suffix'),
-            (r'0[bB][01][01_]*', Number, 'int-suffix'),
+            (r'0[bB][01][01_]*', Number.Bin, 'int-suffix'),
             (r'0o[0-7][0-7_]*', Number.Oct, 'int-suffix'),
             (r'[0-9][0-9_]*', Number.Integer, 'int-suffix'),
             # Whitespace
@@ -3370,14 +3370,15 @@ class RustLexer(RegexLexer):
             # Lifetime
             (r"""'[a-zA-Z_]\w*""", Name.Label),
             # Binary Literal
-            (r'0b[01_]+', Number, 'number_lit'),
+            (r'0b[01_]+', Number.Bin, 'number_lit'),
             # Octal Literal
             (r'0o[0-7_]+', Number.Oct, 'number_lit'),
             # Hexadecimal Literal
             (r'0[xX][0-9a-fA-F_]+', Number.Hex, 'number_lit'),
             # Decimal Literal
-            (r'[0-9][0-9_]*(\.[0-9_]+[eE][+\-]?'
-             r'[0-9_]+|\.[0-9_]*|[eE][+\-]?[0-9_]+)?', Number, 'number_lit'),
+            (r'[0-9][0-9_]*(\.[0-9_]+[eE][+\-]?[0-9_]+|'
+             r'\.[0-9_]*|[eE][+\-]?[0-9_]+)', Number.Float, 'number_lit'),
+            (r'[0-9][0-9_]*', Number.Integer, 'number_lit'),
             # String Literal
             (r'"', String, 'string'),
             (r'r(#*)".*?"\1', String.Raw),
@@ -3526,7 +3527,7 @@ class MonkeyLexer(RegexLexer):
             (r'\.[0-9]+(?!\.)', Number.Float),
             (r'[0-9]+', Number.Integer),
             (r'\$[0-9a-fA-Z]+', Number.Hex),
-            (r'\%[10]+', Number), # Binary
+            (r'\%[10]+', Number.Bin),
             # Native data types
             (r'\b%s\b' % keyword_type, Keyword.Type),
             # Exception handling
@@ -3937,7 +3938,7 @@ class ChapelLexer(RegexLexer):
 
             # integer literals
             # -- binary
-            (r'0[bB][0-1]+', Number),
+            (r'0[bB][0-1]+', Number.Bin),
             # -- hex
             (r'0[xX][0-9a-fA-F]+', Number.Hex),
             # -- decimal
@@ -4118,7 +4119,7 @@ class Inform6Lexer(RegexLexer):
             (r'\$[+%s][0-9]*\.?[0-9]*([eE][+%s]?[0-9]+)?' % (_dash, _dash),
              Number.Float, '#pop'),
             (r'\$[0-9a-fA-F]+', Number.Hex, '#pop'),
-            (r'\$\$[01]+', Number, '#pop'),  # Binary
+            (r'\$\$[01]+', Number.Bin, '#pop'),
             (r'[0-9]+', Number.Integer, '#pop'),
             # Values prefixed by hashes
             (r'(##|#a\$)(%s)' % _name, bygroups(Operator, Name), '#pop'),
diff --git a/pygments/lexers/dotnet.py b/pygments/lexers/dotnet.py
index eb18df71..9c4d6e9b 100644
--- a/pygments/lexers/dotnet.py
+++ b/pygments/lexers/dotnet.py
@@ -626,7 +626,7 @@ class FSharpLexer(RegexLexer):
             (r'\d[\d_]*[uU]?[yslLnQRZINGmM]?', Number.Integer),
             (r'0[xX][\da-fA-F][\da-fA-F_]*[uU]?[yslLn]?[fF]?', Number.Hex),
             (r'0[oO][0-7][0-7_]*[uU]?[yslLn]?', Number.Oct),
-            (r'0[bB][01][01_]*[uU]?[yslLn]?', Number.Binary),
+            (r'0[bB][01][01_]*[uU]?[yslLn]?', Number.Bin),
             (r'-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)[fFmM]?',
              Number.Float),
 
diff --git a/pygments/lexers/functional.py b/pygments/lexers/functional.py
index af3b2552..aeed9ccf 100644
--- a/pygments/lexers/functional.py
+++ b/pygments/lexers/functional.py
@@ -774,7 +774,7 @@ class RacketLexer(RegexLexer):
     _closing_parenthesis = r'[)\]}]'
     _delimiters = r'()[\]{}",\'`;\s'
     _symbol = r'(?u)(?:\|[^|]*\||\\[\w\W]|[^|\\%s]+)+' % _delimiters
-    _number_prefix = r'(?:#e)?(?:#b|(?:#d)?)(?:#e)?'
+    _exact_decimal_prefix = r'(?:#e)?(?:#d)?(?:#e)?'
     _exponent = r'(?:[defls][-+]?\d+)'
     _inexact_simple_no_hashes = r'(?:\d+(?:/\d+|\.\d*)?|\.\d+)'
     _inexact_simple = (r'(?:%s|(?:\d+#+(?:\.#*|/\d+#*)?|\.\d+#+|'
@@ -804,18 +804,18 @@ class RacketLexer(RegexLexer):
             # can denote the base or the type. These don't map neatly
             # onto Pygments token types; some judgment calls here.
 
-            # #b or #d or no prefix
-            (r'(?i)%s[-+]?\d+(?=[%s])' % (_number_prefix, _delimiters),
+            # #d or no prefix
+            (r'(?i)%s[-+]?\d+(?=[%s])' % (_exact_decimal_prefix, _delimiters),
              Number.Integer, '#pop'),
             (r'(?i)%s[-+]?(\d+(\.\d*)?|\.\d+)([deflst][-+]?\d+)?(?=[%s])' %
-             (_number_prefix, _delimiters), Number.Float, '#pop'),
+             (_exact_decimal_prefix, _delimiters), Number.Float, '#pop'),
             (r'(?i)%s[-+]?(%s([-+]%s?i)?|[-+]%s?i)(?=[%s])' %
-             (_number_prefix, _inexact_normal_no_hashes,
+             (_exact_decimal_prefix, _inexact_normal_no_hashes,
               _inexact_normal_no_hashes, _inexact_normal_no_hashes,
               _delimiters), Number, '#pop'),
 
             # Inexact without explicit #i
-            (r'(?i)(#[bd])?(%s([-+]%s?i)?|[-+]%s?i|%s@%s)(?=[%s])' %
+            (r'(?i)(#d)?(%s([-+]%s?i)?|[-+]%s?i|%s@%s)(?=[%s])' %
              (_inexact_real, _inexact_unsigned, _inexact_unsigned,
               _inexact_real, _inexact_real, _delimiters), Number.Float,
              '#pop'),
@@ -824,6 +824,9 @@ class RacketLexer(RegexLexer):
             (r'(?i)(([-+]?%st[-+]?\d+)|[-+](inf|nan)\.t)(?=[%s])' %
              (_inexact_simple, _delimiters), Number.Float, '#pop'),
 
+            # #b
+            (r'(?i)(#[ei])?#b%s' % _symbol, Number.Bin, '#pop'),
+
             # #o
             (r'(?i)(#[ei])?#o%s' % _symbol, Number.Oct, '#pop'),
 
@@ -831,7 +834,7 @@ class RacketLexer(RegexLexer):
             (r'(?i)(#[ei])?#x%s' % _symbol, Number.Hex, '#pop'),
 
             # #i is always inexact, i.e. float
-            (r'(?i)(#[bd])?#i%s' % _symbol, Number.Float, '#pop'),
+            (r'(?i)(#d)?#i%s' % _symbol, Number.Float, '#pop'),
 
             # Strings and characters
             (r'#?"', String.Double, ('#pop', 'string')),
@@ -1178,7 +1181,7 @@ class CommonLispLexer(RegexLexer):
             (r'#\'', Name.Function),
 
             # binary rational
-            (r'#[bB][+-]?[01]+(/[01]+)?', Number),
+            (r'#[bB][+-]?[01]+(/[01]+)?', Number.Bin),
 
             # octal rational
             (r'#[oO][+-]?[0-7]+(/[0-7]+)?', Number.Oct),
@@ -2207,7 +2210,7 @@ class OcamlLexer(RegexLexer):
             (r'-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)', Number.Float),
             (r'0[xX][\da-fA-F][\da-fA-F_]*', Number.Hex),
             (r'0[oO][0-7][0-7_]*', Number.Oct),
-            (r'0[bB][01][01_]*', Number.Binary),
+            (r'0[bB][01][01_]*', Number.Bin),
             (r'\d[\d_]*', Number.Integer),
 
             (r"'(?:(\\[\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))'",
@@ -2455,7 +2458,7 @@ class OpaLexer(RegexLexer):
             (r'-?\d+[eE][+\-]?\d+', Number.Float),
             (r'0[xX][\da-fA-F]+', Number.Hex),
             (r'0[oO][0-7]+', Number.Oct),
-            (r'0[bB][01]+', Number.Binary),
+            (r'0[bB][01]+', Number.Bin),
             (r'\d+', Number.Integer),
             # color literals
             (r'#[\da-fA-F]{3,6}', Number.Integer),
@@ -2817,7 +2820,7 @@ class CoqLexer(RegexLexer):
             (r'\d[\d_]*', Number.Integer),
             (r'0[xX][\da-fA-F][\da-fA-F_]*', Number.Hex),
             (r'0[oO][0-7][0-7_]*', Number.Oct),
-            (r'0[bB][01][01_]*', Number.Binary),
+            (r'0[bB][01][01_]*', Number.Bin),
             (r'-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)', Number.Float),
 
             (r"'(?:(\\[\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))'",
@@ -3177,8 +3180,11 @@ class ElixirLexer(RegexLexer):
             (r'[a-zA-Z_!]\w*[!\?]?', Name),
             (r'[(){};,/\|:\\\[\]]', Punctuation),
             (r'@[a-zA-Z_]\w*|&\d', Name.Variable),
-            (r'\b(0[xX][0-9A-Fa-f]+|\d(_?\d)*(\.(?![^\d\s])'
-             r'(_?\d)*)?([eE][-+]?\d(_?\d)*)?|0[bB][01]+)\b', Number),
+            (r'(?i)\b(0x[\da-f]+)\b', Number.Hex),
+            (r'\b\d(_?\d)*(?!\.)\b', Number.Integer),
+            (r'\b(\d(_?\d)*(\.(?![^\d\s])(_?\d)*)?([eE][-+]?\d(_?\d)*)?)\b',
+             Number.Float),
+            (r'\b(0[bB][01]+)\b', Number.Bin),
             (r'%r\/.*\/', String.Regex),
             include('strings'),
         ],
diff --git a/pygments/lexers/hdl.py b/pygments/lexers/hdl.py
index 6240cfe0..40b1bc54 100644
--- a/pygments/lexers/hdl.py
+++ b/pygments/lexers/hdl.py
@@ -46,7 +46,7 @@ class VerilogLexer(RegexLexer):
             (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?', Number.Float),
             (r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float),
             (r'([0-9]+)|(\'h)[0-9a-fA-F]+', Number.Hex),
-            (r'([0-9]+)|(\'b)[0-1]+', Number.Hex),   # should be binary
+            (r'([0-9]+)|(\'b)[0-1]+', Number.Bin),
             (r'([0-9]+)|(\'d)[0-9]+', Number.Integer),
             (r'([0-9]+)|(\'o)[0-7]+', Number.Oct),
             (r'\'[01xz]', Number),
@@ -161,7 +161,7 @@ class SystemVerilogLexer(RegexLexer):
             (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?', Number.Float),
             (r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float),
             (r'([0-9]+)|(\'h)[0-9a-fA-F]+', Number.Hex),
-            (r'([0-9]+)|(\'b)[0-1]+', Number.Hex),   # should be binary
+            (r'([0-9]+)|(\'b)[0-1]+', Number.Bin),
             (r'([0-9]+)|(\'d)[0-9]+', Number.Integer),
             (r'([0-9]+)|(\'o)[0-7]+', Number.Oct),
             (r'\'[01xz]', Number),
@@ -346,11 +346,10 @@ class VhdlLexer(RegexLexer):
         ],
         'numbers': [
             (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-f_]+"', Number.Oct),
+            (r'X"[0-9a-f_]+"', Number.Hex),
             (r'O"[0-7_]+"', Number.Oct),
-            (r'B"[0-1_]+"', Number.Oct),
+            (r'B"[0-1_]+"', Number.Bin),
         ],
     }
diff --git a/pygments/lexers/jvm.py b/pygments/lexers/jvm.py
index 341d8eb2..fa05b7ed 100644
--- a/pygments/lexers/jvm.py
+++ b/pygments/lexers/jvm.py
@@ -940,8 +940,8 @@ class CeylonLexer(RegexLexer):
              Number.Float),
             (r'#([0-9a-fA-F]{4})(_[0-9a-fA-F]{4})+', Number.Hex),
             (r'#[0-9a-fA-F]+', Number.Hex),
-            (r'\$([01]{4})(_[01]{4})+', Number.Integer),
-            (r'\$[01]+', Number.Integer),
+            (r'\$([01]{4})(_[01]{4})+', Number.Bin),
+            (r'\$[01]+', Number.Bin),
             (r'\d{1,3}(_\d{3})+[kMGTP]?', Number.Integer),
             (r'[0-9]+[kMGTP]?', Number.Integer),
             (r'\n', Text)
diff --git a/pygments/lexers/math.py b/pygments/lexers/math.py
index de766bd2..b324c614 100644
--- a/pygments/lexers/math.py
+++ b/pygments/lexers/math.py
@@ -105,8 +105,8 @@ class JuliaLexer(RegexLexer):
             (r'(\d+\.\d*|\d*\.\d+)([eEf][+-]?[0-9]+)?', Number.Float),
             (r'\d+(_\d+)+[eEf][+-]?[0-9]+', Number.Float),
             (r'\d+[eEf][+-]?[0-9]+', Number.Float),
-            (r'0b[01]+(_[01]+)+', Number.Binary),
-            (r'0b[01]+', Number.Binary),
+            (r'0b[01]+(_[01]+)+', Number.Bin),
+            (r'0b[01]+', Number.Bin),
             (r'0o[0-7]+(_[0-7]+)+', Number.Oct),
             (r'0o[0-7]+', Number.Oct),
             (r'0x[a-fA-F0-9]+(_[a-fA-F0-9]+)+', Number.Hex),
diff --git a/pygments/lexers/other.py b/pygments/lexers/other.py
index 0c4753ad..c02f048c 100644
--- a/pygments/lexers/other.py
+++ b/pygments/lexers/other.py
@@ -509,10 +509,10 @@ class LogtalkLexer(RegexLexer):
             (r'\s+', Text),
             # Numbers
             (r"0'.", Number),
-            (r'0b[01]+', Number),
-            (r'0o[0-7]+', Number),
-            (r'0x[0-9a-fA-F]+', Number),
-            (r'\d+\.?\d*((e|E)(\+|-)?\d+)?', Number),
+            (r'0b[01]+', Number.Bin),
+            (r'0o[0-7]+', Number.Oct),
+            (r'0x[0-9a-fA-F]+', Number.Hex),
+            (r'\d+\.?\d*((e|E)(\+|-)?\d+)?', Number.Float),
             # Variables
             (r'([A-Z_]\w*)', Name.Variable),
             # Event handlers
@@ -670,10 +670,10 @@ class LogtalkLexer(RegexLexer):
              r'(?=[(])', Keyword),
             # Numbers
             (r"0'.", Number),
-            (r'0b[01]+', Number),
-            (r'0o[0-7]+', Number),
-            (r'0x[0-9a-fA-F]+', Number),
-            (r'\d+\.?\d*((e|E)(\+|-)?\d+)?', Number),
+            (r'0b[01]+', Number.Bin),
+            (r'0o[0-7]+', Number.Oct),
+            (r'0x[0-9a-fA-F]+', Number.Hex),
+            (r'\d+\.?\d*((e|E)(\+|-)?\d+)?', Number.Float),
             # Variables
             (r'([A-Z_]\w*)', Name.Variable),
             # Atoms
diff --git a/pygments/lexers/web.py b/pygments/lexers/web.py
index 91b2a1eb..ce857c71 100644
--- a/pygments/lexers/web.py
+++ b/pygments/lexers/web.py
@@ -854,7 +854,7 @@ class PhpLexer(RegexLexer):
             (r'0[0-7]+', Number.Oct),
             (r'0[xX][a-f0-9]+', Number.Hex),
             (r'\d+', Number.Integer),
-            (r'0b[01]+', Number.Binary),
+            (r'0b[01]+', Number.Bin),
             (r"'([^'\\]*(?:\\.[^'\\]*)*)'", String.Single),
             (r'`([^`\\]*(?:\\.[^`\\]*)*)`', String.Backtick),
             (r'"', String.Double, 'string'),
@@ -3558,9 +3558,9 @@ class XQueryLexer(ExtendedRegexLexer):
 
             # handle operator state
             # order on numbers matters - handle most complex first
-            (r'\d+(\.\d*)?[eE][\+\-]?\d+', Number.Double, 'operator'),
-            (r'(\.\d+)[eE][\+\-]?\d+', Number.Double, 'operator'),
-            (r'(\.\d+|\d+\.\d*)', Number, 'operator'),
+            (r'\d+(\.\d*)?[eE][\+\-]?\d+', Number.Float, 'operator'),
+            (r'(\.\d+)[eE][\+\-]?\d+', Number.Float, 'operator'),
+            (r'(\.\d+|\d+\.\d*)', Number.Float, 'operator'),
             (r'(\d+)', Number.Integer, 'operator'),
             (r'(\.\.|\.|\))', Punctuation, 'operator'),
             (r'(declare)(\s+)(construction)',
diff --git a/pygments/token.py b/pygments/token.py
index c40ffd33..372ce748 100644
--- a/pygments/token.py
+++ b/pygments/token.py
@@ -166,6 +166,7 @@ STANDARD_TYPES = {
     String.Symbol:                 'ss',
 
     Number:                        'm',
+    Number.Bin:                    'mb',
     Number.Float:                  'mf',
     Number.Hex:                    'mh',
     Number.Integer:                'mi',