| 1 |
import sys |
| 2 |
from collections.abc import Callable |
| 3 |
from libclinic.codegen import CRenderData |
| 4 |
from libclinic.function import Function |
| 5 |
from typing import Any |
| 6 |
|
| 7 |
|
| 8 |
ReturnConverterType = Callable[..., "CReturnConverter"] |
| 9 |
|
| 10 |
|
| 11 |
# maps strings to callables. |
| 12 |
# these callables must be of the form: |
| 13 |
# def foo(*, ...) |
| 14 |
# The callable may have any number of keyword-only parameters. |
| 15 |
# The callable must return a CReturnConverter object. |
| 16 |
# The callable should not call builtins.print. |
| 17 |
ReturnConverterDict = dict[str, ReturnConverterType] |
| 18 |
return_converters: ReturnConverterDict = {} |
| 19 |
|
| 20 |
|
| 21 |
def add_c_return_converter( |
| 22 |
f: ReturnConverterType, |
| 23 |
name: str | None = None |
| 24 |
) -> ReturnConverterType: |
| 25 |
if not name: |
| 26 |
name = f.__name__ |
| 27 |
if not name.endswith('_return_converter'): |
| 28 |
return f |
| 29 |
name = name.removesuffix('_return_converter') |
| 30 |
return_converters[name] = f |
| 31 |
return f |
| 32 |
|
| 33 |
|
| 34 |
class CReturnConverterAutoRegister(type): |
| 35 |
def __init__( |
| 36 |
cls: ReturnConverterType, |
| 37 |
name: str, |
| 38 |
bases: tuple[type[object], ...], |
| 39 |
classdict: dict[str, Any] |
| 40 |
) -> None: |
| 41 |
add_c_return_converter(cls) |
| 42 |
|
| 43 |
|
| 44 |
class CReturnConverter(metaclass=CReturnConverterAutoRegister): |
| 45 |
|
| 46 |
# The C type to use for this variable. |
| 47 |
# 'type' should be a Python string specifying the type, e.g. "int". |
| 48 |
# If this is a pointer type, the type string should end with ' *'. |
| 49 |
type = 'PyObject *' |
| 50 |
|
| 51 |
# The Python default value for this parameter, as a Python value. |
| 52 |
# Or the magic value "unspecified" if there is no default. |
| 53 |
default: object = None |
| 54 |
|
| 55 |
def __init__( |
| 56 |
self, |
| 57 |
*, |
| 58 |
py_default: str | None = None, |
| 59 |
**kwargs: Any |
| 60 |
) -> None: |
| 61 |
self.py_default = py_default |
| 62 |
try: |
| 63 |
self.return_converter_init(**kwargs) |
| 64 |
except TypeError as e: |
| 65 |
s = ', '.join(name + '=' + repr(value) for name, value in kwargs.items()) |
| 66 |
sys.exit(self.__class__.__name__ + '(' + s + ')\n' + str(e)) |
| 67 |
|
| 68 |
def return_converter_init(self) -> None: ... |
| 69 |
|
| 70 |
def declare(self, data: CRenderData) -> None: |
| 71 |
line: list[str] = [] |
| 72 |
add = line.append |
| 73 |
add(self.type) |
| 74 |
if not self.type.endswith('*'): |
| 75 |
add(' ') |
| 76 |
add(data.converter_retval + ';') |
| 77 |
data.declarations.append(''.join(line)) |
| 78 |
data.return_value = data.converter_retval |
| 79 |
|
| 80 |
def err_occurred_if( |
| 81 |
self, |
| 82 |
expr: str, |
| 83 |
data: CRenderData |
| 84 |
) -> None: |
| 85 |
line = f'if (({expr}) && PyErr_Occurred()) {{\n goto exit;\n}}\n' |
| 86 |
data.return_conversion.append(line) |
| 87 |
|
| 88 |
def err_occurred_if_null_pointer( |
| 89 |
self, |
| 90 |
variable: str, |
| 91 |
data: CRenderData |
| 92 |
) -> None: |
| 93 |
line = f'if ({variable} == NULL) {{\n goto exit;\n}}\n' |
| 94 |
data.return_conversion.append(line) |
| 95 |
|
| 96 |
def render( |
| 97 |
self, |
| 98 |
function: Function, |
| 99 |
data: CRenderData |
| 100 |
) -> None: ... |
| 101 |
|
| 102 |
|
| 103 |
add_c_return_converter(CReturnConverter, 'object') |
| 104 |
|
| 105 |
|
| 106 |
class bool_return_converter(CReturnConverter): |
| 107 |
type = 'int' |
| 108 |
|
| 109 |
def render(self, function: Function, data: CRenderData) -> None: |
| 110 |
self.declare(data) |
| 111 |
self.err_occurred_if(f"{data.converter_retval} == -1", data) |
| 112 |
data.return_conversion.append( |
| 113 |
f'return_value = PyBool_FromLong((long){data.converter_retval});\n' |
| 114 |
) |
| 115 |
|
| 116 |
|
| 117 |
class long_return_converter(CReturnConverter): |
| 118 |
type = 'long' |
| 119 |
conversion_fn = 'PyLong_FromLong' |
| 120 |
cast = '' |
| 121 |
unsigned_cast = '' |
| 122 |
|
| 123 |
def render(self, function: Function, data: CRenderData) -> None: |
| 124 |
self.declare(data) |
| 125 |
self.err_occurred_if(f"{data.converter_retval} == {self.unsigned_cast}-1", data) |
| 126 |
data.return_conversion.append( |
| 127 |
f'return_value = {self.conversion_fn}({self.cast}{data.converter_retval});\n' |
| 128 |
) |
| 129 |
|
| 130 |
|
| 131 |
class int_return_converter(long_return_converter): |
| 132 |
type = 'int' |
| 133 |
cast = '(long)' |
| 134 |
|
| 135 |
|
| 136 |
class unsigned_long_return_converter(long_return_converter): |
| 137 |
type = 'unsigned long' |
| 138 |
conversion_fn = 'PyLong_FromUnsignedLong' |
| 139 |
unsigned_cast = '(unsigned long)' |
| 140 |
|
| 141 |
|
| 142 |
class unsigned_int_return_converter(unsigned_long_return_converter): |
| 143 |
type = 'unsigned int' |
| 144 |
cast = '(unsigned long)' |
| 145 |
unsigned_cast = '(unsigned int)' |
| 146 |
|
| 147 |
|
| 148 |
class Py_ssize_t_return_converter(long_return_converter): |
| 149 |
type = 'Py_ssize_t' |
| 150 |
conversion_fn = 'PyLong_FromSsize_t' |
| 151 |
|
| 152 |
|
| 153 |
class size_t_return_converter(long_return_converter): |
| 154 |
type = 'size_t' |
| 155 |
conversion_fn = 'PyLong_FromSize_t' |
| 156 |
unsigned_cast = '(size_t)' |
| 157 |
|
| 158 |
|
| 159 |
class double_return_converter(CReturnConverter): |
| 160 |
type = 'double' |
| 161 |
cast = '' |
| 162 |
|
| 163 |
def render(self, function: Function, data: CRenderData) -> None: |
| 164 |
self.declare(data) |
| 165 |
self.err_occurred_if(f"{data.converter_retval} == -1.0", data) |
| 166 |
data.return_conversion.append( |
| 167 |
f'return_value = PyFloat_FromDouble({self.cast}{data.converter_retval});\n' |
| 168 |
) |
| 169 |
|
| 170 |
|
| 171 |
class float_return_converter(double_return_converter): |
| 172 |
type = 'float' |
| 173 |
cast = '(double)' |