void
pymatecorba_register_stub(CORBA_TypeCode tc, PyObject *stub)
{
init_hash_tables();
if (tc->repo_id) {
CORBA_Object_duplicate((CORBA_Object)tc, NULL);
g_hash_table_replace(type_codes, tc->repo_id, tc);
}
if (stub) {
PyObject *stub_dict = NULL;
Py_INCREF(stub);
g_hash_table_insert(stubs, tc->repo_id, stub);
if (!strncmp(tc->repo_id, "IDL:omg.org/CORBA", 17)) {
gchar *other_repo_id = g_strconcat("IDL:", &tc->repo_id[12], NULL);
g_hash_table_insert(stubs, other_repo_id, stub);
}
if (PyType_Check(stub))
stub_dict = ((PyTypeObject *)stub)->tp_dict;
else if (PyClass_Check(stub))
stub_dict = ((PyClassObject *)stub)->cl_dict;
if (stub_dict && !PyDict_GetItemString(stub_dict, "__typecode__")) {
PyObject *py_tc = pycorba_typecode_new(tc);
PyDict_SetItemString(stub_dict, "__typecode__", py_tc);
Py_DECREF(py_tc);
}
}
}
static PyObject *
demarshal_value(CORBA_TypeCode tc, gconstpointer *val)
{
PyObject *ret = NULL;
while (tc->kind == CORBA_tk_alias)
tc = tc->subtypes[0];
switch (tc->kind) {
case CORBA_tk_null:
case CORBA_tk_void:
ret = Py_None;
Py_INCREF(ret);
break;
case CORBA_tk_short:
alignval(val, ORBIT_ALIGNOF_CORBA_SHORT);
ret = PyInt_FromLong(getval(val, CORBA_short));
advanceptr(val, sizeof(CORBA_short));
break;
case CORBA_tk_long:
alignval(val, ORBIT_ALIGNOF_CORBA_LONG);
ret = PyInt_FromLong(getval(val, CORBA_long));
advanceptr(val, sizeof(CORBA_long));
break;
case CORBA_tk_ushort:
alignval(val, ORBIT_ALIGNOF_CORBA_SHORT);
ret = PyInt_FromLong(getval(val, CORBA_unsigned_short));
advanceptr(val, sizeof(CORBA_unsigned_short));
break;
case CORBA_tk_ulong:
alignval(val, ORBIT_ALIGNOF_CORBA_LONG);
ret = PyLong_FromUnsignedLong(getval(val, CORBA_unsigned_long));
advanceptr(val, sizeof(CORBA_unsigned_long));
break;
case CORBA_tk_float:
alignval(val, ORBIT_ALIGNOF_CORBA_FLOAT);
ret = PyFloat_FromDouble(getval(val, CORBA_float));
advanceptr(val, sizeof(CORBA_float));
break;
case CORBA_tk_double:
alignval(val, ORBIT_ALIGNOF_CORBA_DOUBLE);
ret = PyFloat_FromDouble(getval(val, CORBA_double));
advanceptr(val, sizeof(CORBA_double));
break;
case CORBA_tk_boolean:
ret = getval(val, CORBA_boolean) ? Py_True : Py_False;
Py_INCREF(ret);
advanceptr(val, sizeof(CORBA_boolean));
break;
case CORBA_tk_char: {
char charbuf[2];
charbuf[0] = getval(val, CORBA_char);
charbuf[1] = '\0';
ret = PyString_FromString(charbuf);
advanceptr(val, sizeof(CORBA_char));
break;
}
case CORBA_tk_octet:
ret = PyInt_FromLong(getval(val, CORBA_octet));
advanceptr(val, sizeof(CORBA_octet));
break;
case CORBA_tk_any:
alignval(val, ORBIT_ALIGNOF_CORBA_ANY);
ret = pycorba_any_new(&getval(val, CORBA_any));
advanceptr(val, sizeof(CORBA_any));
break;
case CORBA_tk_TypeCode:
alignval(val, ORBIT_ALIGNOF_CORBA_POINTER);
ret = pycorba_typecode_new(getval(val, CORBA_TypeCode));
advanceptr(val, sizeof(CORBA_TypeCode));
break;
case CORBA_tk_Principal:
g_warning("can't demarshal Principal's");
break;
case CORBA_tk_objref:
alignval(val, ORBIT_ALIGNOF_CORBA_POINTER);
ret = pycorba_object_new_with_type(getval(val, CORBA_Object), tc);
advanceptr(val, sizeof(CORBA_Object));
break;
case CORBA_tk_struct:
case CORBA_tk_except: {
PyObject *stub;
PyObject *instance;
gint i;
alignval(val, tc->c_align);
stub = pyorbit_get_stub(tc);
if (!stub) {
if (tc->kind == CORBA_tk_struct)
stub = (PyObject *)&PyBaseObject_Type;
else
stub = pyorbit_exception;
}
instance = PyObject_CallFunction(stub, "()");
if (!instance)
break;
if (stub == pyorbit_exception) {
PyObject *pytc = pycorba_typecode_new(tc);
PyObject_SetAttrString(instance, "__typecode__", pytc);
Py_DECREF(pytc);
}
for (i = 0; i < tc->sub_parts; i++) {
PyObject *item;
gchar *pyname;
item = demarshal_value(tc->subtypes[i], val);
if (!item) {
Py_DECREF(instance);
break;
}
pyname = _pyorbit_escape_name(tc->subnames[i]);
PyObject_SetAttrString(instance, pyname, item);
g_free(pyname);
Py_DECREF(item);
}
if (i == tc->sub_parts) ret = instance;
break;
}
case CORBA_tk_union: {
PyObject *stub, *instance, *discrim, *subval;
CORBA_TypeCode subtc;
gint i, sz = 0;
gconstpointer body;
alignval(val, MAX(tc->c_align, tc->discriminator->c_align));
stub = pyorbit_get_stub(tc);
if (!stub) {
if (tc->kind == CORBA_tk_struct)
stub = (PyObject *)&PyBaseObject_Type;
else
stub = PyExc_Exception;
}
instance = PyObject_CallFunction(stub, "()");
if (!instance)
break;
discrim = demarshal_value(tc->discriminator, val);
if (!discrim) {
Py_DECREF(instance);
break;
}
subtc = get_union_tc(tc, discrim);
if (!subtc) {
Py_DECREF(instance);
Py_DECREF(discrim);
break;
}
PyObject_SetAttrString(instance, "_d", discrim);
Py_DECREF(discrim);
for (i = 0; i < tc->sub_parts; i++)
sz = MAX(sz, ORBit_gather_alloc_info(tc->subtypes[i]));
alignval(val, tc->c_align);
body = *val;
subval = demarshal_value(subtc, &body);
if (!subval) {
Py_DECREF(instance);
break;
}
PyObject_SetAttrString(instance, "_v", subval);
Py_DECREF(subval);
ret = instance;
advanceptr(val, sz);
break;
}
case CORBA_tk_enum:
alignval(val, ORBIT_ALIGNOF_CORBA_LONG);
ret = pycorba_enum_from_long(tc, getval(val, CORBA_unsigned_long));
advanceptr(val, sizeof(CORBA_unsigned_long));
break;
case CORBA_tk_string: {
CORBA_string str;
alignval(val, ORBIT_ALIGNOF_CORBA_POINTER);
str = getval(val, CORBA_string);
advanceptr(val, sizeof(CORBA_string));
if (str) {
ret = PyString_FromString(str);
} else {
Py_INCREF(Py_None);
ret = Py_None;
}
break;
}
case CORBA_tk_sequence: {
const CORBA_sequence_CORBA_octet *sval;
gconstpointer seqval;
alignval(val, ORBIT_ALIGNOF_CORBA_SEQ);
sval = (CORBA_sequence_CORBA_octet *)*val;
advanceptr(val, sizeof(CORBA_sequence_CORBA_octet));
switch (tc->subtypes[0]->kind) {
case CORBA_tk_char:
case CORBA_tk_octet:
ret = PyString_FromStringAndSize((char *) sval->_buffer, sval->_length);
break;
default: {
PyObject *list;
Py_ssize_t i;
int align;
list = PyList_New(sval->_length);
align = tc->subtypes[0]->c_align;
seqval = sval->_buffer;
for (i = 0; i < sval->_length; i++) {
PyObject *item;
alignval(&seqval, align);
item = demarshal_value(tc->subtypes[0], &seqval);
if (!item) {
Py_DECREF(list);
break;
}
PyList_SetItem(list, i, item);
}
if (i == sval->_length) ret = list;
}
}
break;
}
case CORBA_tk_array:
switch (tc->subtypes[0]->kind) {
case CORBA_tk_char:
case CORBA_tk_octet:
ret = PyString_FromStringAndSize(*val, tc->length);
advanceptr(val, tc->length);
break;
default: {
PyObject *list;
gint i, align;
list = PyList_New(tc->length);
align = tc->subtypes[0]->c_align;
for (i = 0; i < tc->length; i++) {
PyObject *item;
alignval(val, align);
item = demarshal_value(tc->subtypes[0], val);
if (!item) {
Py_DECREF(list);
break;
}
PyList_SetItem(list, i, item);
}
if (i == tc->length) ret = list;
}
}
break;
case CORBA_tk_longlong:
alignval(val, ORBIT_ALIGNOF_CORBA_LONG_LONG);
ret = PyLong_FromLongLong(getval(val, CORBA_long_long));
advanceptr(val, sizeof(CORBA_long_long));
break;
case CORBA_tk_ulonglong:
alignval(val, ORBIT_ALIGNOF_CORBA_LONG_LONG);
ret = PyLong_FromUnsignedLongLong(getval(val, CORBA_unsigned_long_long));
advanceptr(val, sizeof(CORBA_unsigned_long_long));
break;
case CORBA_tk_longdouble:
g_warning("can't demarshal long doubles");
break;
case CORBA_tk_wchar: {
Py_UNICODE uchar;
alignval(val, ORBIT_ALIGNOF_CORBA_SHORT);
uchar = getval(val, CORBA_wchar);
ret = PyUnicode_FromUnicode(&uchar, 1);
advanceptr(val, sizeof(CORBA_wchar));
break;
}
case CORBA_tk_wstring: {
CORBA_wstring wstr;
alignval(val, ORBIT_ALIGNOF_CORBA_POINTER);
wstr = getval(val, CORBA_wstring);
advanceptr(val, sizeof(CORBA_wstring));
if (wstr) {
gint i, length = CORBA_wstring_len(wstr);
Py_UNICODE *ustr;
ustr = g_new(Py_UNICODE, length);
for (i = 0; i < length; i++) ustr[i] = wstr[i];
ret = PyUnicode_FromUnicode(ustr, length);
g_free(ustr);
} else {
Py_INCREF(Py_None);
ret = Py_None;
}
break;
}
default:
g_warning("unhandled typecode: %s, (kind==%d)", tc->repo_id, tc->kind);
break;
}
return ret;
}
static PyObject *
pymatecomponent_corbatypecode_from_value(const GValue *value)
{
return pycorba_typecode_new(g_value_get_boxed(value));
}
static PyObject *
pycorba_any_typecode(PyCORBA_Any *self, void *closure)
{
return pycorba_typecode_new(self->any._type);
}
