eric: comparison eric6/ThirdParty/Pygments/pygments/lexers/asm.py

-:a3cf077a8db3
+:25f42e208e08
 pygments.lexers.asm
 ~~~~~~~~~~~~~~~~~~~
 Lexers for assembly languages.
-:copyright: Copyright 2006-2019 by the Pygments team, see AUTHORS.
+:copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
 :license: BSD, see LICENSE for details.
 """
 import re
 #: optional Comment or Whitespace
 string = r'"(\\"|[^"])*"'
 char = r'[\w$.@-]'
 identifier = r'(?:[a-zA-Z$_]' + char + r'*|\.' + char + '+)'
-number = r'(?:0[xX][a-zA-Z0-9]+|\d+)'
+number = r'(?:0[xX][a-fA-F0-9]+|#?-?\d+)'
 register = '%' + identifier
 tokens = {
 'root': [
 include('whitespace'),
 }
 class ObjdumpLexer(RegexLexer):
 """
-For the output of 'objdump -dr'
+For the output of ``objdump -dr``.
 """
 name = 'objdump'
 aliases = ['objdump']
 filenames = ['*.objdump']
 mimetypes = ['text/x-objdump']
 tokens = _objdump_lexer_tokens(GasLexer)
 class DObjdumpLexer(DelegatingLexer):
 """
-For the output of 'objdump -Sr on compiled D files'
+For the output of ``objdump -Sr`` on compiled D files.
 """
 name = 'd-objdump'
 aliases = ['d-objdump']
 filenames = ['*.d-objdump']
 mimetypes = ['text/x-d-objdump']
 def __init__(self, **options):
-super(DObjdumpLexer, self).__init__(DLexer, ObjdumpLexer, **options)
+super().__init__(DLexer, ObjdumpLexer, **options)
 class CppObjdumpLexer(DelegatingLexer):
 """
-For the output of 'objdump -Sr on compiled C++ files'
+For the output of ``objdump -Sr`` on compiled C++ files.
 """
 name = 'cpp-objdump'
 aliases = ['cpp-objdump', 'c++-objdumb', 'cxx-objdump']
 filenames = ['*.cpp-objdump', '*.c++-objdump', '*.cxx-objdump']
 mimetypes = ['text/x-cpp-objdump']
 def __init__(self, **options):
-super(CppObjdumpLexer, self).__init__(CppLexer, ObjdumpLexer, **options)
+super().__init__(CppLexer, ObjdumpLexer, **options)
 class CObjdumpLexer(DelegatingLexer):
 """
