/tags/rel-1-3-15/SWIG/Lib/tcl/tcl8.swg
Unknown | 598 lines | 483 code | 115 blank | 0 comment | 0 complexity | 6ebb21d8ec1816a0b3c6cec7fc91c66e MD5 | raw file
Possible License(s): LGPL-2.1, Cube, GPL-3.0, 0BSD, GPL-2.0
1/* -----------------------------------------------------------------------------
2 * tcl8.swg
3 *
4 * Tcl8 configuration module.
5 * ----------------------------------------------------------------------------- */
6
7%runtime "common.swg"
8%runtime "swigtcl8.swg"
9
10/* -----------------------------------------------------------------------------
11 * --- standard typemaps ---
12 * ----------------------------------------------------------------------------- */
13
14/* Input arguments */
15
16/* For primitive types, the Tcl module uses a special function
17
18 SWIG_GetArgs(Tcl_Interp *, int objc, Tcl_Obj *CONST objv[], const char *fmt, ...)
19
20 The fmt field contains special conversion characters i,h,l,b,f,d,c,p, and o
21 that are used to marshal different types. The parse codes below correspond
22 to these special codes */
23
24%typemap(in,parse="i") int, unsigned int "";
25%typemap(in,parse="h") short, unsigned short "";
26%typemap(in,parse="l") long, unsigned long "";
27%typemap(in,parse="b") signed char, unsigned char "";
28%typemap(in,parse="f") float "";
29%typemap(in,parse="d") double "";
30%typemap(in,parse="c") char "";
31%typemap(in,parse="s") char *, char [ANY] "";
32
33/* Pointers */
34%typemap(in) SWIGTYPE *, SWIGTYPE &, SWIGTYPE []
35 "if ((SWIG_ConvertPtr(interp, $input, (void **) &$1, $1_descriptor,SWIG_POINTER_EXCEPTION | $disown) != TCL_OK)) SWIG_fail;";
36
37
38/* For bools, we first convert to an integer and then to a bool. There
39 is no guarantee that a bool is the same size as an int so we have to do this */
40
41%typemap(in) bool (int tempb) "if (Tcl_GetIntFromObj(interp,$input,&tempb) == TCL_ERROR) SWIG_fail;
42 $1 = (bool) tempb;";
43
44/* These will pass an integer as an unsigned long. However, the implementation is crippled due
45 to limited precision in Tcl */
46
47%typemap(in) long long "$1 = (long long) strtoll(Tcl_GetStringFromObj($input,NULL),0,0);";
48%typemap(in) unsigned long long "$1 = (unsigned long long) strtoull(Tcl_GetStringFromObj($input,NULL), 0, 0);";
49
50/* Enum parsing. Note: internally SWIG converts enums to/from integers so it's okay to use
51 the "i" parse code here */
52
53%typemap(in,parse="i") enum SWIGTYPE "";
54
55/* Unknown type. We convert from a pointer */
56%typemap(in) SWIGTYPE ($&1_ltype argp)
57 "if ((SWIG_ConvertPtr(interp, $input, (void **) &argp, $&1_descriptor,SWIG_POINTER_EXCEPTION ) != TCL_OK)) SWIG_fail;
58 $1 = *argp; ";
59
60
61
62/* Special constant variations. These typemaps can be used to parse objects that are both constants
63 or values. A Hash table lookup will occur. */
64
65%typemap(in,parse="I") int CONSTANT, unsigned int CONSTANT "";
66%typemap(in,parse="H") short CONSTANT, unsigned short CONSTANT "";
67%typemap(in,parse="L") long CONSTANT, unsigned long CONSTANT "";
68%typemap(in,parse="B") signed char CONSTANT, unsigned char CONSTANT "";
69%typemap(in,parse="F") float CONSTANT "";
70%typemap(in,parse="D") double CONSTANT "";
71%typemap(in,parse="C") char CONSTANT "";
72%typemap(in,parse="S") char * CONSTANT "";
73%typemap(in,parse="P") SWIGTYPE *CONSTANT, SWIGTYPE &CONSTANT, SWIGTYPE CONSTANT [] "";
74%typemap(in,parse="I") enum SWIGTYPE CONSTANT "";
75
76/* Constant references. Passed by value */
77/* Const primitive references. Passed by value */
78
79%typemap(in) const int & (int temp),
80 const short & (short temp),
81 const long & (long temp),
82 const unsigned int & (unsigned int temp),
83 const unsigned short & (unsigned short temp),
84 const unsigned long & (unsigned long temp),
85 const signed char & (signed char temp),
86 const unsigned char & (unsigned char temp),
87 const bool & (bool temp)
88{
89 long ltemp;
90 if (Tcl_GetLongFromObj(interp, $input, <emp) != TCL_OK) {
91 SWIG_fail;
92 }
93 temp = ($*1_ltype) ltemp;
94 $1 = &temp;
95}
96
97%typemap(in) const float & (float temp),
98 const double & (double temp)
99{
100 double dtemp;
101 if (Tcl_GetDoubleFromObj(interp, $input, &dtemp) != TCL_OK) {
102 SWIG_fail;
103 }
104 temp = ($*1_ltype) dtemp;
105 $1 = &temp;
106}
107
108%typemap(in) const long long & (long long temp)
109 "temp = (long long) strtoll(Tcl_GetStringFromObj($input,NULL),0,0);
110 $1 = &temp;";
111
112%typemap(in) const unsigned long long & (unsigned long long temp)
113 "temp = (unsigned long long) strtoull(Tcl_GetStringFromObj($input,NULL),0,0);
114 $1 = &temp;";
115
116%typemap(in) const char &(char temp) {
117 char *stemp = Tcl_GetStringFromObj($input,NULL);
118 temp = *stemp;
119 $1 = &temp;
120}
121
122/* Output values */
123
124%typemap(out) bool, int, unsigned int, short, unsigned short, long, unsigned long, signed char, unsigned char, enum SWIGTYPE
125 "Tcl_SetObjResult(interp,Tcl_NewIntObj((long) $1));";
126
127%typemap(out) long long {
128 char temp[256];
129 sprintf(temp,"%lld", $1);
130 Tcl_SetObjResult(interp,Tcl_NewStringObj(temp,-1));
131}
132
133%typemap(out) unsigned long long {
134 char temp[256];
135 sprintf(temp,"%llu", $1);
136 Tcl_SetObjResult(interp,Tcl_NewStringObj(temp,-1));
137}
138
139%typemap(out) char
140 "Tcl_SetObjResult(interp,Tcl_NewStringObj(&$1,1));";
141
142%typemap(out) float, double
143 "Tcl_SetObjResult(interp,Tcl_NewDoubleObj((double) $1));";
144
145%typemap(out) char *
146 "Tcl_SetObjResult(interp,Tcl_NewStringObj($1,-1));";
147
148%typemap(out) SWIGTYPE *, SWIGTYPE &, SWIGTYPE []
149 "Tcl_SetObjResult(interp,SWIG_NewPointerObj((void *) $1, $1_descriptor,0));";
150
151%typemap(out) SWIGTYPE *DYNAMIC, SWIGTYPE &DYNAMIC {
152 swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor,(void **) &$1);
153 Tcl_SetObjResult(interp,SWIG_NewPointerObj((void *) $1, ty,0));
154}
155
156%typemap(out) SWIGTYPE *INSTANCE, SWIGTYPE &INSTANCE, SWIGTYPE INSTANCE[]
157 "Tcl_SetObjResult(interp,SWIG_NewInstanceObj(interp, (void *) $1, $1_descriptor,0));";
158
159%typemap(out) SWIGTYPE *, SWIGTYPE &, SWIGTYPE []
160 "Tcl_SetObjResult(interp,SWIG_NewInstanceObj(interp, (void *) $1, $1_descriptor,0));";
161
162%typemap(out) void "";
163
164/* Primitive types--return by value */
165%typemap(out) SWIGTYPE NOINSTANCE
166#ifdef __cplusplus
167{
168 $&1_ltype resultptr;
169 resultptr = new $1_ltype(($1_ltype &) $1);
170 Tcl_SetObjResult(interp,SWIG_NewPointerObj((void*) resultptr, $&1_descriptor,0));
171}
172#else
173{
174 $&1_ltype resultptr;
175 resultptr = ($&1_ltype) malloc(sizeof($1_type));
176 memmove(resultptr, &$1, sizeof($1_type));
177 Tcl_SetObjResult(interp,SWIG_NewPointerObj((void*) resultptr, $&1_descriptor,0));
178}
179#endif
180
181/* Primitive types--return by value */
182%typemap(out) SWIGTYPE INSTANCE
183#ifdef __cplusplus
184{
185 $&1_ltype resultptr;
186 resultptr = new $1_ltype(($1_ltype &) $1);
187 Tcl_SetObjResult(interp,SWIG_NewInstanceObj(interp,(void*) resultptr, $&1_descriptor,1));
188}
189#else
190{
191 $&1_ltype resultptr;
192 resultptr = ($&1_ltype) malloc(sizeof($1_type));
193 memmove(resultptr, &$1, sizeof($1_type));
194 Tcl_SetObjResult(interp,SWIG_NewInstanceObj(interp,(void*) resultptr, $&1_descriptor,1));
195}
196#endif
197
198%typemap(out) SWIGTYPE = SWIGTYPE INSTANCE;
199
200/* Special typemap for character array returns */
201%typemap(out) char [ANY] "Tcl_SetObjResult(interp,Tcl_NewStringObj($1,-1));"
202
203
204/* Primitive references */
205
206%typemap(out) const int &, const unsigned int &,
207 const short &, const unsigned short &,
208 const long &, const unsigned long &,
209 const signed char &, const unsigned char &,
210 const bool &
211 "Tcl_SetObjResult(interp,Tcl_NewIntObj((long) *($1)));";
212
213%typemap(out) const float &, const double &
214 "Tcl_SetObjResult(interp,Tcl_NewDoubleObj((double) *($1)));";
215
216%typemap(out) const long long & {
217 char temp[256];
218 sprintf(temp,"%lld", *($1));
219 Tcl_SetObjResult(interp,Tcl_NewStringObj(temp,-1));
220}
221
222%typemap(out) const unsigned long long &
223{
224 char temp[256];
225 sprintf(temp,"%llu", *($1));
226 Tcl_SetObjResult(interp,Tcl_NewStringObj(temp,-1));
227}
228
229%typemap(out) const char &
230 "Tcl_SetObjResult(interp,Tcl_NewStringObj($1,1));";
231
232
233/* --- Variable output --- */
234
235%typemap(varout) int, unsigned int, short, unsigned short, long, unsigned long, signed char, unsigned char, bool, enum SWIGTYPE
236 "$result = Tcl_NewIntObj((long) $1);";
237
238%typemap(varout) long long {
239 char temp[256];
240 sprintf(temp,"%lld", $1);
241 $result = Tcl_NewStringObj(temp,-1);
242}
243
244%typemap(varout) unsigned long long {
245 char temp[256];
246 sprintf(temp,"%llu", $1);
247 $result = Tcl_NewStringObj(temp,-1);
248}
249
250%typemap(varout) double,float "$result = Tcl_NewDoubleObj((double) $1);";
251%typemap(varout) char * "$result = Tcl_NewStringObj((char*) $1,-1);";
252%typemap(varout) char [ANY] "$result = Tcl_NewStringObj((char *) $1,-1);";
253%typemap(varout) char "$result = Tcl_NewStringObj(&$1,1);";
254%typemap(varout) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] "$result = SWIG_NewPointerObj((void *) $1, $1_descriptor,0);";
255
256%typemap(varout) SWIGTYPE *INSTANCE, SWIGTYPE &INSTANCE, SWIGTYPE INSTANCE[]
257 "$result = SWIG_NewInstanceObj(interp, (void *) $1, $1_descriptor,0);";
258
259%typemap(varout) SWIGTYPE "$result = SWIG_NewPointerObj((void *) &$1, $&1_descriptor,0);";
260%typemap(varout) SWIGTYPE INSTANCE "$result = SWIG_NewInstanceObj(interp, (void *) &$1, $&1_descriptor,0);";
261%typemap(varout) SWIGTYPE "$result = SWIG_NewInstanceObj(interp, (void *) &$1, $&1_descriptor,0);";
262
263/* -- Variable input --- */
264
265%typemap(varin) int, unsigned int, short, unsigned short, long, unsigned long, signed char, unsigned char, bool, enum SWIGTYPE
266{
267 long temp;
268 if (Tcl_GetLongFromObj(interp, $input, &temp) != TCL_OK) {
269 return (char*) "Type error. expected an integer";
270 }
271 $1 = ($1_type) temp;
272}
273
274%typemap(varin) long long "$1 = (long long) strtoll(Tcl_GetStringFromObj($input,NULL),0,0);";
275%typemap(varin) unsigned long long "$1 = (unsigned long long) strtoull(Tcl_GetStringFromObj($input,NULL),0,0);";
276
277%typemap(varin) double, float {
278 double temp;
279 if (Tcl_GetDoubleFromObj(interp, $input, &temp) != TCL_OK) {
280 return (char*) "Type error. expected a double.";
281 }
282 $1 = ($1_type) temp;
283}
284
285%typemap(varin) char *
286#ifdef __cplusplus
287{
288 char *temp = Tcl_GetStringFromObj($input,NULL);
289 if ($1) delete [] $1;
290 $1 = ($1_type) new char[strlen(temp)+1];
291 strcpy((char *) $1,temp);
292}
293#else
294{
295 char *temp = Tcl_GetStringFromObj($input,NULL);
296 if ($1) free((char*)$1);
297 $1 = ($1_type) malloc(strlen(temp)+1);
298 strcpy((char *) $1,temp);
299}
300#endif
301
302%typemap(varin,warning="451:Setting const char * variable may leak memory") const char *
303#ifdef __cplusplus
304{
305 char *temp = Tcl_GetStringFromObj($input,NULL);
306 $1 = ($1_type) new char[strlen(temp)+1];
307 strcpy((char *) $1,temp);
308}
309#else
310{
311 char *temp = Tcl_GetStringFromObj($input,NULL);
312 $1 = ($1_type) malloc(strlen(temp)+1);
313 strcpy((char *) $1,temp);
314}
315#endif
316
317%typemap(varin) char [ANY] {
318 char *temp = Tcl_GetStringFromObj($input,NULL);
319 strncpy((char*)$1,temp,$1_dim0);
320}
321
322%typemap(varin) char
323{
324 char *temp = Tcl_GetStringFromObj($input,NULL);
325 $1 = *temp;
326}
327
328%typemap(varin) SWIGTYPE * {
329 void *temp;
330 if (SWIG_ConvertPtr(interp,$input,&temp,$1_descriptor, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN) != TCL_OK) {
331 return (char*)"Type error. Expected $1_ltype";
332 }
333 $1 = ($1_type) temp;
334}
335
336%typemap(varin) void * {
337 void *temp;
338 if (SWIG_ConvertPtr(interp,$input,&temp,0, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN) != TCL_OK) {
339 return (char*)"Type error. Expected $1_ltype";
340 }
341 $1 = ($1_type) temp;
342}
343
344%typemap(varin) SWIGTYPE & {
345 void *temp;
346 if (SWIG_ConvertPtr(interp,$input,&temp,$1_descriptor, SWIG_POINTER_EXCEPTION) != TCL_OK) {
347 return (char*)"Type error. Expected $1_ltype";
348 }
349 $1 = *(($&1_type) temp);
350}
351
352%typemap(varin) SWIGTYPE {
353 void *temp;
354 if (SWIG_ConvertPtr(interp,$input,&temp,$&1_descriptor, SWIG_POINTER_EXCEPTION) != TCL_OK) {
355 return (char*)"Type error. Expected $&1_ltype";
356 }
357 $1 = *(($&1_type) temp);
358}
359
360%typemap(varin) SWIGTYPE [] {
361 void *temp;
362 if (SWIG_ConvertPtr(interp,$input,&temp,$1_descriptor, SWIG_POINTER_EXCEPTION) != TCL_OK) {
363 return (char *)"Type error. Expected $1_ltype";
364 }
365 memmove((void *) $1,temp,$1_size*sizeof($1_basetype));
366}
367
368/* --- Constants --- */
369
370%typemap(consttab) int, unsigned int, short, unsigned short, long, unsigned long, unsigned char, signed char, bool, enum SWIGTYPE
371 { SWIG_TCL_INT, (char *)"$symname", (long) $value, 0, 0, 0}
372
373%typemap(consttab) float, double
374 { SWIG_TCL_FLOAT, (char*)"$symname", 0, (double) $value, 0, 0}
375
376%typemap(consttab) char, char *
377 { SWIG_TCL_STRING, (char*)"$symname", 0, 0, (void *)"$value", 0}
378
379%typemap(consttab) long long, unsigned long long
380 { SWIG_TCL_STRING, (char *) "$symname", 0, 0, (void *)"$value", 0}
381
382%typemap(consttab) SWIGTYPE *, SWIGTYPE &, SWIGTYPE []
383 { SWIG_TCL_POINTER, (char*)"$symname", 0, 0, (void *)$value, &$1_descriptor}
384
385%typemap(consttab) SWIGTYPE (CLASS::*)
386 { SWIG_TCL_BINARY, (char *)"$symname", sizeof($type), 0, (void *)&$value, &$1_descriptor}
387
388
389
390
391/* ------------------------------------------------------------
392 * String & length
393 * ------------------------------------------------------------ */
394
395%typemap(in) (char *STRING, int LENGTH) {
396 int temp;
397 $1 = ($1_ltype) Tcl_GetStringFromObj($input,&temp);
398 $2 = ($2_ltype) temp;
399}
400
401/* ------------------------------------------------------------
402 * ANSI C typemaps
403 * ------------------------------------------------------------ */
404
405%typemap(in) size_t (int temp) "if (Tcl_GetIntFromObj(interp,$input,&temp) == TCL_ERROR) return TCL_ERROR;
406 $1 = (size_t) temp;";
407
408%typemap(out) size_t = long;
409%typemap(varin) size_t = long;
410%typemap(varout) size_t = long;
411%typemap(consttab) size_t = long;
412
413
414
415/* ------------------------------------------------------------
416 * Typechecking rules
417 * ------------------------------------------------------------ */
418
419%typecheck(SWIG_TYPECHECK_INTEGER)
420 int, short, long,
421 unsigned int, unsigned short, unsigned long,
422 signed char, unsigned char,
423 long long, unsigned long long,
424 const int &, const short &, const long &,
425 const unsigned int &, const unsigned short &, const unsigned long &,
426 const long long &, const unsigned long long &,
427 enum SWIGTYPE,
428 bool, const bool &
429{
430 long tmp;
431 if (Tcl_GetLongFromObj(NULL,$input,&tmp) == TCL_ERROR) $1 = 0;
432 else $1 = 1;
433}
434
435%typecheck(SWIG_TYPECHECK_DOUBLE)
436 float, double,
437 const float &, const double &
438{
439 double tmp;
440 if (Tcl_GetDoubleFromObj(NULL,$input,&tmp) == TCL_ERROR) $1 = 0;
441 else $1 = 1;
442}
443
444%typecheck(SWIG_TYPECHECK_CHAR) char {
445 char *tmp;
446 int len;
447 tmp = Tcl_GetStringFromObj($input,&len);
448 (len == 1) ? 1 : 0;
449}
450
451%typecheck(SWIG_TYPECHECK_STRING) char * {
452 $1 = 1;
453}
454
455%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
456 void *ptr;
457 if (SWIG_ConvertPtr(interp, $input, (void **) &ptr, $1_descriptor, 0) == TCL_ERROR) {
458 $1 = 0;
459 } else {
460 $1 = 1;
461 }
462}
463
464%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
465 void *ptr;
466 if (SWIG_ConvertPtr(interp, $input, (void **) &ptr, $&1_descriptor, 0) == TCL_ERROR) {
467 $1 = 0;
468 } else {
469 $1 = 1;
470 }
471}
472
473%typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
474 void *ptr;
475 if (SWIG_ConvertPtr(interp, $input, (void **) &ptr, 0, 0) == TCL_ERROR) {
476 $1 = 0;
477 } else {
478 $1 = 1;
479 }
480}
481
482/* ------------------------------------------------------------
483 * Exception handling
484 * ------------------------------------------------------------ */
485
486%typemap(throws) int,
487 long,
488 short,
489 unsigned int,
490 unsigned long,
491 unsigned short {
492 Tcl_SetObjResult(interp, Tcl_NewIntObj((long) $1));
493 SWIG_fail;
494}
495
496%typemap(throws) SWIGTYPE CLASS {
497 $&1_ltype temp = new $1_ltype($1);
498 Tcl_SetObjResult(interp, SWIG_NewInstanceObj(interp, (void *) temp, $&1_descriptor, 1));
499 SWIG_fail;
500}
501
502%typemap(throws) SWIGTYPE {
503 Tcl_SetObjResult(interp, Tcl_NewStringObj((char*) "$1_type", -1));
504 SWIG_fail;
505}
506
507%typemap(throws) char * {
508 Tcl_SetObjResult(interp, Tcl_NewStringObj((char*) $1, -1));
509 SWIG_fail;
510}
511
512// Some special reserved words in classes
513
514%namewarn("314:cget is a reserved method name") *::cget;
515%namewarn("314:configure is a reserved method name") *::configure;
516
517/* C++ overloaded operators.
518
519 These declarations define how SWIG is going to rename C++
520 overloaded operators in Tcl. Since Tcl allows identifiers
521 to be essentially any valid string, we'll just use the
522 normal operator names */
523
524#ifdef __cplusplus
525%rename("+") *::operator+;
526//%rename("u+") *::operator+(); // Unary +
527//%rename("u+") *::operator+() const; // Unary +
528%rename("-") *::operator-;
529//%rename("u-") *::operator-(); // Unary -
530//%rename("u-") *::operator-() const; // Unary -
531%rename("*") *::operator*;
532%rename("/") *::operator/;
533%rename("<<") *::operator<<;
534%rename(">>") *::operator>>;
535%rename("&") *::operator&;
536%rename("|") *::operator|;
537%rename("^") *::operator^;
538%rename("%") *::operator%;
539%rename("=") *::operator=;
540#endif
541
542
543/* This initialization code exports the module initialization function */
544
545%header %{
546
547#ifdef __cplusplus
548extern "C" {
549#endif
550#ifdef MAC_TCL
551#pragma export on
552#endif
553SWIGEXPORT(int) SWIG_init(Tcl_Interp *);
554#ifdef MAC_TCL
555#pragma export off
556#endif
557#ifdef __cplusplus
558}
559#endif
560
561%}
562
563/* Start the initialization function */
564
565%init %{
566SWIGEXPORT(int) SWIG_init(Tcl_Interp *interp) {
567 int i;
568 static int _init = 0;
569 if (interp == 0) return TCL_ERROR;
570#ifdef USE_TCL_STUBS
571 if (Tcl_InitStubs(interp, (char*)"8.1", 0) == NULL) {
572 return TCL_ERROR;
573 }
574#endif
575
576 Tcl_PkgProvide(interp, (char*)SWIG_name, (char*)SWIG_version);
577
578#ifdef SWIG_namespace
579 Tcl_Eval(interp, "namespace eval " SWIG_namespace " { }");
580#endif
581 if (!_init) {
582 for (i = 0; swig_types_initial[i]; i++) {
583 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
584 }
585 _init = 1;
586 }
587 for (i = 0; swig_commands[i].name; i++) {
588 Tcl_CreateObjCommand(interp, (char *) swig_commands[i].name, (swig_wrapper_func) swig_commands[i].wrapper, swig_commands[i].clientdata, NULL);
589 }
590 for (i = 0; swig_variables[i].name; i++) {
591 Tcl_SetVar(interp, (char *) swig_variables[i].name, (char *) "", TCL_GLOBAL_ONLY);
592 Tcl_TraceVar(interp, (char *) swig_variables[i].name, TCL_TRACE_READS | TCL_GLOBAL_ONLY, (Tcl_VarTraceProc *) swig_variables[i].get, (ClientData) swig_variables[i].addr);
593 Tcl_TraceVar(interp, (char *) swig_variables[i].name, TCL_TRACE_WRITES | TCL_GLOBAL_ONLY, (Tcl_VarTraceProc *) swig_variables[i].set, (ClientData) swig_variables[i].addr);
594 }
595 SWIG_InstallConstants(interp, swig_constants);
596%}
597
598/* Note: the initialization function is closed after all code is generated */