File: C:/Users/fred/anaconda3/Lib/site-packages/sipbuild/generator/parser/parser_manager.py
# Copyright (c) 2023, Riverbank Computing Limited
# All rights reserved.
#
# This copy of SIP is licensed for use under the terms of the SIP License
# Agreement. See the file LICENSE for more details.
#
# This copy of SIP may also used under the terms of the GNU General Public
# License v2 or v3 as published by the Free Software Foundation which can be
# found in the files LICENSE-GPL2 and LICENSE-GPL3 included in this package.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
from functools import partial
import os
from ply import lex, yacc
from ...bindings_configuration import get_bindings_configuration
from ...exceptions import UserException
from ..error_log import ErrorLog
from ..instantiations import instantiate_class
from ..python_slots import invalid_global_slot, slot_name_detail_map
from ..scoped_name import ScopedName
from ..specification import (AccessSpecifier, Argument, ArgumentType,
ArrayArgument, CachedName, ClassKey, CodeBlock, Constructor,
DocstringFormat, DocstringSignature, EnumBaseType, GILAction,
IfaceFile, IfaceFileType, KwArgs, MappedType, Member, Module, Overload,
PyQtMethodSpecifier, PySlot, Qualifier, QualifierType, Signature,
SourceLocation, Specification, Transfer, TypeHints, WrappedClass,
WrappedException, WrappedEnum, WrappedEnumMember)
from ..templates import encoded_template_name, same_template_signature
from ..utils import (argument_as_str, cached_name, find_iface_file,
normalised_scoped_name, same_base_type)
from . import rules
from . import tokens
from .annotations import InvalidAnnotation, validate_annotation_value
class ParserManager:
""" This object manages the actual lexer and parser objects providing them
with state and utility functions.
"""
def __init__(self, hex_version, encoding, abi_version, tags,
disabled_features, protected_is_public, include_dirs, sip_module,
is_strict):
""" Initialise the manager. """
# Create the lexer.
self._lexer = lex.lex(module=tokens)
self._lexer.pm = self
# Create the parser.
self._parser = yacc.yacc(module=rules, debug=False)
self._parser.pm = self
# This is a hack to give p_error() access to the current parser object.
rules.parser = self._parser
# The list of class templates. Each element is a 2-tuple of the
# template arguments and the class itself.
self.class_templates = []
# Public state.
self.tags = tags
self.spec = Specification(
tuple([int(v) for v in abi_version.split('.')]), is_strict,
sip_module)
# The module is initially unnamed.
self.modules = [self.spec.module]
self.c_bindings = None
self.code_block = None
self.module_state = None
self.paren_depth = 0
self.parsing_template = False
self.parsing_virtual = False
self.raw_sip_file = None
self.skip_stack = [False]
# Private state.
self._hex_version = hex_version
self._encoding = encoding
self._disabled_features = disabled_features
self._protected_is_public = protected_is_public
self._include_dirs = include_dirs
self._template_arg_classes = []
self._scope_stack = []
self._error_log = ErrorLog()
self._file_stack = []
self._pending_module_state = None
self._input = None
self._all_sip_files = []
self._sip_file = None
self._sip_files = []
def complete_class(self, p, symbol, annotations, has_body):
""" Complete the definition of the class that is the current scope, pop
it and return it.
"""
klass = self.scope
if has_body:
if klass.scope is not None:
if klass.iface_file.fq_cpp_name.scope != klass.scope.iface_file.fq_cpp_name:
self.parser_error(p, symbol,
"a scoped name cannot be specified in the definition of a class/struct/union")
elif len(klass.superclasses) != 0:
self.parser_error(p, symbol,
"the class/struct has super-classes but no definition");
else:
klass.is_opaque = True
# Get the Python name and see if it is different to the C++ name.
py_name = self.get_py_name(klass.iface_file.fq_cpp_name.base_name,
annotations)
klass.py_name = cached_name(self.spec, py_name)
klass.no_type_hint = annotations.get('NoTypeHint', False)
metatype = annotations.get('Metatype')
if metatype is not None:
klass.metatype = cached_name(self.spec, metatype)
supertype = annotations.get('Supertype')
if supertype is not None:
klass.supertype = cached_name(self.spec, supertype)
klass.export_derived = annotations.get('ExportDerived', False)
klass.mixin = annotations.get('Mixin', False)
file_extension = annotations.get('FileExtension')
if file_extension is not None:
klass.iface_file.file_extension = file_extension
pyqt_flags_enums = self._get_plugin_annotation(p, symbol, annotations,
'PyQtFlagsEnums', 'PyQt5')
if pyqt_flags_enums is not None:
klass.pyqt_flags_enums = pyqt_flags_enums
klass.pyqt_flags = 1
pyqt_flags = self._get_plugin_annotation(p, symbol, annotations,
'PyQtFlags', 'PyQt5')
if pyqt_flags is not None:
klass.pyqt_flags = pyqt_flags
klass.pyqt_no_qmetaobject = annotations.get('PyQtNoQMetaObject', False)
klass.pyqt_interface = annotations.get('PyQtInterface')
if klass.is_opaque:
klass.external = annotations.get('External', False)
else:
# A default dtor is public.
if klass.dtor is None:
klass.dtor = AccessSpecifier.PUBLIC
klass.no_default_ctors = annotations.get('NoDefaultCtors', False)
# Provide a default ctor if required.
if len(klass.ctors) == 0 and not klass.no_default_ctors:
signature = Signature(result=Argument(ArgumentType.VOID))
ctor = Constructor(AccessSpecifier.PUBLIC,
py_signature=signature, cpp_signature=signature)
klass.default_ctor = ctor
klass.ctors.append(ctor)
klass.can_create = True
# Determine the default ctor if required.
if klass.default_ctor is None:
last_resort = None
for ctor in klass.ctors:
if ctor.access_specifier is not AccessSpecifier.PUBLIC:
continue
if len(ctor.py_signature.args) == 0 or ctor.py_signature.args[0].default_value is not None:
klass.default_ctor = ctor
break
# The last resort is the first public ctor.
if last_resort is None:
last_resort = ctor
else:
klass.default_ctor = last_resort
klass.deprecated = annotations.get('Deprecated', False)
if klass.convert_to_type_code is not None and annotations.get('AllowNone', False):
klass.handles_none = True
if annotations.get('Abstract', False):
klass.is_abstract = True
klass.is_incomplete = True
klass.can_create = False
klass.delay_dtor = annotations.get('DelayDtor', False)
if klass.delay_dtor:
self.module_state.module.has_delayed_dtors = True
# There are subtle differences between the add and concat methods
# and the multiply and repeat methods. The number versions can
# have their operands swapped and may return NotImplemented. If
# the user has used the /Numeric/ annotation or there are other
# numeric operators then we use add/multiply. Otherwise, if the
# user has used the /Sequence/ annotation or there are indexing
# operators then we use concat/repeat.
seq_might = seq_not = False
for md in klass.members:
if md.py_slot in (PySlot.GETITEM, PySlot.SETITEM, PySlot.DELITEM):
# This might be a sequence.
seq_might = True
if md.py_slot in (PySlot.SUB, PySlot.ISUB, PySlot.MOD, PySlot.IMOD, PySlot.FLOORDIV, PySlot.IFLOORDIV, PySlot.TRUEDIV, PySlot.ITRUEDIV, PySlot.POS, PySlot.NEG):
# This is definately not a sequence.
seq_not = True
default_to_sequence = (not seq_not and seq_might)
for md in klass.members:
# Ignore if it is explicitly numeric.
if md.is_numeric:
continue
if md.is_sequence or default_to_sequence:
if md.py_slot is PySlot.ADD:
md.py_slot = PySlot.CONCAT
elif md.py_slot is PySlot.IADD:
md.py_slot = PySlot.ICONCAT
elif md.py_slot is PySlot.MUL:
md.py_slot = PySlot.REPEAT
elif md.py_slot is PySlot.IMUL:
md.py_slot = PySlot.IREPEAT
if self.in_main_module:
klass.iface_file.cpp_name.used = True
klass.py_name.used = True
self.pop_scope()
# Check the name in the current scope (ie. the class's parent scope).
self.check_attributes(p, symbol, py_name, ignore=klass)
# Check that external classes have only been declared at the global
# scope.
if klass.external and self.scope is not None:
self.parser_error(p, symbol,
"/External/ classes/structs/unions can only be declared in the global scope")
return klass
def define_class(self, p, symbol, class_key, scoped_name, annotations,
superclasses=None):
""" Create a new class and make it the current scope. """
klass = self.new_class(p, symbol, IfaceFileType.CLASS,
normalised_scoped_name(scoped_name, self.scope),
virtual_error_handler=annotations.get('VirtualErrorHandler'),
type_hints=self.get_type_hints(p, symbol, annotations))
klass.class_key = class_key
klass.superclasses = superclasses
self.push_scope(klass,
AccessSpecifier.PRIVATE if class_key is ClassKey.CLASS else AccessSpecifier.PUBLIC)
def disambiguate_token(self, value, keywords):
""" Disambiguate a token by inspecting its value. """
# This seems to be needed because it's not possible to get lex() to do
# it. The problem seems to be that you can't control the order in
# which lex() applies its regular expressions despite what the
# documentation says. It seems that tokens that are specific to a
# state are always added after everything else no matter where they
# appear in the file.
if value in keywords:
token_type = value
elif value == '...':
token_type = 'ELLIPSIS'
elif value.startswith('.'):
token_type = 'FILE_PATH'
else:
for marker in ('/', '..', '-'):
if marker in value:
token_type = 'FILE_PATH'
break
else:
if '.' in value:
token_type = 'DOTTED_NAME'
else:
token_type = 'NAME'
return token_type
def find_class(self, p, symbol, iface_file_type, fq_cpp_name,
tmpl_arg=False):
""" Return a WrappedClass object for a C++ name creating it if
necessary.
"""
return self._find_class_with_iface_file(
self.find_iface_file(p, symbol, fq_cpp_name, iface_file_type),
tmpl_arg=tmpl_arg)
def find_exception(self, p, symbol, fq_cpp_name, raise_code=None):
""" Find an exception, optionally creating a new one. """
# Note that we don't normalise the name.
iface_file = self.find_iface_file(p, symbol, fq_cpp_name,
IfaceFileType.EXCEPTION)
# See if it is an existing one.
for w_exception in self.spec.exceptions:
if w_exception.iface_file is iface_file:
return w_exception
# If it is an exception interface file then we have never seen this
# name before. We require that exceptions are defined before being
# used, but don't make the same requirement of classes (for reasons of
# backwards compatibility). Therefore the name must be reinterpreted
# as a (as yet undefined) class.
if raise_code is not None:
if iface_file.type is not IfaceFileType.EXCEPTION:
self.parser_error(p, symbol,
"there is already a class with the same name or the exception has been used before being defined")
class_exception = None
else:
# The C++ name must be the name of a class which implements an
# exception.
if iface_file.type is IfaceFileType.EXCEPTION:
iface_file.type = IfaceFileType.CLASS
class_exception = self._find_class_with_iface_file(iface_file)
# Create a new one.
w_exception = WrappedException(iface_file, raise_code,
class_exception=class_exception)
self.spec.exceptions.append(w_exception)
return w_exception
def new_class(self, p, symbol, iface_file_type, fq_cpp_name,
virtual_error_handler=None, type_hints=None):
""" Create a new, unannotated class and add it to the current scope.
"""
if self.scope_access_specifier is AccessSpecifier.PRIVATE:
self.parser_error(p, symbol,
"classes, structs, unions and namespaces must be in the public or protected sections")
scope = self.scope
if scope is not None:
if self.scope_access_specifier is AccessSpecifier.PROTECTED and not self._protected_is_public:
scope.is_protected = True
if iface_file_type is IfaceFileType.CLASS:
scope.needs_shadow = True
# Header code from outer scopes is also included.
type_header_code = scope.iface_file.type_header_code
else:
type_header_code = None
if bool(self.c_bindings):
# C structs and unions are always global types no matter where they
# are defined.
fq_cpp_name = ScopedName(fq_cpp_name.base_name)
scope = None
klass = self.find_class(p, symbol, iface_file_type, fq_cpp_name)
# Check it hasn't already been defined.
if iface_file_type is not IfaceFileType.NAMESPACE and klass.iface_file.module is not None:
self.parser_error(p, symbol,
"the class/struct/union has already been defined")
# Complete the initialisation.
klass.scope = scope
klass.iface_file.module = self.module_state.module
klass.virtual_error_handler = virtual_error_handler
klass.type_hints = type_hints
if type_header_code is not None:
klass.iface_file.type_header_code.extend(type_header_code)
# See if it is a namespace extender.
if iface_file_type is IfaceFileType.NAMESPACE:
for ns in self.spec.classes:
if ns is klass:
continue
if ns.iface_file.type is not IfaceFileType.NAMESPACE:
continue
if ns.iface_file.fq_cpp_name != klass.iface_file.fq_cpp_name:
continue
klass.real_class = ns
if self.in_main_module:
ns.iface_file.needed = True
return klass
def _find_class_with_iface_file(self, iface_file, tmpl_arg=False):
""" Return a WrappedClass object for an interface file creating it if
necessary.
"""
# See if it already exists.
for klass in self.spec.classes:
if klass.iface_file is iface_file:
if not self.parsing_template:
try:
self._template_arg_classes.remove(klass)
except ValueError:
pass
return klass
# Create a new one.
klass = WrappedClass(iface_file,
cached_name(self.spec, iface_file.fq_cpp_name.base_name), None)
if tmpl_arg:
self._template_arg_classes.append(klass)
# Use the same ordering as the old parser.
self.spec.classes.insert(0, klass)
return klass
def add_ctor(self, p, symbol, arg_list, annotations, *, exceptions,
cpp_signature, docstring, premethod_code, method_code):
""" Create a Constructor and add it to the current scope. """
scope = self.scope
# Error checks.
if p[symbol] != scope.iface_file.fq_cpp_name.base_name:
self.parser_error(p, symbol,
"constructor doesn't have the same name as its class")
if bool(self.c_bindings) and len(arg_list) != 0 and method_code is None:
self.parser_error(p, symbol,
"constructors with arguments in C modules must specify %MethodCode")
if self.scope_pyqt_method_specifier is not None:
self.parser_error(p, symbol,
"constructors must be in the public, protected or private sections")
# Handle the access specifier.
access_specifier = self.scope_access_specifier
if access_specifier is AccessSpecifier.PROTECTED and self._protected_is_public:
access_specifier = AccessSpecifier.PUBLIC
# Handle the signatures allowing it to be used like a function
# signature.
py_signature = Signature(args=arg_list,
result=Argument(ArgumentType.VOID))
self._check_ellipsis(p, symbol, py_signature)
# Configure the constructor.
ctor = Constructor(access_specifier, py_signature)
if annotations.get("NoDerived", False):
if cpp_signature is not None:
self.parser_error(p, symbol,
"/NoDerived/ may not be specified with an explicit C++ signature")
if method_code is None:
self.parser_error(p, symbol,
"%MethodCode must also be specified if /NoDerived/ is specified")
elif cpp_signature is None:
ctor.cpp_signature = py_signature
else:
self._check_ellipsis(p, symbol, cpp_signature)
ctor.cpp_signature = cpp_signature
if annotations.get("Default", False):
if scope.default_ctor is None:
scope.default_ctor = ctor
else:
self.parser_error(p, symbol,
"/Default/ has already been specified for another constructor")
ctor.docstring = docstring
ctor.gil_action = self._get_gil_action(p, symbol, annotations)
ctor.deprecated = annotations.get('Deprecated', False)
if access_specifier is not AccessSpecifier.PRIVATE:
ctor.kw_args = self._get_kw_args(p, symbol, annotations,
py_signature)
scope.can_create = True
if access_specifier is AccessSpecifier.PROTECTED:
scope.needs_shadow = True
ctor.method_code = method_code
ctor.no_type_hint = annotations.get('NoTypeHint', False)
ctor.posthook = annotations.get('PostHook')
ctor.prehook = annotations.get('PreHook')
ctor.premethod_code = premethod_code
ctor.throw_args = exceptions
if method_code is None and annotations.get('NoRaisesPyException') is None:
if self.module_state.all_raise_py_exception or annotations.get('RaisesPyException', False):
ctor.raises_py_exception = True
ctor.transfer = self.get_transfer(p, symbol, annotations)
scope.ctors.append(ctor)
def add_dtor(self, p, symbol, name, annotations, *, exceptions,
abstract, premethod_code, method_code, virtual_catcher_code):
""" Add a dtor to the current scope. """
scope = self.scope
# Error checks.
if name != scope.iface_file.fq_cpp_name.base_name:
self.parser_error(p, symbol,
"destructor doesn't have the same name as its class")
if scope.dtor is not None:
self.parser_error(p, symbol, "destructor has already been defined")
if bool(self.c_bindings) and method_code is None:
self.parser_error(p, symbol,
"destructors in C modules must specify %MethodCode")
if self.scope_pyqt_method_specifier is not None:
self.parser_error(p, symbol,
"destructors must be in the public, protected or private sections")
if self.parsing_virtual:
if self.scope.class_key is ClassKey.UNION:
self.parser_error(p, symbol,
"a union cannot have a virtual destructor")
if virtual_catcher_code is not None:
self.parser_error(p, symbol,
"destructors in C modules cannot specify %VirtualCatcherCode")
elif abstract:
self.parser_error(p, symbol,
"an abstract destructor must be virtual")
# Configure the destructor.
scope.dtor = self.scope_access_specifier
scope.dtor_gil_action = self._get_gil_action(p, symbol, annotations)
scope.dtor_throw_args = exceptions
scope.dtor_virtual_catcher_code = virtual_catcher_code
if premethod_code is not None:
scope.dealloc_code.append(premethod_code)
if method_code is not None:
scope.dealloc_code.append(method_code)
if abstract:
scope.is_abstract = True
if self.parsing_virtual or len(scope.dealloc_code) != 0:
scope.needs_shadow = True
def add_enum(self, p, symbol, cpp_name, is_scoped, annotations, members):
""" Create a new enum and add it to the current scope. """
if self.scope_access_specifier is AccessSpecifier.PRIVATE:
self.parser_error(p, symbol, "class enums cannot be private")
if is_scoped:
self.cpp_only(p, symbol, "scoped enums")
# Determine the base type.
base_type_s = annotations.get('BaseType')
base_type = EnumBaseType.ENUM
if base_type_s is not None:
if self.spec.abi_version < (13, 0):
self.parser_error(p, symbol,
"/BaseType/ is only supported for ABI v13.0 and later")
if base_type_s == 'Enum':
base_type = EnumBaseType.ENUM
elif base_type_s == 'Flag':
base_type = EnumBaseType.FLAG
elif base_type_s == 'IntEnum':
base_type = EnumBaseType.INT_ENUM
elif base_type_s == 'UIntEnum':
base_type = EnumBaseType.UNSIGNED_INT_ENUM
elif base_type_s == 'IntFlag':
base_type = EnumBaseType.INT_FLAG
else:
self.parser_error(p, 1,
"'{0}' is an invalid value of /BaseType/".format(
base_type_s))
if cpp_name is None:
fq_cpp_name = None
cached_fq_cpp_name = None
py_name = None
else:
fq_cpp_name = normalised_scoped_name(cpp_name, self.scope)
cached_fq_cpp_name = cached_name(self.spec, str(fq_cpp_name))
py_name = cached_name(self.spec,
self.get_py_name(cpp_name, annotations))
self.check_attributes(p, symbol, py_name)
if self.in_main_module:
cached_fq_cpp_name.used = True
py_name.used = True
w_enum = WrappedEnum(base_type, fq_cpp_name, self.module_state.module,
cached_fq_cpp_name=cached_fq_cpp_name, is_scoped=is_scoped,
py_name=py_name, scope=self.scope)
if self.scope_access_specifier is AccessSpecifier.PROTECTED:
if not self._protected_is_public:
w_enum.is_protected = True
self.scope.needs_shadow = True
w_enum.no_scope = annotations.get('NoScope', False)
w_enum.no_type_hint = annotations.get('NoTypeHint', False)
# Create the members.
for m_cpp_name, m_py_name, m_no_type_hint in members:
if not is_scoped:
self.check_attributes(p, symbol, m_py_name.name)
w_enum.members.append(
WrappedEnumMember(m_cpp_name, m_py_name, w_enum,
no_type_hint=m_no_type_hint))
if self.in_main_module:
m_py_name.used = True
self.spec.enums.insert(0, w_enum)
def add_function(self, p, symbol, cpp_name, result, arg_list, annotations,
*, const=False, final=False, exceptions=None, abstract=False,
cpp_signature=None, docstring=None, premethod_code=None,
method_code=None, virtual_catcher_code=None,
virtual_call_code=None):
""" Create and return an Overload and add it to the current scope. """
# Get the Python name.
py_name = self.get_py_name(cpp_name, annotations)
# Handle the signatures.
py_signature = Signature(args=arg_list, result=result)
self._check_ellipsis(p, symbol, py_signature)
if cpp_signature is None:
cpp_signature = py_signature
else:
self._check_ellipsis(p, symbol, cpp_signature)
# Find (or create) the member shared by overloads with the same Python
# name.
member = self._find_member(p, symbol, py_name, arg_list, annotations,
method_code)
# Create the overload.
overload = Overload(self.scope_access_specifier, member, cpp_name,
cpp_signature, py_signature)
for m in self.module_state.module.global_functions:
if m is member:
self.module_state.module.overloads.append(overload)
break
else:
self.scope.overloads.append(overload)
overload.pyqt_method_specifier = self.scope_pyqt_method_specifier
if overload.access_specifier is AccessSpecifier.PROTECTED and self._protected_is_public:
overload.access_specifier = AccessSpecifier.PUBLIC
overload.access_is_really_protected = True
if overload.access_specifier is AccessSpecifier.PROTECTED:
self.scope.needs_shadow = True
member.has_protected = True
if overload.access_specifier is AccessSpecifier.PUBLIC:
if overload.pyqt_method_specifier is PyQtMethodSpecifier.SIGNAL:
self.scope.needs_shadow = True
overload.docstring = docstring
overload.is_abstract = abstract
overload.is_const = const
overload.is_delattr = (py_name == '__delattr__')
overload.is_final = final
overload.premethod_code = premethod_code
overload.throw_args = exceptions
overload.virtual_call_code = virtual_call_code
overload.virtual_catcher_code = virtual_catcher_code
overload.source_location = self.get_source_location(p, symbol)
# See if the function is a non-lazy method. These are methods that
# Python expects to see defined in the type before any instance of the
# type is created.
if self.scope is not None:
NONLAZY_METHOD_NAMES = (
'__getattribute__',
'__getattr__',
'__enter__',
'__exit__',
'__aenter__',
'__aexit__',
)
if cpp_name in NONLAZY_METHOD_NAMES:
self.scope.has_nonlazy_method = True
# Handle any annotations.
overload.abort_on_exception = annotations.get('AbortOnException',
False)
auto_gen = annotations.get('AutoGen')
if auto_gen is not None:
overload.is_auto_generated = self.evaluate_feature_or_platform(p,
symbol, name=auto_gen)
overload.gil_action = self._get_gil_action(p, symbol, annotations)
overload.factory = annotations.get('Factory', False)
overload.deprecated = annotations.get('Deprecated', False)
overload.new_thread = annotations.get('NewThread', False)
overload.transfer = self.get_transfer(p, symbol, annotations)
if overload.access_specifier is not AccessSpecifier.PRIVATE:
if member.py_slot is None or member.py_slot is PySlot.CALL:
overload.kw_args = self._get_kw_args(p, symbol, annotations,
py_signature, need_name=member.has_protected)
if overload.kw_args is not KwArgs.NONE:
member.allow_keyword_args = True
# If the overload is protected and defined in an imported
# module then we need to make sure that any other overloads'
# keyword argument names are marked as used.
if overload.pyqt_method_specifier is not PyQtMethodSpecifier.SIGNAL and overload.access_specifier is AccessSpecifier.PROTECTED and not self.in_main_module:
for kwod in self.scope.overloads:
if kwod.common is not member:
continue
if kwod.kw_args is KwArgs.NONE:
continue
for arg in kwod.py_signature.args:
if kwod.kw_args is KwArgs.OPTIONAL and arg.default_value is None:
continue
if arg.name is not None:
arg.name.used = True
overload.no_type_hint = annotations.get('NoTypeHint', False)
overload.posthook = annotations.get('PostHook')
overload.prehook = annotations.get('PreHook')
if method_code is None and annotations.get('NoRaisesPyException') is None:
if self.module_state.all_raise_py_exception or annotations.get('RaisesPyException', False):
overload.raises_py_exception = True
overload.virtual_error_handler = annotations.get('VirtualErrorHandler')
overload.no_virtual_error_handler = annotations.get(
'NoVirtualErrorHandler', False)
if annotations.get('Numeric', False):
if member.is_sequence:
self.parser_error(p, symbol,
"an overload has already specified /Sequence/")
else:
member.is_numeric = True
if annotations.get('Sequence', False):
if member.is_numeric:
self.parser_error(p, symbol,
"an overload has already specified /Numeric/")
else:
member.is_sequence = True
self.apply_common_argument_annotations(p, symbol,
overload.py_signature.result, annotations)
overload.method_code = method_code
# Add some auto-generated slots if required.
if '__len__' in annotations:
len_method_code = method_code
if len_method_code is None:
len_method_code = CodeBlock("Auto-generated",
text=' sipRes = (Py_ssize_t)sipCpp->{0}();\n'.format(cpp_name))
# Note that we can't currently use any %MethodCode because it
# does too much (ie. setting sipRes).
self.scope.len_cpp_name = cpp_name
len_py_signature = Signature(result=Argument(ArgumentType.SSIZE))
self._add_auto_slot(p, symbol, annotations, '__len__',
len_py_signature, len_py_signature, len_method_code)
if '__matmul__' in annotations:
self._add_auto_slot(p, symbol, annotations, '__matmul__',
py_signature, cpp_signature, method_code)
if '__imatmul__' in annotations:
self._add_auto_slot(p, symbol, annotations, '__imatmul__',
py_signature, cpp_signature, method_code)
return overload
def add_mapped_type(self, p, symbol, cpp_type, annotations):
""" Create a new mapped type and add it to the current scope. """
# Check the type is one we want to map.
if cpp_type.type is ArgumentType.DEFINED:
fq_cpp_name = cpp_type.definition = normalised_scoped_name(
cpp_type.definition, self.scope)
cpp_name = fq_cpp_name.base_name
elif cpp_type.type is ArgumentType.TEMPLATE:
cpp_type.definition.cpp_name = normalised_scoped_name(
cpp_type.definition.cpp_name, self.scope)
fq_cpp_name = encoded_template_name(cpp_type.definition)
cpp_name = None
elif cpp_type.type is ArgumentType.STRUCT:
fq_cpp_name = cpp_type.definition = normalised_scoped_name(
cpp_type.definition, self.scope)
cpp_name = fq_cpp_name.base_name
else:
self.parser_error(p, symbol, "invalid type for %MappedType")
fq_cpp_name = ''
iface_file = self.find_iface_file(p, symbol, fq_cpp_name,
IfaceFileType.MAPPED_TYPE, cpp_type=cpp_type)
# Check it hasn't already been defined.
for mtd in self.spec.mapped_types:
if mtd.iface_file is iface_file:
# We allow types based on the same template but with different
# arguments.
if cpp_type.type is not ArgumentType.TEMPLATE or same_base_type(cpp_type, mtd.type):
self.parser_error(p, symbol,
"the mapped type has already been defined in this module")
# The module may not have been set yet.
iface_file.module = self.module_state.module
# Create a new mapped type.
mapped_type = MappedType(iface_file, cpp_type)
mapped_type.cpp_name = cached_name(self.spec,
argument_as_str(cpp_type))
if cpp_name is not None:
mapped_type.py_name = cached_name(self.spec,
annotations.get('PyName', cpp_name))
self.annotate_mapped_type(p, symbol, mapped_type, annotations)
self.spec.mapped_types.insert(0, mapped_type)
if self.in_main_module:
mapped_type.cpp_name.used = True
if mapped_type.py_name is not None:
mapped_type.py_name.used = True
self.push_scope(mapped_type)
def add_qualifier(self, p, symbol, name, type, order=0, timeline=0):
""" Create a Qualifier and add it to the current module. """
module = self.module_state.module
# See if it already exists.
qualifier = self.find_qualifier(p, symbol, name, required=False)
if qualifier is not None:
# We allow versions to be defined more than once so long as they
# are in different timelines. It is sometimes necessary to define
# the same timeline in multiple modules if a module that others
# depend on is added during the timeline.
if qualifier.type is not QualifierType.TIME or type is not QualifierType.TIME or (qualifier.module is module and qualifier.timeline == timeline):
self.parser_error(p, symbol,
"'{0}' has already been defined as a qualifier".format(
name))
return
qualifier = Qualifier(module, name, type, order=order,
timeline=timeline)
if type is QualifierType.TIME or not self.skipping:
qualifier.enabled_by_default = True
module.qualifiers.insert(0, qualifier)
def add_typedef(self, p, symbol, typedef):
""" Add a typedef to the current scope. """
if self.spec.is_strict:
for td in self.spec.typedefs:
if td.fq_cpp_name == typedef.fq_cpp_name:
self.parser_error(p, symbol,
"'{0}' has already been defined".format(
typedef.fq_cpp_name))
self.module_state.module.nr_typedefs += 1
self.spec.typedefs.append(typedef)
def annotate_mapped_type(self, p, symbol, mapped_type, annotations):
""" Apply annotations to a mapped type. """
mapped_type.handles_none = annotations.get('AllowNone', False)
mapped_type.no_assignment_operator = annotations.get(
'NoAssignmentOperator', False)
mapped_type.no_copy_ctor = annotations.get('NoCopyCtor', False)
mapped_type.no_default_ctor = annotations.get('NoDefaultCtor', False)
mapped_type.no_release = annotations.get('NoRelease', False)
mapped_type.type_hints = self.get_type_hints(p, symbol, annotations)
if mapped_type.no_release:
mapped_type.no_assignment_operator = True
mapped_type.no_copy_ctor = True
mapped_type.no_default_ctor = True
pyqt_flags = self._get_plugin_annotation(p, symbol, annotations,
'PyQtFlags', 'PyQt6')
if pyqt_flags is not None:
mapped_type.pyqt_flags = pyqt_flags
def apply_common_argument_annotations(self, p, symbol, arg, annotations):
""" Apply the annotations common to callable arguments and return type.
"""
arg.allow_none = annotations.get('AllowNone', False)
arg.disallow_none = annotations.get('DisallowNone', False)
arg.no_copy = annotations.get('NoCopy', False)
# We need to use an exception because we have to distinguish between
# a missing annotation and one without a value specified.
try:
key = annotations['KeepReference']
if key is None:
key = self.module_state.module.next_key
self.module_state.module.next_key -= 1
elif key < 0:
self.parser_error(p, symbol,
"a /KeepReference/ key cannot be negative")
arg.key = key
except KeyError:
pass
def apply_type_annotations(self, p, symbol, type, annotations):
""" Apply the annotations for an argument type. """
# The type annotations.
type.type_hints = self.get_type_hints(p, symbol, annotations)
# The PyInt annotation.
if annotations.get('PyInt') is not None:
if type.type is ArgumentType.STRING:
type.type = ArgumentType.BYTE
elif type.type is ArgumentType.SSTRING:
type.type = ArgumentType.SBYTE
elif type.type is ArgumentType.USTRING:
type.type = ArgumentType.UBYTE
# The Encoding annotation.
can_be_encoded = type.type is ArgumentType.STRING and type.array is ArrayArgument.NONE and not type.is_reference
if can_be_encoded:
encoding = annotations.get('Encoding')
if encoding is None:
default_encoding = self.module_state.default_encoding
if default_encoding is not None:
type.type = default_encoding
else:
type.type = self.convert_encoding(p, symbol, encoding)
def check_annotations(self, p, symbol, context, annotations):
""" Check that all the annotations provided as a dict of name/values
are valid in a given context.
"""
for name in p[symbol]:
if name not in annotations:
self.parser_error(p, symbol,
"{0} is not a valid {1} annotation".format(name,
context))
def check_attributes(self, p, symbol, py_name, is_function=False,
ignore=None):
""" Check that a Python name will not clash with another object in the
same Python scope.
"""
# We don't do any check for a non-strict parse.
if not self.spec.is_strict:
return
# Report a name clash with something.
def clash(thing):
self.parser_error(p, symbol,
"there is already {0} in scope called '{1}'".format(thing,
py_name))
# Check the enums.
for ed in self.spec.enums:
if ed.py_name is None:
continue
if ed.scope is not self.scope:
continue
if ed.py_name.name == py_name:
clash("an enum")
if not ed.is_scoped:
for emd in ed.members:
if emd.py_name.name == py_name:
clash("an enum member")
# Only check the members if this attribute isn't a member because we
# can handle members with the same name in the same scope.
if not is_function:
if self.scope is None:
members = self.module_state.module.global_functions
thing = "a function"
else:
members = self.scope.members
thing = "a method"
for md in members:
if md.py_name.name == py_name:
clash(thing)
break
# There is nothing more to check in mapped types.
if isinstance(self.scope, MappedType):
return
# Check the variables.
for vd in self.spec.variables:
if vd.scope is not self.scope:
continue
if vd.py_name.name == py_name:
clash("a variable")
break
# Check the classes.
for cd in self.spec.classes:
if cd.scope is not self.scope:
continue
# A class will have already been added to the scope and this will
# tell us to ignore it.
if cd is ignore:
continue
if cd.external:
continue
if cd.py_name.name == py_name:
clash("a class or namespace")
if self.scope is None:
# Check the exceptions.
for xd in self.spec.exceptions:
if xd.py_name is not None and xd.py_name == py_name:
clash("an exception")
break
else:
# Check the properties.
for pd in self.scope.properties:
if pd.name.name == py_name:
clash("a property")
break
def cpp_only(self, p, symbol, feature):
""" Check that a C++ feature isn't being used in a C module. """
if bool(self.c_bindings):
self.parser_error(p, symbol,
feature + " are not allowed in a C module")
def convert_docstring_format(self, p, symbol):
""" Convert a string to the corresponding DocstringFormat member. """
value = p[symbol]
if value == 'deindented':
return DocstringFormat.DEINDENTED
if value == 'raw':
return DocstringFormat.RAW
self.parser_error(p, symbol,
"'{0}' is not a valid value for a docstring format".format(
value))
# Return any value of the right type.
return DocstringFormat.RAW
def convert_docstring_signature(self, p, symbol):
""" Convert a string to the corresponding DocstringSignature member.
"""
value = p[symbol]
if value == 'appended':
return DocstringSignature.APPENDED
if value == 'discarded':
return DocstringSignature.DISCARDED
if value == 'prepended':
return DocstringSignature.PREPENDED
self.parser_error(p, symbol,
"'{0}' is not a valid value for a docstring signature".format(
value))
# Return any value of the right type.
return DocstringSignature.PREPENDED
def convert_encoding(self, p, symbol, value=None):
""" Convert a string to the corresponding ArgumentType member. """
if value is None:
value = p[symbol]
if value == 'ASCII':
return ArgumentType.ASCII_STRING
if value == 'Latin-1':
return ArgumentType.LATIN1_STRING
if value == 'None':
return ArgumentType.STRING
if value == 'UTF-8':
return ArgumentType.UTF8_STRING
self.parser_error(p, symbol,
"'{0}' is not a valid encoding".format(value))
# Return any value of the right type.
return ArgumentType.NONE
def convert_kw_args(self, p, symbol, value=None):
""" Convert a string to the corresponding KwArgs member. """
if value is None:
value = p[symbol]
if value == 'All':
return KwArgs.ALL
if value == 'None':
return KwArgs.NONE
if value == 'Optional':
return KwArgs.OPTIONAL
self.parser_error(p, symbol,
"'{0}' is not a valid value for keyword arguments".format(
value))
# Return any value of the right type.
return KwArgs.OPTIONAL
def ensure_import(self):
""" We allow %Modules that are part of a %CompositeModule to be either
%Imported or %Included. In the case of the latter we need to adjust
things so that it appears like the former.
"""
sip_file, raw_sip_file, input, lineno, lexpos, module_state = self._file_stack.pop()
if module_state is None:
self._import_module(self._sip_file)
module_state = self.module_state
self._file_stack.append(
(sip_file, raw_sip_file, input, lineno, lexpos, module_state))
def evaluate_feature_or_platform(self, p, symbol, name=None,
inverted=False):
""" Evaluate a feature or platform qualifier. """
if name is None:
name = p[symbol]
qual = self.find_qualifier(p, symbol, name)
if qual is None:
return False
if qual.type is QualifierType.FEATURE:
value = qual.name not in self._disabled_features
elif qual.type is QualifierType.PLATFORM:
# The platform is always ignored in non-strict mode.
if not self.spec.is_strict:
return True
value = qual.name in self.tags
else:
self.parser_error(p, symbol,
"'{0}' is a %Timeline qualifier which can only be used in a range".format(name))
return False
if inverted:
value = not value
return value
def evaluate_timeline(self, p, symbol_lower, symbol_upper):
""" Evaluate a timeline qualifier. """
# Get the lower and upper qualifiers if specified.
lower_name = p[symbol_lower]
if lower_name:
lower_qual = self._find_timeline_qualifier(p, symbol_lower)
if lower_qual is None:
return False
else:
lower_qual = None
upper_name = p[symbol_upper]
if upper_name:
upper_qual = self._find_timeline_qualifier(p, symbol_upper)
if upper_qual is None:
return False
else:
upper_qual = None
if lower_qual is None and upper_qual is None:
self.parser_error(p, symbol_lower,
"the lower and upper bounds cannot both be omitted")
return False
if lower_qual is not None and upper_qual is not None:
if lower_qual.module is not upper_qual.module or lower_qual.timeline != upper_qual.timeline:
self.parser_error(p, symbol_lower,
"'{0}' and '{1}' are defined in different %Timelines".format(lower_name, upper_name))
return False
if lower_qual is upper_qual:
self.parser_error(p, symbol_lower,
"the lower and upper bounds must be different")
return False
if lower_qual.order > upper_qual.order:
self.parser_error(p, symbol_lower,
"'{0}' is later in the %Timeline than '{1}'".format(lower_name, upper_name))
return False
# Get the module and timeline.
if lower_qual is not None:
module = lower_qual.module
timeline = lower_qual.timeline
else:
module = upper_qual.module
timeline = upper_qual.timeline
# Handle the SIP version number pseudo-timeline.
if timeline < 0:
if lower_qual is not None and self._hex_version < lower_qual.order:
return False
if upper_qual is not None and self._hex_version >= upper_qual.order:
return False
return True
# See if there is a selected qualifier withing range.
for qual in module.qualifiers:
if qual.type is QualifierType.TIME and qual.timeline == timeline and qual.name in self.tags:
if lower_qual is not None and qual.order < lower_qual.order:
return False
if upper_qual is not None and qual.order >= upper_qual.order:
return False
return True
return upper_qual is None
def find_qualifier(self, p, symbol, name, required=True):
""" Return a Qualifier or None if one doesn't exist. """
for module in self.modules:
for qual in module.qualifiers:
if qual.name == name:
return qual
# Qualifiers corresponding to the SIP version are created on the fly.
if name.startswith('SIP_'):
parts = name.split('_')[1:]
if len(parts) > 3:
order = -1
else:
while len(parts) < 3:
parts.append('0')
order = 0
for part in parts:
try:
order = (order << 8) + int(part)
except ValueError:
order = -1
break
if order >= 0:
module = self.module_state.module
qualifier = Qualifier(module, name, QualifierType.TIME,
order=order)
module.qualifiers.append(qualifier)
return qualifier
if required:
self.parser_error(p, symbol,
"'{0}' is not a known qualifier".format(name))
return None
def get_py_name(self, cpp_name, annotations):
""" Return a valid Python name given a C/C++ name. """
# Use any name specified by annotation.
try:
return annotations['PyName']
except KeyError:
pass
# Use the C/C++ name.
py_name = cpp_name
# Apply any automatic naming rules.
for rule in self.module_state.auto_py_name_rules:
if rule[0] == 'REMOVE_LEADING':
leading = rule[1]
if py_name.startswith(leading):
py_name = py_name[len(leading):]
# Fix any Python keywords.
if py_name in self._PYTHON_KEYWORDS:
py_name += '_'
return py_name
def get_transfer(self, p, symbol, annotations):
""" Return the a Transfer value from a dict of annotations. """
has_transfer = annotations.get('Transfer', False)
has_transfer_back = annotations.get('TransferBack', False)
has_transfer_this = annotations.get('TransferThis', False)
transfer = None
if has_transfer:
if has_transfer_back or has_transfer_this:
pass
else:
transfer = Transfer.TRANSFER
elif has_transfer_back:
if has_transfer or has_transfer_this:
pass
else:
transfer = Transfer.TRANSFER_BACK
elif has_transfer_this:
if has_transfer or has_transfer_back:
pass
else:
transfer = Transfer.TRANSFER_THIS
else:
transfer = Transfer.NONE
if transfer is None:
self.parser_error(p, symbol,
"Only one transfer annotation may be specified")
transfer = Transfer.NONE
return transfer
def get_type_hints(self, p, symbol, annotations):
""" Return a TypeHints object constructed from a dict of annotations or
None if none were specified.
"""
th = annotations.get('TypeHint')
th_in = annotations.get('TypeHintIn')
th_out = annotations.get('TypeHintOut')
th_value = annotations.get('TypeHintValue')
if th_in is None:
th_in = th
elif th is not None:
self.parser_error(p, symbol,
"'TypeHint' and 'TypeHintIn' cannot both be specified")
return None
if th_out is None:
th_out = th
elif th is not None:
self.parser_error(p, symbol,
"'TypeHint' and 'TypeHintOut' cannot both be specified")
return None
if th_in is not None or th_out is not None or th_value is not None:
# Check that type hints haven't been suppressed.
if annotations.get('NoTypeHint') is not None:
self.parser_error(p, symbol,
"'NoTypeHint' cannot be specified with a type hint")
return TypeHints(th_in, th_out, th_value)
return None
@property
def in_main_module(self):
""" Set if the current module is the main one, ie. the one for which
code will be generated for.
"""
return self.module_state.module is self.spec.module
def instantiate_class_template(self, p, symbol, fq_cpp_name, template,
py_name, no_type_name, docstring):
""" Try and instantiate a class template and return True if one was
found.
"""
# Look for an appropriate class template.
for tmpl_names, proto_class in self.class_templates:
if proto_class.iface_file.fq_cpp_name.matches(template.cpp_name, scope=self.scope) and same_template_signature(tmpl_names, template.types):
break
else:
# There was no class template to instantiate.
return False
instantiate_class(p, symbol, fq_cpp_name, tmpl_names, proto_class,
template, py_name, no_type_name, docstring, self)
return True
def lexer_error(self, t, text):
""" Record an error caused by a token. """
self._error_log.log(text,
SourceLocation(self._sip_file, line=t.lineno,
column=self._get_column_from_lexpos(t.lexpos)))
def parse(self, sip_file):
""" Parse a .sip file and return a 3-tuple of a Specification object, a
list of Module objects and a list of the .sip files that specify the
module to be generated. A UserException is raised if there was an
error.
"""
# Note that the retention of the 'raw' filename, ie. that which was
# specified by the user is only done so that generated '#line'
# directives match those from older versions of SIP.
raw_sip_file = sip_file
sip_file = os.path.abspath(sip_file)
self.module_state = ModuleState(self.spec.module, sip_file)
try:
self._parser.parse(self._read(sip_file, raw_sip_file),
lexer=self._lexer, tracking=True)
except UnexpectedEOF:
self._unexpected_eof_error()
self._handle_eom()
self._error_log.as_exception()
self.spec.c_bindings = bool(self.c_bindings)
self.spec.typedefs.sort(key=lambda k: k.fq_cpp_name)
self.spec.variables.sort(key=lambda k: k.py_name.name)
# Remove all template classes and anything they contain.
template_classes = [k for _, k in self.class_templates]
for enum in list(self.spec.enums):
if enum.scope in template_classes:
spec.spec.enums.remove(enum)
for typedef in list(self.spec.typedefs):
if typedef.scope in template_classes:
spec.spec.typedefs.remove(typedef)
for variable in list(self.spec.variables):
if variable.scope in template_classes:
spec.spec.variables.remove(variable)
for klass in template_classes:
self.spec.classes.remove(klass)
self.spec.iface_files.remove(klass.iface_file)
# Remove all classes that are only template arguments.
for klass in self._template_arg_classes:
self.spec.classes.remove(klass)
return self.spec, self.modules, self._sip_files
def parser_error(self, p, symbol, text):
""" Record an error caused by a symbol in a production. """
self._error_log.log(text, self.get_source_location(p, symbol))
def pop_file(self):
""" Restore the current .sip file from the stack and make it current.
An IndexError is raised if the stack is empty.
"""
# Restore the state of the previous .sip file. Note that we don't
# restore the module state until after the EOF has been seen.
self._sip_file, self.raw_sip_file, self._input, self._lexer.lineno, lexpos, self._pending_module_state = self._file_stack.pop()
self._lexer.input(self._input)
self._lexer.lexpos = lexpos
def pop_module_state(self):
""" Restore the current module state. """
if self._pending_module_state is None:
return
self._handle_eom()
# Inherit any default encoding.
if self._pending_module_state.default_encoding is None:
self._pending_module_state.default_encoding = self.module_state.default_encoding
# Inherit any call_super_init.
if self._pending_module_state.call_super_init is None:
self._pending_module_state.call_super_init = self.module_state.call_super_init
self.module_state = self._pending_module_state
self._pending_module_state = None
def pop_scope(self):
""" Pop the current scope. """
self._scope_stack.pop()
def push_file(self, p, symbol, sip_file=None, new_module=False,
optional=False):
""" Push the current .sip file onto the stack and make the new one
current. The new .sip file may be part of a new module (ie. %Import
rather than %Include).
"""
if sip_file is None:
sip_file = p[symbol]
raw_sip_file = sip_file
# Make the name platform-native.
sip_file = sip_file.replace('/', os.sep)
# See if the file can be found.
if os.path.isfile(sip_file):
pass
else:
found = None
# If the name is relative then check the directory containing the
# current file and any include directories.
if not os.path.isabs(sip_file):
inc_dirs = [os.path.dirname(self._sip_file)]
inc_dirs.extend(self._include_dirs)
for inc_dir in inc_dirs:
fn = os.path.join(inc_dir, sip_file)
if os.path.isfile(fn):
found = fn
break
if found is None:
if not optional:
self.parser_error(p, symbol,
"'{0}' could not be found".format(raw_sip_file))
return
# For historic reasons we keep the absolute name for the raw name.
raw_sip_file = sip_file = found
sip_file = os.path.abspath(sip_file)
# Check we aren't reading the file recursively.
for detail in self._file_stack:
if detail[0] == sip_file:
self.parser_error(p, symbol,
"'{0}' is being read recursively".format(sip_file))
return
# Ignore the file if we have already read it.
if sip_file in self._all_sip_files:
return
if new_module:
old_module_state = self.module_state
self._import_module(sip_file)
else:
# This means that the file was %Included rather than %Imported.
old_module_state = None
# Save the state of the current .sip file.
self._file_stack.append(
(self._sip_file, self.raw_sip_file, self._input,
self._lexer.lineno, self._lexer.lexpos,
old_module_state))
# Make the new one current and give it's content to the lexer.
self._lexer.lineno = 1
self._lexer.input(self._read(sip_file, raw_sip_file))
def push_scope(self, scope, access_specifier=None):
""" Push a new scope. """
self._scope_stack.append(ScopeState(scope, access_specifier))
def set_lexer_state(self, state='INITIAL'):
""" Set the lexer state. """
self._lexer.begin(state)
@property
def scope(self):
""" The current scope if any. """
try:
return self._scope_stack[-1].scope
except IndexError:
pass
return None
@property
def scope_access_specifier(self):
""" The current access specifier. """
return None if len(self._scope_stack) == 0 else self._scope_stack[-1].access_specifier
@scope_access_specifier.setter
def scope_access_specifier(self, access_specifier):
""" Set the current access specifier. """
self._scope_stack[-1].access_specifier = access_specifier
@property
def scope_pyqt_method_specifier(self):
""" The current method specifier. """
return None if len(self._scope_stack) == 0 else self._scope_stack[-1].pyqt_method_specifier
@scope_pyqt_method_specifier.setter
def scope_pyqt_method_specifier(self, pyqt_method_specifier):
""" Set the current method specifier. """
self._scope_stack[-1].pyqt_method_specifier = pyqt_method_specifier
@property
def skipping(self):
""" True if symbols are currently being skipped. """
return self.skip_stack[-1]
def validate_annotation(self, p, symbol, value):
""" Validate an annotation and its value and return a valid version of
the value.
"""
try:
value = validate_annotation_value(self, p, symbol, p[symbol],
value)
except InvalidAnnotation as e:
self.parser_error(p, symbol, str(e))
value = e.use
return value
def validate_function(self, p, symbol, overload):
""" Validate a completed function. """
# Shortcuts.
cpp_only = partial(self.cpp_only, p, symbol)
error = partial(self.parser_error, p, symbol)
if overload.access_specifier is None:
if overload.is_abstract:
error("abstract non-member functions cannot be specified")
else:
cpp_only("struct/union member functions")
if overload.new_thread:
# This is an arbitary limitation to make the code generator
# slightly easier - laziness on my part.
result = overload.cpp_signature.result
if result.type is not ArgumentType.VOID or len(result.derefs) != 0:
error("/NewThread/ may only be specified for void functions")
if overload.is_static:
cpp_only("static struct/union data members")
if overload.pyqt_method_specifier is PyQtMethodSpecifier.SIGNAL:
error("signals cannot be static")
if overload.throw_args is not None:
cpp_only("exceptions")
if overload.is_virtual:
if overload.virtual_error_handler is not None and overload.no_virtual_error_handler:
error("/VirtualErrorHandler/ and /NoVirtualErrorHandler/ cannot both be specified")
else:
if overload.abort_on_exception:
error("/AbortOnException/ cannot be specified for non-virtual member functions")
if overload.new_thread:
error("/NewThread/ cannot be specified for non-virtual member functions")
if overload.virtual_call_code is not None:
error("%VirtualCallCode cannot be specified for non-virtual member functions")
if overload.virtual_catcher_code is not None:
error("%VirtualCatcherCode cannot be specified for non-virtual member functions")
if overload.virtual_error_handler is not None:
error("/VirtualErrorHandler/ cannot be specified for non-virtual member functions")
if overload.no_virtual_error_handler:
error("/NoVirtualErrorHandler/ cannot be specified for non-virtual member functions")
if overload.factory:
if overload.transfer is Transfer.TRANSFER_BACK:
error("/TransferBack/ and /Factory/ cannot both be specified")
elif self.scope_access_specifier is None or overload.is_static:
for arg in overload.py_signature.args:
if arg.transfer is Transfer.TRANSFER_THIS:
error("/TransferThis/ may only be specified for constructors and member functions")
break
if overload.common.no_arg_parser and overload.method_code is None:
error("%MethodCode must be specified when /NoArgParser/ is specified")
def validate_mapped_type(self, p, symbol, mapped_type):
""" Validate a completed mapped type. """
if self.spec.abi_version >= (13, 0):
convert_to_us = mapped_type.convert_to_type_code is not None and 'sipUserState' in mapped_type.convert_to_type_code.text
release_us = mapped_type.release_code is not None and 'sipUserState' in mapped_type.release_code.text
if convert_to_us != release_us:
self.parser_error(p, symbol,
"both %ConvertToTypeCode and %ReleaseCode must use user state or neither must")
mapped_type.needs_user_state = convert_to_us or release_us
else:
if mapped_type.convert_to_type_code is None:
self.parser_error(p, symbol,
"%MappedType must have a %ConvertToTypeCode directive")
if mapped_type.convert_from_type_code is None:
self.parser_error(p, symbol,
"%MappedType must have a %ConvertFromTypeCode directive")
def validate_variable(self, p, symbol, variable):
""" Validate a completed variable. """
if variable.type.type is ArgumentType.CAPSULE:
self.parser_error(p, symbol,
"capsule variables are not yet supported")
access_specifier = self.scope_access_specifier
if access_specifier is not None:
if access_specifier is not AccessSpecifier.PUBLIC:
self.parser_error(p, symbol,
"class variables must be in the public section")
if variable.is_static:
self.cpp_only(p, symbol, "static members in C structures")
elif variable.access_code is not None:
self.parser_error(p, symbol,
"%AccessCode cannot be specified for non-static class variables")
if variable.get_code is not None or variable.set_code is not None:
if variable.access_code is not None:
self.parser_error(p, symbol,
"%AccessCode cannot be specified with %GetCode or %SetCode")
if self.scope is None:
# TODO: this can be supported for versions of Python that
# support module descriptors.
self.parser_error(p, symbol,
"%GetCode or %SetCode cannot be specified for global variables")
if self.scope is not None and self.scope.iface_file.type is IfaceFileType.NAMESPACE:
variable.is_static = True
self.check_attributes(p, symbol, variable.py_name)
def _add_auto_slot(self, p, symbol, annotations, py_name, py_signature,
cpp_signature, method_code):
""" Add an automatically generated slot. """
member = self._find_member(p, symbol, py_name, py_signature.args,
annotations, method_code)
overload = Overload(AccessSpecifier.PUBLIC, member, py_name,
cpp_signature, py_signature, method_code=method_code)
if self.scope is None:
self.module_state.module.overloads.append(overload)
else:
self.scope.overloads.append(overload)
def _check_ellipsis(self, p, symbol, signature):
""" Check any ellipsis in a signature. """
seen_ellipsis = False
for arg in signature.args:
if arg.type is ArgumentType.ELLIPSIS:
# Give the argument the standard name so that it appears in
# docstrings and type hints. It is never used in generated
# code so there is no need to add it to the module cache.
arg.name = CachedName('*args')
if seen_ellipsis:
self.parser_error(p, symbol,
"'...' may only be specified once")
break
seen_ellipsis = True
elif seen_ellipsis and arg.default_value is None:
self.parser_error(p, symbol,
"'...' must be at the end of the positional arguments")
break
def find_iface_file(self, p, symbol, fq_cpp_name, iface_file_type,
cpp_type=None):
""" Return an interface file for a fully qualified C/C++ name and type
creating it if necessary.
"""
def error_logger(text):
self.parser_error(p, symbol, text)
return find_iface_file(self.spec, self.module_state.module,
fq_cpp_name, iface_file_type, error_logger, cpp_type=cpp_type,
scope=self.scope)
def _find_member(self, p, symbol, py_name, args, annotations, method_code):
""" Return (creating if necessary) the member for a Python name. """
# See if it is a Python slot rather than an ordinary member function
# and check its requirements.
slot_detail = slot_name_detail_map.get(py_name)
if slot_detail is None:
py_slot = None
else:
py_slot, needs_method_code, nr_args_needed = slot_detail
if needs_method_code and method_code is None:
self.parser_error("'{0}' requires %MethodCode".format(py_name))
if nr_args_needed >= 0:
# Global operators need an extra argument.
if self.scope_access_specifier is None:
nr_args_needed += 1
# Global operators can only be numeric or comparision
# slots.
if invalid_global_slot(py_slot):
self.parser_error(p, symbol,
"'{0}' cannot be specified at the module level".format(py_name))
nr_args = len(args)
if nr_args_needed != nr_args:
self.parser_error(p, symbol,
"{0} arguments are needed but {1} are provided".format(
nr_args_needed, nr_args))
# __delattr__ is implemented as __setattr__.
if py_slot is PySlot.DELATTR:
if self.in_main_module:
cached_name(self.spec, py_name).used = True
py_slot = PySlot.SETATTR
py_name = '__setattr__'
# Check for name clashes.
self.check_attributes(p, symbol, py_name, is_function=True)
# Create a new member if necessary.
no_arg_parser = annotations.get('NoArgParser', False)
if self.scope is None:
members = self.module_state.module.global_functions
namespace_iface_file = None
elif self.scope.iface_file.type is IfaceFileType.NAMESPACE and py_slot is not None:
# The scope is a namespace and the function is an operator so
# handle it as a global, but remember it's C++ scope.
members = self.module_state.module.global_functions
namespace_iface_file = self.scope.iface_file
else:
members = self.scope.members
namespace_iface_file = None
for member in members:
if member.py_name.name == py_name:
# If /NoArgParser/ has been specified then there should only be
# one overload.
if member.no_arg_parser:
self.parser_error(p, symbol,
"an overloaded member function has already been specified with /NoArgParser/")
break
else:
member = Member(self.module_state.module,
cached_name(self.spec, py_name))
member.namespace_iface_file = namespace_iface_file
member.no_arg_parser = no_arg_parser
member.py_slot = py_slot
if self.in_main_module:
member.py_name.used = True
members.insert(0, member)
return member
def _find_timeline_qualifier(self, p, symbol):
""" Return an optional timeline qualifier. """
name = p[symbol]
qual = self.find_qualifier(p, symbol, name)
if qual is None:
return None
if qual.type is not QualifierType.TIME:
self.parser_error(p, symbol,
"'{0}' is not a %Timeline qualifier".format(name))
return None
return qual
def _get_column_from_lexpos(self, lexpos):
""" Return the column within the current line corresponding to a lexer
position.
"""
line_start = self._input.rfind('\n', 0, lexpos) + 1
return lexpos - line_start + 1
def _get_gil_action(self, p, symbol, annotations):
""" Return an appropriate GILAction according to the annotations. """
hold = annotations.get('HoldGIL', False)
release = annotations.get('ReleaseGIL', False)
if hold:
if release:
self.parser_error(p, symbol,
"/HoldGIL/ and /ReleaseGIL' cannot both be specified")
return GILAction.HOLD
if release:
return GILAction.RELEASE
return GILAction.DEFAULT
# The Python keywords.
_PYTHON_KEYWORDS = (
'False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await',
'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except',
'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is',
'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try',
'while', 'with', 'yield',
)
def _get_kw_args(self, p, symbol, annotations, signature, need_name=False):
""" Return the keyword argument support. """
kw_args = annotations.get('KeywordArgs')
if kw_args is not None:
kw_args = self.convert_kw_args(p, symbol, kw_args)
else:
kw_args = self.module_state.kw_args
# An ellipsis cannot be used with keyword arguments.
if len(signature.args) > 0 and signature.args[-1].type is ArgumentType.ELLIPSIS:
kw_args = KwArgs.NONE
# Check that there is at least one optional argument.
if kw_args is not KwArgs.NONE:
no_name = True
for arg in signature.args:
if kw_args is KwArgs.OPTIONAL and arg.default_value is None:
continue
if arg.name is not None:
if need_name or self.in_main_module:
arg.name.used = True
no_name = False
if no_name:
kw_args = KwArgs.NONE
return kw_args
def _get_plugin_annotation(self, p, symbol, annotations, name, plugin):
""" Return an annotation that is only supported by a plugin. """
anno = annotations.get(name)
if anno is not None and plugin not in self.spec.plugins:
self.parser_error(p, symbol,
"/{0}/ is only supported for {1}".format(name, plugin))
return anno
def get_source_location(self, p, symbol):
""" Return a SourceLocation object for a symbol. """
return SourceLocation(self._sip_file, line=p.lineno(symbol),
column=self._get_column_from_lexpos(p.lexpos(symbol)))
def _handle_eom(self):
""" Check that the current module is complete. """
module_state = self.module_state
module = module_state.module
if module.fq_py_name is None:
self._error_log.log("%Module has not been specified",
SourceLocation(self._sip_file))
# call_super_init defaults to False if it wasn't specified.
module.call_super_init = bool(module_state.call_super_init)
def _import_module(self, sip_file):
""" Create a new Module object and corresponding ModuleState object for
a .sip file and make it current.
"""
importing_from = self.module_state.module
module = Module()
self.modules.append(module)
module.default_exception = self.module_state.module.default_exception
self.module_state = ModuleState(module, sip_file)
# Get the configuration of the new module.
mod_tags, mod_disabled = get_bindings_configuration(
self.spec.abi_version[0], sip_file, self._include_dirs)
for tag in mod_tags:
if tag not in self.tags:
self.tags.append(tag)
for feature in mod_disabled:
if feature not in self._disabled_features:
self._disabled_features.append(feature)
# Add the new import.
importing_from.imports.append(module)
def _read(self, sip_file, raw_sip_file):
""" Return the contents of the current .sip file. """
try:
with open(sip_file, encoding=self._encoding) as f:
self._input = f.read()
except FileNotFoundError:
raise UserException("unable to read '{0}'".format(sip_file))
except UnicodeDecodeError as e:
raise UserException(
"'{0}' doesn't appear to use the '{1}' encoding".format(
sip_file, self._encoding),
detail=str(e))
self.raw_sip_file = raw_sip_file
self._sip_file = sip_file
self._all_sip_files.append(sip_file)
if self.in_main_module:
self._sip_files.append(sip_file)
return self._input
def _unexpected_eof_error(self):
""" Record an error caused by an unexpected EOF. """
self._error_log.log("unexpected end of file",
SourceLocation(self._sip_file))
class ModuleState:
""" Encapsulate the parser-related state for a module. """
def __init__(self, module, sip_file):
""" Initialise the state. """
self.module = module
self.sip_file = sip_file
self.all_raise_py_exception = False
self.auto_py_name_rules = []
self.call_super_init = None
self.default_encoding = None
self.kw_args = KwArgs.NONE
self.nr_timelines = 0
class ScopeState:
""" Encapsulate the parser-related state for a scope. """
def __init__(self, scope, access_specifier):
""" Initialise the state. """
self.scope = scope
self.access_specifier = access_specifier
self.pyqt_method_specifier = None
class UnexpectedEOF(Exception):
""" This is raised by p_error() when an unexpected EOF is seen. """