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

-:48d210e41c65
+:54c5cfbb1e29
 pygments.lexers.jvm
 ~~~~~~~~~~~~~~~~~~~
 Pygments lexers for JVM languages.
-:copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
+:copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
 :license: BSD, see LICENSE for details.
 """
 import re
 'class'),
 (r'(var)(\s+)', bygroups(Keyword.Declaration, Text),
 'var'),
 (r'(import(?:\s+static)?)(\s+)', bygroups(Keyword.Namespace, Text),
 'import'),
-(r'"(\\\\|\\"|[^"])*"', String),
+(r'"', String, 'string'),
 (r"'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'", String.Char),
 (r'(\.)((?:[^\W\d]|\$)[\w$]*)', bygroups(Punctuation,
 Name.Attribute)),
 (r'^\s*([^\W\d]|\$)[\w$]*:', Name.Label),
 (r'([^\W\d]|\$)[\w$]*', Name),
 'var': [
 (r'([^\W\d]|\$)[\w$]*', Name, '#pop')
 ],
 'import': [
 (r'[\w.]+\*?', Name.Namespace, '#pop')
+],
+'string': [
+(r'[^\\"]+', String),
+(r'\\\\', String),  # Escaped backslash
+(r'\\"', String),  # Escaped quote
+(r'\\', String),  # Bare backslash
+(r'"', String, '#pop'),  # Closing quote
 ],
 }
 class AspectJLexer(JavaLexer):
 (r'%s%s\b' % (upper, idrest), Name.Class),
 (r'(true|false|null)\b', Keyword.Constant),
 (r'(import|package)(\s+)', bygroups(Keyword, Text), 'import'),
 (r'(type)(\s+)', bygroups(Keyword, Text), 'type'),
 (r'""".*?"""(?!")', String),
-(r'"(\\\\|\\"|[^"])*"', String),
+(r'"(\\\\|\\[^\\]|[^"\\])*"', String),
 (r"'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'", String.Char),
 (r"'%s" % idrest, Text.Symbol),
 (r'[fs]"""', String, 'interptriplestring'),  # interpolated strings
 (r'[fs]"', String, 'interpstring'),  # interpolated strings
-(r'raw"(\\\\|\\"|[^"])*"', String),  # raw strings
+(r'raw"(\\\\|\\[^\\]|[^"\\])*"', String),  # raw strings
 # (r'(\.)(%s|%s|`[^`]+`)' % (idrest, op), bygroups(Operator,
 # Name.Attribute)),
 (idrest, Name),
 (r'`[^`]+`', Name),
 (r'\[', Operator, 'typeparam'),
 (r'(class|interface)(\s+)', bygroups(Keyword.Declaration, Text),
 'class'),
 (r'(import)(\s+)', bygroups(Keyword.Namespace, Text), 'import'),
 (r'""".*?"""', String.Double),
 (r"'''.*?'''", String.Single),
