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_corbaany_from_value(const GValue *value) { return pycorba_any_new(g_value_get_boxed(value)); }