SwigType *SwigType_ltype(const SwigType *s) { String *result; String *element; SwigType *td, *tc = 0; List *elements; int nelements, i; int firstarray = 1; int notypeconv = 0; result = NewStringEmpty(); tc = Copy(s); /* Nuke all leading qualifiers */ while (SwigType_isqualifier(tc)) { Delete(SwigType_pop(tc)); } if (SwigType_issimple(tc)) { /* Resolve any typedef definitions */ SwigType *tt = Copy(tc); td = 0; while ((td = SwigType_typedef_resolve(tt))) { if (td && (SwigType_isconst(td) || SwigType_isarray(td) || SwigType_isreference(td))) { /* We need to use the typedef type */ Delete(tt); break; } else if (td) { Delete(tt); tt = td; } } if (td) { Delete(tc); tc = td; } } elements = SwigType_split(tc); nelements = Len(elements); /* Now, walk the type list and start emitting */ for (i = 0; i < nelements; i++) { element = Getitem(elements, i); /* when we see a function, we need to preserve the following types */ if (SwigType_isfunction(element)) { notypeconv = 1; } if (SwigType_isqualifier(element)) { /* Do nothing. Ignore */ } else if (SwigType_ispointer(element)) { Append(result, element); firstarray = 0; } else if (SwigType_ismemberpointer(element)) { Append(result, element); firstarray = 0; } else if (SwigType_isreference(element)) { if (notypeconv) { Append(result, element); } else { Append(result, "p."); } firstarray = 0; } else if (SwigType_isarray(element) && firstarray) { if (notypeconv) { Append(result, element); } else { Append(result, "p."); } firstarray = 0; } else if (SwigType_isenum(element)) { int anonymous_enum = (Cmp(element, "enum ") == 0); if (notypeconv || !anonymous_enum) { Append(result, element); } else { Append(result, "int"); } } else { Append(result, element); } } Delete(elements); Delete(tc); return result; }
SwigType *SwigType_default(SwigType *t) { String *r1, *def; String *r = 0; char *cr; #ifdef SWIG_DEFAULT_CACHE if (!default_cache) default_cache = NewHash(); r = Getattr(default_cache, t); if (r) { return Copy(r); } #endif if (SwigType_isvarargs(t)) { return 0; } r = t; while ((r1 = SwigType_typedef_resolve(r))) { if (r != t) Delete(r); r = r1; } if (SwigType_isqualifier(r)) { String *q; if (r == t) r = Copy(t); q = SwigType_pop(r); if (strstr(Char(r), "SWIGTYPE")) { Delete(q); def = r; return def; } Delete(q); } cr = Char(r); if (strcmp(cr, "p.SWIGTYPE") == 0) { def = NewString("SWIGTYPE"); } else if (SwigType_ispointer(r)) { #ifdef SWIG_NEW_TYPE_DEFAULT SwigType *nr = Copy(r); SwigType_del_pointer(nr); def = SwigType_isfunction(nr) ? NewStringEmpty() : NewString("p."); SwigType_add_default(def, nr); Delete(nr); #else def = NewString("p.SWIGTYPE"); #endif } else if (strcmp(cr, "r.SWIGTYPE") == 0) { def = NewString("SWIGTYPE"); } else if (SwigType_isreference(r)) { #ifdef SWIG_NEW_TYPE_DEFAULT SwigType *nr = Copy(r); SwigType_del_reference(nr); def = NewString("r."); SwigType_add_default(def, nr); Delete(nr); #else def = NewString("r.SWIGTYPE"); #endif } else if (SwigType_isarray(r)) { if (strcmp(cr, "a().SWIGTYPE") == 0) { def = NewString("p.SWIGTYPE"); } else if (strcmp(cr, "a(ANY).SWIGTYPE") == 0) { def = NewString("a().SWIGTYPE"); } else { int i, empty = 0; int ndim = SwigType_array_ndim(r); SwigType *nr = Copy(r); for (i = 0; i < ndim; i++) { String *dim = SwigType_array_getdim(r, i); if (!Len(dim)) { char *c = Char(nr); empty = strstr(c, "a(ANY).") != c; } Delete(dim); } if (empty) { def = NewString("a()."); } else { def = NewString("a(ANY)."); } #ifdef SWIG_NEW_TYPE_DEFAULT SwigType_del_array(nr); SwigType_add_default(def, nr); #else Append(def, "SWIGTYPE"); #endif Delete(nr); } } else if (SwigType_ismemberpointer(r)) { if (strcmp(cr, "m(CLASS).SWIGTYPE") == 0) { def = NewString("p.SWIGTYPE"); } else { def = NewString("m(CLASS).SWIGTYPE"); } } else if (SwigType_isenum(r)) { if (strcmp(cr, "enum SWIGTYPE") == 0) { def = NewString("SWIGTYPE"); } else { def = NewString("enum SWIGTYPE"); } } else if (SwigType_isfunction(r)) { if (strcmp(cr, "f(ANY).SWIGTYPE") == 0) { def = NewString("p.SWIGTYPE"); } else { def = NewString("p.f(ANY).SWIGTYPE"); } } else { def = NewString("SWIGTYPE"); } if (r != t) Delete(r); if (Equal(def, t)) { Delete(def); def = 0; } #ifdef SWIG_DEFAULT_CACHE /* The cache produces strange results, see enum_template.i case */ if (def) { String *cdef = Copy(def); Setattr(default_cache, t, cdef); Delete(cdef); } #endif /* Printf(stderr,"type : def %s : %s\n", t, def); */ return def; }
SwigType *SwigType_default_deduce(const SwigType *t) { SwigType *r = NewStringEmpty(); List *l; Iterator it; int numitems; l = SwigType_split(t); numitems = Len(l); if (numitems >= 1) { String *last_subtype = Getitem(l, numitems-1); int is_enum = SwigType_isenum(last_subtype); if (numitems >=2 ) { String *subtype = Getitem(l, numitems-2); /* last but one */ if (SwigType_isarray(subtype)) { if (is_enum) { /* enum deduction, enum SWIGTYPE => SWIGTYPE */ Setitem(l, numitems-1, NewString("SWIGTYPE")); } else { /* array deduction, a(ANY). => a(). => p. */ String *deduced_subtype = 0; if (Strcmp(subtype, "a().") == 0) { deduced_subtype = NewString("p."); } else if (Strcmp(subtype, "a(ANY).") == 0) { deduced_subtype = NewString("a()."); } else { assert(0); } Setitem(l, numitems-2, deduced_subtype); } } else if (SwigType_ismemberpointer(subtype)) { /* member pointer deduction, m(CLASS). => p. */ Setitem(l, numitems-2, NewString("p.")); } else if (is_enum && !SwigType_isqualifier(subtype)) { /* enum deduction, enum SWIGTYPE => SWIGTYPE */ Setitem(l, numitems-1, NewString("SWIGTYPE")); } else { /* simple type deduction, eg, r.p.p. => r.p. */ /* also function pointers eg, p.f(ANY). => p. */ Delitem(l, numitems-2); } } else { if (is_enum) { /* enum deduction, enum SWIGTYPE => SWIGTYPE */ Setitem(l, numitems-1, NewString("SWIGTYPE")); } else { /* delete the only item, we are done with deduction */ Delitem(l, 0); } } } else { assert(0); } for (it = First(l); it.item; it = Next(it)) { Append(r, it.item); } if (Len(r) == 0) { Delete(r); r = 0; } Delete(l); return r; }