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@609 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Dave Beazley 2000-07-25 04:02:31 +00:00
commit 4230cc4162
15 changed files with 1152 additions and 1233 deletions
Download patch file Download diff file Expand all files Collapse all files

39
SWIG/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
SWIG/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
SWIG/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
SWIG/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
SWIG/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
SWIG/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
SWIG/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) {