-(r'"(\\\\|\\"|[^"])*"', String.Double),
+(r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
-(r"'(\\\\|\\'|[^'])*'", String.Single),
+(r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
 (r'\$/((?!/\$).)*/\$', String),
-(r'/(\\\\|\\"|[^/])*/', String),
+(r'/(\\\\|\\[^\\]|[^/\\])*/', String),
 (r"'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'", String.Char),
 (r'(\.)([a-zA-Z_]\w*)', bygroups(Operator, Name.Attribute)),
 (r'[a-zA-Z_]\w*:', Name.Label),
 (r'[a-zA-Z_$]\w*', Name),
 (r'[~^*!%&\[\](){}<>|+=:;,./?-]', Operator),
 (r'#r\[', String.Regex, 'squareRegexp'),
 # Symbols
 (r':[\w!:?]+', String.Symbol),
 (r'[\w!:?]+:(?![\w!?])', String.Other),
-(r':"(\\\\|\\"|[^"])*"', String.Symbol),
+(r':"(\\\\|\\[^\\]|[^"\\])*"', String.Symbol),
 # Documentation
 (r'((?<=fn\()|(?<=fnx\()|(?<=method\()|(?<=macro\()|(?<=lecro\()'
 r'|(?<=syntax\()|(?<=dmacro\()|(?<=dlecro\()|(?<=dlecrox\()'
 r'|(?<=dsyntax\())\s*"', String.Doc, 'documentation'),
 (r'-?\d+\.\d+', Number.Float),
 (r'-?\d+', Number.Integer),
 (r'0x-?[abcdef\d]+', Number.Hex),
 # strings, symbols and characters
-(r'"(\\\\|\\"|[^"])*"', String),
+(r'"(\\\\|\\[^\\]|[^"\\])*"', String),
 (r"'" + valid_name, String.Symbol),
 (r"\\(.|[a-z]+)", String.Char),
 # keywords
 (r'::?#?' + valid_name, String.Symbol),
 Keyword),
 (r'(as|call|define)\b', Keyword.Declaration),
 (r'(true|false|null)\b', Keyword.Constant),
 (r'(template)(\s+)', bygroups(Keyword.Declaration, Text), 'template'),
 (r'(import)(\s+)', bygroups(Keyword.Namespace, Text), 'import'),
-(r'"(\\\\|\\"|[^"])*"', String),
+(r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
-(r'\'(\\\\|\\\'|[^\'])*\'', String),
+(r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
 (r'(\.)([a-zA-Z_]\w*)', bygroups(Operator, Name.Attribute)),
 (r'[a-zA-Z_]\w*:', Name.Label),
 (r'[a-zA-Z_\$]\w*', Name),
 (r'(isa|[.]{3}|[.]{2}|[=#!<>+-/%&;,.\*\\\(\)\[\]\{\}])', Operator),
 (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
 (r'(assembly|module|package)(\s+)', bygroups(Keyword.Namespace, Text)),
 (r'(true|false|null)\b', Keyword.Constant),
 (r'(class|interface|object|alias)(\s+)',
 bygroups(Keyword.Declaration, Text), 'class'),
 (r'(import)(\s+)', bygroups(Keyword.Namespace, Text), 'import'),
-(r'"(\\\\|\\"|[^"])*"', String),
+(r'"(\\\\|\\[^\\]|[^"\\])*"', String),
 (r"'\\.'|'[^\\]'|'\\\{#[0-9a-fA-F]{4}\}'", String.Char),
-(r'".*``.*``.*"', String.Interpol),
 (r'(\.)([a-z_]\w*)',
 bygroups(Operator, Name.Attribute)),
 (r'[a-zA-Z_]\w*:', Name.Label),
 (r'[a-zA-Z_]\w*', Name),
 (r'[~^*!%&\[\](){}<>|+=:;,./?-]', Operator),
 .. versionadded:: 1.5
 """
 name = 'Kotlin'
 aliases = ['kotlin']
-filenames = ['*.kt']
+filenames = ['*.kt', '*.kts']
 mimetypes = ['text/x-kotlin']
 flags = re.MULTILINE | re.DOTALL | re.UNICODE
 kt_name = ('@?[_' + uni.combine('Lu', 'Ll', 'Lt', 'Lm', 'Nl') + ']' +
 (r'^\s*\[.*?\]', Name.Attribute),
 (r'[^\S\n]+', Text),
 (r'\s+', Text),
 (r'\\\n', Text),  # line continuation
 (r'//.*?\n', Comment.Single),
+(r'^#!/.+?\n', Comment.Single),  # shebang for kotlin scripts
 (r'/[*].*?[*]/', Comment.Multiline),
 (r'""".*?"""', String),
 (r'\n', Text),
 (r'::|!!|\?[:.]', Operator),
 (r'[~!%^&*()+=|\[\]:;,.<>/?-]', Punctuation),
 (r'[{}]', Punctuation),
 (r'@"(""|[^"])*"', String),
-(r'"(\\\\|\\"|[^"\n])*["\n]', String),
+(r'"(\\\\|\\[^\\]|[^"\\\n])*["\n]', String),
 (r"'\\.'|'[^\\]'", String.Char),
 (r"[0-9](\.[0-9]*)?([eE][+-][0-9]+)?[flFL]?|"
 r"0[xX][0-9a-fA-F]+[Ll]?", Number),
 (r'(object)(\s+)(:)(\s+)', bygroups(Keyword, Text, Punctuation, Text), 'class'),
 (r'(companion)(\s+)(object)', bygroups(Keyword, Text, Keyword)),
 (r'(class|interface)(\s+)', bygroups(Keyword.Declaration, Text),
 'class'),
 (r'(import)(\s+)', bygroups(Keyword.Namespace, Text), 'import'),
 (r"(''')", String, 'template'),
 (r'(\u00BB)', String, 'template'),
-(r'"(\\\\|\\"|[^"])*"', String),
+(r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
-(r"'(\\\\|\\'|[^'])*'", String),
+(r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
 (r'[a-zA-Z_]\w*:', Name.Label),
 (r'[a-zA-Z_$]\w*', Name),
 (r'[~^*!%&\[\](){}<>\|+=:;,./?-]', Operator),
 (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
 (r'0x[0-9a-fA-F]+', Number.Hex),
 score += 0.6
 return score
 class SarlLexer(RegexLexer):
-	"""
+"""
-	For `SARL <http://www.sarl.io>`_ source code.
+For `SARL <http://www.sarl.io>`_ source code.
-	.. versionadded:: 2.4
+.. versionadded:: 2.4
-	"""
+"""
-	name = 'SARL'
+name = 'SARL'
-	aliases = ['sarl']
+aliases = ['sarl']
-	filenames = ['*.sarl']
+filenames = ['*.sarl']
-	mimetypes = ['text/x-sarl']
+mimetypes = ['text/x-sarl']
-	flags = re.MULTILINE | re.DOTALL
+flags = re.MULTILINE | re.DOTALL
-	tokens = {
+tokens = {
-		'root': [
+'root': [
-			# method names
+# method names
-			(r'^(\s*(?:[a-zA-Z_][\w.\[\]]*\s+)+?)'  # return arguments
+(r'^(\s*(?:[a-zA-Z_][\w.\[\]]*\s+)+?)'  # return arguments
-			 r'([a-zA-Z_$][\w$]*)'                      # method name
+r'([a-zA-Z_$][\w$]*)'                      # method name
-			 r'(\s*)(\()',                             # signature start
+r'(\s*)(\()',                             # signature start
-			 bygroups(using(this), Name.Function, Text, Operator)),
+bygroups(using(this), Name.Function, Text, Operator)),
-			(r'[^\S\n]+', Text),
+(r'[^\S\n]+', Text),
-			(r'//.*?\n', Comment.Single),
+(r'//.*?\n', Comment.Single),
-			(r'/\*.*?\*/', Comment.Multiline),
+(r'/\*.*?\*/', Comment.Multiline),
-			(r'@[a-zA-Z_][\w.]*', Name.Decorator),
+(r'@[a-zA-Z_][\w.]*', Name.Decorator),
-			(r'(as|break|case|catch|default|do|else|extends|extension|finally|fires|for|if|implements|instanceof|new|on|requires|return|super|switch|throw|throws|try|typeof|uses|while|with)\b',
+(r'(as|break|case|catch|default|do|else|extends|extension|finally|'
-			 Keyword),
+r'fires|for|if|implements|instanceof|new|on|requires|return|super|'
-			(r'(abstract|def|dispatch|final|native|override|private|protected|public|static|strictfp|synchronized|transient|val|var|volatile)\b', Keyword.Declaration),
+r'switch|throw|throws|try|typeof|uses|while|with)\b',
-			 (r'(boolean|byte|char|double|float|int|long|short|void)\b',
+Keyword),
-			  Keyword.Type),
+(r'(abstract|def|dispatch|final|native|override|private|protected|'
-			 (r'(package)(\s+)', bygroups(Keyword.Namespace, Text)),
+r'public|static|strictfp|synchronized|transient|val|var|volatile)\b',
-			 (r'(false|it|null|occurrence|this|true|void)\b', Keyword.Constant),
+Keyword.Declaration),
-			 (r'(agent|annotation|artifact|behavior|capacity|class|enum|event|interface|skill|space)(\s+)', bygroups(Keyword.Declaration, Text),
+(r'(boolean|byte|char|double|float|int|long|short|void)\b',
-			  'class'),
+Keyword.Type),
-			 (r'(import)(\s+)', bygroups(Keyword.Namespace, Text), 'import'),
+(r'(package)(\s+)', bygroups(Keyword.Namespace, Text)),
-			 (r'"(\\\\|\\"|[^"])*"', String),
+(r'(false|it|null|occurrence|this|true|void)\b', Keyword.Constant),
-			 (r"'(\\\\|\\'|[^'])*'", String),
+(r'(agent|annotation|artifact|behavior|capacity|class|enum|event|'
-			 (r'[a-zA-Z_]\w*:', Name.Label),
+r'interface|skill|space)(\s+)', bygroups(Keyword.Declaration, Text),
-			 (r'[a-zA-Z_$]\w*', Name),
+'class'),
-			 (r'[~^*!%&\[\](){}<>\|+=:;,./?-]', Operator),
+(r'(import)(\s+)', bygroups(Keyword.Namespace, Text), 'import'),
-			 (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
+(r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
-			 (r'0x[0-9a-fA-F]+', Number.Hex),
+(r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
-			 (r'[0-9]+L?', Number.Integer),
+(r'[a-zA-Z_]\w*:', Name.Label),
-			 (r'\n', Text)
+(r'[a-zA-Z_$]\w*', Name),
-		],
+(r'[~^*!%&\[\](){}<>\|+=:;,./?-]', Operator),
-		'class': [
+(r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
-			(r'[a-zA-Z_]\w*', Name.Class, '#pop')
+(r'0x[0-9a-fA-F]+', Number.Hex),
-		],
+(r'[0-9]+L?', Number.Integer),
-		'import': [
+(r'\n', Text)
-			(r'[\w.]+\*?', Name.Namespace, '#pop')
+],
-		],
+'class': [
-	}
+(r'[a-zA-Z_]\w*', Name.Class, '#pop')
+],
+'import': [
+(r'[\w.]+\*?', Name.Namespace, '#pop')
+],
+}

Mercurial Repositories > eric / file comparison

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

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