From 4d362eabacd96a8046c0fe0b0f27d7e9a2532fd4 Mon Sep 17 00:00:00 2001 From: SpaghettDev <37266659+SpaghettDev@users.noreply.github.com> Date: Fri, 3 May 2024 20:59:40 -0500 Subject: [PATCH] Switch to PyBroma and prepare for function signature importer... --- BromaIDA.py | 183 +- README.md | 12 +- assets/{btida.gif => bida.gif} | Bin .../{binding_type.py => broma/binding.py} | 51 +- broma_ida/broma/constants.py | 1 + broma_ida/broma/exporter.py | 69 +- broma_ida/broma/importer.py | 234 + broma_ida/broma/parser.py | 150 - broma_ida/pybroma/PyBroma.cp310-win_amd64.pyd | Bin 0 -> 247296 bytes broma_ida/pybroma/PyBroma.cpp | 24420 ++++++++++++++++ broma_ida/pybroma/PyBroma.pyi | 137 + broma_ida/pybroma/__init__.py | 6 + broma_ida/pybroma/include/ast.hpp | 213 + broma_ida/pybroma/include/broma.hpp | 12 + broma_ida/pybroma/include/helper.hpp | 96 + broma_ida/pybroma/platforms.py | 14 + broma_ida/pybroma/visitor.py | 57 + broma_ida/utils.py | 81 +- 18 files changed, 25397 insertions(+), 339 deletions(-) rename assets/{btida.gif => bida.gif} (100%) rename broma_ida/{binding_type.py => broma/binding.py} (57%) create mode 100644 broma_ida/broma/importer.py delete mode 100644 broma_ida/broma/parser.py create mode 100644 broma_ida/pybroma/PyBroma.cp310-win_amd64.pyd create mode 100644 broma_ida/pybroma/PyBroma.cpp create mode 100644 broma_ida/pybroma/PyBroma.pyi create mode 100644 broma_ida/pybroma/__init__.py create mode 100644 broma_ida/pybroma/include/ast.hpp create mode 100644 broma_ida/pybroma/include/broma.hpp create mode 100644 broma_ida/pybroma/include/helper.hpp create mode 100644 broma_ida/pybroma/platforms.py create mode 100644 broma_ida/pybroma/visitor.py diff --git a/BromaIDA.py b/BromaIDA.py index 3033708..a13ba2a 100644 --- a/BromaIDA.py +++ b/BromaIDA.py @@ -1,25 +1,20 @@ -VERSION = "2.0.0" +VERSION = "3.0.0" __AUTHOR__ = "SpaghettDev" PLUGIN_NAME = "BromaIDA" PLUGIN_HOTKEY = "Ctrl+Shift+B" -import idaapi -import ida_kernwin -import ida_funcs -import idc -import idautils -from typing import cast -from re import sub -from io import TextIOWrapper - -from broma_ida.binding_type import Binding -from broma_ida.utils import ( - popup, stop, rename_func, get_short_info, get_platform, - get_platform_printable +from idaapi import ( + msg as ida_msg, register_action, unregister_action, + plugin_t as ida_plugin_t, action_desc_t as ida_action_desc_t, + PLUGIN_PROC, PLUGIN_HIDE, PLUGIN_KEEP ) -from broma_ida.broma.parser import BromaParser +from ida_kernwin import ask_file, ASKBTN_BTN1, ASKBTN_BTN2 +from idautils import Names + +from broma_ida.utils import popup, stop, get_platform, get_platform_printable +from broma_ida.broma.importer import BromaImporter from broma_ida.broma.exporter import BromaExporter from broma_ida.ida_ctx_entry import IDACtxEntry @@ -31,169 +26,57 @@ def bida_main(): "Import or Export Broma file?" ) - if import_export_prompt == ida_kernwin.ASKBTN_BTN1: - filePath = ida_kernwin.ask_file(False, "GeometryDash.bro", "bro") + if import_export_prompt == ASKBTN_BTN1: + filePath = ask_file(False, "GeometryDash.bro", "bro") if filePath is None or (filePath and not filePath.endswith(".bro")): popup("Ok", None, None, "Please select a valid file!") stop() platform = get_platform() - broma_parser = BromaParser(platform) + broma_importer = BromaImporter(platform) try: with open(filePath, "r") as f: - broma_parser.parse_file_stream(cast(TextIOWrapper, f)) + broma_importer.parse_file_stream(f) except FileNotFoundError: - popup("Ok", None, None, "File doesn't exist? Please try again.") + popup("Ok", "Ok", None, "File doesn't exist? Please try again.") stop() - print( - f"\n\n[+] Read {len(broma_parser.bindings)} " - f"{get_platform_printable(platform)} bindings from {filePath}" - ) - print( - f"[+] Read {len(broma_parser.duplicates)} " - f"duplicate {get_platform_printable(platform)} " - f"bindings from {filePath}\n" - ) - - # first, handle non-duplicates - for binding in broma_parser.bindings: - ida_ea = idaapi.get_imagebase() + binding["address"] - ida_name = idc.get_name(ida_ea) - ida_func_flags = idc.get_func_flags(ida_ea) - - if ida_name.startswith("loc_"): - ida_funcs.add_func(ida_ea) - - if ida_func_flags & idc.FUNC_LIB: - print( - f"[!] Tried to rename a library function! " - f"({get_short_info(binding)})" - ) - continue - - if ida_funcs.get_func(ida_ea).start_ea != ida_ea: - print( - f"[!] Function is in the middle of another one! " - f"({get_short_info(binding)})" - ) - continue - - if ida_name.startswith("sub_"): - rename_func( - ida_ea, - binding["idaQualifiedName"] # type: ignore - ) - elif sub("_[0-9]+", "", ida_name) != binding["idaQualifiedName"]: - mismatch_popup = popup( - "Overwrite", "Keep", "", - f"""Mismatch in Broma ({binding["qualifiedName"]}) """ - f"and idb ({ida_name})!\n" - "Overwrite from Broma or keep current name?" - ) - - if mismatch_popup == ida_kernwin.ASKBTN_BTN1: - rename_func( - ida_ea, - binding["idaQualifiedName"] # type: ignore - ) - elif mismatch_popup == ida_kernwin.ASKBTN_CANCEL: - stop() - - # and now for what took me 3 hours :D - for addr, bindings in broma_parser.duplicates.items(): - ida_ea = idaapi.get_imagebase() + addr - - func_cmt = idc.get_func_cmt(ida_ea, True) - func_names = ", ".join( - [binding["qualifiedName"] - for binding in bindings] # type: ignore - ) - - if func_cmt == "": - # use the first occurrence as the name (very good imo) - rename_func( - ida_ea, - bindings[0]["idaQualifiedName"] # type: ignore - ) - - idc.set_func_cmt(ida_ea, f"Merged with: {func_names}", True) - elif func_cmt.startswith("Merged with: "): - cmt_func_names = func_cmt.lstrip("Merged with: ") - - if func_names != cmt_func_names: - print( - "[!] Mismatch in merged function list " - f"(Current: {cmt_func_names} | Correct: {func_names})! " - "Correcting..." - ) - idc.set_func_cmt( - ida_ea, f"Merged with: {func_names}", True - ) - else: - if popup( - "Overwrite", "Keep", None, - f"{hex(addr)} already has a comment! Would you like to " - "overwrite it with merge information or keep the current " - "comment?\n" - "(You will be prompted with this again if you rerun the " - "script and there are merged functions!)" - ) == ida_kernwin.ASKBTN_BTN1: - idc.set_func_cmt( - ida_ea, f"Merged with: {func_names}", True - ) + broma_importer.import_into_idb() print("[+] Finished importing bindings from Broma file") popup( "Ok", "Ok", None, - f"Finished importing {get_platform_printable(platform)} " + "Finished importing " + f"{get_platform_printable(platform)} " "bindings from Broma file." ) - broma_parser.reset() - elif import_export_prompt == ida_kernwin.ASKBTN_BTN2: + elif import_export_prompt == ASKBTN_BTN2: platform = get_platform() - filePath = ida_kernwin.ask_file(True, "GeometryDash.bro", "bro") + # for_saving is not True because we need to read the file first + # which may not even exist if the saving prompt is used + # (since you can select files that don't exist within said prompt) + filePath = ask_file(False, "GeometryDash.bro", "bro") if filePath is None or (filePath and not filePath.endswith(".bro")): - popup("Ok", None, None, "Please select a valid file!") + popup("Ok", "Ok", None, "Please select a valid file!") stop() broma_exporter = BromaExporter(platform, filePath) - for ea, name in idautils.Names(): - if "::" not in name: - continue - - split_name = name.split("::") - - # ["GJUINode", "dGJUINode"] -> "GJUINode" == "GJUINode" - if split_name[0] == split_name[1][1:]: - split_name = [ - split_name[0], - split_name[1].replace("::d", "::~") - ] - - broma_exporter.push_binding(Binding({ - "name": split_name[1], - "className": split_name[0], - "inheritedClasses": [], - "address": ea - idaapi.get_imagebase() - })) - + broma_exporter.import_from_idb(Names()) broma_exporter.export() print(f"[+] Finished exporting {broma_exporter.num_exports} bindings.") popup("Ok", "Ok", None, "Finished exporting bindings to Broma file.") - broma_exporter.reset() -class BromaIDAPlugin(idaapi.plugin_t): +class BromaIDAPlugin(ida_plugin_t): """BromaIDA Plugin""" - flags = idaapi.PLUGIN_PROC | idaapi.PLUGIN_HIDE + flags = PLUGIN_PROC | PLUGIN_HIDE comment = "Broma support for IDA." help = "Ctrl-Shift-I to start the importing/exporting." wanted_name = PLUGIN_NAME @@ -206,15 +89,15 @@ def init(self): """Ran on plugin load""" self._register_action() - idaapi.msg(f"{self.wanted_name} v{VERSION} initialized\n") + ida_msg(f"{self.wanted_name} v{VERSION} initialized\n") - return idaapi.PLUGIN_KEEP + return PLUGIN_KEEP def term(self): """Ran on plugin unload""" self._unregister_action() - idaapi.msg(f"{self.wanted_name} v{VERSION} unloaded\n") + ida_msg(f"{self.wanted_name} v{VERSION} unloaded\n") def run(self, arg): """Ran on "File -> Script File" (shocker) (broken for me :D)""" @@ -222,7 +105,7 @@ def run(self, arg): def _register_action(self): """Registers BromaIDA's hotkey""" - hotkey = idaapi.action_desc_t( + hotkey = ida_action_desc_t( self.ACTION_BTIDA, "BromaIDA", IDACtxEntry(bida_main), @@ -230,11 +113,11 @@ def _register_action(self): self.ACTION_DESC ) - idaapi.register_action(hotkey) + register_action(hotkey) def _unregister_action(self): """Unregisters BromaIDA's hotkey""" - idaapi.unregister_action(self.ACTION_BTIDA) + unregister_action(self.ACTION_BTIDA) def PLUGIN_ENTRY(): diff --git a/README.md b/README.md index 123c8ce..e3348af 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,10 @@ # BromaIDA -Broma IDA support (now real). +IDA Broma support (now real). -Parses a broma file and exports/imports the bindings into the current IDA project. +Parses a Broma file and exports the bindings into a Broma file/imports the bindings into the current IDA project. -[![Broma-To-IDA](assets/btida.gif)](https://github.com/SpaghettDev/Broma-To-IDA/releases) +[![BromaIDA](assets/bida.gif)](https://github.com/SpaghettDev/BromaIDA/releases) ## Requirements @@ -20,4 +20,8 @@ Parses a broma file and exports/imports the bindings into the current IDA projec 1. `Ctrl-Shift-B` to start importing/exporting 2. Browse and select the broma file (not tested with anything but `GeometryDash.bro`) -3. Let the script handle the rest and enjoy free bindings +3. Let the script handle the rest and enjoy free/exported bindings + +## Thanks + +Special thanks to [CallocGD](https://github.com/CallocGD)'s [PyBroma](https://github.com/CallocGD/PyBroma) which is used to import bindings from Broma. diff --git a/assets/btida.gif b/assets/bida.gif similarity index 100% rename from assets/btida.gif rename to assets/bida.gif diff --git a/broma_ida/binding_type.py b/broma_ida/broma/binding.py similarity index 57% rename from broma_ida/binding_type.py rename to broma_ida/broma/binding.py index 16cf64b..0be21b9 100644 --- a/broma_ida/binding_type.py +++ b/broma_ida/broma/binding.py @@ -1,5 +1,7 @@ from typing import Union, TypedDict, Literal, cast +from broma_ida.pybroma import Type + class BaseBindingType(TypedDict): """Base binding type""" @@ -7,18 +9,25 @@ class BaseBindingType(TypedDict): className: str qualifiedName: str idaQualifiedName: str - inheritedClasses: list[str] address: int + return_type: Type + parameters: dict[str, Type] + class BaseShortBindingType(TypedDict): """Base binding type (but shorter)""" name: str className: str - inheritedClasses: list[str] address: int +class BaseShortBindingTypeWithMD(BaseShortBindingType): + """Base binding type (shorter, with metadata about the function)""" + return_type: Type + parameters: dict[str, Type] + + class Binding: """Actual binding type. Implements __eq__ because TypedDict can't be instantiated, and as such, can't @@ -27,16 +36,23 @@ class Binding: to stop putting type: ignore everywhere """ binding: BaseBindingType + is_overload: bool def __init__( self, - binding: Union[BaseShortBindingType, BaseBindingType] + binding: Union[ + BaseShortBindingType, BaseShortBindingTypeWithMD, BaseBindingType + ], + is_overload: bool = False ) -> None: - if binding.get("qualifiedName"): + if binding.get("qualifiedName") is not None: self.binding = cast(BaseBindingType, binding) else: binding = cast(BaseShortBindingType, binding) + if binding.get("return_type"): + binding = cast(BaseShortBindingTypeWithMD, binding) + self.binding = BaseBindingType({ "name": binding["name"], "className": binding["className"], @@ -46,10 +62,13 @@ def __init__( f"""{binding["className"]}::{binding["name"]}""".replace( "::~", "::d" ), - "inheritedClasses": binding["inheritedClasses"], - "address": binding["address"] + "address": binding["address"], + "return_type": binding.get("return_type") or Type(), + "parameters": binding.get("parameters") or {} }) + self.is_overload = is_overload + def __eq__(self, key: object) -> bool: if isinstance(key, int): return self.binding["address"] == key @@ -62,18 +81,22 @@ def __getitem__( self, key: Literal[ "name", "className", "qualifiedName", - "idaQualifiedName", "inheritedClasses", "address" + "idaQualifiedName", "address", "return_type", + "parameters" ] - ) -> Union[str, list[str], int]: + ) -> Union[str, list[str], int, bool]: return self.binding.__getitem__(key) # type: ignore def __str__(self) -> str: - return f"""name="{self.binding["name"]}" """ \ - f"""className="{self.binding["className"]}" """ \ - f"""qualifiedName="{self.binding["qualifiedName"]}" """ \ - f"""idaQualifiedName="{self.binding["idaQualifiedName"]}" """ \ - f"""inheritedClasses="{self.binding["inheritedClasses"]}" """ \ - f"""address="{self.binding["address"]}\"""" + return f"""name={self.binding["name"]}""" \ + f"""className={self.binding["className"]}""" \ + f"""qualifiedName={self.binding["qualifiedName"]}""" \ + f"""idaQualifiedName={self.binding["idaQualifiedName"]}""" \ + f"""address={hex(self.binding["address"])} """ \ + f"""is_overload={self.is_overload} """ \ + f"""{self.binding["return_type"]}({ + ', '.join(self.binding["parameters"]) + })""" def __hash__(self) -> int: return hash(( diff --git a/broma_ida/broma/constants.py b/broma_ida/broma/constants.py index 965fbc1..0a4a491 100644 --- a/broma_ida/broma/constants.py +++ b/broma_ida/broma/constants.py @@ -1,3 +1,4 @@ from typing import Literal +# no android32 nor android64 because they have symbols BROMA_PLATFORMS = Literal["win", "mac", "ios"] diff --git a/broma_ida/broma/exporter.py b/broma_ida/broma/exporter.py index 3a7eedc..419249a 100644 --- a/broma_ida/broma/exporter.py +++ b/broma_ida/broma/exporter.py @@ -1,20 +1,33 @@ -from typing import cast, Union +from typing import cast, Union, Generator, Any from os import path -from re import match, sub, Match +from idaapi import get_imagebase + +from re import search, match, sub, Match from shutil import move from broma_ida.broma.constants import BROMA_PLATFORMS -from broma_ida.binding_type import Binding +from broma_ida.broma.binding import Binding from broma_ida.utils import popup class BromaExporter: """Broma exporter of all time using regex (if you couldn't already tell)""" + + """ + group 1: class name + """ RX_CLASS = r"""class (\S+)""" - # TODO: also matches "... = mac 0x55; // mac 0x55" + + """ + group 1: "virtual", "callback", "static", or empty + group 2: return type + group 3: function name + group 4: comma-separated parameters or empty + group 5: comma-separated platform address(es) + """ RX_METHOD = \ - r"""^(?:\t| {4})(virtual|)(.* )?(\S+)\((.*)\)(?: const|)(?: = ((?:(?:win|mac|ios) (?:0[xX][0-9a-fA-F]+)(?:, )?)+))?;""" + r"""^(?:\t| {4})(?:\/\/ )?(virtual|callback|static|)(?: )?(?:(.*) )?(\S+)\((.*)\)(?: const|)(?: = ((?:(?:win|mac|ios) (?:0[xX][0-9a-fA-F]+)(?:, )?)+))?;""" # noqa: E501 RX_METHOD_PLAT_ADDR_BASE = r"""{platform} (0[xX][0-9a-fA-F]+)""" _filepath: str = "" @@ -72,11 +85,15 @@ def _get_broma_string( Returns: str: The Broma line with the address added """ + # function is inlined + if parsed_broma_line.string.endswith("{\n"): + return parsed_broma_line.string + self.num_exports += 1 # binding has no address associated to it if parsed_broma_line.string.endswith(");\n"): - # strip last two characters ";\n" then add the binding's address + # strip last two characters (";\n") then add the binding's address return f"""{ parsed_broma_line.string[:-2] } = { @@ -89,11 +106,12 @@ def _get_broma_string( # binding has another platform's address associated to it if self._target_platform not in broma_binding_platforms: - return f"""{ - parsed_broma_line.string[:-2] - }, { - self._target_platform - } {hex(binding["address"])};\n""" # type: ignore + print(f"exported {binding['qualifiedName']}") + return sub( + r"(?:(0[xX][0-9a-fA-F]+);)", + rf"""\1, {self._target_platform} {hex(binding["address"])};""", # type: ignore + parsed_broma_line.string, 1 + ) # binding has this platform's address associated to it if broma_binding_platforms[self._target_platform] != \ @@ -119,6 +137,7 @@ def _get_broma_string( return parsed_broma_line.string def __init__(self, platform: BROMA_PLATFORMS, file: str): + self._reset() self._target_platform = platform self._filepath = file @@ -143,6 +162,32 @@ def push_bindings(self, bindings: list[Binding]): for binding in bindings ]) + def import_from_idb(self, names: Generator[tuple[Any, Any], Any, None]): + """Imports bindings from an idautils.Names generator + + Args: + names (Generator[tuple[Any, Any], Any, None]): + The idautils.Names generator + """ + for ea, name in names: + if "::" not in name: + continue + + split_name = name.split("::") + + # ["GJUINode", "dGJUINode"] -> "GJUINode" == "GJUINode" + if split_name[0] == split_name[1][1:]: + split_name = [ + split_name[0], + split_name[1].replace("::d", "::~") + ] + + self.push_binding(Binding({ + "name": split_name[1], + "className": split_name[0], + "address": ea - get_imagebase() + }, search(r"\S+::\S+_[0-9]+$", name) is not None)) + def export(self): """Exports the bindings to the file TODO: handle function overloads""" @@ -191,7 +236,7 @@ def export(self): move(f"{self._filepath}.tmp", self._filepath) - def reset(self): + def _reset(self): """Resets a BromaExporter instance""" self._filepath = "" self._target_platform = "" # type: ignore diff --git a/broma_ida/broma/importer.py b/broma_ida/broma/importer.py new file mode 100644 index 0000000..cee2f45 --- /dev/null +++ b/broma_ida/broma/importer.py @@ -0,0 +1,234 @@ +from io import TextIOWrapper + +from idaapi import get_imagebase +from idc import ( + get_name as get_ea_name, get_func_flags, get_func_cmt, + set_func_cmt, + FUNC_LIB +) +from ida_funcs import get_func, add_func +from ida_kernwin import ASKBTN_BTN1, ASKBTN_CANCEL + +from re import sub + +from broma_ida.pybroma import Root + +from broma_ida.broma.constants import BROMA_PLATFORMS +from broma_ida.broma.binding import Binding +from broma_ida.utils import ( + get_platform_printable, get_short_info, + rename_func, popup, stop, + are_args_primitive +) + + +class BromaImporter: + """Broma importer of all time using PyBroma now!""" + _target_platform: BROMA_PLATFORMS + _file_path: str + + bindings: list[Binding] = [] + # { 0xaddr: [Binding, Binding, ...] } + duplicates: dict[int, list[Binding]] = {} + + def __init__(self, platform: BROMA_PLATFORMS): + """Initializes a BromaImporter instance + + Args: + platform (BROMA_PLATFORMS): The target platform + """ + self._reset() + self._target_platform = platform + + def parse_file_stream(self, file: TextIOWrapper): + """Parses a .bro file from a file stream + + Args: + file (TextIOWrapper): The file stream + + Returns: + tuple[list[Binding], dict[int, list[Binding]]]: + 0 contains unique bindings, 1 contains duplicates + """ + self._file_path = file.name + root = Root(self._file_path) + + for class_name, broma_class in root.classesAsDict().items(): + for field in broma_class.fields: + function_field = field.getAsFunctionBindField() + + if function_field is None: + continue + + function_address = function_field.binds.__getattribute__( + self._target_platform + ) + + if function_address == -1: + continue + + function = function_field.prototype + + # Runs only for the first time an address has a duplicate + if function_address in self.bindings: + dup_binding = self.bindings[ + self.bindings.index(function_address) + ] + error_location = \ + f"{class_name}::{function.name} " \ + f"and {dup_binding['qualifiedName']} " \ + f"@ {hex(function_address)}" + + if f"{class_name}::{function.name}" == \ + dup_binding['qualifiedName']: + print( + "[!] BromaImporter: Duplicate binding with " + f"same qualified name! ({error_location})" + ) + continue + elif class_name == dup_binding['className']: + print( + "[!] BromaImporter: Duplicate binding within " + f"same class! ({error_location})" + ) + continue + + print( + "[!] BromaImporter: Duplicate binding! " + f"({class_name}::{function.name} " + f"and {dup_binding['qualifiedName']} " + f"@ {hex(function_address)})" + ) + del self.bindings[self.bindings.index(dup_binding)] + self.duplicates[function_address] = [] + self.duplicates[function_address].append(dup_binding) + + if function_address in self.duplicates: + self.duplicates[function_address].append(Binding({ + "name": function.name, + "className": class_name, + "address": function_address, + "return_type": function.ret, + "parameters": function.args + })) + continue + + self.bindings.append(Binding({ + "name": function.name, + "className": class_name, + "address": function_address, + "return_type": function.ret, + "parameters": function.args + })) + + file.close() + + print( + f"\n\n[+] BromaImporter: Read {len(self.bindings)} " + f"{get_platform_printable(self._target_platform)} bindings " + f"and {len(self.duplicates)} duplicates " + f"from {self._file_path}\n\n" + ) + + def import_into_idb(self): + """Imports the bindings into the current idb""" + + # first, handle non-duplicates + for binding in self.bindings: + ida_ea = get_imagebase() + binding["address"] + ida_name = get_ea_name(ida_ea) + ida_func_flags = get_func_flags(ida_ea) + + if ida_name.startswith("loc_"): + add_func(ida_ea) + + if ida_func_flags & FUNC_LIB: + print( + f"[!] BromaImporter: Tried to rename a library function! " + f"({get_short_info(binding)})" + ) + continue + + if get_func(ida_ea).start_ea != ida_ea: + print( + f"[!] BromaImporter: Function is in the middle of " + f"another one! ({get_short_info(binding)})" + ) + continue + + # TODO: finish this + # if are_args_primitive(binding["parameters"]): # type: ignore + # SetType(get_screen_ea(), "") + + if ida_name.startswith("sub_"): + rename_func( + ida_ea, + binding["idaQualifiedName"] # type: ignore + ) + elif sub("_[0-9]+", "", ida_name) != binding["idaQualifiedName"]: + mismatch_popup = popup( + "Overwrite", "Keep", "", + f"""Mismatch in Broma ({binding["qualifiedName"]}) """ + f"and idb ({ida_name})!\n" + "Overwrite from Broma or keep current name?" + ) + + if mismatch_popup == ASKBTN_BTN1: + rename_func( + ida_ea, + binding["idaQualifiedName"] # type: ignore + ) + elif mismatch_popup == ASKBTN_CANCEL: + stop() + + # and now for what took me 3 hours :D + for addr, bindings in self.duplicates.items(): + ida_ea = get_imagebase() + addr + + func_cmt = get_func_cmt(ida_ea, True) + func_names = ", ".join( + [binding["qualifiedName"] + for binding in bindings] # type: ignore + ) + + if func_cmt == "": + # use the first occurrence as the name (very good imo) + rename_func( + ida_ea, + bindings[0]["idaQualifiedName"] # type: ignore + ) + + set_func_cmt(ida_ea, f"Merged with: {func_names}", True) + elif func_cmt.startswith("Merged with: "): + cmt_func_names = func_cmt.lstrip("Merged with: ") + + if set(func_names.split(", ")) != \ + set(cmt_func_names.split(", ")): + print( + "[!] BromaImporter: Mismatch in merged function list " + f"(Current: {cmt_func_names} | " + f"Correct: {func_names})! Correcting..." + ) + set_func_cmt( + ida_ea, f"Merged with: {func_names}", True + ) + else: + if popup( + "Overwrite", "Keep", None, + f"{hex(addr)} already has a comment! Would you like to " + "overwrite it with merge information or keep the current " + "comment?\n" + "(You will be prompted with this again if you rerun the " + "script and there are merged functions!)" + ) == ASKBTN_BTN1: + set_func_cmt( + ida_ea, f"Merged with: {func_names}", True + ) + + def _reset(self): + """Resets a BromaParser instance because not doing so results + in a re-run of the script populating the same bindings list""" + self._target_platform = "" # type: ignore + self._file_path = "" + self.bindings.clear() + self.duplicates.clear() diff --git a/broma_ida/broma/parser.py b/broma_ida/broma/parser.py deleted file mode 100644 index 2ff987c..0000000 --- a/broma_ida/broma/parser.py +++ /dev/null @@ -1,150 +0,0 @@ -from io import TextIOWrapper - -from broma_ida.broma.constants import BROMA_PLATFORMS -from broma_ida.binding_type import Binding - -from re import match - - -class BromaParser: - """Broma parser of all time using regex""" - RX_CLASS = r"""class (\S+)( : (.*))? \{""" - RX_METHOD_BASE = \ - r"""(?:\t| {4})(virtual|)(.* )?(\S+)\((.*)\)(?: const|) = .*{platform} (0[xX][0-9a-fA-F]+)""" # noqa: E501 - - _target_platform: BROMA_PLATFORMS - - bindings: list[Binding] = [] - # { "address": [Binding, Binding, ...] } - duplicates: dict[int, list[Binding]] = {} - - def _make_plat_method_regex(self, platform: BROMA_PLATFORMS) -> str: - """Makes a platform regex - - Args: - platform (BROMA_PLATFORMS): - platform name (win, mac or ios :trollface:) - - Returns: - str: RX_METHOD_BASE with the platform - """ - return self.RX_METHOD_BASE.replace("{platform}", platform) - - def _get_binding_of_address(self, addr: int) -> Binding: # type: ignore - """There are at most 1 binding in bindings_list, - so this will always return 1 binding (not None since - we never fabricate a binding (hopefully) - - Args: - addr (int): Address of binding to look for - - Returns: - Binding: The binding associated with that address - """ - for b in self.bindings: - if addr == b["address"]: - return b - - def __init__(self, platform: BROMA_PLATFORMS): - """Initializes a BromaParser instance for a specific platform - - Args: - platform (BROMA_PLATFORMS): Target platform - """ - self._target_platform = platform - - def parse_file_stream(self, file: TextIOWrapper): - """Parses a .bro file from a file stream - - Args: - file (TextIOWrapper): The file stream - - Returns: - tuple[list[Binding], dict[int, list[Binding]]]: - 0 contains unique bindings, 1 contains duplicates - """ - current_class_name: str = "" - current_class_inheritance: list[str] = [] - method_regex = self._make_plat_method_regex(self._target_platform) - - for line in file.readlines(): - if current_class_name == "": - current_class = match(self.RX_CLASS, line) - if current_class: - current_class_name = current_class.group(1) - - if current_class.group(2) is not None: - current_class_inheritance = \ - current_class.group(2).lstrip(" : ").split(", ") - - continue - - if line.startswith("}"): - current_class_name = "" - current_class_inheritance.clear() - continue - - func = match(method_regex, line) - if func is None: - continue - - func_address = int(func.group(5), 16) - func_name = func.group(3) - - # Runs only for the first time an address has a duplicate - if func_address in self.bindings: - dup_binding = self._get_binding_of_address(func_address) - error_location = \ - f"{current_class_name}::{func_name} " \ - f"and {dup_binding['qualifiedName']} " \ - f"@ {hex(func_address)}" - - if f"{current_class_name}::{func_name}" == \ - dup_binding['qualifiedName']: - print( - "[!] Duplicate binding with same qualified name! " - f"({error_location})" - ) - continue - elif current_class_name == dup_binding['className']: - print( - "[!] Duplicate binding within same class! " - f"({error_location})" - ) - continue - - print( - "[!] Duplicate binding! " - f"({current_class_name}::{func_name} " - f"and {dup_binding['qualifiedName']} " - f"@ {hex(func_address)})" - ) - del self.bindings[self.bindings.index(dup_binding)] - self.duplicates[func_address] = [] - self.duplicates[func_address].append(dup_binding) - - if func_address in self.duplicates: - self.duplicates[func_address].append(Binding({ - "name": func_name, - "className": current_class_name, - "inheritedClasses": current_class_inheritance[:], - "address": func_address - })) - continue - - # print(f"{current_class_name}::{func_name} = {hex(func_address)}") - - self.bindings.append(Binding({ - "name": func_name, - "className": current_class_name, - "inheritedClasses": current_class_inheritance[:], - "address": func_address - })) - - file.close() - - def reset(self): - """Resets a BromaParser instance""" - self._target_platform = "" # type: ignore - self.bindings.clear() - self.duplicates.clear() diff --git a/broma_ida/pybroma/PyBroma.cp310-win_amd64.pyd b/broma_ida/pybroma/PyBroma.cp310-win_amd64.pyd new file mode 100644 index 0000000000000000000000000000000000000000..17e646e7ceb0f4f52cd904d10cb1c6185e53b684 GIT binary patch literal 247296 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 literal 0 HcmV?d00001 diff --git a/broma_ida/pybroma/PyBroma.cpp b/broma_ida/pybroma/PyBroma.cpp new file mode 100644 index 0000000..814436e --- /dev/null +++ b/broma_ida/pybroma/PyBroma.cpp @@ -0,0 +1,24420 @@ +/* Generated by Cython 3.0.10 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "pybroma\\include\\ast.hpp", + "pybroma\\include\\broma.hpp", + "pybroma\\include\\helper.hpp" + ], + "extra_compile_args": [ + "/std:c++17" + ], + "extra_link_args": [ + "pybroma/link/Broma.lib" + ], + "include_dirs": [ + "pybroma" + ], + "language": "c++", + "name": "pybroma.PyBroma", + "sources": [ + "pybroma/PyBroma.pyx" + ] + }, + "module_name": "pybroma.PyBroma" +} +END: Cython Metadata */ + +#ifndef PY_SSIZE_T_CLEAN +#define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ +#if defined(CYTHON_LIMITED_API) && 0 + #ifndef Py_LIMITED_API + #if CYTHON_LIMITED_API+0 > 0x03030000 + #define Py_LIMITED_API CYTHON_LIMITED_API + #else + #define Py_LIMITED_API 0x03030000 + #endif + #endif +#endif + +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.7+ or Python 3.3+. +#else +#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API +#define __PYX_EXTRA_ABI_MODULE_NAME "limited" +#else +#define __PYX_EXTRA_ABI_MODULE_NAME "" +#endif +#define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." +#define CYTHON_HEX_VERSION 0x03000AF0 +#define CYTHON_FUTURE_DIVISION 1 +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#define __PYX_COMMA , +#ifndef HAVE_LONG_LONG + #define HAVE_LONG_LONG +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX +#if defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API + #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_CLINE_IN_TRACEBACK + #define CYTHON_CLINE_IN_TRACEBACK 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #endif + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 1 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #ifndef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #endif +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #if PY_VERSION_HEX < 0x030400a1 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #elif !defined(CYTHON_USE_TP_FINALIZE) + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #if PY_VERSION_HEX < 0x030600B1 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) + #endif + #if PY_VERSION_HEX < 0x030700A3 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #elif !defined(CYTHON_USE_EXC_INFO_STACK) + #define CYTHON_USE_EXC_INFO_STACK 1 + #endif + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 1 + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if !defined(CYTHON_VECTORCALL) +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_MAJOR_VERSION < 3 + #include "longintrepr.h" + #endif + #undef SHIFT + #undef BASE + #undef MASK + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + #endif +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_USE_CPP_STD_MOVE + #if defined(__cplusplus) && (\ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) +#ifdef _MSC_VER + #ifndef _MSC_STDINT_H_ + #if _MSC_VER < 1300 + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + #endif + #endif + #if _MSC_VER < 1300 + #ifdef _WIN64 + typedef unsigned long long __pyx_uintptr_t; + #else + typedef unsigned int __pyx_uintptr_t; + #endif + #else + #ifdef _WIN64 + typedef unsigned __int64 __pyx_uintptr_t; + #else + typedef unsigned __int32 __pyx_uintptr_t; + #endif + #endif +#else + #include + typedef uintptr_t __pyx_uintptr_t; +#endif +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + #if defined(__clang__) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) + +#ifndef __cplusplus + #error "Cython files generated with the C++ option must be compiled with a C++ compiler." +#endif +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #else + #define CYTHON_INLINE inline + #endif +#endif +template +void __Pyx_call_destructor(T& x) { + x.~T(); +} +template +class __Pyx_FakeReference { + public: + __Pyx_FakeReference() : ptr(NULL) { } + __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { } + T *operator->() { return ptr; } + T *operator&() { return ptr; } + operator T&() { return *ptr; } + template bool operator ==(const U& other) const { return *ptr == other; } + template bool operator !=(const U& other) const { return *ptr != other; } + template bool operator==(const __Pyx_FakeReference& other) const { return *ptr == *other.ptr; } + template bool operator!=(const __Pyx_FakeReference& other) const { return *ptr != *other.ptr; } + private: + T *ptr; +}; + +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_DefaultClassType PyClass_Type + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_DefaultClassType PyType_Type +#if CYTHON_COMPILING_IN_LIMITED_API + static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyObject *exception_table = NULL; + PyObject *types_module=NULL, *code_type=NULL, *result=NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 + PyObject *version_info; + PyObject *py_minor_version = NULL; + #endif + long minor_version = 0; + PyObject *type, *value, *traceback; + PyErr_Fetch(&type, &value, &traceback); + #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); + } + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); + if (type) { + PyErr_Restore(type, value, traceback); + } + return result; + } + #ifndef CO_OPTIMIZED + #define CO_OPTIMIZED 0x0001 + #endif + #ifndef CO_NEWLOCALS + #define CO_NEWLOCALS 0x0002 + #endif + #ifndef CO_VARARGS + #define CO_VARARGS 0x0004 + #endif + #ifndef CO_VARKEYWORDS + #define CO_VARKEYWORDS 0x0008 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x0200 + #endif + #ifndef CO_GENERATOR + #define CO_GENERATOR 0x0020 + #endif + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x0080 + #endif +#elif PY_VERSION_HEX >= 0x030B0000 + static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); + if (!empty_bytes) return NULL; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); + Py_DECREF(empty_bytes); + return result; + } +#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#else + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#endif +#endif +#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) +#endif +#ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 +#endif +#ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif +#ifndef METH_STACKLESS + #define METH_STACKLESS 0 +#endif +#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) + #ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif +#endif +#if CYTHON_METH_FASTCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#elif CYTHON_BACKPORT_VECTORCALL + typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#if PY_MAJOR_VERSION >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#endif +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} +#endif +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; +#else + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +#endif +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if __PYX_LIMITED_VERSION_HEX < 0x030900B1 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); +#else + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() +#elif PY_VERSION_HEX >= 0x03060000 + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#elif PY_VERSION_HEX >= 0x03000000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_Current +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) +{ + void *result; + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; +} +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) +#endif +#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) +#include "pythread.h" +#define Py_tss_NEEDS_INIT 0 +typedef int Py_tss_t; +static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { + *key = PyThread_create_key(); + return 0; +} +static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { + Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); + *key = Py_tss_NEEDS_INIT; + return key; +} +static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { + PyObject_Free(key); +} +static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { + return *key != Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { + PyThread_delete_key(*key); + *key = Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { + return PyThread_set_key_value(*key, value); +} +static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { + return PyThread_get_key_value(*key); +} +#endif +#if PY_MAJOR_VERSION < 3 + #if CYTHON_COMPILING_IN_PYPY + #if PYPY_VERSION_NUM < 0x07030600 + #if defined(__cplusplus) && __cplusplus >= 201402L + [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] + #elif defined(__GNUC__) || defined(__clang__) + __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) + #elif defined(_MSC_VER) + __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) + #endif + static CYTHON_INLINE int PyGILState_Check(void) { + return 0; + } + #else // PYPY_VERSION_NUM < 0x07030600 + #endif // PYPY_VERSION_NUM < 0x07030600 + #else + static CYTHON_INLINE int PyGILState_Check(void) { + PyThreadState * tstate = _PyThreadState_Current; + return tstate && (tstate == PyGILState_GetThisThreadState()); + } + #endif +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif +#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL) PyErr_Clear(); + return res; +} +#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) + #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) + #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) +#else + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) +#endif +#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 +#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ + PyTypeObject *type = Py_TYPE((PyObject*)obj);\ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ + PyObject_GC_Del(obj);\ + Py_DECREF(type);\ +} +#else +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_READY(op) (0) + #else + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #endif + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, (Py_UCS4) ch) + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #else + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif + #endif +#else + #define CYTHON_PEP393_ENABLED 0 + #define PyUnicode_1BYTE_KIND 1 + #define PyUnicode_2BYTE_KIND 2 + #define PyUnicode_4BYTE_KIND 4 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) + #undef PyUnicode_Contains + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#ifndef PyObject_Unicode + #define PyObject_Unicode PyObject_Str +#endif +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#if CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#else + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) +#endif +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) + #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) +#else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define __Pyx_Py3Int_Check(op) PyLong_Check(op) + #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#else + #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) + #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef __Pyx_PyAsyncMethodsStruct + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; +#endif + +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #if !defined(_USE_MATH_DEFINES) + #define _USE_MATH_DEFINES + #endif +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + +#define __PYX_MARK_ERR_POS(f_index, lineno) \ + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifdef CYTHON_EXTERN_C + #undef __PYX_EXTERN_C + #define __PYX_EXTERN_C CYTHON_EXTERN_C +#elif defined(__PYX_EXTERN_C) + #ifdef _MSC_VER + #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") + #else + #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. + #endif +#else + #define __PYX_EXTERN_C extern "C++" +#endif + +#define __PYX_HAVE__pybroma__PyBroma +#define __PYX_HAVE_API__pybroma__PyBroma +/* Early includes */ +#include +#include +#include "ios" +#include "new" +#include "stdexcept" +#include "typeinfo" +#include +#include + + #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600) + // move should be defined for these versions of MSVC, but __cplusplus isn't set usefully + #include + + namespace cython_std { + template typename std::remove_reference::type&& move(T& t) noexcept { return std::move(t); } + template typename std::remove_reference::type&& move(T&& t) noexcept { return std::move(t); } + } + + #endif + +#include +#include "include/ast.hpp" +#include "include/helper.hpp" +#include "include/broma.hpp" + +#define DEPACK(x) *x + +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 1 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) +#define __PYX_DEFAULT_STRING_ENCODING "utf8" +#define __Pyx_PyObject_FromString __Pyx_PyUnicode_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { + return (size_t) i < (size_t) limit; +} +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) + #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +#define __Pyx_PySequence_Tuple(obj)\ + (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); +#if CYTHON_ASSUME_SAFE_MACROS +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif +#endif +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +#include +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = (char) c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#include +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } + +#if !CYTHON_USE_MODULE_STATE +static PyObject *__pyx_m = NULL; +#endif +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm = __FILE__; +static const char *__pyx_filename; + +/* #### Code section: filename_table ### */ + +static const char *__pyx_f[] = { + "pybroma\\\\PyBroma.pyx", + "", +}; +/* #### Code section: utility_code_proto_before_types ### */ +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + +/* EnumClassDecl.proto */ +#if defined (_MSC_VER) + #if _MSC_VER >= 1910 + #define __PYX_ENUM_CLASS_DECL enum + #else + #define __PYX_ENUM_CLASS_DECL + #endif +#else + #define __PYX_ENUM_CLASS_DECL enum +#endif + +/* #### Code section: numeric_typedefs ### */ + +/* "pybroma/broma.pxd":9 + * + * + * ctypedef long long ptrdiff_t # <<<<<<<<<<<<<< + * + * cdef extern from "include/ast.hpp" namespace "broma" nogil: + */ +typedef PY_LONG_LONG __pyx_t_7pybroma_5broma_ptrdiff_t; +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ + +/*--- Type declarations ---*/ +struct __pyx_obj_7pybroma_7PyBroma_ImmutableError; +struct __pyx_obj_7pybroma_7PyBroma_Type; +struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto; +struct __pyx_obj_7pybroma_7PyBroma_MemberField; +struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField; +struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField; +struct __pyx_obj_7pybroma_7PyBroma_PadField; +struct __pyx_obj_7pybroma_7PyBroma_Field; +struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber; +struct __pyx_obj_7pybroma_7PyBroma_InlineField; +struct __pyx_obj_7pybroma_7PyBroma_FunctionProto; +struct __pyx_obj_7pybroma_7PyBroma_Function; +struct __pyx_obj_7pybroma_7PyBroma_Class; +struct __pyx_obj_7pybroma_7PyBroma_Root; + +/* "pybroma/PyBroma.pyx":26 + * broma.Class DEPACK(broma.Class* x) + * + * cdef class ImmutableError(Exception): # <<<<<<<<<<<<<< + * """Object is an immutable property and cannot mutate""" + * def __init__(self, str name): + */ +struct __pyx_obj_7pybroma_7PyBroma_ImmutableError { + PyBaseExceptionObject __pyx_base; +}; + + +/* "pybroma/PyBroma.pyx":33 + * + * + * cdef class Type: # <<<<<<<<<<<<<< + * cdef: + * broma.Type type + */ +struct __pyx_obj_7pybroma_7PyBroma_Type { + PyObject_HEAD + struct broma::Type type; +}; + + +/* "pybroma/PyBroma.pyx":62 + * + * + * cdef class MemberFunctionProto: # <<<<<<<<<<<<<< + * cdef: + * broma.MemberFunctionProto proto + */ +struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto { + PyObject_HEAD + struct __pyx_vtabstruct_7pybroma_7PyBroma_MemberFunctionProto *__pyx_vtab; + struct broma::MemberFunctionProto proto; + PyObject *_args; +}; + + +/* "pybroma/PyBroma.pyx":125 + * + * + * cdef class MemberField: # <<<<<<<<<<<<<< + * cdef: + * broma.MemberField field + */ +struct __pyx_obj_7pybroma_7PyBroma_MemberField { + PyObject_HEAD + struct broma::MemberField field; +}; + + +/* "pybroma/PyBroma.pyx":154 + * + * + * cdef class OutOfLineField: # <<<<<<<<<<<<<< + * cdef: + * broma.OutOfLineField oolf + */ +struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField { + PyObject_HEAD + struct broma::OutOfLineField oolf; +}; + + +/* "pybroma/PyBroma.pyx":177 + * + * + * cdef class FunctionBindField: # <<<<<<<<<<<<<< + * cdef broma.FunctionBindField fbf + * def __cinit__(self): + */ +struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField { + PyObject_HEAD + struct broma::FunctionBindField fbf; +}; + + +/* "pybroma/PyBroma.pyx":197 + * + * + * cdef class PadField: # <<<<<<<<<<<<<< + * cdef: + * broma.PadField pf + */ +struct __pyx_obj_7pybroma_7PyBroma_PadField { + PyObject_HEAD + struct broma::PadField pf; +}; + + +/* "pybroma/PyBroma.pyx":221 + * + * + * cdef class Field: # <<<<<<<<<<<<<< + * cdef: + * broma.Field field + */ +struct __pyx_obj_7pybroma_7PyBroma_Field { + PyObject_HEAD + struct broma::Field field; +}; + + +/* "pybroma/PyBroma.pyx":269 + * + * + * cdef class PlatformNumber: # <<<<<<<<<<<<<< + * cdef: + * broma.PlatformNumber binds + */ +struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber { + PyObject_HEAD + struct broma::PlatformNumber binds; +}; + + +/* "pybroma/PyBroma.pyx":305 + * + * + * cdef class InlineField: # <<<<<<<<<<<<<< + * cdef broma.InlineField _if + * def __cinit__(self): + */ +struct __pyx_obj_7pybroma_7PyBroma_InlineField { + PyObject_HEAD + struct broma::InlineField _if; +}; + + +/* "pybroma/PyBroma.pyx":322 + * + * + * cdef class FunctionProto: # <<<<<<<<<<<<<< + * cdef: + * broma.FunctionProto proto + */ +struct __pyx_obj_7pybroma_7PyBroma_FunctionProto { + PyObject_HEAD + struct __pyx_vtabstruct_7pybroma_7PyBroma_FunctionProto *__pyx_vtab; + struct broma::FunctionProto proto; + PyObject *_args; +}; + + +/* "pybroma/PyBroma.pyx":366 + * + * + * cdef class Function: # <<<<<<<<<<<<<< + * cdef: + * broma.Function func + */ +struct __pyx_obj_7pybroma_7PyBroma_Function { + PyObject_HEAD + struct broma::Function func; +}; + + +/* "pybroma/PyBroma.pyx":397 + * + * + * cdef class Class: # <<<<<<<<<<<<<< + * cdef: + * broma.Class _cls + */ +struct __pyx_obj_7pybroma_7PyBroma_Class { + PyObject_HEAD + struct broma::Class _cls; + PyObject *_superclasses; + int _superclasses_ran; + PyObject *_depends; + int _depends_ran; +}; + + +/* "pybroma/PyBroma.pyx":468 + * + * + * cdef class Root: # <<<<<<<<<<<<<< + * cdef: + * broma.Root root + */ +struct __pyx_obj_7pybroma_7PyBroma_Root { + PyObject_HEAD + struct broma::Root root; +}; + + + +/* "pybroma/PyBroma.pyx":62 + * + * + * cdef class MemberFunctionProto: # <<<<<<<<<<<<<< + * cdef: + * broma.MemberFunctionProto proto + */ + +struct __pyx_vtabstruct_7pybroma_7PyBroma_MemberFunctionProto { + void (*init)(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *, struct broma::MemberFunctionProto); +}; +static struct __pyx_vtabstruct_7pybroma_7PyBroma_MemberFunctionProto *__pyx_vtabptr_7pybroma_7PyBroma_MemberFunctionProto; + + +/* "pybroma/PyBroma.pyx":322 + * + * + * cdef class FunctionProto: # <<<<<<<<<<<<<< + * cdef: + * broma.FunctionProto proto + */ + +struct __pyx_vtabstruct_7pybroma_7PyBroma_FunctionProto { + void (*init)(struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *, struct broma::FunctionProto); +}; +static struct __pyx_vtabstruct_7pybroma_7PyBroma_FunctionProto *__pyx_vtabptr_7pybroma_7PyBroma_FunctionProto; +/* #### Code section: utility_code_proto ### */ + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) + #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() +#endif + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_Py_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; Py_XDECREF(tmp);\ + } while (0) +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#endif +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* DictGetItem.proto */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); +#define __Pyx_PyObject_Dict_GetItem(obj, name)\ + (likely(PyDict_CheckExact(obj)) ?\ + __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) +#else +#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) +#endif + +/* GetTopmostException.proto */ +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE +static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); +#endif + +/* SaveResetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +#else +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/* GetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* MoveIfSupported.proto */ +#if CYTHON_USE_CPP_STD_MOVE + #include + #define __PYX_STD_MOVE_IF_SUPPORTED(x) std::move(x) +#else + #define __PYX_STD_MOVE_IF_SUPPORTED(x) x +#endif + +/* TupleAndListFromArray.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* fastcall.proto */ +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) +#else + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) +#endif +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) + #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) +#else + #define __Pyx_Arg_NewRef_VARARGS(arg) arg + #define __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) +#define __Pyx_KwValues_VARARGS(args, nargs) NULL +#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) +#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) +#if CYTHON_METH_FASTCALL + #define __Pyx_Arg_FASTCALL(args, i) args[i] + #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) + #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) + static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif + #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs + to have the same reference counting */ + #define __Pyx_Arg_XDECREF_FASTCALL(arg) +#else + #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS + #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS + #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) + #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) +#else +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) +#endif + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, + PyObject **argnames[], + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, + const char* function_name); + +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#if !CYTHON_VECTORCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); +#endif +#define __Pyx_BUILD_ASSERT_EXPR(cond)\ + (sizeof(char [1 - 2*!(cond)]) - 1) +#ifndef Py_MEMBER_SIZE +#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) +#endif +#if !CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03080000 + #include "frameobject.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif + #define __Pxy_PyFrame_Initialize_Offsets() + #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) +#else + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" + #define __Pxy_PyFrame_Initialize_Offsets()\ + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) + #define __Pyx_PyFrame_GetLocalsplus(frame)\ + (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#endif +#endif +#endif + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectFastCall.proto */ +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs); + +/* KeywordStringCheck.proto */ +static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); + +/* GetAttr3.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); + +/* PyDictVersioning.proto */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) +#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ + (version_var) = __PYX_GET_DICT_VERSION(dict);\ + (cache_var) = (value); +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ + (VAR) = __pyx_dict_cached_value;\ + } else {\ + (VAR) = __pyx_dict_cached_value = (LOOKUP);\ + __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ + }\ +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); +#else +#define __PYX_GET_DICT_VERSION(dict) (0) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); +#endif + +/* GetModuleGlobalName.proto */ +#if CYTHON_USE_DICT_VERSIONS +#define __Pyx_GetModuleGlobalName(var, name) do {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ + (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ + __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ + PY_UINT64_T __pyx_dict_version;\ + PyObject *__pyx_dict_cached_value;\ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); +#else +#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) +#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); +#endif + +/* RaiseUnexpectedTypeError.proto */ +static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* PyObjectCallNoArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); + +/* WriteUnraisableException.proto */ +static void __Pyx_WriteUnraisable(const char *name, int clineno, + int lineno, const char *filename, + int full_traceback, int nogil); + +/* ListCompAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len)) { + Py_INCREF(x); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + L->ob_item[len] = x; + #else + PyList_SET_ITEM(list, len, x); + #endif + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) +#endif + +/* PySequenceContains.proto */ +static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { + int result = PySequence_Contains(seq, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* ImportFrom.proto */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +/* GetAttr.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); + +/* HasAttr.proto */ +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 +#define __Pyx_HasAttr(o, n) PyObject_HasAttrWithError(o, n) +#else +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); +#endif + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +/* IncludeStructmemberH.proto */ +#include + +/* FixUpExtensionType.proto */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); +#endif + +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#else +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + +/* ValidateExternBase.proto */ +static int __Pyx_validate_extern_base(PyTypeObject *base); + +/* PyObjectGetMethod.proto */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); + +/* PyObjectCallMethod0.proto */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); + +/* ValidateBasesTuple.proto */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); +#endif + +/* PyType_Ready.proto */ +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); + +/* PyObject_GenericGetAttrNoDict.proto */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr +#endif + +/* PyObject_GenericGetAttr.proto */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr +#endif + +/* SetupReduce.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_setup_reduce(PyObject* type_obj); +#endif + +/* SetVTable.proto */ +static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); + +/* GetVTable.proto */ +static void* __Pyx_GetVtable(PyTypeObject *type); + +/* MergeVTables.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_MergeVtables(PyTypeObject *type); +#endif + +/* FetchSharedCythonModule.proto */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* FetchCommonType.proto */ +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); +#else +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); +#endif + +/* PyMethodNew.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + typesModule = PyImport_ImportModule("types"); + if (!typesModule) return NULL; + methodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + if (!methodType) return NULL; + result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); + Py_DECREF(methodType); + return result; +} +#elif PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + return PyMethod_New(func, self); +} +#else + #define __Pyx_PyMethod_New PyMethod_New +#endif + +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); +#endif + +/* CythonFunctionShared.proto */ +#define __Pyx_CyFunction_USED +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#else + #define __Pyx_CyFunction_GetClassObj(f)\ + ((PyObject*) ((PyCMethodObject *) (f))->mm_class) +#endif +#define __Pyx_CyFunction_SetClassObj(f, classobj)\ + __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject_HEAD + PyObject *func; +#elif PY_VERSION_HEX < 0x030900B1 + PyCFunctionObject func; +#else + PyCMethodObject func; +#endif +#if CYTHON_BACKPORT_VECTORCALL + __pyx_vectorcallfunc func_vectorcall; +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_classobj; +#endif + void *defaults; + int defaults_pyobjects; + size_t defaults_size; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; + PyObject *func_is_coroutine; +} __pyx_CyFunctionObject; +#undef __Pyx_CyOrPyCFunction_Check +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); +#undef __Pyx_IsSameCFunction +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(PyObject *module); +#if CYTHON_METH_FASTCALL +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#if CYTHON_BACKPORT_VECTORCALL +#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) +#else +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) +#endif +#endif + +/* CythonFunction.proto */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); + +/* CLineInTraceback.proto */ +#ifdef CYTHON_CLINE_IN_TRACEBACK +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#else +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#endif + +/* CodeObjectCache.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API +typedef struct { + PyCodeObject* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); +#endif + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* None.proto */ +#include + +/* GCCDiagnostics.proto */ +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + +static PyObject* __pyx_convert__to_py_struct__broma_3a__3a_Type(struct broma::Type s); +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_ptrdiff_t(ptrdiff_t value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* CppExceptionConversion.proto */ +#ifndef __Pyx_CppExn2PyErr +#include +#include +#include +#include +static void __Pyx_CppExn2PyErr() { + try { + if (PyErr_Occurred()) + ; // let the latest Python exn pass through and ignore the current one + else + throw; + } catch (const std::bad_alloc& exn) { + PyErr_SetString(PyExc_MemoryError, exn.what()); + } catch (const std::bad_cast& exn) { + PyErr_SetString(PyExc_TypeError, exn.what()); + } catch (const std::bad_typeid& exn) { + PyErr_SetString(PyExc_TypeError, exn.what()); + } catch (const std::domain_error& exn) { + PyErr_SetString(PyExc_ValueError, exn.what()); + } catch (const std::invalid_argument& exn) { + PyErr_SetString(PyExc_ValueError, exn.what()); + } catch (const std::ios_base::failure& exn) { + PyErr_SetString(PyExc_IOError, exn.what()); + } catch (const std::out_of_range& exn) { + PyErr_SetString(PyExc_IndexError, exn.what()); + } catch (const std::overflow_error& exn) { + PyErr_SetString(PyExc_OverflowError, exn.what()); + } catch (const std::range_error& exn) { + PyErr_SetString(PyExc_ArithmeticError, exn.what()); + } catch (const std::underflow_error& exn) { + PyErr_SetString(PyExc_ArithmeticError, exn.what()); + } catch (const std::exception& exn) { + PyErr_SetString(PyExc_RuntimeError, exn.what()); + } + catch (...) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown exception"); + } +} +#endif + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); +#else +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) +#endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) + +/* CheckBinaryVersion.proto */ +static unsigned long __Pyx_get_runtime_version(void); +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); + +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + +/* #### Code section: module_declarations ### */ +static void __pyx_f_7pybroma_7PyBroma_19MemberFunctionProto_init(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self, struct broma::MemberFunctionProto __pyx_v_proto); /* proto*/ +static void __pyx_f_7pybroma_7PyBroma_13FunctionProto_init(struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_v_self, struct broma::FunctionProto __pyx_v_proto); /* proto*/ + +/* Module declarations from "libc.string" */ + +/* Module declarations from "libcpp.string" */ + +/* Module declarations from "libcpp.vector" */ + +/* Module declarations from "libcpp.utility" */ + +/* Module declarations from "libcpp" */ + +/* Module declarations from "libc.stdlib" */ + +/* Module declarations from "pybroma.broma" */ + +/* Module declarations from "cython" */ + +/* Module declarations from "pybroma.PyBroma" */ +static struct __pyx_obj_7pybroma_7PyBroma_Type *__pyx_f_7pybroma_7PyBroma_make_type(struct broma::Type); /*proto*/ +static struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_f_7pybroma_7PyBroma_make_MemberFunctionProto(struct broma::MemberFunctionProto); /*proto*/ +static struct __pyx_obj_7pybroma_7PyBroma_MemberField *__pyx_f_7pybroma_7PyBroma_make_MemberField(struct broma::MemberField); /*proto*/ +static struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *__pyx_f_7pybroma_7PyBroma_make_OutOfLineField(struct broma::OutOfLineField); /*proto*/ +static struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *__pyx_f_7pybroma_7PyBroma_make_FunctionBindField(struct broma::FunctionBindField); /*proto*/ +static struct __pyx_obj_7pybroma_7PyBroma_PadField *__pyx_f_7pybroma_7PyBroma_make_PadField(struct broma::PadField); /*proto*/ +static struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_f_7pybroma_7PyBroma_make_Field(struct broma::Field); /*proto*/ +static struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *__pyx_f_7pybroma_7PyBroma_make_PlatfornNum(struct broma::PlatformNumber); /*proto*/ +static struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_f_7pybroma_7PyBroma_make_FunctionProto(struct broma::FunctionProto); /*proto*/ +static struct __pyx_obj_7pybroma_7PyBroma_Function *__pyx_f_7pybroma_7PyBroma_make_Function(struct broma::Function); /*proto*/ +static PyObject *__pyx_f_7pybroma_7PyBroma_make_Class(struct broma::Class); /*proto*/ +static PyObject *__pyx_f_7pybroma_7PyBroma___pyx_unpickle_ImmutableError__set_state(struct __pyx_obj_7pybroma_7PyBroma_ImmutableError *, PyObject *); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string(std::string const &); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(std::string const &); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_convert_PyStr_string_to_py_6libcpp_6string_std__in_string(std::string const &); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string(std::string const &); /*proto*/ +static CYTHON_INLINE PyObject *__pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string(std::string const &); /*proto*/ +static std::string __pyx_convert_string_from_py_6libcpp_6string_std__in_string(PyObject *); /*proto*/ +static struct broma::Type __pyx_convert__from_py_struct__broma_3a__3a_Type(PyObject *); /*proto*/ +/* #### Code section: typeinfo ### */ +/* #### Code section: before_global_var ### */ +#define __Pyx_MODULE_NAME "pybroma.PyBroma" +extern int __pyx_module_is_main_pybroma__PyBroma; +int __pyx_module_is_main_pybroma__PyBroma = 0; + +/* Implementation of "pybroma.PyBroma" */ +/* #### Code section: global_var ### */ +static PyObject *__pyx_builtin_super; +static PyObject *__pyx_builtin_TypeError; +static PyObject *__pyx_builtin_range; +static PyObject *__pyx_builtin_KeyError; +static PyObject *__pyx_builtin_ValueError; +/* #### Code section: string_decls ### */ +static const char __pyx_k_c[] = "c"; +static const char __pyx_k_x[] = "x"; +static const char __pyx_k_gc[] = "gc"; +static const char __pyx_k_id[] = "id"; +static const char __pyx_k__12[] = "."; +static const char __pyx_k__13[] = "?"; +static const char __pyx_k_new[] = "__new__"; +static const char __pyx_k_Root[] = "Root"; +static const char __pyx_k_Type[] = "Type"; +static const char __pyx_k_args[] = "args"; +static const char __pyx_k_dict[] = "__dict__"; +static const char __pyx_k_init[] = "__init__"; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_name[] = "name"; +static const char __pyx_k_self[] = "self"; +static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_Class[] = "Class"; +static const char __pyx_k_Field[] = "Field"; +static const char __pyx_k_links[] = "links"; +static const char __pyx_k_range[] = "range"; +static const char __pyx_k_state[] = "state"; +static const char __pyx_k_super[] = "super"; +static const char __pyx_k_dict_2[] = "_dict"; +static const char __pyx_k_dict_3[] = "dict"; +static const char __pyx_k_enable[] = "enable"; +static const char __pyx_k_fields[] = "fields"; +static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_name_2[] = "__name__"; +static const char __pyx_k_pickle[] = "pickle"; +static const char __pyx_k_reduce[] = "__reduce__"; +static const char __pyx_k_return[] = "return"; +static const char __pyx_k_update[] = "update"; +static const char __pyx_k_depends[] = "depends"; +static const char __pyx_k_disable[] = "disable"; +static const char __pyx_k_missing[] = "missing"; +static const char __pyx_k_Function[] = "Function"; +static const char __pyx_k_KeyError[] = "KeyError"; +static const char __pyx_k_PadField[] = "PadField"; +static const char __pyx_k_fileName[] = "fileName"; +static const char __pyx_k_getstate[] = "__getstate__"; +static const char __pyx_k_pyx_type[] = "__pyx_type"; +static const char __pyx_k_setstate[] = "__setstate__"; +static const char __pyx_k_TypeError[] = "TypeError"; +static const char __pyx_k_is_struct[] = "is_struct"; +static const char __pyx_k_isenabled[] = "isenabled"; +static const char __pyx_k_pyx_state[] = "__pyx_state"; +static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; +static const char __pyx_k_ValueError[] = "ValueError"; +static const char __pyx_k_pyx_result[] = "__pyx_result"; +static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static const char __pyx_k_superclass[] = "superclass"; +static const char __pyx_k_InlineField[] = "InlineField"; +static const char __pyx_k_MemberField[] = "MemberField"; +static const char __pyx_k_PickleError[] = "PickleError"; +static const char __pyx_k_is_coroutine[] = "_is_coroutine"; +static const char __pyx_k_is_immutable[] = " is immutable"; +static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; +static const char __pyx_k_stringsource[] = ""; +static const char __pyx_k_use_setstate[] = "use_setstate"; +static const char __pyx_k_FunctionProto[] = "FunctionProto"; +static const char __pyx_k_classesAsDict[] = "classesAsDict"; +static const char __pyx_k_getAsPadField[] = "getAsPadField"; +static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; +static const char __pyx_k_ImmutableError[] = "ImmutableError"; +static const char __pyx_k_OutOfLineField[] = "OutOfLineField"; +static const char __pyx_k_PlatformNumber[] = "PlatformNumber"; +static const char __pyx_k_functionsAsDict[] = "functionsAsDict"; +static const char __pyx_k_pybroma_PyBroma[] = "pybroma.PyBroma"; +static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; +static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; +static const char __pyx_k_getAsMemberField[] = "getAsMemberField"; +static const char __pyx_k_FunctionBindField[] = "FunctionBindField"; +static const char __pyx_k_Root_classesAsDict[] = "Root.classesAsDict"; +static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; +static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_Field_getAsPadField[] = "Field.getAsPadField"; +static const char __pyx_k_MemberFunctionProto[] = "MemberFunctionProto"; +static const char __pyx_k_getAsOutOfLineField[] = "getAsOutOfLineField"; +static const char __pyx_k_pybroma_PyBroma_pyx[] = "pybroma\\PyBroma.pyx"; +static const char __pyx_k_Root___reduce_cython[] = "Root.__reduce_cython__"; +static const char __pyx_k_Root_functionsAsDict[] = "Root.functionsAsDict"; +static const char __pyx_k_Type___reduce_cython[] = "Type.__reduce_cython__"; +static const char __pyx_k_Class___reduce_cython[] = "Class.__reduce_cython__"; +static const char __pyx_k_Field___reduce_cython[] = "Field.__reduce_cython__"; +static const char __pyx_k_Field_getAsMemberField[] = "Field.getAsMemberField"; +static const char __pyx_k_Root___setstate_cython[] = "Root.__setstate_cython__"; +static const char __pyx_k_Type___setstate_cython[] = "Type.__setstate_cython__"; +static const char __pyx_k_getAsFunctionBindField[] = "getAsFunctionBindField"; +static const char __pyx_k_Class___setstate_cython[] = "Class.__setstate_cython__"; +static const char __pyx_k_Field___setstate_cython[] = "Field.__setstate_cython__"; +static const char __pyx_k_Function___reduce_cython[] = "Function.__reduce_cython__"; +static const char __pyx_k_PadField___reduce_cython[] = "PadField.__reduce_cython__"; +static const char __pyx_k_Field_getAsOutOfLineField[] = "Field.getAsOutOfLineField"; +static const char __pyx_k_Function___setstate_cython[] = "Function.__setstate_cython__"; +static const char __pyx_k_PadField___setstate_cython[] = "PadField.__setstate_cython__"; +static const char __pyx_k_InlineField___reduce_cython[] = "InlineField.__reduce_cython__"; +static const char __pyx_k_MemberField___reduce_cython[] = "MemberField.__reduce_cython__"; +static const char __pyx_k_pyx_unpickle_ImmutableError[] = "__pyx_unpickle_ImmutableError"; +static const char __pyx_k_Field_getAsFunctionBindField[] = "Field.getAsFunctionBindField"; +static const char __pyx_k_FunctionProto___reduce_cython[] = "FunctionProto.__reduce_cython__"; +static const char __pyx_k_InlineField___setstate_cython[] = "InlineField.__setstate_cython__"; +static const char __pyx_k_MemberField___setstate_cython[] = "MemberField.__setstate_cython__"; +static const char __pyx_k_ImmutableError___reduce_cython[] = "ImmutableError.__reduce_cython__"; +static const char __pyx_k_OutOfLineField___reduce_cython[] = "OutOfLineField.__reduce_cython__"; +static const char __pyx_k_PlatformNumber___reduce_cython[] = "PlatformNumber.__reduce_cython__"; +static const char __pyx_k_FunctionProto___setstate_cython[] = "FunctionProto.__setstate_cython__"; +static const char __pyx_k_Pickling_of_struct_members_such[] = "Pickling of struct members such as self.func must be explicitly requested with @auto_pickle(True)"; +static const char __pyx_k_FunctionBindField___reduce_cytho[] = "FunctionBindField.__reduce_cython__"; +static const char __pyx_k_FunctionBindField___setstate_cyt[] = "FunctionBindField.__setstate_cython__"; +static const char __pyx_k_ImmutableError___setstate_cython[] = "ImmutableError.__setstate_cython__"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())"; +static const char __pyx_k_MemberFunctionProto___reduce_cyt[] = "MemberFunctionProto.__reduce_cython__"; +static const char __pyx_k_MemberFunctionProto___setstate_c[] = "MemberFunctionProto.__setstate_cython__"; +static const char __pyx_k_No_value_specified_for_struct_at[] = "No value specified for struct attribute 'name'"; +static const char __pyx_k_OutOfLineField___setstate_cython[] = "OutOfLineField.__setstate_cython__"; +static const char __pyx_k_PlatformNumber___setstate_cython[] = "PlatformNumber.__setstate_cython__"; +static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; +static const char __pyx_k_Pickling_of_struct_members_such_2[] = "Pickling of struct members such as self.root must be explicitly requested with @auto_pickle(True)"; +static const char __pyx_k_No_value_specified_for_struct_at_2[] = "No value specified for struct attribute 'is_struct'"; +/* #### Code section: decls ### */ +static int __pyx_pf_7pybroma_7PyBroma_14ImmutableError___init__(struct __pyx_obj_7pybroma_7PyBroma_ImmutableError *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_14ImmutableError_2__reduce_cython__(struct __pyx_obj_7pybroma_7PyBroma_ImmutableError *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_14ImmutableError_4__setstate_cython__(struct __pyx_obj_7pybroma_7PyBroma_ImmutableError *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_4Type___cinit__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Type *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Type_4name___get__(struct __pyx_obj_7pybroma_7PyBroma_Type *__pyx_v_self); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_4Type_4name_2__set__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Type *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_obj); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Type_2__eq__(struct __pyx_obj_7pybroma_7PyBroma_Type *__pyx_v_self, struct __pyx_obj_7pybroma_7PyBroma_Type *__pyx_v_t); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Type_9is_struct___get__(struct __pyx_obj_7pybroma_7PyBroma_Type *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Type_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Type *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Type_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Type *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto___cinit__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_4args___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_4args_2__set__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_obj); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_3ret___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_8is_const___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_10is_virtual___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_11is_callback___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_9is_static___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_4type___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_4docs___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_4name___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_2__eq__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self, struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_mfp); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_11MemberField___cinit__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_MemberField *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_11MemberField_4name___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberField *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_11MemberField_4type___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberField *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_11MemberField_5count___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberField *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_11MemberField_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_MemberField *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_11MemberField_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_MemberField *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_14OutOfLineField___cinit__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_14OutOfLineField_9prototype___get__(struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_14OutOfLineField_5inner___get__(struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_14OutOfLineField_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_14OutOfLineField_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_17FunctionBindField___cinit__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_17FunctionBindField_9prototype___get__(struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_17FunctionBindField_5binds___get__(struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_17FunctionBindField_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_17FunctionBindField_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_8PadField___cinit__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_PadField *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_8PadField_6amount___get__(struct __pyx_obj_7pybroma_7PyBroma_PadField *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_8PadField_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_PadField *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_8PadField_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_PadField *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_5Field___cinit__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Field_2id___get__(struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_5Field_2id_2__set__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_obj); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Field_6parent___get__(struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Field_2getAsFunctionBindField(struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Field_4getAsMemberField(struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Field_6getAsOutOfLineField(struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Field_8getAsPadField(struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Field_7missing___get__(struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Field_5links___get__(struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Field_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Field_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_14PlatformNumber___cinit__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_14PlatformNumber_3mac___get__(struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_14PlatformNumber_3ios___get__(struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_14PlatformNumber_3win___get__(struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_14PlatformNumber_9android32___get__(struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_14PlatformNumber_9android64___get__(struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_14PlatformNumber_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_14PlatformNumber_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_11InlineField___cinit__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_InlineField *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_11InlineField_5inner___get__(struct __pyx_obj_7pybroma_7PyBroma_InlineField *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_11InlineField_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_InlineField *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_11InlineField_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_InlineField *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_13FunctionProto___cinit__(struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_13FunctionProto_4args___get__(struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_v_self); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_13FunctionProto_4args_2__set__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_obj); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_13FunctionProto_3ret___get__(struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_13FunctionProto_4name___get__(struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_13FunctionProto_4docs___get__(struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_13FunctionProto_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_13FunctionProto_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_8Function___init__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Function *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_8Function_9prototype___get__(struct __pyx_obj_7pybroma_7PyBroma_Function *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_8Function_5binds___get__(struct __pyx_obj_7pybroma_7PyBroma_Function *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_8Function_7missing___get__(struct __pyx_obj_7pybroma_7PyBroma_Function *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_8Function_5links___get__(struct __pyx_obj_7pybroma_7PyBroma_Function *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_8Function_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Function *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_8Function_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Function *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_5Class___cinit__(struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Class_4name___get__(struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_5Class_4name_2__set__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_obj); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Class_5links___get__(struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_5Class_5links_2__set__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_obj); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Class_7missing___get__(struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_5Class_7missing_2__set__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_obj); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Class_12superclasses___get__(struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_5Class_12superclasses_2__set__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_obj); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Class_7depends___get__(struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_5Class_7depends_2__set__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_obj); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Class_6fields___get__(struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_5Class_6fields_2__set__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_obj); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Class_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Class_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_7pybroma_7PyBroma_4Root___init__(struct __pyx_obj_7pybroma_7PyBroma_Root *__pyx_v_self, PyObject *__pyx_v_fileName); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Root_2__getitem__(struct __pyx_obj_7pybroma_7PyBroma_Root *__pyx_v_self, PyObject *__pyx_v__class_name_); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Root_9functions___get__(struct __pyx_obj_7pybroma_7PyBroma_Root *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Root_7classes___get__(struct __pyx_obj_7pybroma_7PyBroma_Root *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Root_4functionsAsDict(struct __pyx_obj_7pybroma_7PyBroma_Root *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Root_6classesAsDict(struct __pyx_obj_7pybroma_7PyBroma_Root *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Root_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Root *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Root_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Root *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_7pybroma_7PyBroma___pyx_unpickle_ImmutableError(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_Type(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_MemberFunctionProto(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_MemberField(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_OutOfLineField(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_FunctionBindField(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_PadField(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_Field(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_PlatformNumber(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_InlineField(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_FunctionProto(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_Function(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_Class(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_Root(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +typedef struct { + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; + #ifdef __Pyx_CyFunction_USED + PyTypeObject *__pyx_CyFunctionType; + #endif + #ifdef __Pyx_FusedFunction_USED + PyTypeObject *__pyx_FusedFunctionType; + #endif + #ifdef __Pyx_Generator_USED + PyTypeObject *__pyx_GeneratorType; + #endif + #ifdef __Pyx_IterableCoroutine_USED + PyTypeObject *__pyx_IterableCoroutineType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineAwaitType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineType; + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + PyObject *__pyx_type_7pybroma_7PyBroma_ImmutableError; + PyObject *__pyx_type_7pybroma_7PyBroma_Type; + PyObject *__pyx_type_7pybroma_7PyBroma_MemberFunctionProto; + PyObject *__pyx_type_7pybroma_7PyBroma_MemberField; + PyObject *__pyx_type_7pybroma_7PyBroma_OutOfLineField; + PyObject *__pyx_type_7pybroma_7PyBroma_FunctionBindField; + PyObject *__pyx_type_7pybroma_7PyBroma_PadField; + PyObject *__pyx_type_7pybroma_7PyBroma_Field; + PyObject *__pyx_type_7pybroma_7PyBroma_PlatformNumber; + PyObject *__pyx_type_7pybroma_7PyBroma_InlineField; + PyObject *__pyx_type_7pybroma_7PyBroma_FunctionProto; + PyObject *__pyx_type_7pybroma_7PyBroma_Function; + PyObject *__pyx_type_7pybroma_7PyBroma_Class; + PyObject *__pyx_type_7pybroma_7PyBroma_Root; + #endif + PyTypeObject *__pyx_ptype_7pybroma_7PyBroma_ImmutableError; + PyTypeObject *__pyx_ptype_7pybroma_7PyBroma_Type; + PyTypeObject *__pyx_ptype_7pybroma_7PyBroma_MemberFunctionProto; + PyTypeObject *__pyx_ptype_7pybroma_7PyBroma_MemberField; + PyTypeObject *__pyx_ptype_7pybroma_7PyBroma_OutOfLineField; + PyTypeObject *__pyx_ptype_7pybroma_7PyBroma_FunctionBindField; + PyTypeObject *__pyx_ptype_7pybroma_7PyBroma_PadField; + PyTypeObject *__pyx_ptype_7pybroma_7PyBroma_Field; + PyTypeObject *__pyx_ptype_7pybroma_7PyBroma_PlatformNumber; + PyTypeObject *__pyx_ptype_7pybroma_7PyBroma_InlineField; + PyTypeObject *__pyx_ptype_7pybroma_7PyBroma_FunctionProto; + PyTypeObject *__pyx_ptype_7pybroma_7PyBroma_Function; + PyTypeObject *__pyx_ptype_7pybroma_7PyBroma_Class; + PyTypeObject *__pyx_ptype_7pybroma_7PyBroma_Root; + PyObject *__pyx_n_s_Class; + PyObject *__pyx_n_s_Class___reduce_cython; + PyObject *__pyx_n_s_Class___setstate_cython; + PyObject *__pyx_n_s_Field; + PyObject *__pyx_n_s_Field___reduce_cython; + PyObject *__pyx_n_s_Field___setstate_cython; + PyObject *__pyx_n_s_Field_getAsFunctionBindField; + PyObject *__pyx_n_s_Field_getAsMemberField; + PyObject *__pyx_n_s_Field_getAsOutOfLineField; + PyObject *__pyx_n_s_Field_getAsPadField; + PyObject *__pyx_n_s_Function; + PyObject *__pyx_n_s_FunctionBindField; + PyObject *__pyx_n_s_FunctionBindField___reduce_cytho; + PyObject *__pyx_n_s_FunctionBindField___setstate_cyt; + PyObject *__pyx_n_s_FunctionProto; + PyObject *__pyx_n_s_FunctionProto___reduce_cython; + PyObject *__pyx_n_s_FunctionProto___setstate_cython; + PyObject *__pyx_n_s_Function___reduce_cython; + PyObject *__pyx_n_s_Function___setstate_cython; + PyObject *__pyx_n_s_ImmutableError; + PyObject *__pyx_n_s_ImmutableError___reduce_cython; + PyObject *__pyx_n_s_ImmutableError___setstate_cython; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; + PyObject *__pyx_n_s_InlineField; + PyObject *__pyx_n_s_InlineField___reduce_cython; + PyObject *__pyx_n_s_InlineField___setstate_cython; + PyObject *__pyx_n_s_KeyError; + PyObject *__pyx_n_s_MemberField; + PyObject *__pyx_n_s_MemberField___reduce_cython; + PyObject *__pyx_n_s_MemberField___setstate_cython; + PyObject *__pyx_n_s_MemberFunctionProto; + PyObject *__pyx_n_s_MemberFunctionProto___reduce_cyt; + PyObject *__pyx_n_s_MemberFunctionProto___setstate_c; + PyObject *__pyx_kp_s_No_value_specified_for_struct_at; + PyObject *__pyx_kp_s_No_value_specified_for_struct_at_2; + PyObject *__pyx_n_s_OutOfLineField; + PyObject *__pyx_n_s_OutOfLineField___reduce_cython; + PyObject *__pyx_n_s_OutOfLineField___setstate_cython; + PyObject *__pyx_n_s_PadField; + PyObject *__pyx_n_s_PadField___reduce_cython; + PyObject *__pyx_n_s_PadField___setstate_cython; + PyObject *__pyx_n_s_PickleError; + PyObject *__pyx_kp_s_Pickling_of_struct_members_such; + PyObject *__pyx_kp_s_Pickling_of_struct_members_such_2; + PyObject *__pyx_n_s_PlatformNumber; + PyObject *__pyx_n_s_PlatformNumber___reduce_cython; + PyObject *__pyx_n_s_PlatformNumber___setstate_cython; + PyObject *__pyx_n_s_Root; + PyObject *__pyx_n_s_Root___reduce_cython; + PyObject *__pyx_n_s_Root___setstate_cython; + PyObject *__pyx_n_s_Root_classesAsDict; + PyObject *__pyx_n_s_Root_functionsAsDict; + PyObject *__pyx_n_s_Type; + PyObject *__pyx_n_s_TypeError; + PyObject *__pyx_n_s_Type___reduce_cython; + PyObject *__pyx_n_s_Type___setstate_cython; + PyObject *__pyx_n_s_ValueError; + PyObject *__pyx_kp_u__12; + PyObject *__pyx_n_s__13; + PyObject *__pyx_n_u_args; + PyObject *__pyx_n_s_asyncio_coroutines; + PyObject *__pyx_n_s_c; + PyObject *__pyx_n_s_classesAsDict; + PyObject *__pyx_n_s_cline_in_traceback; + PyObject *__pyx_n_u_depends; + PyObject *__pyx_n_s_dict; + PyObject *__pyx_n_s_dict_2; + PyObject *__pyx_n_s_dict_3; + PyObject *__pyx_kp_u_disable; + PyObject *__pyx_kp_u_enable; + PyObject *__pyx_n_u_fields; + PyObject *__pyx_n_s_fileName; + PyObject *__pyx_n_s_functionsAsDict; + PyObject *__pyx_kp_u_gc; + PyObject *__pyx_n_s_getAsFunctionBindField; + PyObject *__pyx_n_s_getAsMemberField; + PyObject *__pyx_n_s_getAsOutOfLineField; + PyObject *__pyx_n_s_getAsPadField; + PyObject *__pyx_n_s_getstate; + PyObject *__pyx_n_u_id; + PyObject *__pyx_n_s_import; + PyObject *__pyx_n_s_init; + PyObject *__pyx_n_s_is_coroutine; + PyObject *__pyx_kp_u_is_immutable; + PyObject *__pyx_n_s_is_struct; + PyObject *__pyx_kp_u_isenabled; + PyObject *__pyx_n_u_links; + PyObject *__pyx_n_s_main; + PyObject *__pyx_n_u_missing; + PyObject *__pyx_n_s_name; + PyObject *__pyx_n_u_name; + PyObject *__pyx_n_s_name_2; + PyObject *__pyx_n_s_new; + PyObject *__pyx_kp_s_no_default___reduce___due_to_non; + PyObject *__pyx_n_s_pickle; + PyObject *__pyx_n_s_pybroma_PyBroma; + PyObject *__pyx_kp_s_pybroma_PyBroma_pyx; + PyObject *__pyx_n_s_pyx_PickleError; + PyObject *__pyx_n_s_pyx_checksum; + PyObject *__pyx_n_s_pyx_result; + PyObject *__pyx_n_s_pyx_state; + PyObject *__pyx_n_s_pyx_type; + PyObject *__pyx_n_s_pyx_unpickle_ImmutableError; + PyObject *__pyx_n_s_pyx_vtable; + PyObject *__pyx_n_s_range; + PyObject *__pyx_n_s_reduce; + PyObject *__pyx_n_s_reduce_cython; + PyObject *__pyx_n_s_reduce_ex; + PyObject *__pyx_n_s_return; + PyObject *__pyx_n_s_self; + PyObject *__pyx_n_s_setstate; + PyObject *__pyx_n_s_setstate_cython; + PyObject *__pyx_n_s_state; + PyObject *__pyx_kp_s_stringsource; + PyObject *__pyx_n_s_super; + PyObject *__pyx_n_u_superclass; + PyObject *__pyx_n_s_test; + PyObject *__pyx_n_s_update; + PyObject *__pyx_n_s_use_setstate; + PyObject *__pyx_n_s_x; + PyObject *__pyx_int_222419149; + PyObject *__pyx_int_228825662; + PyObject *__pyx_int_238750788; + PyObject *__pyx_tuple_; + PyObject *__pyx_tuple__2; + PyObject *__pyx_tuple__3; + PyObject *__pyx_tuple__4; + PyObject *__pyx_tuple__5; + PyObject *__pyx_tuple__6; + PyObject *__pyx_tuple__7; + PyObject *__pyx_tuple__8; + PyObject *__pyx_tuple__9; + PyObject *__pyx_tuple__10; + PyObject *__pyx_tuple__11; + PyObject *__pyx_tuple__14; + PyObject *__pyx_tuple__16; + PyObject *__pyx_tuple__18; + PyObject *__pyx_tuple__31; + PyObject *__pyx_tuple__48; + PyObject *__pyx_tuple__53; + PyObject *__pyx_codeobj__15; + PyObject *__pyx_codeobj__17; + PyObject *__pyx_codeobj__19; + PyObject *__pyx_codeobj__20; + PyObject *__pyx_codeobj__21; + PyObject *__pyx_codeobj__22; + PyObject *__pyx_codeobj__23; + PyObject *__pyx_codeobj__24; + PyObject *__pyx_codeobj__25; + PyObject *__pyx_codeobj__26; + PyObject *__pyx_codeobj__27; + PyObject *__pyx_codeobj__28; + PyObject *__pyx_codeobj__29; + PyObject *__pyx_codeobj__30; + PyObject *__pyx_codeobj__32; + PyObject *__pyx_codeobj__33; + PyObject *__pyx_codeobj__34; + PyObject *__pyx_codeobj__35; + PyObject *__pyx_codeobj__36; + PyObject *__pyx_codeobj__37; + PyObject *__pyx_codeobj__38; + PyObject *__pyx_codeobj__39; + PyObject *__pyx_codeobj__40; + PyObject *__pyx_codeobj__41; + PyObject *__pyx_codeobj__42; + PyObject *__pyx_codeobj__43; + PyObject *__pyx_codeobj__44; + PyObject *__pyx_codeobj__45; + PyObject *__pyx_codeobj__46; + PyObject *__pyx_codeobj__47; + PyObject *__pyx_codeobj__49; + PyObject *__pyx_codeobj__50; + PyObject *__pyx_codeobj__51; + PyObject *__pyx_codeobj__52; + PyObject *__pyx_codeobj__54; +} __pyx_mstate; + +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { + extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; +#endif + +#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) + +#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) + +#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstate __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_clear(PyObject *m) { + __pyx_mstate *clear_module_state = __pyx_mstate(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_CLEAR(clear_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); + #endif + Py_CLEAR(clear_module_state->__pyx_ptype_7pybroma_7PyBroma_ImmutableError); + Py_CLEAR(clear_module_state->__pyx_type_7pybroma_7PyBroma_ImmutableError); + Py_CLEAR(clear_module_state->__pyx_ptype_7pybroma_7PyBroma_Type); + Py_CLEAR(clear_module_state->__pyx_type_7pybroma_7PyBroma_Type); + Py_CLEAR(clear_module_state->__pyx_ptype_7pybroma_7PyBroma_MemberFunctionProto); + Py_CLEAR(clear_module_state->__pyx_type_7pybroma_7PyBroma_MemberFunctionProto); + Py_CLEAR(clear_module_state->__pyx_ptype_7pybroma_7PyBroma_MemberField); + Py_CLEAR(clear_module_state->__pyx_type_7pybroma_7PyBroma_MemberField); + Py_CLEAR(clear_module_state->__pyx_ptype_7pybroma_7PyBroma_OutOfLineField); + Py_CLEAR(clear_module_state->__pyx_type_7pybroma_7PyBroma_OutOfLineField); + Py_CLEAR(clear_module_state->__pyx_ptype_7pybroma_7PyBroma_FunctionBindField); + Py_CLEAR(clear_module_state->__pyx_type_7pybroma_7PyBroma_FunctionBindField); + Py_CLEAR(clear_module_state->__pyx_ptype_7pybroma_7PyBroma_PadField); + Py_CLEAR(clear_module_state->__pyx_type_7pybroma_7PyBroma_PadField); + Py_CLEAR(clear_module_state->__pyx_ptype_7pybroma_7PyBroma_Field); + Py_CLEAR(clear_module_state->__pyx_type_7pybroma_7PyBroma_Field); + Py_CLEAR(clear_module_state->__pyx_ptype_7pybroma_7PyBroma_PlatformNumber); + Py_CLEAR(clear_module_state->__pyx_type_7pybroma_7PyBroma_PlatformNumber); + Py_CLEAR(clear_module_state->__pyx_ptype_7pybroma_7PyBroma_InlineField); + Py_CLEAR(clear_module_state->__pyx_type_7pybroma_7PyBroma_InlineField); + Py_CLEAR(clear_module_state->__pyx_ptype_7pybroma_7PyBroma_FunctionProto); + Py_CLEAR(clear_module_state->__pyx_type_7pybroma_7PyBroma_FunctionProto); + Py_CLEAR(clear_module_state->__pyx_ptype_7pybroma_7PyBroma_Function); + Py_CLEAR(clear_module_state->__pyx_type_7pybroma_7PyBroma_Function); + Py_CLEAR(clear_module_state->__pyx_ptype_7pybroma_7PyBroma_Class); + Py_CLEAR(clear_module_state->__pyx_type_7pybroma_7PyBroma_Class); + Py_CLEAR(clear_module_state->__pyx_ptype_7pybroma_7PyBroma_Root); + Py_CLEAR(clear_module_state->__pyx_type_7pybroma_7PyBroma_Root); + Py_CLEAR(clear_module_state->__pyx_n_s_Class); + Py_CLEAR(clear_module_state->__pyx_n_s_Class___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Class___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Field); + Py_CLEAR(clear_module_state->__pyx_n_s_Field___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Field___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Field_getAsFunctionBindField); + Py_CLEAR(clear_module_state->__pyx_n_s_Field_getAsMemberField); + Py_CLEAR(clear_module_state->__pyx_n_s_Field_getAsOutOfLineField); + Py_CLEAR(clear_module_state->__pyx_n_s_Field_getAsPadField); + Py_CLEAR(clear_module_state->__pyx_n_s_Function); + Py_CLEAR(clear_module_state->__pyx_n_s_FunctionBindField); + Py_CLEAR(clear_module_state->__pyx_n_s_FunctionBindField___reduce_cytho); + Py_CLEAR(clear_module_state->__pyx_n_s_FunctionBindField___setstate_cyt); + Py_CLEAR(clear_module_state->__pyx_n_s_FunctionProto); + Py_CLEAR(clear_module_state->__pyx_n_s_FunctionProto___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_FunctionProto___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Function___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Function___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ImmutableError); + Py_CLEAR(clear_module_state->__pyx_n_s_ImmutableError___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ImmutableError___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); + Py_CLEAR(clear_module_state->__pyx_n_s_InlineField); + Py_CLEAR(clear_module_state->__pyx_n_s_InlineField___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_InlineField___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_KeyError); + Py_CLEAR(clear_module_state->__pyx_n_s_MemberField); + Py_CLEAR(clear_module_state->__pyx_n_s_MemberField___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_MemberField___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_MemberFunctionProto); + Py_CLEAR(clear_module_state->__pyx_n_s_MemberFunctionProto___reduce_cyt); + Py_CLEAR(clear_module_state->__pyx_n_s_MemberFunctionProto___setstate_c); + Py_CLEAR(clear_module_state->__pyx_kp_s_No_value_specified_for_struct_at); + Py_CLEAR(clear_module_state->__pyx_kp_s_No_value_specified_for_struct_at_2); + Py_CLEAR(clear_module_state->__pyx_n_s_OutOfLineField); + Py_CLEAR(clear_module_state->__pyx_n_s_OutOfLineField___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_OutOfLineField___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_PadField); + Py_CLEAR(clear_module_state->__pyx_n_s_PadField___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_PadField___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_PickleError); + Py_CLEAR(clear_module_state->__pyx_kp_s_Pickling_of_struct_members_such); + Py_CLEAR(clear_module_state->__pyx_kp_s_Pickling_of_struct_members_such_2); + Py_CLEAR(clear_module_state->__pyx_n_s_PlatformNumber); + Py_CLEAR(clear_module_state->__pyx_n_s_PlatformNumber___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_PlatformNumber___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Root); + Py_CLEAR(clear_module_state->__pyx_n_s_Root___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Root___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Root_classesAsDict); + Py_CLEAR(clear_module_state->__pyx_n_s_Root_functionsAsDict); + Py_CLEAR(clear_module_state->__pyx_n_s_Type); + Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); + Py_CLEAR(clear_module_state->__pyx_n_s_Type___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Type___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ValueError); + Py_CLEAR(clear_module_state->__pyx_kp_u__12); + Py_CLEAR(clear_module_state->__pyx_n_s__13); + Py_CLEAR(clear_module_state->__pyx_n_u_args); + Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); + Py_CLEAR(clear_module_state->__pyx_n_s_c); + Py_CLEAR(clear_module_state->__pyx_n_s_classesAsDict); + Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); + Py_CLEAR(clear_module_state->__pyx_n_u_depends); + Py_CLEAR(clear_module_state->__pyx_n_s_dict); + Py_CLEAR(clear_module_state->__pyx_n_s_dict_2); + Py_CLEAR(clear_module_state->__pyx_n_s_dict_3); + Py_CLEAR(clear_module_state->__pyx_kp_u_disable); + Py_CLEAR(clear_module_state->__pyx_kp_u_enable); + Py_CLEAR(clear_module_state->__pyx_n_u_fields); + Py_CLEAR(clear_module_state->__pyx_n_s_fileName); + Py_CLEAR(clear_module_state->__pyx_n_s_functionsAsDict); + Py_CLEAR(clear_module_state->__pyx_kp_u_gc); + Py_CLEAR(clear_module_state->__pyx_n_s_getAsFunctionBindField); + Py_CLEAR(clear_module_state->__pyx_n_s_getAsMemberField); + Py_CLEAR(clear_module_state->__pyx_n_s_getAsOutOfLineField); + Py_CLEAR(clear_module_state->__pyx_n_s_getAsPadField); + Py_CLEAR(clear_module_state->__pyx_n_s_getstate); + Py_CLEAR(clear_module_state->__pyx_n_u_id); + Py_CLEAR(clear_module_state->__pyx_n_s_import); + Py_CLEAR(clear_module_state->__pyx_n_s_init); + Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); + Py_CLEAR(clear_module_state->__pyx_kp_u_is_immutable); + Py_CLEAR(clear_module_state->__pyx_n_s_is_struct); + Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); + Py_CLEAR(clear_module_state->__pyx_n_u_links); + Py_CLEAR(clear_module_state->__pyx_n_s_main); + Py_CLEAR(clear_module_state->__pyx_n_u_missing); + Py_CLEAR(clear_module_state->__pyx_n_s_name); + Py_CLEAR(clear_module_state->__pyx_n_u_name); + Py_CLEAR(clear_module_state->__pyx_n_s_name_2); + Py_CLEAR(clear_module_state->__pyx_n_s_new); + Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non); + Py_CLEAR(clear_module_state->__pyx_n_s_pickle); + Py_CLEAR(clear_module_state->__pyx_n_s_pybroma_PyBroma); + Py_CLEAR(clear_module_state->__pyx_kp_s_pybroma_PyBroma_pyx); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_PickleError); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_checksum); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_result); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_type); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_ImmutableError); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable); + Py_CLEAR(clear_module_state->__pyx_n_s_range); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); + Py_CLEAR(clear_module_state->__pyx_n_s_return); + Py_CLEAR(clear_module_state->__pyx_n_s_self); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_state); + Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); + Py_CLEAR(clear_module_state->__pyx_n_s_super); + Py_CLEAR(clear_module_state->__pyx_n_u_superclass); + Py_CLEAR(clear_module_state->__pyx_n_s_test); + Py_CLEAR(clear_module_state->__pyx_n_s_update); + Py_CLEAR(clear_module_state->__pyx_n_s_use_setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_x); + Py_CLEAR(clear_module_state->__pyx_int_222419149); + Py_CLEAR(clear_module_state->__pyx_int_228825662); + Py_CLEAR(clear_module_state->__pyx_int_238750788); + Py_CLEAR(clear_module_state->__pyx_tuple_); + Py_CLEAR(clear_module_state->__pyx_tuple__2); + Py_CLEAR(clear_module_state->__pyx_tuple__3); + Py_CLEAR(clear_module_state->__pyx_tuple__4); + Py_CLEAR(clear_module_state->__pyx_tuple__5); + Py_CLEAR(clear_module_state->__pyx_tuple__6); + Py_CLEAR(clear_module_state->__pyx_tuple__7); + Py_CLEAR(clear_module_state->__pyx_tuple__8); + Py_CLEAR(clear_module_state->__pyx_tuple__9); + Py_CLEAR(clear_module_state->__pyx_tuple__10); + Py_CLEAR(clear_module_state->__pyx_tuple__11); + Py_CLEAR(clear_module_state->__pyx_tuple__14); + Py_CLEAR(clear_module_state->__pyx_tuple__16); + Py_CLEAR(clear_module_state->__pyx_tuple__18); + Py_CLEAR(clear_module_state->__pyx_tuple__31); + Py_CLEAR(clear_module_state->__pyx_tuple__48); + Py_CLEAR(clear_module_state->__pyx_tuple__53); + Py_CLEAR(clear_module_state->__pyx_codeobj__15); + Py_CLEAR(clear_module_state->__pyx_codeobj__17); + Py_CLEAR(clear_module_state->__pyx_codeobj__19); + Py_CLEAR(clear_module_state->__pyx_codeobj__20); + Py_CLEAR(clear_module_state->__pyx_codeobj__21); + Py_CLEAR(clear_module_state->__pyx_codeobj__22); + Py_CLEAR(clear_module_state->__pyx_codeobj__23); + Py_CLEAR(clear_module_state->__pyx_codeobj__24); + Py_CLEAR(clear_module_state->__pyx_codeobj__25); + Py_CLEAR(clear_module_state->__pyx_codeobj__26); + Py_CLEAR(clear_module_state->__pyx_codeobj__27); + Py_CLEAR(clear_module_state->__pyx_codeobj__28); + Py_CLEAR(clear_module_state->__pyx_codeobj__29); + Py_CLEAR(clear_module_state->__pyx_codeobj__30); + Py_CLEAR(clear_module_state->__pyx_codeobj__32); + Py_CLEAR(clear_module_state->__pyx_codeobj__33); + Py_CLEAR(clear_module_state->__pyx_codeobj__34); + Py_CLEAR(clear_module_state->__pyx_codeobj__35); + Py_CLEAR(clear_module_state->__pyx_codeobj__36); + Py_CLEAR(clear_module_state->__pyx_codeobj__37); + Py_CLEAR(clear_module_state->__pyx_codeobj__38); + Py_CLEAR(clear_module_state->__pyx_codeobj__39); + Py_CLEAR(clear_module_state->__pyx_codeobj__40); + Py_CLEAR(clear_module_state->__pyx_codeobj__41); + Py_CLEAR(clear_module_state->__pyx_codeobj__42); + Py_CLEAR(clear_module_state->__pyx_codeobj__43); + Py_CLEAR(clear_module_state->__pyx_codeobj__44); + Py_CLEAR(clear_module_state->__pyx_codeobj__45); + Py_CLEAR(clear_module_state->__pyx_codeobj__46); + Py_CLEAR(clear_module_state->__pyx_codeobj__47); + Py_CLEAR(clear_module_state->__pyx_codeobj__49); + Py_CLEAR(clear_module_state->__pyx_codeobj__50); + Py_CLEAR(clear_module_state->__pyx_codeobj__51); + Py_CLEAR(clear_module_state->__pyx_codeobj__52); + Py_CLEAR(clear_module_state->__pyx_codeobj__54); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstate *traverse_module_state = __pyx_mstate(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + Py_VISIT(traverse_module_state->__pyx_empty_tuple); + Py_VISIT(traverse_module_state->__pyx_empty_bytes); + Py_VISIT(traverse_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); + #endif + Py_VISIT(traverse_module_state->__pyx_ptype_7pybroma_7PyBroma_ImmutableError); + Py_VISIT(traverse_module_state->__pyx_type_7pybroma_7PyBroma_ImmutableError); + Py_VISIT(traverse_module_state->__pyx_ptype_7pybroma_7PyBroma_Type); + Py_VISIT(traverse_module_state->__pyx_type_7pybroma_7PyBroma_Type); + Py_VISIT(traverse_module_state->__pyx_ptype_7pybroma_7PyBroma_MemberFunctionProto); + Py_VISIT(traverse_module_state->__pyx_type_7pybroma_7PyBroma_MemberFunctionProto); + Py_VISIT(traverse_module_state->__pyx_ptype_7pybroma_7PyBroma_MemberField); + Py_VISIT(traverse_module_state->__pyx_type_7pybroma_7PyBroma_MemberField); + Py_VISIT(traverse_module_state->__pyx_ptype_7pybroma_7PyBroma_OutOfLineField); + Py_VISIT(traverse_module_state->__pyx_type_7pybroma_7PyBroma_OutOfLineField); + Py_VISIT(traverse_module_state->__pyx_ptype_7pybroma_7PyBroma_FunctionBindField); + Py_VISIT(traverse_module_state->__pyx_type_7pybroma_7PyBroma_FunctionBindField); + Py_VISIT(traverse_module_state->__pyx_ptype_7pybroma_7PyBroma_PadField); + Py_VISIT(traverse_module_state->__pyx_type_7pybroma_7PyBroma_PadField); + Py_VISIT(traverse_module_state->__pyx_ptype_7pybroma_7PyBroma_Field); + Py_VISIT(traverse_module_state->__pyx_type_7pybroma_7PyBroma_Field); + Py_VISIT(traverse_module_state->__pyx_ptype_7pybroma_7PyBroma_PlatformNumber); + Py_VISIT(traverse_module_state->__pyx_type_7pybroma_7PyBroma_PlatformNumber); + Py_VISIT(traverse_module_state->__pyx_ptype_7pybroma_7PyBroma_InlineField); + Py_VISIT(traverse_module_state->__pyx_type_7pybroma_7PyBroma_InlineField); + Py_VISIT(traverse_module_state->__pyx_ptype_7pybroma_7PyBroma_FunctionProto); + Py_VISIT(traverse_module_state->__pyx_type_7pybroma_7PyBroma_FunctionProto); + Py_VISIT(traverse_module_state->__pyx_ptype_7pybroma_7PyBroma_Function); + Py_VISIT(traverse_module_state->__pyx_type_7pybroma_7PyBroma_Function); + Py_VISIT(traverse_module_state->__pyx_ptype_7pybroma_7PyBroma_Class); + Py_VISIT(traverse_module_state->__pyx_type_7pybroma_7PyBroma_Class); + Py_VISIT(traverse_module_state->__pyx_ptype_7pybroma_7PyBroma_Root); + Py_VISIT(traverse_module_state->__pyx_type_7pybroma_7PyBroma_Root); + Py_VISIT(traverse_module_state->__pyx_n_s_Class); + Py_VISIT(traverse_module_state->__pyx_n_s_Class___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Class___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Field); + Py_VISIT(traverse_module_state->__pyx_n_s_Field___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Field___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Field_getAsFunctionBindField); + Py_VISIT(traverse_module_state->__pyx_n_s_Field_getAsMemberField); + Py_VISIT(traverse_module_state->__pyx_n_s_Field_getAsOutOfLineField); + Py_VISIT(traverse_module_state->__pyx_n_s_Field_getAsPadField); + Py_VISIT(traverse_module_state->__pyx_n_s_Function); + Py_VISIT(traverse_module_state->__pyx_n_s_FunctionBindField); + Py_VISIT(traverse_module_state->__pyx_n_s_FunctionBindField___reduce_cytho); + Py_VISIT(traverse_module_state->__pyx_n_s_FunctionBindField___setstate_cyt); + Py_VISIT(traverse_module_state->__pyx_n_s_FunctionProto); + Py_VISIT(traverse_module_state->__pyx_n_s_FunctionProto___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_FunctionProto___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Function___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Function___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ImmutableError); + Py_VISIT(traverse_module_state->__pyx_n_s_ImmutableError___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ImmutableError___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); + Py_VISIT(traverse_module_state->__pyx_n_s_InlineField); + Py_VISIT(traverse_module_state->__pyx_n_s_InlineField___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_InlineField___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_KeyError); + Py_VISIT(traverse_module_state->__pyx_n_s_MemberField); + Py_VISIT(traverse_module_state->__pyx_n_s_MemberField___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_MemberField___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_MemberFunctionProto); + Py_VISIT(traverse_module_state->__pyx_n_s_MemberFunctionProto___reduce_cyt); + Py_VISIT(traverse_module_state->__pyx_n_s_MemberFunctionProto___setstate_c); + Py_VISIT(traverse_module_state->__pyx_kp_s_No_value_specified_for_struct_at); + Py_VISIT(traverse_module_state->__pyx_kp_s_No_value_specified_for_struct_at_2); + Py_VISIT(traverse_module_state->__pyx_n_s_OutOfLineField); + Py_VISIT(traverse_module_state->__pyx_n_s_OutOfLineField___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_OutOfLineField___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_PadField); + Py_VISIT(traverse_module_state->__pyx_n_s_PadField___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_PadField___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_PickleError); + Py_VISIT(traverse_module_state->__pyx_kp_s_Pickling_of_struct_members_such); + Py_VISIT(traverse_module_state->__pyx_kp_s_Pickling_of_struct_members_such_2); + Py_VISIT(traverse_module_state->__pyx_n_s_PlatformNumber); + Py_VISIT(traverse_module_state->__pyx_n_s_PlatformNumber___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_PlatformNumber___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Root); + Py_VISIT(traverse_module_state->__pyx_n_s_Root___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Root___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Root_classesAsDict); + Py_VISIT(traverse_module_state->__pyx_n_s_Root_functionsAsDict); + Py_VISIT(traverse_module_state->__pyx_n_s_Type); + Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); + Py_VISIT(traverse_module_state->__pyx_n_s_Type___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Type___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ValueError); + Py_VISIT(traverse_module_state->__pyx_kp_u__12); + Py_VISIT(traverse_module_state->__pyx_n_s__13); + Py_VISIT(traverse_module_state->__pyx_n_u_args); + Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); + Py_VISIT(traverse_module_state->__pyx_n_s_c); + Py_VISIT(traverse_module_state->__pyx_n_s_classesAsDict); + Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); + Py_VISIT(traverse_module_state->__pyx_n_u_depends); + Py_VISIT(traverse_module_state->__pyx_n_s_dict); + Py_VISIT(traverse_module_state->__pyx_n_s_dict_2); + Py_VISIT(traverse_module_state->__pyx_n_s_dict_3); + Py_VISIT(traverse_module_state->__pyx_kp_u_disable); + Py_VISIT(traverse_module_state->__pyx_kp_u_enable); + Py_VISIT(traverse_module_state->__pyx_n_u_fields); + Py_VISIT(traverse_module_state->__pyx_n_s_fileName); + Py_VISIT(traverse_module_state->__pyx_n_s_functionsAsDict); + Py_VISIT(traverse_module_state->__pyx_kp_u_gc); + Py_VISIT(traverse_module_state->__pyx_n_s_getAsFunctionBindField); + Py_VISIT(traverse_module_state->__pyx_n_s_getAsMemberField); + Py_VISIT(traverse_module_state->__pyx_n_s_getAsOutOfLineField); + Py_VISIT(traverse_module_state->__pyx_n_s_getAsPadField); + Py_VISIT(traverse_module_state->__pyx_n_s_getstate); + Py_VISIT(traverse_module_state->__pyx_n_u_id); + Py_VISIT(traverse_module_state->__pyx_n_s_import); + Py_VISIT(traverse_module_state->__pyx_n_s_init); + Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); + Py_VISIT(traverse_module_state->__pyx_kp_u_is_immutable); + Py_VISIT(traverse_module_state->__pyx_n_s_is_struct); + Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); + Py_VISIT(traverse_module_state->__pyx_n_u_links); + Py_VISIT(traverse_module_state->__pyx_n_s_main); + Py_VISIT(traverse_module_state->__pyx_n_u_missing); + Py_VISIT(traverse_module_state->__pyx_n_s_name); + Py_VISIT(traverse_module_state->__pyx_n_u_name); + Py_VISIT(traverse_module_state->__pyx_n_s_name_2); + Py_VISIT(traverse_module_state->__pyx_n_s_new); + Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non); + Py_VISIT(traverse_module_state->__pyx_n_s_pickle); + Py_VISIT(traverse_module_state->__pyx_n_s_pybroma_PyBroma); + Py_VISIT(traverse_module_state->__pyx_kp_s_pybroma_PyBroma_pyx); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_PickleError); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_checksum); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_result); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_type); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_ImmutableError); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable); + Py_VISIT(traverse_module_state->__pyx_n_s_range); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); + Py_VISIT(traverse_module_state->__pyx_n_s_return); + Py_VISIT(traverse_module_state->__pyx_n_s_self); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_state); + Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); + Py_VISIT(traverse_module_state->__pyx_n_s_super); + Py_VISIT(traverse_module_state->__pyx_n_u_superclass); + Py_VISIT(traverse_module_state->__pyx_n_s_test); + Py_VISIT(traverse_module_state->__pyx_n_s_update); + Py_VISIT(traverse_module_state->__pyx_n_s_use_setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_x); + Py_VISIT(traverse_module_state->__pyx_int_222419149); + Py_VISIT(traverse_module_state->__pyx_int_228825662); + Py_VISIT(traverse_module_state->__pyx_int_238750788); + Py_VISIT(traverse_module_state->__pyx_tuple_); + Py_VISIT(traverse_module_state->__pyx_tuple__2); + Py_VISIT(traverse_module_state->__pyx_tuple__3); + Py_VISIT(traverse_module_state->__pyx_tuple__4); + Py_VISIT(traverse_module_state->__pyx_tuple__5); + Py_VISIT(traverse_module_state->__pyx_tuple__6); + Py_VISIT(traverse_module_state->__pyx_tuple__7); + Py_VISIT(traverse_module_state->__pyx_tuple__8); + Py_VISIT(traverse_module_state->__pyx_tuple__9); + Py_VISIT(traverse_module_state->__pyx_tuple__10); + Py_VISIT(traverse_module_state->__pyx_tuple__11); + Py_VISIT(traverse_module_state->__pyx_tuple__14); + Py_VISIT(traverse_module_state->__pyx_tuple__16); + Py_VISIT(traverse_module_state->__pyx_tuple__18); + Py_VISIT(traverse_module_state->__pyx_tuple__31); + Py_VISIT(traverse_module_state->__pyx_tuple__48); + Py_VISIT(traverse_module_state->__pyx_tuple__53); + Py_VISIT(traverse_module_state->__pyx_codeobj__15); + Py_VISIT(traverse_module_state->__pyx_codeobj__17); + Py_VISIT(traverse_module_state->__pyx_codeobj__19); + Py_VISIT(traverse_module_state->__pyx_codeobj__20); + Py_VISIT(traverse_module_state->__pyx_codeobj__21); + Py_VISIT(traverse_module_state->__pyx_codeobj__22); + Py_VISIT(traverse_module_state->__pyx_codeobj__23); + Py_VISIT(traverse_module_state->__pyx_codeobj__24); + Py_VISIT(traverse_module_state->__pyx_codeobj__25); + Py_VISIT(traverse_module_state->__pyx_codeobj__26); + Py_VISIT(traverse_module_state->__pyx_codeobj__27); + Py_VISIT(traverse_module_state->__pyx_codeobj__28); + Py_VISIT(traverse_module_state->__pyx_codeobj__29); + Py_VISIT(traverse_module_state->__pyx_codeobj__30); + Py_VISIT(traverse_module_state->__pyx_codeobj__32); + Py_VISIT(traverse_module_state->__pyx_codeobj__33); + Py_VISIT(traverse_module_state->__pyx_codeobj__34); + Py_VISIT(traverse_module_state->__pyx_codeobj__35); + Py_VISIT(traverse_module_state->__pyx_codeobj__36); + Py_VISIT(traverse_module_state->__pyx_codeobj__37); + Py_VISIT(traverse_module_state->__pyx_codeobj__38); + Py_VISIT(traverse_module_state->__pyx_codeobj__39); + Py_VISIT(traverse_module_state->__pyx_codeobj__40); + Py_VISIT(traverse_module_state->__pyx_codeobj__41); + Py_VISIT(traverse_module_state->__pyx_codeobj__42); + Py_VISIT(traverse_module_state->__pyx_codeobj__43); + Py_VISIT(traverse_module_state->__pyx_codeobj__44); + Py_VISIT(traverse_module_state->__pyx_codeobj__45); + Py_VISIT(traverse_module_state->__pyx_codeobj__46); + Py_VISIT(traverse_module_state->__pyx_codeobj__47); + Py_VISIT(traverse_module_state->__pyx_codeobj__49); + Py_VISIT(traverse_module_state->__pyx_codeobj__50); + Py_VISIT(traverse_module_state->__pyx_codeobj__51); + Py_VISIT(traverse_module_state->__pyx_codeobj__52); + Py_VISIT(traverse_module_state->__pyx_codeobj__54); + return 0; +} +#endif +/* #### Code section: module_state_defines ### */ +#define __pyx_d __pyx_mstate_global->__pyx_d +#define __pyx_b __pyx_mstate_global->__pyx_b +#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime +#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple +#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes +#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode +#ifdef __Pyx_CyFunction_USED +#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType +#endif +#ifdef __Pyx_FusedFunction_USED +#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType +#endif +#ifdef __Pyx_Generator_USED +#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType +#endif +#ifdef __Pyx_IterableCoroutine_USED +#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#define __pyx_type_7pybroma_7PyBroma_ImmutableError __pyx_mstate_global->__pyx_type_7pybroma_7PyBroma_ImmutableError +#define __pyx_type_7pybroma_7PyBroma_Type __pyx_mstate_global->__pyx_type_7pybroma_7PyBroma_Type +#define __pyx_type_7pybroma_7PyBroma_MemberFunctionProto __pyx_mstate_global->__pyx_type_7pybroma_7PyBroma_MemberFunctionProto +#define __pyx_type_7pybroma_7PyBroma_MemberField __pyx_mstate_global->__pyx_type_7pybroma_7PyBroma_MemberField +#define __pyx_type_7pybroma_7PyBroma_OutOfLineField __pyx_mstate_global->__pyx_type_7pybroma_7PyBroma_OutOfLineField +#define __pyx_type_7pybroma_7PyBroma_FunctionBindField __pyx_mstate_global->__pyx_type_7pybroma_7PyBroma_FunctionBindField +#define __pyx_type_7pybroma_7PyBroma_PadField __pyx_mstate_global->__pyx_type_7pybroma_7PyBroma_PadField +#define __pyx_type_7pybroma_7PyBroma_Field __pyx_mstate_global->__pyx_type_7pybroma_7PyBroma_Field +#define __pyx_type_7pybroma_7PyBroma_PlatformNumber __pyx_mstate_global->__pyx_type_7pybroma_7PyBroma_PlatformNumber +#define __pyx_type_7pybroma_7PyBroma_InlineField __pyx_mstate_global->__pyx_type_7pybroma_7PyBroma_InlineField +#define __pyx_type_7pybroma_7PyBroma_FunctionProto __pyx_mstate_global->__pyx_type_7pybroma_7PyBroma_FunctionProto +#define __pyx_type_7pybroma_7PyBroma_Function __pyx_mstate_global->__pyx_type_7pybroma_7PyBroma_Function +#define __pyx_type_7pybroma_7PyBroma_Class __pyx_mstate_global->__pyx_type_7pybroma_7PyBroma_Class +#define __pyx_type_7pybroma_7PyBroma_Root __pyx_mstate_global->__pyx_type_7pybroma_7PyBroma_Root +#endif +#define __pyx_ptype_7pybroma_7PyBroma_ImmutableError __pyx_mstate_global->__pyx_ptype_7pybroma_7PyBroma_ImmutableError +#define __pyx_ptype_7pybroma_7PyBroma_Type __pyx_mstate_global->__pyx_ptype_7pybroma_7PyBroma_Type +#define __pyx_ptype_7pybroma_7PyBroma_MemberFunctionProto __pyx_mstate_global->__pyx_ptype_7pybroma_7PyBroma_MemberFunctionProto +#define __pyx_ptype_7pybroma_7PyBroma_MemberField __pyx_mstate_global->__pyx_ptype_7pybroma_7PyBroma_MemberField +#define __pyx_ptype_7pybroma_7PyBroma_OutOfLineField __pyx_mstate_global->__pyx_ptype_7pybroma_7PyBroma_OutOfLineField +#define __pyx_ptype_7pybroma_7PyBroma_FunctionBindField __pyx_mstate_global->__pyx_ptype_7pybroma_7PyBroma_FunctionBindField +#define __pyx_ptype_7pybroma_7PyBroma_PadField __pyx_mstate_global->__pyx_ptype_7pybroma_7PyBroma_PadField +#define __pyx_ptype_7pybroma_7PyBroma_Field __pyx_mstate_global->__pyx_ptype_7pybroma_7PyBroma_Field +#define __pyx_ptype_7pybroma_7PyBroma_PlatformNumber __pyx_mstate_global->__pyx_ptype_7pybroma_7PyBroma_PlatformNumber +#define __pyx_ptype_7pybroma_7PyBroma_InlineField __pyx_mstate_global->__pyx_ptype_7pybroma_7PyBroma_InlineField +#define __pyx_ptype_7pybroma_7PyBroma_FunctionProto __pyx_mstate_global->__pyx_ptype_7pybroma_7PyBroma_FunctionProto +#define __pyx_ptype_7pybroma_7PyBroma_Function __pyx_mstate_global->__pyx_ptype_7pybroma_7PyBroma_Function +#define __pyx_ptype_7pybroma_7PyBroma_Class __pyx_mstate_global->__pyx_ptype_7pybroma_7PyBroma_Class +#define __pyx_ptype_7pybroma_7PyBroma_Root __pyx_mstate_global->__pyx_ptype_7pybroma_7PyBroma_Root +#define __pyx_n_s_Class __pyx_mstate_global->__pyx_n_s_Class +#define __pyx_n_s_Class___reduce_cython __pyx_mstate_global->__pyx_n_s_Class___reduce_cython +#define __pyx_n_s_Class___setstate_cython __pyx_mstate_global->__pyx_n_s_Class___setstate_cython +#define __pyx_n_s_Field __pyx_mstate_global->__pyx_n_s_Field +#define __pyx_n_s_Field___reduce_cython __pyx_mstate_global->__pyx_n_s_Field___reduce_cython +#define __pyx_n_s_Field___setstate_cython __pyx_mstate_global->__pyx_n_s_Field___setstate_cython +#define __pyx_n_s_Field_getAsFunctionBindField __pyx_mstate_global->__pyx_n_s_Field_getAsFunctionBindField +#define __pyx_n_s_Field_getAsMemberField __pyx_mstate_global->__pyx_n_s_Field_getAsMemberField +#define __pyx_n_s_Field_getAsOutOfLineField __pyx_mstate_global->__pyx_n_s_Field_getAsOutOfLineField +#define __pyx_n_s_Field_getAsPadField __pyx_mstate_global->__pyx_n_s_Field_getAsPadField +#define __pyx_n_s_Function __pyx_mstate_global->__pyx_n_s_Function +#define __pyx_n_s_FunctionBindField __pyx_mstate_global->__pyx_n_s_FunctionBindField +#define __pyx_n_s_FunctionBindField___reduce_cytho __pyx_mstate_global->__pyx_n_s_FunctionBindField___reduce_cytho +#define __pyx_n_s_FunctionBindField___setstate_cyt __pyx_mstate_global->__pyx_n_s_FunctionBindField___setstate_cyt +#define __pyx_n_s_FunctionProto __pyx_mstate_global->__pyx_n_s_FunctionProto +#define __pyx_n_s_FunctionProto___reduce_cython __pyx_mstate_global->__pyx_n_s_FunctionProto___reduce_cython +#define __pyx_n_s_FunctionProto___setstate_cython __pyx_mstate_global->__pyx_n_s_FunctionProto___setstate_cython +#define __pyx_n_s_Function___reduce_cython __pyx_mstate_global->__pyx_n_s_Function___reduce_cython +#define __pyx_n_s_Function___setstate_cython __pyx_mstate_global->__pyx_n_s_Function___setstate_cython +#define __pyx_n_s_ImmutableError __pyx_mstate_global->__pyx_n_s_ImmutableError +#define __pyx_n_s_ImmutableError___reduce_cython __pyx_mstate_global->__pyx_n_s_ImmutableError___reduce_cython +#define __pyx_n_s_ImmutableError___setstate_cython __pyx_mstate_global->__pyx_n_s_ImmutableError___setstate_cython +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0 +#define __pyx_n_s_InlineField __pyx_mstate_global->__pyx_n_s_InlineField +#define __pyx_n_s_InlineField___reduce_cython __pyx_mstate_global->__pyx_n_s_InlineField___reduce_cython +#define __pyx_n_s_InlineField___setstate_cython __pyx_mstate_global->__pyx_n_s_InlineField___setstate_cython +#define __pyx_n_s_KeyError __pyx_mstate_global->__pyx_n_s_KeyError +#define __pyx_n_s_MemberField __pyx_mstate_global->__pyx_n_s_MemberField +#define __pyx_n_s_MemberField___reduce_cython __pyx_mstate_global->__pyx_n_s_MemberField___reduce_cython +#define __pyx_n_s_MemberField___setstate_cython __pyx_mstate_global->__pyx_n_s_MemberField___setstate_cython +#define __pyx_n_s_MemberFunctionProto __pyx_mstate_global->__pyx_n_s_MemberFunctionProto +#define __pyx_n_s_MemberFunctionProto___reduce_cyt __pyx_mstate_global->__pyx_n_s_MemberFunctionProto___reduce_cyt +#define __pyx_n_s_MemberFunctionProto___setstate_c __pyx_mstate_global->__pyx_n_s_MemberFunctionProto___setstate_c +#define __pyx_kp_s_No_value_specified_for_struct_at __pyx_mstate_global->__pyx_kp_s_No_value_specified_for_struct_at +#define __pyx_kp_s_No_value_specified_for_struct_at_2 __pyx_mstate_global->__pyx_kp_s_No_value_specified_for_struct_at_2 +#define __pyx_n_s_OutOfLineField __pyx_mstate_global->__pyx_n_s_OutOfLineField +#define __pyx_n_s_OutOfLineField___reduce_cython __pyx_mstate_global->__pyx_n_s_OutOfLineField___reduce_cython +#define __pyx_n_s_OutOfLineField___setstate_cython __pyx_mstate_global->__pyx_n_s_OutOfLineField___setstate_cython +#define __pyx_n_s_PadField __pyx_mstate_global->__pyx_n_s_PadField +#define __pyx_n_s_PadField___reduce_cython __pyx_mstate_global->__pyx_n_s_PadField___reduce_cython +#define __pyx_n_s_PadField___setstate_cython __pyx_mstate_global->__pyx_n_s_PadField___setstate_cython +#define __pyx_n_s_PickleError __pyx_mstate_global->__pyx_n_s_PickleError +#define __pyx_kp_s_Pickling_of_struct_members_such __pyx_mstate_global->__pyx_kp_s_Pickling_of_struct_members_such +#define __pyx_kp_s_Pickling_of_struct_members_such_2 __pyx_mstate_global->__pyx_kp_s_Pickling_of_struct_members_such_2 +#define __pyx_n_s_PlatformNumber __pyx_mstate_global->__pyx_n_s_PlatformNumber +#define __pyx_n_s_PlatformNumber___reduce_cython __pyx_mstate_global->__pyx_n_s_PlatformNumber___reduce_cython +#define __pyx_n_s_PlatformNumber___setstate_cython __pyx_mstate_global->__pyx_n_s_PlatformNumber___setstate_cython +#define __pyx_n_s_Root __pyx_mstate_global->__pyx_n_s_Root +#define __pyx_n_s_Root___reduce_cython __pyx_mstate_global->__pyx_n_s_Root___reduce_cython +#define __pyx_n_s_Root___setstate_cython __pyx_mstate_global->__pyx_n_s_Root___setstate_cython +#define __pyx_n_s_Root_classesAsDict __pyx_mstate_global->__pyx_n_s_Root_classesAsDict +#define __pyx_n_s_Root_functionsAsDict __pyx_mstate_global->__pyx_n_s_Root_functionsAsDict +#define __pyx_n_s_Type __pyx_mstate_global->__pyx_n_s_Type +#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError +#define __pyx_n_s_Type___reduce_cython __pyx_mstate_global->__pyx_n_s_Type___reduce_cython +#define __pyx_n_s_Type___setstate_cython __pyx_mstate_global->__pyx_n_s_Type___setstate_cython +#define __pyx_n_s_ValueError __pyx_mstate_global->__pyx_n_s_ValueError +#define __pyx_kp_u__12 __pyx_mstate_global->__pyx_kp_u__12 +#define __pyx_n_s__13 __pyx_mstate_global->__pyx_n_s__13 +#define __pyx_n_u_args __pyx_mstate_global->__pyx_n_u_args +#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines +#define __pyx_n_s_c __pyx_mstate_global->__pyx_n_s_c +#define __pyx_n_s_classesAsDict __pyx_mstate_global->__pyx_n_s_classesAsDict +#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback +#define __pyx_n_u_depends __pyx_mstate_global->__pyx_n_u_depends +#define __pyx_n_s_dict __pyx_mstate_global->__pyx_n_s_dict +#define __pyx_n_s_dict_2 __pyx_mstate_global->__pyx_n_s_dict_2 +#define __pyx_n_s_dict_3 __pyx_mstate_global->__pyx_n_s_dict_3 +#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable +#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable +#define __pyx_n_u_fields __pyx_mstate_global->__pyx_n_u_fields +#define __pyx_n_s_fileName __pyx_mstate_global->__pyx_n_s_fileName +#define __pyx_n_s_functionsAsDict __pyx_mstate_global->__pyx_n_s_functionsAsDict +#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc +#define __pyx_n_s_getAsFunctionBindField __pyx_mstate_global->__pyx_n_s_getAsFunctionBindField +#define __pyx_n_s_getAsMemberField __pyx_mstate_global->__pyx_n_s_getAsMemberField +#define __pyx_n_s_getAsOutOfLineField __pyx_mstate_global->__pyx_n_s_getAsOutOfLineField +#define __pyx_n_s_getAsPadField __pyx_mstate_global->__pyx_n_s_getAsPadField +#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate +#define __pyx_n_u_id __pyx_mstate_global->__pyx_n_u_id +#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import +#define __pyx_n_s_init __pyx_mstate_global->__pyx_n_s_init +#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine +#define __pyx_kp_u_is_immutable __pyx_mstate_global->__pyx_kp_u_is_immutable +#define __pyx_n_s_is_struct __pyx_mstate_global->__pyx_n_s_is_struct +#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled +#define __pyx_n_u_links __pyx_mstate_global->__pyx_n_u_links +#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main +#define __pyx_n_u_missing __pyx_mstate_global->__pyx_n_u_missing +#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name +#define __pyx_n_u_name __pyx_mstate_global->__pyx_n_u_name +#define __pyx_n_s_name_2 __pyx_mstate_global->__pyx_n_s_name_2 +#define __pyx_n_s_new __pyx_mstate_global->__pyx_n_s_new +#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non +#define __pyx_n_s_pickle __pyx_mstate_global->__pyx_n_s_pickle +#define __pyx_n_s_pybroma_PyBroma __pyx_mstate_global->__pyx_n_s_pybroma_PyBroma +#define __pyx_kp_s_pybroma_PyBroma_pyx __pyx_mstate_global->__pyx_kp_s_pybroma_PyBroma_pyx +#define __pyx_n_s_pyx_PickleError __pyx_mstate_global->__pyx_n_s_pyx_PickleError +#define __pyx_n_s_pyx_checksum __pyx_mstate_global->__pyx_n_s_pyx_checksum +#define __pyx_n_s_pyx_result __pyx_mstate_global->__pyx_n_s_pyx_result +#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state +#define __pyx_n_s_pyx_type __pyx_mstate_global->__pyx_n_s_pyx_type +#define __pyx_n_s_pyx_unpickle_ImmutableError __pyx_mstate_global->__pyx_n_s_pyx_unpickle_ImmutableError +#define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable +#define __pyx_n_s_range __pyx_mstate_global->__pyx_n_s_range +#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce +#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython +#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex +#define __pyx_n_s_return __pyx_mstate_global->__pyx_n_s_return +#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self +#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate +#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython +#define __pyx_n_s_state __pyx_mstate_global->__pyx_n_s_state +#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource +#define __pyx_n_s_super __pyx_mstate_global->__pyx_n_s_super +#define __pyx_n_u_superclass __pyx_mstate_global->__pyx_n_u_superclass +#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test +#define __pyx_n_s_update __pyx_mstate_global->__pyx_n_s_update +#define __pyx_n_s_use_setstate __pyx_mstate_global->__pyx_n_s_use_setstate +#define __pyx_n_s_x __pyx_mstate_global->__pyx_n_s_x +#define __pyx_int_222419149 __pyx_mstate_global->__pyx_int_222419149 +#define __pyx_int_228825662 __pyx_mstate_global->__pyx_int_228825662 +#define __pyx_int_238750788 __pyx_mstate_global->__pyx_int_238750788 +#define __pyx_tuple_ __pyx_mstate_global->__pyx_tuple_ +#define __pyx_tuple__2 __pyx_mstate_global->__pyx_tuple__2 +#define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3 +#define __pyx_tuple__4 __pyx_mstate_global->__pyx_tuple__4 +#define __pyx_tuple__5 __pyx_mstate_global->__pyx_tuple__5 +#define __pyx_tuple__6 __pyx_mstate_global->__pyx_tuple__6 +#define __pyx_tuple__7 __pyx_mstate_global->__pyx_tuple__7 +#define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8 +#define __pyx_tuple__9 __pyx_mstate_global->__pyx_tuple__9 +#define __pyx_tuple__10 __pyx_mstate_global->__pyx_tuple__10 +#define __pyx_tuple__11 __pyx_mstate_global->__pyx_tuple__11 +#define __pyx_tuple__14 __pyx_mstate_global->__pyx_tuple__14 +#define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16 +#define __pyx_tuple__18 __pyx_mstate_global->__pyx_tuple__18 +#define __pyx_tuple__31 __pyx_mstate_global->__pyx_tuple__31 +#define __pyx_tuple__48 __pyx_mstate_global->__pyx_tuple__48 +#define __pyx_tuple__53 __pyx_mstate_global->__pyx_tuple__53 +#define __pyx_codeobj__15 __pyx_mstate_global->__pyx_codeobj__15 +#define __pyx_codeobj__17 __pyx_mstate_global->__pyx_codeobj__17 +#define __pyx_codeobj__19 __pyx_mstate_global->__pyx_codeobj__19 +#define __pyx_codeobj__20 __pyx_mstate_global->__pyx_codeobj__20 +#define __pyx_codeobj__21 __pyx_mstate_global->__pyx_codeobj__21 +#define __pyx_codeobj__22 __pyx_mstate_global->__pyx_codeobj__22 +#define __pyx_codeobj__23 __pyx_mstate_global->__pyx_codeobj__23 +#define __pyx_codeobj__24 __pyx_mstate_global->__pyx_codeobj__24 +#define __pyx_codeobj__25 __pyx_mstate_global->__pyx_codeobj__25 +#define __pyx_codeobj__26 __pyx_mstate_global->__pyx_codeobj__26 +#define __pyx_codeobj__27 __pyx_mstate_global->__pyx_codeobj__27 +#define __pyx_codeobj__28 __pyx_mstate_global->__pyx_codeobj__28 +#define __pyx_codeobj__29 __pyx_mstate_global->__pyx_codeobj__29 +#define __pyx_codeobj__30 __pyx_mstate_global->__pyx_codeobj__30 +#define __pyx_codeobj__32 __pyx_mstate_global->__pyx_codeobj__32 +#define __pyx_codeobj__33 __pyx_mstate_global->__pyx_codeobj__33 +#define __pyx_codeobj__34 __pyx_mstate_global->__pyx_codeobj__34 +#define __pyx_codeobj__35 __pyx_mstate_global->__pyx_codeobj__35 +#define __pyx_codeobj__36 __pyx_mstate_global->__pyx_codeobj__36 +#define __pyx_codeobj__37 __pyx_mstate_global->__pyx_codeobj__37 +#define __pyx_codeobj__38 __pyx_mstate_global->__pyx_codeobj__38 +#define __pyx_codeobj__39 __pyx_mstate_global->__pyx_codeobj__39 +#define __pyx_codeobj__40 __pyx_mstate_global->__pyx_codeobj__40 +#define __pyx_codeobj__41 __pyx_mstate_global->__pyx_codeobj__41 +#define __pyx_codeobj__42 __pyx_mstate_global->__pyx_codeobj__42 +#define __pyx_codeobj__43 __pyx_mstate_global->__pyx_codeobj__43 +#define __pyx_codeobj__44 __pyx_mstate_global->__pyx_codeobj__44 +#define __pyx_codeobj__45 __pyx_mstate_global->__pyx_codeobj__45 +#define __pyx_codeobj__46 __pyx_mstate_global->__pyx_codeobj__46 +#define __pyx_codeobj__47 __pyx_mstate_global->__pyx_codeobj__47 +#define __pyx_codeobj__49 __pyx_mstate_global->__pyx_codeobj__49 +#define __pyx_codeobj__50 __pyx_mstate_global->__pyx_codeobj__50 +#define __pyx_codeobj__51 __pyx_mstate_global->__pyx_codeobj__51 +#define __pyx_codeobj__52 __pyx_mstate_global->__pyx_codeobj__52 +#define __pyx_codeobj__54 __pyx_mstate_global->__pyx_codeobj__54 +/* #### Code section: module_code ### */ + +/* "string.to_py":31 + * + * @cname("__pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string(const string& s): # <<<<<<<<<<<<<< + * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size()) + * cdef extern from *: + */ + +static CYTHON_INLINE PyObject *__pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string(std::string const &__pyx_v_s) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string", 1); + + /* "string.to_py":32 + * @cname("__pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string(const string& s): + * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< + * cdef extern from *: + * cdef object __Pyx_PyUnicode_FromStringAndSize(const char*, size_t) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "string.to_py":31 + * + * @cname("__pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string(const string& s): # <<<<<<<<<<<<<< + * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size()) + * cdef extern from *: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("string.to_py.__pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "string.to_py":37 + * + * @cname("__pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(const string& s): # <<<<<<<<<<<<<< + * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size()) + * cdef extern from *: + */ + +static CYTHON_INLINE PyObject *__pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(std::string const &__pyx_v_s) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string", 1); + + /* "string.to_py":38 + * @cname("__pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(const string& s): + * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< + * cdef extern from *: + * cdef object __Pyx_PyStr_FromStringAndSize(const char*, size_t) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyUnicode_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "string.to_py":37 + * + * @cname("__pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(const string& s): # <<<<<<<<<<<<<< + * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size()) + * cdef extern from *: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("string.to_py.__pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "string.to_py":43 + * + * @cname("__pyx_convert_PyStr_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyStr_string_to_py_6libcpp_6string_std__in_string(const string& s): # <<<<<<<<<<<<<< + * return __Pyx_PyStr_FromStringAndSize(s.data(), s.size()) + * cdef extern from *: + */ + +static CYTHON_INLINE PyObject *__pyx_convert_PyStr_string_to_py_6libcpp_6string_std__in_string(std::string const &__pyx_v_s) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert_PyStr_string_to_py_6libcpp_6string_std__in_string", 1); + + /* "string.to_py":44 + * @cname("__pyx_convert_PyStr_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyStr_string_to_py_6libcpp_6string_std__in_string(const string& s): + * return __Pyx_PyStr_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< + * cdef extern from *: + * cdef object __Pyx_PyBytes_FromStringAndSize(const char*, size_t) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyStr_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "string.to_py":43 + * + * @cname("__pyx_convert_PyStr_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyStr_string_to_py_6libcpp_6string_std__in_string(const string& s): # <<<<<<<<<<<<<< + * return __Pyx_PyStr_FromStringAndSize(s.data(), s.size()) + * cdef extern from *: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("string.to_py.__pyx_convert_PyStr_string_to_py_6libcpp_6string_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "string.to_py":49 + * + * @cname("__pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string(const string& s): # <<<<<<<<<<<<<< + * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size()) + * cdef extern from *: + */ + +static CYTHON_INLINE PyObject *__pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string(std::string const &__pyx_v_s) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string", 1); + + /* "string.to_py":50 + * @cname("__pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string(const string& s): + * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< + * cdef extern from *: + * cdef object __Pyx_PyByteArray_FromStringAndSize(const char*, size_t) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "string.to_py":49 + * + * @cname("__pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string(const string& s): # <<<<<<<<<<<<<< + * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size()) + * cdef extern from *: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("string.to_py.__pyx_convert_PyBytes_string_to_py_6libcpp_6string_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "string.to_py":55 + * + * @cname("__pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string(const string& s): # <<<<<<<<<<<<<< + * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size()) + * + */ + +static CYTHON_INLINE PyObject *__pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string(std::string const &__pyx_v_s) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string", 1); + + /* "string.to_py":56 + * @cname("__pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string(const string& s): + * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyByteArray_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "string.to_py":55 + * + * @cname("__pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string") + * cdef inline object __pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string(const string& s): # <<<<<<<<<<<<<< + * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size()) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("string.to_py.__pyx_convert_PyByteArray_string_to_py_6libcpp_6string_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "string.from_py":13 + * + * @cname("__pyx_convert_string_from_py_6libcpp_6string_std__in_string") + * cdef string __pyx_convert_string_from_py_6libcpp_6string_std__in_string(object o) except *: # <<<<<<<<<<<<<< + * cdef Py_ssize_t length = 0 + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) + */ + +static std::string __pyx_convert_string_from_py_6libcpp_6string_std__in_string(PyObject *__pyx_v_o) { + Py_ssize_t __pyx_v_length; + char const *__pyx_v_data; + std::string __pyx_r; + char const *__pyx_t_1; + std::string __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "string.from_py":14 + * @cname("__pyx_convert_string_from_py_6libcpp_6string_std__in_string") + * cdef string __pyx_convert_string_from_py_6libcpp_6string_std__in_string(object o) except *: + * cdef Py_ssize_t length = 0 # <<<<<<<<<<<<<< + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) + * return string(data, length) + */ + __pyx_v_length = 0; + + /* "string.from_py":15 + * cdef string __pyx_convert_string_from_py_6libcpp_6string_std__in_string(object o) except *: + * cdef Py_ssize_t length = 0 + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) # <<<<<<<<<<<<<< + * return string(data, length) + * + */ + __pyx_t_1 = __Pyx_PyObject_AsStringAndSize(__pyx_v_o, (&__pyx_v_length)); if (unlikely(__pyx_t_1 == ((char const *)NULL))) __PYX_ERR(1, 15, __pyx_L1_error) + __pyx_v_data = __pyx_t_1; + + /* "string.from_py":16 + * cdef Py_ssize_t length = 0 + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) + * return string(data, length) # <<<<<<<<<<<<<< + * + * + */ + try { + __pyx_t_2 = std::string(__pyx_v_data, __pyx_v_length); + } catch(...) { + __Pyx_CppExn2PyErr(); + __PYX_ERR(1, 16, __pyx_L1_error) + } + __pyx_r = __pyx_t_2; + goto __pyx_L0; + + /* "string.from_py":13 + * + * @cname("__pyx_convert_string_from_py_6libcpp_6string_std__in_string") + * cdef string __pyx_convert_string_from_py_6libcpp_6string_std__in_string(object o) except *: # <<<<<<<<<<<<<< + * cdef Py_ssize_t length = 0 + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("string.from_py.__pyx_convert_string_from_py_6libcpp_6string_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + return __pyx_r; +} + +/* "FromPyStructUtility":12 + * + * @cname("__pyx_convert__from_py_struct__broma_3a__3a_Type") + * cdef struct_type __pyx_convert__from_py_struct__broma_3a__3a_Type(obj) except *: # <<<<<<<<<<<<<< + * cdef struct_type result + * if not PyMapping_Check(obj): + */ + +static struct broma::Type __pyx_convert__from_py_struct__broma_3a__3a_Type(PyObject *__pyx_v_obj) { + struct broma::Type __pyx_v_result; + PyObject *__pyx_v_value = NULL; + struct broma::Type __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + std::string __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert__from_py_struct__broma_3a__3a_Type", 1); + + /* "FromPyStructUtility":14 + * cdef struct_type __pyx_convert__from_py_struct__broma_3a__3a_Type(obj) except *: + * cdef struct_type result + * if not PyMapping_Check(obj): # <<<<<<<<<<<<<< + * __Pyx_RaiseUnexpectedTypeError(b"a mapping", obj) + * + */ + __pyx_t_1 = (!PyMapping_Check(__pyx_v_obj)); + if (__pyx_t_1) { + + /* "FromPyStructUtility":15 + * cdef struct_type result + * if not PyMapping_Check(obj): + * __Pyx_RaiseUnexpectedTypeError(b"a mapping", obj) # <<<<<<<<<<<<<< + * + * try: + */ + __pyx_t_2 = __Pyx_RaiseUnexpectedTypeError(((char const *)"a mapping"), __pyx_v_obj); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 15, __pyx_L1_error) + + /* "FromPyStructUtility":14 + * cdef struct_type __pyx_convert__from_py_struct__broma_3a__3a_Type(obj) except *: + * cdef struct_type result + * if not PyMapping_Check(obj): # <<<<<<<<<<<<<< + * __Pyx_RaiseUnexpectedTypeError(b"a mapping", obj) + * + */ + } + + /* "FromPyStructUtility":17 + * __Pyx_RaiseUnexpectedTypeError(b"a mapping", obj) + * + * try: # <<<<<<<<<<<<<< + * value = obj['name'] + * except KeyError: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + /*try:*/ { + + /* "FromPyStructUtility":18 + * + * try: + * value = obj['name'] # <<<<<<<<<<<<<< + * except KeyError: + * raise ValueError("No value specified for struct attribute 'name'") + */ + __pyx_t_6 = __Pyx_PyObject_Dict_GetItem(__pyx_v_obj, __pyx_n_s_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 18, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_v_value = __pyx_t_6; + __pyx_t_6 = 0; + + /* "FromPyStructUtility":17 + * __Pyx_RaiseUnexpectedTypeError(b"a mapping", obj) + * + * try: # <<<<<<<<<<<<<< + * value = obj['name'] + * except KeyError: + */ + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L9_try_end; + __pyx_L4_error:; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "FromPyStructUtility":19 + * try: + * value = obj['name'] + * except KeyError: # <<<<<<<<<<<<<< + * raise ValueError("No value specified for struct attribute 'name'") + * result.name = value + */ + __pyx_t_2 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError); + if (__pyx_t_2) { + __Pyx_AddTraceback("FromPyStructUtility.__pyx_convert__from_py_struct__broma_3a__3a_Type", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(1, 19, __pyx_L6_except_error) + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + + /* "FromPyStructUtility":20 + * value = obj['name'] + * except KeyError: + * raise ValueError("No value specified for struct attribute 'name'") # <<<<<<<<<<<<<< + * result.name = value + * try: + */ + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 20, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_Raise(__pyx_t_9, 0, 0, 0); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __PYX_ERR(1, 20, __pyx_L6_except_error) + } + goto __pyx_L6_except_error; + + /* "FromPyStructUtility":17 + * __Pyx_RaiseUnexpectedTypeError(b"a mapping", obj) + * + * try: # <<<<<<<<<<<<<< + * value = obj['name'] + * except KeyError: + */ + __pyx_L6_except_error:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + goto __pyx_L1_error; + __pyx_L9_try_end:; + } + + /* "FromPyStructUtility":21 + * except KeyError: + * raise ValueError("No value specified for struct attribute 'name'") + * result.name = value # <<<<<<<<<<<<<< + * try: + * value = obj['is_struct'] + */ + __pyx_t_10 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_v_value); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 21, __pyx_L1_error) + __pyx_v_result.name = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_10); + + /* "FromPyStructUtility":22 + * raise ValueError("No value specified for struct attribute 'name'") + * result.name = value + * try: # <<<<<<<<<<<<<< + * value = obj['is_struct'] + * except KeyError: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_4, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "FromPyStructUtility":23 + * result.name = value + * try: + * value = obj['is_struct'] # <<<<<<<<<<<<<< + * except KeyError: + * raise ValueError("No value specified for struct attribute 'is_struct'") + */ + __pyx_t_8 = __Pyx_PyObject_Dict_GetItem(__pyx_v_obj, __pyx_n_s_is_struct); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 23, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_8); + __pyx_t_8 = 0; + + /* "FromPyStructUtility":22 + * raise ValueError("No value specified for struct attribute 'name'") + * result.name = value + * try: # <<<<<<<<<<<<<< + * value = obj['is_struct'] + * except KeyError: + */ + } + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L17_try_end; + __pyx_L12_error:; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "FromPyStructUtility":24 + * try: + * value = obj['is_struct'] + * except KeyError: # <<<<<<<<<<<<<< + * raise ValueError("No value specified for struct attribute 'is_struct'") + * result.is_struct = value + */ + __pyx_t_2 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError); + if (__pyx_t_2) { + __Pyx_AddTraceback("FromPyStructUtility.__pyx_convert__from_py_struct__broma_3a__3a_Type", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_7, &__pyx_t_6) < 0) __PYX_ERR(1, 24, __pyx_L14_except_error) + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_6); + + /* "FromPyStructUtility":25 + * value = obj['is_struct'] + * except KeyError: + * raise ValueError("No value specified for struct attribute 'is_struct'") # <<<<<<<<<<<<<< + * result.is_struct = value + * return result + */ + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 25, __pyx_L14_except_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_Raise(__pyx_t_9, 0, 0, 0); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __PYX_ERR(1, 25, __pyx_L14_except_error) + } + goto __pyx_L14_except_error; + + /* "FromPyStructUtility":22 + * raise ValueError("No value specified for struct attribute 'name'") + * result.name = value + * try: # <<<<<<<<<<<<<< + * value = obj['is_struct'] + * except KeyError: + */ + __pyx_L14_except_error:; + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_4, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L17_try_end:; + } + + /* "FromPyStructUtility":26 + * except KeyError: + * raise ValueError("No value specified for struct attribute 'is_struct'") + * result.is_struct = value # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 26, __pyx_L1_error) + __pyx_v_result.is_struct = __pyx_t_1; + + /* "FromPyStructUtility":27 + * raise ValueError("No value specified for struct attribute 'is_struct'") + * result.is_struct = value + * return result # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "FromPyStructUtility":12 + * + * @cname("__pyx_convert__from_py_struct__broma_3a__3a_Type") + * cdef struct_type __pyx_convert__from_py_struct__broma_3a__3a_Type(obj) except *: # <<<<<<<<<<<<<< + * cdef struct_type result + * if not PyMapping_Check(obj): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("FromPyStructUtility.__pyx_convert__from_py_struct__broma_3a__3a_Type", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_value); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":28 + * cdef class ImmutableError(Exception): + * """Object is an immutable property and cannot mutate""" + * def __init__(self, str name): # <<<<<<<<<<<<<< + * super().__init__(name + " is immutable") + * + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_14ImmutableError_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_14ImmutableError_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_name = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 28, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 28, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + } + __pyx_v_name = ((PyObject*)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 28, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pybroma.PyBroma.ImmutableError.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyUnicode_Type), 1, "name", 1))) __PYX_ERR(0, 28, __pyx_L1_error) + __pyx_r = __pyx_pf_7pybroma_7PyBroma_14ImmutableError___init__(((struct __pyx_obj_7pybroma_7PyBroma_ImmutableError *)__pyx_v_self), __pyx_v_name); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_14ImmutableError___init__(struct __pyx_obj_7pybroma_7PyBroma_ImmutableError *__pyx_v_self, PyObject *__pyx_v_name) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 1); + + /* "pybroma/PyBroma.pyx":29 + * """Object is an immutable property and cannot mutate""" + * def __init__(self, str name): + * super().__init__(name + " is immutable") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF((PyObject *)__pyx_ptype_7pybroma_7PyBroma_ImmutableError); + __Pyx_GIVEREF((PyObject *)__pyx_ptype_7pybroma_7PyBroma_ImmutableError); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)__pyx_ptype_7pybroma_7PyBroma_ImmutableError))) __PYX_ERR(0, 29, __pyx_L1_error); + __Pyx_INCREF((PyObject *)__pyx_v_self); + __Pyx_GIVEREF((PyObject *)__pyx_v_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, ((PyObject *)__pyx_v_self))) __PYX_ERR(0, 29, __pyx_L1_error); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_init); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyUnicode_ConcatSafe(__pyx_v_name, __pyx_kp_u_is_immutable); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "pybroma/PyBroma.pyx":28 + * cdef class ImmutableError(Exception): + * """Object is an immutable property and cannot mutate""" + * def __init__(self, str name): # <<<<<<<<<<<<<< + * super().__init__(name + " is immutable") + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pybroma.PyBroma.ImmutableError.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_14ImmutableError_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_14ImmutableError_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_14ImmutableError_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_14ImmutableError_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_14ImmutableError_2__reduce_cython__(((struct __pyx_obj_7pybroma_7PyBroma_ImmutableError *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_14ImmutableError_2__reduce_cython__(struct __pyx_obj_7pybroma_7PyBroma_ImmutableError *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = () # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_v_state = __pyx_empty_tuple; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = () + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(1, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = False + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = False # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_ImmutableError, (type(self), 0xe3b0c44, None), state + */ + /*else*/ { + __pyx_v_use_setstate = 0; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_ImmutableError, (type(self), 0xe3b0c44, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = False + * if use_setstate: + * return __pyx_unpickle_ImmutableError, (type(self), 0xe3b0c44, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_ImmutableError, (type(self), 0xe3b0c44, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_ImmutableError); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_ImmutableError, (type(self), 0xe3b0c44, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_ImmutableError, (type(self), 0xe3b0c44, None), state + * else: + * return __pyx_unpickle_ImmutableError, (type(self), 0xe3b0c44, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_ImmutableError__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_ImmutableError); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pybroma.PyBroma.ImmutableError.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_ImmutableError, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_ImmutableError__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_14ImmutableError_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_14ImmutableError_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_14ImmutableError_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_14ImmutableError_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pybroma.PyBroma.ImmutableError.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_14ImmutableError_4__setstate_cython__(((struct __pyx_obj_7pybroma_7PyBroma_ImmutableError *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_14ImmutableError_4__setstate_cython__(struct __pyx_obj_7pybroma_7PyBroma_ImmutableError *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_ImmutableError, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_ImmutableError__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_7pybroma_7PyBroma___pyx_unpickle_ImmutableError__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_ImmutableError, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_ImmutableError__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.ImmutableError.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":37 + * broma.Type type + * + * def __cinit__(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_4Type_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_4Type_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_4Type___cinit__(((struct __pyx_obj_7pybroma_7PyBroma_Type *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_4Type___cinit__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Type *__pyx_v_self) { + int __pyx_r; + + /* function exit code */ + __pyx_r = 0; + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":41 + * + * property name: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.type.name + * def __set__(self, obj): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Type_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Type_4name_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_4Type_4name___get__(((struct __pyx_obj_7pybroma_7PyBroma_Type *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Type_4name___get__(struct __pyx_obj_7pybroma_7PyBroma_Type *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":42 + * property name: + * def __get__(self): + * return self.type.name # <<<<<<<<<<<<<< + * def __set__(self, obj): + * raise ImmutableError("name") + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(__pyx_v_self->type.name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":41 + * + * property name: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.type.name + * def __set__(self, obj): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Type.name.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":43 + * def __get__(self): + * return self.type.name + * def __set__(self, obj): # <<<<<<<<<<<<<< + * raise ImmutableError("name") + * + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_4Type_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_obj); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_4Type_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_obj) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_4Type_4name_2__set__(((struct __pyx_obj_7pybroma_7PyBroma_Type *)__pyx_v_self), ((PyObject *)__pyx_v_obj)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_4Type_4name_2__set__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Type *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + + /* "pybroma/PyBroma.pyx":44 + * return self.type.name + * def __set__(self, obj): + * raise ImmutableError("name") # <<<<<<<<<<<<<< + * + * def __eq__(self, Type t): + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_ImmutableError), __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 44, __pyx_L1_error) + + /* "pybroma/PyBroma.pyx":43 + * def __get__(self): + * return self.type.name + * def __set__(self, obj): # <<<<<<<<<<<<<< + * raise ImmutableError("name") + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Type.name.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":46 + * raise ImmutableError("name") + * + * def __eq__(self, Type t): # <<<<<<<<<<<<<< + * return broma.TypeEquals(self.type, t) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Type_3__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_t); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Type_3__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_t) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_ptype_7pybroma_7PyBroma_Type, 1, "t", 0))) __PYX_ERR(0, 46, __pyx_L1_error) + __pyx_r = __pyx_pf_7pybroma_7PyBroma_4Type_2__eq__(((struct __pyx_obj_7pybroma_7PyBroma_Type *)__pyx_v_self), ((struct __pyx_obj_7pybroma_7PyBroma_Type *)__pyx_v_t)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Type_2__eq__(struct __pyx_obj_7pybroma_7PyBroma_Type *__pyx_v_self, struct __pyx_obj_7pybroma_7PyBroma_Type *__pyx_v_t) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + struct broma::Type __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__eq__", 1); + + /* "pybroma/PyBroma.pyx":47 + * + * def __eq__(self, Type t): + * return broma.TypeEquals(self.type, t) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert__from_py_struct__broma_3a__3a_Type(((PyObject *)__pyx_v_t)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 47, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBool_FromLong(TypeEquals(__pyx_v_self->type, __pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":46 + * raise ImmutableError("name") + * + * def __eq__(self, Type t): # <<<<<<<<<<<<<< + * return broma.TypeEquals(self.type, t) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pybroma.PyBroma.Type.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":49 + * return broma.TypeEquals(self.type, t) + * + * @property # <<<<<<<<<<<<<< + * def is_struct(self): + * return self.type.is_struct + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Type_9is_struct_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Type_9is_struct_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_4Type_9is_struct___get__(((struct __pyx_obj_7pybroma_7PyBroma_Type *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Type_9is_struct___get__(struct __pyx_obj_7pybroma_7PyBroma_Type *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":51 + * @property + * def is_struct(self): + * return self.type.is_struct # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->type.is_struct); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":49 + * return broma.TypeEquals(self.type, t) + * + * @property # <<<<<<<<<<<<<< + * def is_struct(self): + * return self.type.is_struct + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Type.is_struct.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Type_5__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_4Type_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_4Type_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Type_5__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_4Type_4__reduce_cython__(((struct __pyx_obj_7pybroma_7PyBroma_Type *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Type_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Type *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.Type.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Type_7__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_4Type_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_4Type_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Type_7__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pybroma.PyBroma.Type.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_4Type_6__setstate_cython__(((struct __pyx_obj_7pybroma_7PyBroma_Type *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Type_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Type *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.Type.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":54 + * + * + * cdef Type make_type(broma.Type t) noexcept: # <<<<<<<<<<<<<< + * cdef Type ty = Type(t) + * ty.type = t + */ + +static struct __pyx_obj_7pybroma_7PyBroma_Type *__pyx_f_7pybroma_7PyBroma_make_type(struct broma::Type __pyx_v_t) { + struct __pyx_obj_7pybroma_7PyBroma_Type *__pyx_v_ty = 0; + struct __pyx_obj_7pybroma_7PyBroma_Type *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("make_type", 1); + + /* "pybroma/PyBroma.pyx":55 + * + * cdef Type make_type(broma.Type t) noexcept: + * cdef Type ty = Type(t) # <<<<<<<<<<<<<< + * ty.type = t + * return ty + */ + __pyx_t_1 = __pyx_convert__to_py_struct__broma_3a__3a_Type(__pyx_v_t); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_Type), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_ty = ((struct __pyx_obj_7pybroma_7PyBroma_Type *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "pybroma/PyBroma.pyx":56 + * cdef Type make_type(broma.Type t) noexcept: + * cdef Type ty = Type(t) + * ty.type = t # <<<<<<<<<<<<<< + * return ty + * + */ + __pyx_v_ty->type = __pyx_v_t; + + /* "pybroma/PyBroma.pyx":57 + * cdef Type ty = Type(t) + * ty.type = t + * return ty # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_ty); + __pyx_r = __pyx_v_ty; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":54 + * + * + * cdef Type make_type(broma.Type t) noexcept: # <<<<<<<<<<<<<< + * cdef Type ty = Type(t) + * ty.type = t + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pybroma.PyBroma.make_type", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_ty); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":67 + * dict _args + * + * def __cinit__(self): # <<<<<<<<<<<<<< + * self._args = dict() + * pass + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto___cinit__(((struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto___cinit__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 1); + + /* "pybroma/PyBroma.pyx":68 + * + * def __cinit__(self): + * self._args = dict() # <<<<<<<<<<<<<< + * pass + * + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_args); + __Pyx_DECREF(__pyx_v_self->_args); + __pyx_v_self->_args = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pybroma/PyBroma.pyx":67 + * dict _args + * + * def __cinit__(self): # <<<<<<<<<<<<<< + * self._args = dict() + * pass + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.MemberFunctionProto.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":71 + * pass + * + * cdef void init(self, broma.MemberFunctionProto proto): # <<<<<<<<<<<<<< + * self.proto = proto + * self._args = {a.second : make_type(a.first) for a in proto.args} + */ + +static void __pyx_f_7pybroma_7PyBroma_19MemberFunctionProto_init(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self, struct broma::MemberFunctionProto __pyx_v_proto) { + std::pair __pyx_7genexpr__pyx_v_a; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + std::vector > ::iterator __pyx_t_2; + std::pair __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("init", 1); + + /* "pybroma/PyBroma.pyx":72 + * + * cdef void init(self, broma.MemberFunctionProto proto): + * self.proto = proto # <<<<<<<<<<<<<< + * self._args = {a.second : make_type(a.first) for a in proto.args} + * + */ + __pyx_v_self->proto = __pyx_v_proto; + + /* "pybroma/PyBroma.pyx":73 + * cdef void init(self, broma.MemberFunctionProto proto): + * self.proto = proto + * self._args = {a.second : make_type(a.first) for a in proto.args} # <<<<<<<<<<<<<< + * + * property args: + */ + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_v_proto.args.begin(); + for (;;) { + if (!(__pyx_t_2 != __pyx_v_proto.args.end())) break; + __pyx_t_3 = *__pyx_t_2; + ++__pyx_t_2; + __pyx_7genexpr__pyx_v_a = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_3); + __pyx_t_4 = __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(__pyx_7genexpr__pyx_v_a.second); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = ((PyObject *)__pyx_f_7pybroma_7PyBroma_make_type(__pyx_7genexpr__pyx_v_a.first)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)((PyObject*)__pyx_t_4), (PyObject*)__pyx_t_5))) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } /* exit inner scope */ + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_args); + __Pyx_DECREF(__pyx_v_self->_args); + __pyx_v_self->_args = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pybroma/PyBroma.pyx":71 + * pass + * + * cdef void init(self, broma.MemberFunctionProto proto): # <<<<<<<<<<<<<< + * self.proto = proto + * self._args = {a.second : make_type(a.first) for a in proto.args} + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pybroma.PyBroma.MemberFunctionProto.init", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pybroma/PyBroma.pyx":76 + * + * property args: + * def __get__(self): # <<<<<<<<<<<<<< + * return self._args + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_4args_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_4args_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_4args___get__(((struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_4args___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":77 + * property args: + * def __get__(self): + * return self._args # <<<<<<<<<<<<<< + * + * def __set__(self, obj): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_args); + __pyx_r = __pyx_v_self->_args; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":76 + * + * property args: + * def __get__(self): # <<<<<<<<<<<<<< + * return self._args + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":79 + * return self._args + * + * def __set__(self, obj): # <<<<<<<<<<<<<< + * raise ImmutableError("args") + * + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_obj); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_obj) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_4args_2__set__(((struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *)__pyx_v_self), ((PyObject *)__pyx_v_obj)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_4args_2__set__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + + /* "pybroma/PyBroma.pyx":80 + * + * def __set__(self, obj): + * raise ImmutableError("args") # <<<<<<<<<<<<<< + * + * # TODO: Make More Fields Immutable + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_ImmutableError), __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 80, __pyx_L1_error) + + /* "pybroma/PyBroma.pyx":79 + * return self._args + * + * def __set__(self, obj): # <<<<<<<<<<<<<< + * raise ImmutableError("args") + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.MemberFunctionProto.args.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":83 + * + * # TODO: Make More Fields Immutable + * @property # <<<<<<<<<<<<<< + * def ret(self): + * return make_type(self.proto.ret) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_3ret_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_3ret_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_3ret___get__(((struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_3ret___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":85 + * @property + * def ret(self): + * return make_type(self.proto.ret) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_7pybroma_7PyBroma_make_type(__pyx_v_self->proto.ret)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":83 + * + * # TODO: Make More Fields Immutable + * @property # <<<<<<<<<<<<<< + * def ret(self): + * return make_type(self.proto.ret) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.MemberFunctionProto.ret.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":87 + * return make_type(self.proto.ret) + * + * @property # <<<<<<<<<<<<<< + * def is_const(self): + * return self.proto.is_const + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_8is_const_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_8is_const_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_8is_const___get__(((struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_8is_const___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":89 + * @property + * def is_const(self): + * return self.proto.is_const # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->proto.is_const); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":87 + * return make_type(self.proto.ret) + * + * @property # <<<<<<<<<<<<<< + * def is_const(self): + * return self.proto.is_const + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.MemberFunctionProto.is_const.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":91 + * return self.proto.is_const + * + * @property # <<<<<<<<<<<<<< + * def is_virtual(self): + * return self.proto.is_virtual + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_10is_virtual_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_10is_virtual_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_10is_virtual___get__(((struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_10is_virtual___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":93 + * @property + * def is_virtual(self): + * return self.proto.is_virtual # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->proto.is_virtual); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":91 + * return self.proto.is_const + * + * @property # <<<<<<<<<<<<<< + * def is_virtual(self): + * return self.proto.is_virtual + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.MemberFunctionProto.is_virtual.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":95 + * return self.proto.is_virtual + * + * @property # <<<<<<<<<<<<<< + * def is_callback(self): + * return self.proto.is_callback + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_11is_callback_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_11is_callback_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_11is_callback___get__(((struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_11is_callback___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":97 + * @property + * def is_callback(self): + * return self.proto.is_callback # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->proto.is_callback); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":95 + * return self.proto.is_virtual + * + * @property # <<<<<<<<<<<<<< + * def is_callback(self): + * return self.proto.is_callback + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.MemberFunctionProto.is_callback.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":99 + * return self.proto.is_callback + * + * @property # <<<<<<<<<<<<<< + * def is_static(self): + * return self.proto.is_static + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_9is_static_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_9is_static_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_9is_static___get__(((struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_9is_static___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":101 + * @property + * def is_static(self): + * return self.proto.is_static # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->proto.is_static); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":99 + * return self.proto.is_callback + * + * @property # <<<<<<<<<<<<<< + * def is_static(self): + * return self.proto.is_static + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.MemberFunctionProto.is_static.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":103 + * return self.proto.is_static + * + * @property # <<<<<<<<<<<<<< + * def type(self): + * return self.proto.type + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_4type_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_4type_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_4type___get__(((struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_4type___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":105 + * @property + * def type(self): + * return self.proto.type # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = [](const broma::FunctionType& x){return __Pyx_PyInt_From_int((int)x);}(__pyx_v_self->proto.type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":103 + * return self.proto.is_static + * + * @property # <<<<<<<<<<<<<< + * def type(self): + * return self.proto.type + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.MemberFunctionProto.type.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":107 + * return self.proto.type + * + * @property # <<<<<<<<<<<<<< + * def docs(self): + * return self.proto.docs + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_4docs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_4docs_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_4docs___get__(((struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_4docs___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":109 + * @property + * def docs(self): + * return self.proto.docs # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(__pyx_v_self->proto.docs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject*)__pyx_t_1)); + __pyx_r = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":107 + * return self.proto.type + * + * @property # <<<<<<<<<<<<<< + * def docs(self): + * return self.proto.docs + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.MemberFunctionProto.docs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":111 + * return self.proto.docs + * + * @property # <<<<<<<<<<<<<< + * def name(self): + * return self.proto.name + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_4name_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_4name___get__(((struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_4name___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":113 + * @property + * def name(self): + * return self.proto.name # <<<<<<<<<<<<<< + * + * def __eq__(self, MemberFunctionProto mfp): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(__pyx_v_self->proto.name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject*)__pyx_t_1)); + __pyx_r = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":111 + * return self.proto.docs + * + * @property # <<<<<<<<<<<<<< + * def name(self): + * return self.proto.name + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.MemberFunctionProto.name.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":115 + * return self.proto.name + * + * def __eq__(self, MemberFunctionProto mfp): # <<<<<<<<<<<<<< + * return broma.MemberFunctionProtoEquals(self.proto, mfp.proto) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_3__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_mfp); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_3__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_mfp) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_mfp), __pyx_ptype_7pybroma_7PyBroma_MemberFunctionProto, 1, "mfp", 0))) __PYX_ERR(0, 115, __pyx_L1_error) + __pyx_r = __pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_2__eq__(((struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *)__pyx_v_self), ((struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *)__pyx_v_mfp)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_2__eq__(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self, struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_mfp) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__eq__", 1); + + /* "pybroma/PyBroma.pyx":116 + * + * def __eq__(self, MemberFunctionProto mfp): + * return broma.MemberFunctionProtoEquals(self.proto, mfp.proto) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(MemberFunctionProtoEquals(__pyx_v_self->proto, __pyx_v_mfp->proto)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":115 + * return self.proto.name + * + * def __eq__(self, MemberFunctionProto mfp): # <<<<<<<<<<<<<< + * return broma.MemberFunctionProtoEquals(self.proto, mfp.proto) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.MemberFunctionProto.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_5__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_19MemberFunctionProto_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_5__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_4__reduce_cython__(((struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.MemberFunctionProto.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_7__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_19MemberFunctionProto_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_7__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pybroma.PyBroma.MemberFunctionProto.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_6__setstate_cython__(((struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_19MemberFunctionProto_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.MemberFunctionProto.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":119 + * + * + * cdef MemberFunctionProto make_MemberFunctionProto(broma.MemberFunctionProto proto) noexcept: # <<<<<<<<<<<<<< + * cdef MemberFunctionProto mfp = MemberFunctionProto() + * mfp.init(proto) + */ + +static struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_f_7pybroma_7PyBroma_make_MemberFunctionProto(struct broma::MemberFunctionProto __pyx_v_proto) { + struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_v_mfp = 0; + struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("make_MemberFunctionProto", 1); + + /* "pybroma/PyBroma.pyx":120 + * + * cdef MemberFunctionProto make_MemberFunctionProto(broma.MemberFunctionProto proto) noexcept: + * cdef MemberFunctionProto mfp = MemberFunctionProto() # <<<<<<<<<<<<<< + * mfp.init(proto) + * return mfp + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_MemberFunctionProto)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 120, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_mfp = ((struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pybroma/PyBroma.pyx":121 + * cdef MemberFunctionProto make_MemberFunctionProto(broma.MemberFunctionProto proto) noexcept: + * cdef MemberFunctionProto mfp = MemberFunctionProto() + * mfp.init(proto) # <<<<<<<<<<<<<< + * return mfp + * + */ + ((struct __pyx_vtabstruct_7pybroma_7PyBroma_MemberFunctionProto *)__pyx_v_mfp->__pyx_vtab)->init(__pyx_v_mfp, __pyx_v_proto); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 121, __pyx_L1_error) + + /* "pybroma/PyBroma.pyx":122 + * cdef MemberFunctionProto mfp = MemberFunctionProto() + * mfp.init(proto) + * return mfp # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_mfp); + __pyx_r = __pyx_v_mfp; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":119 + * + * + * cdef MemberFunctionProto make_MemberFunctionProto(broma.MemberFunctionProto proto) noexcept: # <<<<<<<<<<<<<< + * cdef MemberFunctionProto mfp = MemberFunctionProto() + * mfp.init(proto) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.make_MemberFunctionProto", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_mfp); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":129 + * broma.MemberField field + * + * def __cinit__(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_11MemberField_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_11MemberField_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_11MemberField___cinit__(((struct __pyx_obj_7pybroma_7PyBroma_MemberField *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_11MemberField___cinit__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_MemberField *__pyx_v_self) { + int __pyx_r; + + /* function exit code */ + __pyx_r = 0; + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":132 + * pass + * + * @property # <<<<<<<<<<<<<< + * def name(self): + * return self.field.name + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_11MemberField_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_11MemberField_4name_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_11MemberField_4name___get__(((struct __pyx_obj_7pybroma_7PyBroma_MemberField *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_11MemberField_4name___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberField *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":134 + * @property + * def name(self): + * return self.field.name # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(__pyx_v_self->field.name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject*)__pyx_t_1)); + __pyx_r = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":132 + * pass + * + * @property # <<<<<<<<<<<<<< + * def name(self): + * return self.field.name + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.MemberField.name.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":136 + * return self.field.name + * + * @property # <<<<<<<<<<<<<< + * def type(self): + * return make_type(self.field.type) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_11MemberField_4type_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_11MemberField_4type_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_11MemberField_4type___get__(((struct __pyx_obj_7pybroma_7PyBroma_MemberField *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_11MemberField_4type___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberField *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":138 + * @property + * def type(self): + * return make_type(self.field.type) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_7pybroma_7PyBroma_make_type(__pyx_v_self->field.type)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":136 + * return self.field.name + * + * @property # <<<<<<<<<<<<<< + * def type(self): + * return make_type(self.field.type) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.MemberField.type.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":140 + * return make_type(self.field.type) + * + * @property # <<<<<<<<<<<<<< + * def count(self): + * return self.field.count + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_11MemberField_5count_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_11MemberField_5count_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_11MemberField_5count___get__(((struct __pyx_obj_7pybroma_7PyBroma_MemberField *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_11MemberField_5count___get__(struct __pyx_obj_7pybroma_7PyBroma_MemberField *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":142 + * @property + * def count(self): + * return self.field.count # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_v_self->field.count); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":140 + * return make_type(self.field.type) + * + * @property # <<<<<<<<<<<<<< + * def count(self): + * return self.field.count + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.MemberField.count.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_11MemberField_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_11MemberField_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_11MemberField_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_11MemberField_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_11MemberField_2__reduce_cython__(((struct __pyx_obj_7pybroma_7PyBroma_MemberField *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_11MemberField_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_MemberField *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.MemberField.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_11MemberField_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_11MemberField_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_11MemberField_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_11MemberField_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pybroma.PyBroma.MemberField.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_11MemberField_4__setstate_cython__(((struct __pyx_obj_7pybroma_7PyBroma_MemberField *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_11MemberField_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_MemberField *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.MemberField.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":146 + * + * + * cdef MemberField make_MemberField(broma.MemberField field) noexcept: # <<<<<<<<<<<<<< + * cdef MemberField f = MemberField() + * f.field = field + */ + +static struct __pyx_obj_7pybroma_7PyBroma_MemberField *__pyx_f_7pybroma_7PyBroma_make_MemberField(struct broma::MemberField __pyx_v_field) { + struct __pyx_obj_7pybroma_7PyBroma_MemberField *__pyx_v_f = 0; + struct __pyx_obj_7pybroma_7PyBroma_MemberField *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("make_MemberField", 1); + + /* "pybroma/PyBroma.pyx":147 + * + * cdef MemberField make_MemberField(broma.MemberField field) noexcept: + * cdef MemberField f = MemberField() # <<<<<<<<<<<<<< + * f.field = field + * return f + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_MemberField)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_f = ((struct __pyx_obj_7pybroma_7PyBroma_MemberField *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pybroma/PyBroma.pyx":148 + * cdef MemberField make_MemberField(broma.MemberField field) noexcept: + * cdef MemberField f = MemberField() + * f.field = field # <<<<<<<<<<<<<< + * return f + * + */ + __pyx_v_f->field = __pyx_v_field; + + /* "pybroma/PyBroma.pyx":149 + * cdef MemberField f = MemberField() + * f.field = field + * return f # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_f); + __pyx_r = __pyx_v_f; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":146 + * + * + * cdef MemberField make_MemberField(broma.MemberField field) noexcept: # <<<<<<<<<<<<<< + * cdef MemberField f = MemberField() + * f.field = field + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.make_MemberField", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_f); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":158 + * broma.OutOfLineField oolf + * + * def __cinit__(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_14OutOfLineField_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_14OutOfLineField_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_14OutOfLineField___cinit__(((struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_14OutOfLineField___cinit__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *__pyx_v_self) { + int __pyx_r; + + /* function exit code */ + __pyx_r = 0; + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":161 + * pass + * + * @property # <<<<<<<<<<<<<< + * def prototype(self): + * return make_MemberFunctionProto(self.oolf.prototype) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_14OutOfLineField_9prototype_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_14OutOfLineField_9prototype_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_14OutOfLineField_9prototype___get__(((struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_14OutOfLineField_9prototype___get__(struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":163 + * @property + * def prototype(self): + * return make_MemberFunctionProto(self.oolf.prototype) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_7pybroma_7PyBroma_make_MemberFunctionProto(__pyx_v_self->oolf.prototype)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":161 + * pass + * + * @property # <<<<<<<<<<<<<< + * def prototype(self): + * return make_MemberFunctionProto(self.oolf.prototype) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.OutOfLineField.prototype.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":165 + * return make_MemberFunctionProto(self.oolf.prototype) + * + * @property # <<<<<<<<<<<<<< + * def inner(self): + * return self.oolf.inner + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_14OutOfLineField_5inner_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_14OutOfLineField_5inner_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_14OutOfLineField_5inner___get__(((struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_14OutOfLineField_5inner___get__(struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":167 + * @property + * def inner(self): + * return self.oolf.inner # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(__pyx_v_self->oolf.inner); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject*)__pyx_t_1)); + __pyx_r = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":165 + * return make_MemberFunctionProto(self.oolf.prototype) + * + * @property # <<<<<<<<<<<<<< + * def inner(self): + * return self.oolf.inner + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.OutOfLineField.inner.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_14OutOfLineField_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_14OutOfLineField_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_14OutOfLineField_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_14OutOfLineField_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_14OutOfLineField_2__reduce_cython__(((struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_14OutOfLineField_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.OutOfLineField.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_14OutOfLineField_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_14OutOfLineField_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_14OutOfLineField_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_14OutOfLineField_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pybroma.PyBroma.OutOfLineField.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_14OutOfLineField_4__setstate_cython__(((struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_14OutOfLineField_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.OutOfLineField.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":171 + * + * + * cdef OutOfLineField make_OutOfLineField(broma.OutOfLineField oolf) noexcept: # <<<<<<<<<<<<<< + * cdef OutOfLineField _oolf = OutOfLineField() + * _oolf.oolf = oolf + */ + +static struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *__pyx_f_7pybroma_7PyBroma_make_OutOfLineField(struct broma::OutOfLineField __pyx_v_oolf) { + struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *__pyx_v__oolf = 0; + struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("make_OutOfLineField", 1); + + /* "pybroma/PyBroma.pyx":172 + * + * cdef OutOfLineField make_OutOfLineField(broma.OutOfLineField oolf) noexcept: + * cdef OutOfLineField _oolf = OutOfLineField() # <<<<<<<<<<<<<< + * _oolf.oolf = oolf + * return _oolf + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_OutOfLineField)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__oolf = ((struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pybroma/PyBroma.pyx":173 + * cdef OutOfLineField make_OutOfLineField(broma.OutOfLineField oolf) noexcept: + * cdef OutOfLineField _oolf = OutOfLineField() + * _oolf.oolf = oolf # <<<<<<<<<<<<<< + * return _oolf + * + */ + __pyx_v__oolf->oolf = __pyx_v_oolf; + + /* "pybroma/PyBroma.pyx":174 + * cdef OutOfLineField _oolf = OutOfLineField() + * _oolf.oolf = oolf + * return _oolf # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v__oolf); + __pyx_r = __pyx_v__oolf; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":171 + * + * + * cdef OutOfLineField make_OutOfLineField(broma.OutOfLineField oolf) noexcept: # <<<<<<<<<<<<<< + * cdef OutOfLineField _oolf = OutOfLineField() + * _oolf.oolf = oolf + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.make_OutOfLineField", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v__oolf); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":179 + * cdef class FunctionBindField: + * cdef broma.FunctionBindField fbf + * def __cinit__(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_17FunctionBindField_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_17FunctionBindField_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_17FunctionBindField___cinit__(((struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_17FunctionBindField___cinit__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *__pyx_v_self) { + int __pyx_r; + + /* function exit code */ + __pyx_r = 0; + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":182 + * pass + * + * @property # <<<<<<<<<<<<<< + * def prototype(self): + * return make_MemberFunctionProto(self.fbf.prototype) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_17FunctionBindField_9prototype_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_17FunctionBindField_9prototype_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_17FunctionBindField_9prototype___get__(((struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_17FunctionBindField_9prototype___get__(struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":184 + * @property + * def prototype(self): + * return make_MemberFunctionProto(self.fbf.prototype) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_7pybroma_7PyBroma_make_MemberFunctionProto(__pyx_v_self->fbf.prototype)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":182 + * pass + * + * @property # <<<<<<<<<<<<<< + * def prototype(self): + * return make_MemberFunctionProto(self.fbf.prototype) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.FunctionBindField.prototype.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":186 + * return make_MemberFunctionProto(self.fbf.prototype) + * + * @property # <<<<<<<<<<<<<< + * def binds(self): + * return make_PlatfornNum(self.fbf.binds) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_17FunctionBindField_5binds_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_17FunctionBindField_5binds_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_17FunctionBindField_5binds___get__(((struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_17FunctionBindField_5binds___get__(struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":188 + * @property + * def binds(self): + * return make_PlatfornNum(self.fbf.binds) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_7pybroma_7PyBroma_make_PlatfornNum(__pyx_v_self->fbf.binds)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":186 + * return make_MemberFunctionProto(self.fbf.prototype) + * + * @property # <<<<<<<<<<<<<< + * def binds(self): + * return make_PlatfornNum(self.fbf.binds) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.FunctionBindField.binds.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_17FunctionBindField_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_17FunctionBindField_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_17FunctionBindField_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_17FunctionBindField_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_17FunctionBindField_2__reduce_cython__(((struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_17FunctionBindField_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.FunctionBindField.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_17FunctionBindField_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_17FunctionBindField_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_17FunctionBindField_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_17FunctionBindField_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pybroma.PyBroma.FunctionBindField.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_17FunctionBindField_4__setstate_cython__(((struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_17FunctionBindField_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.FunctionBindField.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":191 + * + * + * cdef FunctionBindField make_FunctionBindField(broma.FunctionBindField fbf) noexcept: # <<<<<<<<<<<<<< + * cdef FunctionBindField _fbf = FunctionBindField() + * _fbf.fbf = fbf + */ + +static struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *__pyx_f_7pybroma_7PyBroma_make_FunctionBindField(struct broma::FunctionBindField __pyx_v_fbf) { + struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *__pyx_v__fbf = 0; + struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("make_FunctionBindField", 1); + + /* "pybroma/PyBroma.pyx":192 + * + * cdef FunctionBindField make_FunctionBindField(broma.FunctionBindField fbf) noexcept: + * cdef FunctionBindField _fbf = FunctionBindField() # <<<<<<<<<<<<<< + * _fbf.fbf = fbf + * return _fbf + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_FunctionBindField)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__fbf = ((struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pybroma/PyBroma.pyx":193 + * cdef FunctionBindField make_FunctionBindField(broma.FunctionBindField fbf) noexcept: + * cdef FunctionBindField _fbf = FunctionBindField() + * _fbf.fbf = fbf # <<<<<<<<<<<<<< + * return _fbf + * + */ + __pyx_v__fbf->fbf = __pyx_v_fbf; + + /* "pybroma/PyBroma.pyx":194 + * cdef FunctionBindField _fbf = FunctionBindField() + * _fbf.fbf = fbf + * return _fbf # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v__fbf); + __pyx_r = __pyx_v__fbf; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":191 + * + * + * cdef FunctionBindField make_FunctionBindField(broma.FunctionBindField fbf) noexcept: # <<<<<<<<<<<<<< + * cdef FunctionBindField _fbf = FunctionBindField() + * _fbf.fbf = fbf + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.make_FunctionBindField", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v__fbf); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":200 + * cdef: + * broma.PadField pf + * def __cinit__(self): # <<<<<<<<<<<<<< + * pass + * @property + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_8PadField_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_8PadField_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_8PadField___cinit__(((struct __pyx_obj_7pybroma_7PyBroma_PadField *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_8PadField___cinit__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_PadField *__pyx_v_self) { + int __pyx_r; + + /* function exit code */ + __pyx_r = 0; + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":202 + * def __cinit__(self): + * pass + * @property # <<<<<<<<<<<<<< + * def amount(self): + * return make_PlatfornNum(self.pf.amount) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_8PadField_6amount_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_8PadField_6amount_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_8PadField_6amount___get__(((struct __pyx_obj_7pybroma_7PyBroma_PadField *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_8PadField_6amount___get__(struct __pyx_obj_7pybroma_7PyBroma_PadField *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":204 + * @property + * def amount(self): + * return make_PlatfornNum(self.pf.amount) # <<<<<<<<<<<<<< + * + * cdef broma.PlatformNumber dummyPadFieldattr(): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_7pybroma_7PyBroma_make_PlatfornNum(__pyx_v_self->pf.amount)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":202 + * def __cinit__(self): + * pass + * @property # <<<<<<<<<<<<<< + * def amount(self): + * return make_PlatfornNum(self.pf.amount) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.PadField.amount.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_8PadField_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_8PadField_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_8PadField_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_8PadField_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_8PadField_2__reduce_cython__(((struct __pyx_obj_7pybroma_7PyBroma_PadField *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_8PadField_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_PadField *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.PadField.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_8PadField_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_8PadField_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_8PadField_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_8PadField_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pybroma.PyBroma.PadField.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_8PadField_4__setstate_cython__(((struct __pyx_obj_7pybroma_7PyBroma_PadField *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_8PadField_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_PadField *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.PadField.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":206 + * return make_PlatfornNum(self.pf.amount) + * + * cdef broma.PlatformNumber dummyPadFieldattr(): # <<<<<<<<<<<<<< + * cdef broma.PlatformNumber pn + * pn.win = 0 + */ + +static struct broma::PlatformNumber __pyx_f_7pybroma_7PyBroma_dummyPadFieldattr(void) { + struct broma::PlatformNumber __pyx_v_pn; + struct broma::PlatformNumber __pyx_r; + + /* "pybroma/PyBroma.pyx":208 + * cdef broma.PlatformNumber dummyPadFieldattr(): + * cdef broma.PlatformNumber pn + * pn.win = 0 # <<<<<<<<<<<<<< + * pn.mac = 0 + * pn.android32 = 0 + */ + __pyx_v_pn.win = 0; + + /* "pybroma/PyBroma.pyx":209 + * cdef broma.PlatformNumber pn + * pn.win = 0 + * pn.mac = 0 # <<<<<<<<<<<<<< + * pn.android32 = 0 + * pn.android64 = 0 + */ + __pyx_v_pn.mac = 0; + + /* "pybroma/PyBroma.pyx":210 + * pn.win = 0 + * pn.mac = 0 + * pn.android32 = 0 # <<<<<<<<<<<<<< + * pn.android64 = 0 + * pn.ios = 0 + */ + __pyx_v_pn.android32 = 0; + + /* "pybroma/PyBroma.pyx":211 + * pn.mac = 0 + * pn.android32 = 0 + * pn.android64 = 0 # <<<<<<<<<<<<<< + * pn.ios = 0 + * return pn + */ + __pyx_v_pn.android64 = 0; + + /* "pybroma/PyBroma.pyx":212 + * pn.android32 = 0 + * pn.android64 = 0 + * pn.ios = 0 # <<<<<<<<<<<<<< + * return pn + * + */ + __pyx_v_pn.ios = 0; + + /* "pybroma/PyBroma.pyx":213 + * pn.android64 = 0 + * pn.ios = 0 + * return pn # <<<<<<<<<<<<<< + * + * cdef PadField make_PadField(broma.PadField pf): + */ + __pyx_r = __pyx_v_pn; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":206 + * return make_PlatfornNum(self.pf.amount) + * + * cdef broma.PlatformNumber dummyPadFieldattr(): # <<<<<<<<<<<<<< + * cdef broma.PlatformNumber pn + * pn.win = 0 + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":215 + * return pn + * + * cdef PadField make_PadField(broma.PadField pf): # <<<<<<<<<<<<<< + * cdef PadField _pf = PadField() + * _pf.pf = pf + */ + +static struct __pyx_obj_7pybroma_7PyBroma_PadField *__pyx_f_7pybroma_7PyBroma_make_PadField(struct broma::PadField __pyx_v_pf) { + struct __pyx_obj_7pybroma_7PyBroma_PadField *__pyx_v__pf = 0; + struct __pyx_obj_7pybroma_7PyBroma_PadField *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("make_PadField", 1); + + /* "pybroma/PyBroma.pyx":216 + * + * cdef PadField make_PadField(broma.PadField pf): + * cdef PadField _pf = PadField() # <<<<<<<<<<<<<< + * _pf.pf = pf + * return _pf + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_PadField)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__pf = ((struct __pyx_obj_7pybroma_7PyBroma_PadField *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pybroma/PyBroma.pyx":217 + * cdef PadField make_PadField(broma.PadField pf): + * cdef PadField _pf = PadField() + * _pf.pf = pf # <<<<<<<<<<<<<< + * return _pf + * + */ + __pyx_v__pf->pf = __pyx_v_pf; + + /* "pybroma/PyBroma.pyx":218 + * cdef PadField _pf = PadField() + * _pf.pf = pf + * return _pf # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v__pf); + __pyx_r = __pyx_v__pf; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":215 + * return pn + * + * cdef PadField make_PadField(broma.PadField pf): # <<<<<<<<<<<<<< + * cdef PadField _pf = PadField() + * _pf.pf = pf + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.make_PadField", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v__pf); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":225 + * broma.Field field + * + * def __cinit__(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_5Field_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_5Field_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Field___cinit__(((struct __pyx_obj_7pybroma_7PyBroma_Field *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_5Field___cinit__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self) { + int __pyx_r; + + /* function exit code */ + __pyx_r = 0; + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":229 + * + * property id: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.field.field_id + * def __set__(self, obj): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Field_2id_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Field_2id_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Field_2id___get__(((struct __pyx_obj_7pybroma_7PyBroma_Field *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Field_2id___get__(struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":230 + * property id: + * def __get__(self): + * return self.field.field_id # <<<<<<<<<<<<<< + * def __set__(self, obj): + * raise ImmutableError("id") + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_v_self->field.field_id); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":229 + * + * property id: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.field.field_id + * def __set__(self, obj): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Field.id.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":231 + * def __get__(self): + * return self.field.field_id + * def __set__(self, obj): # <<<<<<<<<<<<<< + * raise ImmutableError("id") + * + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_5Field_2id_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_obj); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_5Field_2id_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_obj) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Field_2id_2__set__(((struct __pyx_obj_7pybroma_7PyBroma_Field *)__pyx_v_self), ((PyObject *)__pyx_v_obj)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_5Field_2id_2__set__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + + /* "pybroma/PyBroma.pyx":232 + * return self.field.field_id + * def __set__(self, obj): + * raise ImmutableError("id") # <<<<<<<<<<<<<< + * + * @property + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_ImmutableError), __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 232, __pyx_L1_error) + + /* "pybroma/PyBroma.pyx":231 + * def __get__(self): + * return self.field.field_id + * def __set__(self, obj): # <<<<<<<<<<<<<< + * raise ImmutableError("id") + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Field.id.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":234 + * raise ImmutableError("id") + * + * @property # <<<<<<<<<<<<<< + * def parent(self): + * return self.field.parent + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Field_6parent_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Field_6parent_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Field_6parent___get__(((struct __pyx_obj_7pybroma_7PyBroma_Field *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Field_6parent___get__(struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":236 + * @property + * def parent(self): + * return self.field.parent # <<<<<<<<<<<<<< + * + * def getAsFunctionBindField(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(__pyx_v_self->field.parent); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject*)__pyx_t_1)); + __pyx_r = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":234 + * raise ImmutableError("id") + * + * @property # <<<<<<<<<<<<<< + * def parent(self): + * return self.field.parent + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Field.parent.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":238 + * return self.field.parent + * + * def getAsFunctionBindField(self): # <<<<<<<<<<<<<< + * cdef broma.FunctionBindField* x = broma.Field_GetAs_FunctionBindField(&self.field) + * return make_FunctionBindField(DEPACK(x)) if x != nullptr else None + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Field_3getAsFunctionBindField(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_5Field_3getAsFunctionBindField = {"getAsFunctionBindField", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_5Field_3getAsFunctionBindField, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Field_3getAsFunctionBindField(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getAsFunctionBindField (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getAsFunctionBindField", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getAsFunctionBindField", 0))) return NULL; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Field_2getAsFunctionBindField(((struct __pyx_obj_7pybroma_7PyBroma_Field *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Field_2getAsFunctionBindField(struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self) { + struct broma::FunctionBindField *__pyx_v_x; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getAsFunctionBindField", 1); + + /* "pybroma/PyBroma.pyx":239 + * + * def getAsFunctionBindField(self): + * cdef broma.FunctionBindField* x = broma.Field_GetAs_FunctionBindField(&self.field) # <<<<<<<<<<<<<< + * return make_FunctionBindField(DEPACK(x)) if x != nullptr else None + * + */ + __pyx_v_x = Field_GetAs_FunctionBindField((&__pyx_v_self->field)); + + /* "pybroma/PyBroma.pyx":240 + * def getAsFunctionBindField(self): + * cdef broma.FunctionBindField* x = broma.Field_GetAs_FunctionBindField(&self.field) + * return make_FunctionBindField(DEPACK(x)) if x != nullptr else None # <<<<<<<<<<<<<< + * + * def getAsMemberField(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = (__pyx_v_x != nullptr); + if (__pyx_t_2) { + __pyx_t_3 = ((PyObject *)__pyx_f_7pybroma_7PyBroma_make_FunctionBindField(DEPACK(__pyx_v_x))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + } else { + __Pyx_INCREF(Py_None); + __pyx_t_1 = Py_None; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":238 + * return self.field.parent + * + * def getAsFunctionBindField(self): # <<<<<<<<<<<<<< + * cdef broma.FunctionBindField* x = broma.Field_GetAs_FunctionBindField(&self.field) + * return make_FunctionBindField(DEPACK(x)) if x != nullptr else None + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pybroma.PyBroma.Field.getAsFunctionBindField", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":242 + * return make_FunctionBindField(DEPACK(x)) if x != nullptr else None + * + * def getAsMemberField(self): # <<<<<<<<<<<<<< + * cdef broma.MemberField* x = broma.Field_GetAs_MemberField(&self.field) + * return make_MemberField(DEPACK(x)) if x != nullptr else None + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Field_5getAsMemberField(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_5Field_5getAsMemberField = {"getAsMemberField", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_5Field_5getAsMemberField, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Field_5getAsMemberField(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getAsMemberField (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getAsMemberField", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getAsMemberField", 0))) return NULL; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Field_4getAsMemberField(((struct __pyx_obj_7pybroma_7PyBroma_Field *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Field_4getAsMemberField(struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self) { + struct broma::MemberField *__pyx_v_x; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getAsMemberField", 1); + + /* "pybroma/PyBroma.pyx":243 + * + * def getAsMemberField(self): + * cdef broma.MemberField* x = broma.Field_GetAs_MemberField(&self.field) # <<<<<<<<<<<<<< + * return make_MemberField(DEPACK(x)) if x != nullptr else None + * + */ + __pyx_v_x = Field_GetAs_MemberField((&__pyx_v_self->field)); + + /* "pybroma/PyBroma.pyx":244 + * def getAsMemberField(self): + * cdef broma.MemberField* x = broma.Field_GetAs_MemberField(&self.field) + * return make_MemberField(DEPACK(x)) if x != nullptr else None # <<<<<<<<<<<<<< + * + * def getAsOutOfLineField(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = (__pyx_v_x != nullptr); + if (__pyx_t_2) { + __pyx_t_3 = ((PyObject *)__pyx_f_7pybroma_7PyBroma_make_MemberField(DEPACK(__pyx_v_x))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + } else { + __Pyx_INCREF(Py_None); + __pyx_t_1 = Py_None; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":242 + * return make_FunctionBindField(DEPACK(x)) if x != nullptr else None + * + * def getAsMemberField(self): # <<<<<<<<<<<<<< + * cdef broma.MemberField* x = broma.Field_GetAs_MemberField(&self.field) + * return make_MemberField(DEPACK(x)) if x != nullptr else None + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pybroma.PyBroma.Field.getAsMemberField", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":246 + * return make_MemberField(DEPACK(x)) if x != nullptr else None + * + * def getAsOutOfLineField(self): # <<<<<<<<<<<<<< + * cdef broma.OutOfLineField* x = broma.Field_GetAs_OutOfLineField(&self.field) + * return make_OutOfLineField(DEPACK(x)) if x != nullptr else None + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Field_7getAsOutOfLineField(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_5Field_7getAsOutOfLineField = {"getAsOutOfLineField", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_5Field_7getAsOutOfLineField, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Field_7getAsOutOfLineField(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getAsOutOfLineField (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getAsOutOfLineField", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getAsOutOfLineField", 0))) return NULL; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Field_6getAsOutOfLineField(((struct __pyx_obj_7pybroma_7PyBroma_Field *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Field_6getAsOutOfLineField(struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self) { + struct broma::OutOfLineField *__pyx_v_x; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getAsOutOfLineField", 1); + + /* "pybroma/PyBroma.pyx":247 + * + * def getAsOutOfLineField(self): + * cdef broma.OutOfLineField* x = broma.Field_GetAs_OutOfLineField(&self.field) # <<<<<<<<<<<<<< + * return make_OutOfLineField(DEPACK(x)) if x != nullptr else None + * + */ + __pyx_v_x = Field_GetAs_OutOfLineField((&__pyx_v_self->field)); + + /* "pybroma/PyBroma.pyx":248 + * def getAsOutOfLineField(self): + * cdef broma.OutOfLineField* x = broma.Field_GetAs_OutOfLineField(&self.field) + * return make_OutOfLineField(DEPACK(x)) if x != nullptr else None # <<<<<<<<<<<<<< + * + * def getAsPadField(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = (__pyx_v_x != nullptr); + if (__pyx_t_2) { + __pyx_t_3 = ((PyObject *)__pyx_f_7pybroma_7PyBroma_make_OutOfLineField(DEPACK(__pyx_v_x))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + } else { + __Pyx_INCREF(Py_None); + __pyx_t_1 = Py_None; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":246 + * return make_MemberField(DEPACK(x)) if x != nullptr else None + * + * def getAsOutOfLineField(self): # <<<<<<<<<<<<<< + * cdef broma.OutOfLineField* x = broma.Field_GetAs_OutOfLineField(&self.field) + * return make_OutOfLineField(DEPACK(x)) if x != nullptr else None + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pybroma.PyBroma.Field.getAsOutOfLineField", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":250 + * return make_OutOfLineField(DEPACK(x)) if x != nullptr else None + * + * def getAsPadField(self): # <<<<<<<<<<<<<< + * cdef broma.PadField* x = broma.Field_GetAs_PadField(&self.field) + * return make_PadField(DEPACK(x)) if x != nullptr else None + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Field_9getAsPadField(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_5Field_9getAsPadField = {"getAsPadField", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_5Field_9getAsPadField, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Field_9getAsPadField(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getAsPadField (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getAsPadField", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getAsPadField", 0))) return NULL; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Field_8getAsPadField(((struct __pyx_obj_7pybroma_7PyBroma_Field *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Field_8getAsPadField(struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self) { + struct broma::PadField *__pyx_v_x; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getAsPadField", 1); + + /* "pybroma/PyBroma.pyx":251 + * + * def getAsPadField(self): + * cdef broma.PadField* x = broma.Field_GetAs_PadField(&self.field) # <<<<<<<<<<<<<< + * return make_PadField(DEPACK(x)) if x != nullptr else None + * + */ + __pyx_v_x = Field_GetAs_PadField((&__pyx_v_self->field)); + + /* "pybroma/PyBroma.pyx":252 + * def getAsPadField(self): + * cdef broma.PadField* x = broma.Field_GetAs_PadField(&self.field) + * return make_PadField(DEPACK(x)) if x != nullptr else None # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = (__pyx_v_x != nullptr); + if (__pyx_t_2) { + __pyx_t_3 = ((PyObject *)__pyx_f_7pybroma_7PyBroma_make_PadField(DEPACK(__pyx_v_x))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + } else { + __Pyx_INCREF(Py_None); + __pyx_t_1 = Py_None; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":250 + * return make_OutOfLineField(DEPACK(x)) if x != nullptr else None + * + * def getAsPadField(self): # <<<<<<<<<<<<<< + * cdef broma.PadField* x = broma.Field_GetAs_PadField(&self.field) + * return make_PadField(DEPACK(x)) if x != nullptr else None + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pybroma.PyBroma.Field.getAsPadField", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":254 + * return make_PadField(DEPACK(x)) if x != nullptr else None + * + * @property # <<<<<<<<<<<<<< + * def missing(self): + * return self.field.missing + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Field_7missing_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Field_7missing_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Field_7missing___get__(((struct __pyx_obj_7pybroma_7PyBroma_Field *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Field_7missing___get__(struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":256 + * @property + * def missing(self): + * return self.field.missing # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(((int)__pyx_v_self->field.missing)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":254 + * return make_PadField(DEPACK(x)) if x != nullptr else None + * + * @property # <<<<<<<<<<<<<< + * def missing(self): + * return self.field.missing + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Field.missing.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":258 + * return self.field.missing + * + * @property # <<<<<<<<<<<<<< + * def links(self): + * return self.field.links + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Field_5links_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Field_5links_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Field_5links___get__(((struct __pyx_obj_7pybroma_7PyBroma_Field *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Field_5links___get__(struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":260 + * @property + * def links(self): + * return self.field.links # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(((int)__pyx_v_self->field.links)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":258 + * return self.field.missing + * + * @property # <<<<<<<<<<<<<< + * def links(self): + * return self.field.links + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Field.links.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Field_11__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_5Field_11__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_5Field_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Field_11__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Field_10__reduce_cython__(((struct __pyx_obj_7pybroma_7PyBroma_Field *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Field_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.Field.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Field_13__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_5Field_13__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_5Field_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Field_13__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pybroma.PyBroma.Field.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Field_12__setstate_cython__(((struct __pyx_obj_7pybroma_7PyBroma_Field *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Field_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.Field.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":263 + * + * + * cdef Field make_Field(broma.Field field) noexcept: # <<<<<<<<<<<<<< + * cdef Field f = Field() + * f.field = field + */ + +static struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_f_7pybroma_7PyBroma_make_Field(struct broma::Field __pyx_v_field) { + struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_v_f = 0; + struct __pyx_obj_7pybroma_7PyBroma_Field *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("make_Field", 1); + + /* "pybroma/PyBroma.pyx":264 + * + * cdef Field make_Field(broma.Field field) noexcept: + * cdef Field f = Field() # <<<<<<<<<<<<<< + * f.field = field + * return f + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_Field)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_f = ((struct __pyx_obj_7pybroma_7PyBroma_Field *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pybroma/PyBroma.pyx":265 + * cdef Field make_Field(broma.Field field) noexcept: + * cdef Field f = Field() + * f.field = field # <<<<<<<<<<<<<< + * return f + * + */ + __pyx_v_f->field = __pyx_v_field; + + /* "pybroma/PyBroma.pyx":266 + * cdef Field f = Field() + * f.field = field + * return f # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_f); + __pyx_r = __pyx_v_f; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":263 + * + * + * cdef Field make_Field(broma.Field field) noexcept: # <<<<<<<<<<<<<< + * cdef Field f = Field() + * f.field = field + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.make_Field", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_f); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":273 + * broma.PlatformNumber binds + * + * def __cinit__(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_14PlatformNumber_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_14PlatformNumber_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_14PlatformNumber___cinit__(((struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_14PlatformNumber___cinit__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *__pyx_v_self) { + int __pyx_r; + + /* function exit code */ + __pyx_r = 0; + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":276 + * pass + * + * @property # <<<<<<<<<<<<<< + * def mac(self): + * return self.binds.mac + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_14PlatformNumber_3mac_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_14PlatformNumber_3mac_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_14PlatformNumber_3mac___get__(((struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_14PlatformNumber_3mac___get__(struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":278 + * @property + * def mac(self): + * return self.binds.mac # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_ptrdiff_t(__pyx_v_self->binds.mac); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":276 + * pass + * + * @property # <<<<<<<<<<<<<< + * def mac(self): + * return self.binds.mac + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.PlatformNumber.mac.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":280 + * return self.binds.mac + * + * @property # <<<<<<<<<<<<<< + * def ios(self): + * return self.binds.ios + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_14PlatformNumber_3ios_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_14PlatformNumber_3ios_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_14PlatformNumber_3ios___get__(((struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_14PlatformNumber_3ios___get__(struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":282 + * @property + * def ios(self): + * return self.binds.ios # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_ptrdiff_t(__pyx_v_self->binds.ios); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 282, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":280 + * return self.binds.mac + * + * @property # <<<<<<<<<<<<<< + * def ios(self): + * return self.binds.ios + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.PlatformNumber.ios.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":284 + * return self.binds.ios + * + * @property # <<<<<<<<<<<<<< + * def win(self): + * return self.binds.win + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_14PlatformNumber_3win_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_14PlatformNumber_3win_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_14PlatformNumber_3win___get__(((struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_14PlatformNumber_3win___get__(struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":286 + * @property + * def win(self): + * return self.binds.win # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_ptrdiff_t(__pyx_v_self->binds.win); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":284 + * return self.binds.ios + * + * @property # <<<<<<<<<<<<<< + * def win(self): + * return self.binds.win + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.PlatformNumber.win.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":288 + * return self.binds.win + * + * @property # <<<<<<<<<<<<<< + * def android32(self): + * return self.binds.android32 + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_14PlatformNumber_9android32_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_14PlatformNumber_9android32_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_14PlatformNumber_9android32___get__(((struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_14PlatformNumber_9android32___get__(struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":290 + * @property + * def android32(self): + * return self.binds.android32 # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_ptrdiff_t(__pyx_v_self->binds.android32); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":288 + * return self.binds.win + * + * @property # <<<<<<<<<<<<<< + * def android32(self): + * return self.binds.android32 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.PlatformNumber.android32.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":292 + * return self.binds.android32 + * + * @property # <<<<<<<<<<<<<< + * def android64(self): + * return self.binds.android64 + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_14PlatformNumber_9android64_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_14PlatformNumber_9android64_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_14PlatformNumber_9android64___get__(((struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_14PlatformNumber_9android64___get__(struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":294 + * @property + * def android64(self): + * return self.binds.android64 # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_ptrdiff_t(__pyx_v_self->binds.android64); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":292 + * return self.binds.android32 + * + * @property # <<<<<<<<<<<<<< + * def android64(self): + * return self.binds.android64 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.PlatformNumber.android64.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_14PlatformNumber_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_14PlatformNumber_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_14PlatformNumber_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_14PlatformNumber_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_14PlatformNumber_2__reduce_cython__(((struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_14PlatformNumber_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.PlatformNumber.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_14PlatformNumber_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_14PlatformNumber_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_14PlatformNumber_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_14PlatformNumber_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pybroma.PyBroma.PlatformNumber.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_14PlatformNumber_4__setstate_cython__(((struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_14PlatformNumber_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.PlatformNumber.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":299 + * + * + * cdef PlatformNumber make_PlatfornNum(broma.PlatformNumber pn) noexcept: # <<<<<<<<<<<<<< + * cdef PlatformNumber f = PlatformNumber() + * f.binds = pn + */ + +static struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *__pyx_f_7pybroma_7PyBroma_make_PlatfornNum(struct broma::PlatformNumber __pyx_v_pn) { + struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *__pyx_v_f = 0; + struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("make_PlatfornNum", 1); + + /* "pybroma/PyBroma.pyx":300 + * + * cdef PlatformNumber make_PlatfornNum(broma.PlatformNumber pn) noexcept: + * cdef PlatformNumber f = PlatformNumber() # <<<<<<<<<<<<<< + * f.binds = pn + * return f + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_PlatformNumber)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_f = ((struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pybroma/PyBroma.pyx":301 + * cdef PlatformNumber make_PlatfornNum(broma.PlatformNumber pn) noexcept: + * cdef PlatformNumber f = PlatformNumber() + * f.binds = pn # <<<<<<<<<<<<<< + * return f + * + */ + __pyx_v_f->binds = __pyx_v_pn; + + /* "pybroma/PyBroma.pyx":302 + * cdef PlatformNumber f = PlatformNumber() + * f.binds = pn + * return f # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_f); + __pyx_r = __pyx_v_f; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":299 + * + * + * cdef PlatformNumber make_PlatfornNum(broma.PlatformNumber pn) noexcept: # <<<<<<<<<<<<<< + * cdef PlatformNumber f = PlatformNumber() + * f.binds = pn + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.make_PlatfornNum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_f); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":307 + * cdef class InlineField: + * cdef broma.InlineField _if + * def __cinit__(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_11InlineField_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_11InlineField_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_11InlineField___cinit__(((struct __pyx_obj_7pybroma_7PyBroma_InlineField *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_11InlineField___cinit__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_InlineField *__pyx_v_self) { + int __pyx_r; + + /* function exit code */ + __pyx_r = 0; + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":310 + * pass + * + * @property # <<<<<<<<<<<<<< + * def inner(self): + * return self._if.inner + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_11InlineField_5inner_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_11InlineField_5inner_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_11InlineField_5inner___get__(((struct __pyx_obj_7pybroma_7PyBroma_InlineField *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_11InlineField_5inner___get__(struct __pyx_obj_7pybroma_7PyBroma_InlineField *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":312 + * @property + * def inner(self): + * return self._if.inner # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(__pyx_v_self->_if.inner); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 312, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject*)__pyx_t_1)); + __pyx_r = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":310 + * pass + * + * @property # <<<<<<<<<<<<<< + * def inner(self): + * return self._if.inner + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.InlineField.inner.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_11InlineField_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_11InlineField_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_11InlineField_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_11InlineField_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_11InlineField_2__reduce_cython__(((struct __pyx_obj_7pybroma_7PyBroma_InlineField *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_11InlineField_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_InlineField *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.InlineField.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_11InlineField_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_11InlineField_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_11InlineField_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_11InlineField_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pybroma.PyBroma.InlineField.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_11InlineField_4__setstate_cython__(((struct __pyx_obj_7pybroma_7PyBroma_InlineField *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_11InlineField_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_InlineField *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.InlineField.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":316 + * + * + * cdef InlineField make_InlineField(broma.InlineField _if) noexcept: # <<<<<<<<<<<<<< + * cdef InlineField c = InlineField() + * c._if = _if + */ + +static struct __pyx_obj_7pybroma_7PyBroma_InlineField *__pyx_f_7pybroma_7PyBroma_make_InlineField(struct broma::InlineField __pyx_v__if) { + struct __pyx_obj_7pybroma_7PyBroma_InlineField *__pyx_v_c = 0; + struct __pyx_obj_7pybroma_7PyBroma_InlineField *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("make_InlineField", 1); + + /* "pybroma/PyBroma.pyx":317 + * + * cdef InlineField make_InlineField(broma.InlineField _if) noexcept: + * cdef InlineField c = InlineField() # <<<<<<<<<<<<<< + * c._if = _if + * return c + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_InlineField)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 317, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_c = ((struct __pyx_obj_7pybroma_7PyBroma_InlineField *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pybroma/PyBroma.pyx":318 + * cdef InlineField make_InlineField(broma.InlineField _if) noexcept: + * cdef InlineField c = InlineField() + * c._if = _if # <<<<<<<<<<<<<< + * return c + * + */ + __pyx_v_c->_if = __pyx_v__if; + + /* "pybroma/PyBroma.pyx":319 + * cdef InlineField c = InlineField() + * c._if = _if + * return c # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_c); + __pyx_r = __pyx_v_c; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":316 + * + * + * cdef InlineField make_InlineField(broma.InlineField _if) noexcept: # <<<<<<<<<<<<<< + * cdef InlineField c = InlineField() + * c._if = _if + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.make_InlineField", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_c); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":327 + * dict _args + * + * def __cinit__(self): # <<<<<<<<<<<<<< + * self._args = dict() + * pass + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_13FunctionProto_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_13FunctionProto_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_13FunctionProto___cinit__(((struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_13FunctionProto___cinit__(struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 1); + + /* "pybroma/PyBroma.pyx":328 + * + * def __cinit__(self): + * self._args = dict() # <<<<<<<<<<<<<< + * pass + * + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 328, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_args); + __Pyx_DECREF(__pyx_v_self->_args); + __pyx_v_self->_args = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pybroma/PyBroma.pyx":327 + * dict _args + * + * def __cinit__(self): # <<<<<<<<<<<<<< + * self._args = dict() + * pass + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.FunctionProto.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":332 + * + * + * cdef void init(self, broma.FunctionProto proto) noexcept: # <<<<<<<<<<<<<< + * cdef vector[pair[broma.Type, string]] args = proto.args + * cdef size_t i + */ + +static void __pyx_f_7pybroma_7PyBroma_13FunctionProto_init(struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_v_self, struct broma::FunctionProto __pyx_v_proto) { + std::vector > __pyx_v_args; + size_t __pyx_8genexpr1__pyx_v_i; + __Pyx_RefNannyDeclarations + std::vector > __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + std::vector > ::size_type __pyx_t_3; + std::vector > ::size_type __pyx_t_4; + size_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("init", 1); + + /* "pybroma/PyBroma.pyx":333 + * + * cdef void init(self, broma.FunctionProto proto) noexcept: + * cdef vector[pair[broma.Type, string]] args = proto.args # <<<<<<<<<<<<<< + * cdef size_t i + * self.proto = proto + */ + __pyx_t_1 = __pyx_v_proto.args; + __pyx_v_args = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_1); + + /* "pybroma/PyBroma.pyx":335 + * cdef vector[pair[broma.Type, string]] args = proto.args + * cdef size_t i + * self.proto = proto # <<<<<<<<<<<<<< + * self._args = {args[i].second : make_type(args[i].first) for i in range(args.size())} + * + */ + __pyx_v_self->proto = __pyx_v_proto; + + /* "pybroma/PyBroma.pyx":336 + * cdef size_t i + * self.proto = proto + * self._args = {args[i].second : make_type(args[i].first) for i in range(args.size())} # <<<<<<<<<<<<<< + * + * property args: + */ + { /* enter inner scope */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_v_args.size(); + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_8genexpr1__pyx_v_i = __pyx_t_5; + __pyx_t_6 = __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string((__pyx_v_args[__pyx_8genexpr1__pyx_v_i]).second); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = ((PyObject *)__pyx_f_7pybroma_7PyBroma_make_type((__pyx_v_args[__pyx_8genexpr1__pyx_v_i]).first)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (unlikely(PyDict_SetItem(__pyx_t_2, (PyObject*)((PyObject*)__pyx_t_6), (PyObject*)__pyx_t_7))) __PYX_ERR(0, 336, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } /* exit inner scope */ + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->_args); + __Pyx_DECREF(__pyx_v_self->_args); + __pyx_v_self->_args = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "pybroma/PyBroma.pyx":332 + * + * + * cdef void init(self, broma.FunctionProto proto) noexcept: # <<<<<<<<<<<<<< + * cdef vector[pair[broma.Type, string]] args = proto.args + * cdef size_t i + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_WriteUnraisable("pybroma.PyBroma.FunctionProto.init", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "pybroma/PyBroma.pyx":339 + * + * property args: + * def __get__(self): # <<<<<<<<<<<<<< + * return self._args + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_13FunctionProto_4args_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_13FunctionProto_4args_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_13FunctionProto_4args___get__(((struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_13FunctionProto_4args___get__(struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":340 + * property args: + * def __get__(self): + * return self._args # <<<<<<<<<<<<<< + * + * def __set__(self, obj): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_args); + __pyx_r = __pyx_v_self->_args; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":339 + * + * property args: + * def __get__(self): # <<<<<<<<<<<<<< + * return self._args + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":342 + * return self._args + * + * def __set__(self, obj): # <<<<<<<<<<<<<< + * raise ImmutableError("args") + * + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_13FunctionProto_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_obj); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_13FunctionProto_4args_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_obj) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_13FunctionProto_4args_2__set__(((struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *)__pyx_v_self), ((PyObject *)__pyx_v_obj)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_13FunctionProto_4args_2__set__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + + /* "pybroma/PyBroma.pyx":343 + * + * def __set__(self, obj): + * raise ImmutableError("args") # <<<<<<<<<<<<<< + * + * @property + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_ImmutableError), __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 343, __pyx_L1_error) + + /* "pybroma/PyBroma.pyx":342 + * return self._args + * + * def __set__(self, obj): # <<<<<<<<<<<<<< + * raise ImmutableError("args") + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.FunctionProto.args.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":345 + * raise ImmutableError("args") + * + * @property # <<<<<<<<<<<<<< + * def ret(self): + * return make_type(self.proto.ret) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_13FunctionProto_3ret_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_13FunctionProto_3ret_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_13FunctionProto_3ret___get__(((struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_13FunctionProto_3ret___get__(struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":347 + * @property + * def ret(self): + * return make_type(self.proto.ret) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_7pybroma_7PyBroma_make_type(__pyx_v_self->proto.ret)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":345 + * raise ImmutableError("args") + * + * @property # <<<<<<<<<<<<<< + * def ret(self): + * return make_type(self.proto.ret) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.FunctionProto.ret.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":349 + * return make_type(self.proto.ret) + * + * @property # <<<<<<<<<<<<<< + * def name(self): + * return self.proto.name + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_13FunctionProto_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_13FunctionProto_4name_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_13FunctionProto_4name___get__(((struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_13FunctionProto_4name___get__(struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":351 + * @property + * def name(self): + * return self.proto.name # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(__pyx_v_self->proto.name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject*)__pyx_t_1)); + __pyx_r = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":349 + * return make_type(self.proto.ret) + * + * @property # <<<<<<<<<<<<<< + * def name(self): + * return self.proto.name + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.FunctionProto.name.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":353 + * return self.proto.name + * + * @property # <<<<<<<<<<<<<< + * def docs(self): + * return self.proto.docs + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_13FunctionProto_4docs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_13FunctionProto_4docs_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_13FunctionProto_4docs___get__(((struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_13FunctionProto_4docs___get__(struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":355 + * @property + * def docs(self): + * return self.proto.docs # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(__pyx_v_self->proto.docs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 355, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject*)__pyx_t_1)); + __pyx_r = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":353 + * return self.proto.name + * + * @property # <<<<<<<<<<<<<< + * def docs(self): + * return self.proto.docs + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.FunctionProto.docs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_13FunctionProto_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_13FunctionProto_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_13FunctionProto_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_13FunctionProto_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_13FunctionProto_2__reduce_cython__(((struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_13FunctionProto_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.FunctionProto.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_13FunctionProto_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_13FunctionProto_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_13FunctionProto_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_13FunctionProto_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pybroma.PyBroma.FunctionProto.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_13FunctionProto_4__setstate_cython__(((struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_13FunctionProto_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.FunctionProto.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":360 + * + * + * cdef FunctionProto make_FunctionProto(broma.FunctionProto fp) noexcept: # <<<<<<<<<<<<<< + * cdef FunctionProto _fp = FunctionProto() + * _fp.init(fp) + */ + +static struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_f_7pybroma_7PyBroma_make_FunctionProto(struct broma::FunctionProto __pyx_v_fp) { + struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_v__fp = 0; + struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("make_FunctionProto", 1); + + /* "pybroma/PyBroma.pyx":361 + * + * cdef FunctionProto make_FunctionProto(broma.FunctionProto fp) noexcept: + * cdef FunctionProto _fp = FunctionProto() # <<<<<<<<<<<<<< + * _fp.init(fp) + * return _fp + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_FunctionProto)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__fp = ((struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pybroma/PyBroma.pyx":362 + * cdef FunctionProto make_FunctionProto(broma.FunctionProto fp) noexcept: + * cdef FunctionProto _fp = FunctionProto() + * _fp.init(fp) # <<<<<<<<<<<<<< + * return _fp + * + */ + ((struct __pyx_vtabstruct_7pybroma_7PyBroma_FunctionProto *)__pyx_v__fp->__pyx_vtab)->init(__pyx_v__fp, __pyx_v_fp); + + /* "pybroma/PyBroma.pyx":363 + * cdef FunctionProto _fp = FunctionProto() + * _fp.init(fp) + * return _fp # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v__fp); + __pyx_r = __pyx_v__fp; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":360 + * + * + * cdef FunctionProto make_FunctionProto(broma.FunctionProto fp) noexcept: # <<<<<<<<<<<<<< + * cdef FunctionProto _fp = FunctionProto() + * _fp.init(fp) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.make_FunctionProto", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v__fp); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":369 + * cdef: + * broma.Function func + * def __init__(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_8Function_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_8Function_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_8Function___init__(((struct __pyx_obj_7pybroma_7PyBroma_Function *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_8Function___init__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Function *__pyx_v_self) { + int __pyx_r; + + /* function exit code */ + __pyx_r = 0; + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":372 + * pass + * + * @property # <<<<<<<<<<<<<< + * def prototype(self): + * return make_FunctionProto(self.func.prototype) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_8Function_9prototype_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_8Function_9prototype_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_8Function_9prototype___get__(((struct __pyx_obj_7pybroma_7PyBroma_Function *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_8Function_9prototype___get__(struct __pyx_obj_7pybroma_7PyBroma_Function *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":374 + * @property + * def prototype(self): + * return make_FunctionProto(self.func.prototype) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_7pybroma_7PyBroma_make_FunctionProto(__pyx_v_self->func.prototype)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":372 + * pass + * + * @property # <<<<<<<<<<<<<< + * def prototype(self): + * return make_FunctionProto(self.func.prototype) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Function.prototype.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":376 + * return make_FunctionProto(self.func.prototype) + * + * @property # <<<<<<<<<<<<<< + * def binds(self): + * return make_PlatfornNum(self.func.binds) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_8Function_5binds_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_8Function_5binds_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_8Function_5binds___get__(((struct __pyx_obj_7pybroma_7PyBroma_Function *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_8Function_5binds___get__(struct __pyx_obj_7pybroma_7PyBroma_Function *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":378 + * @property + * def binds(self): + * return make_PlatfornNum(self.func.binds) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_7pybroma_7PyBroma_make_PlatfornNum(__pyx_v_self->func.binds)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 378, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":376 + * return make_FunctionProto(self.func.prototype) + * + * @property # <<<<<<<<<<<<<< + * def binds(self): + * return make_PlatfornNum(self.func.binds) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Function.binds.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":380 + * return make_PlatfornNum(self.func.binds) + * + * @property # <<<<<<<<<<<<<< + * def missing(self): + * return self.func.missing + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_8Function_7missing_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_8Function_7missing_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_8Function_7missing___get__(((struct __pyx_obj_7pybroma_7PyBroma_Function *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_8Function_7missing___get__(struct __pyx_obj_7pybroma_7PyBroma_Function *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":382 + * @property + * def missing(self): + * return self.func.missing # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = [](const broma::Platform& x){return __Pyx_PyInt_From_int((int)x);}(__pyx_v_self->func.missing); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":380 + * return make_PlatfornNum(self.func.binds) + * + * @property # <<<<<<<<<<<<<< + * def missing(self): + * return self.func.missing + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Function.missing.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":384 + * return self.func.missing + * + * @property # <<<<<<<<<<<<<< + * def links(self): + * return self.func.links + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_8Function_5links_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_8Function_5links_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_8Function_5links___get__(((struct __pyx_obj_7pybroma_7PyBroma_Function *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_8Function_5links___get__(struct __pyx_obj_7pybroma_7PyBroma_Function *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":386 + * @property + * def links(self): + * return self.func.links # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = [](const broma::Platform& x){return __Pyx_PyInt_From_int((int)x);}(__pyx_v_self->func.links); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 386, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":384 + * return self.func.missing + * + * @property # <<<<<<<<<<<<<< + * def links(self): + * return self.func.links + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Function.links.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self.func must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_8Function_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_8Function_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_8Function_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_8Function_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_8Function_2__reduce_cython__(((struct __pyx_obj_7pybroma_7PyBroma_Function *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_8Function_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Function *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "Pickling of struct members such as self.func must be explicitly requested with @auto_pickle(True)" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "Pickling of struct members such as self.func must be explicitly requested with @auto_pickle(True)" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_Pickling_of_struct_members_such, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self.func must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.Function.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "Pickling of struct members such as self.func must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self.func must be explicitly requested with @auto_pickle(True)" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_8Function_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_8Function_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_8Function_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_8Function_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pybroma.PyBroma.Function.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_8Function_4__setstate_cython__(((struct __pyx_obj_7pybroma_7PyBroma_Function *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_8Function_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Function *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "Pickling of struct members such as self.func must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "Pickling of struct members such as self.func must be explicitly requested with @auto_pickle(True)" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_Pickling_of_struct_members_such, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "Pickling of struct members such as self.func must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self.func must be explicitly requested with @auto_pickle(True)" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.Function.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":391 + * + * + * cdef Function make_Function(broma.Function func) noexcept: # <<<<<<<<<<<<<< + * cdef Function fn = Function() + * fn.func = func + */ + +static struct __pyx_obj_7pybroma_7PyBroma_Function *__pyx_f_7pybroma_7PyBroma_make_Function(struct broma::Function __pyx_v_func) { + struct __pyx_obj_7pybroma_7PyBroma_Function *__pyx_v_fn = 0; + struct __pyx_obj_7pybroma_7PyBroma_Function *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("make_Function", 1); + + /* "pybroma/PyBroma.pyx":392 + * + * cdef Function make_Function(broma.Function func) noexcept: + * cdef Function fn = Function() # <<<<<<<<<<<<<< + * fn.func = func + * return fn + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_Function)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 392, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_fn = ((struct __pyx_obj_7pybroma_7PyBroma_Function *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pybroma/PyBroma.pyx":393 + * cdef Function make_Function(broma.Function func) noexcept: + * cdef Function fn = Function() + * fn.func = func # <<<<<<<<<<<<<< + * return fn + * + */ + __pyx_v_fn->func = __pyx_v_func; + + /* "pybroma/PyBroma.pyx":394 + * cdef Function fn = Function() + * fn.func = func + * return fn # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_fn); + __pyx_r = __pyx_v_fn; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":391 + * + * + * cdef Function make_Function(broma.Function func) noexcept: # <<<<<<<<<<<<<< + * cdef Function fn = Function() + * fn.func = func + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.make_Function", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_fn); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":405 + * bint _depends_ran + * + * def __cinit__(self): # <<<<<<<<<<<<<< + * self._superclasses = [] + * self._superclasses_ran = False + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_5Class_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_5Class_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Class___cinit__(((struct __pyx_obj_7pybroma_7PyBroma_Class *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_5Class___cinit__(struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 1); + + /* "pybroma/PyBroma.pyx":406 + * + * def __cinit__(self): + * self._superclasses = [] # <<<<<<<<<<<<<< + * self._superclasses_ran = False + * self._depends = [] + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 406, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_superclasses); + __Pyx_DECREF(__pyx_v_self->_superclasses); + __pyx_v_self->_superclasses = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pybroma/PyBroma.pyx":407 + * def __cinit__(self): + * self._superclasses = [] + * self._superclasses_ran = False # <<<<<<<<<<<<<< + * self._depends = [] + * self._depends_ran = False + */ + __pyx_v_self->_superclasses_ran = 0; + + /* "pybroma/PyBroma.pyx":408 + * self._superclasses = [] + * self._superclasses_ran = False + * self._depends = [] # <<<<<<<<<<<<<< + * self._depends_ran = False + * + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 408, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_depends); + __Pyx_DECREF(__pyx_v_self->_depends); + __pyx_v_self->_depends = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pybroma/PyBroma.pyx":409 + * self._superclasses_ran = False + * self._depends = [] + * self._depends_ran = False # <<<<<<<<<<<<<< + * + * # You might be asking why? Simple truth is that these + */ + __pyx_v_self->_depends_ran = 0; + + /* "pybroma/PyBroma.pyx":405 + * bint _depends_ran + * + * def __cinit__(self): # <<<<<<<<<<<<<< + * self._superclasses = [] + * self._superclasses_ran = False + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Class.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":414 + * # properties aren't meant to be modified + * property name: + * def __get__(self): # <<<<<<<<<<<<<< + * return self._cls.name + * def __set__(self, obj): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Class_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Class_4name_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Class_4name___get__(((struct __pyx_obj_7pybroma_7PyBroma_Class *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Class_4name___get__(struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":415 + * property name: + * def __get__(self): + * return self._cls.name # <<<<<<<<<<<<<< + * def __set__(self, obj): + * raise ImmutableError("name") + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(__pyx_v_self->_cls.name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 415, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject*)__pyx_t_1)); + __pyx_r = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":414 + * # properties aren't meant to be modified + * property name: + * def __get__(self): # <<<<<<<<<<<<<< + * return self._cls.name + * def __set__(self, obj): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Class.name.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":416 + * def __get__(self): + * return self._cls.name + * def __set__(self, obj): # <<<<<<<<<<<<<< + * raise ImmutableError("name") + * + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_5Class_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_obj); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_5Class_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_obj) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Class_4name_2__set__(((struct __pyx_obj_7pybroma_7PyBroma_Class *)__pyx_v_self), ((PyObject *)__pyx_v_obj)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_5Class_4name_2__set__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + + /* "pybroma/PyBroma.pyx":417 + * return self._cls.name + * def __set__(self, obj): + * raise ImmutableError("name") # <<<<<<<<<<<<<< + * + * property links: + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_ImmutableError), __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 417, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 417, __pyx_L1_error) + + /* "pybroma/PyBroma.pyx":416 + * def __get__(self): + * return self._cls.name + * def __set__(self, obj): # <<<<<<<<<<<<<< + * raise ImmutableError("name") + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Class.name.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":420 + * + * property links: + * def __get__(self): # <<<<<<<<<<<<<< + * return self._cls.name + * def __set__(self, obj): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Class_5links_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Class_5links_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Class_5links___get__(((struct __pyx_obj_7pybroma_7PyBroma_Class *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Class_5links___get__(struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":421 + * property links: + * def __get__(self): + * return self._cls.name # <<<<<<<<<<<<<< + * def __set__(self, obj): + * raise ImmutableError("links") + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(__pyx_v_self->_cls.name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject*)__pyx_t_1)); + __pyx_r = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":420 + * + * property links: + * def __get__(self): # <<<<<<<<<<<<<< + * return self._cls.name + * def __set__(self, obj): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Class.links.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":422 + * def __get__(self): + * return self._cls.name + * def __set__(self, obj): # <<<<<<<<<<<<<< + * raise ImmutableError("links") + * + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_5Class_5links_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_obj); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_5Class_5links_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_obj) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Class_5links_2__set__(((struct __pyx_obj_7pybroma_7PyBroma_Class *)__pyx_v_self), ((PyObject *)__pyx_v_obj)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_5Class_5links_2__set__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + + /* "pybroma/PyBroma.pyx":423 + * return self._cls.name + * def __set__(self, obj): + * raise ImmutableError("links") # <<<<<<<<<<<<<< + * + * property missing: + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_ImmutableError), __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 423, __pyx_L1_error) + + /* "pybroma/PyBroma.pyx":422 + * def __get__(self): + * return self._cls.name + * def __set__(self, obj): # <<<<<<<<<<<<<< + * raise ImmutableError("links") + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Class.links.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":426 + * + * property missing: + * def __get__(self): # <<<<<<<<<<<<<< + * # TODO: Make Python Enum for defining Platform so that None is not used... + * return self._cls.missing + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Class_7missing_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Class_7missing_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Class_7missing___get__(((struct __pyx_obj_7pybroma_7PyBroma_Class *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Class_7missing___get__(struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":428 + * def __get__(self): + * # TODO: Make Python Enum for defining Platform so that None is not used... + * return self._cls.missing # <<<<<<<<<<<<<< + * def __set__(self, obj): + * raise ImmutableError("missing") + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = [](const broma::Platform& x){return __Pyx_PyInt_From_int((int)x);}(__pyx_v_self->_cls.missing); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":426 + * + * property missing: + * def __get__(self): # <<<<<<<<<<<<<< + * # TODO: Make Python Enum for defining Platform so that None is not used... + * return self._cls.missing + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Class.missing.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":429 + * # TODO: Make Python Enum for defining Platform so that None is not used... + * return self._cls.missing + * def __set__(self, obj): # <<<<<<<<<<<<<< + * raise ImmutableError("missing") + * + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_5Class_7missing_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_obj); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_5Class_7missing_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_obj) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Class_7missing_2__set__(((struct __pyx_obj_7pybroma_7PyBroma_Class *)__pyx_v_self), ((PyObject *)__pyx_v_obj)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_5Class_7missing_2__set__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + + /* "pybroma/PyBroma.pyx":430 + * return self._cls.missing + * def __set__(self, obj): + * raise ImmutableError("missing") # <<<<<<<<<<<<<< + * + * property superclasses: + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_ImmutableError), __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 430, __pyx_L1_error) + + /* "pybroma/PyBroma.pyx":429 + * # TODO: Make Python Enum for defining Platform so that None is not used... + * return self._cls.missing + * def __set__(self, obj): # <<<<<<<<<<<<<< + * raise ImmutableError("missing") + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Class.missing.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":433 + * + * property superclasses: + * def __get__(self): # <<<<<<<<<<<<<< + * cdef size_t i + * # Have we made these into a list? + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Class_12superclasses_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Class_12superclasses_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Class_12superclasses___get__(((struct __pyx_obj_7pybroma_7PyBroma_Class *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Class_12superclasses___get__(struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self) { + size_t __pyx_8genexpr2__pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + std::vector ::size_type __pyx_t_3; + std::vector ::size_type __pyx_t_4; + size_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":436 + * cdef size_t i + * # Have we made these into a list? + * if not self._superclasses_ran: # <<<<<<<<<<<<<< + * self._superclasses = [self._cls.superclasses[i] for i in range(self._cls.superclasses.size())] + * self._superclasses_ran = True + */ + __pyx_t_1 = (!__pyx_v_self->_superclasses_ran); + if (__pyx_t_1) { + + /* "pybroma/PyBroma.pyx":437 + * # Have we made these into a list? + * if not self._superclasses_ran: + * self._superclasses = [self._cls.superclasses[i] for i in range(self._cls.superclasses.size())] # <<<<<<<<<<<<<< + * self._superclasses_ran = True + * return self._superclasses + */ + { /* enter inner scope */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 437, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_v_self->_cls.superclasses.size(); + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_8genexpr2__pyx_v_i = __pyx_t_5; + __pyx_t_6 = __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string((__pyx_v_self->_cls.superclasses[__pyx_8genexpr2__pyx_v_i])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 437, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(0, 437, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } /* exit inner scope */ + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->_superclasses); + __Pyx_DECREF(__pyx_v_self->_superclasses); + __pyx_v_self->_superclasses = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "pybroma/PyBroma.pyx":438 + * if not self._superclasses_ran: + * self._superclasses = [self._cls.superclasses[i] for i in range(self._cls.superclasses.size())] + * self._superclasses_ran = True # <<<<<<<<<<<<<< + * return self._superclasses + * + */ + __pyx_v_self->_superclasses_ran = 1; + + /* "pybroma/PyBroma.pyx":436 + * cdef size_t i + * # Have we made these into a list? + * if not self._superclasses_ran: # <<<<<<<<<<<<<< + * self._superclasses = [self._cls.superclasses[i] for i in range(self._cls.superclasses.size())] + * self._superclasses_ran = True + */ + } + + /* "pybroma/PyBroma.pyx":439 + * self._superclasses = [self._cls.superclasses[i] for i in range(self._cls.superclasses.size())] + * self._superclasses_ran = True + * return self._superclasses # <<<<<<<<<<<<<< + * + * def __set__(self, obj): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_superclasses); + __pyx_r = __pyx_v_self->_superclasses; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":433 + * + * property superclasses: + * def __get__(self): # <<<<<<<<<<<<<< + * cdef size_t i + * # Have we made these into a list? + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pybroma.PyBroma.Class.superclasses.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":441 + * return self._superclasses + * + * def __set__(self, obj): # <<<<<<<<<<<<<< + * raise ImmutableError("superclass") + * + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_5Class_12superclasses_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_obj); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_5Class_12superclasses_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_obj) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Class_12superclasses_2__set__(((struct __pyx_obj_7pybroma_7PyBroma_Class *)__pyx_v_self), ((PyObject *)__pyx_v_obj)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_5Class_12superclasses_2__set__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + + /* "pybroma/PyBroma.pyx":442 + * + * def __set__(self, obj): + * raise ImmutableError("superclass") # <<<<<<<<<<<<<< + * + * property depends: + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_ImmutableError), __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 442, __pyx_L1_error) + + /* "pybroma/PyBroma.pyx":441 + * return self._superclasses + * + * def __set__(self, obj): # <<<<<<<<<<<<<< + * raise ImmutableError("superclass") + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Class.superclasses.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":445 + * + * property depends: + * def __get__(self): # <<<<<<<<<<<<<< + * cdef size_t i + * # Have we made these into a list? + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Class_7depends_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Class_7depends_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Class_7depends___get__(((struct __pyx_obj_7pybroma_7PyBroma_Class *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Class_7depends___get__(struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self) { + size_t __pyx_8genexpr3__pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + std::vector ::size_type __pyx_t_3; + std::vector ::size_type __pyx_t_4; + size_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":448 + * cdef size_t i + * # Have we made these into a list? + * if not self._depends_ran: # <<<<<<<<<<<<<< + * self._depends = [self._cls.depends[i] for i in range(self._cls.depends.size())] + * self._depends_ran = True + */ + __pyx_t_1 = (!__pyx_v_self->_depends_ran); + if (__pyx_t_1) { + + /* "pybroma/PyBroma.pyx":449 + * # Have we made these into a list? + * if not self._depends_ran: + * self._depends = [self._cls.depends[i] for i in range(self._cls.depends.size())] # <<<<<<<<<<<<<< + * self._depends_ran = True + * return self._depends + */ + { /* enter inner scope */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_v_self->_cls.depends.size(); + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_8genexpr3__pyx_v_i = __pyx_t_5; + __pyx_t_6 = __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string((__pyx_v_self->_cls.depends[__pyx_8genexpr3__pyx_v_i])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(0, 449, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } /* exit inner scope */ + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->_depends); + __Pyx_DECREF(__pyx_v_self->_depends); + __pyx_v_self->_depends = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "pybroma/PyBroma.pyx":450 + * if not self._depends_ran: + * self._depends = [self._cls.depends[i] for i in range(self._cls.depends.size())] + * self._depends_ran = True # <<<<<<<<<<<<<< + * return self._depends + * + */ + __pyx_v_self->_depends_ran = 1; + + /* "pybroma/PyBroma.pyx":448 + * cdef size_t i + * # Have we made these into a list? + * if not self._depends_ran: # <<<<<<<<<<<<<< + * self._depends = [self._cls.depends[i] for i in range(self._cls.depends.size())] + * self._depends_ran = True + */ + } + + /* "pybroma/PyBroma.pyx":451 + * self._depends = [self._cls.depends[i] for i in range(self._cls.depends.size())] + * self._depends_ran = True + * return self._depends # <<<<<<<<<<<<<< + * + * def __set__(self, obj): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_depends); + __pyx_r = __pyx_v_self->_depends; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":445 + * + * property depends: + * def __get__(self): # <<<<<<<<<<<<<< + * cdef size_t i + * # Have we made these into a list? + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pybroma.PyBroma.Class.depends.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":453 + * return self._depends + * + * def __set__(self, obj): # <<<<<<<<<<<<<< + * raise ImmutableError("depends") + * + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_5Class_7depends_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_obj); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_5Class_7depends_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_obj) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Class_7depends_2__set__(((struct __pyx_obj_7pybroma_7PyBroma_Class *)__pyx_v_self), ((PyObject *)__pyx_v_obj)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_5Class_7depends_2__set__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + + /* "pybroma/PyBroma.pyx":454 + * + * def __set__(self, obj): + * raise ImmutableError("depends") # <<<<<<<<<<<<<< + * + * property fields: + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_ImmutableError), __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 454, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 454, __pyx_L1_error) + + /* "pybroma/PyBroma.pyx":453 + * return self._depends + * + * def __set__(self, obj): # <<<<<<<<<<<<<< + * raise ImmutableError("depends") + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Class.depends.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":457 + * + * property fields: + * def __get__(self): # <<<<<<<<<<<<<< + * return [make_Field(f) for f in self._cls.fields] + * def __set__(self, obj): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Class_6fields_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Class_6fields_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Class_6fields___get__(((struct __pyx_obj_7pybroma_7PyBroma_Class *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Class_6fields___get__(struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self) { + struct broma::Field __pyx_8genexpr4__pyx_v_f; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + std::vector ::iterator __pyx_t_2; + struct broma::Field __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":458 + * property fields: + * def __get__(self): + * return [make_Field(f) for f in self._cls.fields] # <<<<<<<<<<<<<< + * def __set__(self, obj): + * raise ImmutableError("fields") + */ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 458, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_v_self->_cls.fields.begin(); + for (;;) { + if (!(__pyx_t_2 != __pyx_v_self->_cls.fields.end())) break; + __pyx_t_3 = *__pyx_t_2; + ++__pyx_t_2; + __pyx_8genexpr4__pyx_v_f = __pyx_t_3; + __pyx_t_4 = ((PyObject *)__pyx_f_7pybroma_7PyBroma_make_Field(__pyx_8genexpr4__pyx_v_f)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 458, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(0, 458, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } /* exit inner scope */ + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":457 + * + * property fields: + * def __get__(self): # <<<<<<<<<<<<<< + * return [make_Field(f) for f in self._cls.fields] + * def __set__(self, obj): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pybroma.PyBroma.Class.fields.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":459 + * def __get__(self): + * return [make_Field(f) for f in self._cls.fields] + * def __set__(self, obj): # <<<<<<<<<<<<<< + * raise ImmutableError("fields") + * + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_5Class_6fields_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_obj); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_5Class_6fields_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_obj) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Class_6fields_2__set__(((struct __pyx_obj_7pybroma_7PyBroma_Class *)__pyx_v_self), ((PyObject *)__pyx_v_obj)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_5Class_6fields_2__set__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + + /* "pybroma/PyBroma.pyx":460 + * return [make_Field(f) for f in self._cls.fields] + * def __set__(self, obj): + * raise ImmutableError("fields") # <<<<<<<<<<<<<< + * + * cdef make_Class(broma.Class cls): + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_ImmutableError), __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 460, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 460, __pyx_L1_error) + + /* "pybroma/PyBroma.pyx":459 + * def __get__(self): + * return [make_Field(f) for f in self._cls.fields] + * def __set__(self, obj): # <<<<<<<<<<<<<< + * raise ImmutableError("fields") + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.Class.fields.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Class_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_5Class_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_5Class_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Class_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Class_2__reduce_cython__(((struct __pyx_obj_7pybroma_7PyBroma_Class *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Class_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.Class.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Class_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_5Class_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_5Class_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_5Class_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pybroma.PyBroma.Class.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_5Class_4__setstate_cython__(((struct __pyx_obj_7pybroma_7PyBroma_Class *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_5Class_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.Class.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":462 + * raise ImmutableError("fields") + * + * cdef make_Class(broma.Class cls): # <<<<<<<<<<<<<< + * cdef Class _cls = Class() + * _cls._cls = cls + */ + +static PyObject *__pyx_f_7pybroma_7PyBroma_make_Class(struct broma::Class __pyx_v_cls) { + struct __pyx_obj_7pybroma_7PyBroma_Class *__pyx_v__cls = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("make_Class", 1); + + /* "pybroma/PyBroma.pyx":463 + * + * cdef make_Class(broma.Class cls): + * cdef Class _cls = Class() # <<<<<<<<<<<<<< + * _cls._cls = cls + * return _cls + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_Class)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 463, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__cls = ((struct __pyx_obj_7pybroma_7PyBroma_Class *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "pybroma/PyBroma.pyx":464 + * cdef make_Class(broma.Class cls): + * cdef Class _cls = Class() + * _cls._cls = cls # <<<<<<<<<<<<<< + * return _cls + * + */ + __pyx_v__cls->_cls = __pyx_v_cls; + + /* "pybroma/PyBroma.pyx":465 + * cdef Class _cls = Class() + * _cls._cls = cls + * return _cls # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v__cls); + __pyx_r = ((PyObject *)__pyx_v__cls); + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":462 + * raise ImmutableError("fields") + * + * cdef make_Class(broma.Class cls): # <<<<<<<<<<<<<< + * cdef Class _cls = Class() + * _cls._cls = cls + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pybroma.PyBroma.make_Class", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v__cls); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":472 + * broma.Root root + * + * def __init__(self, str fileName): # <<<<<<<<<<<<<< + * self.root = broma.parse_file(fileName) + * + */ + +/* Python wrapper */ +static int __pyx_pw_7pybroma_7PyBroma_4Root_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_7pybroma_7PyBroma_4Root_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_fileName = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fileName,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fileName)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 472, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 472, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + } + __pyx_v_fileName = ((PyObject*)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 472, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pybroma.PyBroma.Root.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_fileName), (&PyUnicode_Type), 1, "fileName", 1))) __PYX_ERR(0, 472, __pyx_L1_error) + __pyx_r = __pyx_pf_7pybroma_7PyBroma_4Root___init__(((struct __pyx_obj_7pybroma_7PyBroma_Root *)__pyx_v_self), __pyx_v_fileName); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_7pybroma_7PyBroma_4Root___init__(struct __pyx_obj_7pybroma_7PyBroma_Root *__pyx_v_self, PyObject *__pyx_v_fileName) { + int __pyx_r; + std::string __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "pybroma/PyBroma.pyx":473 + * + * def __init__(self, str fileName): + * self.root = broma.parse_file(fileName) # <<<<<<<<<<<<<< + * + * def __getitem__(self, str _class_name_): + */ + __pyx_t_1 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_v_fileName); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 473, __pyx_L1_error) + __pyx_v_self->root = broma::parse_file(((std::string)__pyx_t_1)); + + /* "pybroma/PyBroma.pyx":472 + * broma.Root root + * + * def __init__(self, str fileName): # <<<<<<<<<<<<<< + * self.root = broma.parse_file(fileName) + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.Root.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":475 + * self.root = broma.parse_file(fileName) + * + * def __getitem__(self, str _class_name_): # <<<<<<<<<<<<<< + * cdef Class c + * cdef broma.Class* _class_ = broma.RootgetClassFromStr(&self.root, _class_name_) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Root_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v__class_name_); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Root_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v__class_name_) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v__class_name_), (&PyUnicode_Type), 1, "_class_name_", 1))) __PYX_ERR(0, 475, __pyx_L1_error) + __pyx_r = __pyx_pf_7pybroma_7PyBroma_4Root_2__getitem__(((struct __pyx_obj_7pybroma_7PyBroma_Root *)__pyx_v_self), ((PyObject*)__pyx_v__class_name_)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Root_2__getitem__(struct __pyx_obj_7pybroma_7PyBroma_Root *__pyx_v_self, PyObject *__pyx_v__class_name_) { + struct broma::Class *__pyx_v__class_; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + std::string __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 1); + + /* "pybroma/PyBroma.pyx":477 + * def __getitem__(self, str _class_name_): + * cdef Class c + * cdef broma.Class* _class_ = broma.RootgetClassFromStr(&self.root, _class_name_) # <<<<<<<<<<<<<< + * if _class_ == NULL: + * return None + */ + __pyx_t_1 = __pyx_convert_string_from_py_6libcpp_6string_std__in_string(__pyx_v__class_name_); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 477, __pyx_L1_error) + __pyx_v__class_ = RootgetClassFromStr((&__pyx_v_self->root), ((std::string)__pyx_t_1)); + + /* "pybroma/PyBroma.pyx":478 + * cdef Class c + * cdef broma.Class* _class_ = broma.RootgetClassFromStr(&self.root, _class_name_) + * if _class_ == NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + __pyx_t_2 = (__pyx_v__class_ == NULL); + if (__pyx_t_2) { + + /* "pybroma/PyBroma.pyx":479 + * cdef broma.Class* _class_ = broma.RootgetClassFromStr(&self.root, _class_name_) + * if _class_ == NULL: + * return None # <<<<<<<<<<<<<< + * else: + * return make_Class(DEPACK(_class_)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":478 + * cdef Class c + * cdef broma.Class* _class_ = broma.RootgetClassFromStr(&self.root, _class_name_) + * if _class_ == NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + } + + /* "pybroma/PyBroma.pyx":481 + * return None + * else: + * return make_Class(DEPACK(_class_)) # <<<<<<<<<<<<<< + * + * @property + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __pyx_f_7pybroma_7PyBroma_make_Class(DEPACK(__pyx_v__class_)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "pybroma/PyBroma.pyx":475 + * self.root = broma.parse_file(fileName) + * + * def __getitem__(self, str _class_name_): # <<<<<<<<<<<<<< + * cdef Class c + * cdef broma.Class* _class_ = broma.RootgetClassFromStr(&self.root, _class_name_) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pybroma.PyBroma.Root.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":492 + * + * + * @property # <<<<<<<<<<<<<< + * def functions(self): + * return [make_Function(x) for x in self.root.functions] + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Root_9functions_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Root_9functions_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_4Root_9functions___get__(((struct __pyx_obj_7pybroma_7PyBroma_Root *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Root_9functions___get__(struct __pyx_obj_7pybroma_7PyBroma_Root *__pyx_v_self) { + struct broma::Function __pyx_8genexpr5__pyx_v_x; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + std::vector ::iterator __pyx_t_2; + struct broma::Function __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":494 + * @property + * def functions(self): + * return [make_Function(x) for x in self.root.functions] # <<<<<<<<<<<<<< + * + * def functionsAsDict(self) -> dict: + */ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_v_self->root.functions.begin(); + for (;;) { + if (!(__pyx_t_2 != __pyx_v_self->root.functions.end())) break; + __pyx_t_3 = *__pyx_t_2; + ++__pyx_t_2; + __pyx_8genexpr5__pyx_v_x = __pyx_t_3; + __pyx_t_4 = ((PyObject *)__pyx_f_7pybroma_7PyBroma_make_Function(__pyx_8genexpr5__pyx_v_x)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(0, 494, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } /* exit inner scope */ + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":492 + * + * + * @property # <<<<<<<<<<<<<< + * def functions(self): + * return [make_Function(x) for x in self.root.functions] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pybroma.PyBroma.Root.functions.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":487 + * return [make_Function(x) for x in self.root.functions] + * + * @property # <<<<<<<<<<<<<< + * def classes(self): + * return [make_Class(x) for x in self.root.classes] + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Root_7classes_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Root_7classes_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_7pybroma_7PyBroma_4Root_7classes___get__(((struct __pyx_obj_7pybroma_7PyBroma_Root *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Root_7classes___get__(struct __pyx_obj_7pybroma_7PyBroma_Root *__pyx_v_self) { + struct broma::Class __pyx_8genexpr6__pyx_v_x; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + std::vector ::iterator __pyx_t_2; + struct broma::Class __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "pybroma/PyBroma.pyx":489 + * @property + * def classes(self): + * return [make_Class(x) for x in self.root.classes] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_v_self->root.classes.begin(); + for (;;) { + if (!(__pyx_t_2 != __pyx_v_self->root.classes.end())) break; + __pyx_t_3 = *__pyx_t_2; + ++__pyx_t_2; + __pyx_8genexpr6__pyx_v_x = __pyx_t_3; + __pyx_t_4 = __pyx_f_7pybroma_7PyBroma_make_Class(__pyx_8genexpr6__pyx_v_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } /* exit inner scope */ + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":487 + * return [make_Function(x) for x in self.root.functions] + * + * @property # <<<<<<<<<<<<<< + * def classes(self): + * return [make_Class(x) for x in self.root.classes] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pybroma.PyBroma.Root.classes.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":496 + * return [make_Function(x) for x in self.root.functions] + * + * def functionsAsDict(self) -> dict: # <<<<<<<<<<<<<< + * """Converts Functions to A Dictionary""" + * return {c.prototype.name: make_Function(c) for c in self.root.functions} + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Root_5functionsAsDict(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_7pybroma_7PyBroma_4Root_4functionsAsDict, "Converts Functions to A Dictionary"); +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_4Root_5functionsAsDict = {"functionsAsDict", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_4Root_5functionsAsDict, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7pybroma_7PyBroma_4Root_4functionsAsDict}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Root_5functionsAsDict(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("functionsAsDict (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("functionsAsDict", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "functionsAsDict", 0))) return NULL; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_4Root_4functionsAsDict(((struct __pyx_obj_7pybroma_7PyBroma_Root *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Root_4functionsAsDict(struct __pyx_obj_7pybroma_7PyBroma_Root *__pyx_v_self) { + struct broma::Function __pyx_8genexpr7__pyx_v_c; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + std::vector ::iterator __pyx_t_2; + struct broma::Function __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("functionsAsDict", 1); + + /* "pybroma/PyBroma.pyx":498 + * def functionsAsDict(self) -> dict: + * """Converts Functions to A Dictionary""" + * return {c.prototype.name: make_Function(c) for c in self.root.functions} # <<<<<<<<<<<<<< + * + * def classesAsDict(self) -> dict: + */ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 498, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_v_self->root.functions.begin(); + for (;;) { + if (!(__pyx_t_2 != __pyx_v_self->root.functions.end())) break; + __pyx_t_3 = *__pyx_t_2; + ++__pyx_t_2; + __pyx_8genexpr7__pyx_v_c = __pyx_t_3; + __pyx_t_4 = __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(__pyx_8genexpr7__pyx_v_c.prototype.name); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 498, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = ((PyObject *)__pyx_f_7pybroma_7PyBroma_make_Function(__pyx_8genexpr7__pyx_v_c)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 498, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)((PyObject*)__pyx_t_4), (PyObject*)__pyx_t_5))) __PYX_ERR(0, 498, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } /* exit inner scope */ + __pyx_r = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":496 + * return [make_Function(x) for x in self.root.functions] + * + * def functionsAsDict(self) -> dict: # <<<<<<<<<<<<<< + * """Converts Functions to A Dictionary""" + * return {c.prototype.name: make_Function(c) for c in self.root.functions} + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pybroma.PyBroma.Root.functionsAsDict", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pybroma/PyBroma.pyx":500 + * return {c.prototype.name: make_Function(c) for c in self.root.functions} + * + * def classesAsDict(self) -> dict: # <<<<<<<<<<<<<< + * """Converts Classes to a dictionary""" + * return {c.name:make_Class(c) for c in self.root.classes} + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Root_7classesAsDict(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_7pybroma_7PyBroma_4Root_6classesAsDict, "Converts Classes to a dictionary"); +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_4Root_7classesAsDict = {"classesAsDict", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_4Root_7classesAsDict, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7pybroma_7PyBroma_4Root_6classesAsDict}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Root_7classesAsDict(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("classesAsDict (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("classesAsDict", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "classesAsDict", 0))) return NULL; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_4Root_6classesAsDict(((struct __pyx_obj_7pybroma_7PyBroma_Root *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Root_6classesAsDict(struct __pyx_obj_7pybroma_7PyBroma_Root *__pyx_v_self) { + struct broma::Class __pyx_8genexpr8__pyx_v_c; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + std::vector ::iterator __pyx_t_2; + struct broma::Class __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("classesAsDict", 1); + + /* "pybroma/PyBroma.pyx":502 + * def classesAsDict(self) -> dict: + * """Converts Classes to a dictionary""" + * return {c.name:make_Class(c) for c in self.root.classes} # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 502, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_v_self->root.classes.begin(); + for (;;) { + if (!(__pyx_t_2 != __pyx_v_self->root.classes.end())) break; + __pyx_t_3 = *__pyx_t_2; + ++__pyx_t_2; + __pyx_8genexpr8__pyx_v_c = __pyx_t_3; + __pyx_t_4 = __pyx_convert_PyUnicode_string_to_py_6libcpp_6string_std__in_string(__pyx_8genexpr8__pyx_v_c.name); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 502, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __pyx_f_7pybroma_7PyBroma_make_Class(__pyx_8genexpr8__pyx_v_c); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 502, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)((PyObject*)__pyx_t_4), (PyObject*)__pyx_t_5))) __PYX_ERR(0, 502, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } /* exit inner scope */ + __pyx_r = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "pybroma/PyBroma.pyx":500 + * return {c.prototype.name: make_Function(c) for c in self.root.functions} + * + * def classesAsDict(self) -> dict: # <<<<<<<<<<<<<< + * """Converts Classes to a dictionary""" + * return {c.name:make_Class(c) for c in self.root.classes} + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pybroma.PyBroma.Root.classesAsDict", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self.root must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Root_9__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_4Root_9__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_4Root_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Root_9__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_4Root_8__reduce_cython__(((struct __pyx_obj_7pybroma_7PyBroma_Root *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Root_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Root *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "Pickling of struct members such as self.root must be explicitly requested with @auto_pickle(True)" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "Pickling of struct members such as self.root must be explicitly requested with @auto_pickle(True)" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_Pickling_of_struct_members_such_2, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self.root must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.Root.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "Pickling of struct members such as self.root must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self.root must be explicitly requested with @auto_pickle(True)" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Root_11__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_4Root_11__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_4Root_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_4Root_11__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pybroma.PyBroma.Root.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7pybroma_7PyBroma_4Root_10__setstate_cython__(((struct __pyx_obj_7pybroma_7PyBroma_Root *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma_4Root_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pybroma_7PyBroma_Root *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "Pickling of struct members such as self.root must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "Pickling of struct members such as self.root must be explicitly requested with @auto_pickle(True)" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_Pickling_of_struct_members_such_2, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "Pickling of struct members such as self.root must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self.root must be explicitly requested with @auto_pickle(True)" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pybroma.PyBroma.Root.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_ImmutableError(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7pybroma_7PyBroma_1__pyx_unpickle_ImmutableError(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_7pybroma_7PyBroma_1__pyx_unpickle_ImmutableError = {"__pyx_unpickle_ImmutableError", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_1__pyx_unpickle_ImmutableError, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_7pybroma_7PyBroma_1__pyx_unpickle_ImmutableError(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_ImmutableError (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_ImmutableError", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_ImmutableError", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_ImmutableError") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_ImmutableError", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pybroma.PyBroma.__pyx_unpickle_ImmutableError", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7pybroma_7PyBroma___pyx_unpickle_ImmutableError(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7pybroma_7PyBroma___pyx_unpickle_ImmutableError(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_ImmutableError", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__11, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = ImmutableError.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = ImmutableError.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = ImmutableError.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_ImmutableError__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_7pybroma_7PyBroma_ImmutableError), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = ImmutableError.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_ImmutableError__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = ImmutableError.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_ImmutableError__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_ImmutableError__set_state(ImmutableError __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_7pybroma_7PyBroma___pyx_unpickle_ImmutableError__set_state(((struct __pyx_obj_7pybroma_7PyBroma_ImmutableError *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = ImmutableError.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_ImmutableError__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_ImmutableError__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_ImmutableError__set_state(ImmutableError __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_ImmutableError(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pybroma.PyBroma.__pyx_unpickle_ImmutableError", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_ImmutableError__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_ImmutableError__set_state(ImmutableError __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + +static PyObject *__pyx_f_7pybroma_7PyBroma___pyx_unpickle_ImmutableError__set_state(struct __pyx_obj_7pybroma_7PyBroma_ImmutableError *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_ImmutableError__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_ImmutableError__set_state(ImmutableError __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 12, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 > 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 12, __pyx_L1_error) + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_ImmutableError__set_state(ImmutableError __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 13, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_ImmutableError__set_state(ImmutableError __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_ImmutableError__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_ImmutableError__set_state(ImmutableError __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pybroma.PyBroma.__pyx_unpickle_ImmutableError__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_tp_traverse_7pybroma_7PyBroma_ImmutableError(PyObject *o, visitproc v, void *a) { + int e; + if (!(&((PyTypeObject*)PyExc_Exception)[0])->tp_traverse); else { e = (&((PyTypeObject*)PyExc_Exception)[0])->tp_traverse(o,v,a); if (e) return e; } + return 0; +} + +static int __pyx_tp_clear_7pybroma_7PyBroma_ImmutableError(PyObject *o) { + if (!(&((PyTypeObject*)PyExc_Exception)[0])->tp_clear); else (&((PyTypeObject*)PyExc_Exception)[0])->tp_clear(o); + return 0; +} + +static PyMethodDef __pyx_methods_7pybroma_7PyBroma_ImmutableError[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_14ImmutableError_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_14ImmutableError_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_7pybroma_7PyBroma_ImmutableError_slots[] = { + {Py_tp_doc, (void *)PyDoc_STR("Object is an immutable property and cannot mutate")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_7pybroma_7PyBroma_ImmutableError}, + {Py_tp_clear, (void *)__pyx_tp_clear_7pybroma_7PyBroma_ImmutableError}, + {Py_tp_methods, (void *)__pyx_methods_7pybroma_7PyBroma_ImmutableError}, + {Py_tp_init, (void *)__pyx_pw_7pybroma_7PyBroma_14ImmutableError_1__init__}, + {0, 0}, +}; +static PyType_Spec __pyx_type_7pybroma_7PyBroma_ImmutableError_spec = { + "pybroma.PyBroma.ImmutableError", + sizeof(struct __pyx_obj_7pybroma_7PyBroma_ImmutableError), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, + __pyx_type_7pybroma_7PyBroma_ImmutableError_slots, +}; +#else + +static PyTypeObject __pyx_type_7pybroma_7PyBroma_ImmutableError = { + PyVarObject_HEAD_INIT(0, 0) + "pybroma.PyBroma.""ImmutableError", /*tp_name*/ + sizeof(struct __pyx_obj_7pybroma_7PyBroma_ImmutableError), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + 0, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ + PyDoc_STR("Object is an immutable property and cannot mutate"), /*tp_doc*/ + __pyx_tp_traverse_7pybroma_7PyBroma_ImmutableError, /*tp_traverse*/ + __pyx_tp_clear_7pybroma_7PyBroma_ImmutableError, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7pybroma_7PyBroma_ImmutableError, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_7pybroma_7PyBroma_14ImmutableError_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + 0, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_Type(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_7pybroma_7PyBroma_Type *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_7pybroma_7PyBroma_Type *)o); + new((void*)&(p->type)) struct broma::Type(); + if (unlikely(__pyx_pw_7pybroma_7PyBroma_4Type_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_7pybroma_7PyBroma_Type(PyObject *o) { + struct __pyx_obj_7pybroma_7PyBroma_Type *p = (struct __pyx_obj_7pybroma_7PyBroma_Type *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7pybroma_7PyBroma_Type) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + __Pyx_call_destructor(p->type); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyObject *__pyx_tp_richcompare_7pybroma_7PyBroma_Type(PyObject *o1, PyObject *o2, int op) { + switch (op) { + case Py_EQ: { + return __pyx_pw_7pybroma_7PyBroma_4Type_3__eq__(o1, o2); + } + case Py_NE: { + PyObject *ret; + ret = __pyx_pw_7pybroma_7PyBroma_4Type_3__eq__(o1, o2); + if (likely(ret && ret != Py_NotImplemented)) { + int b = __Pyx_PyObject_IsTrue(ret); + Py_DECREF(ret); + if (unlikely(b < 0)) return NULL; + ret = (b) ? Py_False : Py_True; + Py_INCREF(ret); + } + return ret; + } + default: { + return __Pyx_NewRef(Py_NotImplemented); + } + } +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_4Type_name(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_4Type_4name_1__get__(o); +} + +static int __pyx_setprop_7pybroma_7PyBroma_4Type_name(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_7pybroma_7PyBroma_4Type_4name_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_4Type_is_struct(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_4Type_9is_struct_1__get__(o); +} + +static PyMethodDef __pyx_methods_7pybroma_7PyBroma_Type[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_4Type_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_4Type_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_7pybroma_7PyBroma_Type[] = { + {(char *)"name", __pyx_getprop_7pybroma_7PyBroma_4Type_name, __pyx_setprop_7pybroma_7PyBroma_4Type_name, (char *)0, 0}, + {(char *)"is_struct", __pyx_getprop_7pybroma_7PyBroma_4Type_is_struct, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_7pybroma_7PyBroma_Type_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7pybroma_7PyBroma_Type}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_7pybroma_7PyBroma_Type}, + {Py_tp_methods, (void *)__pyx_methods_7pybroma_7PyBroma_Type}, + {Py_tp_getset, (void *)__pyx_getsets_7pybroma_7PyBroma_Type}, + {Py_tp_new, (void *)__pyx_tp_new_7pybroma_7PyBroma_Type}, + {0, 0}, +}; +static PyType_Spec __pyx_type_7pybroma_7PyBroma_Type_spec = { + "pybroma.PyBroma.Type", + sizeof(struct __pyx_obj_7pybroma_7PyBroma_Type), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_7pybroma_7PyBroma_Type_slots, +}; +#else + +static PyTypeObject __pyx_type_7pybroma_7PyBroma_Type = { + PyVarObject_HEAD_INIT(0, 0) + "pybroma.PyBroma.""Type", /*tp_name*/ + sizeof(struct __pyx_obj_7pybroma_7PyBroma_Type), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7pybroma_7PyBroma_Type, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + __pyx_tp_richcompare_7pybroma_7PyBroma_Type, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7pybroma_7PyBroma_Type, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_7pybroma_7PyBroma_Type, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7pybroma_7PyBroma_Type, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_7pybroma_7PyBroma_MemberFunctionProto __pyx_vtable_7pybroma_7PyBroma_MemberFunctionProto; + +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_MemberFunctionProto(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *)o); + p->__pyx_vtab = __pyx_vtabptr_7pybroma_7PyBroma_MemberFunctionProto; + new((void*)&(p->proto)) struct broma::MemberFunctionProto(); + p->_args = ((PyObject*)Py_None); Py_INCREF(Py_None); + if (unlikely(__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_7pybroma_7PyBroma_MemberFunctionProto(PyObject *o) { + struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *p = (struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7pybroma_7PyBroma_MemberFunctionProto) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + __Pyx_call_destructor(p->proto); + Py_CLEAR(p->_args); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_7pybroma_7PyBroma_MemberFunctionProto(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *p = (struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *)o; + if (p->_args) { + e = (*v)(p->_args, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_7pybroma_7PyBroma_MemberFunctionProto(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *p = (struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *)o; + tmp = ((PyObject*)p->_args); + p->_args = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_tp_richcompare_7pybroma_7PyBroma_MemberFunctionProto(PyObject *o1, PyObject *o2, int op) { + switch (op) { + case Py_EQ: { + return __pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_3__eq__(o1, o2); + } + case Py_NE: { + PyObject *ret; + ret = __pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_3__eq__(o1, o2); + if (likely(ret && ret != Py_NotImplemented)) { + int b = __Pyx_PyObject_IsTrue(ret); + Py_DECREF(ret); + if (unlikely(b < 0)) return NULL; + ret = (b) ? Py_False : Py_True; + Py_INCREF(ret); + } + return ret; + } + default: { + return __Pyx_NewRef(Py_NotImplemented); + } + } +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_19MemberFunctionProto_args(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_4args_1__get__(o); +} + +static int __pyx_setprop_7pybroma_7PyBroma_19MemberFunctionProto_args(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_4args_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_19MemberFunctionProto_ret(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_3ret_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_19MemberFunctionProto_is_const(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_8is_const_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_19MemberFunctionProto_is_virtual(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_10is_virtual_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_19MemberFunctionProto_is_callback(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_11is_callback_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_19MemberFunctionProto_is_static(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_9is_static_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_19MemberFunctionProto_type(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_4type_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_19MemberFunctionProto_docs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_4docs_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_19MemberFunctionProto_name(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_4name_1__get__(o); +} + +static PyMethodDef __pyx_methods_7pybroma_7PyBroma_MemberFunctionProto[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_19MemberFunctionProto_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_7pybroma_7PyBroma_MemberFunctionProto[] = { + {(char *)"args", __pyx_getprop_7pybroma_7PyBroma_19MemberFunctionProto_args, __pyx_setprop_7pybroma_7PyBroma_19MemberFunctionProto_args, (char *)0, 0}, + {(char *)"ret", __pyx_getprop_7pybroma_7PyBroma_19MemberFunctionProto_ret, 0, (char *)0, 0}, + {(char *)"is_const", __pyx_getprop_7pybroma_7PyBroma_19MemberFunctionProto_is_const, 0, (char *)0, 0}, + {(char *)"is_virtual", __pyx_getprop_7pybroma_7PyBroma_19MemberFunctionProto_is_virtual, 0, (char *)0, 0}, + {(char *)"is_callback", __pyx_getprop_7pybroma_7PyBroma_19MemberFunctionProto_is_callback, 0, (char *)0, 0}, + {(char *)"is_static", __pyx_getprop_7pybroma_7PyBroma_19MemberFunctionProto_is_static, 0, (char *)0, 0}, + {(char *)"type", __pyx_getprop_7pybroma_7PyBroma_19MemberFunctionProto_type, 0, (char *)0, 0}, + {(char *)"docs", __pyx_getprop_7pybroma_7PyBroma_19MemberFunctionProto_docs, 0, (char *)0, 0}, + {(char *)"name", __pyx_getprop_7pybroma_7PyBroma_19MemberFunctionProto_name, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_7pybroma_7PyBroma_MemberFunctionProto_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7pybroma_7PyBroma_MemberFunctionProto}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_7pybroma_7PyBroma_MemberFunctionProto}, + {Py_tp_clear, (void *)__pyx_tp_clear_7pybroma_7PyBroma_MemberFunctionProto}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_7pybroma_7PyBroma_MemberFunctionProto}, + {Py_tp_methods, (void *)__pyx_methods_7pybroma_7PyBroma_MemberFunctionProto}, + {Py_tp_getset, (void *)__pyx_getsets_7pybroma_7PyBroma_MemberFunctionProto}, + {Py_tp_new, (void *)__pyx_tp_new_7pybroma_7PyBroma_MemberFunctionProto}, + {0, 0}, +}; +static PyType_Spec __pyx_type_7pybroma_7PyBroma_MemberFunctionProto_spec = { + "pybroma.PyBroma.MemberFunctionProto", + sizeof(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_7pybroma_7PyBroma_MemberFunctionProto_slots, +}; +#else + +static PyTypeObject __pyx_type_7pybroma_7PyBroma_MemberFunctionProto = { + PyVarObject_HEAD_INIT(0, 0) + "pybroma.PyBroma.""MemberFunctionProto", /*tp_name*/ + sizeof(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7pybroma_7PyBroma_MemberFunctionProto, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7pybroma_7PyBroma_MemberFunctionProto, /*tp_traverse*/ + __pyx_tp_clear_7pybroma_7PyBroma_MemberFunctionProto, /*tp_clear*/ + __pyx_tp_richcompare_7pybroma_7PyBroma_MemberFunctionProto, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7pybroma_7PyBroma_MemberFunctionProto, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_7pybroma_7PyBroma_MemberFunctionProto, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7pybroma_7PyBroma_MemberFunctionProto, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_MemberField(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_7pybroma_7PyBroma_MemberField *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_7pybroma_7PyBroma_MemberField *)o); + new((void*)&(p->field)) struct broma::MemberField(); + if (unlikely(__pyx_pw_7pybroma_7PyBroma_11MemberField_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_7pybroma_7PyBroma_MemberField(PyObject *o) { + struct __pyx_obj_7pybroma_7PyBroma_MemberField *p = (struct __pyx_obj_7pybroma_7PyBroma_MemberField *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7pybroma_7PyBroma_MemberField) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + __Pyx_call_destructor(p->field); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_11MemberField_name(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_11MemberField_4name_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_11MemberField_type(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_11MemberField_4type_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_11MemberField_count(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_11MemberField_5count_1__get__(o); +} + +static PyMethodDef __pyx_methods_7pybroma_7PyBroma_MemberField[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_11MemberField_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_11MemberField_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_7pybroma_7PyBroma_MemberField[] = { + {(char *)"name", __pyx_getprop_7pybroma_7PyBroma_11MemberField_name, 0, (char *)0, 0}, + {(char *)"type", __pyx_getprop_7pybroma_7PyBroma_11MemberField_type, 0, (char *)0, 0}, + {(char *)"count", __pyx_getprop_7pybroma_7PyBroma_11MemberField_count, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_7pybroma_7PyBroma_MemberField_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7pybroma_7PyBroma_MemberField}, + {Py_tp_methods, (void *)__pyx_methods_7pybroma_7PyBroma_MemberField}, + {Py_tp_getset, (void *)__pyx_getsets_7pybroma_7PyBroma_MemberField}, + {Py_tp_new, (void *)__pyx_tp_new_7pybroma_7PyBroma_MemberField}, + {0, 0}, +}; +static PyType_Spec __pyx_type_7pybroma_7PyBroma_MemberField_spec = { + "pybroma.PyBroma.MemberField", + sizeof(struct __pyx_obj_7pybroma_7PyBroma_MemberField), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_7pybroma_7PyBroma_MemberField_slots, +}; +#else + +static PyTypeObject __pyx_type_7pybroma_7PyBroma_MemberField = { + PyVarObject_HEAD_INIT(0, 0) + "pybroma.PyBroma.""MemberField", /*tp_name*/ + sizeof(struct __pyx_obj_7pybroma_7PyBroma_MemberField), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7pybroma_7PyBroma_MemberField, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7pybroma_7PyBroma_MemberField, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_7pybroma_7PyBroma_MemberField, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7pybroma_7PyBroma_MemberField, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_OutOfLineField(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *)o); + new((void*)&(p->oolf)) struct broma::OutOfLineField(); + if (unlikely(__pyx_pw_7pybroma_7PyBroma_14OutOfLineField_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_7pybroma_7PyBroma_OutOfLineField(PyObject *o) { + struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *p = (struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7pybroma_7PyBroma_OutOfLineField) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + __Pyx_call_destructor(p->oolf); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_14OutOfLineField_prototype(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_14OutOfLineField_9prototype_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_14OutOfLineField_inner(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_14OutOfLineField_5inner_1__get__(o); +} + +static PyMethodDef __pyx_methods_7pybroma_7PyBroma_OutOfLineField[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_14OutOfLineField_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_14OutOfLineField_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_7pybroma_7PyBroma_OutOfLineField[] = { + {(char *)"prototype", __pyx_getprop_7pybroma_7PyBroma_14OutOfLineField_prototype, 0, (char *)0, 0}, + {(char *)"inner", __pyx_getprop_7pybroma_7PyBroma_14OutOfLineField_inner, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_7pybroma_7PyBroma_OutOfLineField_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7pybroma_7PyBroma_OutOfLineField}, + {Py_tp_methods, (void *)__pyx_methods_7pybroma_7PyBroma_OutOfLineField}, + {Py_tp_getset, (void *)__pyx_getsets_7pybroma_7PyBroma_OutOfLineField}, + {Py_tp_new, (void *)__pyx_tp_new_7pybroma_7PyBroma_OutOfLineField}, + {0, 0}, +}; +static PyType_Spec __pyx_type_7pybroma_7PyBroma_OutOfLineField_spec = { + "pybroma.PyBroma.OutOfLineField", + sizeof(struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_7pybroma_7PyBroma_OutOfLineField_slots, +}; +#else + +static PyTypeObject __pyx_type_7pybroma_7PyBroma_OutOfLineField = { + PyVarObject_HEAD_INIT(0, 0) + "pybroma.PyBroma.""OutOfLineField", /*tp_name*/ + sizeof(struct __pyx_obj_7pybroma_7PyBroma_OutOfLineField), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7pybroma_7PyBroma_OutOfLineField, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7pybroma_7PyBroma_OutOfLineField, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_7pybroma_7PyBroma_OutOfLineField, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7pybroma_7PyBroma_OutOfLineField, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_FunctionBindField(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *)o); + new((void*)&(p->fbf)) struct broma::FunctionBindField(); + if (unlikely(__pyx_pw_7pybroma_7PyBroma_17FunctionBindField_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_7pybroma_7PyBroma_FunctionBindField(PyObject *o) { + struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *p = (struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7pybroma_7PyBroma_FunctionBindField) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + __Pyx_call_destructor(p->fbf); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_17FunctionBindField_prototype(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_17FunctionBindField_9prototype_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_17FunctionBindField_binds(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_17FunctionBindField_5binds_1__get__(o); +} + +static PyMethodDef __pyx_methods_7pybroma_7PyBroma_FunctionBindField[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_17FunctionBindField_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_17FunctionBindField_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_7pybroma_7PyBroma_FunctionBindField[] = { + {(char *)"prototype", __pyx_getprop_7pybroma_7PyBroma_17FunctionBindField_prototype, 0, (char *)0, 0}, + {(char *)"binds", __pyx_getprop_7pybroma_7PyBroma_17FunctionBindField_binds, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_7pybroma_7PyBroma_FunctionBindField_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7pybroma_7PyBroma_FunctionBindField}, + {Py_tp_methods, (void *)__pyx_methods_7pybroma_7PyBroma_FunctionBindField}, + {Py_tp_getset, (void *)__pyx_getsets_7pybroma_7PyBroma_FunctionBindField}, + {Py_tp_new, (void *)__pyx_tp_new_7pybroma_7PyBroma_FunctionBindField}, + {0, 0}, +}; +static PyType_Spec __pyx_type_7pybroma_7PyBroma_FunctionBindField_spec = { + "pybroma.PyBroma.FunctionBindField", + sizeof(struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_7pybroma_7PyBroma_FunctionBindField_slots, +}; +#else + +static PyTypeObject __pyx_type_7pybroma_7PyBroma_FunctionBindField = { + PyVarObject_HEAD_INIT(0, 0) + "pybroma.PyBroma.""FunctionBindField", /*tp_name*/ + sizeof(struct __pyx_obj_7pybroma_7PyBroma_FunctionBindField), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7pybroma_7PyBroma_FunctionBindField, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7pybroma_7PyBroma_FunctionBindField, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_7pybroma_7PyBroma_FunctionBindField, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7pybroma_7PyBroma_FunctionBindField, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_PadField(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_7pybroma_7PyBroma_PadField *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_7pybroma_7PyBroma_PadField *)o); + new((void*)&(p->pf)) struct broma::PadField(); + if (unlikely(__pyx_pw_7pybroma_7PyBroma_8PadField_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_7pybroma_7PyBroma_PadField(PyObject *o) { + struct __pyx_obj_7pybroma_7PyBroma_PadField *p = (struct __pyx_obj_7pybroma_7PyBroma_PadField *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7pybroma_7PyBroma_PadField) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + __Pyx_call_destructor(p->pf); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_8PadField_amount(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_8PadField_6amount_1__get__(o); +} + +static PyMethodDef __pyx_methods_7pybroma_7PyBroma_PadField[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_8PadField_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_8PadField_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_7pybroma_7PyBroma_PadField[] = { + {(char *)"amount", __pyx_getprop_7pybroma_7PyBroma_8PadField_amount, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_7pybroma_7PyBroma_PadField_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7pybroma_7PyBroma_PadField}, + {Py_tp_methods, (void *)__pyx_methods_7pybroma_7PyBroma_PadField}, + {Py_tp_getset, (void *)__pyx_getsets_7pybroma_7PyBroma_PadField}, + {Py_tp_new, (void *)__pyx_tp_new_7pybroma_7PyBroma_PadField}, + {0, 0}, +}; +static PyType_Spec __pyx_type_7pybroma_7PyBroma_PadField_spec = { + "pybroma.PyBroma.PadField", + sizeof(struct __pyx_obj_7pybroma_7PyBroma_PadField), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_7pybroma_7PyBroma_PadField_slots, +}; +#else + +static PyTypeObject __pyx_type_7pybroma_7PyBroma_PadField = { + PyVarObject_HEAD_INIT(0, 0) + "pybroma.PyBroma.""PadField", /*tp_name*/ + sizeof(struct __pyx_obj_7pybroma_7PyBroma_PadField), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7pybroma_7PyBroma_PadField, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7pybroma_7PyBroma_PadField, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_7pybroma_7PyBroma_PadField, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7pybroma_7PyBroma_PadField, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_Field(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_7pybroma_7PyBroma_Field *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_7pybroma_7PyBroma_Field *)o); + new((void*)&(p->field)) struct broma::Field(); + if (unlikely(__pyx_pw_7pybroma_7PyBroma_5Field_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_7pybroma_7PyBroma_Field(PyObject *o) { + struct __pyx_obj_7pybroma_7PyBroma_Field *p = (struct __pyx_obj_7pybroma_7PyBroma_Field *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7pybroma_7PyBroma_Field) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + __Pyx_call_destructor(p->field); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_5Field_id(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_5Field_2id_1__get__(o); +} + +static int __pyx_setprop_7pybroma_7PyBroma_5Field_id(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_7pybroma_7PyBroma_5Field_2id_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_5Field_parent(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_5Field_6parent_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_5Field_missing(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_5Field_7missing_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_5Field_links(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_5Field_5links_1__get__(o); +} + +static PyMethodDef __pyx_methods_7pybroma_7PyBroma_Field[] = { + {"getAsFunctionBindField", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_5Field_3getAsFunctionBindField, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"getAsMemberField", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_5Field_5getAsMemberField, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"getAsOutOfLineField", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_5Field_7getAsOutOfLineField, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"getAsPadField", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_5Field_9getAsPadField, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_5Field_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_5Field_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_7pybroma_7PyBroma_Field[] = { + {(char *)"id", __pyx_getprop_7pybroma_7PyBroma_5Field_id, __pyx_setprop_7pybroma_7PyBroma_5Field_id, (char *)0, 0}, + {(char *)"parent", __pyx_getprop_7pybroma_7PyBroma_5Field_parent, 0, (char *)0, 0}, + {(char *)"missing", __pyx_getprop_7pybroma_7PyBroma_5Field_missing, 0, (char *)0, 0}, + {(char *)"links", __pyx_getprop_7pybroma_7PyBroma_5Field_links, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_7pybroma_7PyBroma_Field_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7pybroma_7PyBroma_Field}, + {Py_tp_methods, (void *)__pyx_methods_7pybroma_7PyBroma_Field}, + {Py_tp_getset, (void *)__pyx_getsets_7pybroma_7PyBroma_Field}, + {Py_tp_new, (void *)__pyx_tp_new_7pybroma_7PyBroma_Field}, + {0, 0}, +}; +static PyType_Spec __pyx_type_7pybroma_7PyBroma_Field_spec = { + "pybroma.PyBroma.Field", + sizeof(struct __pyx_obj_7pybroma_7PyBroma_Field), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_7pybroma_7PyBroma_Field_slots, +}; +#else + +static PyTypeObject __pyx_type_7pybroma_7PyBroma_Field = { + PyVarObject_HEAD_INIT(0, 0) + "pybroma.PyBroma.""Field", /*tp_name*/ + sizeof(struct __pyx_obj_7pybroma_7PyBroma_Field), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7pybroma_7PyBroma_Field, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7pybroma_7PyBroma_Field, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_7pybroma_7PyBroma_Field, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7pybroma_7PyBroma_Field, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_PlatformNumber(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *)o); + new((void*)&(p->binds)) struct broma::PlatformNumber(); + if (unlikely(__pyx_pw_7pybroma_7PyBroma_14PlatformNumber_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_7pybroma_7PyBroma_PlatformNumber(PyObject *o) { + struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *p = (struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7pybroma_7PyBroma_PlatformNumber) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + __Pyx_call_destructor(p->binds); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_14PlatformNumber_mac(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_14PlatformNumber_3mac_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_14PlatformNumber_ios(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_14PlatformNumber_3ios_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_14PlatformNumber_win(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_14PlatformNumber_3win_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_14PlatformNumber_android32(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_14PlatformNumber_9android32_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_14PlatformNumber_android64(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_14PlatformNumber_9android64_1__get__(o); +} + +static PyMethodDef __pyx_methods_7pybroma_7PyBroma_PlatformNumber[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_14PlatformNumber_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_14PlatformNumber_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_7pybroma_7PyBroma_PlatformNumber[] = { + {(char *)"mac", __pyx_getprop_7pybroma_7PyBroma_14PlatformNumber_mac, 0, (char *)0, 0}, + {(char *)"ios", __pyx_getprop_7pybroma_7PyBroma_14PlatformNumber_ios, 0, (char *)0, 0}, + {(char *)"win", __pyx_getprop_7pybroma_7PyBroma_14PlatformNumber_win, 0, (char *)0, 0}, + {(char *)"android32", __pyx_getprop_7pybroma_7PyBroma_14PlatformNumber_android32, 0, (char *)0, 0}, + {(char *)"android64", __pyx_getprop_7pybroma_7PyBroma_14PlatformNumber_android64, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_7pybroma_7PyBroma_PlatformNumber_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7pybroma_7PyBroma_PlatformNumber}, + {Py_tp_methods, (void *)__pyx_methods_7pybroma_7PyBroma_PlatformNumber}, + {Py_tp_getset, (void *)__pyx_getsets_7pybroma_7PyBroma_PlatformNumber}, + {Py_tp_new, (void *)__pyx_tp_new_7pybroma_7PyBroma_PlatformNumber}, + {0, 0}, +}; +static PyType_Spec __pyx_type_7pybroma_7PyBroma_PlatformNumber_spec = { + "pybroma.PyBroma.PlatformNumber", + sizeof(struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_7pybroma_7PyBroma_PlatformNumber_slots, +}; +#else + +static PyTypeObject __pyx_type_7pybroma_7PyBroma_PlatformNumber = { + PyVarObject_HEAD_INIT(0, 0) + "pybroma.PyBroma.""PlatformNumber", /*tp_name*/ + sizeof(struct __pyx_obj_7pybroma_7PyBroma_PlatformNumber), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7pybroma_7PyBroma_PlatformNumber, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7pybroma_7PyBroma_PlatformNumber, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_7pybroma_7PyBroma_PlatformNumber, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7pybroma_7PyBroma_PlatformNumber, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_InlineField(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_7pybroma_7PyBroma_InlineField *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_7pybroma_7PyBroma_InlineField *)o); + new((void*)&(p->_if)) struct broma::InlineField(); + if (unlikely(__pyx_pw_7pybroma_7PyBroma_11InlineField_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_7pybroma_7PyBroma_InlineField(PyObject *o) { + struct __pyx_obj_7pybroma_7PyBroma_InlineField *p = (struct __pyx_obj_7pybroma_7PyBroma_InlineField *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7pybroma_7PyBroma_InlineField) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + __Pyx_call_destructor(p->_if); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_11InlineField_inner(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_11InlineField_5inner_1__get__(o); +} + +static PyMethodDef __pyx_methods_7pybroma_7PyBroma_InlineField[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_11InlineField_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_11InlineField_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_7pybroma_7PyBroma_InlineField[] = { + {(char *)"inner", __pyx_getprop_7pybroma_7PyBroma_11InlineField_inner, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_7pybroma_7PyBroma_InlineField_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7pybroma_7PyBroma_InlineField}, + {Py_tp_methods, (void *)__pyx_methods_7pybroma_7PyBroma_InlineField}, + {Py_tp_getset, (void *)__pyx_getsets_7pybroma_7PyBroma_InlineField}, + {Py_tp_new, (void *)__pyx_tp_new_7pybroma_7PyBroma_InlineField}, + {0, 0}, +}; +static PyType_Spec __pyx_type_7pybroma_7PyBroma_InlineField_spec = { + "pybroma.PyBroma.InlineField", + sizeof(struct __pyx_obj_7pybroma_7PyBroma_InlineField), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_7pybroma_7PyBroma_InlineField_slots, +}; +#else + +static PyTypeObject __pyx_type_7pybroma_7PyBroma_InlineField = { + PyVarObject_HEAD_INIT(0, 0) + "pybroma.PyBroma.""InlineField", /*tp_name*/ + sizeof(struct __pyx_obj_7pybroma_7PyBroma_InlineField), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7pybroma_7PyBroma_InlineField, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7pybroma_7PyBroma_InlineField, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_7pybroma_7PyBroma_InlineField, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7pybroma_7PyBroma_InlineField, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_7pybroma_7PyBroma_FunctionProto __pyx_vtable_7pybroma_7PyBroma_FunctionProto; + +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_FunctionProto(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *)o); + p->__pyx_vtab = __pyx_vtabptr_7pybroma_7PyBroma_FunctionProto; + new((void*)&(p->proto)) struct broma::FunctionProto(); + p->_args = ((PyObject*)Py_None); Py_INCREF(Py_None); + if (unlikely(__pyx_pw_7pybroma_7PyBroma_13FunctionProto_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_7pybroma_7PyBroma_FunctionProto(PyObject *o) { + struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *p = (struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7pybroma_7PyBroma_FunctionProto) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + __Pyx_call_destructor(p->proto); + Py_CLEAR(p->_args); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_7pybroma_7PyBroma_FunctionProto(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *p = (struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *)o; + if (p->_args) { + e = (*v)(p->_args, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_7pybroma_7PyBroma_FunctionProto(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *p = (struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *)o; + tmp = ((PyObject*)p->_args); + p->_args = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_13FunctionProto_args(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_13FunctionProto_4args_1__get__(o); +} + +static int __pyx_setprop_7pybroma_7PyBroma_13FunctionProto_args(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_7pybroma_7PyBroma_13FunctionProto_4args_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_13FunctionProto_ret(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_13FunctionProto_3ret_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_13FunctionProto_name(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_13FunctionProto_4name_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_13FunctionProto_docs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_13FunctionProto_4docs_1__get__(o); +} + +static PyMethodDef __pyx_methods_7pybroma_7PyBroma_FunctionProto[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_13FunctionProto_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_13FunctionProto_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_7pybroma_7PyBroma_FunctionProto[] = { + {(char *)"args", __pyx_getprop_7pybroma_7PyBroma_13FunctionProto_args, __pyx_setprop_7pybroma_7PyBroma_13FunctionProto_args, (char *)0, 0}, + {(char *)"ret", __pyx_getprop_7pybroma_7PyBroma_13FunctionProto_ret, 0, (char *)0, 0}, + {(char *)"name", __pyx_getprop_7pybroma_7PyBroma_13FunctionProto_name, 0, (char *)0, 0}, + {(char *)"docs", __pyx_getprop_7pybroma_7PyBroma_13FunctionProto_docs, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_7pybroma_7PyBroma_FunctionProto_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7pybroma_7PyBroma_FunctionProto}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_7pybroma_7PyBroma_FunctionProto}, + {Py_tp_clear, (void *)__pyx_tp_clear_7pybroma_7PyBroma_FunctionProto}, + {Py_tp_methods, (void *)__pyx_methods_7pybroma_7PyBroma_FunctionProto}, + {Py_tp_getset, (void *)__pyx_getsets_7pybroma_7PyBroma_FunctionProto}, + {Py_tp_new, (void *)__pyx_tp_new_7pybroma_7PyBroma_FunctionProto}, + {0, 0}, +}; +static PyType_Spec __pyx_type_7pybroma_7PyBroma_FunctionProto_spec = { + "pybroma.PyBroma.FunctionProto", + sizeof(struct __pyx_obj_7pybroma_7PyBroma_FunctionProto), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_7pybroma_7PyBroma_FunctionProto_slots, +}; +#else + +static PyTypeObject __pyx_type_7pybroma_7PyBroma_FunctionProto = { + PyVarObject_HEAD_INIT(0, 0) + "pybroma.PyBroma.""FunctionProto", /*tp_name*/ + sizeof(struct __pyx_obj_7pybroma_7PyBroma_FunctionProto), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7pybroma_7PyBroma_FunctionProto, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7pybroma_7PyBroma_FunctionProto, /*tp_traverse*/ + __pyx_tp_clear_7pybroma_7PyBroma_FunctionProto, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7pybroma_7PyBroma_FunctionProto, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_7pybroma_7PyBroma_FunctionProto, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7pybroma_7PyBroma_FunctionProto, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_Function(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_7pybroma_7PyBroma_Function *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_7pybroma_7PyBroma_Function *)o); + new((void*)&(p->func)) struct broma::Function(); + return o; +} + +static void __pyx_tp_dealloc_7pybroma_7PyBroma_Function(PyObject *o) { + struct __pyx_obj_7pybroma_7PyBroma_Function *p = (struct __pyx_obj_7pybroma_7PyBroma_Function *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7pybroma_7PyBroma_Function) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + __Pyx_call_destructor(p->func); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_8Function_prototype(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_8Function_9prototype_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_8Function_binds(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_8Function_5binds_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_8Function_missing(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_8Function_7missing_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_8Function_links(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_8Function_5links_1__get__(o); +} + +static PyMethodDef __pyx_methods_7pybroma_7PyBroma_Function[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_8Function_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_8Function_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_7pybroma_7PyBroma_Function[] = { + {(char *)"prototype", __pyx_getprop_7pybroma_7PyBroma_8Function_prototype, 0, (char *)0, 0}, + {(char *)"binds", __pyx_getprop_7pybroma_7PyBroma_8Function_binds, 0, (char *)0, 0}, + {(char *)"missing", __pyx_getprop_7pybroma_7PyBroma_8Function_missing, 0, (char *)0, 0}, + {(char *)"links", __pyx_getprop_7pybroma_7PyBroma_8Function_links, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_7pybroma_7PyBroma_Function_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7pybroma_7PyBroma_Function}, + {Py_tp_methods, (void *)__pyx_methods_7pybroma_7PyBroma_Function}, + {Py_tp_getset, (void *)__pyx_getsets_7pybroma_7PyBroma_Function}, + {Py_tp_init, (void *)__pyx_pw_7pybroma_7PyBroma_8Function_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_7pybroma_7PyBroma_Function}, + {0, 0}, +}; +static PyType_Spec __pyx_type_7pybroma_7PyBroma_Function_spec = { + "pybroma.PyBroma.Function", + sizeof(struct __pyx_obj_7pybroma_7PyBroma_Function), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_7pybroma_7PyBroma_Function_slots, +}; +#else + +static PyTypeObject __pyx_type_7pybroma_7PyBroma_Function = { + PyVarObject_HEAD_INIT(0, 0) + "pybroma.PyBroma.""Function", /*tp_name*/ + sizeof(struct __pyx_obj_7pybroma_7PyBroma_Function), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7pybroma_7PyBroma_Function, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7pybroma_7PyBroma_Function, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_7pybroma_7PyBroma_Function, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_7pybroma_7PyBroma_8Function_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7pybroma_7PyBroma_Function, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_Class(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_7pybroma_7PyBroma_Class *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_7pybroma_7PyBroma_Class *)o); + new((void*)&(p->_cls)) struct broma::Class(); + p->_superclasses = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_depends = ((PyObject*)Py_None); Py_INCREF(Py_None); + if (unlikely(__pyx_pw_7pybroma_7PyBroma_5Class_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_7pybroma_7PyBroma_Class(PyObject *o) { + struct __pyx_obj_7pybroma_7PyBroma_Class *p = (struct __pyx_obj_7pybroma_7PyBroma_Class *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7pybroma_7PyBroma_Class) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + __Pyx_call_destructor(p->_cls); + Py_CLEAR(p->_superclasses); + Py_CLEAR(p->_depends); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_7pybroma_7PyBroma_Class(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_7pybroma_7PyBroma_Class *p = (struct __pyx_obj_7pybroma_7PyBroma_Class *)o; + if (p->_superclasses) { + e = (*v)(p->_superclasses, a); if (e) return e; + } + if (p->_depends) { + e = (*v)(p->_depends, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_7pybroma_7PyBroma_Class(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_7pybroma_7PyBroma_Class *p = (struct __pyx_obj_7pybroma_7PyBroma_Class *)o; + tmp = ((PyObject*)p->_superclasses); + p->_superclasses = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_depends); + p->_depends = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_5Class_name(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_5Class_4name_1__get__(o); +} + +static int __pyx_setprop_7pybroma_7PyBroma_5Class_name(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_7pybroma_7PyBroma_5Class_4name_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_5Class_links(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_5Class_5links_1__get__(o); +} + +static int __pyx_setprop_7pybroma_7PyBroma_5Class_links(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_7pybroma_7PyBroma_5Class_5links_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_5Class_missing(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_5Class_7missing_1__get__(o); +} + +static int __pyx_setprop_7pybroma_7PyBroma_5Class_missing(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_7pybroma_7PyBroma_5Class_7missing_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_5Class_superclasses(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_5Class_12superclasses_1__get__(o); +} + +static int __pyx_setprop_7pybroma_7PyBroma_5Class_superclasses(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_7pybroma_7PyBroma_5Class_12superclasses_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_5Class_depends(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_5Class_7depends_1__get__(o); +} + +static int __pyx_setprop_7pybroma_7PyBroma_5Class_depends(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_7pybroma_7PyBroma_5Class_7depends_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_5Class_fields(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_5Class_6fields_1__get__(o); +} + +static int __pyx_setprop_7pybroma_7PyBroma_5Class_fields(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_7pybroma_7PyBroma_5Class_6fields_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyMethodDef __pyx_methods_7pybroma_7PyBroma_Class[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_5Class_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_5Class_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_7pybroma_7PyBroma_Class[] = { + {(char *)"name", __pyx_getprop_7pybroma_7PyBroma_5Class_name, __pyx_setprop_7pybroma_7PyBroma_5Class_name, (char *)0, 0}, + {(char *)"links", __pyx_getprop_7pybroma_7PyBroma_5Class_links, __pyx_setprop_7pybroma_7PyBroma_5Class_links, (char *)0, 0}, + {(char *)"missing", __pyx_getprop_7pybroma_7PyBroma_5Class_missing, __pyx_setprop_7pybroma_7PyBroma_5Class_missing, (char *)0, 0}, + {(char *)"superclasses", __pyx_getprop_7pybroma_7PyBroma_5Class_superclasses, __pyx_setprop_7pybroma_7PyBroma_5Class_superclasses, (char *)0, 0}, + {(char *)"depends", __pyx_getprop_7pybroma_7PyBroma_5Class_depends, __pyx_setprop_7pybroma_7PyBroma_5Class_depends, (char *)0, 0}, + {(char *)"fields", __pyx_getprop_7pybroma_7PyBroma_5Class_fields, __pyx_setprop_7pybroma_7PyBroma_5Class_fields, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_7pybroma_7PyBroma_Class_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7pybroma_7PyBroma_Class}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_7pybroma_7PyBroma_Class}, + {Py_tp_clear, (void *)__pyx_tp_clear_7pybroma_7PyBroma_Class}, + {Py_tp_methods, (void *)__pyx_methods_7pybroma_7PyBroma_Class}, + {Py_tp_getset, (void *)__pyx_getsets_7pybroma_7PyBroma_Class}, + {Py_tp_new, (void *)__pyx_tp_new_7pybroma_7PyBroma_Class}, + {0, 0}, +}; +static PyType_Spec __pyx_type_7pybroma_7PyBroma_Class_spec = { + "pybroma.PyBroma.Class", + sizeof(struct __pyx_obj_7pybroma_7PyBroma_Class), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_7pybroma_7PyBroma_Class_slots, +}; +#else + +static PyTypeObject __pyx_type_7pybroma_7PyBroma_Class = { + PyVarObject_HEAD_INIT(0, 0) + "pybroma.PyBroma.""Class", /*tp_name*/ + sizeof(struct __pyx_obj_7pybroma_7PyBroma_Class), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7pybroma_7PyBroma_Class, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_7pybroma_7PyBroma_Class, /*tp_traverse*/ + __pyx_tp_clear_7pybroma_7PyBroma_Class, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7pybroma_7PyBroma_Class, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_7pybroma_7PyBroma_Class, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7pybroma_7PyBroma_Class, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_7pybroma_7PyBroma_Root(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_7pybroma_7PyBroma_Root *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_7pybroma_7PyBroma_Root *)o); + new((void*)&(p->root)) struct broma::Root(); + return o; +} + +static void __pyx_tp_dealloc_7pybroma_7PyBroma_Root(PyObject *o) { + struct __pyx_obj_7pybroma_7PyBroma_Root *p = (struct __pyx_obj_7pybroma_7PyBroma_Root *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7pybroma_7PyBroma_Root) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + __Pyx_call_destructor(p->root); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} +static PyObject *__pyx_sq_item_7pybroma_7PyBroma_Root(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_4Root_functions(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_4Root_9functions_1__get__(o); +} + +static PyObject *__pyx_getprop_7pybroma_7PyBroma_4Root_classes(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_7pybroma_7PyBroma_4Root_7classes_1__get__(o); +} + +static PyMethodDef __pyx_methods_7pybroma_7PyBroma_Root[] = { + {"functionsAsDict", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_4Root_5functionsAsDict, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7pybroma_7PyBroma_4Root_4functionsAsDict}, + {"classesAsDict", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_4Root_7classesAsDict, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_7pybroma_7PyBroma_4Root_6classesAsDict}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_4Root_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7pybroma_7PyBroma_4Root_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_7pybroma_7PyBroma_Root[] = { + {(char *)"functions", __pyx_getprop_7pybroma_7PyBroma_4Root_functions, 0, (char *)0, 0}, + {(char *)"classes", __pyx_getprop_7pybroma_7PyBroma_4Root_classes, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_7pybroma_7PyBroma_Root_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7pybroma_7PyBroma_Root}, + {Py_sq_item, (void *)__pyx_sq_item_7pybroma_7PyBroma_Root}, + {Py_mp_subscript, (void *)__pyx_pw_7pybroma_7PyBroma_4Root_3__getitem__}, + {Py_tp_methods, (void *)__pyx_methods_7pybroma_7PyBroma_Root}, + {Py_tp_getset, (void *)__pyx_getsets_7pybroma_7PyBroma_Root}, + {Py_tp_init, (void *)__pyx_pw_7pybroma_7PyBroma_4Root_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_7pybroma_7PyBroma_Root}, + {0, 0}, +}; +static PyType_Spec __pyx_type_7pybroma_7PyBroma_Root_spec = { + "pybroma.PyBroma.Root", + sizeof(struct __pyx_obj_7pybroma_7PyBroma_Root), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_7pybroma_7PyBroma_Root_slots, +}; +#else + +static PySequenceMethods __pyx_tp_as_sequence_Root = { + 0, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_7pybroma_7PyBroma_Root, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_Root = { + 0, /*mp_length*/ + __pyx_pw_7pybroma_7PyBroma_4Root_3__getitem__, /*mp_subscript*/ + 0, /*mp_ass_subscript*/ +}; + +static PyTypeObject __pyx_type_7pybroma_7PyBroma_Root = { + PyVarObject_HEAD_INIT(0, 0) + "pybroma.PyBroma.""Root", /*tp_name*/ + sizeof(struct __pyx_obj_7pybroma_7PyBroma_Root), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_7pybroma_7PyBroma_Root, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_Root, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_Root, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_7pybroma_7PyBroma_Root, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_7pybroma_7PyBroma_Root, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_7pybroma_7PyBroma_4Root_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_7pybroma_7PyBroma_Root, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif +/* #### Code section: pystring_table ### */ + +static int __Pyx_CreateStringTabAndInitStrings(void) { + __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_Class, __pyx_k_Class, sizeof(__pyx_k_Class), 0, 0, 1, 1}, + {&__pyx_n_s_Class___reduce_cython, __pyx_k_Class___reduce_cython, sizeof(__pyx_k_Class___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Class___setstate_cython, __pyx_k_Class___setstate_cython, sizeof(__pyx_k_Class___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Field, __pyx_k_Field, sizeof(__pyx_k_Field), 0, 0, 1, 1}, + {&__pyx_n_s_Field___reduce_cython, __pyx_k_Field___reduce_cython, sizeof(__pyx_k_Field___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Field___setstate_cython, __pyx_k_Field___setstate_cython, sizeof(__pyx_k_Field___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Field_getAsFunctionBindField, __pyx_k_Field_getAsFunctionBindField, sizeof(__pyx_k_Field_getAsFunctionBindField), 0, 0, 1, 1}, + {&__pyx_n_s_Field_getAsMemberField, __pyx_k_Field_getAsMemberField, sizeof(__pyx_k_Field_getAsMemberField), 0, 0, 1, 1}, + {&__pyx_n_s_Field_getAsOutOfLineField, __pyx_k_Field_getAsOutOfLineField, sizeof(__pyx_k_Field_getAsOutOfLineField), 0, 0, 1, 1}, + {&__pyx_n_s_Field_getAsPadField, __pyx_k_Field_getAsPadField, sizeof(__pyx_k_Field_getAsPadField), 0, 0, 1, 1}, + {&__pyx_n_s_Function, __pyx_k_Function, sizeof(__pyx_k_Function), 0, 0, 1, 1}, + {&__pyx_n_s_FunctionBindField, __pyx_k_FunctionBindField, sizeof(__pyx_k_FunctionBindField), 0, 0, 1, 1}, + {&__pyx_n_s_FunctionBindField___reduce_cytho, __pyx_k_FunctionBindField___reduce_cytho, sizeof(__pyx_k_FunctionBindField___reduce_cytho), 0, 0, 1, 1}, + {&__pyx_n_s_FunctionBindField___setstate_cyt, __pyx_k_FunctionBindField___setstate_cyt, sizeof(__pyx_k_FunctionBindField___setstate_cyt), 0, 0, 1, 1}, + {&__pyx_n_s_FunctionProto, __pyx_k_FunctionProto, sizeof(__pyx_k_FunctionProto), 0, 0, 1, 1}, + {&__pyx_n_s_FunctionProto___reduce_cython, __pyx_k_FunctionProto___reduce_cython, sizeof(__pyx_k_FunctionProto___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_FunctionProto___setstate_cython, __pyx_k_FunctionProto___setstate_cython, sizeof(__pyx_k_FunctionProto___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Function___reduce_cython, __pyx_k_Function___reduce_cython, sizeof(__pyx_k_Function___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Function___setstate_cython, __pyx_k_Function___setstate_cython, sizeof(__pyx_k_Function___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ImmutableError, __pyx_k_ImmutableError, sizeof(__pyx_k_ImmutableError), 0, 0, 1, 1}, + {&__pyx_n_s_ImmutableError___reduce_cython, __pyx_k_ImmutableError___reduce_cython, sizeof(__pyx_k_ImmutableError___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ImmutableError___setstate_cython, __pyx_k_ImmutableError___setstate_cython, sizeof(__pyx_k_ImmutableError___setstate_cython), 0, 0, 1, 1}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 0, 1, 0}, + {&__pyx_n_s_InlineField, __pyx_k_InlineField, sizeof(__pyx_k_InlineField), 0, 0, 1, 1}, + {&__pyx_n_s_InlineField___reduce_cython, __pyx_k_InlineField___reduce_cython, sizeof(__pyx_k_InlineField___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_InlineField___setstate_cython, __pyx_k_InlineField___setstate_cython, sizeof(__pyx_k_InlineField___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_KeyError, __pyx_k_KeyError, sizeof(__pyx_k_KeyError), 0, 0, 1, 1}, + {&__pyx_n_s_MemberField, __pyx_k_MemberField, sizeof(__pyx_k_MemberField), 0, 0, 1, 1}, + {&__pyx_n_s_MemberField___reduce_cython, __pyx_k_MemberField___reduce_cython, sizeof(__pyx_k_MemberField___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_MemberField___setstate_cython, __pyx_k_MemberField___setstate_cython, sizeof(__pyx_k_MemberField___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_MemberFunctionProto, __pyx_k_MemberFunctionProto, sizeof(__pyx_k_MemberFunctionProto), 0, 0, 1, 1}, + {&__pyx_n_s_MemberFunctionProto___reduce_cyt, __pyx_k_MemberFunctionProto___reduce_cyt, sizeof(__pyx_k_MemberFunctionProto___reduce_cyt), 0, 0, 1, 1}, + {&__pyx_n_s_MemberFunctionProto___setstate_c, __pyx_k_MemberFunctionProto___setstate_c, sizeof(__pyx_k_MemberFunctionProto___setstate_c), 0, 0, 1, 1}, + {&__pyx_kp_s_No_value_specified_for_struct_at, __pyx_k_No_value_specified_for_struct_at, sizeof(__pyx_k_No_value_specified_for_struct_at), 0, 0, 1, 0}, + {&__pyx_kp_s_No_value_specified_for_struct_at_2, __pyx_k_No_value_specified_for_struct_at_2, sizeof(__pyx_k_No_value_specified_for_struct_at_2), 0, 0, 1, 0}, + {&__pyx_n_s_OutOfLineField, __pyx_k_OutOfLineField, sizeof(__pyx_k_OutOfLineField), 0, 0, 1, 1}, + {&__pyx_n_s_OutOfLineField___reduce_cython, __pyx_k_OutOfLineField___reduce_cython, sizeof(__pyx_k_OutOfLineField___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_OutOfLineField___setstate_cython, __pyx_k_OutOfLineField___setstate_cython, sizeof(__pyx_k_OutOfLineField___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_PadField, __pyx_k_PadField, sizeof(__pyx_k_PadField), 0, 0, 1, 1}, + {&__pyx_n_s_PadField___reduce_cython, __pyx_k_PadField___reduce_cython, sizeof(__pyx_k_PadField___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_PadField___setstate_cython, __pyx_k_PadField___setstate_cython, sizeof(__pyx_k_PadField___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, + {&__pyx_kp_s_Pickling_of_struct_members_such, __pyx_k_Pickling_of_struct_members_such, sizeof(__pyx_k_Pickling_of_struct_members_such), 0, 0, 1, 0}, + {&__pyx_kp_s_Pickling_of_struct_members_such_2, __pyx_k_Pickling_of_struct_members_such_2, sizeof(__pyx_k_Pickling_of_struct_members_such_2), 0, 0, 1, 0}, + {&__pyx_n_s_PlatformNumber, __pyx_k_PlatformNumber, sizeof(__pyx_k_PlatformNumber), 0, 0, 1, 1}, + {&__pyx_n_s_PlatformNumber___reduce_cython, __pyx_k_PlatformNumber___reduce_cython, sizeof(__pyx_k_PlatformNumber___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_PlatformNumber___setstate_cython, __pyx_k_PlatformNumber___setstate_cython, sizeof(__pyx_k_PlatformNumber___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Root, __pyx_k_Root, sizeof(__pyx_k_Root), 0, 0, 1, 1}, + {&__pyx_n_s_Root___reduce_cython, __pyx_k_Root___reduce_cython, sizeof(__pyx_k_Root___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Root___setstate_cython, __pyx_k_Root___setstate_cython, sizeof(__pyx_k_Root___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Root_classesAsDict, __pyx_k_Root_classesAsDict, sizeof(__pyx_k_Root_classesAsDict), 0, 0, 1, 1}, + {&__pyx_n_s_Root_functionsAsDict, __pyx_k_Root_functionsAsDict, sizeof(__pyx_k_Root_functionsAsDict), 0, 0, 1, 1}, + {&__pyx_n_s_Type, __pyx_k_Type, sizeof(__pyx_k_Type), 0, 0, 1, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_n_s_Type___reduce_cython, __pyx_k_Type___reduce_cython, sizeof(__pyx_k_Type___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Type___setstate_cython, __pyx_k_Type___setstate_cython, sizeof(__pyx_k_Type___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_kp_u__12, __pyx_k__12, sizeof(__pyx_k__12), 0, 1, 0, 0}, + {&__pyx_n_s__13, __pyx_k__13, sizeof(__pyx_k__13), 0, 0, 1, 1}, + {&__pyx_n_u_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 1, 0, 1}, + {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, + {&__pyx_n_s_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 0, 1, 1}, + {&__pyx_n_s_classesAsDict, __pyx_k_classesAsDict, sizeof(__pyx_k_classesAsDict), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_u_depends, __pyx_k_depends, sizeof(__pyx_k_depends), 0, 1, 0, 1}, + {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, + {&__pyx_n_s_dict_2, __pyx_k_dict_2, sizeof(__pyx_k_dict_2), 0, 0, 1, 1}, + {&__pyx_n_s_dict_3, __pyx_k_dict_3, sizeof(__pyx_k_dict_3), 0, 0, 1, 1}, + {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, + {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, + {&__pyx_n_u_fields, __pyx_k_fields, sizeof(__pyx_k_fields), 0, 1, 0, 1}, + {&__pyx_n_s_fileName, __pyx_k_fileName, sizeof(__pyx_k_fileName), 0, 0, 1, 1}, + {&__pyx_n_s_functionsAsDict, __pyx_k_functionsAsDict, sizeof(__pyx_k_functionsAsDict), 0, 0, 1, 1}, + {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, + {&__pyx_n_s_getAsFunctionBindField, __pyx_k_getAsFunctionBindField, sizeof(__pyx_k_getAsFunctionBindField), 0, 0, 1, 1}, + {&__pyx_n_s_getAsMemberField, __pyx_k_getAsMemberField, sizeof(__pyx_k_getAsMemberField), 0, 0, 1, 1}, + {&__pyx_n_s_getAsOutOfLineField, __pyx_k_getAsOutOfLineField, sizeof(__pyx_k_getAsOutOfLineField), 0, 0, 1, 1}, + {&__pyx_n_s_getAsPadField, __pyx_k_getAsPadField, sizeof(__pyx_k_getAsPadField), 0, 0, 1, 1}, + {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, + {&__pyx_n_u_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 1, 0, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, + {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, + {&__pyx_kp_u_is_immutable, __pyx_k_is_immutable, sizeof(__pyx_k_is_immutable), 0, 1, 0, 0}, + {&__pyx_n_s_is_struct, __pyx_k_is_struct, sizeof(__pyx_k_is_struct), 0, 0, 1, 1}, + {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, + {&__pyx_n_u_links, __pyx_k_links, sizeof(__pyx_k_links), 0, 1, 0, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_u_missing, __pyx_k_missing, sizeof(__pyx_k_missing), 0, 1, 0, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_u_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 1, 0, 1}, + {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, + {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, + {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, + {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, + {&__pyx_n_s_pybroma_PyBroma, __pyx_k_pybroma_PyBroma, sizeof(__pyx_k_pybroma_PyBroma), 0, 0, 1, 1}, + {&__pyx_kp_s_pybroma_PyBroma_pyx, __pyx_k_pybroma_PyBroma_pyx, sizeof(__pyx_k_pybroma_PyBroma_pyx), 0, 0, 1, 0}, + {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_ImmutableError, __pyx_k_pyx_unpickle_ImmutableError, sizeof(__pyx_k_pyx_unpickle_ImmutableError), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, + {&__pyx_n_s_return, __pyx_k_return, sizeof(__pyx_k_return), 0, 0, 1, 1}, + {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, + {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_state, __pyx_k_state, sizeof(__pyx_k_state), 0, 0, 1, 1}, + {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, + {&__pyx_n_s_super, __pyx_k_super, sizeof(__pyx_k_super), 0, 0, 1, 1}, + {&__pyx_n_u_superclass, __pyx_k_superclass, sizeof(__pyx_k_superclass), 0, 1, 0, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, + {&__pyx_n_s_use_setstate, __pyx_k_use_setstate, sizeof(__pyx_k_use_setstate), 0, 0, 1, 1}, + {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} + }; + return __Pyx_InitStrings(__pyx_string_tab); +} +/* #### Code section: cached_builtins ### */ +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_super = __Pyx_GetBuiltinName(__pyx_n_s_super); if (!__pyx_builtin_super) __PYX_ERR(0, 29, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 336, __pyx_L1_error) + __pyx_builtin_KeyError = __Pyx_GetBuiltinName(__pyx_n_s_KeyError); if (!__pyx_builtin_KeyError) __PYX_ERR(1, 19, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 20, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: cached_constants ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "FromPyStructUtility":20 + * value = obj['name'] + * except KeyError: + * raise ValueError("No value specified for struct attribute 'name'") # <<<<<<<<<<<<<< + * result.name = value + * try: + */ + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_No_value_specified_for_struct_at); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "FromPyStructUtility":25 + * value = obj['is_struct'] + * except KeyError: + * raise ValueError("No value specified for struct attribute 'is_struct'") # <<<<<<<<<<<<<< + * result.is_struct = value + * return result + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_No_value_specified_for_struct_at_2); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "pybroma/PyBroma.pyx":44 + * return self.type.name + * def __set__(self, obj): + * raise ImmutableError("name") # <<<<<<<<<<<<<< + * + * def __eq__(self, Type t): + */ + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_n_u_name); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "pybroma/PyBroma.pyx":80 + * + * def __set__(self, obj): + * raise ImmutableError("args") # <<<<<<<<<<<<<< + * + * # TODO: Make More Fields Immutable + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_n_u_args); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "pybroma/PyBroma.pyx":232 + * return self.field.field_id + * def __set__(self, obj): + * raise ImmutableError("id") # <<<<<<<<<<<<<< + * + * @property + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_n_u_id); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "pybroma/PyBroma.pyx":423 + * return self._cls.name + * def __set__(self, obj): + * raise ImmutableError("links") # <<<<<<<<<<<<<< + * + * property missing: + */ + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_n_u_links); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + + /* "pybroma/PyBroma.pyx":430 + * return self._cls.missing + * def __set__(self, obj): + * raise ImmutableError("missing") # <<<<<<<<<<<<<< + * + * property superclasses: + */ + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_n_u_missing); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + + /* "pybroma/PyBroma.pyx":442 + * + * def __set__(self, obj): + * raise ImmutableError("superclass") # <<<<<<<<<<<<<< + * + * property depends: + */ + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_n_u_superclass); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "pybroma/PyBroma.pyx":454 + * + * def __set__(self, obj): + * raise ImmutableError("depends") # <<<<<<<<<<<<<< + * + * property fields: + */ + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_n_u_depends); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 454, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + + /* "pybroma/PyBroma.pyx":460 + * return [make_Field(f) for f in self._cls.fields] + * def __set__(self, obj): + * raise ImmutableError("fields") # <<<<<<<<<<<<<< + * + * cdef make_Class(broma.Class cls): + */ + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_n_u_fields); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 460, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + __pyx_tuple__11 = PyTuple_Pack(3, __pyx_int_238750788, __pyx_int_228825662, __pyx_int_222419149); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_tuple__14 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_state, __pyx_n_s_dict_2, __pyx_n_s_use_setstate); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); + __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_ImmutableError, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_ImmutableError__set_state(self, __pyx_state) + */ + __pyx_tuple__16 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); + __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(1, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_tuple__18 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__18); + __Pyx_GIVEREF(__pyx_tuple__18); + __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(1, 3, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(1, 3, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_codeobj__24 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__24)) __PYX_ERR(1, 3, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__25 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__25)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_codeobj__26 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__26)) __PYX_ERR(1, 3, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_codeobj__28 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__28)) __PYX_ERR(1, 3, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_codeobj__30 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__30)) __PYX_ERR(1, 3, __pyx_L1_error) + + /* "pybroma/PyBroma.pyx":238 + * return self.field.parent + * + * def getAsFunctionBindField(self): # <<<<<<<<<<<<<< + * cdef broma.FunctionBindField* x = broma.Field_GetAs_FunctionBindField(&self.field) + * return make_FunctionBindField(DEPACK(x)) if x != nullptr else None + */ + __pyx_tuple__31 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_x); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__31); + __Pyx_GIVEREF(__pyx_tuple__31); + __pyx_codeobj__32 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__31, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pybroma_PyBroma_pyx, __pyx_n_s_getAsFunctionBindField, 238, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__32)) __PYX_ERR(0, 238, __pyx_L1_error) + + /* "pybroma/PyBroma.pyx":242 + * return make_FunctionBindField(DEPACK(x)) if x != nullptr else None + * + * def getAsMemberField(self): # <<<<<<<<<<<<<< + * cdef broma.MemberField* x = broma.Field_GetAs_MemberField(&self.field) + * return make_MemberField(DEPACK(x)) if x != nullptr else None + */ + __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__31, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pybroma_PyBroma_pyx, __pyx_n_s_getAsMemberField, 242, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 242, __pyx_L1_error) + + /* "pybroma/PyBroma.pyx":246 + * return make_MemberField(DEPACK(x)) if x != nullptr else None + * + * def getAsOutOfLineField(self): # <<<<<<<<<<<<<< + * cdef broma.OutOfLineField* x = broma.Field_GetAs_OutOfLineField(&self.field) + * return make_OutOfLineField(DEPACK(x)) if x != nullptr else None + */ + __pyx_codeobj__34 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__31, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pybroma_PyBroma_pyx, __pyx_n_s_getAsOutOfLineField, 246, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__34)) __PYX_ERR(0, 246, __pyx_L1_error) + + /* "pybroma/PyBroma.pyx":250 + * return make_OutOfLineField(DEPACK(x)) if x != nullptr else None + * + * def getAsPadField(self): # <<<<<<<<<<<<<< + * cdef broma.PadField* x = broma.Field_GetAs_PadField(&self.field) + * return make_PadField(DEPACK(x)) if x != nullptr else None + */ + __pyx_codeobj__35 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__31, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pybroma_PyBroma_pyx, __pyx_n_s_getAsPadField, 250, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(0, 250, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__36 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__36)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(1, 3, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__38 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__38)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_codeobj__39 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__39)) __PYX_ERR(1, 3, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__40 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__40)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_codeobj__41 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__41)) __PYX_ERR(1, 3, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__42 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__42)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_codeobj__43 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__43)) __PYX_ERR(1, 3, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self.func must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__44 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__44)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "Pickling of struct members such as self.func must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self.func must be explicitly requested with @auto_pickle(True)" + */ + __pyx_codeobj__45 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__45)) __PYX_ERR(1, 3, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__46 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__46)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_codeobj__47 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__47)) __PYX_ERR(1, 3, __pyx_L1_error) + + /* "pybroma/PyBroma.pyx":496 + * return [make_Function(x) for x in self.root.functions] + * + * def functionsAsDict(self) -> dict: # <<<<<<<<<<<<<< + * """Converts Functions to A Dictionary""" + * return {c.prototype.name: make_Function(c) for c in self.root.functions} + */ + __pyx_tuple__48 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_c); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(0, 496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__48); + __Pyx_GIVEREF(__pyx_tuple__48); + __pyx_codeobj__49 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__48, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pybroma_PyBroma_pyx, __pyx_n_s_functionsAsDict, 496, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__49)) __PYX_ERR(0, 496, __pyx_L1_error) + + /* "pybroma/PyBroma.pyx":500 + * return {c.prototype.name: make_Function(c) for c in self.root.functions} + * + * def classesAsDict(self) -> dict: # <<<<<<<<<<<<<< + * """Converts Classes to a dictionary""" + * return {c.name:make_Class(c) for c in self.root.classes} + */ + __pyx_codeobj__50 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__48, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pybroma_PyBroma_pyx, __pyx_n_s_classesAsDict, 500, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__50)) __PYX_ERR(0, 500, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self.root must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__51 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__51)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "Pickling of struct members such as self.root must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self.root must be explicitly requested with @auto_pickle(True)" + */ + __pyx_codeobj__52 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__52)) __PYX_ERR(1, 3, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __pyx_unpickle_ImmutableError(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + __pyx_tuple__53 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__53); + __Pyx_GIVEREF(__pyx_tuple__53); + __pyx_codeobj__54 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__53, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_ImmutableError, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__54)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} +/* #### Code section: init_constants ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { + if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_int_222419149 = PyInt_FromLong(222419149L); if (unlikely(!__pyx_int_222419149)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_228825662 = PyInt_FromLong(228825662L); if (unlikely(!__pyx_int_228825662)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_238750788 = PyInt_FromLong(238750788L); if (unlikely(!__pyx_int_238750788)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: init_globals ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + return 0; +} +/* #### Code section: init_module ### */ + +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ + +static int __Pyx_modinit_global_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_7pybroma_7PyBroma_ImmutableError = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7pybroma_7PyBroma_ImmutableError_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_7pybroma_7PyBroma_ImmutableError)) __PYX_ERR(0, 26, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_7pybroma_7PyBroma_ImmutableError_spec, __pyx_ptype_7pybroma_7PyBroma_ImmutableError) < 0) __PYX_ERR(0, 26, __pyx_L1_error) + #else + __pyx_ptype_7pybroma_7PyBroma_ImmutableError = &__pyx_type_7pybroma_7PyBroma_ImmutableError; + #endif + if (sizeof(struct __pyx_obj_7pybroma_7PyBroma_ImmutableError) != sizeof(PyBaseExceptionObject)) { + if (__Pyx_validate_extern_base((&((PyTypeObject*)PyExc_Exception)[0])) < 0) __PYX_ERR(0, 26, __pyx_L1_error) + } + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_7pybroma_7PyBroma_ImmutableError->tp_dealloc = (&((PyTypeObject*)PyExc_Exception)[0])->tp_dealloc; + __pyx_ptype_7pybroma_7PyBroma_ImmutableError->tp_base = (&((PyTypeObject*)PyExc_Exception)[0]); + __pyx_ptype_7pybroma_7PyBroma_ImmutableError->tp_new = (&((PyTypeObject*)PyExc_Exception)[0])->tp_new; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_7pybroma_7PyBroma_ImmutableError) < 0) __PYX_ERR(0, 26, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_7pybroma_7PyBroma_ImmutableError->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_7pybroma_7PyBroma_ImmutableError->tp_dictoffset && __pyx_ptype_7pybroma_7PyBroma_ImmutableError->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_7pybroma_7PyBroma_ImmutableError->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ImmutableError, (PyObject *) __pyx_ptype_7pybroma_7PyBroma_ImmutableError) < 0) __PYX_ERR(0, 26, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_7pybroma_7PyBroma_ImmutableError) < 0) __PYX_ERR(0, 26, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_7pybroma_7PyBroma_Type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7pybroma_7PyBroma_Type_spec, NULL); if (unlikely(!__pyx_ptype_7pybroma_7PyBroma_Type)) __PYX_ERR(0, 33, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_7pybroma_7PyBroma_Type_spec, __pyx_ptype_7pybroma_7PyBroma_Type) < 0) __PYX_ERR(0, 33, __pyx_L1_error) + #else + __pyx_ptype_7pybroma_7PyBroma_Type = &__pyx_type_7pybroma_7PyBroma_Type; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_7pybroma_7PyBroma_Type) < 0) __PYX_ERR(0, 33, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_7pybroma_7PyBroma_Type->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_7pybroma_7PyBroma_Type->tp_dictoffset && __pyx_ptype_7pybroma_7PyBroma_Type->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_7pybroma_7PyBroma_Type->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Type, (PyObject *) __pyx_ptype_7pybroma_7PyBroma_Type) < 0) __PYX_ERR(0, 33, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_7pybroma_7PyBroma_Type) < 0) __PYX_ERR(0, 33, __pyx_L1_error) + #endif + __pyx_vtabptr_7pybroma_7PyBroma_MemberFunctionProto = &__pyx_vtable_7pybroma_7PyBroma_MemberFunctionProto; + __pyx_vtable_7pybroma_7PyBroma_MemberFunctionProto.init = (void (*)(struct __pyx_obj_7pybroma_7PyBroma_MemberFunctionProto *, struct broma::MemberFunctionProto))__pyx_f_7pybroma_7PyBroma_19MemberFunctionProto_init; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_7pybroma_7PyBroma_MemberFunctionProto = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7pybroma_7PyBroma_MemberFunctionProto_spec, NULL); if (unlikely(!__pyx_ptype_7pybroma_7PyBroma_MemberFunctionProto)) __PYX_ERR(0, 62, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_7pybroma_7PyBroma_MemberFunctionProto_spec, __pyx_ptype_7pybroma_7PyBroma_MemberFunctionProto) < 0) __PYX_ERR(0, 62, __pyx_L1_error) + #else + __pyx_ptype_7pybroma_7PyBroma_MemberFunctionProto = &__pyx_type_7pybroma_7PyBroma_MemberFunctionProto; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_7pybroma_7PyBroma_MemberFunctionProto) < 0) __PYX_ERR(0, 62, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_7pybroma_7PyBroma_MemberFunctionProto->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_7pybroma_7PyBroma_MemberFunctionProto->tp_dictoffset && __pyx_ptype_7pybroma_7PyBroma_MemberFunctionProto->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_7pybroma_7PyBroma_MemberFunctionProto->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_ptype_7pybroma_7PyBroma_MemberFunctionProto, __pyx_vtabptr_7pybroma_7PyBroma_MemberFunctionProto) < 0) __PYX_ERR(0, 62, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_7pybroma_7PyBroma_MemberFunctionProto) < 0) __PYX_ERR(0, 62, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_MemberFunctionProto, (PyObject *) __pyx_ptype_7pybroma_7PyBroma_MemberFunctionProto) < 0) __PYX_ERR(0, 62, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_7pybroma_7PyBroma_MemberFunctionProto) < 0) __PYX_ERR(0, 62, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_7pybroma_7PyBroma_MemberField = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7pybroma_7PyBroma_MemberField_spec, NULL); if (unlikely(!__pyx_ptype_7pybroma_7PyBroma_MemberField)) __PYX_ERR(0, 125, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_7pybroma_7PyBroma_MemberField_spec, __pyx_ptype_7pybroma_7PyBroma_MemberField) < 0) __PYX_ERR(0, 125, __pyx_L1_error) + #else + __pyx_ptype_7pybroma_7PyBroma_MemberField = &__pyx_type_7pybroma_7PyBroma_MemberField; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_7pybroma_7PyBroma_MemberField) < 0) __PYX_ERR(0, 125, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_7pybroma_7PyBroma_MemberField->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_7pybroma_7PyBroma_MemberField->tp_dictoffset && __pyx_ptype_7pybroma_7PyBroma_MemberField->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_7pybroma_7PyBroma_MemberField->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_MemberField, (PyObject *) __pyx_ptype_7pybroma_7PyBroma_MemberField) < 0) __PYX_ERR(0, 125, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_7pybroma_7PyBroma_MemberField) < 0) __PYX_ERR(0, 125, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_7pybroma_7PyBroma_OutOfLineField = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7pybroma_7PyBroma_OutOfLineField_spec, NULL); if (unlikely(!__pyx_ptype_7pybroma_7PyBroma_OutOfLineField)) __PYX_ERR(0, 154, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_7pybroma_7PyBroma_OutOfLineField_spec, __pyx_ptype_7pybroma_7PyBroma_OutOfLineField) < 0) __PYX_ERR(0, 154, __pyx_L1_error) + #else + __pyx_ptype_7pybroma_7PyBroma_OutOfLineField = &__pyx_type_7pybroma_7PyBroma_OutOfLineField; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_7pybroma_7PyBroma_OutOfLineField) < 0) __PYX_ERR(0, 154, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_7pybroma_7PyBroma_OutOfLineField->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_7pybroma_7PyBroma_OutOfLineField->tp_dictoffset && __pyx_ptype_7pybroma_7PyBroma_OutOfLineField->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_7pybroma_7PyBroma_OutOfLineField->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_OutOfLineField, (PyObject *) __pyx_ptype_7pybroma_7PyBroma_OutOfLineField) < 0) __PYX_ERR(0, 154, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_7pybroma_7PyBroma_OutOfLineField) < 0) __PYX_ERR(0, 154, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_7pybroma_7PyBroma_FunctionBindField = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7pybroma_7PyBroma_FunctionBindField_spec, NULL); if (unlikely(!__pyx_ptype_7pybroma_7PyBroma_FunctionBindField)) __PYX_ERR(0, 177, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_7pybroma_7PyBroma_FunctionBindField_spec, __pyx_ptype_7pybroma_7PyBroma_FunctionBindField) < 0) __PYX_ERR(0, 177, __pyx_L1_error) + #else + __pyx_ptype_7pybroma_7PyBroma_FunctionBindField = &__pyx_type_7pybroma_7PyBroma_FunctionBindField; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_7pybroma_7PyBroma_FunctionBindField) < 0) __PYX_ERR(0, 177, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_7pybroma_7PyBroma_FunctionBindField->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_7pybroma_7PyBroma_FunctionBindField->tp_dictoffset && __pyx_ptype_7pybroma_7PyBroma_FunctionBindField->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_7pybroma_7PyBroma_FunctionBindField->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_FunctionBindField, (PyObject *) __pyx_ptype_7pybroma_7PyBroma_FunctionBindField) < 0) __PYX_ERR(0, 177, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_7pybroma_7PyBroma_FunctionBindField) < 0) __PYX_ERR(0, 177, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_7pybroma_7PyBroma_PadField = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7pybroma_7PyBroma_PadField_spec, NULL); if (unlikely(!__pyx_ptype_7pybroma_7PyBroma_PadField)) __PYX_ERR(0, 197, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_7pybroma_7PyBroma_PadField_spec, __pyx_ptype_7pybroma_7PyBroma_PadField) < 0) __PYX_ERR(0, 197, __pyx_L1_error) + #else + __pyx_ptype_7pybroma_7PyBroma_PadField = &__pyx_type_7pybroma_7PyBroma_PadField; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_7pybroma_7PyBroma_PadField) < 0) __PYX_ERR(0, 197, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_7pybroma_7PyBroma_PadField->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_7pybroma_7PyBroma_PadField->tp_dictoffset && __pyx_ptype_7pybroma_7PyBroma_PadField->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_7pybroma_7PyBroma_PadField->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PadField, (PyObject *) __pyx_ptype_7pybroma_7PyBroma_PadField) < 0) __PYX_ERR(0, 197, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_7pybroma_7PyBroma_PadField) < 0) __PYX_ERR(0, 197, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_7pybroma_7PyBroma_Field = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7pybroma_7PyBroma_Field_spec, NULL); if (unlikely(!__pyx_ptype_7pybroma_7PyBroma_Field)) __PYX_ERR(0, 221, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_7pybroma_7PyBroma_Field_spec, __pyx_ptype_7pybroma_7PyBroma_Field) < 0) __PYX_ERR(0, 221, __pyx_L1_error) + #else + __pyx_ptype_7pybroma_7PyBroma_Field = &__pyx_type_7pybroma_7PyBroma_Field; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_7pybroma_7PyBroma_Field) < 0) __PYX_ERR(0, 221, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_7pybroma_7PyBroma_Field->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_7pybroma_7PyBroma_Field->tp_dictoffset && __pyx_ptype_7pybroma_7PyBroma_Field->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_7pybroma_7PyBroma_Field->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Field, (PyObject *) __pyx_ptype_7pybroma_7PyBroma_Field) < 0) __PYX_ERR(0, 221, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_7pybroma_7PyBroma_Field) < 0) __PYX_ERR(0, 221, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_7pybroma_7PyBroma_PlatformNumber = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7pybroma_7PyBroma_PlatformNumber_spec, NULL); if (unlikely(!__pyx_ptype_7pybroma_7PyBroma_PlatformNumber)) __PYX_ERR(0, 269, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_7pybroma_7PyBroma_PlatformNumber_spec, __pyx_ptype_7pybroma_7PyBroma_PlatformNumber) < 0) __PYX_ERR(0, 269, __pyx_L1_error) + #else + __pyx_ptype_7pybroma_7PyBroma_PlatformNumber = &__pyx_type_7pybroma_7PyBroma_PlatformNumber; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_7pybroma_7PyBroma_PlatformNumber) < 0) __PYX_ERR(0, 269, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_7pybroma_7PyBroma_PlatformNumber->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_7pybroma_7PyBroma_PlatformNumber->tp_dictoffset && __pyx_ptype_7pybroma_7PyBroma_PlatformNumber->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_7pybroma_7PyBroma_PlatformNumber->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PlatformNumber, (PyObject *) __pyx_ptype_7pybroma_7PyBroma_PlatformNumber) < 0) __PYX_ERR(0, 269, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_7pybroma_7PyBroma_PlatformNumber) < 0) __PYX_ERR(0, 269, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_7pybroma_7PyBroma_InlineField = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7pybroma_7PyBroma_InlineField_spec, NULL); if (unlikely(!__pyx_ptype_7pybroma_7PyBroma_InlineField)) __PYX_ERR(0, 305, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_7pybroma_7PyBroma_InlineField_spec, __pyx_ptype_7pybroma_7PyBroma_InlineField) < 0) __PYX_ERR(0, 305, __pyx_L1_error) + #else + __pyx_ptype_7pybroma_7PyBroma_InlineField = &__pyx_type_7pybroma_7PyBroma_InlineField; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_7pybroma_7PyBroma_InlineField) < 0) __PYX_ERR(0, 305, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_7pybroma_7PyBroma_InlineField->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_7pybroma_7PyBroma_InlineField->tp_dictoffset && __pyx_ptype_7pybroma_7PyBroma_InlineField->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_7pybroma_7PyBroma_InlineField->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_InlineField, (PyObject *) __pyx_ptype_7pybroma_7PyBroma_InlineField) < 0) __PYX_ERR(0, 305, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_7pybroma_7PyBroma_InlineField) < 0) __PYX_ERR(0, 305, __pyx_L1_error) + #endif + __pyx_vtabptr_7pybroma_7PyBroma_FunctionProto = &__pyx_vtable_7pybroma_7PyBroma_FunctionProto; + __pyx_vtable_7pybroma_7PyBroma_FunctionProto.init = (void (*)(struct __pyx_obj_7pybroma_7PyBroma_FunctionProto *, struct broma::FunctionProto))__pyx_f_7pybroma_7PyBroma_13FunctionProto_init; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_7pybroma_7PyBroma_FunctionProto = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7pybroma_7PyBroma_FunctionProto_spec, NULL); if (unlikely(!__pyx_ptype_7pybroma_7PyBroma_FunctionProto)) __PYX_ERR(0, 322, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_7pybroma_7PyBroma_FunctionProto_spec, __pyx_ptype_7pybroma_7PyBroma_FunctionProto) < 0) __PYX_ERR(0, 322, __pyx_L1_error) + #else + __pyx_ptype_7pybroma_7PyBroma_FunctionProto = &__pyx_type_7pybroma_7PyBroma_FunctionProto; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_7pybroma_7PyBroma_FunctionProto) < 0) __PYX_ERR(0, 322, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_7pybroma_7PyBroma_FunctionProto->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_7pybroma_7PyBroma_FunctionProto->tp_dictoffset && __pyx_ptype_7pybroma_7PyBroma_FunctionProto->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_7pybroma_7PyBroma_FunctionProto->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_ptype_7pybroma_7PyBroma_FunctionProto, __pyx_vtabptr_7pybroma_7PyBroma_FunctionProto) < 0) __PYX_ERR(0, 322, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_7pybroma_7PyBroma_FunctionProto) < 0) __PYX_ERR(0, 322, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_FunctionProto, (PyObject *) __pyx_ptype_7pybroma_7PyBroma_FunctionProto) < 0) __PYX_ERR(0, 322, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_7pybroma_7PyBroma_FunctionProto) < 0) __PYX_ERR(0, 322, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_7pybroma_7PyBroma_Function = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7pybroma_7PyBroma_Function_spec, NULL); if (unlikely(!__pyx_ptype_7pybroma_7PyBroma_Function)) __PYX_ERR(0, 366, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_7pybroma_7PyBroma_Function_spec, __pyx_ptype_7pybroma_7PyBroma_Function) < 0) __PYX_ERR(0, 366, __pyx_L1_error) + #else + __pyx_ptype_7pybroma_7PyBroma_Function = &__pyx_type_7pybroma_7PyBroma_Function; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_7pybroma_7PyBroma_Function) < 0) __PYX_ERR(0, 366, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_7pybroma_7PyBroma_Function->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_7pybroma_7PyBroma_Function->tp_dictoffset && __pyx_ptype_7pybroma_7PyBroma_Function->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_7pybroma_7PyBroma_Function->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Function, (PyObject *) __pyx_ptype_7pybroma_7PyBroma_Function) < 0) __PYX_ERR(0, 366, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_7pybroma_7PyBroma_Function) < 0) __PYX_ERR(0, 366, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_7pybroma_7PyBroma_Class = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7pybroma_7PyBroma_Class_spec, NULL); if (unlikely(!__pyx_ptype_7pybroma_7PyBroma_Class)) __PYX_ERR(0, 397, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_7pybroma_7PyBroma_Class_spec, __pyx_ptype_7pybroma_7PyBroma_Class) < 0) __PYX_ERR(0, 397, __pyx_L1_error) + #else + __pyx_ptype_7pybroma_7PyBroma_Class = &__pyx_type_7pybroma_7PyBroma_Class; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_7pybroma_7PyBroma_Class) < 0) __PYX_ERR(0, 397, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_7pybroma_7PyBroma_Class->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_7pybroma_7PyBroma_Class->tp_dictoffset && __pyx_ptype_7pybroma_7PyBroma_Class->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_7pybroma_7PyBroma_Class->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Class, (PyObject *) __pyx_ptype_7pybroma_7PyBroma_Class) < 0) __PYX_ERR(0, 397, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_7pybroma_7PyBroma_Class) < 0) __PYX_ERR(0, 397, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_7pybroma_7PyBroma_Root = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7pybroma_7PyBroma_Root_spec, NULL); if (unlikely(!__pyx_ptype_7pybroma_7PyBroma_Root)) __PYX_ERR(0, 468, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_7pybroma_7PyBroma_Root_spec, __pyx_ptype_7pybroma_7PyBroma_Root) < 0) __PYX_ERR(0, 468, __pyx_L1_error) + #else + __pyx_ptype_7pybroma_7PyBroma_Root = &__pyx_type_7pybroma_7PyBroma_Root; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_7pybroma_7PyBroma_Root) < 0) __PYX_ERR(0, 468, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_7pybroma_7PyBroma_Root->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_7pybroma_7PyBroma_Root->tp_dictoffset && __pyx_ptype_7pybroma_7PyBroma_Root->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_7pybroma_7PyBroma_Root->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Root, (PyObject *) __pyx_ptype_7pybroma_7PyBroma_Root) < 0) __PYX_ERR(0, 468, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_7pybroma_7PyBroma_Root) < 0) __PYX_ERR(0, 468, __pyx_L1_error) + #endif + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + + +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_PyBroma(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_PyBroma}, + {0, NULL} +}; +#endif + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "PyBroma", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #elif CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstate), /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ + #else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ + #endif + }; + #ifdef __cplusplus +} /* anonymous namespace */ +#endif +#endif + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyObject * +#endif +#endif + + +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initPyBroma(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initPyBroma(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_PyBroma(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_PyBroma(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + #if PY_VERSION_HEX >= 0x030700A1 + static PY_INT64_T main_interpreter_id = -1; + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return (unlikely(current_id == -1)) ? -1 : 0; + } else if (unlikely(main_interpreter_id != current_id)) + #else + static PyInterpreterState *main_interpreter = NULL; + PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; + if (!main_interpreter) { + main_interpreter = current_interpreter; + } else if (unlikely(main_interpreter != current_interpreter)) + #endif + { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) +#else +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) +#endif +{ + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { +#if CYTHON_COMPILING_IN_LIMITED_API + result = PyModule_AddObject(module, to_name, value); +#else + result = PyDict_SetItemString(moddict, to_name, value); +#endif + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); + if (__Pyx_check_single_interpreter()) + return NULL; + if (__pyx_m) + return __Pyx_NewRef(__pyx_m); + modname = PyObject_GetAttrString(spec, "name"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + moddict = module; +#else + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; +#endif + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static CYTHON_SMALL_CODE int __pyx_pymod_exec_PyBroma(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'PyBroma' has already been imported. Re-initialisation is not supported."); + return -1; + } + #elif PY_MAJOR_VERSION >= 3 + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("PyBroma", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #elif CYTHON_USE_MODULE_STATE + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + { + int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "PyBroma" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #endif + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if CYTHON_REFNANNY +__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); +if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); +} +#endif + __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_PyBroma(void)", 0); + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + PyEval_InitThreads(); + #endif + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + stringtab_initialized = 1; + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_pybroma__PyBroma) { + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "pybroma.PyBroma")) { + if (unlikely((PyDict_SetItemString(modules, "pybroma.PyBroma", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(); + (void)__Pyx_modinit_variable_export_code(); + (void)__Pyx_modinit_function_export_code(); + if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_type_import_code(); + (void)__Pyx_modinit_variable_import_code(); + (void)__Pyx_modinit_function_import_code(); + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_14ImmutableError_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ImmutableError___reduce_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__15)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7pybroma_7PyBroma_ImmutableError, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_7pybroma_7PyBroma_ImmutableError); + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_ImmutableError, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_ImmutableError__set_state(self, __pyx_state) + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_14ImmutableError_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ImmutableError___setstate_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__17)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7pybroma_7PyBroma_ImmutableError, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_7pybroma_7PyBroma_ImmutableError); + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_4Type_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Type___reduce_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__19)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_4Type_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Type___setstate_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__20)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_19MemberFunctionProto_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MemberFunctionProto___reduce_cyt, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__21)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_19MemberFunctionProto_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MemberFunctionProto___setstate_c, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__22)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_11MemberField_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MemberField___reduce_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__23)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_11MemberField_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_MemberField___setstate_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__24)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_14OutOfLineField_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_OutOfLineField___reduce_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__25)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_14OutOfLineField_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_OutOfLineField___setstate_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__26)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_17FunctionBindField_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FunctionBindField___reduce_cytho, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__27)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_17FunctionBindField_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FunctionBindField___setstate_cyt, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__28)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_8PadField_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PadField___reduce_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_8PadField_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PadField___setstate_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__30)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "pybroma/PyBroma.pyx":238 + * return self.field.parent + * + * def getAsFunctionBindField(self): # <<<<<<<<<<<<<< + * cdef broma.FunctionBindField* x = broma.Field_GetAs_FunctionBindField(&self.field) + * return make_FunctionBindField(DEPACK(x)) if x != nullptr else None + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_5Field_3getAsFunctionBindField, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Field_getAsFunctionBindField, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__32)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7pybroma_7PyBroma_Field, __pyx_n_s_getAsFunctionBindField, __pyx_t_2) < 0) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_7pybroma_7PyBroma_Field); + + /* "pybroma/PyBroma.pyx":242 + * return make_FunctionBindField(DEPACK(x)) if x != nullptr else None + * + * def getAsMemberField(self): # <<<<<<<<<<<<<< + * cdef broma.MemberField* x = broma.Field_GetAs_MemberField(&self.field) + * return make_MemberField(DEPACK(x)) if x != nullptr else None + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_5Field_5getAsMemberField, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Field_getAsMemberField, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__33)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7pybroma_7PyBroma_Field, __pyx_n_s_getAsMemberField, __pyx_t_2) < 0) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_7pybroma_7PyBroma_Field); + + /* "pybroma/PyBroma.pyx":246 + * return make_MemberField(DEPACK(x)) if x != nullptr else None + * + * def getAsOutOfLineField(self): # <<<<<<<<<<<<<< + * cdef broma.OutOfLineField* x = broma.Field_GetAs_OutOfLineField(&self.field) + * return make_OutOfLineField(DEPACK(x)) if x != nullptr else None + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_5Field_7getAsOutOfLineField, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Field_getAsOutOfLineField, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__34)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7pybroma_7PyBroma_Field, __pyx_n_s_getAsOutOfLineField, __pyx_t_2) < 0) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_7pybroma_7PyBroma_Field); + + /* "pybroma/PyBroma.pyx":250 + * return make_OutOfLineField(DEPACK(x)) if x != nullptr else None + * + * def getAsPadField(self): # <<<<<<<<<<<<<< + * cdef broma.PadField* x = broma.Field_GetAs_PadField(&self.field) + * return make_PadField(DEPACK(x)) if x != nullptr else None + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_5Field_9getAsPadField, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Field_getAsPadField, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__35)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7pybroma_7PyBroma_Field, __pyx_n_s_getAsPadField, __pyx_t_2) < 0) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_7pybroma_7PyBroma_Field); + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_5Field_11__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Field___reduce_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__36)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_5Field_13__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Field___setstate_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__37)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_14PlatformNumber_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PlatformNumber___reduce_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__38)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_14PlatformNumber_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PlatformNumber___setstate_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__39)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_11InlineField_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_InlineField___reduce_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__40)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_11InlineField_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_InlineField___setstate_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__41)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_13FunctionProto_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FunctionProto___reduce_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__42)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_13FunctionProto_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_FunctionProto___setstate_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__43)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self.func must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_8Function_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Function___reduce_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__44)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "Pickling of struct members such as self.func must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self.func must be explicitly requested with @auto_pickle(True)" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_8Function_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Function___setstate_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__45)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_5Class_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Class___reduce_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__46)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_5Class_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Class___setstate_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__47)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "pybroma/PyBroma.pyx":496 + * return [make_Function(x) for x in self.root.functions] + * + * def functionsAsDict(self) -> dict: # <<<<<<<<<<<<<< + * """Converts Functions to A Dictionary""" + * return {c.prototype.name: make_Function(c) for c in self.root.functions} + */ + __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_return, __pyx_n_s_dict_3) < 0) __PYX_ERR(0, 496, __pyx_L1_error) + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_4Root_5functionsAsDict, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Root_functionsAsDict, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__49)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7pybroma_7PyBroma_Root, __pyx_n_s_functionsAsDict, __pyx_t_3) < 0) __PYX_ERR(0, 496, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_7pybroma_7PyBroma_Root); + + /* "pybroma/PyBroma.pyx":500 + * return {c.prototype.name: make_Function(c) for c in self.root.functions} + * + * def classesAsDict(self) -> dict: # <<<<<<<<<<<<<< + * """Converts Classes to a dictionary""" + * return {c.name:make_Class(c) for c in self.root.classes} + */ + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 500, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_return, __pyx_n_s_dict_3) < 0) __PYX_ERR(0, 500, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_4Root_7classesAsDict, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Root_classesAsDict, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__50)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 500, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_2, __pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7pybroma_7PyBroma_Root, __pyx_n_s_classesAsDict, __pyx_t_2) < 0) __PYX_ERR(0, 500, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_7pybroma_7PyBroma_Root); + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self.root must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_4Root_9__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Root___reduce_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__51)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "Pickling of struct members such as self.root must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self.root must be explicitly requested with @auto_pickle(True)" + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_4Root_11__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Root___setstate_cython, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__52)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_ImmutableError(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7pybroma_7PyBroma_1__pyx_unpickle_ImmutableError, 0, __pyx_n_s_pyx_unpickle_ImmutableError, NULL, __pyx_n_s_pybroma_PyBroma, __pyx_d, ((PyObject *)__pyx_codeobj__54)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_ImmutableError, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "pybroma/PyBroma.pyx":1 + * # cython: language_level = 3 # <<<<<<<<<<<<<< + * # distutils: language = c++ + * # cython: c_string_type=unicode, c_string_encoding=utf8 + */ + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + if (__pyx_m) { + if (__pyx_d && stringtab_initialized) { + __Pyx_AddTraceback("init pybroma.PyBroma", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + #if !CYTHON_USE_MODULE_STATE + Py_CLEAR(__pyx_m); + #else + Py_DECREF(__pyx_m); + if (pystate_addmodule_run) { + PyObject *tp, *value, *tb; + PyErr_Fetch(&tp, &value, &tb); + PyState_RemoveModule(&__pyx_moduledef); + PyErr_Restore(tp, value, tb); + } + #endif + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init pybroma.PyBroma"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #elif PY_MAJOR_VERSION >= 3 + return __pyx_m; + #else + return; + #endif +} +/* #### Code section: cleanup_globals ### */ +/* #### Code section: cleanup_module ### */ +/* #### Code section: main_method ### */ +/* #### Code section: utility_code_pragmas ### */ +#ifdef _MSC_VER +#pragma warning( push ) +/* Warning 4127: conditional expression is constant + * Cython uses constant conditional expressions to allow in inline functions to be optimized at + * compile-time, so this warning is not useful + */ +#pragma warning( disable : 4127 ) +#endif + + + +/* #### Code section: utility_code_def ### */ + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; i= 0x030C00A6 + PyObject *current_exception = tstate->current_exception; + if (unlikely(!current_exception)) return 0; + exc_type = (PyObject*) Py_TYPE(current_exception); + if (exc_type == err) return 1; +#else + exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; +#endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(exc_type); + #endif + if (unlikely(PyTuple_Check(err))) { + result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + } else { + result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(exc_type); + #endif + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject *tmp_value; + assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + if (value) { + #if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) + #endif + PyException_SetTraceback(value, tb); + } + tmp_value = tstate->current_exception; + tstate->current_exception = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject* exc_value; + exc_value = tstate->current_exception; + tstate->current_exception = 0; + *value = exc_value; + *type = NULL; + *tb = NULL; + if (exc_value) { + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + #if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject*) exc_value)->traceback; + Py_XINCREF(*tb); + #else + *tb = PyException_GetTraceback(exc_value); + #endif + } +#else + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#endif +} +#endif + +/* PyObjectGetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +#endif +} + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* DictGetItem */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + if (unlikely(PyTuple_Check(key))) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) { + PyErr_SetObject(PyExc_KeyError, args); + Py_DECREF(args); + } + } else { + PyErr_SetObject(PyExc_KeyError, key); + } + } + return NULL; + } + Py_INCREF(value); + return value; +} +#endif + +/* GetTopmostException */ +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; + } + return exc_info; +} +#endif + +/* SaveResetException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + PyObject *exc_value = exc_info->exc_value; + if (exc_value == NULL || exc_value == Py_None) { + *value = NULL; + *type = NULL; + *tb = NULL; + } else { + *value = exc_value; + Py_INCREF(*value); + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + *tb = PyException_GetTraceback(exc_value); + } + #elif CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); + #endif +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + PyObject *tmp_value = exc_info->exc_value; + exc_info->exc_value = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); + #else + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); + #endif +} +#endif + +/* GetException */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) +#endif +{ + PyObject *local_type = NULL, *local_value, *local_tb = NULL; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if PY_VERSION_HEX >= 0x030C00A6 + local_value = tstate->current_exception; + tstate->current_exception = 0; + if (likely(local_value)) { + local_type = (PyObject*) Py_TYPE(local_value); + Py_INCREF(local_type); + local_tb = PyException_GetTraceback(local_value); + } + #else + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + #endif +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6 + if (unlikely(tstate->current_exception)) +#elif CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + #if PY_VERSION_HEX >= 0x030B00a4 + tmp_value = exc_info->exc_value; + exc_info->exc_value = local_value; + tmp_type = NULL; + tmp_tb = NULL; + Py_XDECREF(local_type); + Py_XDECREF(local_tb); + #else + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + #endif + } + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +} + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = Py_TYPE(func)->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* RaiseException */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + __Pyx_PyThreadState_declare + CYTHON_UNUSED_VAR(cause); + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { + #if PY_VERSION_HEX >= 0x030C00A6 + PyException_SetTraceback(value, tb); + #elif CYTHON_FAST_THREAD_STATE + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +/* TupleAndListFromArray */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { + PyObject *v; + Py_ssize_t i; + for (i = 0; i < length; i++) { + v = dest[i] = src[i]; + Py_INCREF(v); + } +} +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + Py_INCREF(__pyx_empty_tuple); + return __pyx_empty_tuple; + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); + return res; +} +static CYTHON_INLINE PyObject * +__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return PyList_New(0); + } + res = PyList_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); + return res; +} +#endif + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + return PyObject_RichCompareBool(s1, s2, equals); +#else +#if PY_MAJOR_VERSION < 3 + PyObject* owned_ref = NULL; +#endif + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); +#if PY_MAJOR_VERSION < 3 + if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { + owned_ref = PyUnicode_FromObject(s2); + if (unlikely(!owned_ref)) + return -1; + s2 = owned_ref; + s2_is_unicode = 1; + } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { + owned_ref = PyUnicode_FromObject(s1); + if (unlikely(!owned_ref)) + return -1; + s1 = owned_ref; + s1_is_unicode = 1; + } else if (((!s2_is_unicode) & (!s1_is_unicode))) { + return __Pyx_PyBytes_Equals(s1, s2, equals); + } +#endif + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length; + int kind; + void *data1, *data2; + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + length = __Pyx_PyUnicode_GET_LENGTH(s1); + if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + #if CYTHON_PEP393_ENABLED + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + #else + hash1 = ((PyUnicodeObject*)s1)->hash; + hash2 = ((PyUnicodeObject*)s2)->hash; + #endif + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ); +return_ne: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_NE); +#endif +} + +/* fastcall */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); + for (i = 0; i < n; i++) + { + if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ); + if (unlikely(eq != 0)) { + if (unlikely(eq < 0)) return NULL; + return kwvalues[i]; + } + } + return NULL; +} +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); + PyObject *dict; + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; i= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject *const *kwvalues, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); + while (1) { + Py_XDECREF(key); key = NULL; + Py_XDECREF(value); value = NULL; + if (kwds_is_tuple) { + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(kwds); +#else + size = PyTuple_Size(kwds); + if (size < 0) goto bad; +#endif + if (pos >= size) break; +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); + if (!key) goto bad; +#elif CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kwds, pos); +#else + key = PyTuple_GetItem(kwds, pos); + if (!key) goto bad; +#endif + value = kwvalues[pos]; + pos++; + } + else + { + if (!PyDict_Next(kwds, &pos, &key, &value)) break; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + } + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(value); + Py_DECREF(key); +#endif + key = NULL; + value = NULL; + continue; + } +#if !CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + Py_INCREF(value); + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = ( + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key) + ); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + Py_XDECREF(key); + Py_XDECREF(value); + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + Py_XDECREF(key); + Py_XDECREF(value); + return -1; +} + +/* RaiseArgTupleInvalid */ +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + __Pyx_TypeName type_name; + __Pyx_TypeName obj_type_name; + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (exact) { + #if PY_MAJOR_VERSION == 2 + if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } + type_name = __Pyx_PyType_GetName(type); + obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME + ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name); + __Pyx_DECREF_TypeName(type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return 0; +} + +/* PyFunctionFastCall */ +#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { + return NULL; + } + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { + return NULL; + } + #endif + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif + +/* PyObjectCallMethO */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectFastCall */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) { + PyObject *argstuple; + PyObject *result = 0; + size_t i; + argstuple = PyTuple_New((Py_ssize_t)nargs); + if (unlikely(!argstuple)) return NULL; + for (i = 0; i < nargs; i++) { + Py_INCREF(args[i]); + if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad; + } + result = __Pyx_PyObject_Call(func, argstuple, kwargs); + bad: + Py_DECREF(argstuple); + return result; +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) { + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); +#if CYTHON_COMPILING_IN_CPYTHON + if (nargs == 0 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) + return __Pyx_PyObject_CallMethO(func, NULL); + } + else if (nargs == 1 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) + return __Pyx_PyObject_CallMethO(func, args[0]); + } +#endif + #if PY_VERSION_HEX < 0x030800B1 + #if CYTHON_FAST_PYCCALL + if (PyCFunction_Check(func)) { + if (kwargs) { + return _PyCFunction_FastCallDict(func, args, nargs, kwargs); + } else { + return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); + } + } + #if PY_VERSION_HEX >= 0x030700A1 + if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { + return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); + } + #endif + #endif + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); + } + #endif + #endif + if (kwargs == NULL) { + #if CYTHON_VECTORCALL + #if PY_VERSION_HEX < 0x03090000 + vectorcallfunc f = _PyVectorcall_Function(func); + #else + vectorcallfunc f = PyVectorcall_Function(func); + #endif + if (f) { + return f(func, args, (size_t)nargs, NULL); + } + #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL + if (__Pyx_CyFunction_CheckExact(func)) { + __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); + if (f) return f(func, args, (size_t)nargs, NULL); + } + #endif + } + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs); + } + #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API + return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); + #else + return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); + #endif +} + +/* KeywordStringCheck */ +static int __Pyx_CheckKeywordStrings( + PyObject *kw, + const char* function_name, + int kw_allowed) +{ + PyObject* key = 0; + Py_ssize_t pos = 0; +#if CYTHON_COMPILING_IN_PYPY + if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0)) + goto invalid_keyword; + return 1; +#else + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) { + Py_ssize_t kwsize; +#if CYTHON_ASSUME_SAFE_MACROS + kwsize = PyTuple_GET_SIZE(kw); +#else + kwsize = PyTuple_Size(kw); + if (kwsize < 0) return 0; +#endif + if (unlikely(kwsize == 0)) + return 1; + if (!kw_allowed) { +#if CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kw, 0); +#else + key = PyTuple_GetItem(kw, pos); + if (!key) return 0; +#endif + goto invalid_keyword; + } +#if PY_VERSION_HEX < 0x03090000 + for (pos = 0; pos < kwsize; pos++) { +#if CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kw, pos); +#else + key = PyTuple_GetItem(kw, pos); + if (!key) return 0; +#endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } +#endif + return 1; + } + while (PyDict_Next(kw, &pos, &key, 0)) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(!PyString_Check(key))) + #endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } + if (!kw_allowed && unlikely(key)) + goto invalid_keyword; + return 1; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + return 0; +#endif +invalid_keyword: + #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif + return 0; +} + +/* GetAttr3 */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +static PyObject *__Pyx_GetAttr3Default(PyObject *d) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + return NULL; + __Pyx_PyErr_Clear(); + Py_INCREF(d); + return d; +} +#endif +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { + PyObject *r; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + int res = PyObject_GetOptionalAttr(o, n, &r); + return (res != 0) ? r : __Pyx_NewRef(d); +#else + #if CYTHON_USE_TYPE_SLOTS + if (likely(PyString_Check(n))) { + r = __Pyx_PyObject_GetAttrStrNoError(o, n); + if (unlikely(!r) && likely(!PyErr_Occurred())) { + r = __Pyx_NewRef(d); + } + return r; + } + #endif + r = PyObject_GetAttr(o, n); + return (likely(r)) ? r : __Pyx_GetAttr3Default(d); +#endif +} + +/* PyDictVersioning */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif + } + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); +} +#endif + +/* GetModuleGlobalName */ +#if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000 + result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } else if (unlikely(PyErr_Occurred())) { + return NULL; + } +#elif CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!__pyx_m)) { + return NULL; + } + result = PyObject_GetAttr(__pyx_m, name); + if (likely(result)) { + return result; + } +#else + result = PyDict_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } +#endif +#else + result = PyObject_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + +/* RaiseUnexpectedTypeError */ +static int +__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) +{ + __Pyx_TypeName obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME, + expected, obj_type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return 0; +} + +/* PyObjectCallOneArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *args[2] = {NULL, arg}; + return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* PyObjectCallNoArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { + PyObject *arg[2] = {NULL, NULL}; + return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* WriteUnraisableException */ +static void __Pyx_WriteUnraisable(const char *name, int clineno, + int lineno, const char *filename, + int full_traceback, int nogil) { + PyObject *old_exc, *old_val, *old_tb; + PyObject *ctx; + __Pyx_PyThreadState_declare +#ifdef WITH_THREAD + PyGILState_STATE state; + if (nogil) + state = PyGILState_Ensure(); + else state = (PyGILState_STATE)0; +#endif + CYTHON_UNUSED_VAR(clineno); + CYTHON_UNUSED_VAR(lineno); + CYTHON_UNUSED_VAR(filename); + CYTHON_MAYBE_UNUSED_VAR(nogil); + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); + if (full_traceback) { + Py_XINCREF(old_exc); + Py_XINCREF(old_val); + Py_XINCREF(old_tb); + __Pyx_ErrRestore(old_exc, old_val, old_tb); + PyErr_PrintEx(1); + } + #if PY_MAJOR_VERSION < 3 + ctx = PyString_FromString(name); + #else + ctx = PyUnicode_FromString(name); + #endif + __Pyx_ErrRestore(old_exc, old_val, old_tb); + if (!ctx) { + PyErr_WriteUnraisable(Py_None); + } else { + PyErr_WriteUnraisable(ctx); + Py_DECREF(ctx); + } +#ifdef WITH_THREAD + if (nogil) + PyGILState_Release(state); +#endif +} + +/* Import */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *module = 0; + PyObject *empty_dict = 0; + PyObject *empty_list = 0; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (unlikely(!py_import)) + goto bad; + if (!from_list) { + empty_list = PyList_New(0); + if (unlikely(!empty_list)) + goto bad; + from_list = empty_list; + } + #endif + empty_dict = PyDict_New(); + if (unlikely(!empty_dict)) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.') != NULL) { + module = PyImport_ImportModuleLevelObject( + name, __pyx_d, empty_dict, from_list, 1); + if (unlikely(!module)) { + if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_MAJOR_VERSION < 3 + PyObject *py_level = PyInt_FromLong(level); + if (unlikely(!py_level)) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, __pyx_d, empty_dict, from_list, level); + #endif + } + } +bad: + Py_XDECREF(empty_dict); + Py_XDECREF(empty_list); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + return module; +} + +/* ImportFrom */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + const char* module_name_str = 0; + PyObject* module_name = 0; + PyObject* module_dot = 0; + PyObject* full_name = 0; + PyErr_Clear(); + module_name_str = PyModule_GetName(module); + if (unlikely(!module_name_str)) { goto modbad; } + module_name = PyUnicode_FromString(module_name_str); + if (unlikely(!module_name)) { goto modbad; } + module_dot = PyUnicode_Concat(module_name, __pyx_kp_u__12); + if (unlikely(!module_dot)) { goto modbad; } + full_name = PyUnicode_Concat(module_dot, name); + if (unlikely(!full_name)) { goto modbad; } + #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) + { + PyObject *modules = PyImport_GetModuleDict(); + if (unlikely(!modules)) + goto modbad; + value = PyObject_GetItem(modules, full_name); + } + #else + value = PyImport_GetModule(full_name); + #endif + modbad: + Py_XDECREF(full_name); + Py_XDECREF(module_dot); + Py_XDECREF(module_name); + } + if (unlikely(!value)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +/* GetAttr */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { +#if CYTHON_USE_TYPE_SLOTS +#if PY_MAJOR_VERSION >= 3 + if (likely(PyUnicode_Check(n))) +#else + if (likely(PyString_Check(n))) +#endif + return __Pyx_PyObject_GetAttrStr(o, n); +#endif + return PyObject_GetAttr(o, n); +} + +/* HasAttr */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { + PyObject *r; + if (unlikely(!__Pyx_PyBaseString_Check(n))) { + PyErr_SetString(PyExc_TypeError, + "hasattr(): attribute name must be string"); + return -1; + } + r = __Pyx_GetAttr(o, n); + if (!r) { + PyErr_Clear(); + return 0; + } else { + Py_DECREF(r); + return 1; + } +} +#endif + +/* GetItemInt */ +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (unlikely(!j)) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; + PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; + if (mm && mm->mp_subscript) { + PyObject *r, *key = PyInt_FromSsize_t(i); + if (unlikely(!key)) return NULL; + r = mm->mp_subscript(o, key); + Py_DECREF(key); + return r; + } + if (likely(sm && sm->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { + Py_ssize_t l = sm->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return sm->sq_item(o, i); + } + } +#else + if (is_list || !PyMapping_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +/* FixUpExtensionType */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { +#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); +#else + const PyType_Slot *slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { + int changed = 0; +#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) + const +#endif + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { +#if PY_VERSION_HEX < 0x030900b1 + if (strcmp(memb->name, "__weaklistoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_weaklistoffset = memb->offset; + changed = 1; + } + else if (strcmp(memb->name, "__dictoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_dictoffset = memb->offset; + changed = 1; + } +#if CYTHON_METH_FASTCALL + else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); +#if PY_VERSION_HEX >= 0x030800b4 + type->tp_vectorcall_offset = memb->offset; +#else + type->tp_print = (printfunc) memb->offset; +#endif + changed = 1; + } +#endif +#else + if ((0)); +#endif +#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON + else if (strcmp(memb->name, "__module__") == 0) { + PyObject *descr; + assert(memb->type == T_OBJECT); + assert(memb->flags == 0 || memb->flags == READONLY); + descr = PyDescr_NewMember(type, memb); + if (unlikely(!descr)) + return -1; + if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { + Py_DECREF(descr); + return -1; + } + Py_DECREF(descr); + changed = 1; + } +#endif + } + memb++; + } + if (changed) + PyType_Modified(type); + } +#endif + return 0; +} +#endif + +/* FormatTypeName */ +#if CYTHON_COMPILING_IN_LIMITED_API +static __Pyx_TypeName +__Pyx_PyType_GetName(PyTypeObject* tp) +{ + PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_n_s_name_2); + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { + PyErr_Clear(); + Py_XDECREF(name); + name = __Pyx_NewRef(__pyx_n_s__13); + } + return name; +} +#endif + +/* ValidateExternBase */ +static int __Pyx_validate_extern_base(PyTypeObject *base) { + Py_ssize_t itemsize; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_itemsize; +#endif +#if !CYTHON_COMPILING_IN_LIMITED_API + itemsize = ((PyTypeObject *)base)->tp_itemsize; +#else + py_itemsize = PyObject_GetAttrString((PyObject*)base, "__itemsize__"); + if (!py_itemsize) + return -1; + itemsize = PyLong_AsSsize_t(py_itemsize); + Py_DECREF(py_itemsize); + py_itemsize = 0; + if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred()) + return -1; +#endif + if (itemsize) { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(base); + PyErr_Format(PyExc_TypeError, + "inheritance from PyVarObject types like '" __Pyx_FMT_TYPENAME "' not currently supported", b_name); + __Pyx_DECREF_TypeName(b_name); + return -1; + } + return 0; +} + +/* PyObjectGetMethod */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { + PyObject *attr; +#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP + __Pyx_TypeName type_name; + PyTypeObject *tp = Py_TYPE(obj); + PyObject *descr; + descrgetfunc f = NULL; + PyObject **dictptr, *dict; + int meth_found = 0; + assert (*method == NULL); + if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; + } + if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { + return 0; + } + descr = _PyType_Lookup(tp, name); + if (likely(descr != NULL)) { + Py_INCREF(descr); +#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR + if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) +#elif PY_MAJOR_VERSION >= 3 + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) + #endif +#else + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr))) + #endif +#endif + { + meth_found = 1; + } else { + f = Py_TYPE(descr)->tp_descr_get; + if (f != NULL && PyDescr_IsData(descr)) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + } + } + dictptr = _PyObject_GetDictPtr(obj); + if (dictptr != NULL && (dict = *dictptr) != NULL) { + Py_INCREF(dict); + attr = __Pyx_PyDict_GetItemStr(dict, name); + if (attr != NULL) { + Py_INCREF(attr); + Py_DECREF(dict); + Py_XDECREF(descr); + goto try_unpack; + } + Py_DECREF(dict); + } + if (meth_found) { + *method = descr; + return 1; + } + if (f != NULL) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + if (likely(descr != NULL)) { + *method = descr; + return 0; + } + type_name = __Pyx_PyType_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); +#else + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(name)); +#endif + __Pyx_DECREF_TypeName(type_name); + return 0; +#else + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; +#endif +try_unpack: +#if CYTHON_UNPACK_METHODS + if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { + PyObject *function = PyMethod_GET_FUNCTION(attr); + Py_INCREF(function); + Py_DECREF(attr); + *method = function; + return 1; + } +#endif + *method = attr; + return 0; +} + +/* PyObjectCallMethod0 */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { + PyObject *method = NULL, *result = NULL; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_CallOneArg(method, obj); + Py_DECREF(method); + return result; + } + if (unlikely(!method)) goto bad; + result = __Pyx_PyObject_CallNoArg(method); + Py_DECREF(method); +bad: + return result; +} + +/* ValidateBasesTuple */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { + Py_ssize_t i, n; +#if CYTHON_ASSUME_SAFE_MACROS + n = PyTuple_GET_SIZE(bases); +#else + n = PyTuple_Size(bases); + if (n < 0) return -1; +#endif + for (i = 1; i < n; i++) + { +#if CYTHON_AVOID_BORROWED_REFS + PyObject *b0 = PySequence_GetItem(bases, i); + if (!b0) return -1; +#elif CYTHON_ASSUME_SAFE_MACROS + PyObject *b0 = PyTuple_GET_ITEM(bases, i); +#else + PyObject *b0 = PyTuple_GetItem(bases, i); + if (!b0) return -1; +#endif + PyTypeObject *b; +#if PY_MAJOR_VERSION < 3 + if (PyClass_Check(b0)) + { + PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", + PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } +#endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); + PyErr_Format(PyExc_TypeError, + "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); + __Pyx_DECREF_TypeName(b_name); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + if (dictoffset == 0) + { + Py_ssize_t b_dictoffset = 0; +#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + b_dictoffset = b->tp_dictoffset; +#else + PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); + if (!py_b_dictoffset) goto dictoffset_return; + b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); + Py_DECREF(py_b_dictoffset); + if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; +#endif + if (b_dictoffset) { + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); + PyErr_Format(PyExc_TypeError, + "extension type '%.200s' has no __dict__ slot, " + "but base type '" __Pyx_FMT_TYPENAME "' has: " + "either add 'cdef dict __dict__' to the extension type " + "or add '__slots__ = [...]' to the base type", + type_name, b_name); + __Pyx_DECREF_TypeName(b_name); + } +#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY) + dictoffset_return: +#endif +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + } +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + } + return 0; +} +#endif + +/* PyType_Ready */ +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION) + (void)__Pyx_PyObject_CallMethod0; +#if CYTHON_USE_TYPE_SPECS + (void)__Pyx_validate_bases_tuple; +#endif + return PyType_Ready(t); +#else + int r; + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) + return -1; +#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) + { + int gc_was_enabled; + #if PY_VERSION_HEX >= 0x030A00b1 + gc_was_enabled = PyGC_Disable(); + (void)__Pyx_PyObject_CallMethod0; + #else + PyObject *ret, *py_status; + PyObject *gc = NULL; + #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) + gc = PyImport_GetModule(__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled); + if (unlikely(!py_status)) { + Py_DECREF(gc); + return -1; + } + gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); + Py_DECREF(py_status); + if (gc_was_enabled > 0) { + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable); + if (unlikely(!ret)) { + Py_DECREF(gc); + return -1; + } + Py_DECREF(ret); + } else if (unlikely(gc_was_enabled == -1)) { + Py_DECREF(gc); + return -1; + } + #endif + t->tp_flags |= Py_TPFLAGS_HEAPTYPE; +#if PY_VERSION_HEX >= 0x030A0000 + t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; +#endif +#else + (void)__Pyx_PyObject_CallMethod0; +#endif + r = PyType_Ready(t); +#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) + t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; + #if PY_VERSION_HEX >= 0x030A00b1 + if (gc_was_enabled) + PyGC_Enable(); + #else + if (gc_was_enabled) { + PyObject *tp, *v, *tb; + PyErr_Fetch(&tp, &v, &tb); + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable); + if (likely(ret || r == -1)) { + Py_XDECREF(ret); + PyErr_Restore(tp, v, tb); + } else { + Py_XDECREF(tp); + Py_XDECREF(v); + Py_XDECREF(tb); + r = -1; + } + } + Py_DECREF(gc); + #endif + } +#endif + return r; +#endif +} + +/* PyObject_GenericGetAttrNoDict */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, attr_name); +#else + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(attr_name)); +#endif + __Pyx_DECREF_TypeName(type_name); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { + PyObject *descr; + PyTypeObject *tp = Py_TYPE(obj); + if (unlikely(!PyString_Check(attr_name))) { + return PyObject_GenericGetAttr(obj, attr_name); + } + assert(!tp->tp_dictoffset); + descr = _PyType_Lookup(tp, attr_name); + if (unlikely(!descr)) { + return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); + } + Py_INCREF(descr); + #if PY_MAJOR_VERSION < 3 + if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) + #endif + { + descrgetfunc f = Py_TYPE(descr)->tp_descr_get; + if (unlikely(f)) { + PyObject *res = f(descr, obj, (PyObject *)tp); + Py_DECREF(descr); + return res; + } + } + return descr; +} +#endif + +/* PyObject_GenericGetAttr */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { + if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { + return PyObject_GenericGetAttr(obj, attr_name); + } + return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); +} +#endif + +/* SetupReduce */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name_2); + if (likely(name_attr)) { + ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); + } else { + ret = -1; + } + if (unlikely(ret < 0)) { + PyErr_Clear(); + ret = 0; + } + Py_XDECREF(name_attr); + return ret; +} +static int __Pyx_setup_reduce(PyObject* type_obj) { + int ret = 0; + PyObject *object_reduce = NULL; + PyObject *object_getstate = NULL; + PyObject *object_reduce_ex = NULL; + PyObject *reduce = NULL; + PyObject *reduce_ex = NULL; + PyObject *reduce_cython = NULL; + PyObject *setstate = NULL; + PyObject *setstate_cython = NULL; + PyObject *getstate = NULL; +#if CYTHON_USE_PYTYPE_LOOKUP + getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); +#else + getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); + if (!getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (getstate) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); +#else + object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); + if (!object_getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (object_getstate != getstate) { + goto __PYX_GOOD; + } + } +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#else + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#endif + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; + if (reduce_ex == object_reduce_ex) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#else + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#endif + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; + if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { + reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); + if (likely(reduce_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (reduce == object_reduce || PyErr_Occurred()) { + goto __PYX_BAD; + } + setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate); + if (!setstate) PyErr_Clear(); + if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { + setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); + if (likely(setstate_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (!setstate || PyErr_Occurred()) { + goto __PYX_BAD; + } + } + PyType_Modified((PyTypeObject*)type_obj); + } + } + goto __PYX_GOOD; +__PYX_BAD: + if (!PyErr_Occurred()) { + __Pyx_TypeName type_obj_name = + __Pyx_PyType_GetName((PyTypeObject*)type_obj); + PyErr_Format(PyExc_RuntimeError, + "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); + __Pyx_DECREF_TypeName(type_obj_name); + } + ret = -1; +__PYX_GOOD: +#if !CYTHON_USE_PYTYPE_LOOKUP + Py_XDECREF(object_reduce); + Py_XDECREF(object_reduce_ex); + Py_XDECREF(object_getstate); + Py_XDECREF(getstate); +#endif + Py_XDECREF(reduce); + Py_XDECREF(reduce_ex); + Py_XDECREF(reduce_cython); + Py_XDECREF(setstate); + Py_XDECREF(setstate_cython); + return ret; +} +#endif + +/* SetVTable */ +static int __Pyx_SetVtable(PyTypeObject *type, void *vtable) { + PyObject *ob = PyCapsule_New(vtable, 0, 0); + if (unlikely(!ob)) + goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(PyObject_SetAttr((PyObject *) type, __pyx_n_s_pyx_vtable, ob) < 0)) +#else + if (unlikely(PyDict_SetItem(type->tp_dict, __pyx_n_s_pyx_vtable, ob) < 0)) +#endif + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +/* GetVTable */ +static void* __Pyx_GetVtable(PyTypeObject *type) { + void* ptr; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_n_s_pyx_vtable); +#else + PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_n_s_pyx_vtable); +#endif + if (!ob) + goto bad; + ptr = PyCapsule_GetPointer(ob, 0); + if (!ptr && !PyErr_Occurred()) + PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); + Py_DECREF(ob); + return ptr; +bad: + Py_XDECREF(ob); + return NULL; +} + +/* MergeVTables */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_MergeVtables(PyTypeObject *type) { + int i; + void** base_vtables; + __Pyx_TypeName tp_base_name; + __Pyx_TypeName base_name; + void* unknown = (void*)-1; + PyObject* bases = type->tp_bases; + int base_depth = 0; + { + PyTypeObject* base = type->tp_base; + while (base) { + base_depth += 1; + base = base->tp_base; + } + } + base_vtables = (void**) malloc(sizeof(void*) * (size_t)(base_depth + 1)); + base_vtables[0] = unknown; + for (i = 1; i < PyTuple_GET_SIZE(bases); i++) { + void* base_vtable = __Pyx_GetVtable(((PyTypeObject*)PyTuple_GET_ITEM(bases, i))); + if (base_vtable != NULL) { + int j; + PyTypeObject* base = type->tp_base; + for (j = 0; j < base_depth; j++) { + if (base_vtables[j] == unknown) { + base_vtables[j] = __Pyx_GetVtable(base); + base_vtables[j + 1] = unknown; + } + if (base_vtables[j] == base_vtable) { + break; + } else if (base_vtables[j] == NULL) { + goto bad; + } + base = base->tp_base; + } + } + } + PyErr_Clear(); + free(base_vtables); + return 0; +bad: + tp_base_name = __Pyx_PyType_GetName(type->tp_base); + base_name = __Pyx_PyType_GetName((PyTypeObject*)PyTuple_GET_ITEM(bases, i)); + PyErr_Format(PyExc_TypeError, + "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base_name, base_name); + __Pyx_DECREF_TypeName(tp_base_name); + __Pyx_DECREF_TypeName(base_name); + free(base_vtables); + return -1; +} +#endif + +/* FetchSharedCythonModule */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void) { + return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); +} + +/* FetchCommonType */ +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t basicsize, + Py_ssize_t expected_basicsize) { + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; + } + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; +} +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* abi_module; + const char* object_name; + PyTypeObject *cached_type = NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + object_name = strrchr(type->tp_name, '.'); + object_name = object_name ? object_name+1 : type->tp_name; + cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + if (__Pyx_VerifyCachedType( + (PyObject *)cached_type, + object_name, + cached_type->tp_basicsize, + type->tp_basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; +done: + Py_DECREF(abi_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} +#else +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module, *cached_type = NULL; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + cached_type = PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + Py_ssize_t basicsize; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; +#else + basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; +#endif + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + basicsize, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + CYTHON_UNUSED_VAR(module); + cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases); + if (unlikely(!cached_type)) goto bad; + if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; +done: + Py_DECREF(abi_module); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} +#endif + +/* PyVectorcallFastCallDict */ +#if CYTHON_METH_FASTCALL +static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + PyObject *res = NULL; + PyObject *kwnames; + PyObject **newargs; + PyObject **kwvalues; + Py_ssize_t i, pos; + size_t j; + PyObject *key, *value; + unsigned long keys_are_strings; + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); + if (unlikely(newargs == NULL)) { + PyErr_NoMemory(); + return NULL; + } + for (j = 0; j < nargs; j++) newargs[j] = args[j]; + kwnames = PyTuple_New(nkw); + if (unlikely(kwnames == NULL)) { + PyMem_Free(newargs); + return NULL; + } + kwvalues = newargs + nargs; + pos = i = 0; + keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; + while (PyDict_Next(kw, &pos, &key, &value)) { + keys_are_strings &= Py_TYPE(key)->tp_flags; + Py_INCREF(key); + Py_INCREF(value); + PyTuple_SET_ITEM(kwnames, i, key); + kwvalues[i] = value; + i++; + } + if (unlikely(!keys_are_strings)) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + goto cleanup; + } + res = vc(func, newargs, nargs, kwnames); +cleanup: + Py_DECREF(kwnames); + for (i = 0; i < nkw; i++) + Py_DECREF(kwvalues[i]); + PyMem_Free(newargs); + return res; +} +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { + return vc(func, args, nargs, NULL); + } + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); +} +#endif + +/* CythonFunctionShared */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + if (__Pyx_CyFunction_Check(func)) { + return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; + } else if (PyCFunction_Check(func)) { + return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; + } + return 0; +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +} +#endif +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + __Pyx_Py_XDECREF_SET( + __Pyx_CyFunction_GetClassObj(f), + ((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#else + __Pyx_Py_XDECREF_SET( + ((PyCMethodObject *) (f))->mm_class, + (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#endif +} +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) +{ + CYTHON_UNUSED_VAR(closure); + if (unlikely(op->func_doc == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); + if (unlikely(!op->func_doc)) return NULL; +#else + if (((PyCFunctionObject*)op)->m_ml->ml_doc) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#endif + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } +#endif + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_doc, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); +#elif PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#else + op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_name, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_qualname); + return op->func_qualname; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; + } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_dict, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(op); + CYTHON_UNUSED_VAR(context); + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + CYTHON_UNUSED_VAR(context); + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_tuple; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_kwdict; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value || value == Py_None) { + value = NULL; + } else if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + __Pyx_Py_XDECREF_SET(op->func_annotations, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->func_annotations; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + int is_coroutine; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; +#if PY_VERSION_HEX >= 0x03050000 + if (is_coroutine) { + PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine; + fromlist = PyList_New(1); + if (unlikely(!fromlist)) return NULL; + Py_INCREF(marker); +#if CYTHON_ASSUME_SAFE_MACROS + PyList_SET_ITEM(fromlist, 0, marker); +#else + if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { + Py_DECREF(marker); + Py_DECREF(fromlist); + return NULL; + } +#endif + module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(op->func_is_coroutine)) { + return __Pyx_NewRef(op->func_is_coroutine); + } +ignore: + PyErr_Clear(); + } +#endif + op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); + return __Pyx_NewRef(op->func_is_coroutine); +} +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject * +__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_GetAttrString(op->func, "__module__"); +} +static int +__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_SetAttrString(op->func, "__module__", value); +} +#endif +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API + {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, +#endif + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif +#if CYTHON_USE_TYPE_SPECS + {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#if CYTHON_METH_FASTCALL +#if CYTHON_BACKPORT_VECTORCALL + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, +#else +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, +#endif +#endif +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#else + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, +#endif +#endif + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) +{ + CYTHON_UNUSED_VAR(args); +#if PY_MAJOR_VERSION >= 3 + Py_INCREF(m->func_qualname); + return m->func_qualname; +#else + return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); +#endif +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { +#if !CYTHON_COMPILING_IN_LIMITED_API + PyCFunctionObject *cf = (PyCFunctionObject*) op; +#endif + if (unlikely(op == NULL)) + return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); + if (unlikely(!op->func)) return NULL; +#endif + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; +#if !CYTHON_COMPILING_IN_LIMITED_API + cf->m_ml = ml; + cf->m_self = (PyObject *) op; +#endif + Py_XINCREF(closure); + op->func_closure = closure; +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_XINCREF(module); + cf->m_module = module; +#endif + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + op->func_classobj = NULL; +#else + ((PyCMethodObject*)op)->mm_class = NULL; +#endif + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults_pyobjects = 0; + op->defaults_size = 0; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + op->func_is_coroutine = NULL; +#if CYTHON_METH_FASTCALL + switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { + case METH_NOARGS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; + break; + case METH_O: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; + break; + case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; + break; + case METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; + break; + case METH_VARARGS | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = NULL; + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + Py_DECREF(op); + return NULL; + } +#endif + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func); +#else + Py_CLEAR(((PyCFunctionObject*)m)->m_module); +#endif + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API +#if PY_VERSION_HEX < 0x030900B1 + Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); +#else + { + PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; + ((PyCMethodObject *) (m))->mm_class = NULL; + Py_XDECREF(cls); + } +#endif +#endif + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + Py_CLEAR(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyObject_Free(m->defaults); + m->defaults = NULL; + } + return 0; +} +static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + __Pyx_PyHeapTypeObject_GC_Del(m); +} +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + __Pyx__CyFunction_dealloc(m); +} +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + Py_VISIT(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func); +#else + Py_VISIT(((PyCFunctionObject*)m)->m_module); +#endif + Py_VISIT(m->func_dict); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); +#endif + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + Py_VISIT(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); + } + return 0; +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyObject *py_name = NULL; + PyCFunction meth; + int flags; + meth = PyCFunction_GetFunction(f); + if (unlikely(!meth)) return NULL; + flags = PyCFunction_GetFlags(f); + if (unlikely(flags < 0)) return NULL; +#else + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + int flags = f->m_ml->ml_flags; +#endif + Py_ssize_t size; + switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 0)) + return (*meth)(self, NULL); +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; + #endif + result = (*meth)(self, arg0); + #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(arg0); + #endif + return result; + } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; + } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", + py_name); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); +#endif + return NULL; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *self, *result; +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)func)->m_self; +#endif + result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); + return result; +} +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; +#if CYTHON_METH_FASTCALL + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS + return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); +#else + (void) &__Pyx_PyVectorcall_FastCallDict; + return PyVectorcall_Call(func, args, kw); +#endif + } +#endif + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; +#if CYTHON_ASSUME_SAFE_MACROS + argc = PyTuple_GET_SIZE(args); +#else + argc = PyTuple_Size(args); + if (unlikely(!argc) < 0) return NULL; +#endif + new_args = PyTuple_GetSlice(args, 1, argc); + if (unlikely(!new_args)) + return NULL; + self = PyTuple_GetItem(args, 0); + if (unlikely(!self)) { + Py_DECREF(new_args); +#if PY_MAJOR_VERSION > 2 + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); +#else + PyErr_SetString(PyExc_TypeError, + "unbound method needs an argument"); +#endif + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); + } + return result; +} +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) +{ + int ret = 0; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + if (unlikely(nargs < 1)) { + PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", + ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } + ret = 1; + } + if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } + return ret; +} +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + if (unlikely(nargs != 0)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; + } + return def->ml_meth(self, NULL); +} +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + if (unlikely(nargs != 1)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; + } + return def->ml_meth(self, args[0]); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; + PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); +#endif + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; + } + return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); +} +#endif +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_CyFunctionType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, + {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, + {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, + {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, + {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, + {Py_tp_methods, (void *)__pyx_CyFunction_methods}, + {Py_tp_members, (void *)__pyx_CyFunction_members}, + {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, + {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, + {0, 0}, +}; +static PyType_Spec __pyx_CyFunctionType_spec = { + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots +}; +#else +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, +#if !CYTHON_METH_FASTCALL + 0, +#elif CYTHON_BACKPORT_VECTORCALL + (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), +#else + offsetof(PyCFunctionObject, vectorcall), +#endif + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, +#else + 0, +#endif + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_CallAsMethod, + 0, + 0, + 0, + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), +#else + offsetof(PyCFunctionObject, m_weakreflist), +#endif + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_PyMethod_New, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, +#endif +#if __PYX_NEED_TP_PRINT_SLOT + 0, +#endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, +#endif +}; +#endif +static int __pyx_CyFunction_init(PyObject *module) { +#if CYTHON_USE_TYPE_SPECS + __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); +#else + CYTHON_UNUSED_VAR(module); + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); +#endif + if (unlikely(__pyx_CyFunctionType == NULL)) { + return -1; + } + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_Malloc(size); + if (unlikely(!m->defaults)) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + m->defaults_size = size; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +/* CythonFunction */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + PyObject *op = __Pyx_CyFunction_Init( + PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); + } + return op; +} + +/* CLineInTraceback */ +#ifndef CYTHON_CLINE_IN_TRACEBACK +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { + PyObject *use_cline; + PyObject *ptype, *pvalue, *ptraceback; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict; +#endif + CYTHON_MAYBE_UNUSED_VAR(tstate); + if (unlikely(!__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, *cython_runtime_dict, + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) + } else +#endif + { + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } + } + if (!use_cline) { + c_line = 0; + (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + } + else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} +#endif + +/* AddTraceback */ +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, + PyObject *firstlineno, PyObject *name) { + PyObject *replace = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; + replace = PyObject_GetAttrString(code, "replace"); + if (likely(replace)) { + PyObject *result; + result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + #if __PYX_LIMITED_VERSION_HEX < 0x030780000 + { + PyObject *compiled = NULL, *result = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; + compiled = Py_CompileString( + "out = type(code)(\n" + " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" + " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" + " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" + " code.co_lnotab)\n", "", Py_file_input); + if (!compiled) return NULL; + result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); + Py_DECREF(compiled); + if (!result) PyErr_Print(); + Py_DECREF(result); + result = PyDict_GetItemString(scratch_dict, "out"); + if (result) Py_INCREF(result); + return result; + } + #else + return NULL; + #endif +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; + PyObject *replace = NULL, *getframe = NULL, *frame = NULL; + PyObject *exc_type, *exc_value, *exc_traceback; + int success = 0; + if (c_line) { + (void) __pyx_cfilenm; + (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + } + PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + py_funcname = PyUnicode_FromString(funcname); + if (unlikely(!py_funcname)) goto bad; + dict = PyDict_New(); + if (unlikely(!dict)) goto bad; + { + PyObject *old_code_object = code_object; + code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); + Py_DECREF(old_code_object); + } + if (unlikely(!code_object)) goto bad; + getframe = PySys_GetObject("_getframe"); + if (unlikely(!getframe)) goto bad; + if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; + frame = PyEval_EvalCode(code_object, dict, dict); + if (unlikely(!frame) || frame == Py_None) goto bad; + success = 1; + bad: + PyErr_Restore(exc_type, exc_value, exc_traceback); + Py_XDECREF(code_object); + Py_XDECREF(py_py_line); + Py_XDECREF(py_funcname); + Py_XDECREF(dict); + Py_XDECREF(replace); + if (success) { + PyTraceBack_Here( + (struct _frame*)frame); + } + Py_XDECREF(frame); +} +#else +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = NULL; + PyObject *py_funcname = NULL; + #if PY_MAJOR_VERSION < 3 + PyObject *py_srcfile = NULL; + py_srcfile = PyString_FromString(filename); + if (!py_srcfile) goto bad; + #endif + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + funcname = PyUnicode_AsUTF8(py_funcname); + if (!funcname) goto bad; + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + if (!py_funcname) goto bad; + #endif + } + #if PY_MAJOR_VERSION < 3 + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + #else + py_code = PyCode_NewEmpty(filename, funcname, py_line); + #endif + Py_XDECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_funcname); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_srcfile); + #endif + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject *ptype, *pvalue, *ptraceback; + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); + } + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) { + /* If the code object creation fails, then we should clear the + fetched exception references and propagate the new exception */ + Py_XDECREF(ptype); + Py_XDECREF(pvalue); + Py_XDECREF(ptraceback); + goto bad; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} +#endif + +/* CIntFromPyVerify */ +#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +static PyObject* __pyx_convert__to_py_struct__broma_3a__3a_Type(struct broma::Type s) { + PyObject* res; + PyObject* member; + res = __Pyx_PyDict_NewPresized(2); if (unlikely(!res)) return NULL; + member = __pyx_convert_PyObject_string_to_py_6libcpp_6string_std__in_string(s.name); if (unlikely(!member)) goto bad; + if (unlikely(PyDict_SetItem(res, __pyx_n_s_name, member) < 0)) goto bad; + Py_DECREF(member); + member = __Pyx_PyBool_FromLong(s.is_struct); if (unlikely(!member)) goto bad; + if (unlikely(PyDict_SetItem(res, __pyx_n_s_is_struct, member) < 0)) goto bad; + Py_DECREF(member); + return res; + bad: + Py_XDECREF(member); + Py_DECREF(res); + return NULL; +} +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + +/* CIntFromPy */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if ((sizeof(int) < sizeof(long))) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if ((sizeof(int) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } + } +#endif + if ((sizeof(int) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); +#if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } +#endif + if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (int) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (int) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif + Py_DECREF(v); + if (likely(!ret)) + return val; + } + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* CIntFromPy */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if ((sizeof(long) < sizeof(long))) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if ((sizeof(long) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } + } +#endif + if ((sizeof(long) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); +#if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } +#endif + if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (long) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (long) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif + Py_DECREF(v); + if (likely(!ret)) + return val; + } + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_ptrdiff_t(ptrdiff_t value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const ptrdiff_t neg_one = (ptrdiff_t) -1, const_zero = (ptrdiff_t) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(ptrdiff_t) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(ptrdiff_t) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(ptrdiff_t) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(ptrdiff_t) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(ptrdiff_t) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + return _PyLong_FromByteArray(bytes, sizeof(ptrdiff_t), + little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(ptrdiff_t)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + +/* CIntFromPy */ +static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const size_t neg_one = (size_t) -1, const_zero = (size_t) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if ((sizeof(size_t) < sizeof(long))) { + __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (size_t) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(size_t) >= 2 * PyLong_SHIFT)) { + return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(size_t) >= 3 * PyLong_SHIFT)) { + return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + } + break; + case 4: + if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(size_t) >= 4 * PyLong_SHIFT)) { + return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + } + break; + } + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (size_t) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if ((sizeof(size_t) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if ((sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) { + return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) { + return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case -3: + if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) { + return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case 3: + if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) { + return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case -4: + if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT)) { + return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case 4: + if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT)) { + return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + } + } +#endif + if ((sizeof(size_t) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if ((sizeof(size_t) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { + size_t val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); +#if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } +#endif + if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (size_t) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (size_t) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (size_t) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (size_t) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (size_t) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(size_t) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((size_t) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(size_t) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((size_t) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((size_t) 1) << (sizeof(size_t) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif + Py_DECREF(v); + if (likely(!ret)) + return val; + } + return (size_t) -1; + } + } else { + size_t val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (size_t) -1; + val = __Pyx_PyInt_As_size_t(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to size_t"); + return (size_t) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to size_t"); + return (size_t) -1; +} + +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + +/* FastTypeChecks */ +#if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(a, b); +} +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (cls == a || cls == b) return 1; + mro = cls->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + PyObject *base = PyTuple_GET_ITEM(mro, i); + if (base == (PyObject *)a || base == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); +} +#if PY_MAJOR_VERSION == 2 +static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { + PyObject *exception, *value, *tb; + int res; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&exception, &value, &tb); + res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + if (!res) { + res = PyObject_IsSubclass(err, exc_type2); + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + } + __Pyx_ErrRestore(exception, value, tb); + return res; +} +#else +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + if (exc_type1) { + return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + } else { + return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } +} +#endif +static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + assert(PyExceptionClass_Check(exc_type)); + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; i= 0x030B00A4 + return Py_Version & ~0xFFUL; +#else + const char* rt_version = Py_GetVersion(); + unsigned long version = 0; + unsigned long factor = 0x01000000UL; + unsigned int digit = 0; + int i = 0; + while (factor) { + while ('0' <= rt_version[i] && rt_version[i] <= '9') { + digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + ++i; + } + version += factor * digit; + if (rt_version[i] != '.') + break; + digit = 0; + factor >>= 8; + ++i; + } + return version; +#endif +} +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { + const unsigned long MAJOR_MINOR = 0xFFFF0000UL; + if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) + return 0; + if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) + return 1; + { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compile time Python version %d.%d " + "of module '%.100s' " + "%s " + "runtime version %d.%d", + (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), + __Pyx_MODULE_NAME, + (allow_newer) ? "was newer than" : "does not match", + (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) + ); + return PyErr_WarnEx(NULL, message, 1); + } +} + +/* InitStrings */ +#if PY_MAJOR_VERSION >= 3 +static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { + if (t.is_unicode | t.is_str) { + if (t.intern) { + *str = PyUnicode_InternFromString(t.s); + } else if (t.encoding) { + *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); + } else { + *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); + } + } else { + *str = PyBytes_FromStringAndSize(t.s, t.n - 1); + } + if (!*str) + return -1; + if (PyObject_Hash(*str) == -1) + return -1; + return 0; +} +#endif +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION >= 3 + __Pyx_InitString(*t, t->p); + #else + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + if (!*t->p) + return -1; + if (PyObject_Hash(*t->p) == -1) + return -1; + #endif + ++t; + } + return 0; +} + +#include +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { + size_t len = strlen(s); + if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, "byte string is too long"); + return -1; + } + return (Py_ssize_t) len; +} +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return __Pyx_PyUnicode_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return PyByteArray_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#if !CYTHON_PEP393_ENABLED +static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +} +#else +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (likely(PyUnicode_IS_ASCII(o))) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +} +#endif +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { + int retval; + if (unlikely(!x)) return -1; + retval = __Pyx_PyObject_IsTrue(x); + Py_DECREF(x); + return retval; +} +static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); +#if PY_MAJOR_VERSION >= 3 + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { + __Pyx_DECREF_TypeName(result_type_name); + Py_DECREF(result); + return NULL; + } + __Pyx_DECREF_TypeName(result_type_name); + return result; + } +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", + type_name, type_name, result_type_name); + __Pyx_DECREF_TypeName(result_type_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x) || PyLong_Check(x))) +#else + if (likely(PyLong_Check(x))) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = m->nb_int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = m->nb_long(x); + } + #else + if (likely(m && m->nb_int)) { + name = "int"; + res = m->nb_int(x); + } + #endif +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Int(x); + } +#endif + if (likely(res)) { +#if PY_MAJOR_VERSION < 3 + if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { +#else + if (unlikely(!PyLong_CheckExact(res))) { +#endif + return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(b); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(__Pyx_PyLong_IsCompact(b))) { + return __Pyx_PyLong_CompactValue(b); + } else { + const digit* digits = __Pyx_PyLong_Digits(b); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { + if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { + return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); +#if PY_MAJOR_VERSION < 3 + } else if (likely(PyInt_CheckExact(o))) { + return PyInt_AS_LONG(o); +#endif + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyInt_AsLong(x); + Py_DECREF(x); + return ival; + } +} +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +/* #### Code section: utility_code_pragmas_end ### */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + + + +/* #### Code section: end ### */ +#endif /* Py_PYTHON_H */ diff --git a/broma_ida/pybroma/PyBroma.pyi b/broma_ida/pybroma/PyBroma.pyi new file mode 100644 index 0000000..243e65e --- /dev/null +++ b/broma_ida/pybroma/PyBroma.pyi @@ -0,0 +1,137 @@ +from typing import Optional + +class Type: + @property + def name() -> str: ... + def __eq__(self, __value: Type) -> bool: ... + @property + def is_struct() -> bool:... + + +class MemberFunctionProto: + @property + def args() -> dict[str, Type]: ... + @property + def ret() -> Type: ... + @property + def is_const() -> bool: ... + @property + def is_virtual() -> bool: ... + @property + def is_callback() -> bool: ... + @property + def is_static() -> bool: ... + @property + def type() -> Type: ... + @property + def docs() -> str: ... + @property + def name() -> str: ... + def __eq__(self, __value: MemberFunctionProto) -> bool: ... + +class MemberField: + @property + def name() -> str: ... + @property + def type() -> Type: ... + @property + def count() -> int: ... + +class OutOfLineField: + @property + def prototype(self) -> MemberFunctionProto: ... + @property + def inner(self) -> str: ... + +class FunctionBindField: + @property + def prototype(self) -> MemberFunctionProto: ... + @property + def binds(self) -> PlatFormNumber: ... + +class PadField: + @property + def amount(self) -> PlatFormNumber: ... + +class Field: + @property + def id(self) -> int: ... + @property + def parent(self) -> str: ... + def getAsFunctionBindField(self) -> Optional[FunctionBindField]: ... + def getAsMemberField(self) -> Optional[MemberField]: ... + def getAsOutOfLineField(self) -> Optional[OutOfLineField]: ... + def getAsPadField(self) -> Optional[PadField]: ... + @property + def missing(self) -> int: ... + @property + def links(self) -> int: ... + +class PlatFormNumber: + @property + def mac(self) -> int: ... + @property + def ios(self) -> int: ... + @property + def win(self) -> int: ... + @property + def android32(self) -> int: ... + @property + def android64(self) -> int: ... + +class InlineField: + @property + def inner(self) -> str: ... + +class FunctionProto: + @property + def args(self) -> dict[str, Type]: ... + @property + def ret(self) -> Type: ... + @property + def name(self) -> str: ... + @property + def docs(self) -> str: ... + +class Function: + @property + def prototype(self) -> FunctionProto: ... + @property + def binds(self) -> PlatFormNumber: ... + @property + def missing(self) -> int: ... + @property + def links(self) -> int: ... + +class Class: + @property + def name(self) -> str: ... + @property + def links(self) -> int: ... + @property + def missing(self) -> int: ... + @property + def superclasses(self) -> list[str]: ... + @property + def depends(self) -> list[str]: ... + @property + def fields(self) -> list[Field]:... + +class Root: + """Automatically Parses a given File and returns with a Parsed Broma File""" + + def __init__(self, fileName: str) -> None: ... + def __getitem__(self, _class_name_: str) -> Optional[Class]: + """Searches for a class object by Name + + `NOTE`: This Function Takes a linear search time. + If this is not what you want use `classesAsDict`""" + def functionsAsDict(self) -> dict[str, Function]: + """Converts Functions to A Dictionary""" + def classesAsDict(self) -> dict[str, Class]: + """Converts Classes to a dictionary""" + @property + def classes(self) -> list[Class]:... + @property + def functions(self) -> list[Function]:... + \ No newline at end of file diff --git a/broma_ida/pybroma/__init__.py b/broma_ida/pybroma/__init__.py new file mode 100644 index 0000000..9d8173f --- /dev/null +++ b/broma_ida/pybroma/__init__.py @@ -0,0 +1,6 @@ +from .PyBroma import * +from enum import IntEnum + + +# No Circular imports... +from .visitor import BromaTreeVisitor diff --git a/broma_ida/pybroma/include/ast.hpp b/broma_ida/pybroma/include/ast.hpp new file mode 100644 index 0000000..2a68ba7 --- /dev/null +++ b/broma_ida/pybroma/include/ast.hpp @@ -0,0 +1,213 @@ +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace broma { + /// TODO: (Calloc) Make a pull request with None Translated to NONE for python support... + /// @brief The platform currently being processed in a bind statement. + enum class Platform { + None = 0, + Mac = 1, + Windows = 2, + Android = 4, + iOS = 8, + Android32 = 16, + Android64 = 32, + }; + + inline Platform operator|(Platform a, Platform b) { + return static_cast(static_cast(a) | static_cast(b)); + } + + inline Platform& operator|=(Platform& a, Platform b) { + a = a | b; + return a; + } + + inline Platform operator&(Platform a, Platform b) { + return static_cast(static_cast(a) & static_cast(b)); + } + + inline Platform& operator&=(Platform& a, Platform b) { + a = a & b; + return a; + } + + /// @brief Binding offsets for each platform. + struct PlatformNumber { + ptrdiff_t mac = -1; + ptrdiff_t ios = -1; + ptrdiff_t win = -1; + ptrdiff_t android32 = -1; + ptrdiff_t android64 = -1; + }; + + /// @brief A C++ type declaration. + struct Type { + bool is_struct = false; + std::string name; + + bool operator==(Type const& t) const { + return name == t.name; + } + }; + + /// @brief The signature of a free function. + struct FunctionProto { + Type ret; ///< The return type of the function. + std::vector> args; ///< All arguments, represented by their type and their name. + std::string docs; ///< Any docstring pulled from a `[[docs(...)]]` attribute. + std::string name; ///< The function's name. + + inline bool operator==(FunctionProto const& f) const { + if (name != f.name || args.size() != f.args.size()) { + return false; + } + + for (size_t i = 0; i < args.size(); ++i) { + if (!(args[i].first == f.args[i].first)) { + return false; + } + } + + return true; + } + }; + + /// @brief A member function's type. + enum class FunctionType { + Normal, + Ctor, ///< A constructor. + Dtor ///< A destructor. + }; + + /// @brief The signature of a member function. + struct MemberFunctionProto : FunctionProto { + FunctionType type = FunctionType::Normal; + bool is_const = false; + bool is_virtual = false; + bool is_callback = false; ///< Whether or not this function is a callback. + ///< In Geode, this determines the function's calling convention (optcall or thiscall). + bool is_static = false; + + inline bool operator==(MemberFunctionProto const& f) const { + if (!FunctionProto::operator==(f)) + return false; + + if (is_const != f.is_const) + return false; + + return true; + } + }; + + /// @brief A class's member variables. + struct MemberField { + std::string name; ///< The name of the field. + Type type; ///< The type of the field. + size_t count = 0; ///< The number of elements in the field when it's an array (pretty much unused since we use std::array). + }; + + /// @brief Any class padding. + struct PadField { + PlatformNumber amount; ///< The amount of padding, separated per platform. + }; + + /// @brief A function that is bound to an offset. + struct FunctionBindField { + MemberFunctionProto prototype; + PlatformNumber binds; ///< The offsets, separated per platform. + }; + + /// @brief An inline function body that should go in a source file (.cpp). + struct OutOfLineField { + MemberFunctionProto prototype; + std::string inner; ///< The inline body of the function as a raw string. + }; + + /// @brief A inline function body that should go in a header file (.hpp). + struct InlineField { + std::string inner; ///< The inline body of the function as a raw string. + }; + + /// @brief A class field. + struct Field { + size_t field_id; ///< The index of the field. This starts from 0 and counts up across all classes. + std::string parent; ///< The name of the parent class. + std::variant inner; + Platform links; ///< All the platforms that link the field + Platform missing; ///< All the platforms that are missing the field + + /// @brief Cast the field into a variant type. This is useful to extract data from the field. + template + T* get_as() { + return std::get_if(&inner); + } + + /// @brief Cast the field into a variant type. This is useful to extract data from the field. + template + T const* get_as() const { + return std::get_if(&inner); + } + + /// @brief Convenience function to get the function prototype of the field, if the field is a function of some sort. + inline MemberFunctionProto* get_fn() { + if (auto fn = get_as()) { + return &fn->prototype; + } else if (auto fn = get_as()) { + return &fn->prototype; + } else return nullptr; + } + }; + + /// @brief A top-level class declaration. + struct Class { + std::string name; ///< The name of the class. + std::vector superclasses; ///< Parent classes that the current class inherits. + std::vector depends; ///< Classes the current class depends on. + ///< This includes parent classes, and any classes declared in a `[[depends(...)]]` attribute. + std::vector fields; ///< All the fields parsed in the class. + + Platform links; ///< All the platforms that link the class + Platform missing; ///< All the platforms that are missing the class + + inline bool operator==(Class const& c) const { + return name == c.name; + } + inline bool operator==(std::string const& n) const { + return name == n; + } + }; + + /// @brief A top-level free function binding. + struct Function { + FunctionProto prototype; ///< The free function's signature. + PlatformNumber binds; ///< The offsets of free function, separated per platform. + Platform links; ///< All the platforms that link the function + Platform missing; ///< All the platforms that are missing the function + }; + + /// @brief Broma's root grammar (the root AST). + /// + /// See the user's guide for an example on how to traverse this AST. + struct Root { + std::vector classes; + std::vector functions; + + inline Class* operator[](std::string const& name) { + auto it = std::find_if(classes.begin(), classes.end(), [name](Class& cls) { + return cls.name == name; + }); + + if (it == classes.end()) + return nullptr; + + return &*it; + } + }; +} // namespace broma diff --git a/broma_ida/pybroma/include/broma.hpp b/broma_ida/pybroma/include/broma.hpp new file mode 100644 index 0000000..510efa7 --- /dev/null +++ b/broma_ida/pybroma/include/broma.hpp @@ -0,0 +1,12 @@ +#pragma once + +#include "ast.hpp" + +namespace broma { + /// @brief Pass a file for Broma to parse into an AST. + /// + /// This function throws, so make sure to handle errors properly if needed. + /// + /// @param fname The path of the file you want to parse, as a string. + Root parse_file(std::string const& fname); +} diff --git a/broma_ida/pybroma/include/helper.hpp b/broma_ida/pybroma/include/helper.hpp new file mode 100644 index 0000000..6c4a4e3 --- /dev/null +++ b/broma_ida/pybroma/include/helper.hpp @@ -0,0 +1,96 @@ +#ifndef __HELPER_HPP__ +#define __HELPER_HPP__ + +#include "broma.hpp" +#include "ast.hpp" + +/* Used as a primary helpers around Field's variant and other Types since variants +are not supported by cython yet as far as I am aware... */ + +/* These help to provide compatability to python */ + +inline broma::InlineField *Field_GetAs_InlineField(broma::Field *f) +{ + broma::InlineField *x; + if (x = std::get_if(&f->inner)) + { + return x; + }; + return nullptr; +} + +inline broma::OutOfLineField *Field_GetAs_OutOfLineField(broma::Field *f) +{ + broma::OutOfLineField *x; + if (x = std::get_if(&f->inner)) + { + return x; + }; + return nullptr; +} + +inline broma::FunctionBindField *Field_GetAs_FunctionBindField(broma::Field *f) +{ + broma::FunctionBindField *x; + if (x = std::get_if(&f->inner)) + { + return x; + }; + return nullptr; +} + +inline broma::PadField *Field_GetAs_PadField(broma::Field *f) +{ + broma::PadField *x; + if (x = std::get_if(&f->inner)) + { + return x; + }; + return nullptr; +} + +inline broma::MemberField *Field_GetAs_MemberField(broma::Field *f) +{ + broma::MemberField *x; + if (x = std::get_if(&f->inner)) + { + return x; + }; + return nullptr; +} + +inline bool MemberFunctionProtoEquals(broma::MemberFunctionProto const &a, broma::MemberFunctionProto const &b) +{ + return a == b; +}; + +inline bool FunctionProtoEquals(broma::FunctionProto const &a, broma::FunctionProto const &b) +{ + return a == b; +}; + +inline bool TypeEquals(broma::Type const &a, broma::Type const &b) +{ + return a == b; +} + +inline bool ClassEqualsTo(broma::Class const &a, broma::Class const &b) +{ + return a.name == b.name; +} +inline bool ClassEqualsToName(broma::Class const &a, std::string const &b) +{ + return a.name == b; +} + +inline broma::MemberFunctionProto *FieldGetFn(broma::Field *field) +{ + return field->get_fn(); +} + +broma::Class *RootgetClassFromStr(broma::Root *root, std::string const &name) +{ + return root->operator[](name); +} + +#endif // __HELPER_HPP__ \ No newline at end of file diff --git a/broma_ida/pybroma/platforms.py b/broma_ida/pybroma/platforms.py new file mode 100644 index 0000000..6bca4da --- /dev/null +++ b/broma_ida/pybroma/platforms.py @@ -0,0 +1,14 @@ +from enum import IntEnum + +class Platform(IntEnum): + """Special Platform Number NOTE: + This hasn't been merged to cython yet due to + compatability issues with Broma itself...""" + NONE = 0 + Mac = 1 + Windows = 2 + Android = 4 + iOS = 8 + Android32 = 16 + Android64 = 32 + \ No newline at end of file diff --git a/broma_ida/pybroma/visitor.py b/broma_ida/pybroma/visitor.py new file mode 100644 index 0000000..7946585 --- /dev/null +++ b/broma_ida/pybroma/visitor.py @@ -0,0 +1,57 @@ +from .PyBroma import * +# Inspired by Cython's Compiler Tree Visitors... + +class BromaTreeVisitor: + """Used to safely visit different Parts of a broma file + and is built to allow for easy visiting of all the parts + you need in your code""" + + def visit_PlatformNumber(self, node): + return + + def visit_FunctionProto(self, node:FunctionProto): + return + + def visit_MemberFunctionProto(self, node:MemberFunctionProto): + return + + def visit_FunctionBindField(self, node:FunctionBindField): + self.visit_PlatformNumber(node.binds) + self.visit_MemberFunctionProto(node.prototype) + + def visit_MemberField(self, node:MemberField): + pass + + def visit_OutOfLineField(self, node:OutOfLineField): + self.visit_MemberFunctionProto(node.prototype) + + def visit_PadField(self, node:PadField): + self.visit_FunctionProto(node) + + def visit_Field(self, f:Field): + if x := f.getAsFunctionBindField(): + self.visit_FunctionBindField(x) + elif x := f.getAsMemberField(): + self.visit_MemberField(x) + elif x := f.getAsOutOfLineField(): + self.visit_OutOfLineField(x) + elif x := f.getAsPadField(): + self.visit_PadField(x) + + def visit_Function(self, node:Function): + self.visit_PlatformNumber(node.binds) + self.visit_FunctionProto(node.prototype) + + def visit_Class(self, node:Class): + for f in node.fields: + self.visit_Field(f) + + def start(self, root:Root): + self.root = root + for c in root.classes: + self.visit_Class(c) + for f in root.functions: + self.visit_Function(f) + + def __call__(self, file:str): + return self.start(Root(file)) diff --git a/broma_ida/utils.py b/broma_ida/utils.py index fea1d66..2d7d86a 100644 --- a/broma_ida/utils.py +++ b/broma_ida/utils.py @@ -9,8 +9,23 @@ from ida_name import get_name_ea from idc import set_name -from broma_ida.binding_type import Binding +from re import sub + +from broma_ida.pybroma import Type + from broma_ida.broma.constants import BROMA_PLATFORMS +from broma_ida.broma.binding import Binding + + +CPP_TYPE_SPECIFIERS = ("unsigned", "signed") +CPP_TYPE_QUALIFIERS = ("const", "volatile") +CPP_DATA_TYPES = ("bool", "char", "short", "int", "long") +CPP_PRIMITIVES = ( + "void", "int", "char", "float", "short", + "double", "bool", "long" +) + +g_platform: BROMA_PLATFORMS = "" # type: ignore def stop(reason: Union[str, None] = None) -> NoReturn: @@ -32,9 +47,9 @@ def popup( Args: button1 (str): Button 1 text - button2 (str): Button 2 text - button3 (str): Button 3 text - text (str): The text to put int the popup + button2 (str): Button 2 text. None will hide the button inshallah. + button3 (str): Button 3 text. None hides the button. + text (str): The text to put. default (int, optional): Default option. Defaults to 1. """ return ask_buttons( @@ -74,7 +89,7 @@ def rename_func(addr: int, name: str, max: int = 10) -> bool: f"{name} is already taken at " f"{hex(ida_prev_addr - get_imagebase())} while trying to " f"rename {hex(addr)}\n" - f"Overwrite or keep current name?\n" + "Overwrite or keep current name?\n" "(Old location will be renamed to " f"sub_{hex(ida_prev_addr)[2:].upper()})" ) == ASKBTN_BTN1: @@ -104,9 +119,10 @@ def get_short_info(binding: Binding) -> str: def get_platform() -> Union[BROMA_PLATFORMS, NoReturn]: """Tries to get the binary's platform Returns: - BROMA_PLATFORMS | None: The platform or None if + BROMA_PLATFORMS | NoReturn: The platform or stop() called if not able to be determined """ + global g_platform structure_info = get_inf_structure() if structure_info.filetype == f_PE: @@ -120,9 +136,11 @@ def get_platform() -> Union[BROMA_PLATFORMS, NoReturn]: elif file_type_name.endswith("X86_64"): return "mac" - platform = ask_str( - "win", 256, "Enter a platform (win, mac or ios)" - ) + if g_platform == "": + platform = ask_str( + "win", 256, "Enter a platform (win, mac or ios)" + ) + g_platform = platform if platform not in get_args(BROMA_PLATFORMS): popup( @@ -150,3 +168,48 @@ def get_platform_printable(platform: BROMA_PLATFORMS) -> str: } return platform_to_printable[platform] + + +def are_args_primitive(arguments: dict[str, Type]) -> bool: + """Checks if the arguments are all primitives because + importing structs isn't supported yet + TODO: start importing structs :D + + Args: + arguments (dict[str, Type]): + FunctionBindField.MemberFunctionProto::args + + Returns: + bool: ya + """ + is_pointer_or_reference = \ + lambda p: p[-1] == "*" or p[-1] == "&" # noqa: E731 + remove_pointer_or_reference = \ + lambda p: p[:-1] if is_pointer_or_reference(p) else p # noqa: E731 + + if len(arguments) == 0: + return True + + arguments_str = { + name: arg_type.name for name, arg_type in arguments.items() + } + + for name, arg_type in arguments_str.items(): + arguments_str[name] = sub( + rf"""(?: )?unsigned(?!{ + "|".join([f" {x}" for x in CPP_DATA_TYPES]) + })""", + "unsigned int", + arg_type + ) + + for qualifier in CPP_TYPE_QUALIFIERS: + arguments_str[name] = sub( + rf"(?: )?{qualifier}(?: )?", + "", + arguments_str[name] + ) + + arguments_str[name] = remove_pointer_or_reference(arguments_str[name]) + + return all([arg_type in CPP_PRIMITIVES for _, arg_type in arguments_str.items()])