143 lines
4.9 KiB
Python
143 lines
4.9 KiB
Python
"""
|
|
pygments.lexers.cel
|
|
~~~~~~~~~~~~~~~~~~~
|
|
|
|
Lexer for CEL (Common Expression Language).
|
|
|
|
:copyright: Copyright 2006-present by the Pygments team, see AUTHORS.
|
|
:license: BSD, see LICENSE for details.
|
|
"""
|
|
|
|
__all__ = ['CELLexer']
|
|
|
|
import re
|
|
|
|
from pygments.lexer import RegexLexer, words
|
|
from pygments.token import (
|
|
Comment, Keyword, Name, Number, Operator, Punctuation, String, Whitespace,
|
|
)
|
|
|
|
|
|
class CELLexer(RegexLexer):
|
|
"""Lexer for CEL (Common Expression Language)."""
|
|
|
|
name = 'CEL'
|
|
aliases = ['cel']
|
|
filenames = ['*.cel']
|
|
mimetypes = []
|
|
url = 'https://cel.dev'
|
|
version_added = '2.21'
|
|
|
|
flags = re.MULTILINE | re.UNICODE
|
|
|
|
# Escape sequence per the CEL spec:
|
|
# \a \b \f \n \r \t \v \\ \" \' \` \?
|
|
# \xHH or \XHH (exactly 2 hex digits)
|
|
# \uHHHH (exactly 4 hex digits)
|
|
# \UHHHHHHHH (exactly 8 hex digits)
|
|
# \OOO (3-digit octal, first digit 0-3)
|
|
# \. (fallback for unknown escapes)
|
|
_ESCAPE = r"""\\(?:[abfnrtv\\"'`?]|[xX][0-9a-fA-F]{2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|[0-3][0-7][0-7]|.)"""
|
|
|
|
# Raw prefix: r/R alone, or b/B combined with r/R in either order
|
|
_RAW = r'(?:[bB][rR]|[rR][bB]|[rR])'
|
|
|
|
tokens = {
|
|
'root': [
|
|
(r'\s+', Whitespace),
|
|
# CEL only has line comments; no block comments.
|
|
(r'//.*$', Comment.Single),
|
|
|
|
# Bytes and string literals.
|
|
# Raw variants (no escape processing) must be tried before
|
|
# non-raw so that br/rb/r prefixes are consumed greedily.
|
|
# Triple-quoted raw (br""", rb""", r""")
|
|
(_RAW + r'"""', String, 'triple-double-raw'),
|
|
(_RAW + r"'''", String, 'triple-single-raw'),
|
|
# Triple-quoted non-raw with optional b prefix (b""" or """)
|
|
(r'[bB]?"""', String, 'triple-double'),
|
|
(r"[bB]?'''", String, 'triple-single'),
|
|
# Single-line raw
|
|
(_RAW + r'"[^"\r\n]*"', String),
|
|
(_RAW + r"'[^'\r\n]*'", String),
|
|
# Single-line non-raw with optional b prefix
|
|
(r'[bB]?"', String, 'double-string'),
|
|
(r"[bB]?'", String, 'single-string'),
|
|
|
|
# Numbers.
|
|
# uint_literal: integer (decimal or hex) followed by u/U suffix.
|
|
(r'(?:0[xX][0-9a-fA-F]+|0|[1-9][0-9]*)[uU]', Number.Integer),
|
|
# float_literal: the grammar requires digits on both sides of the
|
|
# decimal point for the dotted form — `1.` is not valid CEL.
|
|
(r'(?:[0-9]+\.[0-9]+(?:[eE][+-]?[0-9]+)?'
|
|
r'|[0-9]+[eE][+-]?[0-9]+'
|
|
r'|\.[0-9]+(?:[eE][+-]?[0-9]+)?)',
|
|
Number.Float),
|
|
# int_literal: hex or decimal.
|
|
(r'0[xX][0-9a-fA-F]+|0|[1-9][0-9]*', Number.Integer),
|
|
|
|
# Reserved keywords (may not appear as identifiers).
|
|
(words((
|
|
'as', 'break', 'const', 'continue', 'else', 'for',
|
|
'function', 'if', 'import', 'let', 'loop', 'namespace',
|
|
'package', 'return', 'var', 'void', 'while',
|
|
), suffix=r'\b'), Keyword.Reserved),
|
|
# `in` is a comparison operator keyword.
|
|
(r'in\b', Keyword),
|
|
# Built-in literal constants.
|
|
(words(('true', 'false', 'null'), suffix=r'\b'), Keyword.Constant),
|
|
|
|
# Logical and comparison operators.
|
|
(r'&&|\|\|', Operator),
|
|
(r'==|!=|<=|>=', Operator),
|
|
# Arithmetic, unary, ternary, and remaining comparison operators.
|
|
(r'[+\-*/%<>!?]', Operator),
|
|
|
|
# Punctuation: brackets, comma, dot, colon.
|
|
(r'[(){}\[\]]', Punctuation),
|
|
(r'[,.]', Punctuation),
|
|
(r':', Punctuation),
|
|
|
|
# Identifiers: start with letter or underscore (Unicode-aware).
|
|
(r'[^\W\d]\w*', Name),
|
|
],
|
|
|
|
# Raw triple-quoted (no escape tokens; content is one big String).
|
|
'triple-double-raw': [
|
|
(r'"""', String, '#pop'),
|
|
(r'"(?!"")', String),
|
|
(r'[^"]+', String),
|
|
],
|
|
'triple-single-raw': [
|
|
(r"'''", String, '#pop'),
|
|
(r"'(?!'')", String),
|
|
(r"[^']+", String),
|
|
],
|
|
|
|
# Non-raw triple-quoted (escape sequences highlighted separately).
|
|
'triple-double': [
|
|
(r'"""', String, '#pop'),
|
|
(_ESCAPE, String.Escape),
|
|
(r'"(?!"")', String),
|
|
(r'[^"\\]+', String),
|
|
],
|
|
'triple-single': [
|
|
(r"'''", String, '#pop'),
|
|
(_ESCAPE, String.Escape),
|
|
(r"'(?!'')", String),
|
|
(r"[^'\\]+", String),
|
|
],
|
|
|
|
# Single-line non-raw strings (cannot span lines).
|
|
'double-string': [
|
|
(r'"', String, '#pop'),
|
|
(_ESCAPE, String.Escape),
|
|
(r'[^"\\\r\n]+', String),
|
|
],
|
|
'single-string': [
|
|
(r"'", String, '#pop'),
|
|
(_ESCAPE, String.Escape),
|
|
(r"[^'\\\r\n]+", String),
|
|
],
|
|
}
|