def register(cls, symbol, **kwargs):
"""
Register/update a token class in the symbol table.
:param symbol: The identifier symbol for a new class or an existent token class.
:param kwargs: Optional attributes/methods for the token class.
:return: A token class.
"""
try:
try:
if ' ' in symbol:
raise ValueError("%r: a symbol can't contain whitespaces" % symbol)
except TypeError:
assert isinstance(symbol, type) and issubclass(symbol, Token), \
"A %r subclass requested, not %r." % (Token, symbol)
symbol, token_class = symbol.symbol, symbol
assert symbol in cls.symbol_table and cls.symbol_table[symbol] is token_class, \
"Token class %r is not registered." % token_class
else:
token_class = cls.symbol_table[symbol]
except KeyError:
# Register a new symbol and create a new custom class. The new class
# name is registered at parser class's module level.
if symbol not in cls.SYMBOLS:
raise NameError('%r is not a symbol of the parser %r.' % (symbol, cls))
kwargs['symbol'] = symbol
label = kwargs.get('label', 'symbol')
if isinstance(label, tuple):
label = kwargs['label'] = MultiLabel(*label)
token_class_name = "_{}{}".format(
symbol_to_classname(symbol), str(label).title().replace(' ', '')
)
token_class_bases = kwargs.get('bases', (cls.token_base_class,))
kwargs.update({
'__module__': cls.__module__,
'__qualname__': token_class_name,
'__return__': None
})
token_class = ABCMeta(token_class_name, token_class_bases, kwargs)
cls.symbol_table[symbol] = token_class
MutableSequence.register(token_class)
setattr(sys.modules[cls.__module__], token_class_name, token_class)
else:
for key, value in kwargs.items():
if key == 'lbp' and value > token_class.lbp:
token_class.lbp = value
elif key == 'rbp' and value > token_class.rbp:
token_class.rbp = value
elif callable(value):
setattr(token_class, key, value)
return token_class
def schema_constructor(self, atomic_type_name: str, bp: int = 90) \
-> Type[XPathFunction]:
"""Registers a token class for a schema atomic type constructor function."""
if atomic_type_name in (XSD_ANY_ATOMIC_TYPE, XSD_NOTATION):
raise xpath_error('XPST0080')
def nud_(self_: XPathFunction) -> XPathFunction:
self_.parser.advance('(')
self_[0:] = self_.parser.expression(5),
self_.parser.advance(')')
try:
self_.value = self_.evaluate() # Static context evaluation
except MissingContextError:
self_.value = None
return self_
def evaluate_(self_: XPathFunction, context: Optional[XPathContext] = None) \
-> Union[List[None], AtomicValueType]:
arg = self_.get_argument(context)
if arg is None or self_.parser.schema is None:
return []
value = self_.string_value(arg)
try:
return self_.parser.schema.cast_as(value, atomic_type_name)
except (TypeError, ValueError) as err:
raise self_.error('FORG0001', err)
symbol = get_prefixed_name(atomic_type_name, self.namespaces)
token_class_name = "_%sConstructorFunction" % symbol.replace(':', '_')
kwargs = {
'symbol': symbol,
'nargs': 1,
'label': 'constructor function',
'pattern': r'\b%s(?=\s*\(|\s*\(\:.*\:\)\()' % symbol,
'lbp': bp,
'rbp': bp,
'nud': nud_,
'evaluate': evaluate_,
'__module__': self.__module__,
'__qualname__': token_class_name,
'__return__': None
}
token_class = cast(
Type[XPathFunction],
ABCMeta(token_class_name, (XPathFunction, ), kwargs))
MutableSequence.register(token_class)
self.symbol_table[symbol] = token_class
return token_class
def schema_constructor(self, atomic_type, bp=90):
"""Registers a token class for a schema atomic type constructor function."""
if atomic_type in {XSD_ANY_ATOMIC_TYPE, XSD_NOTATION}:
raise xpath_error('XPST0080')
def nud_(self_):
self_.parser.advance('(')
self_[0:] = self_.parser.expression(5),
self_.parser.advance(')')
try:
self_.value = self_.evaluate() # Static context evaluation
except MissingContextError:
self_.value = None
return self_
def evaluate_(self_, context=None):
arg = self_.get_argument(context)
if arg is None:
return []
value = self_.string_value(arg)
try:
return self_.parser.schema.cast_as(value, atomic_type)
except (TypeError, ValueError) as err:
raise self_.error('FORG0001', err)
symbol = get_prefixed_name(atomic_type, self.namespaces)
token_class_name = str("_%s_constructor_token" %
symbol.replace(':', '_'))
kwargs = {
'symbol': symbol,
'label': 'constructor function',
'pattern': r'\b%s(?=\s*\(|\s*\(\:.*\:\)\()' % symbol,
'lbp': bp,
'rbp': bp,
'nud': nud_,
'evaluate': evaluate_,
'__module__': self.__module__,
'__qualname__': token_class_name,
'__return__': None
}
token_class = ABCMeta(token_class_name, (self.token_base_class, ),
kwargs)
MutableSequence.register(token_class)
self.symbol_table[symbol] = token_class
return token_class
def __jclass_init__(self):
Sequence.register(self)
MutableSequence.register(self)
"""
Helper classmethod to construct a ``ParseResults`` from a ``dict``, preserving the
name-value relations as results names. If an optional ``name`` argument is
given, a nested ``ParseResults`` will be returned.
"""
def is_iterable(obj):
try:
iter(obj)
except Exception:
return False
else:
return not isinstance(obj, str_type)
ret = cls([])
for k, v in other.items():
if isinstance(v, Mapping):
ret += cls.from_dict(v, name=k)
else:
ret += cls([v], name=k, asList=is_iterable(v))
if name is not None:
ret = cls([ret], name=name)
return ret
asList = as_list
asDict = as_dict
getName = get_name
MutableMapping.register(ParseResults)
MutableSequence.register(ParseResults)
def extend(self, values):
end = len(self._items)
self[end:end] = values
pop = MutableSequence.pop
remove = MutableSequence.remove
__iadd__ = MutableSequence.__iadd__
# convenience
def clear(self):
del self[:]
MutableSequence.register(List)
class Selection(List):
"""Set of items with the additional notion of a cursor to the least
recently *active* element. Each item can occur only once in the set.
Note that the inherited ``List`` methods and signals can be used to listen
for selection changes, and to query or delete items. However, for
*inserting* or *modifying* elements, only use the methods defined in the
``Selection`` class can be used to ensure that items stay unique.
"""
def __init__(self):
super().__init__()
def register(cls, symbol, **kwargs):
"""
Register/update a token class in the symbol table.
:param symbol: The identifier symbol for a new class or an existent token class.
:param kwargs: Optional attributes/methods for the token class.
:return: A token class.
"""
def symbol_escape(s):
s = re.escape(s)
s.replace(r'\ ', r'\s+')
if s.isalpha():
s = r'\b%s\b(?![\-\.])' % s
elif s[-2:] == r'\(':
s = r'%s\s*%s' % (s[:-2], s[-2:])
elif s[-4:] == r'\:\:':
s = r'%s\s*%s' % (s[:-4], s[-4:])
return s
try:
try:
if ' ' in symbol:
raise ValueError(
"%r: a symbol can't contains whitespaces." % symbol)
except TypeError:
assert isinstance(symbol, type) and issubclass(symbol, Token), \
"A %r subclass requested, not %r." % (Token, symbol)
symbol, token_class = symbol.symbol, symbol
assert symbol in cls.symbol_table and cls.symbol_table[symbol] is token_class, \
"Token class %r is not registered." % token_class
else:
token_class = cls.symbol_table[symbol]
except KeyError:
# Register a new symbol and create a new custom class. The new class
# name is registered at parser class's module level.
if symbol not in cls.SYMBOLS:
raise NameError('%r is not a symbol of the parser %r.' %
(symbol, cls))
kwargs['symbol'] = symbol
if 'pattern' not in kwargs:
pattern = symbol_escape(
symbol) if len(symbol) > 1 else re.escape(symbol)
kwargs['pattern'] = pattern
label = kwargs.get('label', 'symbol')
if isinstance(label, tuple):
label = kwargs['label'] = MultiLabel(*label)
token_class_name = "_{}_{}_token".format(
symbol_to_identifier(symbol),
str(label).replace(' ', '_'))
token_class_bases = (getattr(cls, 'token_base_class', object), )
kwargs.update({
'__module__': cls.__module__,
'__qualname__': token_class_name,
'__return__': None
})
token_class = ABCMeta(token_class_name, token_class_bases, kwargs)
cls.symbol_table[symbol] = token_class
MutableSequence.register(token_class)
setattr(sys.modules[cls.__module__], token_class_name, token_class)
else:
for key, value in kwargs.items():
if key == 'lbp' and value > token_class.lbp:
token_class.lbp = value
elif key == 'rbp' and value > token_class.rbp:
token_class.rbp = value
elif callable(value):
setattr(token_class, key, value)
return token_class
@staticmethod
def _c_one_lsb(index: int, stop: int = 0) -> _Gen:
""" Consuming set bits starting from LSB."""
while index > stop:
yield index
index &= index - 1
@staticmethod
def _c_zero_lsb(index: int, start: int = 2) -> _Gen:
""" Yields powers of two that perfectly divide index.
Consuming unset bits starting from LSB.
"""
while index & 1 == 0:
yield start // 2
start <<= 1
index >>= 1
@staticmethod
def _nmlz_index(index: int, length: int) -> int:
""" Normalize index, bringing it in [0, len(self)),
IndexError is raised if index is out of bounds.
"""
index = index + length if index < 0 else index
if index >= length or length == 0:
raise IndexError("Index out of range.")
return index
# Register as virtual subclass.
MutableSequence.register(BIT)
return getattr(self, '_{}'.format(idx))
def __repr__(self):
with stringify_context(self) as nested:
cls = type(self).__qualname__
if nested:
return "@{}".format(get_short_id(self))
else:
return "{}@{}({})".format(
cls,
get_short_id(self),
repr(list(self)),
)
MutableSequence.register(ManagedList)
# ------------- TEST -------------------
class Test(Managed):
def init(self):
self.a = 1
self.a = 2
self.node = self._resmngr.new(Node, 123)
self.more = self._resmngr.new_list([
self._resmngr.new(Node, 100),
self._resmngr.new(Node, 200),
])
def extend(self, values):
end = len(self._items)
self[end:end] = values
pop = MutableSequence.pop
remove = MutableSequence.remove
__iadd__ = MutableSequence.__iadd__
# convenience
def clear(self):
del self[:]
MutableSequence.register(List)
class Selection(List):
"""Set of items with the additional notion of a cursor to the least
recently *active* element. Each item can occur only once in the set.
Note that the inherited ``List`` methods and signals can be used to listen
for selection changes, and to query or delete items. However, for
*inserting* or *modifying* elements, only use the methods defined in the
``Selection`` class can be used to ensure that items stay unique.
"""
def __init__(self):
super().__init__()
