+++ /dev/null
-/*******************************************************************************
- * Simplified Wrapper and Interface Generator (SWIG)
- *
- * Author : David Beazley
- *
- * Department of Computer Science
- * University of Chicago
- * 1100 E 58th Street
- * Chicago, IL 60637
- * beazley@cs.uchicago.edu
- *
- * Please read the file LICENSE for the copyright and terms by which SWIG
- * can be used and distributed.
- *******************************************************************************/
-
-/**********************************************************************
- * $Header$
- *
- * python.cxx
- *
- * Python module.
- **************************************************************************/
-
-
-#include "swig.h"
-#include "python.h"
-
-// Structures for managing doc strings
-
-struct DocString {
- DocEntry *de;
- char *name;
- DocString *next;
-};
-
-static int doc_index = 0;
-static DocString *doc_strings = 0;
-
-static char *usage = "\
-Python Options (available with -python)\n\
- -docstring - Produce docstrings (only applies to shadow classes)\n\
- -globals name - Set name used to access C global variable ('cvar' by default).\n\
- -module name - Set module name\n\
- -keyword - Use keyword arguments\n\
- -shadow - Generate shadow classes. \n\n";
-
-static String pragma_include;
-
-// ---------------------------------------------------------------------
-// PYTHON::parse_args(int argc, char *argv[])
-//
-// ---------------------------------------------------------------------
-
-void PYTHON::parse_args(int argc, char *argv[]) {
-
- int i = 1;
-
- sprintf(LibDir,"%s",path);
-
- docstring = 0;
-
- // Look for additional command line options.
- for (i = 1; i < argc; i++) {
- if (argv[i]) {
- if(strcmp(argv[i],"-module") == 0) {
- if (argv[i+1]) {
- module = new char[strlen(argv[i+1])+2];
- strcpy(module, argv[i+1]);
- mark_arg(i);
- mark_arg(i+1);
- i+=1;
- } else {
- arg_error();
- }
- } else if (strcmp(argv[i],"-globals") == 0) {
- if (argv[i+1]) {
- global_name = new char[strlen(argv[i+1])+1];
- strcpy(global_name, argv[i+1]);
- mark_arg(i);
- mark_arg(i+1);
- i++;
- } else {
- arg_error();
- }
- } else if (strcmp(argv[i],"-shadow") == 0) {
- shadow = 1;
- mark_arg(i);
- } else if (strcmp(argv[i],"-docstring") == 0) {
- docstring = 1;
- mark_arg(i);
- } else if (strcmp(argv[i],"-keyword") == 0) {
- use_kw = 1;
- mark_arg(i);
- } else if (strcmp(argv[i],"-help") == 0) {
- fputs(usage,stderr);
- }
- }
- }
- // Create a symbol for this language
- add_symbol("SWIGPYTHON",0,0);
-
- // Set name of typemaps
-
- typemap_lang = "python";
-
-}
-
-// ---------------------------------------------------------------------
-// PYTHON::parse()
-//
-// Parse the interface file
-// ---------------------------------------------------------------------
-
-void
-PYTHON::parse() {
-
- printf("Generating wrappers for Python\n");
- headers();
-
- // Run the SWIG parser
-
- yyparse();
-}
-
-// ---------------------------------------------------------------------
-// PYTHON::set_module(char *mod_name, char **mod_list)
-//
-// Sets the module name.
-// Does nothing if it's already set (so it can be overridden as a command
-// line option).
-//
-//----------------------------------------------------------------------
-
-void PYTHON::set_module(char *mod_name, char **mod_list) {
- int i;
-
- // If an "import" method has been set and we're in shadow class mode,
- // output a python command to load the module
-
- if (import_file) {
- if (!(strcmp(import_file,input_file+strlen(input_file)-strlen(import_file)))) {
- if (shadow) {
- fprintf(f_shadow,"\nfrom %s import *\n", mod_name);
- }
- delete import_file;
- import_file = 0;
- }
- }
-
- if (module) return;
-
- module = new char[strlen(mod_name)+1];
- strcpy(module,mod_name);
-
- // If there was a mod_list specified, make this incredible hack
- if (mod_list) {
- modinit << "#define SWIGMODINIT ";
- modextern << "#ifdef __cplusplus\n"
- << "extern \"C\" {\n"
- << "#endif\n";
- i = 0;
- while(mod_list[i]) {
- modinit << "swig_add_module(\"" << mod_list[i] << "\",init"
- << mod_list[i] << "); \\\n";
-
- modextern << "extern void init" << mod_list[i] << "();\n";
- i++;
- }
- modextern << "#ifdef __cplusplus\n"
- << "}\n"
- << "#endif\n";
- modinit << "/* End of extern module initialization */\n";
-
- }
-}
-
-// ---------------------------------------------------------------------
-// PYTHON::set_init(char *iname)
-//
-// Sets the initialization function name.
-// Does nothing if it's already set
-//
-//----------------------------------------------------------------------
-
-void PYTHON::set_init(char *iname) {
- set_module(iname,0);
-}
-
-
-// ---------------------------------------------------------------------
-// PYTHON::import(char *filename)
-//
-// Imports a SWIG module as a separate file.
-//----------------------------------------------------------------------
-
-void PYTHON::import(char *filename) {
- if (import_file) delete import_file;
- import_file = copy_string(filename);
-}
-
-// ----------------------------------------------------------------------
-// PYTHON::add_method(char *name, char *function)
-//
-// Add some symbols to the methods table
-// ----------------------------------------------------------------------
-
-void PYTHON::add_method(char *name, char *function) {
-
- Method *n;
-
- n = new Method;
- n->name = new char[strlen(name)+1];
- strcpy(n->name,name);
- n->function = new char[strlen(function)+1];
- strcpy(n->function, function);
-
- n->next = head;
- head = n;
-}
-
-// ---------------------------------------------------------------------
-// PYTHON::print_methods()
-//
-// Prints out the method array.
-// ---------------------------------------------------------------------
-
-void PYTHON::print_methods() {
-
- Method *n;
-
- fprintf(f_wrappers,"static PyMethodDef %sMethods[] = {\n", module);
- n = head;
- while (n) {
- if (!use_kw) {
- fprintf(f_wrappers,"\t { \"%s\", %s, METH_VARARGS },\n", n->name, n->function);
- } else {
- fprintf(f_wrappers,"\t { \"%s\", (PyCFunction) %s, METH_VARARGS | METH_KEYWORDS },\n", n->name, n->function);
- }
- n = n->next;
- }
- fprintf(f_wrappers,"\t { NULL, NULL }\n");
- fprintf(f_wrappers,"};\n");
- fprintf(f_wrappers,"#ifdef __cplusplus\n");
- fprintf(f_wrappers,"}\n");
- fprintf(f_wrappers,"#endif\n");
-}
-
-// ---------------------------------------------------------------------
-// char *PYTHON::add_docstring(DocEntry *de)
-//
-// Adds a documentation entry to the doc-string generator. Returns a
-// unique character symbol that will be used to fill in the doc-string
-// at a later time.
-// ---------------------------------------------------------------------
-
-char *PYTHON::add_docstring(DocEntry *de) {
- DocString *s;
- String str;
-
- str = "@doc";
- str << doc_index << "@";
-
- s = new DocString();
- s->de = de;
- s->name = copy_string(str);
- s->next = doc_strings;
- doc_strings = s;
- doc_index++;
- return s->name;
-}
-
-// ---------------------------------------------------------------------
-// PYTHON::headers(void)
-//
-// ----------------------------------------------------------------------
-
-void PYTHON::headers(void)
-{
-
- emit_banner(f_header);
-
- fprintf(f_header,"/* Implementation : PYTHON */\n\n");
- fprintf(f_header,"#define SWIGPYTHON\n");
-
- if (!NoInclude) {
- if (insert_file("python.swg", f_header) == -1) {
- fprintf(stderr,"SWIG : Fatal error. Unable to locate python.swg. (Possible installation problem).\n");
- SWIG_exit(1);
- }
- } else {
- if (insert_file("pyexp.swg", f_header) == -1) {
- fprintf(stderr,"SWIG : Fatal error. Unable to locate pyexp.swg. (Possible installation problem).\n");
- SWIG_exit(1);
- }
- }
-}
-
-
-// --------------------------------------------------------------------
-// PYTHON::initialize(void)
-//
-// This function outputs the starting code for a function to initialize
-// your interface. It is only called once by the parser.
-//
-// ---------------------------------------------------------------------
-
-void PYTHON::initialize(void)
-{
-
- char filen[256];
- char *temp;
- char *oldmodule = 0;
-
- if (!module) {
- module = "swig";
- fprintf(stderr,"SWIG : *** Warning. No module name specified.\n");
- }
-
- // If shadow classing is enabled, we're going to change the module
- // name to "modulec"
-
- if (shadow) {
- temp = new char[strlen(module)+2];
- sprintf(temp,"%sc",module);
- oldmodule = module;
- module = temp;
- }
- /* Initialize the C code for the module */
- initialize_cmodule();
- /* Create a shadow file (if enabled).*/
- if (shadow) {
- sprintf(filen,"%s%s.py", output_dir, oldmodule);
- if ((f_shadow = fopen(filen,"w")) == 0) {
- fprintf(stderr,"Unable to open %s\n", filen);
- SWIG_exit(0);
- }
- fprintf(f_shadow,"# This file was created automatically by SWIG.\n");
- fprintf(f_shadow,"import %s\n", module);
- }
-
- // Dump out external module declarations
-
- if (strlen(modinit.get()) > 0) {
- fprintf(f_header,"%s\n",modinit.get());
- }
- if (strlen(modextern.get()) > 0) {
- fprintf(f_header,"%s\n",modextern.get());
- }
- fprintf(f_wrappers,"#ifdef __cplusplus\n");
- fprintf(f_wrappers,"extern \"C\" {\n");
- fprintf(f_wrappers,"#endif\n");
-}
-
-// ---------------------------------------------------------------------
-// PYTHON::initialize_cmodule(void)
-//
-// Initializes the C module.
-//
-// ---------------------------------------------------------------------
-void PYTHON::initialize_cmodule(void)
-{
- int i;
- fprintf(f_header,"#define SWIG_init init%s\n\n", module);
- fprintf(f_header,"#define SWIG_name \"%s\"\n", module);
-
- // Output the start of the init function.
- // Modify this to use the proper return type and arguments used
- // by the target Language
-
- fprintf(f_init,"static PyObject *SWIG_globals;\n");
-
- fprintf(f_init,"#ifdef __cplusplus\n");
- fprintf(f_init,"extern \"C\" \n");
- fprintf(f_init,"#endif\n");
-
- fprintf(f_init,"SWIGEXPORT(void) init%s() {\n",module);
- fprintf(f_init,"\t PyObject *m, *d;\n");
-
- if (InitNames) {
- i = 0;
- while (InitNames[i]) {
- fprintf(f_init,"\t %s();\n", InitNames[i]);
- i++;
- }
- }
- fprintf(f_init,"\t SWIG_globals = SWIG_newvarlink();\n");
- fprintf(f_init,"\t m = Py_InitModule(\"%s\", %sMethods);\n", module, module);
- fprintf(f_init,"\t d = PyModule_GetDict(m);\n");
-}
-
-
-// ---------------------------------------------------------------------
-// PYTHON::close(void)
-//
-// Called when the end of the interface file is reached. Closes the
-// initialization function and performs cleanup as necessary.
-// ---------------------------------------------------------------------
-
-void PYTHON::close(void)
-{
-
- print_methods();
- close_cmodule();
- if ((doc_entry) && (module)){
- String temp;
- temp << "Python Module : ";
- if (shadow) {
- module[strlen(module)-1] = 0;
- }
- temp << module;
- doc_entry->cinfo << temp;
- }
- if (shadow) {
- String fullshadow;
- fullshadow << classes
- << "\n\n#-------------- FUNCTION WRAPPERS ------------------\n\n"
- << func
- << "\n\n#-------------- VARIABLE WRAPPERS ------------------\n\n"
- << vars;
-
- if (strlen(pragma_include) > 0) {
- fullshadow << "\n\n#-------------- USER INCLUDE -----------------------\n\n"
- << pragma_include;
- }
-
- // Go through all of the docstrings and replace the docstrings
-
- DocString *s;
- s = doc_strings;
- while (s) {
- fullshadow.replace(s->name, s->de->text);
- s = s->next;
- }
- /*
- fprintf(f_shadow,"\n\n#-------------- FUNCTION WRAPPERS ------------------\n\n");
- fprintf(f_shadow,"%s",func.get());
- fprintf(f_shadow,"\n\n#-------------- VARIABLE WRAPPERS ------------------\n\n");
- fprintf(f_shadow,"%s",vars.get());
- if (strlen(pragma_include) > 0) {
- fprintf(f_shadow,"\n\n#-------------- USER INCLUDE -----------------------\n\n");
- fprintf(f_shadow,"%s",pragma_include.get());
- }
- */
- fprintf(f_shadow, "%s", fullshadow.get());
- fclose(f_shadow);
- }
-}
-
-// --------------------------------------------------------------------
-// PYTHON::close_cmodule(void)
-//
-// Called to cleanup the C module code
-// --------------------------------------------------------------------
-void PYTHON::close_cmodule(void)
-{
- emit_ptr_equivalence(f_init);
- fprintf(f_init,"}\n");
-}
-
-// ----------------------------------------------------------------------
-// PYTHON::get_pointer(char *iname, char *srcname, char *src, char *target,
-// DataType *t, WrapperFunction &f, char *ret)
-//
-// Emits code to get a pointer and do type checking.
-// iname = name of the function/method (used for error messages)
-// srcname = Name of source (used for error message reporting).
-// src = name of variable where source string is located.
-// dest = name of variable where pointer value is stored.
-// t = Expected datatype of the parameter
-// f = Wrapper function object being used to generate code.
-// ret = return code upon failure.
-//
-// Note : pointers are stored as strings so you first need to get
-// a string and then call _swig_get_hex() to extract a point.
-//
-// This module is pretty ugly, but type checking is kind of nasty
-// anyways.
-// ----------------------------------------------------------------------
-
-void
-PYTHON::get_pointer(char *iname, char *srcname, char *src, char *dest,
- DataType *t, String &f, char *ret)
-{
-
- // Now get the pointer value from the string and save in dest
-
- if (t->is_reference)
- f << tab4 << "if (" << src << ") {\n"
- << tab8 << "if (SWIG_GetPtrObj(" << src << ",(void **) &" << dest << ",";
- else
- f << tab4 << "if (" << src << ") {\n"
- << tab8 << "if (" << src << " == Py_None) { " << dest << " = NULL; }\n"
- << tab8 << "else if (SWIG_GetPtrObj(" << src << ",(void **) &" << dest << ",";
-
- // If we're passing a void pointer, we give the pointer conversion a NULL
- // pointer, otherwise pass in the expected type.
-
- if (t->type == T_VOID) f << "(char *) 0 )) {\n";
- else
- f << "\"" << t->print_mangle() << "\")) {\n";
-
- // This part handles the type checking according to three different
- // levels. 0 = no checking, 1 = warning message, 2 = strict.
-
- switch(TypeStrict) {
- case 0: // No type checking
- f << tab8 << "}\n";
- break;
-
- case 1: // Warning message only
-
- // Change this part to how you want to handle a type-mismatch warning.
- // By default, it will just print to stderr.
-
- f << tab8 << tab4 << "fprintf(stderr,\"Warning : type mismatch in " << srcname
- << " of " << iname << ". Expected " << t->print_mangle()
- << ", received %s\\n\"," << src << ");\n"
- << tab8 << "}\n";
-
- break;
- case 2: // Super strict mode.
-
- // Change this part to return an error.
-
- f << tab8 << tab4 << "PyErr_SetString(PyExc_TypeError,\"Type error in " << srcname
- << " of " << iname << ". Expected " << t->print_mangle() << ".\");\n"
- << tab8 << "return " << ret << ";\n"
- << tab8 << "}\n";
- break;
-
- default :
- fprintf(stderr,"SWIG Error. Unknown strictness level\n");
- break;
- }
- f << tab4 << "}\n";
-}
-
-// ----------------------------------------------------------------------
-// PYTHON::emit_function_header()
-//
-// Return the code to be used as a function header
-// ----------------------------------------------------------------------
-void PYTHON::emit_function_header(WrapperFunction &emit_to, char *wname)
-{
- if (!use_kw) {
- emit_to.def << "static PyObject *" << wname
- << "(PyObject *self, PyObject *args) {";
- } else {
- emit_to.def << "static PyObject *" << wname
- << "(PyObject *self, PyObject *args, PyObject *kwargs) {";
- }
- emit_to.code << tab4 << "self = self;\n";
-}
-
-// ----------------------------------------------------------------------
-// PYTHON::convert_self()
-//
-// Called during the function generation process, to determine what to
-// use as the "self" variable during the call. Derived classes may emit code
-// to convert the real self pointer into a usable pointer.
-//
-// Returns the name of the variable to use as the self pointer
-// ----------------------------------------------------------------------
-char *PYTHON::convert_self(WrapperFunction &)
-{
- // Default behaviour is no translation
- return "";
-}
-
-// ----------------------------------------------------------------------
-// PYTHON::make_funcname_wrapper()
-//
-// Called to create a name for a wrapper function
-// ----------------------------------------------------------------------
-char *PYTHON::make_funcname_wrapper(char *fnName)
-{
- return name_wrapper(fnName,"");
-}
-
-// ----------------------------------------------------------------------
-// PYTHON::create_command(char *cname, char *iname)
-//
-// Create a new command in the interpreter. Used for C++ inheritance
-// stuff.
-// ----------------------------------------------------------------------
-
-void PYTHON::create_command(char *cname, char *iname) {
-
- // Create the name of the wrapper function
-
- char *wname = name_wrapper(cname,"");
-
- // Now register the function with the interpreter.
-
- add_method(iname, wname);
-
-}
-
-// ----------------------------------------------------------------------
-// PYTHON::create_function(char *name, char *iname, DataType *d,
-// ParmList *l)
-//
-// This function creates a wrapper function and registers it with the
-// interpreter.
-//
-// Inputs :
-// name = actual name of the function that's being wrapped
-// iname = name of the function in the interpreter (may be different)
-// d = Return datatype of the functions.
-// l = A linked list containing function parameter information.
-//
-// ----------------------------------------------------------------------
-
-void PYTHON::create_function(char *name, char *iname, DataType *d, ParmList *l)
-{
- Parm *p;
- int pcount,i,j;
- String wname, self_name, call_name;
- char source[64], target[64], temp[256], argnum[20];
- char *usage = 0;
- WrapperFunction f;
- String parse_args;
- String arglist;
- String get_pointers;
- String cleanup, outarg;
- String check;
- String build;
- String kwargs;
-
- int have_build = 0;
- char *tm;
- int numopt = 0;
-
- have_output = 0;
-
- // Make a valid name for this function. This removes special symbols
- // that would cause problems in the C compiler.
-
- wname = make_funcname_wrapper(iname);
-
- // Now emit the function declaration for the wrapper function. You
- // should modify this to return the appropriate types and use the
- // appropriate parameters.
-
- emit_function_header(f, wname);
-
- f.add_local("PyObject *","_resultobj");
-
- // Get the function usage string for later use
-
- usage = usage_func(iname,d,l);
-
- // Write code to extract function parameters.
- // This is done in one pass, but we need to construct three independent
- // pieces.
- // 1. Python format string such as "iis"
- // 2. The actual arguments to put values into
- // 3. Pointer conversion code.
- //
- // If there is a type mapping, we will extract the Python argument
- // as a raw PyObject and let the user deal with it.
- //
-
- pcount = emit_args(d, l, f);
- if (!use_kw) {
- parse_args << tab4 << "if(!PyArg_ParseTuple(args,\"";
- } else {
- parse_args << tab4 << "if(!PyArg_ParseTupleAndKeywords(args,kwargs,\"";
- arglist << ",_kwnames";
- }
-
- i = 0;
- j = 0;
- numopt = l->numopt(); // Get number of optional arguments
- if (numopt) have_defarg = 1;
- p = l->get_first();
-
- kwargs << "{ ";
- while (p != 0) {
-
- // Generate source and target strings
- sprintf(source,"_obj%d",i);
- sprintf(target,"_arg%d",i);
- sprintf(argnum,"%d",j+1);
-
- // Only consider this argument if it's not ignored
-
- if (!p->ignore) {
- arglist << ",";
- // Add an optional argument separator if needed
-
- if (j == pcount-numopt) {
- parse_args << "|";
- }
-
- if (strlen(p->name)) {
- kwargs << "\"" << p->name << "\",";
- } else {
- kwargs << "\"arg" << j+1 << "\",";
- // kwargs << "\"\",";
- }
-
- // Look for input typemap
-
- if ((tm = typemap_lookup("in","python",p->t,p->name,source,target,&f))) {
- parse_args << "O"; // Grab the argument as a raw PyObject
- f.add_local("PyObject *",source,"0");
- arglist << "&" << source;
- if (i >= (pcount-numopt))
- get_pointers << tab4 << "if (" << source << ")\n";
- get_pointers << tm << "\n";
- get_pointers.replace("$argnum", argnum);
- get_pointers.replace("$arg",source);
- } else {
-
- // Check if this parameter is a pointer. If not, we'll get values
-
- if (!p->t->is_pointer) {
- // Extract a parameter by "value"
-
- switch(p->t->type) {
-
- // Handle integers here. Usually this can be done as a single
- // case if you appropriate cast things. However, if you have
- // special cases, you'll need to add more code.
-
- case T_INT : case T_UINT: case T_SINT:
- parse_args << "i";
- break;
- case T_SHORT: case T_USHORT: case T_SSHORT:
- parse_args << "h";
- break;
- case T_LONG : case T_ULONG: case T_SLONG :
- parse_args << "l";
- break;
- case T_SCHAR : case T_UCHAR :
- parse_args << "b";
- break;
- case T_CHAR:
- parse_args << "c";
- break;
- case T_FLOAT :
- parse_args << "f";
- break;
- case T_DOUBLE:
- parse_args << "d";
- break;
-
- case T_BOOL:
- {
- String tempb;
- String tempval;
- if (p->defvalue) {
- tempval << "(int) " << p->defvalue;
- }
- tempb << "tempbool" << i;
- parse_args << "i";
- if (!p->defvalue)
- f.add_local("int",tempb.get());
- else
- f.add_local("int",tempb.get(),tempval.get());
- get_pointers << tab4 << target << " = " << p->t->print_cast() << " " << tempb << ";\n";
- arglist << "&" << tempb;
- }
- break;
-
- // Void.. Do nothing.
-
- case T_VOID :
- break;
-
- // User defined. This is usually invalid. No way to pass a
- // complex type by "value". We'll just pass into the unsupported
- // datatype case.
-
- case T_USER:
-
- // Unsupported data type
-
- default :
- fprintf(stderr,"%s : Line %d. Unable to use type %s as a function argument.\n",input_file, line_number, p->t->print_type());
- break;
- }
-
- // Emit code for parameter list
-
- if ((p->t->type != T_VOID) && (p->t->type != T_BOOL))
- arglist << "&_arg" << i;
-
- } else {
-
- // Is some other kind of variable.
-
- if ((p->t->type == T_CHAR) && (p->t->is_pointer == 1)) {
- parse_args << "s";
- arglist << "&_arg" << i;
- } else {
-
- // Have some sort of pointer variable. Create a temporary local
- // variable for the string and read the pointer value into it.
-
- parse_args << "O";
- sprintf(source,"_argo%d", i);
- sprintf(target,"_arg%d", i);
- sprintf(temp,"argument %d",i+1);
-
- f.add_local("PyObject *", source,"0");
- arglist << "&" << source;
- get_pointer(iname, temp, source, target, p->t, get_pointers, "NULL");
- }
- }
- }
- j++;
- }
- // Check if there was any constraint code
- if ((tm = typemap_lookup("check","python",p->t,p->name,source,target))) {
- check << tm << "\n";
- check.replace("$argnum", argnum);
- }
- // Check if there was any cleanup code
- if ((tm = typemap_lookup("freearg","python",p->t,p->name,target,source))) {
- cleanup << tm << "\n";
- cleanup.replace("$argnum", argnum);
- cleanup.replace("$arg",source);
- }
- if ((tm = typemap_lookup("argout","python",p->t,p->name,target,"_resultobj"))) {
- outarg << tm << "\n";
- outarg.replace("$argnum", argnum);
- outarg.replace("$arg",source);
- have_output++;
- }
- if ((tm = typemap_lookup("build","python",p->t,p->name,source,target))) {
- build << tm << "\n";
- have_build = 1;
- }
- p = l->get_next();
- i++;
- }
-
- kwargs << " NULL }";
- if (use_kw) {
- f.locals << tab4 << "char *_kwnames[] = " << kwargs << ";\n";
- }
-
- parse_args << ":" << iname << "\""; // No additional arguments
- parse_args << arglist << ")) \n"
- << tab8 << "return NULL;\n";
-
- self_name = convert_self(f);
-
- /* Now slap the whole first part of the wrapper function together */
-
- f.code << parse_args << get_pointers << check;
-
-
- // Special handling for build values
-
- if (have_build) {
- char temp1[256];
- char temp2[256];
- l->sub_parmnames(build); // Replace all parameter names
- for (i = 0; i < l->nparms; i++) {
- p = l->get(i);
- if (strlen(p->name) > 0) {
- sprintf(temp1,"_in_%s", p->name);
- } else {
- sprintf(temp1,"_in_arg%d", i);
- }
- sprintf(temp2,"_obj%d",i);
- build.replaceid(temp1,temp2);
- }
- f.code << build;
- }
-
- // This function emits code to call the real function. Assuming you read
- // the parameters in correctly, this will work.
-
- call_name = "";
- call_name << self_name << name;
- emit_func_call(call_name,d,l,f);
-
- // Now emit code to return the functions return value (if any).
- // If there was a result, it was saved in _result.
- // If the function is a void type, don't do anything.
-
- if ((strncmp(name, "new_", 4) != 0) && // don't use the out typemap for constructors
- (tm = typemap_lookup("out","python",d,iname,"_result","_resultobj"))) {
- // Yep. Use it instead of the default
- f.code << tm << "\n";
- } else {
-
- if ((d->type != T_VOID) || (d->is_pointer)) {
- // Now have return value, figure out what to do with it.
-
- if (!d->is_pointer) {
-
- // Function returns a "value"
-
- switch(d->type) {
-
- // Return an integer type
-
- case T_INT: case T_SINT: case T_UINT: case T_BOOL:
- f.code << tab4 << "_resultobj = Py_BuildValue(\"i\",_result);\n";
- break;
- case T_SHORT: case T_SSHORT: case T_USHORT:
- f.code << tab4 << "_resultobj = Py_BuildValue(\"h\",_result);\n";
- break;
- case T_LONG : case T_SLONG : case T_ULONG:
- f.code << tab4 << "_resultobj = Py_BuildValue(\"l\",_result);\n";
- break;
- case T_SCHAR: case T_UCHAR :
- f.code << tab4 << "_resultobj = Py_BuildValue(\"b\",_result);\n";
- break;
-
- // Return a floating point value
-
- case T_DOUBLE :
- f.code << tab4 << "_resultobj = Py_BuildValue(\"d\",_result);\n";
- break;
- case T_FLOAT :
- f.code << tab4 << "_resultobj = Py_BuildValue(\"f\",_result);\n";
- break;
-
- // Return a single ASCII value. Usually we need to convert
- // it to a NULL-terminate string and return that instead.
-
- case T_CHAR :
- f.code << tab4 << "_resultobj = Py_BuildValue(\"c\",_result);\n";
- break;
-
- case T_USER :
-
- // Return something by value
- // We're living dangerously here, but life is short...play hard
-
- // Oops. Need another local variable
- f.add_local("char","_ptemp[128]");
-
- d->is_pointer++;
- f.code << tab4 << "SWIG_MakePtr(_ptemp, (void *) _result,\""
- << d->print_mangle() << "\");\n";
- d->is_pointer--;
- // Return a character string containing our pointer.
-
- f.code << tab4 << "_resultobj = Py_BuildValue(\"s\",_ptemp);\n";
- break;
- default :
- fprintf(stderr,"%s: Line %d. Unable to use return type %s in function %s.\n", input_file, line_number, d->print_type(), name);
- break;
- }
- } else {
-
- // Return type is a pointer. We'll see if it's a char * and return
- // a string. Otherwise, we'll convert it into a SWIG pointer and return
- // that.
-
- if ((d->type == T_CHAR) && (d->is_pointer == 1)) {
-
- // Return a character string
- f.code << tab4 << "_resultobj = Py_BuildValue(\"s\", _result);\n";
-
- // If declared as a new object, free the result
-
- } else {
-
- // Build a SWIG pointer.
- f.add_local("char","_ptemp[128]");
- f.code << tab4 << "if (_result) {\n"
- << tab8 << "SWIG_MakePtr(_ptemp, (char *) _result,\""
- << d->print_mangle() << "\");\n";
-
- // Return a character string containing our pointer.
- f.code << tab8 << "_resultobj = Py_BuildValue(\"s\",_ptemp);\n";
- f.code << tab4 << "} else {\n"
- << tab8 << "Py_INCREF(Py_None);\n"
- << tab8 << "_resultobj = Py_None;\n"
- << tab4 << "}\n";
- }
- }
- } else {
- // no return value and no output args
- //if (!have_output) {
- f.code << tab4 << "Py_INCREF(Py_None);\n";
- f.code << tab4 << "_resultobj = Py_None;\n";
- //}
- }
- }
-
- // Check to see if there were any output arguments, if so we're going to
- // create a Python list object out of the current result
-
- f.code << outarg;
-
- // If there was any other cleanup needed, do that
-
- f.code << cleanup;
-
- // Look to see if there is any newfree cleanup code
-
- if (NewObject) {
- if ((tm = typemap_lookup("newfree","python",d,iname,"_result",""))) {
- f.code << tm << "\n";
- }
- }
-
- // See if there is any argument cleanup code
-
- if ((tm = typemap_lookup("ret","python",d,iname,"_result",""))) {
- // Yep. Use it instead of the default
- f.code << tm << "\n";
- }
-
- f.code << tab4 << "return _resultobj;\n";
- f.code << "}\n";
-
- // Substitute the cleanup code
- f.code.replace("$cleanup",cleanup);
-
- // Substitute the function name
- f.code.replace("$name",iname);
-
- // Dump the function out
- f.print(f_wrappers);
-
- // Now register the function with the interpreter.
-
- add_method(iname, wname);
-
- // Create a documentation entry for this
-
- if (doc_entry) {
- static DocEntry *last_doc_entry = 0;
- doc_entry->usage << usage;
- if (last_doc_entry != doc_entry) {
- doc_entry->cinfo << "returns " << d->print_type();
- last_doc_entry = doc_entry;
- }
- }
-
- // ---------------------------------------------------------------------------
- // Create a shadow for this function (if enabled and not in a member function)
- // ---------------------------------------------------------------------------
-
- if ((shadow) && (!(shadow & PYSHADOW_MEMBER))) {
- String translate;
-
- int need_wrapper = 0;
- int munge_return = 0;
- int have_optional = 0;
-
- // Check return code for modification
- if ((hash.lookup(d->name)) && (d->is_pointer <=1)) {
- need_wrapper = 1;
- munge_return = 1;
- }
-
- if (docstring && doc_entry)
- need_wrapper = 1;
-
- // If no modification is needed. We're just going to play some
- // symbol table games instead
-
- if (!need_wrapper) {
- func << iname << " = " << module << "." << iname << "\n\n";
- } else {
- func << "def " << iname << "(*_args, **_kwargs):\n";
-
- // Create a docstring for this
- if (docstring && doc_entry) {
- func << tab4 << "\"\"\"" << add_docstring(doc_entry) << "\"\"\"\n";
- }
-
- func << tab4 << "val = " << module << "." << iname << "(*_args,**_kwargs)\n";
-
- if (munge_return) {
- // If the output of this object has been remapped in any way, we're
- // going to return it as a bare object.
-
- if (!typemap_check("out",typemap_lang,d,iname)) {
-
- // If there are output arguments, we are going to return the value
- // unchanged. Otherwise, emit some shadow class conversion code.
-
- if (!have_output) {
- func << tab4 << "if val: val = " << (char *) hash.lookup(d->name) << "Ptr(val)";
- if (((hash.lookup(d->name)) && (d->is_pointer < 1)) ||
- ((hash.lookup(d->name)) && (d->is_pointer == 1) && NewObject))
- func << "; val.thisown = 1\n";
- else
- func << "\n";
- } else {
- // Does nothing--returns the value unmolested
- }
- }
- }
- func << tab4 << "return val\n\n";
- }
- }
-}
-
-// -----------------------------------------------------------------------
-// PYTHON::link_variable(char *name, char *iname, DataType *d)
-//
-// Input variables:
-// name = the real name of the variable being linked
-// iname = Name of the variable in the interpreter (may be different)
-// d = Datatype of the variable.
-//
-// This creates a pair of functions for evaluating/setting the value
-// of a variable. These are then added to the special SWIG global
-// variable type.
-// -----------------------------------------------------------------------
-
-void PYTHON::link_variable(char *name, char *iname, DataType *t) {
-
- char *wname;
- static int have_globals = 0;
- char *tm;
-
- WrapperFunction getf, setf;
-
- // If this is our first call, add the globals variable to the
- // Python dictionary.
-
- if (!have_globals) {
- fprintf(f_init,"\t PyDict_SetItemString(d,\"%s\", SWIG_globals);\n",global_name);
- have_globals=1;
- if ((shadow) && (!(shadow & PYSHADOW_MEMBER))) {
- vars << global_name << " = " << module << "." << global_name << "\n";
- }
- }
- // First make a sanitized version of the function name (in case it's some
- // funky C++ thing).
-
- wname = name_wrapper(name,"");
-
- // ---------------------------------------------------------------------
- // Create a function for setting the value of the variable
- // ---------------------------------------------------------------------
-
- setf.def << "static int " << wname << "_set(PyObject *val) {";
- if (!(Status & STAT_READONLY)) {
- if ((tm = typemap_lookup("varin","python",t,name,"val",name))) {
- setf.code << tm << "\n";
- setf.code.replace("$name",iname);
- } else {
- if ((t->type != T_VOID) || (t->is_pointer)) {
- if (!t->is_pointer) {
-
- // Have a real value here
-
- switch(t->type) {
- case T_INT: case T_SHORT: case T_LONG :
- case T_UINT: case T_USHORT: case T_ULONG:
- case T_SINT: case T_SSHORT: case T_SLONG:
- case T_SCHAR: case T_UCHAR: case T_BOOL:
- // Get an integer value
- setf.add_local(t->print_type(), "tval");
- setf.code << tab4 << "tval = " << t->print_cast() << "PyInt_AsLong(val);\n"
- << tab4 << "if (PyErr_Occurred()) {\n"
- << tab8 << "PyErr_SetString(PyExc_TypeError,\"C variable '"
- << iname << "'(" << t->print_type() << ")\");\n"
- << tab8 << "return 1; \n"
- << tab4 << "}\n"
- << tab4 << name << " = tval;\n";
- break;
-
- case T_FLOAT: case T_DOUBLE:
- // Get a floating point value
- setf.add_local(t->print_type(), "tval");
- setf.code << tab4 << "tval = " << t->print_cast() << "PyFloat_AsDouble(val);\n"
- << tab4 << "if (PyErr_Occurred()) {\n"
- << tab8 << "PyErr_SetString(PyExc_TypeError,\"C variable '"
- << iname << "'(" << t->print_type() << ")\");\n"
- << tab8 << "return 1; \n"
- << tab4 << "}\n"
- << tab4 << name << " = tval;\n";
- break;
-
- // A single ascii character
-
- case T_CHAR:
- setf.add_local("char *", "tval");
- setf.code << tab4 << "tval = (char *) PyString_AsString(val);\n"
- << tab4 << "if (PyErr_Occurred()) {\n"
- << tab8 << "PyErr_SetString(PyExc_TypeError,\"C variable '"
- << iname << "'(" << t->print_type() << ")\");\n"
- << tab8 << "return 1; \n"
- << tab4 << "}\n"
- << tab4 << name << " = *tval;\n";
- break;
- case T_USER:
- t->is_pointer++;
- setf.add_local(t->print_type(),"temp");
- get_pointer(iname,"value","val","temp",t,setf.code,"1");
- setf.code << tab4 << name << " = *temp;\n";
- t->is_pointer--;
- break;
- default:
- fprintf(stderr,"%s : Line %d. Unable to link with type %s.\n", input_file, line_number, t->print_type());
- }
- } else {
-
- // Parse a pointer value
-
- if ((t->type == T_CHAR) && (t->is_pointer == 1)) {
- setf.add_local("char *", "tval");
- setf.code << tab4 << "tval = (char *) PyString_AsString(val);\n"
- << tab4 << "if (PyErr_Occurred()) {\n"
- << tab8 << "PyErr_SetString(PyExc_TypeError,\"C variable '"
- << iname << "'(" << t->print_type() << ")\");\n"
- << tab8 << "return 1; \n"
- << tab4 << "}\n";
-
- if (CPlusPlus) {
- setf.code << tab4 << "if (" << name << ") delete [] " << name << ";\n"
- << tab4 << name << " = new char[strlen(tval)+1];\n"
- << tab4 << "strcpy((char *)" << name << ",tval);\n";
- } else {
- setf.code << tab4 << "if (" << name << ") free(" << name << ");\n"
- << tab4 << name << " = (char *) malloc(strlen(tval)+1);\n"
- << tab4 << "strcpy((char *)" << name << ",tval);\n";
- }
- } else {
-
- // Is a generic pointer value.
-
- setf.add_local(t->print_type(),"temp");
- get_pointer(iname,"value","val","temp",t,setf.code,"1");
- setf.code << tab4 << name << " = temp;\n";
- }
- }
- }
- }
- setf.code << tab4 << "return 0;\n";
- } else {
- // Is a readonly variable. Issue an error
- setf.code << tab4 << "PyErr_SetString(PyExc_TypeError,\"Variable " << iname
- << " is read-only.\");\n"
- << tab4 << "return 1;\n";
- }
-
- setf.code << "}\n";
-
- // Dump out function for setting value
-
- setf.print(f_wrappers);
-
- // ----------------------------------------------------------------
- // Create a function for getting the value of a variable
- // ----------------------------------------------------------------
-
- getf.def << "static PyObject *" << wname << "_get() {";
- getf.add_local("PyObject *","pyobj");
- if ((tm = typemap_lookup("varout","python",t,name,name,"pyobj"))) {
- getf.code << tm << "\n";
- getf.code.replace("$name",iname);
- } else if ((tm = typemap_lookup("out","python",t,name,name,"pyobj"))) {
- getf.code << tm << "\n";
- getf.code.replace("$name",iname);
- } else {
- if ((t->type != T_VOID) || (t->is_pointer)) {
- if (!t->is_pointer) {
-
- /* Is a normal datatype */
- switch(t->type) {
- case T_INT: case T_SINT: case T_UINT:
- case T_SHORT: case T_SSHORT: case T_USHORT:
- case T_LONG: case T_SLONG: case T_ULONG:
- case T_SCHAR: case T_UCHAR: case T_BOOL:
- getf.code << tab4 << "pyobj = PyInt_FromLong((long) " << name << ");\n";
- break;
- case T_FLOAT: case T_DOUBLE:
- getf.code << tab4 << "pyobj = PyFloat_FromDouble((double) " << name << ");\n";
- break;
- case T_CHAR:
- getf.add_local("char","ptemp[2]");
- getf.code << tab4 << "ptemp[0] = " << name << ";\n"
- << tab4 << "ptemp[1] = 0;\n"
- << tab4 << "pyobj = PyString_FromString(ptemp);\n";
- break;
- case T_USER:
- // Hack this into a pointer
- getf.add_local("char", "ptemp[128]");
- t->is_pointer++;
- getf.code << tab4 << "SWIG_MakePtr(ptemp,(char *) &" << name
- << "," << quote << t->print_mangle() << quote << ");\n"
- << tab4 << "pyobj = PyString_FromString(ptemp);\n";
- t->is_pointer--;
- break;
- default:
- fprintf(stderr,"Unable to link with type %s\n", t->print_type());
- break;
- }
- } else {
-
- // Is some sort of pointer value
- if ((t->type == T_CHAR) && (t->is_pointer == 1)) {
- getf.code << tab4 << "if (" << name << ")\n"
- << tab8 << "pyobj = PyString_FromString(" << name << ");\n"
- << tab4 << "else pyobj = PyString_FromString(\"(NULL)\");\n";
- } else {
- getf.add_local("char","ptemp[128]");
- getf.code << tab4 << "SWIG_MakePtr(ptemp, (char *) " << name << ",\""
- << t->print_mangle() << "\");\n"
- << tab4 << "pyobj = PyString_FromString(ptemp);\n";
- }
- }
- }
- }
-
- getf.code << tab4 << "return pyobj;\n"
- << "}\n";
-
- getf.print(f_wrappers);
-
- // Now add this to the variable linking mechanism
-
- fprintf(f_init,"\t SWIG_addvarlink(SWIG_globals,\"%s\",%s_get, %s_set);\n", iname, wname, wname);
-
-
- // Fill in the documentation entry
-
- if (doc_entry) {
- doc_entry->usage << usage_var(iname, t);
- doc_entry->cinfo << "Global : " << t->print_type() << " " << name;
- }
-
- // ----------------------------------------------------------
- // Output a shadow variable. (If applicable and possible)
- // ----------------------------------------------------------
- if ((shadow) && (!(shadow & PYSHADOW_MEMBER))) {
- if ((hash.lookup(t->name)) && (t->is_pointer <= 1)) {
- vars << iname << " = " << (char *) hash.lookup(t->name) << "Ptr(" << module << "." << global_name
- << "." << iname << ")\n";
- }
- }
-}
-
-// -----------------------------------------------------------------------
-// PYTHON::declare_const(char *name, char *iname, DataType *type, char *value)
-//
-// Makes a constant as defined with #define. Constants are added to the
-// module's dictionary and are **NOT** guaranteed to be read-only,
-// sorry.
-//
-// ------------------------------------------------------------------------
-
-void PYTHON::declare_const(char *name, char *, DataType *type, char *value) {
-
- char *tm;
-
- // Make a static python object
-
- if ((tm = typemap_lookup("const","python",type,name,value,name))) {
- fprintf(f_init,"%s\n",tm);
- } else {
-
- if ((type->type == T_USER) && (!type->is_pointer)) {
- fprintf(stderr,"%s : Line %d. Unsupported constant value.\n", input_file, line_number);
- return;
- }
-
- if (type->is_pointer == 0) {
- switch(type->type) {
- case T_INT:case T_SINT: case T_UINT: case T_BOOL:
- case T_SHORT: case T_SSHORT: case T_USHORT:
- case T_LONG: case T_SLONG: case T_ULONG:
- case T_SCHAR: case T_UCHAR:
- fprintf(f_init,"\t PyDict_SetItemString(d,\"%s\", PyInt_FromLong((long) %s));\n",name,value);
- break;
- case T_DOUBLE:
- case T_FLOAT:
- fprintf(f_init,"\t PyDict_SetItemString(d,\"%s\", PyFloat_FromDouble((double) %s));\n",name,value);
- break;
- case T_CHAR :
- fprintf(f_init,"\t PyDict_SetItemString(d,\"%s\", PyString_FromString(\"%s\"));\n",name,value);
- break;
- default:
- fprintf(stderr,"%s : Line %d. Unsupported constant value.\n", input_file, line_number);
- break;
- }
- } else {
- if ((type->type == T_CHAR) && (type->is_pointer == 1)) {
- fprintf(f_init,"\t PyDict_SetItemString(d,\"%s\", PyString_FromString(\"%s\"));\n",name,value);
- } else {
- // A funky user-defined type. We're going to munge it into a string pointer value
- fprintf(f_init,"\t {\n");
- fprintf(f_init,"\t\t char %s_char[%d];\n", name, (int) strlen(type->print_mangle()) + 20);
- fprintf(f_init,"\t\t SWIG_MakePtr(%s_char, (void *) (%s),\"%s\");\n",
- name, value, type->print_mangle());
- fprintf(f_init,"\t\t PyDict_SetItemString(d,\"%s\", PyString_FromString(%s_char));\n",name,name);
- fprintf(f_init,"\t }\n");
- }
- }
- }
- if ((shadow) && (!(shadow & PYSHADOW_MEMBER))) {
- vars << name << " = " << module << "." << name << "\n";
- }
- if (doc_entry) {
- doc_entry->usage = "";
- doc_entry->usage << usage_const(name,type,value);
- doc_entry->cinfo = "";
- doc_entry->cinfo << "Constant: " << type->print_type();
- }
-}
-
-// ----------------------------------------------------------------------
-// PYTHON::usage_var(char *iname, DataType *t)
-//
-// This function produces a string indicating how to use a variable.
-// It is called by the documentation system to produce syntactically
-// correct documentation entires.
-//
-// s is a pointer to a character pointer. You should create
-// a string and set this pointer to point to it.
-// ----------------------------------------------------------------------
-
-char *PYTHON::usage_var(char *iname, DataType *) {
-
- static String temp;
-
- temp = "";
- temp << global_name << "." << iname;
-
- // Create result. Don't modify this
-
- return temp.get();
-}
-
-// ---------------------------------------------------------------------------
-// PYTHON::usage_func(char *iname, DataType *t, ParmList *l)
-//
-// Produces a string indicating how to call a function in the target
-// language.
-//
-// ---------------------------------------------------------------------------
-
-char *PYTHON::usage_func(char *iname, DataType *, ParmList *l) {
-
- static String temp;
- Parm *p;
- int i;
-
- temp = "";
- temp << iname << "(";
-
- // Now go through and print parameters
- // You probably don't need to change this
-
- i = 0;
- p = l->get_first();
- while (p != 0) {
- if (!p->ignore) {
- i++;
- /* If parameter has been named, use that. Otherwise, just print a type */
-
- if ((p->t->type != T_VOID) || (p->t->is_pointer)) {
- if (strlen(p->name) > 0) {
- temp << p->name;
- } else {
- temp << p->t->print_type();
- }
- }
- p = l->get_next();
- if (p != 0) {
- if (!p->ignore)
- temp << ",";
- }
- } else {
- p = l->get_next();
- if (p) {
- if ((!p->ignore) && (i > 0))
- temp << ",";
- }
- }
- }
-
- temp << ")";
-
- // Create result. Don't change this
-
- return temp.get();
-
-}
-
-
-// ----------------------------------------------------------------------
-// PYTHON::usage_const(char *iname, DataType *type, char *value)
-//
-// Produces a string for a constant. Really about the same as
-// usage_var() except we'll indicate the value of the constant.
-// ----------------------------------------------------------------------
-
-char *PYTHON::usage_const(char *iname, DataType *, char *value) {
-
- static String temp;
- temp = "";
- temp << iname << " = " << value;
-
- return temp.get();
-}
-
-// -----------------------------------------------------------------------
-// PYTHON::add_native(char *name, char *funcname)
-//
-// Add a native module name to the methods list.
-// -----------------------------------------------------------------------
-
-void PYTHON::add_native(char *name, char *funcname) {
- add_method(name, funcname);
- if (shadow) {
- func << name << " = " << module << "." << name << "\n\n";
- }
-}
-
-// -----------------------------------------------------------------------
-// PYTHON::cpp_class_decl(char *name, char *rename, char *type)
-//
-// Treatment of an empty class definition. Used to handle
-// shadow classes across modules.
-// -----------------------------------------------------------------------
-
-void PYTHON::cpp_class_decl(char *name, char *rename, char *type) {
- char temp[256];
- if (shadow) {
- hash.add(name,copy_string(rename));
- // Add full name of datatype to the hash table
- if (strlen(type) > 0) {
- sprintf(temp,"%s %s", type, name);
- hash.add(temp,copy_string(rename));
- }
- }
-}
-
-// -----------------------------------------------------------------------
-// PYTHON::pragma(char *name, char *type)
-//
-// Pragma directive. Used to do various python specific things
-// -----------------------------------------------------------------------
-
-void PYTHON::pragma(char *lang, char *cmd, char *value) {
-
- if (strcmp(lang,"python") == 0) {
- if (strcmp(cmd,"CODE") == 0) {
- if (shadow) {
- fprintf(f_shadow,"%s\n",value);
- }
- } else if (strcmp(cmd,"code") == 0) {
- if (shadow) {
- fprintf(f_shadow,"%s\n",value);
- }
- } else if (strcmp(cmd,"include") == 0) {
- if (shadow) {
- if (value) {
- if (get_file(value,pragma_include) == -1) {
- fprintf(stderr,"%s : Line %d. Unable to locate file %s\n", input_file, line_number, value);
- }
- }
- }
- } else {
- fprintf(stderr,"%s : Line %d. Unrecognized pragma.\n", input_file, line_number);
- }
- }
-}
-
-
-struct PyPragma {
- PyPragma(char *method, char *text) : m_method(method), m_text(text), next(0) { }
- ~PyPragma() { if (next) delete next; }
- String m_method;
- String m_text;
- PyPragma *next;
-};
-
-static PyPragma *pragmas = 0;
-
-// -----------------------------------------------------------------------------
-// PYTHON::cpp_pragma(Pragma *plist)
-//
-// Handle C++ pragmas
-// -----------------------------------------------------------------------------
-
-void PYTHON::cpp_pragma(Pragma *plist) {
- PyPragma *pyp1 = 0, *pyp2 = 0;
- if (pragmas) {
- delete pragmas;
- pragmas = 0;
- }
- while (plist) {
- if (strcmp(plist->lang,"python") == 0) {
- if (strcmp(plist->name,"addtomethod") == 0) {
- // parse value, expected to be in the form "methodName:line"
- String temp = plist->value;
- char* txtptr = strchr(temp.get(), ':');
- if (txtptr) {
- // add name and line to a list in current_class
- *txtptr = 0;
- txtptr++;
- pyp1 = new PyPragma(temp,txtptr);
- if (pyp2) {
- pyp2->next = pyp1;
- pyp2 = pyp1;
- } else {
- pragmas = pyp1;
- pyp2 = pragmas;
- }
- } else {
- fprintf(stderr,"%s : Line %d. Malformed addtomethod pragma. Should be \"methodName:text\"\n",
- plist->filename.get(),plist->lineno);
- }
- } else if (strcmp(plist->name, "addtoclass") == 0) {
- pyp1 = new PyPragma("__class__",plist->value);
- if (pyp2) {
- pyp2->next = pyp1;
- pyp2 = pyp1;
- } else {
- pragmas = pyp1;
- pyp2 = pragmas;
- }
- }
- }
- plist = plist->next;
- }
-}
-
-// --------------------------------------------------------------------------------
-// PYTHON::emitAddPragmas(String& output, char* name, char* spacing);
-//
-// Search the current class pragma for any text belonging to name.
-// Append the text properly spaced to the output string.
-// --------------------------------------------------------------------------------
-
-void PYTHON::emitAddPragmas(String& output, char* name, char* spacing)
-{
- PyPragma *p = pragmas;
- while (p) {
- if (strcmp(p->m_method,name) == 0) {
- output << spacing << p->m_text << "\n";
- }
- p = p->next;
- }
-}
projects / wxWidgets.git / blobdiff