the Russian translations were somehow corrupted, fixed

[wxWidgets.git] / wxPython / wxSWIG / Modules / python.cxx

/*******************************************************************************
 * 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

  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 = apply(" << 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;
  }
}