Source/Modules/tcl8.cxx

   1 /* -----------------------------------------------------------------------------
   2  * See the LICENSE file for information on copyright, usage and redistribution
   3  * of SWIG, and the README file for authors - http://www.swig.org/release.html.
   4  *
   5  * tcl8.cxx
   6  *
   7  * Tcl8 language module for SWIG.
   8  * ----------------------------------------------------------------------------- */
   9
  10 char cvsroot_tcl8_cxx[] = "$Id: tcl8.cxx 11518 2009-08-08 22:56:10Z wsfulton $";
  11
  12 #include "swigmod.h"
  13 #include "cparse.h"
  14 static int treduce = SWIG_cparse_template_reduce(0);
  15
  16 static const char *usage = (char *) "\
  17 Tcl 8 Options (available with -tcl)\n\
  18      -itcl           - Enable ITcl support\n\
  19      -nosafe         - Leave out SafeInit module function.\n\
  20      -prefix <name>  - Set a prefix <name> to be prepended to all names\n\
  21      -namespace      - Build module into a Tcl 8 namespace\n\
  22      -pkgversion     - Set package version\n\n";
  23
  24 static String *cmd_tab = 0;     /* Table of command names    */
  25 static String *var_tab = 0;     /* Table of global variables */
  26 static String *const_tab = 0;   /* Constant table            */
  27 static String *methods_tab = 0; /* Methods table             */
  28 static String *attr_tab = 0;    /* Attribute table           */
  29 static String *prefix = 0;
  30 static String *module = 0;
  31 static int nspace = 0;
  32 static String *init_name = 0;
  33 static String *ns_name = 0;
  34 static int have_constructor;
  35 static String *constructor_name;
  36 static int have_destructor;
  37 static int have_base_classes;
  38 static String *destructor_action = 0;
  39 static String *version = (String *) "0.0";
  40 static String *class_name = 0;
  41
  42 static int have_attributes;
  43 static int have_methods;
  44 static int nosafe = 0;
  45
  46 static File *f_header = 0;
  47 static File *f_wrappers = 0;
  48 static File *f_init = 0;
  49 static File *f_begin = 0;
  50 static File *f_runtime = 0;
  51
  52
  53 //  Itcl support
  54 static int itcl = 0;
  55 static File *f_shadow = 0;
  56 static File *f_shadow_stubs = 0;
  57
  58 static String *constructor = 0;
  59 static String *destructor = 0;
  60 static String *base_classes = 0;
  61 static String *base_class_init = 0;
  62 static String *methods = 0;
  63 static String *imethods = 0;
  64 static String *attributes = 0;
  65 static String *attribute_traces = 0;
  66 static String *iattribute_traces = 0;
  67
  68
  69
  70 class TCL8:public Language {
  71 public:
  72
  73   /* ------------------------------------------------------------
  74    * TCL8::main()
  75    * ------------------------------------------------------------ */
  76
  77   virtual void main(int argc, char *argv[]) {
  78     int cppcast = 1;
  79
  80      SWIG_library_directory("tcl");
  81
  82     for (int i = 1; i < argc; i++) {
  83       if (argv[i]) {
  84         if (strcmp(argv[i], "-prefix") == 0) {
  85           if (argv[i + 1]) {
  86             prefix = NewString(argv[i + 1]);
  87             Swig_mark_arg(i);
  88             Swig_mark_arg(i + 1);
  89             i++;
  90           } else
  91              Swig_arg_error();
  92         } else if (strcmp(argv[i], "-pkgversion") == 0) {
  93           if (argv[i + 1]) {
  94             version = NewString(argv[i + 1]);
  95             Swig_mark_arg(i);
  96             Swig_mark_arg(i + 1);
  97             i++;
  98           }
  99         } else if (strcmp(argv[i], "-namespace") == 0) {
 100           nspace = 1;
 101           Swig_mark_arg(i);
 102         } else if (strcmp(argv[i], "-itcl") == 0) {
 103           itcl = 1;
 104           Swig_mark_arg(i);
 105         } else if (strcmp(argv[i], "-nosafe") == 0) {
 106           nosafe = 1;
 107           Swig_mark_arg(i);
 108         } else if (strcmp(argv[i], "-cppcast") == 0) {
 109           cppcast = 1;
 110           Swig_mark_arg(i);
 111         } else if (strcmp(argv[i], "-nocppcast") == 0) {
 112           cppcast = 0;
 113           Swig_mark_arg(i);
 114         } else if (strcmp(argv[i], "-help") == 0) {
 115           fputs(usage, stdout);
 116         }
 117       }
 118     }
 119
 120     if (cppcast) {
 121       Preprocessor_define((DOH *) "SWIG_CPLUSPLUS_CAST", 0);
 122     }
 123
 124     Preprocessor_define("SWIGTCL 1", 0);
 125     // SWIGTCL8 is deprecated, and no longer documented.
 126     Preprocessor_define("SWIGTCL8 1", 0);
 127     SWIG_typemap_lang("tcl8");
 128     SWIG_config_file("tcl8.swg");
 129     allow_overloading();
 130   }
 131
 132   /* ------------------------------------------------------------
 133    * top()
 134    * ------------------------------------------------------------ */
 135
 136   virtual int top(Node *n) {
 137
 138     /* Initialize all of the output files */
 139     String *outfile = Getattr(n, "outfile");
 140
 141     f_begin = NewFile(outfile, "w", SWIG_output_files());
 142     if (!f_begin) {
 143       FileErrorDisplay(outfile);
 144       SWIG_exit(EXIT_FAILURE);
 145     }
 146     f_runtime = NewString("");
 147     f_init = NewString("");
 148     f_header = NewString("");
 149     f_wrappers = NewString("");
 150
 151     /* Register file targets with the SWIG file handler */
 152     Swig_register_filebyname("header", f_header);
 153     Swig_register_filebyname("wrapper", f_wrappers);
 154     Swig_register_filebyname("begin", f_begin);
 155     Swig_register_filebyname("runtime", f_runtime);
 156     Swig_register_filebyname("init", f_init);
 157
 158     /* Initialize some variables for the object interface */
 159
 160     cmd_tab = NewString("");
 161     var_tab = NewString("");
 162     methods_tab = NewString("");
 163     const_tab = NewString("");
 164
 165     Swig_banner(f_begin);
 166
 167     Printf(f_runtime, "\n");
 168     Printf(f_runtime, "#define SWIGTCL\n");
 169     Printf(f_runtime, "\n");
 170
 171     /* Set the module name, namespace, and prefix */
 172
 173     module = NewStringf("%(lower)s", Getattr(n, "name"));
 174     init_name = NewStringf("%(title)s_Init", module);
 175
 176     ns_name = prefix ? Copy(prefix) : Copy(module);
 177     if (prefix)
 178       Append(prefix, "_");
 179
 180
 181     /* If shadow classing is enabled, we're going to change the module name to "_module" */
 182     if (itcl) {
 183       String *filen;
 184       filen = NewStringf("%s%s.itcl", Swig_file_dirname(outfile), module);
 185
 186       Insert(module, 0, "_");
 187
 188       if ((f_shadow = NewFile(filen, "w", SWIG_output_files())) == 0) {
 189         FileErrorDisplay(filen);
 190         SWIG_exit(EXIT_FAILURE);
 191       }
 192       f_shadow_stubs = NewString("");
 193
 194       Swig_register_filebyname("shadow", f_shadow);
 195       Swig_register_filebyname("itcl", f_shadow);
 196
 197       Swig_banner_target_lang(f_shadow, "#");
 198
 199       Printv(f_shadow, "\npackage require Itcl\n\n", NIL);
 200       Delete(filen);
 201     }
 202
 203     /* Generate some macros used throughout code generation */
 204
 205     Printf(f_header, "#define SWIG_init    %s\n", init_name);
 206     Printf(f_header, "#define SWIG_name    \"%s\"\n", module);
 207     if (nspace) {
 208       Printf(f_header, "#define SWIG_prefix  \"%s::\"\n", ns_name);
 209       Printf(f_header, "#define SWIG_namespace \"%s\"\n\n", ns_name);
 210     } else {
 211       Printf(f_header, "#define SWIG_prefix  \"%s\"\n", prefix);
 212     }
 213     Printf(f_header, "#define SWIG_version \"%s\"\n", version);
 214
 215     Printf(cmd_tab, "\nstatic swig_command_info swig_commands[] = {\n");
 216     Printf(var_tab, "\nstatic swig_var_info swig_variables[] = {\n");
 217     Printf(const_tab, "\nstatic swig_const_info swig_constants[] = {\n");
 218
 219     Printf(f_wrappers, "#ifdef __cplusplus\nextern \"C\" {\n#endif\n");
 220
 221     /* Start emitting code */
 222     Language::top(n);
 223
 224     /* Done.  Close up the module */
 225     Printv(cmd_tab, tab4, "{0, 0, 0}\n", "};\n", NIL);
 226     Printv(var_tab, tab4, "{0,0,0,0}\n", "};\n", NIL);
 227     Printv(const_tab, tab4, "{0,0,0,0,0,0}\n", "};\n", NIL);
 228
 229     Printv(f_wrappers, cmd_tab, var_tab, const_tab, NIL);
 230
 231     /* Dump the pointer equivalency table */
 232     SwigType_emit_type_table(f_runtime, f_wrappers);
 233
 234     Printf(f_wrappers, "#ifdef __cplusplus\n}\n#endif\n");
 235
 236     /* Close the init function and quit */
 237     Printf(f_init, "return TCL_OK;\n}\n");
 238
 239     if (!nosafe) {
 240       Printf(f_init, "SWIGEXPORT int %(title)s_SafeInit(Tcl_Interp *interp) {\n", module);
 241       Printf(f_init, "    return SWIG_init(interp);\n");
 242       Printf(f_init, "}\n");
 243     }
 244
 245     if (itcl) {
 246       Printv(f_shadow, f_shadow_stubs, "\n", NIL);
 247       Close(f_shadow);
 248       Delete(f_shadow);
 249     }
 250
 251     /* Close all of the files */
 252     Dump(f_runtime, f_begin);
 253     Printv(f_begin, f_header, f_wrappers, NIL);
 254     Wrapper_pretty_print(f_init, f_begin);
 255     Delete(f_header);
 256     Delete(f_wrappers);
 257     Delete(f_init);
 258     Close(f_begin);
 259     Delete(f_runtime);
 260     Delete(f_begin);
 261     return SWIG_OK;
 262   }
 263
 264   /* ------------------------------------------------------------
 265    * functionWrapper()
 266    * ------------------------------------------------------------ */
 267
 268   virtual int functionWrapper(Node *n) {
 269     String *name = Getattr(n, "name");  /* Like to get rid of this */
 270     String *iname = Getattr(n, "sym:name");
 271     SwigType *type = Getattr(n, "type");
 272     ParmList *parms = Getattr(n, "parms");
 273     String *overname = 0;
 274
 275     Parm *p;
 276     int i;
 277     String *tm;
 278     Wrapper *f;
 279     String *incode, *cleanup, *outarg, *argstr, *args;
 280     int num_arguments = 0;
 281     int num_required = 0;
 282     int varargs = 0;
 283
 284     char source[64];
 285
 286     if (Getattr(n, "sym:overloaded")) {
 287       overname = Getattr(n, "sym:overname");
 288     } else {
 289       if (!addSymbol(iname, n))
 290         return SWIG_ERROR;
 291     }
 292
 293     incode = NewString("");
 294     cleanup = NewString("");
 295     outarg = NewString("");
 296     argstr = NewString("\"");
 297     args = NewString("");
 298
 299     f = NewWrapper();
 300
 301 #ifdef SWIG_USE_RESULTOBJ
 302     Wrapper_add_local(f, "resultobj", "Tcl_Obj *resultobj = NULL");
 303 #endif
 304
 305
 306     String *wname = Swig_name_wrapper(iname);
 307     if (overname) {
 308       Append(wname, overname);
 309     }
 310     Setattr(n, "wrap:name", wname);
 311
 312     Printv(f->def, "SWIGINTERN int\n ", wname, "(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {", NIL);
 313
 314     // Emit all of the local variables for holding arguments.
 315     emit_parameter_variables(parms, f);
 316
 317     /* Attach standard typemaps */
 318     emit_attach_parmmaps(parms, f);
 319     Setattr(n, "wrap:parms", parms);
 320
 321     /* Get number of require and total arguments */
 322     num_arguments = emit_num_arguments(parms);
 323     num_required = emit_num_required(parms);
 324     varargs = emit_isvarargs(parms);
 325
 326     /* Unmarshal parameters */
 327
 328     for (i = 0, p = parms; i < num_arguments; i++) {
 329       /* Skip ignored arguments */
 330
 331       while (checkAttribute(p, "tmap:in:numinputs", "0")) {
 332         p = Getattr(p, "tmap:in:next");
 333       }
 334
 335       SwigType *pt = Getattr(p, "type");
 336       String *ln = Getattr(p, "lname");
 337
 338       /* Produce string representations of the source and target arguments */
 339       sprintf(source, "objv[%d]", i + 1);
 340
 341       if (i == num_required)
 342         Putc('|', argstr);
 343       if ((tm = Getattr(p, "tmap:in"))) {
 344         String *parse = Getattr(p, "tmap:in:parse");
 345         if (!parse) {
 346           Replaceall(tm, "$target", ln);
 347           Replaceall(tm, "$source", source);
 348           Replaceall(tm, "$input", source);
 349           Setattr(p, "emit:input", source);
 350
 351           if (Getattr(p, "wrap:disown") || (Getattr(p, "tmap:in:disown"))) {
 352             Replaceall(tm, "$disown", "SWIG_POINTER_DISOWN");
 353           } else {
 354             Replaceall(tm, "$disown", "0");
 355           }
 356
 357           Putc('o', argstr);
 358           Printf(args, ",(void *)0");
 359           if (i >= num_required) {
 360             Printf(incode, "if (objc > %d) {\n", i + 1);
 361           }
 362           Printf(incode, "%s\n", tm);
 363           if (i >= num_required) {
 364             Printf(incode, "}\n");
 365           }
 366         } else {
 367           Printf(argstr, "%s", parse);
 368           Printf(args, ",&%s", ln);
 369           if (Strcmp(parse, "p") == 0) {
 370             SwigType *lt = SwigType_ltype(pt);
 371             SwigType_remember(pt);
 372             if (Cmp(lt, "p.void") == 0) {
 373               Printf(args, ",(void *)0");
 374             } else {
 375               Printf(args, ",SWIGTYPE%s", SwigType_manglestr(pt));
 376             }
 377             Delete(lt);
 378           }
 379         }
 380         p = Getattr(p, "tmap:in:next");
 381         continue;
 382       } else {
 383         Swig_warning(WARN_TYPEMAP_IN_UNDEF, input_file, line_number, "Unable to use type %s as a function argument.\n", SwigType_str(pt, 0));
 384       }
 385       p = nextSibling(p);
 386     }
 387
 388     if (!varargs) {
 389       Putc(':', argstr);
 390     } else {
 391       Putc(';', argstr);
 392       /* If variable length arguments we need to emit the in typemap here */
 393       if (p && (tm = Getattr(p, "tmap:in"))) {
 394         sprintf(source, "objv[%d]", i + 1);
 395         Printf(incode, "if (objc > %d) {\n", i);
 396         Replaceall(tm, "$input", source);
 397         Printv(incode, tm, "\n", NIL);
 398         Printf(incode, "}\n");
 399       }
 400     }
 401
 402     Printf(argstr, "%s\"", usage_string(Char(iname), type, parms));
 403
 404     Printv(f->code, "if (SWIG_GetArgs(interp, objc, objv,", argstr, args, ") == TCL_ERROR) SWIG_fail;\n", NIL);
 405
 406     Printv(f->code, incode, NIL);
 407
 408     /* Insert constraint checking code */
 409     for (p = parms; p;) {
 410       if ((tm = Getattr(p, "tmap:check"))) {
 411         Replaceall(tm, "$target", Getattr(p, "lname"));
 412         Printv(f->code, tm, "\n", NIL);
 413         p = Getattr(p, "tmap:check:next");
 414       } else {
 415         p = nextSibling(p);
 416       }
 417     }
 418
 419     /* Insert cleanup code */
 420     for (i = 0, p = parms; p; i++) {
 421       if (!checkAttribute(p, "tmap:in:numinputs", "0")
 422           && !Getattr(p, "tmap:in:parse") && (tm = Getattr(p, "tmap:freearg"))) {
 423         if (Len(tm) != 0) {
 424           Replaceall(tm, "$source", Getattr(p, "lname"));
 425           Printv(cleanup, tm, "\n", NIL);
 426         }
 427         p = Getattr(p, "tmap:freearg:next");
 428       } else {
 429         p = nextSibling(p);
 430       }
 431     }
 432
 433     /* Insert argument output code */
 434     for (i = 0, p = parms; p; i++) {
 435       if ((tm = Getattr(p, "tmap:argout"))) {
 436         Replaceall(tm, "$source", Getattr(p, "lname"));
 437 #ifdef SWIG_USE_RESULTOBJ
 438         Replaceall(tm, "$target", "resultobj");
 439         Replaceall(tm, "$result", "resultobj");
 440 #else
 441         Replaceall(tm, "$target", "(Tcl_GetObjResult(interp))");
 442         Replaceall(tm, "$result", "(Tcl_GetObjResult(interp))");
 443 #endif
 444         Replaceall(tm, "$arg", Getattr(p, "emit:input"));
 445         Replaceall(tm, "$input", Getattr(p, "emit:input"));
 446         Printv(outarg, tm, "\n", NIL);
 447         p = Getattr(p, "tmap:argout:next");
 448       } else {
 449         p = nextSibling(p);
 450       }
 451     }
 452
 453     /* Now write code to make the function call */
 454     String *actioncode = emit_action(n);
 455
 456     /* Need to redo all of this code (eventually) */
 457
 458     /* Return value if necessary  */
 459     if ((tm = Swig_typemap_lookup_out("out", n, "result", f, actioncode))) {
 460       Replaceall(tm, "$source", "result");
 461 #ifdef SWIG_USE_RESULTOBJ
 462       Replaceall(tm, "$target", "resultobj");
 463       Replaceall(tm, "$result", "resultobj");
 464 #else
 465       Replaceall(tm, "$target", "(Tcl_GetObjResult(interp))");
 466       Replaceall(tm, "$result", "(Tcl_GetObjResult(interp))");
 467 #endif
 468       if (GetFlag(n, "feature:new")) {
 469         Replaceall(tm, "$owner", "SWIG_POINTER_OWN");
 470       } else {
 471         Replaceall(tm, "$owner", "0");
 472       }
 473       Printf(f->code, "%s\n", tm);
 474     } else {
 475       Swig_warning(WARN_TYPEMAP_OUT_UNDEF, input_file, line_number, "Unable to use return type %s in function %s.\n", SwigType_str(type, 0), name);
 476     }
 477     emit_return_variable(n, type, f);
 478
 479     /* Dump output argument code */
 480     Printv(f->code, outarg, NIL);
 481
 482     /* Dump the argument cleanup code */
 483     Printv(f->code, cleanup, NIL);
 484
 485     /* Look for any remaining cleanup */
 486     if (GetFlag(n, "feature:new")) {
 487       if ((tm = Swig_typemap_lookup("newfree", n, "result", 0))) {
 488         Replaceall(tm, "$source", "result");
 489         Printf(f->code, "%s\n", tm);
 490       }
 491     }
 492
 493     if ((tm = Swig_typemap_lookup("ret", n, "result", 0))) {
 494       Replaceall(tm, "$source", "result");
 495       Printf(f->code, "%s\n", tm);
 496     }
 497 #ifdef SWIG_USE_RESULTOBJ
 498     Printv(f->code, "if (resultobj) Tcl_SetObjResult(interp, resultobj);\n", NIL);
 499 #endif
 500     Printv(f->code, "return TCL_OK;\n", NIL);
 501     Printv(f->code, "fail:\n", cleanup, "return TCL_ERROR;\n", NIL);
 502     Printv(f->code, "}\n", NIL);
 503
 504     /* Substitute the cleanup code */
 505     Replaceall(f->code, "$cleanup", cleanup);
 506     Replaceall(f->code, "$symname", iname);
 507
 508     /* Dump out the function */
 509     Wrapper_print(f, f_wrappers);
 510
 511     if (!Getattr(n, "sym:overloaded")) {
 512       /* Register the function with Tcl */
 513       Printv(cmd_tab, tab4, "{ SWIG_prefix \"", iname, "\", (swig_wrapper_func) ", Swig_name_wrapper(iname), ", NULL},\n", NIL);
 514     } else {
 515       if (!Getattr(n, "sym:nextSibling")) {
 516         /* Emit overloading dispatch function */
 517
 518         int maxargs;
 519         String *dispatch = Swig_overload_dispatch(n, "return %s(clientData, interp, objc, argv - 1);", &maxargs);
 520
 521         /* Generate a dispatch wrapper for all overloaded functions */
 522
 523         Wrapper *df = NewWrapper();
 524         String *dname = Swig_name_wrapper(iname);
 525
 526         Printv(df->def, "SWIGINTERN int\n", dname, "(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {", NIL);
 527         Printf(df->code, "Tcl_Obj *CONST *argv = objv+1;\n");
 528         Printf(df->code, "int argc = objc-1;\n");
 529         Printv(df->code, dispatch, "\n", NIL);
 530         Printf(df->code, "Tcl_SetResult(interp,(char *) \"No matching function for overloaded '%s'\", TCL_STATIC);\n", iname);
 531         Printf(df->code, "return TCL_ERROR;\n");
 532         Printv(df->code, "}\n", NIL);
 533         Wrapper_print(df, f_wrappers);
 534         Printv(cmd_tab, tab4, "{ SWIG_prefix \"", iname, "\", (swig_wrapper_func) ", dname, ", NULL},\n", NIL);
 535         DelWrapper(df);
 536         Delete(dispatch);
 537         Delete(dname);
 538       }
 539     }
 540
 541     Delete(incode);
 542     Delete(cleanup);
 543     Delete(outarg);
 544     Delete(argstr);
 545     Delete(args);
 546     DelWrapper(f);
 547     return SWIG_OK;
 548   }
 549
 550   /* ------------------------------------------------------------
 551    * variableWrapper()
 552    * ------------------------------------------------------------ */
 553
 554   virtual int variableWrapper(Node *n) {
 555
 556     String *name = Getattr(n, "name");
 557     String *iname = Getattr(n, "sym:name");
 558     SwigType *t = Getattr(n, "type");
 559
 560     String *setname = 0;
 561     String *setfname = 0;
 562     Wrapper *setf = 0, *getf = 0;
 563     int readonly = 0;
 564     String *tm;
 565
 566     if (!addSymbol(iname, n))
 567       return SWIG_ERROR;
 568
 569     /* Create a function for getting a variable */
 570     int addfail = 0;
 571     getf = NewWrapper();
 572     String *getname = Swig_name_get(iname);
 573     String *getfname = Swig_name_wrapper(getname);
 574     Setattr(n, "wrap:name", getfname);
 575     Printv(getf->def, "SWIGINTERN const char *", getfname, "(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, char *name1, char *name2, int flags) {", NIL);
 576     Wrapper_add_local(getf, "value", "Tcl_Obj *value = 0");
 577     if ((tm = Swig_typemap_lookup("varout", n, name, 0))) {
 578       Replaceall(tm, "$source", name);
 579       Replaceall(tm, "$target", "value");
 580       Replaceall(tm, "$result", "value");
 581       /* Printf(getf->code, "%s\n",tm); */
 582       addfail = emit_action_code(n, getf->code, tm);
 583       Printf(getf->code, "if (value) {\n");
 584       Printf(getf->code, "Tcl_SetVar2(interp,name1,name2,Tcl_GetStringFromObj(value,NULL), flags);\n");
 585       Printf(getf->code, "Tcl_DecrRefCount(value);\n");
 586       Printf(getf->code, "}\n");
 587       Printf(getf->code, "return NULL;\n");
 588       if (addfail) {
 589         Append(getf->code, "fail:\n");
 590         Printf(getf->code, "return \"%s\";\n", iname);
 591       }
 592       Printf(getf->code, "}\n");
 593       Wrapper_print(getf, f_wrappers);
 594     } else {
 595       Swig_warning(WARN_TYPEMAP_VAROUT_UNDEF, input_file, line_number, "Unable to read variable of type %s\n", SwigType_str(t, 0));
 596       DelWrapper(getf);
 597       return SWIG_NOWRAP;
 598     }
 599     DelWrapper(getf);
 600
 601     /* Try to create a function setting a variable */
 602     if (is_assignable(n)) {
 603       setf = NewWrapper();
 604       setname = Swig_name_set(iname);
 605       setfname = Swig_name_wrapper(setname);
 606       Setattr(n, "wrap:name", setfname);
 607       if (setf) {
 608         Printv(setf->def, "SWIGINTERN const char *", setfname,
 609              "(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, char *name1, char *name2 SWIGUNUSED, int flags) {", NIL);
 610         Wrapper_add_local(setf, "value", "Tcl_Obj *value = 0");
 611         Wrapper_add_local(setf, "name1o", "Tcl_Obj *name1o = 0");
 612
 613         if ((tm = Swig_typemap_lookup("varin", n, name, 0))) {
 614           Replaceall(tm, "$source", "value");
 615           Replaceall(tm, "$target", name);
 616           Replaceall(tm, "$input", "value");
 617           Printf(setf->code, "name1o = Tcl_NewStringObj(name1,-1);\n");
 618           Printf(setf->code, "value = Tcl_ObjGetVar2(interp, name1o, 0, flags);\n");
 619           Printf(setf->code, "Tcl_DecrRefCount(name1o);\n");
 620           Printf(setf->code, "if (!value) SWIG_fail;\n");
 621           /* Printf(setf->code,"%s\n", tm); */
 622           emit_action_code(n, setf->code, tm);
 623           Printf(setf->code, "return NULL;\n");
 624           Printf(setf->code, "fail:\n");
 625           Printf(setf->code, "return \"%s\";\n", iname);
 626           Printf(setf->code, "}\n");
 627           Wrapper_print(setf, f_wrappers);
 628         } else {
 629           Swig_warning(WARN_TYPEMAP_VARIN_UNDEF, input_file, line_number, "Unable to set variable of type %s.\n", SwigType_str(t, 0));
 630           readonly = 1;
 631         }
 632       }
 633       DelWrapper(setf);
 634     } else {
 635       readonly = 1;
 636     }
 637
 638
 639     Printv(var_tab, tab4, "{ SWIG_prefix \"", iname, "\", 0, (swig_variable_func) ", getfname, ",", NIL);
 640     if (readonly) {
 641       static int readonlywrap = 0;
 642       if (!readonlywrap) {
 643         Wrapper *ro = NewWrapper();
 644         Printf(ro->def,
 645                "SWIGINTERN const char *swig_readonly(ClientData clientData SWIGUNUSED, Tcl_Interp *interp SWIGUNUSED, char *name1 SWIGUNUSED, char *name2 SWIGUNUSED, int flags SWIGUNUSED) {");
 646         Printv(ro->code, "return \"Variable is read-only\";\n", "}\n", NIL);
 647         Wrapper_print(ro, f_wrappers);
 648         readonlywrap = 1;
 649         DelWrapper(ro);
 650       }
 651       Printf(var_tab, "(swig_variable_func) swig_readonly},\n");
 652     } else {
 653       Printv(var_tab, "(swig_variable_func) ", setfname, "},\n", NIL);
 654     }
 655     Delete(getfname);
 656     Delete(setfname);
 657     Delete(setname);
 658     Delete(getname);
 659     return SWIG_OK;
 660   }
 661
 662   /* ------------------------------------------------------------
 663    * constantWrapper()
 664    * ------------------------------------------------------------ */
 665
 666   virtual int constantWrapper(Node *n) {
 667     String *name = Getattr(n, "name");
 668     String *iname = Getattr(n, "sym:name");
 669     String *nsname = !nspace ? Copy(iname) : NewStringf("%s::%s", ns_name, iname);
 670     SwigType *type = Getattr(n, "type");
 671     String *rawval = Getattr(n, "rawval");
 672     String *value = rawval ? rawval : Getattr(n, "value");
 673     String *tm;
 674
 675     if (!addSymbol(iname, n))
 676       return SWIG_ERROR;
 677     if (nspace)
 678       Setattr(n, "sym:name", nsname);
 679
 680     /* Special hook for member pointer */
 681     if (SwigType_type(type) == T_MPOINTER) {
 682       String *wname = Swig_name_wrapper(iname);
 683       Printf(f_wrappers, "static %s = %s;\n", SwigType_str(type, wname), value);
 684       value = Char(wname);
 685     }
 686
 687     if ((tm = Swig_typemap_lookup("consttab", n, name, 0))) {
 688       Replaceall(tm, "$source", value);
 689       Replaceall(tm, "$target", name);
 690       Replaceall(tm, "$value", value);
 691       Replaceall(tm, "$nsname", nsname);
 692       Printf(const_tab, "%s,\n", tm);
 693     } else if ((tm = Swig_typemap_lookup("constcode", n, name, 0))) {
 694       Replaceall(tm, "$source", value);
 695       Replaceall(tm, "$target", name);
 696       Replaceall(tm, "$value", value);
 697       Replaceall(tm, "$nsname", nsname);
 698       Printf(f_init, "%s\n", tm);
 699     } else {
 700       Delete(nsname);
 701       Swig_warning(WARN_TYPEMAP_CONST_UNDEF, input_file, line_number, "Unsupported constant value.\n");
 702       return SWIG_NOWRAP;
 703     }
 704     Delete(nsname);
 705     return SWIG_OK;
 706   }
 707
 708   /* ------------------------------------------------------------
 709    * nativeWrapper()
 710    * ------------------------------------------------------------ */
 711
 712   virtual int nativeWrapper(Node *n) {
 713     String *name = Getattr(n, "sym:name");
 714     String *funcname = Getattr(n, "wrap:name");
 715     if (!addSymbol(funcname, n))
 716       return SWIG_ERROR;
 717
 718     Printf(f_init, "\t Tcl_CreateObjCommand(interp, SWIG_prefix \"%s\", (swig_wrapper_func) %s, (ClientData) NULL, (Tcl_CmdDeleteProc *) NULL);\n", name,
 719            funcname);
 720     return SWIG_OK;
 721   }
 722
 723   /* ------------------------------------------------------------
 724    * classHandler()
 725    * ------------------------------------------------------------ */
 726
 727   virtual int classHandler(Node *n) {
 728     static Hash *emitted = NewHash();
 729     String *mangled_classname = 0;
 730     String *real_classname = 0;
 731
 732     have_constructor = 0;
 733     have_destructor = 0;
 734     destructor_action = 0;
 735
 736     if (itcl) {
 737       constructor = NewString("");
 738       destructor = NewString("");
 739       base_classes = NewString("");
 740       base_class_init = NewString("");
 741       methods = NewString("");
 742       imethods = NewString("");
 743       attributes = NewString("");
 744       attribute_traces = NewString("");
 745       iattribute_traces = NewString("");
 746
 747       have_base_classes = 0;
 748       have_methods = 0;
 749       have_attributes = 0;
 750     }
 751
 752     class_name = Getattr(n, "sym:name");
 753     if (!addSymbol(class_name, n))
 754       return SWIG_ERROR;
 755
 756     real_classname = Getattr(n, "name");
 757     mangled_classname = Swig_name_mangle(real_classname);
 758
 759     if (Getattr(emitted, mangled_classname))
 760       return SWIG_NOWRAP;
 761     Setattr(emitted, mangled_classname, "1");
 762
 763     attr_tab = NewString("");
 764     Printf(attr_tab, "static swig_attribute swig_");
 765     Printv(attr_tab, mangled_classname, "_attributes[] = {\n", NIL);
 766
 767     methods_tab = NewStringf("");
 768     Printf(methods_tab, "static swig_method swig_");
 769     Printv(methods_tab, mangled_classname, "_methods[] = {\n", NIL);
 770
 771     /* Generate normal wrappers */
 772     Language::classHandler(n);
 773
 774     SwigType *t = Copy(Getattr(n, "name"));
 775     SwigType_add_pointer(t);
 776
 777     // Catch all: eg. a class with only static functions and/or variables will not have 'remembered'
 778     // SwigType_remember(t);
 779     String *wrap_class = NewStringf("&_wrap_class_%s", mangled_classname);
 780     SwigType_remember_clientdata(t, wrap_class);
 781
 782     //    t = Copy(Getattr(n,"classtype"));
 783     //    SwigType_add_pointer(t);
 784
 785     String *rt = Copy(Getattr(n, "classtype"));
 786     SwigType_add_pointer(rt);
 787
 788     // Register the class structure with the type checker
 789     /*    Printf(f_init,"SWIG_TypeClientData(SWIGTYPE%s, (void *) &_wrap_class_%s);\n", SwigType_manglestr(t), mangled_classname); */
 790     if (have_destructor) {
 791       Printv(f_wrappers, "SWIGINTERN void swig_delete_", class_name, "(void *obj) {\n", NIL);
 792       if (destructor_action) {
 793         Printv(f_wrappers, SwigType_str(rt, "arg1"), " = (", SwigType_str(rt, 0), ") obj;\n", NIL);
 794         Printv(f_wrappers, destructor_action, "\n", NIL);
 795       } else {
 796         if (CPlusPlus) {
 797           Printv(f_wrappers, "    delete (", SwigType_str(rt, 0), ") obj;\n", NIL);
 798         } else {
 799           Printv(f_wrappers, "    free((char *) obj);\n", NIL);
 800         }
 801       }
 802       Printf(f_wrappers, "}\n");
 803     }
 804
 805     Printf(methods_tab, "    {0,0}\n};\n");
 806     Printv(f_wrappers, methods_tab, NIL);
 807
 808     Printf(attr_tab, "    {0,0,0}\n};\n");
 809     Printv(f_wrappers, attr_tab, NIL);
 810
 811     /* Handle inheritance */
 812
 813     String *base_class = NewString("");
 814     String *base_class_names = NewString("");
 815
 816     if (itcl) {
 817       base_classes = NewString("");
 818     }
 819
 820     List *baselist = Getattr(n, "bases");
 821     if (baselist && Len(baselist)) {
 822       Iterator b;
 823       int index = 0;
 824       b = First(baselist);
 825       while (b.item) {
 826         String *bname = Getattr(b.item, "name");
 827         if ((!bname) || GetFlag(b.item, "feature:ignore") || (!Getattr(b.item, "module"))) {
 828           b = Next(b);
 829           continue;
 830         }
 831         if (itcl) {
 832           have_base_classes = 1;
 833           Printv(base_classes, bname, " ", NIL);
 834           Printv(base_class_init, "    ", bname, "Ptr::constructor $ptr\n", NIL);
 835         }
 836         String *bmangle = Swig_name_mangle(bname);
 837         //      Printv(f_wrappers,"extern swig_class _wrap_class_", bmangle, ";\n", NIL);
 838         //      Printf(base_class,"&_wrap_class_%s",bmangle);
 839         Printf(base_class, "0");
 840         Printf(base_class_names, "\"%s *\",", SwigType_namestr(bname));
 841         /* Put code to register base classes in init function */
 842
 843         //Printf(f_init,"/* Register base : %s */\n", bmangle);
 844         //Printf(f_init,"swig_%s_bases[%d] = (swig_class *) SWIG_TypeQuery(\"%s *\")->clientdata;\n",  mangled_classname, index, SwigType_namestr(bname));
 845         b = Next(b);
 846         index++;
 847         Putc(',', base_class);
 848         Delete(bmangle);
 849       }
 850     }
 851
 852     if (itcl) {
 853       String *ptrclass = NewString("");
 854
 855       // First, build the pointer base class
 856       Printv(ptrclass, "itcl::class ", class_name, "Ptr {\n", NIL);
 857       if (have_base_classes)
 858         Printv(ptrclass, "  inherit ", base_classes, "\n", NIL);
 859
 860       //  Define protected variables for SWIG object pointer
 861       Printv(ptrclass, "  protected variable swigobj\n", "  protected variable thisown\n", NIL);
 862
 863       //  Define public variables
 864       if (have_attributes) {
 865         Printv(ptrclass, attributes, NIL);
 866
 867         // base class swig_getset was being called for complex inheritance trees
 868         if (nspace) {
 869
 870           Printv(ptrclass, "  protected method ", class_name, "_swig_getset {var name1 name2 op} {\n", NIL);
 871
 872           Printv(ptrclass,
 873                  "    switch -exact -- $op {\n",
 874                  "      r {set $var [", ns_name, "::", class_name, "_[set var]_get $swigobj]}\n",
 875                  "      w {", ns_name, "::", class_name, "_${var}_set $swigobj [set $var]}\n", "    }\n", "  }\n", NIL);
 876         } else {
 877           Printv(ptrclass,
 878                  "  protected method ", class_name, "_swig_getset {var name1 name2 op} {\n",
 879                  "    switch -exact -- $op {\n",
 880                  "      r {set $var [", class_name, "_[set var]_get $swigobj]}\n",
 881                  "      w {", class_name, "_${var}_set $swigobj [set $var]}\n", "    }\n", "  }\n", NIL);
 882         }
 883       }
 884       //  Add the constructor, which may include
 885       //  calls to base class class constructors
 886
 887       Printv(ptrclass, "  constructor { ptr } {\n", NIL);
 888       if (have_base_classes) {
 889         Printv(ptrclass, base_class_init, NIL);
 890         Printv(ptrclass, "  } {\n", NIL);
 891       }
 892
 893       Printv(ptrclass, "    set swigobj $ptr\n", "    set thisown 0\n", NIL);
 894
 895       if (have_attributes) {
 896         Printv(ptrclass, attribute_traces, NIL);
 897       }
 898       Printv(ptrclass, "  }\n", NIL);
 899
 900
 901       //  Add destructor
 902       Printv(ptrclass, "  destructor {\n",
 903              "    set d_func delete_", class_name, "\n",
 904              "    if { $thisown && ([info command $d_func] != \"\") } {\n" "      $d_func $swigobj\n", "    }\n", "  }\n", NIL);
 905
 906       //  Add methods
 907       if (have_methods) {
 908         Printv(ptrclass, imethods, NIL);
 909       };
 910
 911       //  Close out the pointer class
 912       Printv(ptrclass, "}\n\n", NIL);
 913       Printv(f_shadow, ptrclass, NIL);
 914       // pointer class end
 915
 916
 917       //  Create the "real" class.
 918       Printv(f_shadow, "itcl::class ", class_name, " {\n", NIL);
 919       Printv(f_shadow, "  inherit ", class_name, "Ptr\n", NIL);
 920
 921       //  If we have a constructor, then use it.
 922       //  If not, then we must have an abstract class without
 923       //  any constructor.  So we create a class constructor
 924       //  which will fail for this class (but not for inherited
 925       //  classes).  Note that the constructor must fail before
 926       //  calling the ptrclass constructor.
 927
 928       if (have_constructor) {
 929         Printv(f_shadow, constructor, NIL);
 930       } else {
 931         Printv(f_shadow, "  constructor { } {\n", NIL);
 932         Printv(f_shadow, "    # This constructor will fail if called directly\n", NIL);
 933         Printv(f_shadow, "    if { [info class] == \"::", class_name, "\" } {\n", NIL);
 934         Printv(f_shadow, "      error \"No constructor for class ", class_name, (Getattr(n, "abstract") ? " - class is abstract" : ""), "\"\n", NIL);
 935         Printv(f_shadow, "    }\n", NIL);
 936         Printv(f_shadow, "  }\n", NIL);
 937       }
 938
 939       Printv(f_shadow, "}\n\n", NIL);
 940     }
 941
 942     Printv(f_wrappers, "static swig_class *swig_", mangled_classname, "_bases[] = {", base_class, "0};\n", NIL);
 943     Printv(f_wrappers, "static const char * swig_", mangled_classname, "_base_names[] = {", base_class_names, "0};\n", NIL);
 944     Delete(base_class);
 945     Delete(base_class_names);
 946
 947     Printv(f_wrappers, "static swig_class _wrap_class_", mangled_classname, " = { \"", class_name, "\", &SWIGTYPE", SwigType_manglestr(t), ",", NIL);
 948
 949     if (have_constructor) {
 950       Printf(f_wrappers, "%s", Swig_name_wrapper(Swig_name_construct(constructor_name)));
 951       Delete(constructor_name);
 952       constructor_name = 0;
 953     } else {
 954       Printf(f_wrappers, "0");
 955     }
 956     if (have_destructor) {
 957       Printv(f_wrappers, ", swig_delete_", class_name, NIL);
 958     } else {
 959       Printf(f_wrappers, ",0");
 960     }
 961     Printv(f_wrappers, ", swig_", mangled_classname, "_methods, swig_", mangled_classname, "_attributes, swig_", mangled_classname, "_bases,",
 962            "swig_", mangled_classname, "_base_names, &swig_module };\n", NIL);
 963
 964     if (!itcl) {
 965       Printv(cmd_tab, tab4, "{ SWIG_prefix \"", class_name, "\", (swig_wrapper_func) SWIG_ObjectConstructor, (ClientData)&_wrap_class_", mangled_classname,
 966              "},\n", NIL);
 967     };
 968
 969     Delete(t);
 970     Delete(mangled_classname);
 971     return SWIG_OK;
 972   }
 973
 974
 975   /* ------------------------------------------------------------
 976    * memberfunctionHandler()
 977    * ------------------------------------------------------------ */
 978
 979   virtual int memberfunctionHandler(Node *n) {
 980     String *name = Getattr(n, "name");
 981     String *iname = GetChar(n, "sym:name");
 982
 983     String *realname, *rname;
 984
 985     Language::memberfunctionHandler(n);
 986
 987     realname = iname ? iname : name;
 988     rname = Swig_name_wrapper(Swig_name_member(class_name, realname));
 989     if (!Getattr(n, "sym:nextSibling")) {
 990       Printv(methods_tab, tab4, "{\"", realname, "\", ", rname, "}, \n", NIL);
 991     }
 992
 993     if (itcl) {
 994       ParmList *l = Getattr(n, "parms");
 995       Parm *p = 0;
 996       String *pname = NewString("");
 997
 998       // Add this member to our class handler function
 999       Printv(imethods, tab2, "method ", realname, " [list ", NIL);
1000
1001       int pnum = 0;
1002       for (p = l; p; p = nextSibling(p)) {
1003
1004         String *pn = Getattr(p, "name");
1005         String *dv = Getattr(p, "value");
1006         SwigType *pt = Getattr(p, "type");
1007
1008         Printv(pname, ",(", pt, ")", NIL);
1009         Clear(pname);
1010
1011         /* Only print an argument if not void */
1012         if (Cmp(pt, "void") != 0) {
1013           if (Len(pn) > 0) {
1014             Printv(pname, pn, NIL);
1015           } else {
1016             Printf(pname, "p%d", pnum);
1017           }
1018
1019           if (Len(dv) > 0) {
1020             String *defval = NewString(dv);
1021             if (nspace) {
1022               Insert(defval, 0, "::");
1023               Insert(defval, 0, ns_name);
1024             }
1025             if (Strncmp(dv, "(", 1) == 0) {
1026               Insert(defval, 0, "$");
1027               Replaceall(defval, "(", "");
1028               Replaceall(defval, ")", "");
1029             }
1030             Printv(imethods, "[list ", pname, " ", defval, "] ", NIL);
1031           } else {
1032             Printv(imethods, pname, " ", NIL);
1033           }
1034         }
1035         ++pnum;
1036       }
1037       Printv(imethods, "] ", NIL);
1038
1039       if (nspace) {
1040         Printv(imethods, "{ ", ns_name, "::", class_name, "_", realname, " $swigobj", NIL);
1041       } else {
1042         Printv(imethods, "{ ", class_name, "_", realname, " $swigobj", NIL);
1043       };
1044
1045       pnum = 0;
1046       for (p = l; p; p = nextSibling(p)) {
1047
1048         String *pn = Getattr(p, "name");
1049         SwigType *pt = Getattr(p, "type");
1050         Clear(pname);
1051
1052         /* Only print an argument if not void */
1053         if (Cmp(pt, "void") != 0) {
1054           if (Len(pn) > 0) {
1055             Printv(pname, pn, NIL);
1056           } else {
1057             Printf(pname, "p%d", pnum);
1058           }
1059           Printv(imethods, " $", pname, NIL);
1060         }
1061         ++pnum;
1062       }
1063       Printv(imethods, " }\n", NIL);
1064       have_methods = 1;
1065     }
1066
1067     Delete(rname);
1068     return SWIG_OK;
1069   }
1070
1071   /* ------------------------------------------------------------
1072    * membervariableHandler()
1073    * ------------------------------------------------------------ */
1074
1075   virtual int membervariableHandler(Node *n) {
1076     String *symname = Getattr(n, "sym:name");
1077     String *rname;
1078
1079     Language::membervariableHandler(n);
1080     Printv(attr_tab, tab4, "{ \"-", symname, "\",", NIL);
1081     rname = Swig_name_wrapper(Swig_name_get(Swig_name_member(class_name, symname)));
1082     Printv(attr_tab, rname, ", ", NIL);
1083     Delete(rname);
1084     if (!GetFlag(n, "feature:immutable")) {
1085       rname = Swig_name_wrapper(Swig_name_set(Swig_name_member(class_name, symname)));
1086       Printv(attr_tab, rname, "},\n", NIL);
1087       Delete(rname);
1088     } else {
1089       Printf(attr_tab, "0 },\n");
1090     }
1091
1092     if (itcl) {
1093       Printv(attributes, "  public variable ", symname, "\n", NIL);
1094
1095       Printv(attribute_traces, "    trace variable ", symname, " rw [list ", class_name, "_swig_getset ", symname, "]\n", NIL);
1096       Printv(attribute_traces, "    set ", symname, "\n", NIL);
1097
1098       have_attributes = 1;
1099     }
1100     return SWIG_OK;
1101   }
1102
1103   /* ------------------------------------------------------------
1104    * constructorHandler()
1105    * ------------------------------------------------------------ */
1106
1107   virtual int constructorHandler(Node *n) {
1108     Language::constructorHandler(n);
1109
1110     if (itcl) {
1111       String *name = Getattr(n, "name");
1112       String *iname = GetChar(n, "sym:name");
1113
1114       String *realname;
1115
1116       ParmList *l = Getattr(n, "parms");
1117       Parm *p = 0;
1118
1119       String *pname = NewString("");
1120
1121       realname = iname ? iname : name;
1122
1123       if (!have_constructor) {
1124         // Add this member to our class handler function
1125         Printf(constructor, "  constructor { ");
1126
1127         //  Add parameter list
1128         int pnum = 0;
1129         for (p = l; p; p = nextSibling(p)) {
1130
1131           SwigType *pt = Getattr(p, "type");
1132           String *pn = Getattr(p, "name");
1133           String *dv = Getattr(p, "value");
1134           Clear(pname);
1135
1136           /* Only print an argument if not void */
1137           if (Cmp(pt, "void") != 0) {
1138             if (Len(pn) > 0) {
1139               Printv(pname, pn, NIL);
1140             } else {
1141               Printf(pname, "p%d", pnum);
1142             }
1143
1144             if (Len(dv) > 0) {
1145               Printv(constructor, "{", pname, " {", dv, "} } ", NIL);
1146             } else {
1147               Printv(constructor, pname, " ", NIL);
1148             }
1149           }
1150           ++pnum;
1151         }
1152         Printf(constructor, "} { \n");
1153
1154         // [BRE] 08/17/00 Added test to see if we are instantiating this object
1155         // type, or, if this constructor is being called as part of the itcl
1156         // inheritance hierarchy.
1157         // In the former case, we need to call the C++ constructor, in the
1158         // latter we don't, or we end up with two C++ objects.
1159         // Check to see if we are instantiating a 'realname' or something
1160         // derived from it.
1161         //
1162         Printv(constructor, "    if { [string equal -nocase \"", realname, "\" \"[namespace tail [info class]]\" ] } {\n", NIL);
1163
1164         // Call to constructor wrapper and parent Ptr class
1165         // [BRE] add -namespace/-prefix support
1166
1167         if (nspace) {
1168           Printv(constructor, "      ", realname, "Ptr::constructor [", ns_name, "::new_", realname, NIL);
1169         } else {
1170           Printv(constructor, "      ", realname, "Ptr::constructor [new_", realname, NIL);
1171         }
1172
1173         pnum = 0;
1174         for (p = l; p; p = nextSibling(p)) {
1175
1176           SwigType *pt = Getattr(p, "type");
1177           String *pn = Getattr(p, "name");
1178           Clear(pname);
1179
1180           /* Only print an argument if not void */
1181           if (Cmp(pt, "void") != 0) {
1182             if (Len(pn) > 0) {
1183               Printv(pname, pn, NIL);
1184             } else {
1185               Printf(pname, "p%d", pnum);
1186             }
1187             Printv(constructor, " $", pname, NIL);
1188           }
1189           ++pnum;
1190         }
1191
1192         Printv(constructor, "]\n", "    }\n", "  } {\n", "    set thisown 1\n", "  }\n", NIL);
1193       }
1194     }
1195
1196     constructor_name = NewString(Getattr(n, "sym:name"));
1197     have_constructor = 1;
1198     return SWIG_OK;
1199   }
1200
1201   /* ------------------------------------------------------------
1202    * destructorHandler()
1203    * ------------------------------------------------------------ */
1204
1205   virtual int destructorHandler(Node *n) {
1206     Language::destructorHandler(n);
1207     have_destructor = 1;
1208     destructor_action = Getattr(n, "wrap:action");
1209     return SWIG_OK;
1210   }
1211
1212   /* ------------------------------------------------------------
1213    * validIdentifier()
1214    * ------------------------------------------------------------ */
1215
1216   virtual int validIdentifier(String *s) {
1217     if (Strchr(s, ' '))
1218       return 0;
1219     return 1;
1220   }
1221
1222   /* ------------------------------------------------------------
1223    * usage_string()
1224    * ------------------------------------------------------------ */
1225
1226   char *usage_string(char *iname, SwigType *, ParmList *l) {
1227     static String *temp = 0;
1228     Parm *p;
1229     int i, numopt, pcount;
1230
1231     if (!temp)
1232       temp = NewString("");
1233     Clear(temp);
1234     if (nspace) {
1235       Printf(temp, "%s::%s ", ns_name, iname);
1236     } else {
1237       Printf(temp, "%s ", iname);
1238     }
1239     /* Now go through and print parameters */
1240     i = 0;
1241     pcount = emit_num_arguments(l);
1242     numopt = pcount - emit_num_required(l);
1243     for (p = l; p; p = nextSibling(p)) {
1244
1245       SwigType *pt = Getattr(p, "type");
1246       String *pn = Getattr(p, "name");
1247       /* Only print an argument if not ignored */
1248       if (!checkAttribute(p, "tmap:in:numinputs", "0")) {
1249         if (i >= (pcount - numopt))
1250           Putc('?', temp);
1251         if (Len(pn) > 0) {
1252           Printf(temp, "%s", pn);
1253         } else {
1254           Printf(temp, "%s", SwigType_str(pt, 0));
1255         }
1256         if (i >= (pcount - numopt))
1257           Putc('?', temp);
1258         Putc(' ', temp);
1259         i++;
1260       }
1261     }
1262     return Char(temp);
1263   }
1264
1265   String *runtimeCode() {
1266     String *s = NewString("");
1267     String *serrors = Swig_include_sys("tclerrors.swg");
1268     if (!serrors) {
1269       Printf(stderr, "*** Unable to open 'tclerrors.swg'\n");
1270     } else {
1271       Append(s, serrors);
1272       Delete(serrors);
1273     }
1274     String *sapi = Swig_include_sys("tclapi.swg");
1275     if (!sapi) {
1276       Printf(stderr, "*** Unable to open 'tclapi.swg'\n");
1277     } else {
1278       Append(s, sapi);
1279       Delete(sapi);
1280     }
1281     String *srun = Swig_include_sys("tclrun.swg");
1282     if (!srun) {
1283       Printf(stderr, "*** Unable to open 'tclrun.swg'\n");
1284     } else {
1285       Append(s, srun);
1286       Delete(srun);
1287     }
1288
1289     return s;
1290   }
1291
1292   String *defaultExternalRuntimeFilename() {
1293     return NewString("swigtclrun.h");
1294   }
1295 };
1296
1297 /* ----------------------------------------------------------------------
1298  * swig_tcl()    - Instantiate module
1299  * ---------------------------------------------------------------------- */
1300
1301 static Language *new_swig_tcl() {
1302   return new TCL8();
1303 }
1304 extern "C" Language *swig_tcl(void) {
1305   return new_swig_tcl();
1306 }