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

Removed String class from Tcl module

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@538 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Dave Beazley 2000-07-09 03:03:01 +00:00
commit dc68a4427a
2 changed files with 289 additions and 283 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -38,10 +38,34 @@ Tcl 8.0 Options (available with -tcl)\n\
static char *ns_name = 0; static char *ns_name = 0;
static String mod_init; static DOHString *mod_init = 0;
static String mod_extern; static DOHString *mod_extern = 0;
static String cmd_info; static DOHString *cmd_info = 0;
static String var_info; static DOHString *var_info = 0;
static DOHString *methods = 0;
static DOHString *attributes = 0;
/* Various parameters */
static char *prefix = 0;
static char *module = 0;
static int nspace = 0;
static int shadow = 1;
static char *tcl_path = (char*)"tcl";
static char interp_name[256] = "interp";
static char *init_name = 0;
static char *char_result = (char *)"TCL_VOLATILE";
static int have_constructor;
static int have_destructor;
static char *class_name = 0;
static char *class_type = 0;
static char *real_classname = 0;
static char *base_class = 0;
static DOHHash *hash = 0;
static DOHHash *repeatcmd = 0;
static DOHHash *setget = 0;
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
// TCL8::parse_args(int argc, char *argv[]) // TCL8::parse_args(int argc, char *argv[])
@ -124,6 +148,17 @@ void TCL8::parse() {
fprintf(stderr,"Making wrappers for Tcl 8.x\n"); fprintf(stderr,"Making wrappers for Tcl 8.x\n");
mod_init = NewString("");
mod_extern = NewString("");
cmd_info = NewString("");
var_info = NewString("");
methods = NewString("");
attributes = NewString("");
hash = NewHash();
repeatcmd = NewHash();
setget = NewHash();
// Print out TCL specific headers // Print out TCL specific headers
headers(); headers();
@ -198,10 +233,12 @@ void TCL8::set_module(char *mod_name, char **mod_list) {
// Dump out some initialization code // Dump out some initialization code
mod_init << tab4 << "if (" << temp << "(" << interp_name << ") == TCL_ERROR) {\n" Printv(mod_init,
<< tab8 << "return TCL_ERROR;\n" tab4, "if (", temp, "(", interp_name, ") == TCL_ERROR) {\n",
<< tab4 << "}\n\n"; tab8, "return TCL_ERROR;\n",
mod_extern << "extern int " << temp << "(Tcl_Interp *);\n"; tab4, "}\n\n",
0);
Printv(mod_extern, "extern int ", temp, "(Tcl_Interp *);\n", 0);
i++; i++;
} }
} }
@ -305,18 +342,17 @@ void TCL8::initialize()
/* Check to see if other initializations need to be performed */ /* Check to see if other initializations need to be performed */
if (strlen(mod_extern.get())) { if (Len(mod_extern)) {
fprintf(f_init,"%s\n",mod_init.get()); Printf(f_init,"%s\n",mod_init);
fprintf(f_header,"#ifdef __cplusplus\n"); Printf(f_header,"#ifdef __cplusplus\n");
fprintf(f_header,"extern \"C\" {\n"); Printf(f_header,"extern \"C\" {\n");
fprintf(f_header,"#endif\n"); Printf(f_header,"#endif\n");
fprintf(f_header,"%s\n",mod_extern.get()); Printf(f_header,"%s\n",mod_extern);
fprintf(f_header,"#ifdef __cplusplus\n"); Printf(f_header,"#ifdef __cplusplus\n");
fprintf(f_header,"}\n"); Printf(f_header,"}\n");
fprintf(f_header,"#endif\n"); Printf(f_header,"#endif\n");
} }
/* Check to see if we're adding support for Tcl8 nspaces */ /* Check to see if we're adding support for Tcl8 nspaces */
if (nspace) { if (nspace) {
fprintf(f_init,"#if (TCL_MAJOR_VERSION >= 8)\n"); fprintf(f_init,"#if (TCL_MAJOR_VERSION >= 8)\n");
@ -324,17 +360,16 @@ void TCL8::initialize()
fprintf(f_init,"#endif\n"); fprintf(f_init,"#endif\n");
} }
cmd_info << "\nstatic _swig_command_info _swig_commands[] = {\n"; Printf(cmd_info, "\nstatic _swig_command_info _swig_commands[] = {\n");
var_info << "\nstatic _swig_var_info _swig_variables[] = {\n"; Printf(var_info, "\nstatic _swig_var_info _swig_variables[] = {\n");
Printv(f_init,
String init; tab4, "{\n",
init << tab4 << "{\n" tab8, "int i;\n",
<< tab8 << "int i;\n" tab8, "for (i = 0; _swig_types_initial[i]; i++) {\n",
<< tab8 << "for (i = 0; _swig_types_initial[i]; i++) {\n" tab8, tab4, "_swig_types[i] = SWIG_TypeRegister(_swig_types_initial[i]);\n",
<< tab8 << tab4 << "_swig_types[i] = SWIG_TypeRegister(_swig_types_initial[i]);\n" tab8, "}\n",
<< tab8 << "}\n" tab4, "}\n",
<< tab4 << "}\n"; 0);
fprintf(f_init,"%s", init.get());
} }
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
@ -346,14 +381,12 @@ void TCL8::initialize()
void TCL8::close(void) void TCL8::close(void)
{ {
extern void emit_type_table(); extern void emit_type_table();
cmd_info << tab4 << "{0, 0, 0}\n" Printv(cmd_info, tab4, "{0, 0, 0}\n", "};\n",0);
<< "};\n";
var_info << tab4 << "{0,0,0,0}\n" Printv(var_info, tab4, "{0,0,0,0}\n", "};\n",0);
<< "};\n";
fprintf(f_wrappers,"%s", cmd_info.get()); Printf(f_wrappers,"%s", cmd_info);
fprintf(f_wrappers,"%s", var_info.get()); Printf(f_wrappers,"%s", var_info);
fprintf(f_init,"\tfor (i = 0; _swig_commands[i].name; i++) {\n"); fprintf(f_init,"\tfor (i = 0; _swig_commands[i].name; i++) {\n");
fprintf(f_init,"\t Tcl_CreateObjCommand(interp, (char *) _swig_commands[i].name, _swig_commands[i].wrapper, _swig_commands[i].clientdata, NULL);\n"); fprintf(f_init,"\t Tcl_CreateObjCommand(interp, (char *) _swig_commands[i].name, _swig_commands[i].wrapper, _swig_commands[i].clientdata, NULL);\n");
@ -373,7 +406,6 @@ void TCL8::close(void)
// Close the init file and quit // Close the init file and quit
fprintf(f_init,"%s",postinit.get());
fprintf(f_init,"\t return TCL_OK;\n"); fprintf(f_init,"\t return TCL_OK;\n");
fprintf(f_init,"}\n"); fprintf(f_init,"}\n");
@ -393,20 +425,18 @@ void TCL8::close(void)
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
void TCL8::get_pointer(char *iname, char *srcname, char *src, char *dest, void TCL8::get_pointer(char *iname, char *srcname, char *src, char *dest,
DataType *t, String &f, char *ret) { DataType *t, DOHString *f, char *ret) {
// Pointers are read as hex-strings with encoded type information // Pointers are read as hex-strings with encoded type information
t->remember(); t->remember();
f << tab4 << "if ((SWIG_ConvertPtr(interp," << src << ",(void **) &" << dest << ","; Printv(f, tab4, "if ((SWIG_ConvertPtr(interp,", src, ",(void **) &", dest, ",",0);
if (t->type == T_VOID) f << "0)) == TCL_ERROR) { return TCL_ERROR; }\n"; if (t->type == T_VOID) Printf(f, "0)) == TCL_ERROR) { return TCL_ERROR; }\n");
else else
f << "SWIGTYPE" << t->print_mangle() << ")) == TCL_ERROR) { return TCL_ERROR; }\n"; Printv(f, "SWIGTYPE", t->print_mangle(), ")) == TCL_ERROR) { return TCL_ERROR; }\n", 0);
} }
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
// TCL8::create_command(char *cname, char *iname) // TCL8::create_command(char *cname, char *iname)
// //
@ -417,7 +447,7 @@ void TCL8::create_command(char *cname, char *iname) {
char *wname = Swig_name_wrapper(cname); char *wname = Swig_name_wrapper(cname);
cmd_info << tab4 << "{ SWIG_prefix \"" << iname << "\", " << wname << ", NULL},\n"; Printv(cmd_info, tab4, "{ SWIG_prefix \"", iname, "\", ", wname, ", NULL},\n", 0);
// Add interpreter name to repeatcmd hash table. This hash is used in C++ code // Add interpreter name to repeatcmd hash table. This hash is used in C++ code
// generation to try and find repeated wrapper functions. // generation to try and find repeated wrapper functions.
@ -441,10 +471,15 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l)
char target[64]; char target[64];
char argnum[32]; char argnum[32];
WrapperFunction f; WrapperFunction f;
String incode, cleanup, outarg; DOHString *incode, *cleanup, *outarg, *argstr, *args;
int numopt= 0; int numopt= 0;
String argstr;
String args;
incode = NewString("");
cleanup = NewString("");
outarg = NewString("");
argstr = NewString("\"");
args = NewString("");
// Make a wrapper name for this function // Make a wrapper name for this function
@ -452,7 +487,9 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l)
// Now write the wrapper function itself....this is pretty ugly // Now write the wrapper function itself....this is pretty ugly
f.def << "static int " << wname << "(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {"; Printv(f._def,
"static int ", wname, "(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {",
0);
// Print out variables for storing arguments. // Print out variables for storing arguments.
@ -461,21 +498,10 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l)
// Create a local variable for holding the interpreter result value // Create a local variable for holding the interpreter result value
// f.add_local("Tcl_Obj *", "tcl_result");
// Check the number of arguments // Check the number of arguments
usage = usage_func(iname,d,l); // Create a usage string usage = usage_func(iname,d,l); // Create a usage string
//
// f.code << tab4 << "if ((objc < " << (pcount-numopt) +1 << ") || (objc > " << l->numarg()+1 << ")) {\n"
// << tab8 << "Tcl_SetResult(interp, \"Wrong # args. " << usage << "\", TCL_STATIC);\n"
// << tab8 << "return TCL_ERROR;\n"
// << tab4 << "}\n";
argstr = "\"";
args = "";
// Extract parameters. This case statement should be used to extract // Extract parameters. This case statement should be used to extract
// Function parameters. Add more cases if you want to do more. // Function parameters. Add more cases if you want to do more.
@ -492,17 +518,16 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l)
if (!p->ignore) { if (!p->ignore) {
if (j == (pcount-numopt)) if (j == (pcount-numopt))
argstr << "|"; Putc('|',argstr);
// f.code << tab4 << "if (objc >" << j+1 << ") { \n";
if ((tm = typemap_lookup((char*)"in",(char*)"tcl8",p->t,p->name,source,target,&f))) { if ((tm = typemap_lookup((char*)"in",(char*)"tcl8",p->t,p->name,source,target,&f))) {
argstr << "o"; Putc('o',argstr);
args << ",0"; Printf(args,",0");
// Yep. Use it instead of the default // Yep. Use it instead of the default
incode << tm << "\n"; Printf(incode,"%s\n", tm);
incode.replace("$argnum",argnum); Replace(incode,"$argnum",argnum, DOH_REPLACE_ANY);
incode.replace("$arg",source); Replace(incode,"$arg",source, DOH_REPLACE_ANY);
} else { } else {
if (!p->t->is_pointer) { if (!p->t->is_pointer) {
@ -515,53 +540,53 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l)
case T_INT: case T_INT:
case T_SINT: case T_SINT:
case T_UINT: case T_UINT:
argstr << "i"; Putc('i', argstr);
args << ",&" << target; Printf(args,",&%s",target);
break; break;
case T_BOOL: case T_BOOL:
argstr << "i"; Putc('i',argstr);
{ {
char tb[32]; char tb[32];
sprintf(tb,"tempb%d",i); sprintf(tb,"tempb%d",i);
f.add_local((char*)"int",tb); f.add_local((char*)"int",tb);
args << ",&" << tb; Printf(args,",&%s",tb);
incode << tab4 << target << " = (bool) " << tb << ";\n"; Printv(incode, tab4, target, " = (bool) ", tb, ";\n", 0);
} }
break; break;
case T_SHORT: case T_SHORT:
case T_SSHORT: case T_SSHORT:
case T_USHORT: case T_USHORT:
argstr << "h"; Putc('h',argstr);
args << ",&" << target; Printf(args,",&%s",target);
break; break;
case T_LONG: case T_LONG:
case T_SLONG: case T_SLONG:
case T_ULONG: case T_ULONG:
argstr << "l"; Putc('l',argstr);
args << ",&" << target; Printf(args,",&%s",target);
break; break;
case T_SCHAR: case T_SCHAR:
case T_UCHAR: case T_UCHAR:
argstr << "b"; Putc('b',argstr);
args << ",&" << target; Printf(args,",&%s", target);
break; break;
// Floating point // Floating point
case T_FLOAT: case T_FLOAT:
argstr << "f"; Putc('f',argstr);
args << ",&" << target; Printf(args,",&%s", target);
break; break;
case T_DOUBLE: case T_DOUBLE:
argstr << "d"; Putc('d',argstr);
args << ",&" << target; Printf(args,",&%s", target);
break; break;
// A single character // A single character
case T_CHAR : case T_CHAR :
argstr << "c"; Putc('c',argstr);
args << ",&" << target; Printf(args,",&%s",target);
break; break;
// Void.. Do nothing. // Void.. Do nothing.
@ -584,12 +609,12 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l)
// Look for a string. Otherwise, just pull off a pointer. // Look for a string. Otherwise, just pull off a pointer.
if ((p->t->type == T_CHAR) && (p->t->is_pointer == 1)) { if ((p->t->type == T_CHAR) && (p->t->is_pointer == 1)) {
argstr << "s"; Putc('s',argstr);
args << ",&" << target; Printf(args,",&%s",target);
} else { } else {
p->t->remember(); p->t->remember();
argstr << "p"; Putc('p',argstr);
args << ",&" << target << ", SWIGTYPE" << p->t->print_mangle(); Printv(args, ",&", target, ", SWIGTYPE", p->t->print_mangle(), 0);
} }
} }
} }
@ -599,32 +624,33 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l)
// Check to see if there was any sort of a constaint typemap // Check to see if there was any sort of a constaint typemap
if ((tm = typemap_lookup((char*)"check",(char*)"tcl8",p->t,p->name,source,target))) { if ((tm = typemap_lookup((char*)"check",(char*)"tcl8",p->t,p->name,source,target))) {
// Yep. Use it instead of the default // Yep. Use it instead of the default
incode << tm << "\n"; Printf(incode,"%s\n", tm);
incode.replace("$argnum",argnum); Replace(incode,"$argnum",argnum, DOH_REPLACE_ANY);
incode.replace("$arg",source); Replace(incode,"$arg",source, DOH_REPLACE_ANY);
} }
// Check if there was any cleanup code (save it for later) // Check if there was any cleanup code (save it for later)
if ((tm = typemap_lookup((char*)"freearg",(char*)"tcl8",p->t,p->name,target,(char*)"tcl_result"))) { if ((tm = typemap_lookup((char*)"freearg",(char*)"tcl8",p->t,p->name,target,(char*)"tcl_result"))) {
// Yep. Use it instead of the default // Yep. Use it instead of the default
cleanup << tm << "\n"; Printf(cleanup,"%s\n", tm);
cleanup.replace("$argnum",argnum); Replace(cleanup,"$argnum",argnum, DOH_REPLACE_ANY);
cleanup.replace("$arg",source); Replace(cleanup,"$arg",source,DOH_REPLACE_ANY);
} }
// Look for output arguments // Look for output arguments
if ((tm = typemap_lookup((char*)"argout",(char*)"tcl8",p->t,p->name,target,(char*)"tcl_result"))) { if ((tm = typemap_lookup((char*)"argout",(char*)"tcl8",p->t,p->name,target,(char*)"tcl_result"))) {
outarg << tm << "\n"; Printf(outarg,"%s\n", tm);
outarg.replace("$argnum",argnum); Replace(outarg,"$argnum",argnum, DOH_REPLACE_ANY);
outarg.replace("$arg",source); Replace(outarg,"$arg",source, DOH_REPLACE_ANY);
} }
i++; i++;
p = l->get_next(); // Get next parameter and continue p = l->get_next(); // Get next parameter and continue
} }
Printf(argstr,":%s\"",usage);
Printv(f._code,
tab4, "if (SWIG_GetArgs(interp, objc, objv,", argstr, args, ") == TCL_ERROR) return TCL_ERROR;\n",
0);
argstr << ":" << usage << "\""; Printv(f._code,incode,0);
f.code << tab4 << "if (SWIG_GetArgs(interp, objc, objv," << argstr << args << ") == TCL_ERROR) return TCL_ERROR;\n";
f.code << incode;
// Now write code to make the function call // Now write code to make the function call
@ -634,7 +660,7 @@ 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"))) { if ((tm = typemap_lookup((char*)"out",(char*)"tcl8",d,name,(char*)"_result",(char*)"tcl_result"))) {
// Yep. Use it instead of the default // Yep. Use it instead of the default
f.code << tm << "\n"; Printf(f._code,"%s\n", tm);
} else if ((d->type != T_VOID) || (d->is_pointer)) { } else if ((d->type != T_VOID) || (d->is_pointer)) {
if (!d->is_pointer) { if (!d->is_pointer) {
@ -654,18 +680,18 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l)
case T_USHORT: case T_USHORT:
case T_ULONG: case T_ULONG:
case T_UCHAR: case T_UCHAR:
f.code << tab4 << "Tcl_SetObjResult(interp,Tcl_NewIntObj((long) _result));\n"; Printv(f._code, tab4, "Tcl_SetObjResult(interp,Tcl_NewIntObj((long) _result));\n",0);
break; break;
// Is a single character. Assume we return it as a string // Is a single character. Assume we return it as a string
case T_CHAR : case T_CHAR :
f.code << tab4 << "Tcl_SetObjResult(interp,Tcl_NewStringObj(&_result,1));\n"; Printv(f._code, tab4, "Tcl_SetObjResult(interp,Tcl_NewStringObj(&_result,1));\n",0);
break; break;
// Floating point number // Floating point number
case T_DOUBLE : case T_DOUBLE :
case T_FLOAT : case T_FLOAT :
f.code << tab4 << "Tcl_SetObjResult(interp,Tcl_NewDoubleObj((double) _result));\n"; Printv(f._code, tab4, "Tcl_SetObjResult(interp,Tcl_NewDoubleObj((double) _result));\n",0);
break; break;
// User defined type // User defined type
@ -674,10 +700,10 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l)
// Okay. We're returning malloced memory at this point. // Okay. We're returning malloced memory at this point.
// Probably dangerous, but who said safety was a good thing? // Probably dangerous, but who said safety was a good thing?
// f.add_local("char","resultchar[256]");
d->is_pointer++; d->is_pointer++;
d->remember(); d->remember();
f.code << tab4 << "Tcl_SetObjResult(interp,SWIG_NewPointerObj((void *) _result,SWIGTYPE" << d->print_mangle() << "));\n"; Printv(f._code, tab4, "Tcl_SetObjResult(interp,SWIG_NewPointerObj((void *) _result,SWIGTYPE",
d->print_mangle(), "));\n", 0);
d->is_pointer--; d->is_pointer--;
break; break;
@ -694,40 +720,39 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l)
if ((d->type == T_CHAR) && (d->is_pointer == 1)) { if ((d->type == T_CHAR) && (d->is_pointer == 1)) {
// Return a character string // Return a character string
f.code << tab4 << "Tcl_SetObjResult(interp,Tcl_NewStringObj(_result,-1));\n"; Printv(f._code, tab4, "Tcl_SetObjResult(interp,Tcl_NewStringObj(_result,-1));\n",0);
} else { } else {
d->remember(); d->remember();
f.code << tab4 << "Tcl_SetObjResult(interp,SWIG_NewPointerObj((void *) _result,SWIGTYPE" << d->print_mangle() << "));\n"; Printv(f._code, tab4, "Tcl_SetObjResult(interp,SWIG_NewPointerObj((void *) _result,SWIGTYPE",
d->print_mangle(), "));\n",
0);
} }
} }
} else {
// f.code << tab4 << "Tcl_SetResult(interp,"",TCL_STATIC);\n";
} }
// Dump output argument code // Dump output argument code
f.code << outarg; Printv(f._code,outarg,0);
// Dump the argument cleanup code // Dump the argument cleanup code
f.code << cleanup; Printv(f._code,cleanup,0);
// Look for any remaining cleanup // Look for any remaining cleanup
if (NewObject) { if (NewObject) {
if ((tm = typemap_lookup((char*)"newfree",(char*)"tcl8",d,iname,(char*)"_result",(char*)""))) { if ((tm = typemap_lookup((char*)"newfree",(char*)"tcl8",d,iname,(char*)"_result",(char*)""))) {
f.code << tm << "\n"; Printf(f._code,"%s\n", tm);
} }
} }
if ((tm = typemap_lookup((char*)"ret",(char*)"tcl8",d,name,(char*)"_result",(char*)""))) { if ((tm = typemap_lookup((char*)"ret",(char*)"tcl8",d,name,(char*)"_result",(char*)""))) {
// Yep. Use it instead of the default // Yep. Use it instead of the default
f.code << tm << "\n"; Printf(f._code,"%s\n", tm);
} }
Printv(f._code,tab4, "return TCL_OK;\n}", 0);
f.code << tab4 << "return TCL_OK;\n}";
// Substitute the cleanup code // Substitute the cleanup code
f.code.replace("$cleanup",cleanup.get()); Replace(f._code,"$cleanup",cleanup,DOH_REPLACE_ANY);
f.code.replace("$name",iname); Replace(f._code,"$name", iname, DOH_REPLACE_ANY);
// Dump out the function // Dump out the function
@ -735,7 +760,14 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l)
// Now register the function with Tcl // Now register the function with Tcl
cmd_info << tab4 << "{ SWIG_prefix \"" << iname << "\", " << wname << ", NULL},\n"; Printv(cmd_info, tab4, "{ SWIG_prefix \"", iname, "\", ", wname, ", NULL},\n", 0);
Delete(incode);
Delete(cleanup);
Delete(outarg);
Delete(argstr);
Delete(args);
} }
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -746,7 +778,6 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l)
void TCL8::link_variable(char *name, char *iname, DataType *t) void TCL8::link_variable(char *name, char *iname, DataType *t)
{ {
String s;
char *tm, *tm1; char *tm, *tm1;
// See if there were any typemaps // See if there were any typemaps
@ -763,19 +794,20 @@ void TCL8::link_variable(char *name, char *iname, DataType *t)
Setattr(setget,t->print_type(),"1"); Setattr(setget,t->print_type(),"1");
WrapperFunction get; WrapperFunction get;
WrapperFunction set; WrapperFunction set;
set.def << "static char *_swig_" << t->print_mangle() << "_set(ClientData clientData, Tcl_Interp *interp, char *name1, char *name2, int flags) {"; Printv(set._def, "static char *_swig_", t->print_mangle(), "_set(ClientData clientData, Tcl_Interp *interp, char *name1, char *name2, int flags) {",0);
get.def << "static char *_swig_" << t->print_mangle() << "_get(ClientData clientData, Tcl_Interp *interp, char *name1, char *name2, int flags) {";
Printv(get._def, "static char *_swig_", t->print_mangle(), "_get(ClientData clientData, Tcl_Interp *interp, char *name1, char *name2, int flags) {",0);
t->is_pointer++; t->is_pointer++;
get.add_local(t->print_type(),(char*)"addr"); get.add_local(t->print_type(),(char*)"addr");
set.add_local(t->print_type(),(char*)"addr"); set.add_local(t->print_type(),(char*)"addr");
set.code << tab4 << "addr = " << t->print_cast() << " clientData;\n"; Printv(set._code, tab4, "addr = ", t->print_cast(), " clientData;\n", 0);
get.code << tab4 << "addr = " << t->print_cast() << " clientData;\n"; Printv(get._code, tab4, "addr = ", t->print_cast(), " clientData;\n", 0);
t->is_pointer--; t->is_pointer--;
set.add_local((char*)"char *",(char*)"value"); set.add_local((char*)"char *",(char*)"value");
get.add_local((char*)"Tcl_Obj *",(char*)"value"); get.add_local((char*)"Tcl_Obj *",(char*)"value");
set.code << tab4 << "value = Tcl_GetVar2(interp, name1, name2, flags);\n" Printv(set._code, tab4, "value = Tcl_GetVar2(interp, name1, name2, flags);\n",
<< tab4 << "if (!value) return NULL;\n"; tab4, "if (!value) return NULL;\n", 0);
if (!t->is_pointer) { if (!t->is_pointer) {
switch(t->type) { switch(t->type) {
@ -789,30 +821,31 @@ void TCL8::link_variable(char *name, char *iname, DataType *t)
case T_UCHAR: case T_UCHAR:
case T_SCHAR: case T_SCHAR:
case T_BOOL: case T_BOOL:
set.code << tab4 << "*(addr) = " << t->print_cast() << "atol(value);\n"; Printv(set._code, tab4, "*(addr) = ", t->print_cast(), "atol(value);\n", 0);
break; break;
case T_UINT: case T_UINT:
case T_ULONG: case T_ULONG:
set.code << tab4 << "*(addr) = " << t->print_cast() << "strtoul(value,0,0);\n"; Printv(set._code, tab4, "*(addr) = ", t->print_cast(), "strtoul(value,0,0);\n",0);
break; break;
case T_FLOAT: case T_FLOAT:
case T_DOUBLE: case T_DOUBLE:
set.code << tab4 << "*(addr) = " << t->print_cast() << "atof(value);\n"; Printv(set._code, tab4, "*(addr) = ", t->print_cast(), "atof(value);\n",0);
break; break;
case T_CHAR: /* Single character. */ case T_CHAR: /* Single character. */
set.code << tab4 << "*(addr) = *value;\n"; Printv(set._code, tab4, "*(addr) = *value;\n",0);
break; break;
case T_USER: case T_USER:
// User defined type. We return it as a pointer // User defined type. We return it as a pointer
t->is_pointer++; t->is_pointer++;
t->remember(); t->remember();
set.code << tab4 << "{\n" Printv(set._code, tab4, "{\n",
<< tab8 << "void *ptr;\n" tab8, "void *ptr;\n",
<< tab8 << "if (SWIG_ConvertPtrFromString(interp,value,&ptr,SWIGTYPE" << t->print_mangle() << ") != TCL_OK) {\n" tab8, "if (SWIG_ConvertPtrFromString(interp,value,&ptr,SWIGTYPE", t->print_mangle(), ") != TCL_OK) {\n",
<< tab8 << tab4 << "return \"Type Error\";\n" tab8, tab4, "return \"Type Error\";\n",
<< tab8 << "}\n" tab8, "}\n",
<< tab8 << "*(addr) = *(" << t->print_cast() << " ptr);\n" tab8, "*(addr) = *(", t->print_cast(), " ptr);\n",
<< tab4 << "}\n"; tab4, "}\n",
0);
t->is_pointer--; t->is_pointer--;
break; break;
@ -822,26 +855,26 @@ void TCL8::link_variable(char *name, char *iname, DataType *t)
} }
} else { } else {
if ((t->is_pointer == 1) && (t->type == T_CHAR)) { if ((t->is_pointer == 1) && (t->type == T_CHAR)) {
set.code << tab4 << "if (*addr) free(*addr);\n" Printv(set._code, tab4, "if (*addr) free(*addr);\n",
<< tab4 << "*addr = (char *) malloc(strlen(value)+1);\n" tab4, "*addr = (char *) malloc(strlen(value)+1);\n",
<< tab4 << "strcpy(*addr,value);\n"; tab4, "strcpy(*addr,value);\n",
0);
} else { } else {
// User defined type. We return it as a pointer // User defined type. We return it as a pointer
t->remember(); t->remember();
set.code << tab4 << "{\n" Printv(set._code, tab4, "{\n",
<< tab8 << "void *ptr;\n" tab8, "void *ptr;\n",
<< tab8 << "if (SWIG_ConvertPtrFromString(interp,value,&ptr,SWIGTYPE" << t->print_mangle() << ") != TCL_OK) {\n" tab8, "if (SWIG_ConvertPtrFromString(interp,value,&ptr,SWIGTYPE", t->print_mangle(), ") != TCL_OK) {\n",
<< tab8 << tab4 << "return \"Type Error\";\n" tab8, tab4, "return \"Type Error\";\n",
<< tab8 << "}\n" tab8, "}\n",
<< tab8 << "*(addr) = " << t->print_cast() << " ptr;\n" tab8, "*(addr) = ", t->print_cast(), " ptr;\n",
<< tab4 << "}\n"; tab4, "}\n",
0);
/* A Pointer */ /* A Pointer */
} }
} }
set.code << tab4 << "return NULL;\n" Printv(set._code, tab4, "return NULL;\n", "}\n",0);
<< "}\n";
if (!t->is_pointer) { if (!t->is_pointer) {
switch(t->type) { switch(t->type) {
@ -858,31 +891,36 @@ void TCL8::link_variable(char *name, char *iname, DataType *t)
case T_SCHAR: case T_SCHAR:
case T_BOOL: case T_BOOL:
get.add_local((char*)"Tcl_Obj *",(char*)"value"); get.add_local((char*)"Tcl_Obj *",(char*)"value");
get.code << tab4 << "value = Tcl_NewIntObj((int) *addr);\n" Printv(get._code,
<< tab4 << "Tcl_SetVar2(interp,name1,name2,Tcl_GetStringFromObj(value,NULL), flags);\n" tab4, "value = Tcl_NewIntObj((int) *addr);\n",
<< tab4 << "Tcl_DecrRefCount(value);\n"; tab4, "Tcl_SetVar2(interp,name1,name2,Tcl_GetStringFromObj(value,NULL), flags);\n",
tab4, "Tcl_DecrRefCount(value);\n",
0);
break; break;
case T_FLOAT: case T_FLOAT:
case T_DOUBLE: case T_DOUBLE:
get.add_local((char*)"Tcl_Obj *",(char*)"value"); get.add_local((char*)"Tcl_Obj *",(char*)"value");
get.code << tab4 << "value = Tcl_NewDoubleObj((double) *addr);\n" Printv(get._code,
<< tab4 << "Tcl_SetVar2(interp,name1,name2,Tcl_GetStringFromObj(value,NULL), flags);\n" tab4, "value = Tcl_NewDoubleObj((double) *addr);\n",
<< tab4 << "Tcl_DecrRefCount(value);\n"; tab4, "Tcl_SetVar2(interp,name1,name2,Tcl_GetStringFromObj(value,NULL), flags);\n",
tab4, "Tcl_DecrRefCount(value);\n",
0);
break; break;
case T_CHAR: case T_CHAR:
get.add_local((char*)"char",(char*)"temp[4]"); get.add_local((char*)"char",(char*)"temp[4]");
get.code << tab4 << "temp[0] = *addr; temp[1] = 0;\n" Printv(get._code,tab4, "temp[0] = *addr; temp[1] = 0;\n",
<< tab4 << "Tcl_SetVar2(interp,name1,name2,temp,flags);\n"; tab4, "Tcl_SetVar2(interp,name1,name2,temp,flags);\n",
0);
break; break;
case T_USER: case T_USER:
get.add_local((char*)"Tcl_Obj *",(char*)"value"); get.add_local((char*)"Tcl_Obj *",(char*)"value");
t->is_pointer++; t->is_pointer++;
t->remember(); t->remember();
get.code << tab4 << "value = SWIG_NewPointerObj(addr, SWIGTYPE" << t->print_mangle() << ");\n" Printv(get._code, tab4, "value = SWIG_NewPointerObj(addr, SWIGTYPE", t->print_mangle(), ");\n",
<< tab4 << "Tcl_SetVar2(interp,name1,name2,Tcl_GetStringFromObj(value,NULL), flags);\n" tab4, "Tcl_SetVar2(interp,name1,name2,Tcl_GetStringFromObj(value,NULL), flags);\n",
<< tab4 << "Tcl_DecrRefCount(value);\n"; tab4, "Tcl_DecrRefCount(value);\n",0);
t->is_pointer--; t->is_pointer--;
break; break;
@ -891,36 +929,36 @@ void TCL8::link_variable(char *name, char *iname, DataType *t)
} }
} else { } else {
if ((t->is_pointer == 1) && (t->type == T_CHAR)) { if ((t->is_pointer == 1) && (t->type == T_CHAR)) {
get.code << tab4 << "Tcl_SetVar2(interp,name1,name2,*addr, flags);\n"; Printv(get._code, tab4, "Tcl_SetVar2(interp,name1,name2,*addr, flags);\n",0);
} else { } else {
get.add_local((char*)"Tcl_Obj *",(char*)"value"); get.add_local((char*)"Tcl_Obj *",(char*)"value");
t->remember(); t->remember();
get.code << tab4 << "value = SWIG_NewPointerObj(*addr, SWIGTYPE" << t->print_mangle() << ");\n" Printv(get._code,
<< tab4 << "Tcl_SetVar2(interp,name1,name2,Tcl_GetStringFromObj(value,NULL), flags);\n" tab4, "value = SWIG_NewPointerObj(*addr, SWIGTYPE", t->print_mangle(), ");\n",
<< tab4 << "Tcl_DecrRefCount(value);\n"; tab4, "Tcl_SetVar2(interp,name1,name2,Tcl_GetStringFromObj(value,NULL), flags);\n",
tab4, "Tcl_DecrRefCount(value);\n",
0);
} }
} }
get.code << tab4 << "return NULL;\n" Printv(get._code, tab4, "return NULL;\n", "}\n",0);
<< "}\n";
get.print(f_wrappers); get.print(f_wrappers);
set.print(f_wrappers); set.print(f_wrappers);
} }
var_info << tab4 << "{ SWIG_prefix \"" << iname << "\", (void *) &" << name << ", _swig_" << t->print_mangle() << "_get,"; Printv(var_info, tab4,"{ SWIG_prefix \"", iname, "\", (void *) &", name, ", _swig_", t->print_mangle(), "_get,", 0);
if (Status & STAT_READONLY) { if (Status & STAT_READONLY) {
static int readonly = 0; static int readonly = 0;
if (!readonly) { if (!readonly) {
WrapperFunction ro; WrapperFunction ro;
ro.def << "static char *_swig_readonly(ClientData clientData, Tcl_Interp *interp, char *name1, char *name2, int flags) {"; Printf(ro._def, "static char *_swig_readonly(ClientData clientData, Tcl_Interp *interp, char *name1, char *name2, int flags) {");
ro.code << tab4 << "return \"Variable is read-only\";\n"; Printv(ro._code, tab4, "return \"Variable is read-only\";\n", "}\n", 0);
ro.code << "}\n";
ro.print(f_wrappers); ro.print(f_wrappers);
readonly = 1; readonly = 1;
} }
var_info << "_swig_readonly},\n"; Printf(var_info, "_swig_readonly},\n");
} else { } else {
var_info << "_swig_" << t->print_mangle() << "_set},\n"; Printv(var_info, "_swig_", t->print_mangle(), "_set},\n",0);
} }
} }
@ -938,7 +976,7 @@ void TCL8::declare_const(char *name, char *, DataType *type, char *value) {
DataType *t; DataType *t;
char var_name[256]; char var_name[256];
char *tm; char *tm;
String rvalue; DOHString *rvalue;
Status = STAT_READONLY; // Enable readonly mode. Status = STAT_READONLY; // Enable readonly mode.
// Make a static variable; // Make a static variable;
@ -946,16 +984,14 @@ void TCL8::declare_const(char *name, char *, DataType *type, char *value) {
sprintf(var_name,"_wrap_const_%s",name); sprintf(var_name,"_wrap_const_%s",name);
// See if there's a typemap // See if there's a typemap
rvalue = value;
if ((type->type == T_CHAR) && (type->is_pointer == 1)) { if ((type->type == T_CHAR) && (type->is_pointer == 1)) {
rvalue << "\""; rvalue = NewStringf("\"%s\"",value);
"\"" >> rvalue; } else if ((type->type == T_CHAR) && (type->is_pointer == 0)) {
rvalue = NewStringf("\'%s\'",value);
} else {
rvalue = NewString(value);
} }
if ((type->type == T_CHAR) && (type->is_pointer == 0)) { if ((tm = typemap_lookup((char*)"const",(char*)"tcl8",type,name,Char(rvalue),name))) {
rvalue << "'";
"'" >> rvalue;
}
if ((tm = typemap_lookup((char*)"const",(char*)"tcl8",type,name,rvalue.get(),name))) {
// Yep. Use it instead of the default // Yep. Use it instead of the default
fprintf(f_init,"%s\n",tm); fprintf(f_init,"%s\n",tm);
} else { } else {
@ -1048,6 +1084,7 @@ void TCL8::declare_const(char *name, char *, DataType *type, char *value) {
} }
} }
} }
Delete(rvalue);
Status = OldStatus; Status = OldStatus;
} }
@ -1059,7 +1096,7 @@ void TCL8::declare_const(char *name, char *, DataType *type, char *value) {
char *TCL8::usage_var(char *iname, DataType *t) { char *TCL8::usage_var(char *iname, DataType *t) {
static char temp[1024]; static char temp[2048];
if (!nspace) { if (!nspace) {
sprintf(temp,"$%s%s", prefix, iname); sprintf(temp,"$%s%s", prefix, iname);
@ -1087,12 +1124,13 @@ char *TCL8::usage_var(char *iname, DataType *t) {
char * TCL8::usage_string(char *iname, DataType *, ParmList *l) { char * TCL8::usage_string(char *iname, DataType *, ParmList *l) {
static String temp; static DOHString *temp = 0;
Parm *p; Parm *p;
int i, numopt,pcount; int i, numopt,pcount;
temp = ""; if (!temp) temp = NewString("");
temp << iname << " "; Clear(temp);
Printf(temp,"%s ",iname);
/* Now go through and print parameters */ /* Now go through and print parameters */
i = 0; i = 0;
@ -1105,26 +1143,26 @@ char * TCL8::usage_string(char *iname, DataType *, ParmList *l) {
if (!typemap_check((char*)"ignore",(char*)"tcl8",p->t,p->name)) { if (!typemap_check((char*)"ignore",(char*)"tcl8",p->t,p->name)) {
if (i >= (pcount-numopt)) if (i >= (pcount-numopt))
temp << "?"; Putc('?',temp);
/* If parameter has been named, use that. Otherwise, just print a type */ /* If parameter has been named, use that. Otherwise, just print a type */
if ((p->t->type != T_VOID) || (p->t->is_pointer)) { if ((p->t->type != T_VOID) || (p->t->is_pointer)) {
if (strlen(p->name) > 0) { if (strlen(p->name) > 0) {
temp << p->name; Printf(temp,p->name);
} }
else { else {
temp << "{ " << p->t->print_type() << " }"; Printf(temp,"{ %s }", p->t->print_type());
} }
} }
if (i >= (pcount-numopt)) if (i >= (pcount-numopt))
temp << "?"; Putc('?',temp);
temp << " "; Putc(' ',temp);
i++; i++;
} }
p = l->get_next(); p = l->get_next();
} }
return temp.get(); return Char(temp);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -1134,15 +1172,14 @@ char * TCL8::usage_string(char *iname, DataType *, ParmList *l) {
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
char * TCL8::usage_func(char *iname, DataType *t, ParmList *l) { char * TCL8::usage_func(char *iname, DataType *t, ParmList *l) {
char temp[1024];
String temp;
if (nspace) { if (nspace) {
temp << ns_name << "::" << iname; sprintf(temp,"%s::%s",ns_name,iname);
} else { } else {
temp << prefix << iname; sprintf(temp,"%s%s",prefix,iname);
} }
return usage_string(temp.get(),t,l); return usage_string(temp,t,l);
} }
// ----------------------------------------------------------------- // -----------------------------------------------------------------
@ -1153,14 +1190,13 @@ char * TCL8::usage_func(char *iname, DataType *t, ParmList *l) {
// ----------------------------------------------------------------- // -----------------------------------------------------------------
char *TCL8::usage_const(char *name, DataType *, char *value) { char *TCL8::usage_const(char *name, DataType *, char *value) {
static String temp; static char temp[1024];
temp = "";
if (nspace) { if (nspace) {
temp << ns_name << "::" << name << " = " << value; sprintf(temp,"%s::%s = %s", ns_name,name,value);
} else { } else {
temp << "$" << prefix << name << " = " << value; sprintf(temp,"$%s%s = %s", prefix,name,value);
} }
return temp.get(); return temp;
} }
// ------------------------------------------------------------------- // -------------------------------------------------------------------
@ -1208,11 +1244,13 @@ void TCL8::cpp_open_class(char *classname, char *rename, char *ctype, int strip)
included_object = 1; included_object = 1;
} }
attributes = "static _swig_attribute _swig_"; Clear(attributes);
attributes << classname << "_attributes[] = {\n"; Printf(attributes, "static _swig_attribute _swig_");
Printv(attributes, classname, "_attributes[] = {\n", 0);
methods = "static _swig_method _swig_"; Clear(methods);
methods << classname << "_methods[] = {\n"; Printf(methods,"static _swig_method _swig_");
Printv(methods, classname, "_methods[] = {\n", 0);
have_constructor = 0; have_constructor = 0;
have_destructor = 0; have_destructor = 0;
@ -1234,9 +1272,11 @@ void TCL8::cpp_open_class(char *classname, char *rename, char *ctype, int strip)
} }
void TCL8::cpp_close_class() { void TCL8::cpp_close_class() {
String code,temp; DOHString *code;
DataType *t; DataType *t;
code = NewString("");
this->Language::cpp_close_class(); this->Language::cpp_close_class();
if (shadow) { if (shadow) {
@ -1246,43 +1286,43 @@ void TCL8::cpp_close_class() {
t->is_pointer = 1; t->is_pointer = 1;
if (have_destructor) { if (have_destructor) {
code << "static void _swig_delete_" << class_name << "(void *obj) {\n" Printv(code, "static void _swig_delete_", class_name, "(void *obj) {\n",
<< tab4 << Swig_name_destroy(class_name) << "((" << t->print_type() << ") obj);\n" tab4, Swig_name_destroy(class_name), "((", t->print_type(), ") obj);\n",
<< "}\n"; "}\n",0);
} }
methods << " {0,0}\n" Printf(methods, " {0,0}\n};\n");
<< "};\n"; Printv(code,methods,0);
code << methods;
attributes << " {0,0,0}\n" Printf(attributes, " {0,0,0}\n};\n");
<< "};\n"; Printv(code,attributes,0);
code << attributes;
code << "static _swig_class _wrap_class_" << class_name << " = { \"" << class_name Printv(code, "static _swig_class _wrap_class_", class_name, " = { \"", class_name,
<< "\", &SWIGTYPE" << t->print_mangle() << ","; "\", &SWIGTYPE", t->print_mangle(), ",",0);
if (have_constructor) { if (have_constructor) {
code << Swig_name_wrapper(Swig_name_construct(class_name)); Printf(code, Swig_name_wrapper(Swig_name_construct(class_name)));
} else { } else {
code << "0"; Printf(code,"0");
} }
if (have_destructor) { if (have_destructor) {
code << ", _swig_delete_" << class_name; Printv(code, ", _swig_delete_", class_name,0);
} else { } else {
code << ",0"; Printf(code,",0");
} }
code << ", _swig_" << class_name << "_methods, _swig_" << class_name << "_attributes };\n"; Printv(code, ", _swig_", class_name, "_methods, _swig_", class_name, "_attributes };\n", 0);
fprintf(f_wrappers,"%s", code.get()); Printf(f_wrappers,"%s",code);
cmd_info << tab4 << "{ SWIG_prefix \"" << class_name << "\", SwigObjectCmd, &_wrap_class_" << class_name << "},\n"; Printv(cmd_info, tab4, "{ SWIG_prefix \"", class_name, "\", SwigObjectCmd, &_wrap_class_", class_name, "},\n", 0);
} }
Delete(code);
} }
void TCL8::cpp_member_func(char *name, char *iname, DataType *t, ParmList *l) { void TCL8::cpp_member_func(char *name, char *iname, DataType *t, ParmList *l) {
char *realname; char *realname;
String temp; char temp[1024];
char *rname; char *rname;
this->Language::cpp_member_func(name,iname,t,l); this->Language::cpp_member_func(name,iname,t,l);
@ -1295,19 +1335,18 @@ void TCL8::cpp_member_func(char *name, char *iname, DataType *t, ParmList *l) {
// Add stubs for this member to our class handler function // Add stubs for this member to our class handler function
temp = ""; strcpy(temp, Swig_name_member(class_name,realname));
temp << Swig_name_member(class_name,realname); rname = GetChar(repeatcmd,temp);
rname = GetChar(repeatcmd,temp.get());
if (!rname) if (!rname)
rname = Swig_name_wrapper(temp.get()); rname = Swig_name_wrapper(temp);
methods << tab4 << "{\"" << realname << "\", " << rname << "}, \n"; Printv(methods, tab4, "{\"", realname, "\", ", rname, "}, \n", 0);
} }
} }
void TCL8::cpp_variable(char *name, char *iname, DataType *t) { void TCL8::cpp_variable(char *name, char *iname, DataType *t) {
char *realname; char *realname;
String temp; char temp[1024];
char *rname; char *rname;
this->Language::cpp_variable(name, iname, t); this->Language::cpp_variable(name, iname, t);
@ -1320,25 +1359,23 @@ void TCL8::cpp_variable(char *name, char *iname, DataType *t) {
char *bc = class_name; char *bc = class_name;
attributes << tab4 << "{ \"-" << realname << "\","; Printv(attributes, tab4, "{ \"-", realname, "\",", 0);
// Try to figure out if there is a wrapper for this function // Try to figure out if there is a wrapper for this function
temp = ""; strcpy(temp, Swig_name_get(Swig_name_member(bc,realname)));
temp << Swig_name_get(Swig_name_member(bc,realname)); rname = GetChar(repeatcmd,temp);
rname = GetChar(repeatcmd,temp.get());
if (!rname) if (!rname)
rname = Swig_name_wrapper(temp.get()); rname = Swig_name_wrapper(temp);
attributes << rname << ", "; Printv(attributes, rname, ", ", 0);
if (!(Status & STAT_READONLY)) { if (!(Status & STAT_READONLY)) {
temp = ""; strcpy(temp, Swig_name_set(Swig_name_member(bc,realname)));
temp << Swig_name_set(Swig_name_member(bc,realname)); rname = GetChar(repeatcmd,temp);
rname = GetChar(repeatcmd,temp.get());
if (!rname) if (!rname)
rname = Swig_name_wrapper(temp.get()); rname = Swig_name_wrapper(temp);
attributes << rname << "},\n"; Printv(attributes, rname, "},\n",0);
} else { } else {
attributes << "0 },\n"; Printf(attributes, "0 },\n");
} }
} }
} }
@ -1418,3 +1455,11 @@ void TCL8::cpp_class_decl(char *name, char *rename, char *type) {
} }
} }
} }