-For the output of 'objdump -Sr on compiled C files'
+For the output of ``objdump -Sr`` on compiled C files.
 """
 name = 'c-objdump'
 aliases = ['c-objdump']
 filenames = ['*.c-objdump']
 mimetypes = ['text/x-c-objdump']
 def __init__(self, **options):
-super(CObjdumpLexer, self).__init__(CLexer, ObjdumpLexer, **options)
+super().__init__(CLexer, ObjdumpLexer, **options)
 class HsailLexer(RegexLexer):
 """
 For HSAIL assembly code.
 # Integer types
 (r'i[1-9]\d*', Keyword)
 ]
 }
 class LlvmMirBodyLexer(RegexLexer):
 """
-For LLVM MIR examples without the YAML wrapper
+For LLVM MIR examples without the YAML wrapper.
 For more information on LLVM MIR see https://llvm.org/docs/MIRLangRef.html.
 .. versionadded:: 2.6
 """
 tokens = {
 'root': [
 # Attributes on basic blocks
 (words(('liveins', 'successors'), suffix=':'), Keyword),
 # Basic Block Labels
-(r'bb\.[0-9]+(\.[0-9a-zA-Z_.-]+)?( \(address-taken\))?:', Name.Label),
+(r'bb\.[0-9]+(\.[a-zA-Z0-9_.-]+)?( \(address-taken\))?:', Name.Label),
-(r'bb\.[0-9]+ \(%[0-9a-zA-Z_.-]+\)( \(address-taken\))?:', Name.Label),
+(r'bb\.[0-9]+ \(%[a-zA-Z0-9_.-]+\)( \(address-taken\))?:', Name.Label),
 (r'%bb\.[0-9]+(\.\w+)?', Name.Label),
 # Stack references
 (r'%stack\.[0-9]+(\.\w+\.addr)?', Name),
 # Subreg indices
 (r'%subreg\.\w+', Name),
 # Virtual registers
-(r'%[0-9a-zA-Z_]+ *', Name.Variable, 'vreg'),
+(r'%[a-zA-Z0-9_]+ *', Name.Variable, 'vreg'),
 # Reference to LLVM-IR global
 include('global'),
 # Reference to Intrinsic
-(r'intrinsic\(\@[0-9a-zA-Z_.]+\)', Name.Variable.Global),
+(r'intrinsic\(\@[a-zA-Z0-9_.]+\)', Name.Variable.Global),
 # Comparison predicates
 (words(('eq', 'ne', 'sgt', 'sge', 'slt', 'sle', 'ugt', 'uge', 'ult',
 'ule'), prefix=r'intpred\(', suffix=r'\)'), Name.Builtin),
 (words(('oeq', 'one', 'ogt', 'oge', 'olt', 'ole', 'ugt', 'uge',
 'ult', 'ule'), prefix=r'floatpred\(', suffix=r'\)'),
 Name.Builtin),
 # Physical registers
 (r'\$\w+', String.Single),
 # Assignment operator
-(r'[=]', Operator),
+(r'=', Operator),
 # gMIR Opcodes
 (r'(G_ANYEXT|G_[SZ]EXT|G_SEXT_INREG|G_TRUNC|G_IMPLICIT_DEF|G_PHI|'
 r'G_FRAME_INDEX|G_GLOBAL_VALUE|G_INTTOPTR|G_PTRTOINT|G_BITCAST|'
 r'G_CONSTANT|G_FCONSTANT|G_VASTART|G_VAARG|G_CTLZ|G_CTLZ_ZERO_UNDEF|'
 r'G_CTTZ|G_CTTZ_ZERO_UNDEF|G_CTPOP|G_BSWAP|G_BITREVERSE|'
 (r'(COPY|PHI|INSERT_SUBREG|EXTRACT_SUBREG|REG_SEQUENCE)\b',
 Name.Builtin),
 # Flags
 (words(('killed', 'implicit')), Keyword),
 # ConstantInt values
-(r'[i][0-9]+ +', Keyword.Type, 'constantint'),
+(r'i[0-9]+ +', Keyword.Type, 'constantint'),
 # ConstantFloat values
 (r'(half|float|double) +', Keyword.Type, 'constantfloat'),
 # Bare immediates
 include('integer'),
 # MMO's
 (r':: *', Operator, 'mmo'),
 # MIR Comments
 (r';.*', Comment),
 # If we get here, assume it's a target instruction
-(r'[0-9a-zA-Z_]+', Name),
+(r'[a-zA-Z0-9_]+', Name),
 # Everything else that isn't highlighted
 (r'[(), \n]+', Text),
 ],
 # The integer constant from a ConstantInt value
 'constantint': [
 (r'(?=.)', Text, '#pop'),
 ],
 'vreg_bank_or_class': [
 # The unassigned bank/class
 (r' *_', Name.Variable.Magic),
-(r' *[0-9a-zA-Z_]+', Name.Variable),
+(r' *[a-zA-Z0-9_]+', Name.Variable),
 # The LLT if there is one
 (r' *\(', Text, 'vreg_type'),
 (r'(?=.)', Text, '#pop'),
 ],
 'vreg_type': [
 (r' +', Text),
 (words(('load', 'store', 'on', 'into', 'from', 'align', 'monotonic',
 'acquire', 'release', 'acq_rel', 'seq_cst')),
 Keyword),
 # IR references
-(r'%ir\.[0-9a-zA-Z_.-]+', Name),
+(r'%ir\.[a-zA-Z0-9_.-]+', Name),
-(r'%ir-block\.[0-9a-zA-Z_.-]+', Name),
+(r'%ir-block\.[a-zA-Z0-9_.-]+', Name),
 (r'[-+]', Operator),
 include('integer'),
 include('global'),
 (r',', Punctuation),
 (r'\), \(', Text),
 (r'\)', Text, '#pop'),
 ],
 'integer': [(r'-?[0-9]+', Number.Integer),],
 'float': [(r'-?[0-9]+\.[0-9]+(e[+-][0-9]+)?', Number.Float)],
-'global': [(r'\@[0-9a-zA-Z_.]+', Name.Variable.Global)],
+'global': [(r'\@[a-zA-Z0-9_.]+', Name.Variable.Global)],
 }
 class LlvmMirLexer(RegexLexer):
 """
-Lexer for the overall LLVM MIR document format
+Lexer for the overall LLVM MIR document format.
 MIR is a human readable serialization format that's used to represent LLVM's
 machine specific intermediate representation. It allows LLVM's developers to
 see the state of the compilation process at various points, as well as test
 individual pieces of the compiler.
 (r'body: *\|', Keyword, 'llvm_mir_body'),
 # Consume everything else
 (r'.+', Text),
 (r'\n', Text),
 ],
-'name': [ (r'[^\n]+', Name), default('#pop') ],
+'name': [
-'boolean': [ (r' *(true|false)', Name.Builtin), default('#pop') ],
+(r'[^\n]+', Name),
-'number': [ (r' *[0-9]+', Number), default('#pop') ],
+default('#pop'),
+],
+'boolean': [
+(r' *(true|false)', Name.Builtin),
+default('#pop'),
+],
+'number': [
+(r' *[0-9]+', Number),
+default('#pop'),
+],
 'llvm_mir_body': [
 # Documents end with '...' or '---'.
 # We have to pop llvm_mir_body and llvm_mir
 (r'(\.\.\.|(?=---))', Keyword, '#pop:2'),
 # Delegate the body block to the LlvmMirBodyLexer
 (r'((?:.|\n)+?)(?=\.\.\.|---)', bygroups(using(LlvmMirBodyLexer))),
 # The '...' is optional. If we didn't already find it then it isn't
 # there. There might be a '---' instead though.
-(r'(?!\.\.\.|---)((.|\n)+)', bygroups(using(LlvmMirBodyLexer), Keyword)),
+(r'(?!\.\.\.|---)((?:.|\n)+)', bygroups(using(LlvmMirBodyLexer))),
 ],
 }
 class NasmLexer(RegexLexer):
 binn = r'[01]+b'
 decn = r'[0-9]+'
 floatn = decn + r'\.e?' + decn
 string = r'"(\\"|[^"\n])*"|' + r"'(\\'|[^'\n])*'|" + r"`(\\`|[^`\n])*`"
 declkw = r'(?:res|d)[bwdqt]|times'
-register = (r'r[0-9][0-5]?[bwd]|'
+register = (r'r[0-9][0-5]?[bwd]?|'
 r'[a-d][lh]|[er]?[a-d]x|[er]?[sb]p|[er]?[sd]i|[c-gs]s|st[0-7]|'
 r'mm[0-7]|cr[0-4]|dr[0-367]|tr[3-7]')
 wordop = r'seg|wrt|strict'
 type = r'byte|[dq]?word'
 # Directives must be followed by whitespace, otherwise CPU will match
 return False
 class NasmObjdumpLexer(ObjdumpLexer):
 """
-For the output of 'objdump -d -M intel'.
+For the output of ``objdump -d -M intel``.
 .. versionadded:: 2.0
 """
 name = 'objdump-nasm'
 aliases = ['objdump-nasm']
 return 0.9
 class Dasm16Lexer(RegexLexer):
 """
-Simple lexer for DCPU-16 Assembly
+For DCPU-16 Assembly.
 Check http://0x10c.com/doc/dcpu-16.txt
 .. versionadded:: 2.4
 """
 'SP', 'PC', 'EX',
 'POP', 'PEEK', 'PUSH'
 ]
 # Regexes yo
-char = r'[a-zA-Z$._0-9@]'
+char = r'[a-zA-Z0-9_$@.]'
 identifier = r'(?:[a-zA-Z$_]' + char + r'*|\.' + char + '+)'
 number = r'[+-]?(?:0[xX][a-zA-Z0-9]+|\d+)'
 binary_number = r'0b[01_]+'
 instruction = r'(?i)(' + '|'.join(INSTRUCTIONS) + ')'
 single_char = r"'\\?" + char + "'"

Mercurial Repositories > eric / file comparison

comparison: eric6/ThirdParty/Pygments/pygments/lexers/asm.py

eric6/ThirdParty/Pygments/pygments/lexers/asm.py