jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Started the (most painful) process of dropping type attributes behind a function call interface.

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@609 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Dave Beazley 2000-07-25 04:02:31 +00:00
commit 5c7d202825
15 changed files with 1152 additions and 1233 deletions
Download patch file Download diff file Expand all files Collapse all files

39
Source/Modules1.1/guile.cxx
View file

@ -360,7 +360,7 @@ GUILE::get_pointer (char *iname, int parm, DataType *t,
{
/* Pointers are smobs */
Printf(f->code, " if (SWIG_Guile_GetPtr_Str(s_%d,(void **) &_arg%d", parm, parm);
if (t->type == T_VOID)
if (DataType_type(t) == T_VOID)
Printf(f->code, ", (char *) 0)) {\n");
else
Printv(f->code, ", \"", DataType_manglestr(t), "\")) {\n", 0);
@ -393,7 +393,7 @@ throw_unhandled_guile_type_error (DataType *d)
{
fflush (stdout);
Printf (stderr, "ERROR: Unhandled GUILE type error.\n");
Printf (stderr, " type %d\n", d->type);
Printf (stderr, " type %d\n", DataType_type(d));
Printf (stderr, " name %s\n", d->name);
Printf (stderr, " is_pointer %d\n", d->is_pointer);
Printf (stderr, "implicit_ptr %d\n", d->implicit_ptr);
@ -441,7 +441,7 @@ GUILE::create_function (char *name, char *iname, DataType *d, ParmList *l)
if (Getignore(p))
continue;
if ((pt->type != T_VOID) || (pt->is_pointer)) {
if (DataType_type(pt) != T_VOID) {
if (!first_arg)
Printf(f->def,", ");
Printf(f->def,"SCM s_%d", i);
@ -529,7 +529,7 @@ GUILE::create_function (char *name, char *iname, DataType *d, ParmList *l)
// Now have return value, figure out what to do with it.
if (d->type == T_VOID)
if (DataType_type(d) == T_VOID)
Printv(f->code, tab4, "gswig_result = GH_UNSPECIFIED;\n", 0);
else if ((tm = typemap_lookup ((char*)"out", typemap_lang,
d, name, (char*)"result", (char*)"gswig_result", f))) {
@ -631,11 +631,11 @@ GUILE::link_variable (char *name, char *iname, DataType *t)
proc_name = NewString(iname);
Replace(proc_name,"_", "-",DOH_REPLACE_ANY);
if ((t->type != T_USER) || (t->is_pointer)) {
if (DataType_type(t) != T_USER) {
Printf (f_wrappers, "SCM %s(SCM s_0) {\n", var_name);
if (!(Status & STAT_READONLY) && t->type == T_CHAR && t->is_pointer==1) {
if (!(Status & STAT_READONLY) && DataType_type(t) == T_STRING) {
Printf (f_wrappers, "\t char *_temp;\n");
Printf (f_wrappers, "\t int _len;\n");
}
@ -657,7 +657,7 @@ GUILE::link_variable (char *name, char *iname, DataType *t)
Printf (f_wrappers, "%s\n", tm);
}
else if (t->is_pointer) {
if ((t->type == T_CHAR) && (t->is_pointer == 1)) {
if (DataType_type(t) == T_STRING) {
Printf (f_wrappers, "\t\t _temp = gh_scm2newstr(s_0, &_len);\n");
Printf (f_wrappers, "\t\t if (%s) { free(%s);}\n", name, name);
Printf (f_wrappers, "\t\t %s = (char *) "
@ -669,7 +669,7 @@ GUILE::link_variable (char *name, char *iname, DataType *t)
/* MK: I would like to use SWIG_Guile_GetPtr here */
Printf (f_wrappers, "\t if (SWIG_Guile_GetPtr_Str(s_0, "
"(void **) &%s, ", name);
if (t->type == T_VOID)
if (DataType_type(t) == T_VOID)
Printf (f_wrappers, "(char *) 0)) {\n");
else
Printf (f_wrappers, "\"%s\")) {\n", DataType_manglestr(t));
@ -692,7 +692,7 @@ GUILE::link_variable (char *name, char *iname, DataType *t)
Printf (f_wrappers, "%s\n", tm);
}
else if (t->is_pointer) {
if ((t->type == T_CHAR) && (t->is_pointer == 1)) {
if (DataType_type(t) == T_STRING) {
Printf (f_wrappers, "\t gswig_result = gh_str02scm(%s);\n", name);
} else {
// Is an ordinary pointer type.
@ -748,7 +748,7 @@ GUILE::declare_const (char *name, char *, DataType *type, char *value)
proc_name = NewString(name);
Replace(proc_name,"_", "-", DOH_REPLACE_ANY);
if ((type->type == T_USER) && (!type->is_pointer)) {
if (DataType_type(type) == T_USER) {
Printf (stderr, "%s : Line %d. Unsupported constant value.\n",
input_file, line_number);
return;
@ -756,9 +756,9 @@ GUILE::declare_const (char *name, char *, DataType *type, char *value)
// See if there's a typemap
if ((type->type == T_CHAR) && (type->is_pointer == 1)) {
if (DataType_type(type) == T_STRING) {
rvalue = NewStringf("\"%s\"", value);
} else if ((type->type == T_CHAR) && (type->is_pointer == 0)) {
} else if (DataType_type(type) == T_CHAR) {
rvalue = NewStringf("\'%s\'", value);
} else {
rvalue = NewString(value);
@ -770,12 +770,11 @@ GUILE::declare_const (char *name, char *, DataType *type, char *value)
// Create variable and assign it a value
Printf (f_header, "static %s %s = ", DataType_lstr(type,0), var_name);
if ((type->type == T_CHAR) && (type->is_pointer <= 1)) {
if (DataType_type(type) == T_STRING) {
Printf (f_header, "\"%s\";\n", value);
} else {
Printf (f_header, "%s;\n", value);
}
// Now create a variable declaration
link_variable (var_name, name, type);
@ -796,7 +795,7 @@ GUILE::usage_var (char *iname, DataType *t, DOHString *usage)
{
Printv(usage, "(", iname, " [value])", 0);
if (!((t->type != T_USER) || (t->is_pointer))) {
if ((DataType_type(t) == T_USER) || (DataType_type(t) == T_VOID)) {
Printf(usage," - unsupported");
}
}
@ -828,7 +827,7 @@ GUILE::usage_func (char *iname, DataType *d, ParmList *l, DOHString *usage)
// Print the type. If the parameter has been named, use that as well.
if ((pt->type != T_VOID) || (pt->is_pointer)) {
if (DataType_type(pt) != T_VOID) {
// Print the type.
Printv(usage, " <", pt->name, 0);
@ -877,7 +876,7 @@ GUILE::usage_returns (char *iname, DataType *d, ParmList *l, DOHString *usage)
// Print the type. If the parameter has been named, use that as well.
if ((pt->type != T_VOID) || (pt->is_pointer)) {
if (DataType_type(pt) != T_VOID) {
++have_param;
// Print the type.
@ -892,9 +891,9 @@ GUILE::usage_returns (char *iname, DataType *d, ParmList *l, DOHString *usage)
}
// See if we stick on the function return type.
if (d->type != T_VOID || have_param == 0) {
if ((DataType_type(d) != T_VOID) || (have_param == 0)) {
++have_param;
if (d->type == T_VOID)
if (DataType_type(d) == T_VOID)
Insert(param,0," unspecified ");
else {
Insert(param,0,"# ");
@ -929,3 +928,5 @@ GUILE::usage_const (char *iname, DataType *, char *value, DOHString *usage)
{
Printv(usage, "(", iname, " ", value, ")", 0);
}

86
Source/Modules1.1/java.cxx
View file

@ -21,6 +21,13 @@
*******************************************************************************
*/
/* !!!!!!!
* DB 7/24/00: Is there any way to clean up the implementation of this module?
* I've tried to bring it as far as I can with core changes, but it's getting
* to be a little rough.
* !!!!!!!
*/
#include <ctype.h>
#include "mod11.h"
@ -65,7 +72,7 @@ static DOHString *registerNativesList = 0;
char *JAVA::SwigTcToJniType(DataType *t, int ret) {
if(t->is_pointer == 1) {
switch(t->type) {
switch(DataType_Gettypecode(t)) {
case T_INT: return (char*)"jintArray";
case T_SHORT: return (char*)"jshortArray";
case T_LONG: return (char*)"jlongArray";
@ -86,7 +93,7 @@ char *JAVA::SwigTcToJniType(DataType *t, int ret) {
return (char*)"jlong";
else return (char*)"jlongArray";
} else {
switch(t->type) {
switch(DataType_Gettypecode(t)) {
case T_INT: return (char*)"jint";
case T_SHORT: return (char*)"jshort";
case T_LONG: return (char*)"jlong";
@ -103,13 +110,13 @@ char *JAVA::SwigTcToJniType(DataType *t, int ret) {
case T_USER: return (char*)"jlong";
}
}
Printf(stderr, "SwigTcToJniType: unhandled SWIG type %d, %s\n", t->type, (char *) t->name);
Printf(stderr, "SwigTcToJniType: unhandled SWIG type %s\n", DataType_str(t,0));
return NULL;
}
char *JAVA::SwigTcToJavaType(DataType *t, int ret, int inShadow) {
if(t->is_pointer == 1) {
switch(t->type) {
switch(DataType_Gettypecode(t)) {
case T_INT: return (char*)"int []";
case T_SHORT: return (char*)"short []";
case T_LONG: return (char*)"long []";
@ -132,7 +139,7 @@ char *JAVA::SwigTcToJavaType(DataType *t, int ret, int inShadow) {
return (char*)"long";
else return (char*)"long []";
} else {
switch(t->type) {
switch(DataType_Gettypecode(t)) {
case T_INT: return (char*)"int";
case T_SHORT: return (char*)"short";
case T_LONG: return (char*)"long";
@ -149,13 +156,13 @@ char *JAVA::SwigTcToJavaType(DataType *t, int ret, int inShadow) {
case T_USER: return (char*)"long";
}
}
Printf(stderr, "SwigTcToJavaType: unhandled SWIG type %d, %s\n", t->type, (char *) t->name);
Printf(stderr, "SwigTcToJavaType: unhandled SWIG type %s\n", DataType_str(t,0));
return NULL;
}
char *JAVA::SwigTcToJniScalarType(DataType *t) {
if(t->is_pointer == 1) {
switch(t->type) {
switch(DataType_Gettypecode(t)) {
case T_INT: return (char*)"Int";
case T_SHORT: return (char*)"Short";
case T_LONG: return (char*)"Long";
@ -175,13 +182,13 @@ char *JAVA::SwigTcToJniScalarType(DataType *t) {
return (char*)"Long";
}
Printf(stderr, "SwigTcToJniScalarType: unhandled SWIG type %d, %s\n", t->type, (char *) t->name);
Printf(stderr, "SwigTcToJniScalarType: unhandled SWIG type %s\n", DataType_str(t,0));
return NULL;
}
char *JAVA::JavaMethodSignature(DataType *t, int ret, int inShadow) {
if(t->is_pointer == 1) {
switch(t->type) {
switch(DataType_Gettypecode(t)) {
case T_INT: return (char*)"[I";
case T_SHORT: return (char*)"[S";
case T_LONG: return (char*)"[J";
@ -203,7 +210,7 @@ char *JAVA::JavaMethodSignature(DataType *t, int ret, int inShadow) {
if(ret) return (char*)"J";
else return (char*)"[J";
} else {
switch(t->type) {
switch(DataType_Gettypecode(t)) {
case T_INT: return (char*)"I";
case T_SHORT: return (char*)"S";
case T_LONG: return (char*)"J";
@ -220,7 +227,7 @@ char *JAVA::JavaMethodSignature(DataType *t, int ret, int inShadow) {
case T_USER: return (char*)"J";
}
}
Printf(stderr, "JavaMethodSignature: unhandled SWIG type %d, %s\n", t->type, (char *) t->name);
Printf(stderr, "JavaMethodSignature: unhandled SWIG type %s\n", DataType_str(t,0));
return NULL;
}
@ -559,7 +566,7 @@ void JAVA::create_function(char *name, char *iname, DataType *t, ParmList *l)
javaReturnSignature = JavaMethodSignature(t, 1, 0);
}
if(t->type != T_VOID || t->is_pointer) {
if (DataType_type(t) != T_VOID) {
Wrapper_add_localv(f,"_jresult", jnirettype, "_jresult = 0",0);
}
@ -633,13 +640,13 @@ void JAVA::create_function(char *name, char *iname, DataType *t, ParmList *l)
} else {
if(!pt->is_pointer)
Printv(f->code, tab4, target, " = (", DataType_lstr(pt,0), ") ", source, ";\n", 0);
else if((pt->type == T_VOID && pt->is_pointer == 1) ||
(pt->type == T_USER && pt->is_pointer == 1)) {
else if((DataType_Gettypecode(pt) == T_VOID && pt->is_pointer == 1) ||
(DataType_Gettypecode(pt) == T_USER && pt->is_pointer == 1)) {
pt->is_pointer++;
Printv(f->code, tab4, target, " = *(", DataType_lstr(pt,0), ")&", source, ";\n", 0);
pt->is_pointer--;
} else {
if(pt->type == T_CHAR && pt->is_pointer == 1) {
if(DataType_type(pt) == T_STRING) {
Printv(f->code, tab4, target, " = (", source, ") ? (char *)", JNICALL((char*)"GetStringUTFChars"), source, ", 0) : NULL;\n", 0);
} else {
char *scalarType = SwigTcToJniScalarType(pt);
@ -700,10 +707,10 @@ void JAVA::create_function(char *name, char *iname, DataType *t, ParmList *l)
} else {
// if(pt->is_pointer && pt->type != T_USER && pt->type != T_VOID) {
if(pt->is_pointer) {
if(pt->type == T_CHAR && pt->is_pointer == 1) {
if(DataType_type(pt) == T_STRING) {
Printv(outarg, tab4, "if(", target,") ", JNICALL((char*)"ReleaseStringUTFChars"), source, ", ", target, ");\n", 0);
} else if((pt->type == T_VOID && pt->is_pointer == 1) ||
(pt->type == T_USER && pt->is_pointer == 1)) {
} else if(((DataType_Gettypecode(pt) == T_VOID) && pt->is_pointer == 1) ||
((DataType_Gettypecode(pt) == T_USER) && pt->is_pointer == 1)) {
// nothing to do
} else {
char *scalarType = SwigTcToJniScalarType(pt);
@ -749,23 +756,23 @@ void JAVA::create_function(char *name, char *iname, DataType *t, ParmList *l)
// Return value if necessary
if((t->type != T_VOID || t->is_pointer) && !native_func) {
if((DataType_type(t) != T_VOID) && !native_func) {
if ((tm = typemap_lookup((char*)"out",typemap_lang,t,iname,(char*)"result",(char*)"_jresult"))) {
Printf(f->code,"%s\n", tm);
} else {
if(t->is_pointer == 0 && t->type == T_USER) { /* return by value */
if(DataType_type(t) == T_USER) { /* return by value */
t->is_pointer=2;
Printv(f->code, tab4, "*(", DataType_lstr(t,0), ")&_jresult = result;\n", 0);
t->is_pointer=0;
} else if(t->is_pointer == 0 && t->type != T_USER) {
} else if(t->is_pointer == 0 && (DataType_Gettypecode(t) != T_USER)) {
Printv(f->code, tab4, "_jresult = (", jnirettype, ") result;\n", 0);
} else if((t->type == T_VOID && t->is_pointer == 1) ||
(t->type == T_USER && t->is_pointer == 1)) {
} else if(((DataType_Gettypecode(t) == T_VOID) && t->is_pointer == 1) ||
((DataType_Gettypecode(t) == T_USER) && t->is_pointer == 1)) {
t->is_pointer++;
Printv(f->code, tab4, "*(", DataType_lstr(t,0), ")&_jresult = result;\n", 0);
t->is_pointer--;
} else {
if(t->type == T_CHAR && t->is_pointer == 1) {
if(DataType_type(t) == T_STRING) {
Printv(f->code, tab4, "if(result != NULL)\n", 0);
Printv(f->code, tab8, "_jresult = (jstring)", JNICALL((char*)"NewStringUTF"), "result);\n", 0);
} else {
@ -792,14 +799,14 @@ void JAVA::create_function(char *name, char *iname, DataType *t, ParmList *l)
}
}
if((t->type != T_VOID || t->is_pointer) && !native_func) {
if((DataType_type(t) != T_VOID) && !native_func) {
if ((tm = typemap_lookup((char*)"ret",typemap_lang,t,iname,(char*)"result",(char*)"_jresult", NULL))) {
Printf(f->code,"%s\n", tm);
}
}
// Wrap things up (in a manner of speaking)
if(t->type != T_VOID || t->is_pointer)
if(DataType_type(t) != T_VOID)
Printv(f->code, tab4, "return _jresult;\n", 0);
Printf(f->code, "}\n");
@ -811,7 +818,6 @@ void JAVA::create_function(char *name, char *iname, DataType *t, ParmList *l)
if(!native_func)
Wrapper_print(f,f_wrappers);
// If registerNatives is active, store the table entry for this method
if (useRegisterNatives) {
Printv(registerNativesList,
@ -873,7 +879,7 @@ void JAVA::declare_const(char *name, char *iname, DataType *type, char *value) {
} else
Printf(jfile, " public final static %s %s = %s;\n\n", jtype, jname, value);
} else {
if(type->type == T_CHAR && type->is_pointer == 1) {
if(DataType_type(type) == T_STRING) {
Printf(jfile, " public final static String %s = \"%s\";\n\n", jname, value);
} else {
emit_set_get(name,iname, type);
@ -1053,13 +1059,13 @@ void JAVA::cpp_member_func(char *name, char *iname, DataType *t, ParmList *l) {
char *javarettype = JavaTypeFromTypemap((char*)"jtype", typemap_lang, t, iname);
if(!javarettype) javarettype = SwigTcToJavaType(t, 1, 0);
char *shadowrettype = JavaTypeFromTypemap((char*)"jstype", typemap_lang, t, iname);
if(!shadowrettype && t->type == T_USER && t->is_pointer <= 1) {
if(!shadowrettype && (DataType_Gettypecode(t) == T_USER) && t->is_pointer <= 1) {
shadowrettype = GetChar(shadow_classes,t->name);
}
Printf(f_shadow, " public %s %s(", (shadowrettype) ? shadowrettype : javarettype, iname);
if((t->type != T_VOID || t->is_pointer)) {
if(DataType_type(t) != T_VOID) {
Printf(nativecall,"return ");
if(shadowrettype) {
Printv(nativecall, "new ", shadowrettype, "(new Long(", 0);
@ -1081,7 +1087,7 @@ void JAVA::cpp_member_func(char *name, char *iname, DataType *t, ParmList *l) {
sprintf(arg,"arg%d",i);
}
if(pt->type == T_USER && pt->is_pointer <= 1 && Getattr(shadow_classes,pt->name)) {
if((DataType_Gettypecode(pt) == T_USER) && pt->is_pointer <= 1 && Getattr(shadow_classes,pt->name)) {
Printv(nativecall, ", ", arg, "._self", 0);
} else Printv(nativecall, ", ", arg, 0);
@ -1089,7 +1095,7 @@ void JAVA::cpp_member_func(char *name, char *iname, DataType *t, ParmList *l) {
if(!jtype) jtype = SwigTcToJavaType(pt, 0, 0);
char *jstype = JavaTypeFromTypemap((char*)"jstype", typemap_lang, pt, pn);
if(!jstype && pt->type == T_USER && pt->is_pointer <= 1) {
if(!jstype && (DataType_Gettypecode(pt) == T_USER) && pt->is_pointer <= 1) {
jstype = GetChar(shadow_classes,pt->name);
}
@ -1100,7 +1106,7 @@ void JAVA::cpp_member_func(char *name, char *iname, DataType *t, ParmList *l) {
}
}
if((t->type != T_VOID) && shadowrettype)
if((DataType_Gettypecode(t) != T_VOID) && shadowrettype)
Printf(nativecall, "))");
Printf(nativecall,");\n");
@ -1125,13 +1131,13 @@ void JAVA::cpp_static_func(char *name, char *iname, DataType *t, ParmList *l) {
char *javarettype = JavaTypeFromTypemap((char*)"jtype", typemap_lang, t, iname);
if(!javarettype) javarettype = SwigTcToJavaType(t, 1, 0);
char *shadowrettype = JavaTypeFromTypemap((char*)"jstype", typemap_lang, t, iname);
if(!shadowrettype && t->type == T_USER && t->is_pointer <= 1) {
if(!shadowrettype && (DataType_Gettypecode(t) == T_USER) && t->is_pointer <= 1) {
shadowrettype = GetChar(shadow_classes,t->name);
}
Printf(f_shadow, " public static %s %s(", (shadowrettype) ? shadowrettype : javarettype, iname);
if((t->type != T_VOID || t->is_pointer)) {
if(DataType_type(t) != T_VOID) {
Printf(nativecall, "return ");
if(shadowrettype) {
Printv(nativecall, "new ", shadowrettype, "(new Long(", 0);
@ -1156,7 +1162,7 @@ void JAVA::cpp_static_func(char *name, char *iname, DataType *t, ParmList *l) {
if(gencomma) Printf(nativecall,", ");
if(pt->type == T_USER && pt->is_pointer <= 1 && Getattr(shadow_classes,pt->name)) {
if((DataType_Gettypecode(pt) == T_USER) && pt->is_pointer <= 1 && Getattr(shadow_classes,pt->name)) {
Printv(nativecall, arg, "._self", 0);
} else Printv(nativecall,arg,0);
@ -1166,7 +1172,7 @@ void JAVA::cpp_static_func(char *name, char *iname, DataType *t, ParmList *l) {
if(!jtype) jtype = SwigTcToJavaType(pt, 0, 0);
char *jstype = JavaTypeFromTypemap((char*)"jstype", typemap_lang, pt, pn);
if(!jstype && pt->type == T_USER && pt->is_pointer <= 1) {
if(!jstype && (DataType_Gettypecode(pt) == T_USER) && pt->is_pointer <= 1) {
jstype = GetChar(shadow_classes, pt->name);
}
@ -1178,7 +1184,7 @@ void JAVA::cpp_static_func(char *name, char *iname, DataType *t, ParmList *l) {
}
if((t->type != T_VOID || t->is_pointer) && shadowrettype)
if((DataType_type(t) != T_VOID) && shadowrettype)
Printf(nativecall,"))");
Printf(nativecall,");\n");
@ -1231,7 +1237,7 @@ void JAVA::cpp_constructor(char *name, char *iname, ParmList *l) {
// Add to java function header
Printf(f_shadow, "%s %s", (jstype) ? jstype : jtype, arg);
if(pt->type == T_USER && pt->is_pointer <= 1 && Getattr(shadow_classes,pt->name)) {
if((DataType_Gettypecode(pt) == T_USER) && pt->is_pointer <= 1 && Getattr(shadow_classes,pt->name)) {
Printv(nativecall,arg, "._self", 0);
} else Printv(nativecall, arg, 0);
@ -1332,3 +1338,5 @@ void JAVA::cpp_declare_const(char *name, char *iname, DataType *type, char *valu
member_func = 0;
}

32
Source/Modules1.1/mzscheme.cxx
View file

@ -258,7 +258,7 @@ throw_unhandled_mzscheme_type_error (DataType *d)
{
fflush (stdout);
Printf (stderr, "ERROR: Unhandled MZSCHEME type error.\n");
Printf (stderr, " type %d\n", d->type);
Printf (stderr, " type %d\n", DataType_Gettypecode(d));
Printf (stderr, " name %s\n", d->name);
Printf (stderr, " is_pointer %d\n", d->is_pointer);
Printf (stderr, "implicit_ptr %d\n", d->implicit_ptr);
@ -387,7 +387,7 @@ MZSCHEME::create_function (char *name, char *iname, DataType *d, ParmList *l)
// Now have return value, figure out what to do with it.
if (d->type == T_VOID) {
if (DataType_type(d) == T_VOID) {
if(!argout_set)
Printv(f->code, tab4, "swig_result = scheme_void;\n", 0);
}
@ -439,7 +439,7 @@ MZSCHEME::create_function (char *name, char *iname, DataType *d, ParmList *l)
// returning multiple values
if(argout_set) {
if(d->type == T_VOID) {
if(DataType_type(d) == T_VOID) {
Wrapper_add_local(f,"_lenv","int _lenv = 0");
Wrapper_add_local(f,"_values", "Scheme_Object * _values[MAXVALUES]");
Printv(f->code, tab4, "swig_result = scheme_values(_lenv, _values);\n", 0);
@ -504,11 +504,11 @@ MZSCHEME::link_variable (char *name, char *iname, DataType *t)
proc_name = NewString(iname);
Replace(proc_name,"_","-",DOH_REPLACE_ANY);
if ((t->type != T_USER) || (t->is_pointer)) {
if (DataType_type(t) != T_USER) {
Printf (f_wrappers, "static Scheme_Object *%s(int argc, Scheme_Object** argv) {\n", var_name);
if ((t->type == T_CHAR) || (t->is_pointer)){
if ((DataType_type(t) == T_CHAR) || (DataType_type(t) == T_POINTER) || (DataType_type(t) == T_ARRAY) || (DataType_type(t) == T_REFERENCE)) {
Printf (f_wrappers, "\t char *_temp, _ptemp[128];\n");
Printf (f_wrappers, "\t int _len;\n");
}
@ -536,7 +536,7 @@ MZSCHEME::link_variable (char *name, char *iname, DataType *t)
Delete(tm2);
}
else if (t->is_pointer) {
if ((t->type == T_CHAR) && (t->is_pointer == 1)) {
if (DataType_type(t) == T_STRING) {
Printf (f_wrappers, "\t\t _temp = SCHEME_STR_VAL(argv[0]);\n");
Printf (f_wrappers, "\t\t _len = SCHEME_STRLEN_VAL(argv[0]);\n");
Printf (f_wrappers, "\t\t if (%s) { free(%s);}\n", name, name);
@ -564,7 +564,7 @@ MZSCHEME::link_variable (char *name, char *iname, DataType *t)
Printf (f_wrappers, "%s\n", tm);
}
else if (t->is_pointer) {
if ((t->type == T_CHAR) && (t->is_pointer == 1)) {
if (DataType_type(t) == T_STRING) {
Printf (f_wrappers, "\t swig_result = scheme_make_string(%s);\n", name);
} else {
// Is an ordinary pointer type.
@ -620,7 +620,7 @@ MZSCHEME::declare_const (char *name, char *, DataType *type, char *value)
proc_name = NewString(name);
Replace(proc_name,"_","-",DOH_REPLACE_ANY);
if ((type->type == T_USER) && (!type->is_pointer)) {
if (DataType_type(type) == T_USER) {
Printf (stderr, "%s : Line %d. Unsupported constant value.\n",
input_file, line_number);
return;
@ -628,9 +628,9 @@ MZSCHEME::declare_const (char *name, char *, DataType *type, char *value)
// See if there's a typemap
rvalue = NewString(value);
if ((type->type == T_CHAR) && (type->is_pointer == 1)) {
if (DataType_type(type) == T_STRING) {
rvalue = NewStringf("\"%s\"", value);
} else if ((type->type == T_CHAR) && (type->is_pointer == 0)) {
} else if (DataType_type(type) == T_CHAR) {
rvalue = NewStringf("\'%s\'", value);
} else {
rvalue = NewString(value);
@ -643,7 +643,7 @@ MZSCHEME::declare_const (char *name, char *, DataType *type, char *value)
// Create variable and assign it a value
Printf (f_header, "static %s %s = ", DataType_lstr(type,0), var_name);
if ((type->type == T_CHAR) && (type->is_pointer <= 1)) {
if ((DataType_type(type) == T_CHAR) || (DataType_type(type) == T_STRING)) {
Printf (f_header, "\"%s\";\n", value);
} else {
Printf (f_header, "%s;\n", value);
@ -666,7 +666,7 @@ void
MZSCHEME::usage_var (char *iname, DataType *t, DOHString *usage)
{
Printv(usage, "(", iname, " [value])", 0);
if (!((t->type != T_USER) || (t->is_pointer))) {
if (DataType_type(t) == T_USER) {
Printf(usage," - unsupported");
}
}
@ -698,7 +698,7 @@ MZSCHEME::usage_func (char *iname, DataType *d, ParmList *l, DOHString *usage)
// Print the type. If the parameter has been named, use that as well.
if ((pt->type != T_VOID) || (pt->is_pointer)) {
if (DataType_type(pt) != T_VOID) {
// Print the type.
Printv(usage," <", pt->name, 0);
@ -748,7 +748,7 @@ MZSCHEME::usage_returns (char *iname, DataType *d, ParmList *l, DOHString *usage
// Print the type. If the parameter has been named, use that as well.
if ((pt->type != T_VOID) || (pt->is_pointer)) {
if (DataType_type(pt) != T_VOID) {
++have_param;
// Print the type.
@ -763,9 +763,9 @@ MZSCHEME::usage_returns (char *iname, DataType *d, ParmList *l, DOHString *usage
}
// See if we stick on the function return type.
if (d->type != T_VOID || have_param == 0) {
if (DataType_type(d) != T_VOID || have_param == 0) {
++have_param;
if (d->type == T_VOID)
if (DataType_type(d) == T_VOID)
Insert(param,0," unspecified");
else {
Insert(param,0,"# ");

446
Source/Modules1.1/perl5.cxx
View file

@ -702,7 +702,7 @@ void PERL5::get_pointer(char *iname, char *srcname, char *src, char *dest,
// If we're passing a void pointer, we give the pointer conversion a NULL
// pointer, otherwise pass in the expected type.
if (t->type == T_VOID) Printf(f, "(char *) 0 )) {\n");
if (DataType_type(t) == T_VOID) Printf(f, "(char *) 0 )) {\n");
else
Printv(f, "\"", (hidden ? realpackage : ""), (hidden ? "::" : ""), DataType_manglestr(t), "\")) {\n", 0);
@ -769,6 +769,7 @@ void PERL5::create_function(char *name, char *iname, DataType *d, ParmList *l)
// Check the number of arguments
usage = usage_func(iname,d,l);
Printf(f->code," if ((items < %d) || (items > %d)) \n", pcount-numopt, ParmList_numarg(l));
Printf(f->code," croak(\"Usage: %s\");\n", usage);
@ -803,77 +804,64 @@ void PERL5::create_function(char *name, char *iname, DataType *d, ParmList *l)
Replace(f->code,"$argnum",argnum,DOH_REPLACE_ANY);
Replace(f->code,"$arg",source,DOH_REPLACE_ANY);
} else {
if (!pt->is_pointer) {
switch(DataType_type(pt)) {
// Integers
// Extract a parameter by "value"
case T_BOOL:
case T_INT :
case T_SHORT :
case T_LONG :
case T_SCHAR:
case T_UINT:
case T_USHORT:
case T_ULONG:
case T_UCHAR:
Printf(f->code," %s = (%s)SvIV(ST(%d));\n", target, DataType_lstr(pt,0),j);
break;
case T_CHAR :
switch(pt->type) {
// Integers
case T_BOOL:
case T_INT :
case T_SHORT :
case T_LONG :
case T_SCHAR:
case T_UINT:
case T_USHORT:
case T_ULONG:
case T_UCHAR:
Printf(f->code," %s = (%s)SvIV(ST(%d));\n", target, DataType_lstr(pt,0),j);
break;
case T_CHAR :
Printf(f->code," %s = (char) *SvPV(ST(%d),PL_na);\n", target, j);
break;
Printf(f->code," %s = (char) *SvPV(ST(%d),PL_na);\n", target, j);
break;
// Doubles
case T_DOUBLE :
case T_FLOAT :
Printf(f->code," %s = (%s)SvNV(ST(%d));\n", target, DataType_lstr(pt,0), j);
break;
case T_DOUBLE :
case T_FLOAT :
Printf(f->code," %s = (%s)SvNV(ST(%d));\n", target, DataType_lstr(pt,0), j);
break;
// Void.. Do nothing.
case T_VOID :
break;
case T_VOID :
break;
// User defined. This is invalid here. Note, user-defined types by
// value are handled in the parser.
case T_USER:
pt->is_pointer++;
sprintf(temp,"argument %d", i+1);
get_pointer(iname, temp, source, target, pt, f->code, (char *)"XSRETURN(1)");
pt->is_pointer--;
break;
// User defined. This is invalid here. Note, user-defined types by
// value are handled in the parser.
case T_USER:
pt->is_pointer++;
sprintf(temp,"argument %d", i+1);
get_pointer(iname, temp, source, target, pt, f->code, (char *)"XSRETURN(1)");
pt->is_pointer--;
break;
// Unsupported data type
case T_STRING:
Printf(f->code," if (! SvOK((SV*) ST(%d))) { %s = 0; }\n", j, target);
Printf(f->code," else { %s = (char *) SvPV(ST(%d),PL_na); }\n", target,j);
break;
case T_POINTER: case T_ARRAY: case T_REFERENCE:
sprintf(temp,"argument %d", i+1);
get_pointer(iname,temp,source,target, pt, f->code, (char*)"XSRETURN(1)");
break;
// Unsupported data type
default :
Printf(stderr,"%s : Line %d. Unable to use type %s as a function argument.\n",input_file, line_number, DataType_str(pt,0));
break;
}
} else {
// Argument is a pointer type. Special case is for char *
// since that is usually a string.
if ((pt->type == T_CHAR) && (pt->is_pointer == 1)) {
Printf(f->code," if (! SvOK((SV*) ST(%d))) { %s = 0; }\n", j, target);
Printf(f->code," else { %s = (char *) SvPV(ST(%d),PL_na); }\n", target,j);
} else {
// Have a generic pointer type here. Read it in as a swig
// typed pointer.
sprintf(temp,"argument %d", i+1);
get_pointer(iname,temp,source,target, pt, f->code, (char*)"XSRETURN(1)");
}
default :
Printf(stderr,"%s : Line %d. Unable to use type %s as a function argument.\n",input_file, line_number, DataType_str(pt,0));
break;
}
}
// The source is going to be an array of saved values.
@ -932,12 +920,10 @@ void PERL5::create_function(char *name, char *iname, DataType *d, ParmList *l)
if ((tm = typemap_lookup((char*)"out",(char*)"perl5",d,iname,(char*)"result",(char*)"ST(argvi)"))) {
// Yep. Use it instead of the default
Printf(f->code, "%s\n", tm);
} else if ((d->type != T_VOID) || (d->is_pointer)) {
if (!d->is_pointer) {
// Function returns a "value"
} else {
if (DataType_type(d) != T_VOID) {
Printf(f->code," ST(argvi) = sv_newmortal();\n");
switch(d->type) {
switch (DataType_type(d)) {
case T_INT: case T_BOOL: case T_UINT:
case T_SHORT: case T_USHORT:
case T_LONG : case T_ULONG:
@ -967,24 +953,19 @@ void PERL5::create_function(char *name, char *iname, DataType *d, ParmList *l)
d->is_pointer--;
break;
case T_STRING:
Printf(f->code," sv_setpv((SV*)ST(argvi++),(char *) result);\n");
break;
case T_POINTER: case T_ARRAY: case T_REFERENCE:
Printv(f->code, tab4, "sv_setref_pv(ST(argvi++),\"", (hidden ? realpackage : ""), (hidden ? "::" : ""), DataType_manglestr(d),
"\", (void *) result);\n", 0);
break;
default :
Printf(stderr,"%s: Line %d. Unable to use return type %s in function %s.\n", input_file, line_number, DataType_str(d,0), name);
break;
}
} else {
// Is a pointer return type
Printf(f->code," ST(argvi) = sv_newmortal();\n");
if ((d->type == T_CHAR) && (d->is_pointer == 1)) {
// Return a character string
Printf(f->code," sv_setpv((SV*)ST(argvi++),(char *) result);\n");
} else {
// Is an ordinary pointer type.
Printv(f->code, tab4, "sv_setref_pv(ST(argvi++),\"", (hidden ? realpackage : ""), (hidden ? "::" : ""), DataType_manglestr(d),
"\", (void *) result);\n", 0);
}
}
}
@ -1181,65 +1162,62 @@ void PERL5::link_variable(char *name, char *iname, DataType *t)
} else if ((tm = typemap_lookup((char*)"in",(char*)"perl5",t,(char*)"",(char*)"sv",name))) {
Printf(setf->code,"%s\n", tm);
} else {
if (!t->is_pointer) {
switch(DataType_type(t)) {
// Set the value to something
case T_INT : case T_BOOL: case T_UINT:
case T_SHORT : case T_USHORT:
case T_LONG : case T_ULONG:
case T_UCHAR: case T_SCHAR:
Printv(setf->code,tab4, name, " = (", DataType_str(t,0), ") SvIV(sv);\n", 0);
break;
case T_DOUBLE :
case T_FLOAT :
Printv(setf->code, tab4, name, " = (", DataType_str(t,0), ") SvNV(sv);\n", 0);
break;
case T_CHAR :
Printv(setf->code, tab4, name, " = (char) *SvPV(sv,PL_na);\n", 0);
break;
switch(t->type) {
case T_INT : case T_BOOL: case T_UINT:
case T_SHORT : case T_USHORT:
case T_LONG : case T_ULONG:
case T_UCHAR: case T_SCHAR:
Printv(setf->code,tab4, name, " = (", DataType_str(t,0), ") SvIV(sv);\n", 0);
break;
case T_DOUBLE :
case T_FLOAT :
Printv(setf->code, tab4, name, " = (", DataType_str(t,0), ") SvNV(sv);\n", 0);
break;
case T_CHAR :
Printv(setf->code, tab4, name, " = (char) *SvPV(sv,PL_na);\n", 0);
break;
case T_USER:
// Add support for User defined type here
// Get as a pointer value
t->is_pointer++;
Wrapper_add_local(setf,"_temp", "void *_temp");
get_pointer(iname,(char*)"value",(char*)"sv",(char*)"_temp", t, setf->code, (char*)"return(1)");
Printv(setf->code, tab4, name, " = *((", DataType_str(t,0), ") _temp);\n", 0);
t->is_pointer--;
break;
default :
Printf(stderr,"%s : Line %d. Unable to link with datatype %s (ignored).\n", input_file, line_number, DataType_str(t,0));
return;
}
} else {
// Have some sort of pointer type here, Process it differently
if ((t->type == T_CHAR) && (t->is_pointer == 1)) {
Wrapper_add_local(setf,"_a","char *_a");
Printf(setf->code," _a = (char *) SvPV(sv,PL_na);\n");
if (CPlusPlus)
Printv(setf->code,
tab4, "if (", name, ") delete [] ", name, ";\n",
tab4, name, " = new char[strlen(_a)+1];\n",
0);
else
Printv(setf->code,
tab4, "if (", name, ") free(", name, ");\n",
tab4, name, " = (char *) malloc(strlen(_a)+1);\n",
0);
Printv(setf->code,"strcpy(", name, ",_a);\n", 0);
} else {
// Set the value of a pointer
Wrapper_add_local(setf,"_temp","void *_temp");
get_pointer(iname,(char*)"value",(char*)"sv",(char*)"_temp", t, setf->code, (char*)"return(1)");
Printv(setf->code,tab4, name, " = (", DataType_str(t,0), ") _temp;\n", 0);
}
case T_USER:
// Add support for User defined type here
// Get as a pointer value
t->is_pointer++;
Wrapper_add_local(setf,"_temp", "void *_temp");
get_pointer(iname,(char*)"value",(char*)"sv",(char*)"_temp", t, setf->code, (char*)"return(1)");
Printv(setf->code, tab4, name, " = *((", DataType_str(t,0), ") _temp);\n", 0);
t->is_pointer--;
break;
case T_STRING:
Wrapper_add_local(setf,"_a","char *_a");
Printf(setf->code," _a = (char *) SvPV(sv,PL_na);\n");
if (CPlusPlus)
Printv(setf->code,
tab4, "if (", name, ") delete [] ", name, ";\n",
tab4, name, " = new char[strlen(_a)+1];\n",
0);
else
Printv(setf->code,
tab4, "if (", name, ") free(", name, ");\n",
tab4, name, " = (char *) malloc(strlen(_a)+1);\n",
0);
Printv(setf->code,"strcpy(", name, ",_a);\n", 0);
break;
case T_POINTER: case T_ARRAY: case T_REFERENCE:
// Set the value of a pointer
Wrapper_add_local(setf,"_temp","void *_temp");
get_pointer(iname,(char*)"value",(char*)"sv",(char*)"_temp", t, setf->code, (char*)"return(1)");
Printv(setf->code,tab4, name, " = (", DataType_str(t,0), ") _temp;\n", 0);
break;
default :
Printf(stderr,"%s : Line %d. Unable to link with datatype %s (ignored).\n", input_file, line_number, DataType_str(t,0));
return;
}
}
Printf(setf->code," return 1;\n}\n");
@ -1263,58 +1241,57 @@ void PERL5::link_variable(char *name, char *iname, DataType *t)
} else if ((tm = typemap_lookup((char*)"out",(char*)"perl5",t,(char*)"",name,(char*)"sv"))) {
Printf(getf->code,"%s\n", tm);
} else {
if (!t->is_pointer) {
switch(t->type) {
case T_INT : case T_BOOL: case T_UINT:
case T_SHORT : case T_USHORT:
case T_LONG : case T_ULONG:
case T_UCHAR: case T_SCHAR:
Printv(getf->code,tab4, "sv_setiv(sv, (IV) ", name, ");\n", 0);
Printv(vinit, tab4, "sv_setiv(sv,(IV)", name, ");\n",0);
break;
case T_DOUBLE :
case T_FLOAT :
Printv(getf->code, tab4,"sv_setnv(sv, (double) ", name, ");\n", 0);
Printv(vinit, tab4, "sv_setnv(sv,(double)", name, ");\n",0);
break;
case T_CHAR :
Wrapper_add_local(getf,"_ptemp","char _ptemp[2]");
Printv(getf->code,
tab4, "_ptemp[0] = ", name, ";\n",
tab4, "_ptemp[1] = 0;\n",
tab4, "sv_setpv((SV*) sv, _ptemp);\n",
0);
break;
case T_USER:
t->is_pointer++;
Printv(getf->code,
tab4, "rsv = SvRV(sv);\n",
tab4, "sv_setiv(rsv,(IV) &", name, ");\n",
0);
Wrapper_add_local(getf,"rsv","SV *rsv");
Printv(vinit, tab4, "sv_setref_pv(sv,\"", DataType_manglestr(t), "\",(void *) &", name, ");\n",0);
t->is_pointer--;
break;
default :
break;
}
} else {
switch(DataType_type(t)) {
// Have some sort of arbitrary pointer type. Return it as a string
case T_INT : case T_BOOL: case T_UINT:
case T_SHORT : case T_USHORT:
case T_LONG : case T_ULONG:
case T_UCHAR: case T_SCHAR:
Printv(getf->code,tab4, "sv_setiv(sv, (IV) ", name, ");\n", 0);
Printv(vinit, tab4, "sv_setiv(sv,(IV)", name, ");\n",0);
break;
case T_DOUBLE :
case T_FLOAT :
Printv(getf->code, tab4,"sv_setnv(sv, (double) ", name, ");\n", 0);
Printv(vinit, tab4, "sv_setnv(sv,(double)", name, ");\n",0);
break;
case T_CHAR :
Wrapper_add_local(getf,"_ptemp","char _ptemp[2]");
Printv(getf->code,
tab4, "_ptemp[0] = ", name, ";\n",
tab4, "_ptemp[1] = 0;\n",
tab4, "sv_setpv((SV*) sv, _ptemp);\n",
0);
break;
case T_USER:
t->is_pointer++;
Printv(getf->code,
tab4, "rsv = SvRV(sv);\n",
tab4, "sv_setiv(rsv,(IV) &", name, ");\n",
0);
if ((t->type == T_CHAR) && (t->is_pointer == 1))
Printv(getf->code, tab4, "sv_setpv((SV*) sv, ", name, ");\n", 0);
else {
Printv(getf->code,
tab4, "rsv = SvRV(sv);\n",
tab4, "sv_setiv(rsv,(IV) ", name, ");\n",
0);
Wrapper_add_local(getf,"rsv","SV *rsv");
Printv(vinit, tab4, "sv_setref_pv(sv,\"", DataType_manglestr(t), "\",(void *) &", name, ");\n",0);
t->is_pointer--;
break;
Wrapper_add_local(getf,"rsv","SV *rsv");
Printv(vinit, tab4, "sv_setref_pv(sv,\"", DataType_manglestr(t), "\",(void *) 1);\n",0);
}
case T_STRING:
Printv(getf->code, tab4, "sv_setpv((SV*) sv, ", name, ");\n", 0);
break;
case T_POINTER: case T_ARRAY: case T_REFERENCE:
Printv(getf->code,
tab4, "rsv = SvRV(sv);\n",
tab4, "sv_setiv(rsv,(IV) ", name, ");\n",
0);
Wrapper_add_local(getf,"rsv","SV *rsv");
Printv(vinit, tab4, "sv_setref_pv(sv,\"", DataType_manglestr(t), "\",(void *) 1);\n",0);
break;
default :
break;
}
}
Printf(getf->code," return 1;\n}\n");
@ -1427,58 +1404,53 @@ PERL5::declare_const(char *name, char *, DataType *type, char *value)
if ((tm = typemap_lookup((char*)"const",(char*)"perl5",type,name,value,name))) {
Printf(f_init,"%s\n",tm);
} else {
if ((type->type == T_USER) && (!type->is_pointer)) {
Printf(stderr,"%s : Line %d. Unsupported constant value.\n", input_file, line_number);
return;
}
// Generate a constant
if (type->is_pointer == 0) {
switch(type->type) {
case T_INT: case T_UINT: case T_BOOL:
case T_SHORT: case T_USHORT:
case T_LONG: case T_ULONG:
case T_SCHAR: case T_UCHAR:
if (!have_int_func) {
Printf(f_header,"%s\n",setiv);
have_int_func = 1;
}
Printv(vinit, tab4, "swig_setiv(\"", package, "::", name, "\", (long) ", value, ");\n",0);
break;
case T_DOUBLE:
case T_FLOAT:
if (!have_double_func) {
Printf(f_header,"%s\n",setnv);
have_double_func = 1;
}
Printv(vinit, tab4, "swig_setnv(\"", package, "::", name, "\", (double) (", value, "));\n",0);
break;
case T_CHAR :
if (!have_char_func) {
Printf(f_header,"%s\n",setpv);
have_char_func = 1;
}
Printv(vinit, tab4, "swig_setpv(\"", package, "::", name, "\", \"", value, "\");\n",0);
break;
default:
Printf(stderr,"%s : Line %d. Unsupported constant value.\n", input_file, line_number);
break;
switch(DataType_type(type)) {
case T_INT: case T_UINT: case T_BOOL:
case T_SHORT: case T_USHORT:
case T_LONG: case T_ULONG:
case T_SCHAR: case T_UCHAR:
if (!have_int_func) {
Printf(f_header,"%s\n",setiv);
have_int_func = 1;
}
} else {
if ((type->type == T_CHAR) && (type->is_pointer == 1)) {
if (!have_char_func) {
Printf(f_header,"%s\n",setpv);
have_char_func = 1;
}
Printv(vinit, tab4, "swig_setpv(\"", package, "::", name, "\", \"", value, "\");\n",0);
} else {
// A user-defined type. We're going to munge it into a string pointer value
if (!have_ref_func) {
Printf(f_header,"%s\n",setrv);
have_ref_func = 1;
}
Printv(vinit, tab4, "swig_setrv(\"", package, "::", name, "\", (void *) ", value, ", \"",
DataType_manglestr(type), "\");\n", 0);
Printv(vinit, tab4, "swig_setiv(\"", package, "::", name, "\", (long) ", value, ");\n",0);
break;
case T_DOUBLE:
case T_FLOAT:
if (!have_double_func) {
Printf(f_header,"%s\n",setnv);
have_double_func = 1;
}
Printv(vinit, tab4, "swig_setnv(\"", package, "::", name, "\", (double) (", value, "));\n",0);
break;
case T_CHAR :
if (!have_char_func) {
Printf(f_header,"%s\n",setpv);
have_char_func = 1;
}
Printv(vinit, tab4, "swig_setpv(\"", package, "::", name, "\", \"", value, "\");\n",0);
break;
case T_STRING:
if (!have_char_func) {
Printf(f_header,"%s\n",setpv);
have_char_func = 1;
}
Printv(vinit, tab4, "swig_setpv(\"", package, "::", name, "\", \"", value, "\");\n",0);
break;
case T_POINTER: case T_ARRAY: case T_REFERENCE:
// A user-defined type. We're going to munge it into a string pointer value
if (!have_ref_func) {
Printf(f_header,"%s\n",setrv);
have_ref_func = 1;
}
Printv(vinit, tab4, "swig_setrv(\"", package, "::", name, "\", (void *) ", value, ", \"",
DataType_manglestr(type), "\");\n", 0);
break;
default:
Printf(stderr,"%s : Line %d. Unsupported constant value.\n", input_file, line_number);
break;
}
}
@ -1542,7 +1514,7 @@ char *PERL5::usage_func(char *iname, DataType *, ParmList *l) {
if (!Getignore(p)) {
/* If parameter has been named, use that. Otherwise, just print a type */
if ((pt->type != T_VOID) || (pt->is_pointer)) {
if (DataType_type(pt) != T_VOID) {
if (strlen(pn) > 0) {
Printf(temp,"%s",pn);
} else {

636
Source/Modules1.1/python.cxx
View file

@ -524,7 +524,7 @@ PYTHON::get_pointer(char *iname, char *srcname, char *src, char *dest,
// If we're passing a void pointer, we give the pointer conversion a NULL
// pointer, otherwise pass in the expected type.
if (t->type == T_VOID) Printv(f, "0,1)) == -1) return ", ret, ";\n", 0);
if (DataType_type(t) == T_VOID) Printv(f, "0,1)) == -1) return ", ret, ";\n", 0);
else
Printv(f,"SWIGTYPE", DataType_manglestr(t), ",1)) == -1) return ", ret, ";\n", 0);
}
@ -721,110 +721,101 @@ void PYTHON::create_function(char *name, char *iname, DataType *d, ParmList *l)
Replace(get_pointers,"$argnum", argnum, DOH_REPLACE_ANY);
Replace(get_pointers,"$arg",source, DOH_REPLACE_ANY);
} else {
int noarg = 0;
// Check if this parameter is a pointer. If not, we'll get values
if (!pt->is_pointer) {
// Extract a parameter by "value"
switch(pt->type) {
switch(DataType_type(pt)) {
case T_INT : case T_UINT:
Putc('i',parse_args);
break;
case T_SHORT: case T_USHORT:
Putc('h',parse_args);
break;
case T_LONG : case T_ULONG:
Putc('l',parse_args);
break;
case T_SCHAR : case T_UCHAR :
Putc('b',parse_args);
break;
case T_CHAR:
Putc('c',parse_args);
break;
case T_FLOAT :
Putc('f',parse_args);
break;
case T_DOUBLE:
Putc('d',parse_args);
break;
// Handle integers here. Usually this can be done as a single
// case if you appropriate cast things. However, if you have
// special cases, you'll need to add more code.
case T_INT : case T_UINT:
Putc('i',parse_args);
break;
case T_SHORT: case T_USHORT:
Putc('h',parse_args);
break;
case T_LONG : case T_ULONG:
Putc('l',parse_args);
break;
case T_SCHAR : case T_UCHAR :
Putc('b',parse_args);
break;
case T_CHAR:
Putc('c',parse_args);
break;
case T_FLOAT :
Putc('f',parse_args);
break;
case T_DOUBLE:
Putc('d',parse_args);
break;
case T_BOOL:
{
char tempb[128];
char tempval[128];
if (pv) {
sprintf(tempval, "(int) %s", pv);
}
sprintf(tempb,"tempbool%d",i);
Putc('i',parse_args);
if (!pv)
Wrapper_add_localv(f,tempb,"int",tempb,0);
else
Wrapper_add_localv(f,tempb,"int",tempb, "=",tempval,0);
Printv(get_pointers, tab4, target, " = (", DataType_lstr(pt,0), ") ", tempb, ";\n", 0);
Printf(arglist,"&%s",tempb);
case T_BOOL:
{
char tempb[128];
char tempval[128];
if (pv) {
sprintf(tempval, "(int) %s", pv);
}
sprintf(tempb,"tempbool%d",i);
Putc('i',parse_args);
if (!pv)
Wrapper_add_localv(f,tempb,"int",tempb,0);
else
Wrapper_add_localv(f,tempb,"int",tempb, "=",tempval,0);
Printv(get_pointers, tab4, target, " = (", DataType_lstr(pt,0), ") ", tempb, ";\n", 0);
Printf(arglist,"&%s",tempb);
noarg = 1;
}
break;
// Void.. Do nothing.
case T_VOID :
break;
case T_VOID :
noarg = 1;
break;
case T_USER:
Putc('O',parse_args);
sprintf(source,"argo%d", i);
sprintf(target,Getlname(p));
sprintf(temp,"argument %d",i+1);
Wrapper_add_localv(f,source,"PyObject *",source,"=0",0);
Printf(arglist,"&%s",source);
pt->is_pointer++;
get_pointer(iname, temp, source, target, pt, get_pointers, (char*)"NULL");
pt->is_pointer--;
// Unsupported data type
break;
case T_USER:
Putc('O',parse_args);
sprintf(source,"argo%d", i);
sprintf(target,Getlname(p));
sprintf(temp,"argument %d",i+1);
Wrapper_add_localv(f,source,"PyObject *",source,"=0",0);
Printf(arglist,"&%s",source);
pt->is_pointer++;
get_pointer(iname, temp, source, target, pt, get_pointers, (char*)"NULL");
pt->is_pointer--;
noarg = 1;
break;
default :
Printf(stderr,"%s : Line %d. Unable to use type %s as a function argument.\n",input_file, line_number, DataType_str(pt,0));
break;
}
// Emit code for parameter list
if ((pt->type != T_VOID) && (pt->type != T_BOOL) && (pt->type != T_USER))
Printf(arglist,"&%s",Getlname(p));
} else {
// Is some other kind of variable.
if ((pt->type == T_CHAR) && (pt->is_pointer == 1)) {
Putc('s',parse_args);
Printf(arglist,"&%s", Getlname(p));
} else {
case T_STRING:
Putc('s',parse_args);
Printf(arglist,"&%s", Getlname(p));
noarg = 1;
break;
case T_POINTER: case T_ARRAY: case T_REFERENCE:
// Have some sort of pointer variable. Create a temporary local
// variable for the string and read the pointer value into it.
// Have some sort of pointer variable. Create a temporary local
// variable for the string and read the pointer value into it.
Putc('O',parse_args);
sprintf(source,"argo%d", i);
sprintf(target,"%s",Getlname(p));
sprintf(temp,"argument %d",i+1);
Putc('O',parse_args);
sprintf(source,"argo%d", i);
sprintf(target,"%s",Getlname(p));
sprintf(temp,"argument %d",i+1);
Wrapper_add_localv(f,source,"PyObject *",source,"=0",0);
Printf(arglist,"&%s",source);
get_pointer(iname, temp, source, target, pt, get_pointers, (char*)"NULL");
}
Wrapper_add_localv(f,source,"PyObject *",source,"=0",0);
Printf(arglist,"&%s",source);
get_pointer(iname, temp, source, target, pt, get_pointers, (char*)"NULL");
noarg = 1;
break;
default :
Printf(stderr,"%s : Line %d. Unable to use type %s as a function argument.\n",input_file, line_number, DataType_str(pt,0));
break;
}
// Emit code for parameter list
if (!noarg)
Printf(arglist,"&%s",Getlname(p));
}
j++;
}
@ -878,79 +869,60 @@ void PYTHON::create_function(char *name, char *iname, DataType *d, ParmList *l)
// Yep. Use it instead of the default
Printf(f->code,"%s\n", tm);
} else {
if ((d->type != T_VOID) || (d->is_pointer)) {
// Now have return value, figure out what to do with it.
switch(DataType_type(d)) {
case T_INT: case T_UINT: case T_BOOL:
Printf(f->code," resultobj = Py_BuildValue(\"i\",result);\n");
break;
case T_SHORT: case T_USHORT:
Printf(f->code," resultobj = Py_BuildValue(\"h\",result);\n");
break;
case T_LONG : case T_ULONG:
Printf(f->code," resultobj = Py_BuildValue(\"l\",result);\n");
break;
case T_SCHAR: case T_UCHAR :
Printf(f->code," resultobj = Py_BuildValue(\"b\",result);\n");
break;
if (!d->is_pointer) {
// Function returns a "value"
switch(d->type) {
// Return an integer type
case T_INT: case T_UINT: case T_BOOL:
Printf(f->code," resultobj = Py_BuildValue(\"i\",result);\n");
break;
case T_SHORT: case T_USHORT:
Printf(f->code," resultobj = Py_BuildValue(\"h\",result);\n");
break;
case T_LONG : case T_ULONG:
Printf(f->code," resultobj = Py_BuildValue(\"l\",result);\n");
break;
case T_SCHAR: case T_UCHAR :
Printf(f->code," resultobj = Py_BuildValue(\"b\",result);\n");
break;
// Return a floating point value
case T_DOUBLE :
Printf(f->code," resultobj = Py_BuildValue(\"d\",result);\n");
break;
case T_FLOAT :
Printf(f->code," resultobj = Py_BuildValue(\"f\",result);\n");
break;
// Return a single ASCII value. Usually we need to convert
// it to a NULL-terminate string and return that instead.
case T_CHAR :
Printf(f->code," resultobj = Py_BuildValue(\"c\",result);\n");
break;
case T_USER :
d->is_pointer++;
DataType_remember(d);
Printv(f->code,tab4, "resultobj = SWIG_NewPointerObj((void *)result, SWIGTYPE", DataType_manglestr(d), ");\n",0);
d->is_pointer--;
break;
default :
Printf(stderr,"%s: Line %d. Unable to use return type %s in function %s.\n", input_file, line_number, DataType_str(d,0), name);
break;
}
} else {
// Return type is a pointer. We'll see if it's a char * and return
// a string. Otherwise, we'll convert it into a SWIG pointer and return
// that.
if ((d->type == T_CHAR) && (d->is_pointer == 1)) {
// Return a character string
Printf(f->code," resultobj = Py_BuildValue(\"s\", result);\n");
// Return a floating point value
case T_DOUBLE :
Printf(f->code," resultobj = Py_BuildValue(\"d\",result);\n");
break;
case T_FLOAT :
Printf(f->code," resultobj = Py_BuildValue(\"f\",result);\n");
break;
// Return a single ASCII value. Usually we need to convert
// it to a NULL-terminate string and return that instead.
case T_CHAR :
Printf(f->code," resultobj = Py_BuildValue(\"c\",result);\n");
break;
case T_USER :
d->is_pointer++;
DataType_remember(d);
Printv(f->code,tab4, "resultobj = SWIG_NewPointerObj((void *)result, SWIGTYPE", DataType_manglestr(d), ");\n",0);
d->is_pointer--;
break;
// If declared as a new object, free the result
case T_STRING:
Printf(f->code," resultobj = Py_BuildValue(\"s\", result);\n");
break;
} else {
// Build a SWIG pointer.
DataType_remember(d);
Printv(f->code, tab4, "resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE", DataType_manglestr(d), ");\n", 0);
}
}
} else {
case T_POINTER: case T_ARRAY: case T_REFERENCE:
DataType_remember(d);
Printv(f->code, tab4, "resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE", DataType_manglestr(d), ");\n", 0);
break;
case T_VOID:
Printf(f->code," Py_INCREF(Py_None);\n");
Printf(f->code," resultobj = Py_None;\n");
break;
default :
Printf(stderr,"%s: Line %d. Unable to use return type %s in function %s.\n", input_file, line_number, DataType_str(d,0), name);
break;
}
}
@ -1108,103 +1080,94 @@ void PYTHON::link_variable(char *name, char *iname, DataType *t) {
Printf(setf->code,"%s\n",tm);
Replace(setf->code,"$name",iname, DOH_REPLACE_ANY);
} else {
if ((t->type != T_VOID) || (t->is_pointer)) {
if (!t->is_pointer) {
// Have a real value here
switch(t->type) {
case T_INT: case T_SHORT: case T_LONG :
case T_UINT: case T_USHORT: case T_ULONG:
case T_SCHAR: case T_UCHAR: case T_BOOL:
// Get an integer value
Wrapper_add_localv(setf,"tval",DataType_lstr(t,0),"tval",0);
Printv(setf->code,
tab4, "tval = (", DataType_lstr(t,0), ") PyInt_AsLong(val);\n",
tab4, "if (PyErr_Occurred()) {\n",
tab8, "PyErr_SetString(PyExc_TypeError,\"C variable '",
iname, "'(", DataType_str(t,0), ")\");\n",
tab8, "return 1; \n",
tab4, "}\n",
tab4, name, " = tval;\n",
0);
break;
case T_FLOAT: case T_DOUBLE:
// Get a floating point value
Wrapper_add_localv(setf,"tval",DataType_lstr(t,0), "tval",0);
Printv(setf->code,
tab4, "tval = (", DataType_lstr(t,0), ") PyFloat_AsDouble(val);\n",
tab4, "if (PyErr_Occurred()) {\n",
tab8, "PyErr_SetString(PyExc_TypeError,\"C variable '",
iname, "'(", DataType_str(t,0), ")\");\n",
tab8, "return 1; \n",
tab4, "}\n",
tab4, name, " = tval;\n",
0);
break;
// A single ascii character
case T_CHAR:
Wrapper_add_local(setf,"tval","char * tval");
Printv(setf->code,
tab4, "tval = (char *) PyString_AsString(val);\n",
tab4, "if (PyErr_Occurred()) {\n",
tab8, "PyErr_SetString(PyExc_TypeError,\"C variable '",
iname, "'(", DataType_str(t,0), ")\");\n",
tab8, "return 1; \n",
tab4, "}\n",
tab4, name, " = *tval;\n",
0);
break;
case T_USER:
t->is_pointer++;
Wrapper_add_localv(setf,"temp",DataType_lstr(t,0),"temp",0);
get_pointer(iname,(char*)"value",(char*)"val",(char*)"temp",t,setf->code,(char*)"1");
Printv(setf->code, tab4, name, " = *temp;\n", 0);
t->is_pointer--;
break;
default:
Printf(stderr,"%s : Line %d. Unable to link with type %s.\n", input_file, line_number, DataType_str(t,0));
}
switch(DataType_type(t)) {
case T_INT: case T_SHORT: case T_LONG :
case T_UINT: case T_USHORT: case T_ULONG:
case T_SCHAR: case T_UCHAR: case T_BOOL:
// Get an integer value
Wrapper_add_localv(setf,"tval",DataType_lstr(t,0),"tval",0);
Printv(setf->code,
tab4, "tval = (", DataType_lstr(t,0), ") PyInt_AsLong(val);\n",
tab4, "if (PyErr_Occurred()) {\n",
tab8, "PyErr_SetString(PyExc_TypeError,\"C variable '",
iname, "'(", DataType_str(t,0), ")\");\n",
tab8, "return 1; \n",
tab4, "}\n",
tab4, name, " = tval;\n",
0);
break;
case T_FLOAT: case T_DOUBLE:
// Get a floating point value
Wrapper_add_localv(setf,"tval",DataType_lstr(t,0), "tval",0);
Printv(setf->code,
tab4, "tval = (", DataType_lstr(t,0), ") PyFloat_AsDouble(val);\n",
tab4, "if (PyErr_Occurred()) {\n",
tab8, "PyErr_SetString(PyExc_TypeError,\"C variable '",
iname, "'(", DataType_str(t,0), ")\");\n",
tab8, "return 1; \n",
tab4, "}\n",
tab4, name, " = tval;\n",
0);
break;
// A single ascii character
case T_CHAR:
Wrapper_add_local(setf,"tval","char * tval");
Printv(setf->code,
tab4, "tval = (char *) PyString_AsString(val);\n",
tab4, "if (PyErr_Occurred()) {\n",
tab8, "PyErr_SetString(PyExc_TypeError,\"C variable '",
iname, "'(", DataType_str(t,0), ")\");\n",
tab8, "return 1; \n",
tab4, "}\n",
tab4, name, " = *tval;\n",
0);
break;
case T_USER:
t->is_pointer++;
Wrapper_add_localv(setf,"temp",DataType_lstr(t,0),"temp",0);
get_pointer(iname,(char*)"value",(char*)"val",(char*)"temp",t,setf->code,(char*)"1");
Printv(setf->code, tab4, name, " = *temp;\n", 0);
t->is_pointer--;
break;
case T_STRING:
Wrapper_add_local(setf,"tval","char * tval");
Printv(setf->code,
tab4, "tval = (char *) PyString_AsString(val);\n",
tab4, "if (PyErr_Occurred()) {\n",
tab8, "PyErr_SetString(PyExc_TypeError,\"C variable '",
iname, "'(", DataType_str(t,0), ")\");\n",
tab8, "return 1; \n",
tab4, "}\n",
0);
if (CPlusPlus) {
Printv(setf->code,
tab4, "if (", name, ") delete [] ", name, ";\n",
tab4, name, " = new char[strlen(tval)+1];\n",
tab4, "strcpy((char *)", name, ",tval);\n",
0);
} else {
// Parse a pointer value
if ((t->type == T_CHAR) && (t->is_pointer == 1)) {
Wrapper_add_local(setf,"tval","char * tval");
Printv(setf->code,
tab4, "tval = (char *) PyString_AsString(val);\n",
tab4, "if (PyErr_Occurred()) {\n",
tab8, "PyErr_SetString(PyExc_TypeError,\"C variable '",
iname, "'(", DataType_str(t,0), ")\");\n",
tab8, "return 1; \n",
tab4, "}\n",
0);
if (CPlusPlus) {
Printv(setf->code,
tab4, "if (", name, ") delete [] ", name, ";\n",
tab4, name, " = new char[strlen(tval)+1];\n",
tab4, "strcpy((char *)", name, ",tval);\n",
0);
} else {
Printv(setf->code,
tab4, "if (", name, ") free(", name, ");\n",
tab4, name, " = (char *) malloc(strlen(tval)+1);\n",
tab4, "strcpy((char *)", name, ",tval);\n",
0);
}
} else {
// Is a generic pointer value.
Wrapper_add_localv(setf,"temp", DataType_lstr(t,0), "temp",0);
get_pointer(iname,(char*)"value",(char*)"val",(char*)"temp",t,setf->code,(char*)"1");
Printv(setf->code,tab4, name, " = temp;\n", 0);
}
Printv(setf->code,
tab4, "if (", name, ") free(", name, ");\n",
tab4, name, " = (char *) malloc(strlen(tval)+1);\n",
tab4, "strcpy((char *)", name, ",tval);\n",
0);
}
break;
case T_POINTER: case T_ARRAY: case T_REFERENCE:
Wrapper_add_localv(setf,"temp", DataType_lstr(t,0), "temp",0);
get_pointer(iname,(char*)"value",(char*)"val",(char*)"temp",t,setf->code,(char*)"1");
Printv(setf->code,tab4, name, " = temp;\n", 0);
break;
default:
Printf(stderr,"%s : Line %d. Unable to link with type %s.\n", input_file, line_number, DataType_str(t,0));
}
}
Printf(setf->code," return 0;\n");
@ -1236,62 +1199,56 @@ void PYTHON::link_variable(char *name, char *iname, DataType *t) {
Printf(getf->code,"%s\n",tm);
Replace(getf->code,"$name",iname, DOH_REPLACE_ANY);
} else {
if ((t->type != T_VOID) || (t->is_pointer)) {
if (!t->is_pointer) {
/* Is a normal datatype */
switch(t->type) {
case T_INT: case T_UINT:
case T_SHORT: case T_USHORT:
case T_LONG: case T_ULONG:
case T_SCHAR: case T_UCHAR: case T_BOOL:
Printv(getf->code, tab4, "pyobj = PyInt_FromLong((long) ", name, ");\n", 0);
break;
case T_FLOAT: case T_DOUBLE:
Printv(getf->code, tab4, "pyobj = PyFloat_FromDouble((double) ", name, ");\n", 0);
break;
case T_CHAR:
Wrapper_add_local(getf,"ptemp","char ptemp[2]");
Printv(getf->code,
tab4, "ptemp[0] = ", name, ";\n",
tab4, "ptemp[1] = 0;\n",
tab4, "pyobj = PyString_FromString(ptemp);\n",
0);
break;
case T_USER:
// Hack this into a pointer
t->is_pointer++;
DataType_remember(t);
Printv(getf->code,
tab4, "pyobj = SWIG_NewPointerObj((void *) &", name ,
", SWIGTYPE", DataType_manglestr(t), ");\n",
0);
t->is_pointer--;
break;
default:
Printf(stderr,"Unable to link with type %s\n", DataType_str(t,0));
break;
}
} else {
// Is some sort of pointer value
if ((t->type == T_CHAR) && (t->is_pointer == 1)) {
Printv(getf->code,
tab4, "if (", name, ")\n",
tab8, "pyobj = PyString_FromString(", name, ");\n",
tab4, "else pyobj = PyString_FromString(\"(NULL)\");\n",
0);
} else {
DataType_remember(t);
Printv(getf->code,
tab4, "pyobj = SWIG_NewPointerObj((void *)", name,
", SWIGTYPE", DataType_manglestr(t), ");\n",
0);
}
}
switch(DataType_type(t)) {
case T_INT: case T_UINT:
case T_SHORT: case T_USHORT:
case T_LONG: case T_ULONG:
case T_SCHAR: case T_UCHAR: case T_BOOL:
Printv(getf->code, tab4, "pyobj = PyInt_FromLong((long) ", name, ");\n", 0);
break;
case T_FLOAT: case T_DOUBLE:
Printv(getf->code, tab4, "pyobj = PyFloat_FromDouble((double) ", name, ");\n", 0);
break;
case T_CHAR:
Wrapper_add_local(getf,"ptemp","char ptemp[2]");
Printv(getf->code,
tab4, "ptemp[0] = ", name, ";\n",
tab4, "ptemp[1] = 0;\n",
tab4, "pyobj = PyString_FromString(ptemp);\n",
0);
break;
case T_USER:
// Hack this into a pointer
t->is_pointer++;
DataType_remember(t);
Printv(getf->code,
tab4, "pyobj = SWIG_NewPointerObj((void *) &", name ,
", SWIGTYPE", DataType_manglestr(t), ");\n",
0);
t->is_pointer--;
break;
case T_STRING:
Printv(getf->code,
tab4, "if (", name, ")\n",
tab8, "pyobj = PyString_FromString(", name, ");\n",
tab4, "else pyobj = PyString_FromString(\"(NULL)\");\n",
0);
break;
case T_POINTER: case T_ARRAY: case T_REFERENCE:
DataType_remember(t);
Printv(getf->code,
tab4, "pyobj = SWIG_NewPointerObj((void *)", name,
", SWIGTYPE", DataType_manglestr(t), ");\n",
0);
break;
default:
Printf(stderr,"Unable to link with type %s\n", DataType_str(t,0));
break;
}
}
Printf(getf->code," return pyobj;\n}\n");
Wrapper_print(getf,f_wrappers);
@ -1333,40 +1290,31 @@ void PYTHON::declare_const(char *name, char *, DataType *type, char *value) {
if ((tm = typemap_lookup((char*)"const",(char*)"python",type,name,value,name))) {
Printf(const_code,"%s\n", tm);
} else {
if ((type->type == T_USER) && (!type->is_pointer)) {
Printf(stderr,"%s : Line %d. Unsupported constant value.\n", input_file, line_number);
switch(DataType_type(type)) {
case T_INT: case T_UINT: case T_BOOL:
case T_SHORT: case T_USHORT:
case T_LONG: case T_ULONG:
case T_SCHAR: case T_UCHAR:
Printv(const_code, tab4, "{ SWIG_PY_INT, \"", name, "\", (long) ", value, ", 0, 0, 0},\n", 0);
break;
case T_DOUBLE:
case T_FLOAT:
Printv(const_code, tab4, "{ SWIG_PY_FLOAT, \"", name, "\", 0, (double) ", value, ", 0,0},\n", 0);
break;
case T_CHAR :
Printv(const_code, tab4, "{ SWIG_PY_STRING, \"", name, "\", 0, 0, (void *) \"", value, "\", 0},\n", 0);
break;
case T_STRING:
Printv(const_code,tab4, "{ SWIG_PY_STRING, \"", name, "\", 0, 0, (void *) \"", value, "\", 0},\n", 0);
break;
case T_POINTER: case T_ARRAY: case T_REFERENCE:
DataType_remember(type);
Printv(const_code, tab4, "{ SWIG_PY_POINTER, \"", name, "\", 0, 0, (void *) ", value, ", &SWIGTYPE", DataType_manglestr(type), "}, \n", 0);
break;
default:
Printf(stderr,"%s : Line %d. Unsupported constant value.\n", input_file, line_number);
return;
}
if (type->is_pointer == 0) {
switch(type->type) {
case T_INT: case T_UINT: case T_BOOL:
case T_SHORT: case T_USHORT:
case T_LONG: case T_ULONG:
case T_SCHAR: case T_UCHAR:
Printv(const_code, tab4, "{ SWIG_PY_INT, \"", name, "\", (long) ", value, ", 0, 0, 0},\n", 0);
break;
case T_DOUBLE:
case T_FLOAT:
Printv(const_code, tab4, "{ SWIG_PY_FLOAT, \"", name, "\", 0, (double) ", value, ", 0,0},\n", 0);
break;
case T_CHAR :
Printv(const_code, tab4, "{ SWIG_PY_STRING, \"", name, "\", 0, 0, (void *) \"", value, "\", 0},\n", 0);
break;
default:
Printf(stderr,"%s : Line %d. Unsupported constant value.\n", input_file, line_number);
break;
}
} else {
if ((type->type == T_CHAR) && (type->is_pointer == 1)) {
Printv(const_code,tab4, "{ SWIG_PY_STRING, \"", name, "\", 0, 0, (void *) \"", value, "\", 0},\n", 0);
} else {
// A funky user-defined type. We're going to munge it into a string pointer value
DataType_remember(type);
Printv(const_code, tab4, "{ SWIG_PY_POINTER, \"", name, "\", 0, 0, (void *) ", value, ", &SWIGTYPE", DataType_manglestr(type), "}, \n", 0);
}
break;
}
}
if ((shadow) && (!(shadow & PYSHADOW_MEMBER))) {
@ -1425,7 +1373,7 @@ char *PYTHON::usage_func(char *iname, DataType *, ParmList *l) {
i++;
/* If parameter has been named, use that. Otherwise, just print a type */
if ((pt->type != T_VOID) || (pt->is_pointer)) {
if (DataType_type(pt) != T_VOID) {
if (strlen(pn) > 0) {
Printf(temp,"%s",pn);
} else {

143
Source/Modules1.1/ruby.cxx
View file

@ -176,9 +176,8 @@ void RUBY::parse() {
headers();
// typedef void *VALUE
DataType *value = NewDataType(0);
DataType *value = NewDataType(T_VOID);
strcpy(value->name, "void");
value->type = T_VOID;
value->is_pointer = 1;
value->implicit_ptr = 0;
DataType_typedef_add(value,(char*)"VALUE",0);
@ -582,7 +581,7 @@ void RUBY::create_function(char *name, char *iname, DataType *t, ParmList *l) {
// Return value if necessary
if ((t->type != T_VOID) || (t->is_pointer)) {
if (DataType_type(t) != T_VOID) {
if (predicate) {
Printv(f->code, tab4, "vresult = (result ? Qtrue : Qfalse);\n", 0);
} else {
@ -682,7 +681,7 @@ void RUBY::link_variable(char *name, char *iname, DataType *t) {
indent(s);
Printv(getf->code,s,"\n", 0);
Delete(s);
} else if (!t->is_pointer && t->type == T_USER) {
} else if (DataType_type(t) == T_USER) {
// Hack this into a pointer
t->is_pointer++;
DataType_remember(t);
@ -715,7 +714,7 @@ void RUBY::link_variable(char *name, char *iname, DataType *t) {
indent(s);
Printv(setf->code,s,"\n",0);
Delete(s);
} else if (!t->is_pointer && t->type == T_USER) {
} else if (DataType_type(t) == T_USER) {
t->is_pointer++;
Wrapper_add_localv(setf,"temp",DataType_lstr(t,0), "temp",0);
Printv(setf->code, tab4, "temp = (", DataType_lstr(t,0), ")",
@ -876,11 +875,11 @@ char *RUBY::ruby_typemap_lookup(char *op, DataType *type, char *pname, char *sou
if ((strcmp("out", op) == 0 || strcmp("in", op) == 0)
&& strcmp(type->name, "VALUE") == 0) {
Printf(s,"$target = $source;");
} else if (strcmp("out", op) == 0 && type->type == T_USER &&
} else if (strcmp("out", op) == 0 && (DataType_Gettypecode(type) == T_USER) &&
type->is_pointer == 1 && cls) {
const char *vname = (current == CONSTRUCTOR ? "self" : Char(cls->vname));
Printv(s, "$target = Wrap_", cls->cname, "(", vname, ", $source);",0);
} else if (strcmp("in", op)==0 && type->type == T_USER &&
} else if (strcmp("in", op)==0 && (DataType_Gettypecode(type) == T_USER) &&
type->is_pointer == 1 && cls) {
Printv(s, "Get_", cls->cname, "($source, $target);", 0);
} else {
@ -932,42 +931,41 @@ char *RUBY::ruby_typemap_lookup(char *op, DataType *type, char *pname, char *sou
// ---------------------------------------------------------------------
int RUBY::to_VALUE(DataType *type, char *value, DOHString *str, int raw) {
Clear(str);
if (type->is_pointer == 0) {
switch(type->type) {
case T_INT:
case T_SHORT:
case T_LONG:
case T_SCHAR:
Printv(str, "INT2NUM(", value, ")", 0);
break;
case T_UINT:
case T_USHORT:
case T_ULONG:
case T_UCHAR:
Printv(str,"UINT2NUM(", value, ")", 0);
break;
case T_DOUBLE:
case T_FLOAT:
Printv(str, "rb_float_new(", value, ")", 0);
break;
case T_CHAR:
Printv(str, "rb_str_new(&", value, ", 1)", 0);
break;
case T_BOOL:
Printv(str, "(", value, " ? Qtrue : Qfalse)", 0);
break;
default:
break;
}
} else if ((type->type == T_CHAR) && (type->is_pointer == 1)) {
switch(DataType_type(type)) {
case T_INT:
case T_SHORT:
case T_LONG:
case T_SCHAR:
Printv(str, "INT2NUM(", value, ")", 0);
break;
case T_UINT:
case T_USHORT:
case T_ULONG:
case T_UCHAR:
Printv(str,"UINT2NUM(", value, ")", 0);
break;
case T_DOUBLE:
case T_FLOAT:
Printv(str, "rb_float_new(", value, ")", 0);
break;
case T_CHAR:
Printv(str, "rb_str_new(&", value, ", 1)", 0);
break;
case T_BOOL:
Printv(str, "(", value, " ? Qtrue : Qfalse)", 0);
break;
case T_STRING:
if (raw)
Printv(str, "rb_str_new2(\"", value, "\")", 0);
else
Printv(str, "rb_str_new2(", value, ")", 0);
} else {
break;
case T_POINTER: case T_ARRAY: case T_REFERENCE:
Printv(str, "SWIG_NewPointerObj((void *)", value, ", \"", DataType_manglestr(type), "\")", 0);
break;
default:
break;
}
if (Len(str) == 0)
return 0;
return 1;
@ -983,45 +981,44 @@ int RUBY::to_VALUE(DataType *type, char *value, DOHString *str, int raw) {
// ---------------------------------------------------------------------
int RUBY::from_VALUE(DataType *type, char *value, DOHString *str) {
Clear(str);
if (type->is_pointer == 0) {
switch(type->type) {
case T_INT:
Printv(str, "NUM2INT(", value, ")", 0);
break;
case T_LONG:
Printv(str, "NUM2LONG(", value, ")", 0);
break;
case T_SHORT:
Printv(str, "NUM2SHRT(", value, ")", 0);
break;
case T_UINT:
Printv(str, "NUM2UINT(", value, ")", 0);
break;
case T_ULONG:
Printv(str, "NUM2ULONG(", value, ")", 0);
break;
case T_USHORT:
Printv(str, "NUM2USHRT(", value, ")", 0);
break;
case T_DOUBLE:
case T_FLOAT:
Printv(str, "NUM2DBL(", value, ")", 0);
break;
case T_CHAR: case T_SCHAR: case T_UCHAR:
Printv(str, "NUM2CHR(", value, ")", 0);
break;
case T_BOOL:
Printv(str,"RTEST(", value, ")", 0);
break;
default:
break;
}
} else if ((type->type == T_CHAR) && (type->is_pointer == 1)) {
switch(DataType_type(type)) {
case T_INT:
Printv(str, "NUM2INT(", value, ")", 0);
break;
case T_LONG:
Printv(str, "NUM2LONG(", value, ")", 0);
break;
case T_SHORT:
Printv(str, "NUM2SHRT(", value, ")", 0);
break;
case T_UINT:
Printv(str, "NUM2UINT(", value, ")", 0);
break;
case T_ULONG:
Printv(str, "NUM2ULONG(", value, ")", 0);
break;
case T_USHORT:
Printv(str, "NUM2USHRT(", value, ")", 0);
break;
case T_DOUBLE:
case T_FLOAT:
Printv(str, "NUM2DBL(", value, ")", 0);
break;
case T_CHAR: case T_SCHAR: case T_UCHAR:
Printv(str, "NUM2CHR(", value, ")", 0);
break;
case T_BOOL:
Printv(str,"RTEST(", value, ")", 0);
break;
case T_STRING:
Printv(str, "STR2CSTR(", value, ")", 0);
} else {
break;
case T_POINTER: case T_ARRAY: case T_REFERENCE:
Printv(str, "SWIG_ConvertPtr(", value, ", \"", DataType_manglestr(type), "\")", 0);
break;
default:
break;
}
if (Len(str) == 0) return 0;
return 1;
}

611
Source/Modules1.1/tcl8.cxx
View file

@ -430,7 +430,7 @@ void TCL8::get_pointer(char *iname, char *srcname, char *src, char *dest,
DataType_remember(t);
Printv(f, tab4, "if ((SWIG_ConvertPtr(interp,", src, ",(void **) &", dest, ",",0);
if (t->type == T_VOID) Printf(f, "0)) == TCL_ERROR) { return TCL_ERROR; }\n");
if (DataType_type(t) == T_VOID) Printf(f, "0)) == TCL_ERROR) { return TCL_ERROR; }\n");
else
Printv(f, "SWIGTYPE", DataType_manglestr(t), ")) == TCL_ERROR) { return TCL_ERROR; }\n", 0);
}
@ -530,97 +530,90 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l)
Replace(incode,"$argnum",argnum, DOH_REPLACE_ANY);
Replace(incode,"$arg",source, DOH_REPLACE_ANY);
} else {
if (!pt->is_pointer) {
// Extract a parameter by value.
switch(pt->type) {
switch(DataType_type(pt)) {
// Signed Integers
case T_INT:
case T_UINT:
Putc('i', argstr);
Printf(args,",&%s",target);
break;
case T_BOOL:
Putc('i',argstr);
{
char tb[32];
sprintf(tb,"tempb%d",i);
Wrapper_add_localv(f,tb,"int",tb,0);
Printf(args,",&%s",tb);
Printv(incode, tab4, target, " = (bool) ", tb, ";\n", 0);
}
break;
case T_SHORT:
case T_USHORT:
Putc('h',argstr);
Printf(args,",&%s",target);
break;
case T_LONG:
case T_ULONG:
Putc('l',argstr);
Printf(args,",&%s",target);
break;
case T_SCHAR:
case T_UCHAR:
Putc('b',argstr);
Printf(args,",&%s", target);
break;
case T_INT:
case T_UINT:
Putc('i', argstr);
Printf(args,",&%s",target);
break;
case T_BOOL:
Putc('i',argstr);
{
char tb[32];
sprintf(tb,"tempb%d",i);
Wrapper_add_localv(f,tb,"int",tb,0);
Printf(args,",&%s",tb);
Printv(incode, tab4, target, " = (bool) ", tb, ";\n", 0);
}
break;
case T_SHORT:
case T_USHORT:
Putc('h',argstr);
Printf(args,",&%s",target);
break;
case T_LONG:
case T_ULONG:
Putc('l',argstr);
Printf(args,",&%s",target);
break;
case T_SCHAR:
case T_UCHAR:
Putc('b',argstr);
Printf(args,",&%s", target);
break;
// Floating point
case T_FLOAT:
Putc('f',argstr);
Printf(args,",&%s", target);
break;
case T_DOUBLE:
Putc('d',argstr);
Printf(args,",&%s", target);
break;
// A single character
case T_CHAR :
Putc('c',argstr);
Printf(args,",&%s",target);
break;
// Void.. Do nothing.
case T_VOID :
break;
// User defined. This is an error.
case T_USER:
pt->is_pointer++;
DataType_remember(pt);
Putc('p',argstr);
Printv(args, ",&", target, ", SWIGTYPE", DataType_manglestr(pt), 0);
pt->is_pointer--;
break;
case T_STRING:
Putc('s',argstr);
Printf(args,",&%s",target);
break;
case T_FLOAT:
Putc('f',argstr);
Printf(args,",&%s", target);
break;
case T_POINTER: case T_ARRAY: case T_REFERENCE:
DataType_remember(pt);
Putc('p',argstr);
Printv(args, ",&", target, ", SWIGTYPE", DataType_manglestr(pt), 0);
break;
case T_DOUBLE:
Putc('d',argstr);
Printf(args,",&%s", target);
break;
// A single character
case T_CHAR :
Putc('c',argstr);
Printf(args,",&%s",target);
break;
// Void.. Do nothing.
case T_VOID :
break;
// User defined. This is an error.
// Unsupported data type
case T_USER:
pt->is_pointer++;
DataType_remember(pt);
Putc('p',argstr);
Printv(args, ",&", target, ", SWIGTYPE", DataType_manglestr(pt), 0);
pt->is_pointer--;
break;
// Unsupported data type
default :
Printf(stderr,"%s : Line %d: Unable to use type %s as a function argument.\n",
input_file, line_number, DataType_str(pt,0));
break;
}
} else {
// Function argument is some sort of pointer
// Look for a string. Otherwise, just pull off a pointer.
if ((pt->type == T_CHAR) && (pt->is_pointer == 1)) {
Putc('s',argstr);
Printf(args,",&%s",target);
} else {
DataType_remember(pt);
Putc('p',argstr);
Printv(args, ",&", target, ", SWIGTYPE", DataType_manglestr(pt), 0);
}
default :
Printf(stderr,"%s : Line %d: Unable to use type %s as a function argument.\n",
input_file, line_number, DataType_str(pt,0));
break;
}
}
j++;
@ -666,13 +659,8 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l)
if ((tm = typemap_lookup((char*)"out",(char*)"tcl8",d,name,(char*)"result",(char*)"tcl_result"))) {
// Yep. Use it instead of the default
Printf(f->code,"%s\n", tm);
} else if ((d->type != T_VOID) || (d->is_pointer)) {
if (!d->is_pointer) {
// Function returns a "value"
switch(d->type) {
// Is an integer
} else {
switch(DataType_type(d)) {
case T_BOOL:
case T_INT:
case T_SHORT:
@ -710,25 +698,24 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l)
d->is_pointer--;
break;
// Unknown type
default :
Printf(stderr,"%s : Line %d: Unable to use return type %s in function %s.\n",
input_file, line_number, DataType_str(d,0), name);
break;
}
} else {
// Is a pointer return type
if ((d->type == T_CHAR) && (d->is_pointer == 1)) {
case T_STRING:
// Return a character string
Printv(f->code, tab4, "Tcl_SetObjResult(interp,Tcl_NewStringObj(result,-1));\n",0);
} else {
break;
case T_POINTER: case T_REFERENCE: case T_ARRAY:
DataType_remember(d);
Printv(f->code, tab4, "Tcl_SetObjResult(interp,SWIG_NewPointerObj((void *) result,SWIGTYPE",
DataType_manglestr(d), "));\n",
0);
}
break;
case T_VOID:
break;
// Unknown type
default :
Printf(stderr,"%s : Line %d: Unable to use return type %s in function %s.\n",
input_file, line_number, DataType_str(d,0), name);
break;
}
}
@ -812,130 +799,129 @@ void TCL8::link_variable(char *name, char *iname, DataType *t)
Printv(set->code, tab4, "value = Tcl_GetVar2(interp, name1, name2, flags);\n",
tab4, "if (!value) return NULL;\n", 0);
if (!t->is_pointer) {
switch(t->type) {
case T_INT:
case T_SHORT:
case T_USHORT:
case T_LONG:
case T_UCHAR:
case T_SCHAR:
case T_BOOL:
Printv(set->code, tab4, "*(addr) = (", DataType_str(t,0), ") atol(value);\n", 0);
break;
case T_UINT:
case T_ULONG:
Printv(set->code, tab4, "*(addr) = (", DataType_str(t,0), ") strtoul(value,0,0);\n",0);
break;
case T_FLOAT:
case T_DOUBLE:
Printv(set->code, tab4, "*(addr) = (", DataType_str(t,0), ") atof(value);\n",0);
break;
case T_CHAR: /* Single character. */
Printv(set->code, tab4, "*(addr) = *value;\n",0);
break;
case T_USER:
// User defined type. We return it as a pointer
t->is_pointer++;
DataType_remember(t);
Printv(set->code, tab4, "{\n",
tab8, "void *ptr;\n",
tab8, "if (SWIG_ConvertPtrFromString(interp,value,&ptr,SWIGTYPE", DataType_manglestr(t), ") != TCL_OK) {\n",
tab8, tab4, "return \"Type Error\";\n",
tab8, "}\n",
tab8, "*(addr) = *((", DataType_lstr(t,0), ") ptr);\n",
tab4, "}\n",
0);
switch(DataType_type(t)) {
case T_INT:
case T_SHORT:
case T_USHORT:
case T_LONG:
case T_UCHAR:
case T_SCHAR:
case T_BOOL:
Printv(set->code, tab4, "*(addr) = (", DataType_str(t,0), ") atol(value);\n", 0);
break;
case T_UINT:
case T_ULONG:
Printv(set->code, tab4, "*(addr) = (", DataType_str(t,0), ") strtoul(value,0,0);\n",0);
break;
case T_FLOAT:
case T_DOUBLE:
Printv(set->code, tab4, "*(addr) = (", DataType_str(t,0), ") atof(value);\n",0);
break;
case T_CHAR: /* Single character. */
Printv(set->code, tab4, "*(addr) = *value;\n",0);
break;
case T_USER:
// User defined type. We return it as a pointer
t->is_pointer++;
DataType_remember(t);
Printv(set->code, tab4, "{\n",
tab8, "void *ptr;\n",
tab8, "if (SWIG_ConvertPtrFromString(interp,value,&ptr,SWIGTYPE", DataType_manglestr(t), ") != TCL_OK) {\n",
tab8, tab4, "return \"Type Error\";\n",
tab8, "}\n",
tab8, "*(addr) = *((", DataType_lstr(t,0), ") ptr);\n",
tab4, "}\n",
0);
t->is_pointer--;
break;
case T_STRING:
Printv(set->code, tab4, "if (*addr) free(*addr);\n",
tab4, "*addr = (char *) malloc(strlen(value)+1);\n",
tab4, "strcpy(*addr,value);\n",
0);
break;
case T_POINTER: case T_ARRAY: case T_REFERENCE:
// User defined type. We return it as a pointer
DataType_remember(t);
Printv(set->code, tab4, "{\n",
tab8, "void *ptr;\n",
tab8, "if (SWIG_ConvertPtrFromString(interp,value,&ptr,SWIGTYPE", DataType_manglestr(t), ") != TCL_OK) {\n",
tab8, tab4, "return \"Type Error\";\n",
tab8, "}\n",
tab8, "*(addr) = (", DataType_lstr(t,0), ") ptr;\n",
tab4, "}\n",
0);
break;
case T_VOID:
break;
t->is_pointer--;
break;
default:
Printf(stderr,"Unknown type %d!\n", t->type);
break;
}
} else {
if ((t->is_pointer == 1) && (t->type == T_CHAR)) {
Printv(set->code, tab4, "if (*addr) free(*addr);\n",
tab4, "*addr = (char *) malloc(strlen(value)+1);\n",
tab4, "strcpy(*addr,value);\n",
0);
} else {
// User defined type. We return it as a pointer
DataType_remember(t);
Printv(set->code, tab4, "{\n",
tab8, "void *ptr;\n",
tab8, "if (SWIG_ConvertPtrFromString(interp,value,&ptr,SWIGTYPE", DataType_manglestr(t), ") != TCL_OK) {\n",
tab8, tab4, "return \"Type Error\";\n",
tab8, "}\n",
tab8, "*(addr) = (", DataType_lstr(t,0), ") ptr;\n",
tab4, "}\n",
0);
/* A Pointer */
}
default:
Printf(stderr,"Unknown type %s!\n", DataType_str(t,0));
break;
}
Printv(set->code, tab4, "return NULL;\n", "}\n",0);
if (!t->is_pointer) {
switch(t->type) {
case T_INT:
case T_UINT:
case T_SHORT:
case T_USHORT:
case T_LONG:
case T_ULONG:
case T_UCHAR:
case T_SCHAR:
case T_BOOL:
Wrapper_add_local(get,"value","Tcl_Obj *value");
Printv(get->code,
tab4, "value = Tcl_NewIntObj((int) *addr);\n",
tab4, "Tcl_SetVar2(interp,name1,name2,Tcl_GetStringFromObj(value,NULL), flags);\n",
tab4, "Tcl_DecrRefCount(value);\n",
0);
break;
case T_FLOAT:
case T_DOUBLE:
Wrapper_add_local(get,"value","Tcl_Obj *value");
Printv(get->code,
tab4, "value = Tcl_NewDoubleObj((double) *addr);\n",
tab4, "Tcl_SetVar2(interp,name1,name2,Tcl_GetStringFromObj(value,NULL), flags);\n",
tab4, "Tcl_DecrRefCount(value);\n",
0);
break;
switch(DataType_type(t)) {
case T_INT:
case T_UINT:
case T_SHORT:
case T_USHORT:
case T_LONG:
case T_ULONG:
case T_UCHAR:
case T_SCHAR:
case T_BOOL:
Wrapper_add_local(get,"value","Tcl_Obj *value");
Printv(get->code,
tab4, "value = Tcl_NewIntObj((int) *addr);\n",
tab4, "Tcl_SetVar2(interp,name1,name2,Tcl_GetStringFromObj(value,NULL), flags);\n",
tab4, "Tcl_DecrRefCount(value);\n",
0);
break;
case T_FLOAT:
case T_DOUBLE:
Wrapper_add_local(get,"value","Tcl_Obj *value");
Printv(get->code,
tab4, "value = Tcl_NewDoubleObj((double) *addr);\n",
tab4, "Tcl_SetVar2(interp,name1,name2,Tcl_GetStringFromObj(value,NULL), flags);\n",
tab4, "Tcl_DecrRefCount(value);\n",
0);
break;
case T_CHAR:
Wrapper_add_local(get,"temp", "char temp[2]");
Printv(get->code,tab4, "temp[0] = *addr; temp[1] = 0;\n",
tab4, "Tcl_SetVar2(interp,name1,name2,temp,flags);\n",
0);
break;
case T_USER:
Wrapper_add_local(get,"value", "Tcl_Obj *value");
t->is_pointer++;
DataType_remember(t);
Printv(get->code, tab4, "value = SWIG_NewPointerObj(addr, SWIGTYPE", DataType_manglestr(t), ");\n",
tab4, "Tcl_SetVar2(interp,name1,name2,Tcl_GetStringFromObj(value,NULL), flags);\n",
tab4, "Tcl_DecrRefCount(value);\n",0);
t->is_pointer--;
break;
case T_STRING:
Printv(get->code, tab4, "Tcl_SetVar2(interp,name1,name2,*addr, flags);\n",0);
break;
case T_CHAR:
Wrapper_add_local(get,"temp", "char temp[2]");
Printv(get->code,tab4, "temp[0] = *addr; temp[1] = 0;\n",
tab4, "Tcl_SetVar2(interp,name1,name2,temp,flags);\n",
0);
break;
case T_USER:
Wrapper_add_local(get,"value", "Tcl_Obj *value");
t->is_pointer++;
DataType_remember(t);
Printv(get->code, tab4, "value = SWIG_NewPointerObj(addr, SWIGTYPE", DataType_manglestr(t), ");\n",
tab4, "Tcl_SetVar2(interp,name1,name2,Tcl_GetStringFromObj(value,NULL), flags);\n",
tab4, "Tcl_DecrRefCount(value);\n",0);
t->is_pointer--;
break;
default:
break;
}
} else {
if ((t->is_pointer == 1) && (t->type == T_CHAR)) {
Printv(get->code, tab4, "Tcl_SetVar2(interp,name1,name2,*addr, flags);\n",0);
} else {
Wrapper_add_local(get,"value","Tcl_Obj *value");
DataType_remember(t);
Printv(get->code,
tab4, "value = SWIG_NewPointerObj(*addr, SWIGTYPE", DataType_manglestr(t), ");\n",
tab4, "Tcl_SetVar2(interp,name1,name2,Tcl_GetStringFromObj(value,NULL), flags);\n",
tab4, "Tcl_DecrRefCount(value);\n",
0);
}
case T_POINTER: case T_ARRAY: case T_REFERENCE:
Wrapper_add_local(get,"value","Tcl_Obj *value");
DataType_remember(t);
Printv(get->code,
tab4, "value = SWIG_NewPointerObj(*addr, SWIGTYPE", DataType_manglestr(t), ");\n",
tab4, "Tcl_SetVar2(interp,name1,name2,Tcl_GetStringFromObj(value,NULL), flags);\n",
tab4, "Tcl_DecrRefCount(value);\n",
0);
break;
default:
break;
}
Printv(get->code, tab4, "return NULL;\n", "}\n",0);
@ -984,9 +970,9 @@ void TCL8::declare_const(char *name, char *, DataType *type, char *value) {
sprintf(var_name,"_wrap_const_%s",name);
// See if there's a typemap
if ((type->type == T_CHAR) && (type->is_pointer == 1)) {
if (DataType_type(type) == T_STRING) {
rvalue = NewStringf("\"%s\"",value);
} else if ((type->type == T_CHAR) && (type->is_pointer == 0)) {
} else if (DataType_type(type) == T_CHAR) {
rvalue = NewStringf("\'%s\'",value);
} else {
rvalue = NewString(value);
@ -997,89 +983,86 @@ void TCL8::declare_const(char *name, char *, DataType *type, char *value) {
} else {
// Create variable and assign it a value
if (type->is_pointer == 0) {
switch(type->type) {
case T_BOOL: case T_INT: case T_DOUBLE:
Printf(f_header,"static %s %s = %s;\n", DataType_str(type,0), var_name, value);
link_variable(var_name,name,type);
break;
case T_SHORT:
case T_LONG:
case T_SCHAR:
Printf(f_header,"static %s %s = %s;\n", DataType_str(type,0), var_name, value);
Printf(f_header,"static char *%s_char;\n", var_name);
if (CPlusPlus)
Printf(f_init,"\t %s_char = new char[32];\n",var_name);
else
Printf(f_init,"\t %s_char = (char *) malloc(32);\n",var_name);
switch(DataType_type(type)) {
case T_BOOL: case T_INT: case T_DOUBLE:
Printf(f_header,"static %s %s = %s;\n", DataType_str(type,0), var_name, value);
link_variable(var_name,name,type);
break;
case T_SHORT:
case T_LONG:
case T_SCHAR:
Printf(f_header,"static %s %s = %s;\n", DataType_str(type,0), var_name, value);
Printf(f_header,"static char *%s_char;\n", var_name);
if (CPlusPlus)
Printf(f_init,"\t %s_char = new char[32];\n",var_name);
else
Printf(f_init,"\t %s_char = (char *) malloc(32);\n",var_name);
Printf(f_init,"\t sprintf(%s_char,\"%%ld\", (long) %s);\n", var_name, var_name);
sprintf(var_name,"%s_char",var_name);
t = NewDataType(T_CHAR);
t->is_pointer = 1;
link_variable(var_name,name,t);
DelDataType(t);
break;
case T_UINT:
case T_USHORT:
case T_ULONG:
case T_UCHAR:
Printf(f_header,"static %s %s = %s;\n", DataType_str(type,0), var_name, value);
Printf(f_header,"static char *%s_char;\n", var_name);
if (CPlusPlus)
Printf(f_init,"\t %s_char = new char[32];\n",var_name);
else
Printf(f_init,"\t %s_char = (char *) malloc(32);\n",var_name);
Printf(f_init,"\t sprintf(%s_char,\"%%lu\", (unsigned long) %s);\n", var_name, var_name);
sprintf(var_name,"%s_char",var_name);
t = NewDataType(T_CHAR);
t->is_pointer = 1;
link_variable(var_name,name,t);
DelDataType(t);
break;
case T_FLOAT:
DataType_Settypecode(type,T_DOUBLE);
strcpy(type->name,"double");
Printf(f_header,"static %s %s = (%s) (%s);\n", DataType_lstr(type,0), var_name, DataType_lstr(type,0), value);
link_variable(var_name,name,type);
break;
Printf(f_init,"\t sprintf(%s_char,\"%%ld\", (long) %s);\n", var_name, var_name);
sprintf(var_name,"%s_char",var_name);
t = NewDataType(T_CHAR);
t->is_pointer = 1;
link_variable(var_name,name,t);
DelDataType(t);
break;
case T_UINT:
case T_USHORT:
case T_ULONG:
case T_UCHAR:
Printf(f_header,"static %s %s = %s;\n", DataType_str(type,0), var_name, value);
Printf(f_header,"static char *%s_char;\n", var_name);
if (CPlusPlus)
Printf(f_init,"\t %s_char = new char[32];\n",var_name);
else
Printf(f_init,"\t %s_char = (char *) malloc(32);\n",var_name);
Printf(f_init,"\t sprintf(%s_char,\"%%lu\", (unsigned long) %s);\n", var_name, var_name);
sprintf(var_name,"%s_char",var_name);
t = NewDataType(T_CHAR);
t->is_pointer = 1;
link_variable(var_name,name,t);
DelDataType(t);
break;
case T_FLOAT:
type->type = T_DOUBLE;
strcpy(type->name,"double");
Printf(f_header,"static %s %s = (%s) (%s);\n", DataType_lstr(type,0), var_name, DataType_lstr(type,0), value);
link_variable(var_name,name,type);
break;
case T_CHAR:
type->is_pointer++;
Printf(f_header,"static %s %s = \"%s\";\n", DataType_lstr(type,0), var_name, value);
link_variable(var_name,name,type);
type->is_pointer--;
break;
default:
Printf(stderr,"%s : Line %d. Unsupported constant value.\n", input_file, line_number);
break;
}
} else {
// Have some sort of pointer value here
if ((type->type == T_CHAR) && (type->is_pointer == 1)) {
// Character string
Printf(f_header,"static %s %s = \"%s\";\n", DataType_lstr(type,0), var_name, value);
link_variable(var_name,name,type);
} else {
// Something else. Some sort of pointer value
Printf(f_header,"static %s %s = %s;\n", DataType_lstr(type,0), var_name, value);
Printf(f_header,"static char *%s_char;\n", var_name);
if (CPlusPlus)
Printf(f_init,"\t %s_char = new char[%d];\n",var_name,(int) strlen(DataType_manglestr(type))+ 20);
else
Printf(f_init,"\t %s_char = (char *) malloc(%d);\n",var_name, (int) strlen(DataType_manglestr(type))+ 20);
t = NewDataType(T_CHAR);
t->is_pointer = 1;
DataType_remember(type);
Printf(f_init,"\t SWIG_MakePtr(%s_char, (void *) %s, SWIGTYPE%s);\n",
var_name, var_name, DataType_manglestr(type));
sprintf(var_name,"%s_char",var_name);
link_variable(var_name,name,t);
DelDataType(t);
}
case T_CHAR:
type->is_pointer++;
Printf(f_header,"static %s %s = \"%s\";\n", DataType_lstr(type,0), var_name, value);
link_variable(var_name,name,type);
type->is_pointer--;
break;
case T_STRING:
Printf(f_header,"static %s %s = \"%s\";\n", DataType_lstr(type,0), var_name, value);
link_variable(var_name,name,type);
break;
case T_POINTER: case T_ARRAY: case T_REFERENCE:
// Something else. Some sort of pointer value
Printf(f_header,"static %s %s = %s;\n", DataType_lstr(type,0), var_name, value);
Printf(f_header,"static char *%s_char;\n", var_name);
if (CPlusPlus)
Printf(f_init,"\t %s_char = new char[%d];\n",var_name,(int) strlen(DataType_manglestr(type))+ 20);
else
Printf(f_init,"\t %s_char = (char *) malloc(%d);\n",var_name, (int) strlen(DataType_manglestr(type))+ 20);
t = NewDataType(T_CHAR);
t->is_pointer = 1;
DataType_remember(type);
Printf(f_init,"\t SWIG_MakePtr(%s_char, (void *) %s, SWIGTYPE%s);\n",
var_name, var_name, DataType_manglestr(type));
sprintf(var_name,"%s_char",var_name);
link_variable(var_name,name,t);
DelDataType(t);
break;
default:
Printf(stderr,"%s : Line %d. Unsupported constant value.\n", input_file, line_number);
break;
}
}
Delete(rvalue);
@ -1101,14 +1084,6 @@ char *TCL8::usage_var(char *iname, DataType *t) {
} else {
sprintf(temp,"%s::%s", ns_name, iname);
}
if (!(((t->type == T_INT) && (!t->is_pointer)) ||
((t->type == T_UINT) && (!t->is_pointer)) ||
((t->type == T_DOUBLE) && (!t->is_pointer)) ||
((t->type == T_BOOL) && (!t->is_pointer)) ||
((t->type == T_CHAR) && (t->is_pointer)))) {
/* We emitted a pair of set/get functions instead. Doc will be generated for that */
return temp;
}
return temp;
}
@ -1147,8 +1122,7 @@ char * TCL8::usage_string(char *iname, DataType *, ParmList *l) {
Putc('?',temp);
/* If parameter has been named, use that. Otherwise, just print a type */
if ((pt->type != T_VOID) || (pt->is_pointer)) {
if (DataType_type(pt) != T_VOID) {
if (strlen(pn) > 0) {
Printf(temp,pn);
}
@ -1281,9 +1255,8 @@ void TCL8::cpp_close_class() {
this->Language::cpp_close_class();
if (shadow) {
t = NewDataType(0);
t = NewDataType(T_USER);
sprintf(t->name,"%s%s", class_type, real_classname);
t->type = T_USER;
t->is_pointer = 1;
if (have_destructor) {

3
Source/SWIG1.1/emit.cxx
View file

@ -159,12 +159,11 @@ void emit_set_get(char *name, char *iname, DataType *t) {
/* First write a function to set the variable of the variable */
if (!(Status & STAT_READONLY)) {
if ((t->type == T_CHAR) && (t->is_pointer == 1)) {
if (DataType_type(t) == T_STRING) {
if (CPlusPlus)
code = cpp_str;
else
code = c_str;
}
w = Swig_cvarset_wrapper(name, t, code);
Wrapper_print(w,f_header);

74
Source/SWIG1.1/parser.yxx
View file

@ -386,9 +386,9 @@ void create_constant(char *name, DataType *type, char *value) {
Rename_true = 0;
}
if ((type->type == T_CHAR) && (!type->is_pointer))
if (DataType_type(type) == T_CHAR) {
type->is_pointer++;
}
if (!value) value = Swig_copy_string(name);
sprintf(temp_name,"const:%s", name);
if (add_symbol(temp_name)) {
@ -1001,7 +1001,7 @@ statement : INCLUDE STRING LBRACE {
| extern ENUM ename LBRACE { scanner_clear_start(); } enumlist RBRACE SEMI {
init_language();
if ($3) {
temp_type->type = T_INT;
DataType_Settypecode(temp_type,T_INT);
temp_type->is_pointer = 0;
temp_type->implicit_ptr = 0;
sprintf(temp_type->name,"int");
@ -1014,7 +1014,7 @@ statement : INCLUDE STRING LBRACE {
| TYPEDEF ENUM ename LBRACE { scanner_clear_start(); } enumlist RBRACE ID {
init_language();
temp_type->type = T_INT;
DataType_Settypecode(temp_type,T_INT);
temp_type->is_pointer = 0;
temp_type->implicit_ptr = 0;
sprintf(temp_type->name,"int");
@ -1260,7 +1260,7 @@ typedef_decl : TYPEDEF type declaration {
emit_extern_func(temp_name, $2,$8,0,f_header);
}
strcpy($2->name,"<function ptr>");
$2->type = T_USER;
DataType_Settypecode($2,T_USER);
$2->is_pointer = 1;
DataType_typedef_add($2,$5,1);
lang->add_typedef($2,$5);
@ -1283,7 +1283,7 @@ typedef_decl : TYPEDEF type declaration {
/* Typedef'd pointer */
strcpy($2->name,"<function ptr>");
$2->type = T_USER;
DataType_Settypecode($2,T_USER);
$2->is_pointer = 1;
DataType_typedef_add($2,$6,1);
lang->add_typedef($2,$6);
@ -1431,8 +1431,8 @@ func_end : cpp_const LBRACE { skip_brace(); }
parms : parm ptail {
DataType *pt = Gettype($1);
if ((pt->type != T_VOID) || (pt->is_pointer))
Insert($2,0,$1);
if (DataType_type(pt) != T_VOID)
Insert($2,0,$1);
$$ = $2;
}
| empty { $$ = NewParmList(); }
@ -1493,7 +1493,7 @@ parm_type : type pname {
FatalError();
$$ = NewParm($1,$4);
DataType *pt = Gettype($$);
pt->type = T_ERROR;
DataType_Settypecode(pt,T_ERROR);
Setname($$,$4);
strcpy(pt->name,"<function ptr>");
DelDataType($1);
@ -1504,7 +1504,7 @@ parm_type : type pname {
fprintf(stderr,"%s : Line %d. Variable length arguments not supported (ignored).\n", input_file, line_number);
$$ = NewParm(NewDataType(T_INT),(char *) "varargs");
DataType *pt = Gettype($$);
pt->type = T_ERROR;
DataType_Settypecode(pt,T_ERROR);
Setname($$,(char*)"varargs");
strcpy(pt->name,"<varargs>");
FatalError();
@ -1646,9 +1646,8 @@ type : TYPE_INT {
}
}
| ID objc_protolist {
$$ = NewDataType(0);
$$ = NewDataType(T_USER);
strcpy($$->name,$1);
$$->type = T_USER;
/* Do a typedef lookup */
DataType_typedef_resolve($$,0);
if (strlen($2) > 0) {
@ -1665,29 +1664,25 @@ type : TYPE_INT {
DataType_set_qualifier($$,(char*)"const");
}
| cpptype ID {
$$ = NewDataType(0);
$$ = NewDataType(T_USER);
sprintf($$->name,"%s %s",$1, $2);
$$->type = T_USER;
}
| ID DCOLON ID {
$$ = NewDataType(0);
$$ = NewDataType(T_USER);
sprintf($$->name,"%s::%s",$1,$3);
$$->type = T_USER;
DataType_typedef_resolve($$,0);
}
/* This declaration causes a shift-reduce conflict. Unresolved for now */
| DCOLON ID {
$$ = NewDataType(0);
$$ = NewDataType(T_USER);
sprintf($$->name,"%s", $2);
$$->type = T_USER;
DataType_typedef_resolve($$,1);
}
| ENUM ID {
$$ = NewDataType(0);
$$ = NewDataType(T_INT);
sprintf($$->name,"enum %s", $2);
$$->type = T_INT;
DataType_typedef_resolve($$,1);
}
;
@ -1735,9 +1730,8 @@ strict_type : TYPE_INT {
DataType_set_qualifier($$,(char*)"const");
}
| cpptype ID {
$$ = NewDataType(0);
$$ = NewDataType(T_USER);
sprintf($$->name,"%s %s",$1, $2);
$$->type = T_USER;
}
;
@ -1748,25 +1742,25 @@ opt_signed : empty {
}
| TYPE_INT {
$$ = $1;
$$->type = T_INT;
DataType_Settypecode($$,T_INT);
sprintf(temp_name,"signed %s",$1->name);
strcpy($$->name,temp_name);
}
| TYPE_SHORT opt_int {
$$ = $1;
$$->type = T_SHORT;
DataType_Settypecode($$,T_SHORT);
sprintf(temp_name,"signed %s",$1->name);
strcpy($$->name,temp_name);
}
| TYPE_LONG opt_int {
$$ = $1;
$$->type = T_LONG;
DataType_Settypecode($$,T_LONG);
sprintf(temp_name,"signed %s",$1->name);
strcpy($$->name,temp_name);
}
| TYPE_CHAR {
$$ = $1;
$$->type = T_SCHAR;
DataType_Settypecode($$,T_SCHAR);
sprintf(temp_name,"signed %s",$1->name);
strcpy($$->name,temp_name);
}
@ -1779,25 +1773,25 @@ opt_unsigned : empty {
}
| TYPE_INT {
$$ = $1;
$$->type = T_UINT;
DataType_Settypecode($$,T_UINT);
sprintf(temp_name,"unsigned %s",$1->name);
strcpy($$->name,temp_name);
}
| TYPE_SHORT opt_int {
$$ = $1;
$$->type = T_USHORT;
DataType_Settypecode($$,T_USHORT);
sprintf(temp_name,"unsigned %s",$1->name);
strcpy($$->name,temp_name);
}
| TYPE_LONG opt_int {
$$ = $1;
$$->type = T_ULONG;
DataType_Settypecode($$,T_ULONG);
sprintf(temp_name,"unsigned %s",$1->name);
strcpy($$->name,temp_name);
}
| TYPE_CHAR {
$$ = $1;
$$->type = T_UCHAR;
DataType_Settypecode($$,T_UCHAR);
sprintf(temp_name,"unsigned %s",$1->name);
strcpy($$->name,temp_name);
}
@ -1930,7 +1924,7 @@ expr : NUM_INT {
| LPAREN strict_type RPAREN expr %prec UMINUS {
$$.id = (char *) malloc(strlen($4.id)+strlen($2->name)+3);
sprintf($$.id,"(%s)%s",$2->name,$4.id);
$$.type = $2->type;
$$.type = DataType_Gettypecode($2);
}
| ID {
$$.id = $1;
@ -2156,8 +2150,7 @@ cpp_class :
}
}
// Create a datatype for correctly processing the typedef
Active_typedef = NewDataType(0);
Active_typedef->type = T_USER;
Active_typedef = NewDataType(T_USER);
sprintf(Active_typedef->name,"%s %s", $2,$3);
Active_typedef->is_pointer = 0;
Active_typedef->implicit_ptr = 0;
@ -2237,11 +2230,8 @@ cpp_class :
}
}
// Create a datatype for correctly processing the typedef
Active_typedef = NewDataType(0);
Active_typedef->type = T_USER;
Active_typedef = NewDataType(T_USER);
sprintf(Active_typedef->name,"%s",$7.id);
Active_typedef->is_pointer = 0;
Active_typedef->implicit_ptr = 0;
// Dump nested classes
if ($7.is_pointer == 0)
@ -2576,7 +2566,7 @@ cpp_member : type declaration LPAREN parms RPAREN cpp_end {
if (cplus_mode == CPLUS_PUBLIC) {
if ($2) {
cplus_register_type($2);
temp_type->type = T_INT;
DataType_Settypecode(temp_type,T_INT);
temp_type->is_pointer = 0;
temp_type->implicit_ptr = 0;
sprintf(temp_type->name,"int");
@ -2659,8 +2649,7 @@ cpp_pragma : PRAGMA ID stylearg {
Char(CCode), " $classname_", $5.id, ";\n", 0);
n->name = Swig_copy_string($5.id);
n->line = start_line;
n->type = NewDataType(0);
n->type->type = T_USER;
n->type = NewDataType(T_USER);
n->type->is_pointer = $5.is_pointer;
n->type->is_reference = $5.is_reference;
n->next = 0;
@ -2685,8 +2674,7 @@ cpp_pragma : PRAGMA ID stylearg {
Char(CCode), " $classname_", $4.id, ";\n",0);
n->name = Swig_copy_string($4.id);
n->line = start_line;
n->type = NewDataType(0);
n->type->type = T_USER;
n->type = NewDataType(T_USER);
n->type->is_pointer = $4.is_pointer;
n->type->is_reference = $4.is_reference;
n->next = 0;
@ -3353,7 +3341,7 @@ typemap_parm : type typemap_name {
$$ = NewTMParm();
$$->p = NewParm($1,$4);
DataType *pt = Gettype($$->p);
pt->type = T_ERROR;
DataType_Settypecode(pt,T_ERROR);
Setname($$->p,$4);
strcpy(pt->name,"<function ptr>");
$$->args = tm_parm;

33
Source/SWIG1.1/scanner.cxx
View file

@ -1128,62 +1128,52 @@ extern "C" int yylex(void) {
/* Look for keywords now */
if (strcmp(yytext,"int") == 0) {
yylval.type = NewDataType(0);
yylval.type->type = T_INT;
yylval.type = NewDataType(T_INT);
strcpy(yylval.type->name,yytext);
return(TYPE_INT);
}
if (strcmp(yytext,"double") == 0) {
yylval.type = NewDataType(0);
yylval.type->type = T_DOUBLE;
yylval.type = NewDataType(T_DOUBLE);
strcpy(yylval.type->name,yytext);
return(TYPE_DOUBLE);
}
if (strcmp(yytext,"void") == 0) {
yylval.type = NewDataType(0);
yylval.type->type = T_VOID;
yylval.type = NewDataType(T_VOID);
strcpy(yylval.type->name,yytext);
return(TYPE_VOID);
}
if (strcmp(yytext,"char") == 0) {
yylval.type = NewDataType(0);
yylval.type->type = T_CHAR;
yylval.type = NewDataType(T_CHAR);
strcpy(yylval.type->name,yytext);
return(TYPE_CHAR);
}
if (strcmp(yytext,"short") == 0) {
yylval.type = NewDataType(0);
yylval.type->type = T_SHORT;
yylval.type = NewDataType(T_SHORT);
strcpy(yylval.type->name,yytext);
return(TYPE_SHORT);
}
if (strcmp(yytext,"long") == 0) {
yylval.type = NewDataType(0);
yylval.type->type = T_LONG;
yylval.type = NewDataType(T_LONG);
strcpy(yylval.type->name,yytext);
return(TYPE_LONG);
}
if (strcmp(yytext,"float") == 0) {
yylval.type = NewDataType(0);
yylval.type->type = T_FLOAT;
yylval.type = NewDataType(T_FLOAT);
strcpy(yylval.type->name,yytext);
return(TYPE_FLOAT);
}
if (strcmp(yytext,"signed") == 0) {
yylval.type = NewDataType(0);
yylval.type->type = T_INT;
yylval.type = NewDataType(T_INT);
strcpy(yylval.type->name,yytext);
return(TYPE_SIGNED);
}
if (strcmp(yytext,"unsigned") == 0) {
yylval.type = NewDataType(0);
yylval.type->type = T_UINT;
yylval.type = NewDataType(T_UINT);
strcpy(yylval.type->name,yytext);
return(TYPE_UNSIGNED);
}
if (strcmp(yytext,"bool") == 0) {
yylval.type = NewDataType(0);
yylval.type->type = T_BOOL;
yylval.type = NewDataType(T_BOOL);
strcpy(yylval.type->name,yytext);
return(TYPE_BOOL);
}
@ -1300,8 +1290,7 @@ extern "C" int yylex(void) {
if (check_typedef) {
if (DataType_is_typedef(yytext)) {
yylval.type = NewDataType(0);
yylval.type->type = T_USER;
yylval.type = NewDataType(T_USER);
strcpy(yylval.type->name,yytext);
DataType_typedef_resolve(yylval.type,0);
return(TYPE_TYPEDEF);

17
Source/SWIG1.1/typemap.cxx
View file

@ -335,7 +335,7 @@ void typemap_register(char *op, char *lang, char *type, char *pname,
temp = NewDataType(0);
strcpy(temp->name,type);
temp->is_pointer = 0;
temp->type = T_USER;
DataType_Settypecode(temp,T_USER);
typemap_register(op,lang,temp,pname,getcode,args);
DelDataType(temp);
}
@ -759,11 +759,11 @@ char *typemap_lookup(char *op, char *lang, DataType *type, char *pname, char *so
DelDataType(t);
return result;
}
if ((t->type == T_USER) || (t->is_pointer)) {
if ((t->type == T_CHAR) && (t->is_pointer == 1)) return 0;
int tc = DataType_type(t);
if (tc == T_STRING) return 0;
if ((tc == T_USER) || (tc == T_POINTER)) {
/* Still no result, go even more primitive */
t->type = T_USER;
DataType_Settypecode(t, T_USER);
t->is_pointer = 1;
DataType_set_arraystr(t,0);
DataType_primitive(t);
@ -916,10 +916,11 @@ char *typemap_check(char *op, char *lang, DataType *type, char *pname) {
DelDataType(t);
return result;
}
if ((t->type == T_USER) || (t->is_pointer)) {
if ((t->type == T_CHAR) && (t->is_pointer == 1)) return 0;
int tc = DataType_type(t);
if (tc == T_STRING) return 0;
if ((tc == T_USER) || (tc == T_POINTER)) {
/* Still no result, go even more primitive */
t->type = T_USER;
DataType_Settypecode(t,T_USER);
t->is_pointer = 1;
DataType_set_arraystr(t,0);
DataType_primitive(t);

189
Source/Swig/cwrap.c
View file

@ -48,25 +48,28 @@ Swig_clocal(DataType *t, DOHString_or_char *name, DOHString_or_char *value) {
if (!decl) decl = NewString("");
Clear(decl);
if ((t->type != T_VOID) || (t->is_pointer)) {
if ((t->type == T_USER) && (!t->is_pointer)) {
t->is_pointer++;
if (value)
Printf(decl,"%s = &%s", DataType_lstr(t,name), value);
else
Printf(decl,"%s", DataType_lstr(t,name));
t->is_pointer--;
} else if (t->is_reference) {
if (value)
Printf(decl,"%s = &%s", DataType_lstr(t,name), value);
else
Printf(decl,"%s", DataType_lstr(t,name));
} else {
if (value)
Printf(decl,"%s = %s", DataType_lstr(t,name), value);
else
Printf(decl,"%s", DataType_lstr(t,name));
}
switch(DataType_type(t)) {
case T_USER:
t->is_pointer++;
if (value)
Printf(decl,"%s = &%s", DataType_lstr(t,name), value);
else
Printf(decl,"%s", DataType_lstr(t,name));
t->is_pointer--;
break;
case T_REFERENCE:
if (value)
Printf(decl,"%s = &%s", DataType_lstr(t,name), value);
else
Printf(decl,"%s", DataType_lstr(t,name));
break;
case T_VOID:
break;
default:
if (value)
Printf(decl,"%s = %s", DataType_lstr(t,name), value);
else
Printf(decl,"%s", DataType_lstr(t,name));
}
return Char(decl);
}
@ -81,16 +84,15 @@ Swig_clocal(DataType *t, DOHString_or_char *name, DOHString_or_char *value) {
DataType *
Swig_clocal_type(DataType *t) {
DataType *ty;
if ((t->type != T_VOID) || (t->is_pointer)) {
if ((t->type == T_USER) && (!t->is_pointer)) {
t->is_pointer++;
ty = DataType_ltype(t);
t->is_pointer--;
} else {
ty = DataType_ltype(t);
}
} else {
switch(DataType_type(t)) {
case T_USER:
t->is_pointer++;
ty = DataType_ltype(t);
t->is_pointer--;
break;
default:
ty = DataType_ltype(t);
break;
}
return ty;
}
@ -106,14 +108,17 @@ Swig_clocal_type(DataType *t) {
char *
Swig_clocal_deref(DataType *t, DOHString_or_char *name) {
static char temp[256];
if ((t->type != T_VOID) || (t->is_pointer)) {
if ((t->type == T_USER) && (!t->is_pointer)) {
sprintf(temp,"*%s",Char(name));
} else {
sprintf(temp,DataType_rcaststr(t,name));
}
} else {
switch(DataType_type(t)) {
case T_USER:
sprintf(temp,"*%s",Char(name));
break;
case T_VOID:
strcpy(temp,"");
break;
default:
sprintf(temp,DataType_rcaststr(t,name));
break;
}
return temp;
}
@ -127,14 +132,16 @@ Swig_clocal_deref(DataType *t, DOHString_or_char *name) {
char *
Swig_clocal_assign(DataType *t, DOHString_or_char *name) {
static char temp[256];
if ((t->type != T_VOID) || (t->is_pointer)) {
if ((t->type == T_USER) && (!t->is_pointer)) {
sprintf(temp,"&%s",Char(name));
} else {
sprintf(temp,DataType_lcaststr(t,name));
}
} else {
switch(DataType_type(t)) {
case T_VOID:
strcpy(temp,"");
break;
case T_USER:
sprintf(temp,"&%s",Char(name));
break;
default:
sprintf(temp,DataType_lcaststr(t,name));
break;
}
return temp;
}
@ -179,35 +186,39 @@ int Swig_cargs(Wrapper *w, ParmList *l) {
void Swig_cresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or_char *decl) {
DOHString *fcall;
fcall = NewString("");
if ((t->type != T_VOID) || (t->is_pointer)) {
Wrapper_add_localv(w,name, Swig_clocal(t,name,0), 0);
if ((t->type == T_USER) && (!t->is_pointer)) {
t->is_pointer++;
Printv(fcall, name, " = (", DataType_lstr(t,0), ") malloc(sizeof(", 0);
t->is_pointer--;
Printv(fcall, DataType_str(t,0), "));\n", 0);
Printv(fcall, "*(", name, ") = ", 0);
if (DataType_type(t) != T_VOID)
Wrapper_add_localv(w,name, Swig_clocal(t,name,0), 0);
switch(DataType_type(t)) {
case T_VOID:
break;
case T_USER:
t->is_pointer++;
Printv(fcall, name, " = (", DataType_lstr(t,0), ") malloc(sizeof(", 0);
t->is_pointer--;
Printv(fcall, DataType_str(t,0), "));\n", 0);
Printv(fcall, "*(", name, ") = ", 0);
break;
case T_REFERENCE:
Printv(fcall, DataType_str(t,"_result_ref")," = ", 0);
break;
default:
/* Normal return value */
if (DataType_qualifier(t)) {
Printv(fcall, name, " = (", DataType_lstr(t,0), ")", 0);
} else {
/* Is this a reference? */
if (t->is_reference) {
Printv(fcall, DataType_str(t,"_result_ref")," = ", 0);
} else {
/* Normal return value */
if (DataType_qualifier(t)) {
Printv(fcall, name, " = (", DataType_lstr(t,0), ")", 0);
} else {
Printv(fcall, name, " = ", 0);
}
}
Printv(fcall, name, " = ", 0);
}
break;
}
/* Now print out function call */
Printv(fcall, decl, ";\n", 0);
if (t->is_reference) {
if (DataType_type(t) == T_REFERENCE) {
Printv(fcall, name, " = (", DataType_lstr(t,0), ") &_result_ref;\n", 0);
}
@ -228,31 +239,37 @@ void Swig_cppresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_
DOHString *fcall;
fcall = NewString("");
if ((t->type != T_VOID) || (t->is_pointer)) {
Wrapper_add_localv(w,name, Swig_clocal(t,name,0), 0);
if ((t->type == T_USER) && (!t->is_pointer)) {
Printv(fcall, name, " = new ", DataType_str(t,0), "(", 0);
} else {
/* Is this a reference? */
if (t->is_reference) {
Printv(fcall, DataType_str(t,"_result_ref")," = ", 0);
} else {
/* Normal return value */
Printv(fcall, name, " = ", DataType_lcaststr(t,""), 0);
}
}
if (DataType_type(t) != T_VOID)
Wrapper_add_localv(w,name, Swig_clocal(t,name,0), 0);
switch(DataType_type(t)) {
case T_VOID:
break;
case T_USER:
Printv(fcall, name, " = new ", DataType_str(t,0), "(", 0);
break;
case T_REFERENCE:
Printv(fcall, DataType_str(t,"_result_ref")," = ", 0);
break;
default:
Printv(fcall, name, " = ", DataType_lcaststr(t,""), 0);
break;
}
/* Now print out function call */
Printv(fcall, decl, 0);
if ((t->type == T_USER) && (!t->is_pointer)) {
Printf(fcall,")");
}
Printf(fcall,";\n");
if (t->is_reference) {
Printv(fcall, name, " = (", DataType_lstr(t,0), ") &_result_ref;\n", 0);
switch(DataType_type(t)) {
case T_USER:
Printf(fcall,");");
break;
case T_REFERENCE:
Printf(fcall,";\n");
Printv(fcall, name, " = (", DataType_lstr(t,0), ") &_result_ref;\n", 0);
break;
default:
Printf(fcall,";\n");
break;
}
if (Replace(w->code,"$function",fcall, DOH_REPLACE_ANY) == 0) {
@ -442,7 +459,7 @@ Swig_cmemberset_call(DOHString_or_char *name, DataType *type) {
if (!func) func = NewString("");
Clear(func);
if ((type->type == T_USER) && (type->is_pointer == 0)) {
if (DataType_type(type) == T_USER) {
Printf(func,"%s %s->%s; ", Swig_clocal_assign(type,""), Swig_cparm_name(0,0), name);
} else {
Printf(func,"%s ", Swig_clocal_assign(type,""));
@ -566,7 +583,7 @@ Swig_cmethod_wrapper(DOHString_or_char *classname,
if (!code) {
/* No code supplied. Write a function manually */
if ((rtype->type != T_VOID) || (rtype->is_pointer)) {
if (DataType_type(rtype) != T_VOID) {
Printf(w->code,"return ");
}

32
Source/Swig/oldtypes.c
View file

@ -68,7 +68,7 @@ DataType *NewDataType(int t) {
strcpy(ty->name,"");
break;
}
ty->type = t;
ty->_type = t;
ty->is_pointer = 0;
ty->implicit_ptr = 0;
ty->_qualifier = 0;
@ -81,7 +81,7 @@ DataType *NewDataType(int t) {
DataType *CopyDataType(DataType *t) {
DataType *ty = (DataType *) malloc(sizeof(DataType));
ty->type = t->type;
ty->_type = t->_type;
strcpy(ty->name,t->name);
ty->is_pointer = t->is_pointer;
ty->implicit_ptr = t->implicit_ptr;
@ -99,6 +99,22 @@ void DelDataType(DataType *t) {
free(t);
}
int DataType_type(DataType *t) {
if ((t->_type == T_CHAR) && (t->is_pointer == 1)) return T_STRING;
if (t->_arraystr) return T_ARRAY;
if (t->is_reference) return T_REFERENCE;
if (t->is_pointer) return T_POINTER;
return t->_type;
}
int DataType_Gettypecode(DataType *t) {
return t->_type;
}
void DataType_Settypecode(DataType *t, int ty) {
t->_type = ty;
}
char *DataType_qualifier(DataType *t) {
return t->_qualifier;
}
@ -126,7 +142,7 @@ void DataType_set_arraystr(DataType *t, char *a) {
* -------------------------------------------------------------------- */
void DataType_primitive(DataType *t) {
switch(t->type) {
switch(t->_type) {
case T_BOOL:
strcpy(t->name,"bool");
break;
@ -554,7 +570,7 @@ int DataType_typedef_add(DataType *t,char *tname, int mode) {
/* Now add this type mapping to our type-equivalence table */
if (mode == 0) {
if ((t->type != T_VOID) && (strcmp(t->name,tname) != 0)) {
if ((t->_type != T_VOID) && (strcmp(t->name,tname) != 0)) {
t1 = NewDataType(0);
strcpy(t1->name,tname);
name2 = DataType_manglestr(t1);
@ -601,7 +617,7 @@ void DataType_typedef_resolve(DataType *t, int level) {
while (s >= 0) {
if ((td = (DataType *) GetVoid(typedef_hash[s],t->name))) {
t->type = td->type;
t->_type = td->_type;
t->is_pointer += td->is_pointer;
t->implicit_ptr += td->implicit_ptr;
t->status = t->status | td->status;
@ -637,7 +653,7 @@ void DataType_typedef_replace (DataType *t) {
temp[0] = 0;
if ((td = (DataType *) GetVoid(typedef_hash[scope],t->name))) {
t->type = td->type;
t->_type = td->_type;
t->is_pointer = td->is_pointer;
t->implicit_ptr -= td->implicit_ptr;
strcpy(t->name, td->name);
@ -979,8 +995,8 @@ void typeeq_derived(char *n1, char *n2, char *cast) {
t1 = NewDataType(0);
if (!te_init) typeeq_init();
t->type = T_USER;
t1->type = T_USER;
t->_type = T_USER;
t1->_type = T_USER;
strcpy(t->name,n1);
strcpy(t1->name,n2);
name = DataType_manglestr(t);

2
Source/Swig/parms.c
View file

@ -102,7 +102,7 @@ int ParmList_numarg(ParmList *l) {
p = Firstitem(l);
while (p) {
if (Getignore(p)) n++;
if (!Getignore(p)) n++;
p = Nextitem(l);
}
return n;

42
Source/Swig/swig.h
View file

@ -24,27 +24,32 @@
/* --- Legacy DataType interface. This is being replaced --- */
#define T_INT 1
#define T_SHORT 2
#define T_LONG 3
#define T_UINT 4
#define T_USHORT 5
#define T_ULONG 6
#define T_UCHAR 7
#define T_SCHAR 8
#define T_BOOL 9
#define T_DOUBLE 10
#define T_FLOAT 11
#define T_CHAR 12
#define T_USER 13
#define T_VOID 14
#define T_INT 1
#define T_SHORT 2
#define T_LONG 3
#define T_UINT 4
#define T_USHORT 5
#define T_ULONG 6
#define T_UCHAR 7
#define T_SCHAR 8
#define T_BOOL 9
#define T_DOUBLE 10
#define T_FLOAT 11
#define T_CHAR 12
#define T_USER 13
#define T_VOID 14
#define T_STRING 20
#define T_POINTER 21
#define T_REFERENCE 22
#define T_ARRAY 23
#define T_SYMBOL 98
#define T_ERROR 99
#define MAX_NAME 96
typedef struct DataType {
int type; /* SWIG Type code */
int _type; /* SWIG Type code */
char name[MAX_NAME]; /* Name of type */
int is_pointer; /* Is this a pointer */
int implicit_ptr; /* Implicit ptr */
@ -59,6 +64,10 @@ extern DataType *NewDataType(int type);
extern DataType *CopyDataType(DataType *type);
extern void DelDataType(DataType *type);
int DataType_type(DataType *t);
int DataType_Gettypecode(DataType *t);
void DataType_Settypecode(DataType *t, int type);
/* -- New type interface -- */
extern char *DataType_str(DataType *, DOHString_or_char *name); /* Exact datatype */
@ -68,12 +77,13 @@ extern char *DataType_lcaststr(DataType *, DOHString_or_char *name); /* C
extern char *DataType_manglestr(DataType *t); /* Mangled type name */
extern DataType *DataType_ltype(DataType *); /* Create local type object */
/* -- Old type interface -- */
/* -- Old type interface. This is going away -- */
extern char *DataType_qualifier(DataType *);
extern void DataType_set_qualifier(DataType *, char *q);
extern char *DataType_arraystr(DataType *);
extern void DataType_set_arraystr(DataType *, char *a);
extern char *DataType_mangle_default(DataType *t); /* Default name mangler */
extern void DataType_primitive(DataType *);
extern void DataType_set_mangle(char *(*m)(DataType *));