41
Source/Modules1.1/tcl8.h
View file

@ -22,54 +22,15 @@
class TCL8 : public Language { class TCL8 : public Language {
private: private:
char interp_name[256];
char *prefix; // Package prefix
char *module; // Name of the module
char *tcl_path;
char *init_name;
int nspace;
void get_pointer(char *iname, char *srcname, char *src, char *dest, DataType *t, void get_pointer(char *iname, char *srcname, char *src, char *dest, DataType *t,
String &f, char *ret); DOHString *f, char *ret);
char *char_result; char *char_result;
char *usage_func(char *, DataType *, ParmList *); char *usage_func(char *, DataType *, ParmList *);
char *usage_string(char *, DataType *, ParmList *); char *usage_string(char *, DataType *, ParmList *);
char *usage_var(char *, DataType *); char *usage_var(char *, DataType *);
char *usage_const(char *, DataType *, char *); char *usage_const(char *, DataType *, char *);
// C++ handling
int have_constructor;
int have_destructor;
String methods;
String attributes;
String postinit;
int shadow;
char *class_name;
char *class_type;
char *real_classname;
char *base_class;
DOH *hash;
DOH *repeatcmd;
DOH *setget;
public : public :
TCL8() {
prefix = 0;
module = 0;
init_name = 0;
nspace = 0;
shadow = 1;
char_result = (char*)"TCL_VOLATILE";
tcl_path = (char*)"tcl";
sprintf(interp_name,"interp");
class_name = 0;
class_type = 0;
real_classname = 0;
base_class = 0;
hash = NewHash();
repeatcmd = NewHash();
setget = NewHash();
};
virtual void parse_args(int, char *argv[]); virtual void parse_args(int, char *argv[]);
virtual void parse(); virtual void parse();
virtual void create_function(char *, char *, DataType *, ParmList *); virtual void create_function(char *, char *, DataType *, ParmList *);