+++ /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.
- *******************************************************************************/
-
-#include "internal.h"
-
-/*******************************************************************************
- * $Header$
- *
- * File : cplus.cxx
- *
- * This module defines parser entry points for supporting C++. Primarily
- * this module is in charge of keeping track of the contents of C++ classes,
- * organizing inheritance, and other things.
- *
- * Eventually this module will be merged with the type handling mechanism
- * in SWIG 2.0 so it's a little messy right now.
- *
- * General comments :
- *
- * 1. The words "simple" and "C++" are rarely used in the same
- * sentence. Therefore this module is going to be some sort
- * of compromise.
- *
- * 2. I'm using the "Annotated C++ Reference Manual" (ARM) as my
- * reference for handling certain cases. Of course, there
- * is a high probability that I have misinterpreted or overlooked
- * certain cases.
- *
- * 3. It is not my intent to write a full C++ compiler.
- *
- * My goals are simple :
- * - Support simple ANSI C-like class member functions and data.
- * - Support constructors and destructors.
- * - static member functions.
- * - basic inheritance.
- * - virtual functions.
- * - References
- *
- * I do not plan to support the following anytime in the near future
- * - Operator overloading
- * - templates
- *
- * Caution :
- *
- * The control flow in this module is completely insane. But here's the
- * rough outline.
- *
- * Stage 1 : SWIG Parsing
- * cplus_open_class() - Open up a new class
- * cplus_* - Add members to class
- * cplus_inherit() - Inherit from base classes
- * cplus_class_close() - Close class
- *
- * ...
- * cplus_open_class()
- * ...
- * cplus_class_close()
- *
- * ... and so on, until the end of the file
- *
- * After stage 1, all classes have been read, but nothing has been
- * sent to the language module yet.
- *
- * Stage 2 : Code generation
- * For each class we've saved, do this :
- * lang->cpp_open_class() - Open class
- * lang->cpp_* - Emit members
- * lang->cpp_inherit() - Inherit
- * lang->cpp_close_class() - Close class
- *
- * This two-stage approach solves a number of problems related to working
- * with multiple files, mutually referenced classes, add adding methods.
- * Just keep in mind that all C++ code is emitted *after* an entire SWIG
- * file has been parsed.
- *
- * Improved code generation and inheritance of added methods (2/18/97):
- *
- * Each C++ declaration now has an associated function name attached to it.
- * For example :
- *
- * class Foo {
- * void bar();
- * }
- *
- * Generates a member function "bar()" with a accessor function named
- * "Foo_bar()". We will use this recorded accessor function to generate
- * better code for inheritance. For example :
- *
- * class Foo2 : public Foo {
- *
- * ...
- * }
- *
- * Will create a function called "Foo2_bar()" that is really mapped
- * onto the base-class method "Foo_bar()". This should improve
- * code generation substantially.
- *
- * Tricky stuff :
- * - Each target language is responsible for naming wrapper
- * functions.
- *
- *******************************************************************************/
-
-// Some status variables
-
-static int Inherit_mode = 0; // Set if we're inheriting members
-static char *ccode = 0; // Set to optional C code (if available)
-static Hash *localtypes; // Localtype hash
-static int abstract =0; // Status bit set during code generation
-
-static int cpp_id = 0;
-
-// Forward references
-
-void cplus_member_func(char *, char *, DataType *, ParmList *, int);
-void cplus_constructor(char *, char *, ParmList *);
-void cplus_destructor(char *, char *);
-void cplus_variable(char *, char *, DataType *);
-void cplus_static_func(char *, char *, DataType *, ParmList *);
-void cplus_declare_const(char *, char *, DataType *, char *);
-void cplus_static_var(char *, char *, DataType *);
-void cplus_inherit_decl(char **);
-
-// -----------------------------------------------------------------------------
-// void add_local_type(char *type, char *classname)
-// void add_local_type(DataType *type, char *classname)
-//
-// Adds a new datatype to the local datatype hash. This is used to handle
-// datatypes defined within a class.
-//
-// Inputs : Datatype to place in hash
-//
-// Output : None
-//
-// Side Effects : Updates localtypes hash.
-// -----------------------------------------------------------------------------
-
-static void add_local_type(char *type, char *classname) {
- String str;
-
- if (!localtypes) return; // No hash table initialized, ignore this
-
- str << classname << "::" << type;
- localtypes->add(type,copy_string(str));
-}
-
-void add_local_type(DataType *type, char *classname) {
- add_local_type(type->name,classname);
-}
-
-// -----------------------------------------------------------------------------
-// void update_local_type(DataType *type)
-//
-// Checks to see whether this datatype is part of a class definition. If so,
-// we update the type-name by appending the class prefix to it. Uses the
-// name stored in current_class unless unavailable.
-//
-// Inputs : type = Datatype
-//
-// Output : type is updated with a new name.
-//
-// Side Effects : None
-// -----------------------------------------------------------------------------
-
-static void update_local_type(DataType *type) {
-
- char *newname = 0;
-
- // Lookup the datatype in the hash table
-
- if (!localtypes) return;
-
- newname = (char *) localtypes->lookup(type->name);
- if (newname) {
- strcpy(type->name, newname);
- }
-}
-
-// -----------------------------------------------------------------------------
-// void update_parms(ParmList *l)
-//
-// Updates all of the parameters in a parameter list with the proper C++ prefix
-// (if neccessary).
-//
-// Inputs : l = Parameter list
-//
-// Output : Parameter list l is updated (make sure its a copy!)
-//
-// Side Effects : None
-// -----------------------------------------------------------------------------
-
-static void update_parms(ParmList *l) {
- Parm *p;
- p = l->get_first();
- while (p) {
- update_local_type(p->t);
-
- // Check for default arguments
-
- if ((p->defvalue) && (localtypes)) {
- char *s;
- s = (char *) localtypes->lookup(p->defvalue);
- if (s) {
- delete p->defvalue;
- p->defvalue = copy_string(s);
- }
- }
- p = l->get_next();
- }
-}
-
-// -----------------------------------------------------------------------
-// class CPP_member
-//
-// Base class for various kinds of C++ members
-// -----------------------------------------------------------------------
-class CPP_member {
-public:
- char *name; // Name of the member
- char *iname; // Name of member in the interpreter
- int is_static; // Is this a static member?
- int new_method; // Is this a new method (added by SWIG)?
- int line; // What line number was this member on
- char *file; // What file was this in?
- char *code; // Was there any supplied code?
- char *base; // Base class where this was defined
- int inherited; // Was this member inherited?
- DocEntry *de; // Documentation entry
- CPP_member *next; // Next member (for building linked lists)
- int id; // type id when created
-
- virtual void inherit(int) { }; // Inheritance rule (optional)
- virtual void emit() = 0; // Emit rule
-};
-
-// ----------------------------------------------------------------------
-// class CPP_function : public CPP_member
-//
-// Structure for handling a C++ member function
-// ----------------------------------------------------------------------
-
-class CPP_function : public CPP_member {
-public:
- DataType *ret_type;
- ParmList *parms;
- int new_object;
- int is_virtual;
-
- CPP_function(char *n, char *i, DataType *t, ParmList *l, int s, int v = 0) {
- name = copy_string(n);
- iname = copy_string(i);
- ret_type = new DataType(t);
- parms = new ParmList(l);
- is_static = s;
- is_virtual = v;
- new_method = AddMethods;
- new_object = NewObject;
- inherited = Inherit_mode;
- de = 0;
- next = 0;
- line = line_number;
- file = input_file;
- if (Inherit_mode) {
- id = cpp_id;
- } else {
- id = type_id;
- }
- if (AddMethods) {
- if (strlen(CCode.get()))
- code = copy_string(CCode.get());
- else
- code = 0;
- } else {
- code = 0;
- }
- }
- void inherit(int mode) {
- doc_entry = 0; // No documentation for an inherited member
- if (mode & INHERIT_FUNC) {
- // Set up the proper addmethods mode and provide C code (if provided)
- int oldaddmethods = AddMethods;
- int oldnewobject = NewObject;
- AddMethods = new_method;
- NewObject = new_object;
- CCode = code;
- if (is_static) {
- cplus_static_func(name, iname, ret_type, parms);
- } else {
- cplus_member_func(name, iname, ret_type, parms, is_virtual);
- }
- AddMethods = oldaddmethods;
- NewObject = oldnewobject;
- CCode = "";
- }
- }
- void emit() {
- ParmList *l;
- DataType *t;
- AddMethods = new_method;
- NewObject = new_object;
- doc_entry = de; // Restore documentation entry
- line_number = line; // Restore line and file
- input_file = file;
- ccode = code;
-
- // Make a copy of the parameter list and upgrade its types
-
- l = new ParmList(parms);
- t = new DataType(ret_type);
- update_parms(l);
- update_local_type(t);
- if (is_static) {
- lang->cpp_static_func(name, iname, t, l);
- } else {
- lang->cpp_member_func(name, iname, t, l);
- }
- l->check_defined();
- t->check_defined();
- delete l;
- delete t;
- }
-};
-
-// --------------------------------------------------------------------------
-// class CPP_constructor : public CPP_member
-//
-// Class for holding a C++ constructor definition.
-// --------------------------------------------------------------------------
-
-class CPP_constructor : public CPP_member {
-public:
- ParmList *parms;
- CPP_constructor(char *n, char *i, ParmList *l) {
- name = copy_string(n);
- iname = copy_string(i);
- parms = new ParmList(l);
- new_method = AddMethods;
- inherited = 0;
- de = 0;
- next = 0;
- line = line_number;
- file = input_file;
- id = type_id;
- if (AddMethods) {
- if (strlen(CCode.get()))
- code = copy_string(CCode.get());
- else
- code = 0;
- } else {
- code = 0;
- }
- }
- void emit() {
- if (1) {
- ParmList *l;
- AddMethods = new_method;
- doc_entry = de;
- line_number = line;
- input_file = file;
- ccode = code;
-
- // Make a copy of the parameter list and upgrade its types
-
- l = new ParmList(parms);
- update_parms(l);
- lang->cpp_constructor(name,iname,l);
- l->check_defined();
- delete l;
- } else {
- if (Verbose) {
- fprintf(stderr,"%s:%d: Constructor for abstract base class ignored.\n",
- file,line);
- }
- }
- }
-};
-
-
-// --------------------------------------------------------------------------
-// class CPP_destructor : public CPP_member
-//
-// Class for holding a destructor definition
-// --------------------------------------------------------------------------
-
-class CPP_destructor : public CPP_member {
-public:
-
- CPP_destructor(char *n, char *i) {
- name = copy_string(n);
- iname = copy_string(i);
- new_method = AddMethods;
- de = 0;
- next = 0;
- inherited = 0;
- line = line_number;
- file = input_file;
- id = type_id;
- if (AddMethods) {
- if (strlen(CCode.get()))
- code = copy_string(CCode.get());
- else
- code = 0;
- } else {
- code = 0;
- }
-
- }
- void emit() {
- AddMethods = new_method;
- doc_entry = de;
- line_number = line;
- input_file = file;
- ccode = code;
- lang->cpp_destructor(name, iname);
- }
-};
-
-// -------------------------------------------------------------------------
-// class CPP_variable : public CPP_member
-//
-// Class for a managing a data member
-// -------------------------------------------------------------------------
-
-class CPP_variable : public CPP_member {
-public:
- DataType *type;
- int status;
- CPP_variable(char *n, char *i, DataType *t, int s) {
- name = copy_string(n);
- iname = copy_string(i);
- type = new DataType(t);
- is_static = s;
- status = Status;
- de = 0;
- next = 0;
- new_method = AddMethods;
- line = line_number;
- file = input_file;
- if (Inherit_mode) {
- id = cpp_id;
- } else {
- id = type_id;
- }
- code = 0;
- inherited = 0;
- }
-
- // Emit code for this
-
- void emit() {
- DataType *t;
- int old_status = Status;
- doc_entry = de;
- AddMethods = new_method;
- Status = status;
- line_number = line;
- input_file = file;
- ccode = code;
-
- t = new DataType(type);
- if (t->qualifier) {
- // if (strcmp(t->qualifier,"const") == 0) Status = Status | STAT_READONLY;
- }
- update_local_type(t);
- if (!is_static) {
- lang->cpp_variable(name,iname,t);
- } else {
- lang->cpp_static_var(name,iname,t);
- }
- t->check_defined();
- Status = old_status;
- delete t;
- }
-
- // Inherit into another class
-
- void inherit(int mode) {
- int oldstatus = Status;
- Status = status;
- doc_entry = 0;
- if (mode & INHERIT_VAR) {
- if (!is_static) {
- int oldaddmethods = AddMethods;
- AddMethods = new_method;
- CCode = code;
- cplus_variable(name,iname,type);
- AddMethods = oldaddmethods;
- CCode = "";
- } else {
- cplus_static_var(name,iname,type);
- }
- }
- Status = oldstatus;
- }
-};
-
-// -------------------------------------------------------------------------
-// class CPP_constant : public CPP_member
-//
-// Class for managing constant values
-// -------------------------------------------------------------------------
-
-class CPP_constant : public CPP_member {
-public:
- char *value;
- DataType *type;
- CPP_constant(char *n, char *i, DataType *t, char *v) {
- name = copy_string(n);
- iname = copy_string(i);
- type = new DataType(t);
- value = copy_string(v);
- de = 0;
- new_method = AddMethods;
- next = 0;
- line = line_number;
- file = input_file;
- if (Inherit_mode)
- id = cpp_id;
- else
- id = type_id;
- code = 0;
- inherited = 0;
- }
-
- void emit() {
- doc_entry = de;
- AddMethods = new_method;
- line_number = line;
- input_file = file;
- ccode = code;
- lang->cpp_declare_const(name,iname,type,value);
- type->check_defined();
- }
-
- void inherit(int mode) {
- doc_entry = 0;
- if (mode & INHERIT_CONST)
- cplus_declare_const(name, iname, type, value);
- }
-};
-
-// ----------------------------------------------------------------------
-// class CPP_class
-//
-// Class for managing class members (internally)
-// ----------------------------------------------------------------------
-
-static char *inherit_base_class = 0;
-
-class CPP_class {
-public:
- char *classname; // Real class name
- char *classrename; // New name of class (if applicable)
- char *classtype; // class type (struct, union, class)
- int strip; // Strip off class declarator
- int wextern; // Value of extern wrapper variable for this class
- int have_constructor; // Status bit indicating if we've seen a constructor
- int have_destructor; // Status bit indicating if a destructor has been seen
- int is_abstract; // Status bit indicating if this is an abstract class
- int generate_default; // Generate default constructors
- int objective_c; // Set if this is an objective C class
- int error; // Set if this class can't be generated
- int line; // Line number
- char **baseclass; // Base classes (if any)
- Hash *local; // Hash table for local types
- Hash *scope; // Local scope hash table
- DocEntry *de; // Documentation entry of class
- CPP_member *members; // Linked list of members
- CPP_class *next; // Next class
- static CPP_class *classlist; // List of all classes stored
- Pragma *pragmas; // Class pragmas
-
- CPP_class(char *name, char *ctype) {
- CPP_class *c;
- classname = copy_string(name);
- classtype = copy_string(ctype);
- classrename = 0;
- baseclass = 0;
- de = doc_entry;
- local = new Hash; // Create hash table for storing local datatypes
- scope = 0;
- error = 0;
- pragmas = 0;
- line = line_number;
-
- // Walk down class list and add to end
-
- c = classlist;
- if (c) {
- while (c->next) {
- c = c->next;
- }
- c->next = this;
- } else {
- classlist = this;
- }
- next = 0;
- members = 0;
- strip = 0;
- wextern = WrapExtern;
- have_constructor = 0;
- have_destructor = 0;
- is_abstract = 0;
- generate_default = GenerateDefault;
- objective_c = ObjCClass;
- }
-
- // ------------------------------------------------------------------------------
- // Add a new C++ member to this class
- // ------------------------------------------------------------------------------
-
- void add_member(CPP_member *m) {
- CPP_member *cm;
-
- // Set base class where this was defined
- if (inherit_base_class)
- m->base = inherit_base_class;
- else
- m->base = classname;
- if (!members) {
- members = m;
- return;
- }
- cm = members;
- while (cm->next) {
- cm = cm->next;
- }
- cm->next = m;
- }
- // ------------------------------------------------------------------------------
- // Search for a member with the given name. Returns the member on success, 0 on failure
- // ------------------------------------------------------------------------------
-
- CPP_member *search_member(char *name) {
- CPP_member *m;
- char *c;
- m = members;
- while (m) {
- c = m->iname ? m->iname : m->name;
- if (strcmp(c,name) == 0) return m;
- m = m->next;
- }
- return 0;
- }
-
- // ------------------------------------------------------------------------------
- // Inherit. Put all the declarations associated with this class into the current
- // ------------------------------------------------------------------------------
-
- void inherit_decls(int mode) {
- CPP_member *m;
- m = members;
- while (m) {
- inherit_base_class = m->base;
- cpp_id = m->id;
- m->inherit(mode);
- m = m->next;
- }
- inherit_base_class = 0;
- }
-
- // ------------------------------------------------------------------------------
- // Emit all of the declarations associated with this class
- // ------------------------------------------------------------------------------
-
- void emit_decls() {
- CPP_member *m = members;
- int last_scope = name_scope(0);
- abstract = is_abstract;
- while (m) {
- cpp_id = m->id;
- name_scope(cpp_id); // Set proper naming scope
- m->emit();
- m = m->next;
- }
- name_scope(last_scope);
- }
-
- // ------------------------------------------------------------------------------
- // Search for a given class in the list
- // ------------------------------------------------------------------------------
-
- static CPP_class *search(char *name) {
- CPP_class *c;
- c = classlist;
- if (!name) return 0;
- while (c) {
- if (strcmp(name,c->classname) == 0) return c;
- c = c->next;
- }
- return 0;
- }
-
- // ------------------------------------------------------------------------------
- // Add default constructors and destructors
- //
- // ------------------------------------------------------------------------------
-
- void create_default() {
- if (!generate_default) return;
-
- // Try to generate a constructor if not available.
- CCode = "";
- AddMethods = 0;
- if ((!have_constructor) && (1)) {
- ParmList *l;
- l = new ParmList();
- doc_entry = new DocDecl(classname,this->de);
- cplus_constructor(classname,0,l);
- };
-
- if (!have_destructor) {
- doc_entry = new DocDecl(classname,this->de);
- cplus_destructor(classname,0);
- }
- }
-
- // ------------------------------------------------------------------------------
- // Dump *all* of the classes saved out to the various
- // language modules (this does what cplus_close_class used to do)
- // ------------------------------------------------------------------------------
- static void create_all();
-};
-
-CPP_class *CPP_class::classlist = 0;
-static CPP_class *current_class;
-
-void CPP_class::create_all() {
- CPP_class *c;
- c = classlist;
- while (c) {
- if (!c->error) {
- current_class = c;
- localtypes = c->local;
- if ((!c->wextern) && (c->classtype)) {
- ObjCClass = c->objective_c;
- doc_entry = c->de;
- lang->cpp_open_class(c->classname,c->classrename,c->classtype,c->strip);
- lang->cpp_pragma(c->pragmas);
- c->create_default();
- if (c->baseclass)
- cplus_inherit_decl(c->baseclass);
- c->emit_decls();
- doc_entry = c->de;
- lang->cpp_close_class();
- }
- }
- c = c->next;
- }
-}
-
-// -----------------------------------------------------------------------------
-// char *cplus_base_class(char *name)
-//
-// Given a member name, return the base class that it belongs to.
-// -----------------------------------------------------------------------------
-
-char *cplus_base_class(char *name) {
- CPP_member *m = current_class->search_member(name);
- if (m) {
- return m->base;
- }
- return 0;
-}
-
-// -----------------------------------------------------------------------------
-// void cplus_open_class(char *name, char *rname, char *ctype)
-//
-// Opens up a new C++ class. If rname is given, we'll be renaming the
-// class. This also sets up some basic type equivalence for the
-// type checker.
-//
-// Inputs :
-// name = Name of the class
-// rname = New name of the class (using %name() directive)
-// ctype = Class type ("class","struct", or "union")
-//
-// Output : None
-//
-// Side Effects :
-// Creates a new class obect internally.
-// Added type-mappings to the SWIG type-checker module.
-// Sets a number of internal state variables for later use.
-//
-// -----------------------------------------------------------------------------
-
-void cplus_open_class(char *name, char *rname, char *ctype) {
-
- extern void typeeq_derived(char *, char *, char *cast=0);
- char temp[256];
- CPP_class *c;
-
- // Add some symbol table management here
-
- // Search for a previous class definition
-
- c = CPP_class::search(name);
- if (c) {
- if (c->classtype) {
- // Hmmm. We already seem to have defined this class so we'll
- // create a new class object for whatever reason
- current_class = new CPP_class(name, ctype);
- } else {
- // Looks like a reference was made to this class earlier
- // somehow, but no other information is known. We'll
- // make it our current class and fix it up a bit
- current_class = c;
- c->classtype = copy_string(ctype);
- }
- } else {
- // Create a new class
- current_class = new CPP_class(name, ctype);
- current_class->de = doc_entry;
- }
-
- // Set localtypes hash to our current class
-
- localtypes = current_class->local;
-
- // If renaming the class, set the new name
-
- if (rname) {
- current_class->classrename = copy_string(rname);
- }
-
- // Make a typedef for both long and short versions of this datatype
-
- if (name) {
- if (strlen(name)) {
- if (strlen(ctype) > 0 && strcmp(ctype, "class") != 0) {
- sprintf(temp,"%s %s", ctype, name);
- typeeq_derived(temp,name); // Map "struct foo" to "foo"
- typeeq_derived(name,temp); // Map "foo" to "struct foo"
- }
- }
- }
-
- AddMethods = 0; // Reset add methods flag
-
-}
-
-// -----------------------------------------------------------------------------
-// DocEntry *cplus_set_class(char *name)
-//
-// This function sets the current class to a given name. If the class
-// doesn't exist, this function will create one. If it already exists,
-// we'll just use that.
-//
-// This function is used primarily to add or manipulate an already
-// existing class, but in a different location. For example :
-//
-// %include "class.h" // Grab some classes
-// ...
-// %addmethods MyClass { // Add some members for shadow classes
-// ... members ...
-// }
-//
-// Sounds weird, but returns the documentation entry to class if it exists.
-// The parser needs this so we can generate documentation correctly.
-//
-// Inputs : name = Name of the class
-//
-// Output : Documentation entry of class or NULL if it doesn't exist.
-// The parser needs the documentation entry to properly associate
-// new members.
-//
-// Side Effects :
-// Changes the current class object. Resets a number of internal
-// state variables. Should not be called inside of a open class
-// declaration.
-// -----------------------------------------------------------------------------
-
-DocEntry *cplus_set_class(char *name) {
-
- CPP_class *c;
-
- // Look for a previous class definition
-
- c = CPP_class::search(name);
- if (c) {
- current_class = c;
- localtypes = c->local;
- return c->de;
- } else {
- fprintf(stderr,"%s:%d: Warning class %s undefined.\n",input_file,line_number,name);
- current_class = new CPP_class(name,0);
- localtypes = current_class->local;
- return 0;
- }
-};
-
-// This function closes a class open with cplus_set_class()
-
-void cplus_unset_class() {
- current_class = 0;
-}
-
-// -----------------------------------------------------------------------------
-// void cplus_class_close(char *name)
-//
-// Close a C++ class definition. Up to this point, we've only been collecting
-// member definitions. This function merely closes the class object and
-// stores it in a list. All classes are dumped after processing has completed.
-//
-// If name is non-null, it means that the name of the class has actually been
-// set after all of the definitions. For example :
-//
-// typedef struct {
-// double x,y,z
-// } Vector;
-//
-// If this is the case, we'll use that as our classname and datatype.
-// Otherwise, we'll just go with the classname and classtype set earlier.
-//
-// Inputs : name = optional "new name" for the class.
-//
-// Output : None
-//
-// Side Effects : Resets internal variables. Saves class in internal list.
-// Registers the class with the language module, but doesn't
-// emit any code.
-// -----------------------------------------------------------------------------
-
-void cplus_class_close(char *name) {
-
- if (name) {
- // The name of our class suddenly changed by typedef. Fix things up
- current_class->classname = copy_string(name);
-
- // This flag indicates that the class needs to have it's type stripped off
- current_class->strip = 1;
- }
-
- // If we're in C++ or Objective-C mode. We're going to drop the class specifier
-
- if ((CPlusPlus) || (ObjCClass)) {
- current_class->strip = 1;
- }
-
- // Register our class with the target language module, but otherwise
- // don't do anything yet.
-
- char *iname;
- if (current_class->classrename) iname = current_class->classrename;
- else iname = current_class->classname;
-
- lang->cpp_class_decl(current_class->classname, iname, current_class->classtype);
-
- // Clear current class variable and reset
- current_class = 0;
- localtypes = 0;
-
-}
-
-// -----------------------------------------------------------------------------
-// void cplus_abort(void)
-//
-// Voids the current class--some kind of unrecoverable parsing error occurred.
-// -----------------------------------------------------------------------------
-
-void cplus_abort(void) {
- current_class->error = 1;
- current_class = 0;
- localtypes = 0;
-}
-
-// -----------------------------------------------------------------------------
-// void cplus_cleanup(void)
-//
-// This function is called after all parsing has been completed. It dumps all
-// of the stored classes out to the language module.
-//
-// Inputs : None
-//
-// Output : None
-//
-// Side Effects : Emits all C++ wrapper code.
-// -----------------------------------------------------------------------------
-
-void cplus_cleanup(void) {
-
- // Dump all classes created at once (yikes!)
-
- CPP_class::create_all();
- lang->cpp_cleanup();
-}
-
-// -----------------------------------------------------------------------------
-// void cplus_inherit(int count, char **baseclass)
-//
-// Inherit from a baseclass. This function only really registers
-// the inheritance, but doesn't do anything with it yet.
-//
-// Inputs : baseclass = A NULL terminated array of strings with the names
-// of baseclasses. For multiple inheritance, there
-// will be multiple entries in this list.
-//
-// Output : None
-//
-// Side Effects : Sets the baseclass variable of the current class.
-// -----------------------------------------------------------------------------
-
-void cplus_inherit(int count, char **baseclass) {
- int i;
-
- // printf("Inheriting : count = %d, baseclass = %x\n",count,baseclass);
- // If there are baseclasses, make copy of them
- if (count) {
- current_class->baseclass = (char **) new char*[count+1];
- for (i = 0; i < count; i++)
- current_class->baseclass[i] = copy_string(baseclass[i]);
- current_class->baseclass[i] = 0;
- } else {
- baseclass = 0;
- }
-}
-
-// -----------------------------------------------------------------------------
-// cplus_generate_types(char **baseclass)
-//
-// Generates the type-mappings between the current class and any associated
-// base classes. This is done by performing a depth first search of the
-// class hierarchy. Functions for performing correct type-casting are
-// generated for each base-derived class pair.
-//
-// Inputs : baseclass = NULL terminated list of base classes
-//
-// Output : None
-//
-// Side Effects : Emits pointer conversion functions. Registers type-mappings
-// with the type checking module.
-//
-// -----------------------------------------------------------------------------
-
-static Hash convert; // Hash table of conversion functions
-
-void cplus_generate_types(char **baseclass) {
- CPP_class *bc;
- int i;
- String cfunc, temp1, temp2, temp3;
- extern void typeeq_derived(char *, char *, char *);
-
- if (!baseclass) {
- return;
- }
-
- // Generate type-conversion functions and type-equivalence
-
- i = 0;
- while(baseclass[i]) {
- cfunc = "";
-
- bc = CPP_class::search(baseclass[i]);
- if (bc) {
- // Generate a conversion function (but only for C++)
-
- if (!current_class->objective_c) {
- temp3 = "";
- temp3 << "Swig" << current_class->classname << "To" << bc->classname;
-
- if (convert.add(temp3,(void *) 1) != -1) {
-
- // Write a function for casting derived type to parent class
-
- cfunc << "static void *Swig" << current_class->classname << "To" << bc->classname
- << "(void *ptr) {\n"
- << tab4 << current_class->classname << " *src;\n"
- << tab4 << bc->classname << " *dest;\n"
- << tab4 << "src = (" << current_class->classname << " *) ptr;\n"
- << tab4 << "dest = (" << bc->classname << " *) src;\n"
- // << tab4 << "printf(\"casting...\\n\");\n"
- << tab4 << "return (void *) dest;\n"
- << "}\n";
-
- fprintf(f_wrappers,"%s\n",cfunc.get());
- }
- } else {
- temp3 = "0";
- }
-
- // Make a type-equivalence allowing derived classes to be used in functions of the
-
- if (strlen(current_class->classtype) > 0 &&
- strcmp(current_class->classtype, "class") != 0) {
- temp1 = "";
- temp1 << current_class->classtype << " " << current_class->classname;
- temp2 = "";
- temp2 << bc->classtype << " " << bc->classname;
- // Add various equivalences to the pointer table
-
- typeeq_derived(bc->classname, current_class->classname,temp3.get());
- typeeq_derived(temp2.get(), current_class->classname,temp3.get());
- typeeq_derived(temp2.get(), temp1.get(),temp3.get());
- typeeq_derived(bc->classname, temp1.get(),temp3.get());
- } else {
- typeeq_derived(bc->classname, current_class->classname,temp3.get());
- }
- // Now traverse the hierarchy some more
- cplus_generate_types(bc->baseclass);
- }
- i++;
- }
-}
-
-// -----------------------------------------------------------------------------
-// void cplus_inherit_decl(char **baseclass)
-//
-// This function is called internally to handle inheritance between classes.
-// Basically, we're going to generate type-checking information and call
-// out to the target language to handle the inheritance.
-//
-// This function is only called when emitting classes to the language modules
-// (after all parsing has been complete).
-//
-// Inputs : baseclass = NULL terminated list of base-class names.
-//
-// Output : None
-//
-// Side Effects : Generates type-mappings. Calls the language-specific
-// inheritance function.
-// -----------------------------------------------------------------------------
-
-void cplus_inherit_decl(char **baseclass) {
-
- // If not base-classes, bail out
-
- if (!baseclass) return;
-
- Inherit_mode = 1;
- lang->cpp_inherit(baseclass); // Pass inheritance onto the various languages
- Inherit_mode = 0;
-
- // Create type-information for class hierarchy
-
- cplus_generate_types(baseclass);
-}
-// -----------------------------------------------------------------------------
-// void cplus_inherit_members(char *baseclass, int mode)
-//
-// Inherits members from a class. This is called by specific language modules
-// to bring in members from base classes. It may or may not be called.
-//
-// This function is called with a *single* base-class, not multiple classes
-// like other functions. To do multiple inheritance, simply call this
-// with each of the associated base classes.
-//
-// Inputs :
-// baseclass = Name of baseclass
-// mode = Inheritance handling flags
-// INHERIT_FUNC - Import functions in base class
-// INHERIT_VAR - Import variables in base class
-// INHERIT_CONST - Inherit constants
-// INHERIT_ALL - Inherit everything (grossly inefficient)
-//
-// Output : None
-//
-// Side Effects : Imports methods from base-classes into derived classes.
-//
-// -----------------------------------------------------------------------------
-
-void cplus_inherit_members(char *baseclass, int mode) {
- CPP_class *bc;
-
- bc = CPP_class::search(baseclass);
- if (bc) {
- bc->inherit_decls(mode);
- } else {
- fprintf(stderr,"%s:%d: Warning. Base class %s undefined (ignored).\n", input_file, current_class->line, baseclass);
- }
-}
-
-// -----------------------------------------------------------------------------
-// void cplus_member_func(char *name, char *iname, DataType *type, ParmList *, is_virtual)
-//
-// Parser entry point to creating a C++ member function. This function primarily
-// just records the function and does a few symbol table checks.
-//
-// Inputs :
-// name = Real name of the member function
-// iname = Renamed version (may be NULL)
-// type = Return datatype
-// l = Parameter list
-// is_virtual = Set if this is a pure virtual function (ignored)
-//
-// Output : None
-//
-// Side Effects :
-// Adds member function to current class.
-// -----------------------------------------------------------------------------
-
-void cplus_member_func(char *name, char *iname, DataType *type, ParmList *l,
- int is_virtual) {
-
- CPP_function *f;
- char *temp_iname;
-
- // First, figure out if we're renaming this function or not
-
- if (!iname)
- temp_iname = name;
- else
- temp_iname = iname;
-
- // If we're in inherit mode, we need to check for duplicates.
- // Issue a warning.
-
- if (Inherit_mode) {
- if (current_class->search_member(temp_iname)) {
- return;
- }
- }
-
- // Add it to our C++ class list
-
- f = new CPP_function(name,temp_iname,type,l,0,is_virtual);
- f->de = doc_entry;
- current_class->add_member(f);
-
- // If this is a pure virtual function, the class is abstract
-
- if (is_virtual)
- current_class->is_abstract = 1;
-
-}
-
-// -----------------------------------------------------------------------------
-// void cplus_constructor(char *name, char *iname, ParmList *l)
-//
-// Parser entry point for creating a constructor.
-//
-// Inputs :
-// name = Real name of the constructor (usually the same as the class)
-// iname = Renamed version (may be NULL)
-// l = Parameter list
-//
-// Output : None
-//
-// Side Effects :
-// Adds a constructor to the current class.
-// -----------------------------------------------------------------------------
-
-void cplus_constructor(char *name, char *iname, ParmList *l) {
-
- CPP_constructor *c;
-
- // May want to check the naming scheme here
-
- c = new CPP_constructor(name,iname,l);
- c->de = doc_entry;
- current_class->add_member(c);
- current_class->have_constructor = 1;
-
-}
-
-// -----------------------------------------------------------------------------
-// void cplus_destructor(char *name, char *iname)
-//
-// Parser entry point for adding a destructor.
-//
-// Inputs :
-// name = Real name of the destructor (usually same as class name)
-// iname = Renamed version (may be NULL)
-//
-// Output : None
-//
-// Side Effects :
-// Adds a destructor to the current class
-//
-// -----------------------------------------------------------------------------
-
-void cplus_destructor(char *name, char *iname) {
-
- CPP_destructor *d;
-
- d = new CPP_destructor(name,iname);
- d->de = doc_entry;
- current_class->add_member(d);
- current_class->have_destructor = 1;
-}
-
-// -----------------------------------------------------------------------------
-// void cplus_variable(char *name, char *iname, DataType *t)
-//
-// Parser entry point for creating a new member variable.
-//
-// Inputs :
-// name = name of the variable
-// iname = Renamed version (may be NULL)
-// t = Datatype
-//
-// Output : None
-//
-// Side Effects :
-// Adds a member variable to the current class
-// -----------------------------------------------------------------------------
-
-void cplus_variable(char *name, char *iname, DataType *t) {
-
- CPP_variable *v;
- char *temp_iname;
-
- // If we're in inherit mode, we need to check for duplicates.
-
- if (iname)
- temp_iname = iname;
- else
- temp_iname = name;
-
- if (Inherit_mode) {
- if (current_class->search_member(temp_iname)) {
- return;
- }
- }
-
- v = new CPP_variable(name,iname,t,0);
- v->de = doc_entry;
- current_class->add_member(v);
-}
-
-// -----------------------------------------------------------------------------
-// void cplus_static_func(char *name, char *iname, DataType *type, ParmList *l)
-//
-// Parser entry point for creating a new static member function.
-//
-// Inputs :
-// name = Real name of the function
-// iname = Renamed version (may be NULL)
-// type = Return datatype
-// l = Parameter list
-//
-// Output : None
-//
-// Side Effects :
-// Adds a static function to the current class.
-//
-// -----------------------------------------------------------------------------
-
-void cplus_static_func(char *name, char *iname, DataType *type, ParmList *l) {
-
- char *temp_iname;
-
- // If we're in inherit mode, we need to check for duplicates.
-
- if (iname) temp_iname = iname;
- else temp_iname = name;
-
- if (Inherit_mode) {
- if (current_class->search_member(iname)) {
- // Have a duplication
- return;
- }
- }
-
- CPP_function *f = new CPP_function(name, temp_iname, type, l, 1);
- f->de = doc_entry;
- current_class->add_member(f);
-}
-
-// -----------------------------------------------------------------------------
-// void cplus_declare_const(char *name, char *iname, DataType *type, char *value)
-//
-// Parser entry point for creating a C++ constant (usually contained in an
-// enum).
-//
-// Inputs :
-// name = Real name of the constant
-// iname = Renamed constant (may be NULL)
-// type = Datatype of the constant
-// value = String representation of the value
-//
-// Output : None
-//
-// Side Effects :
-// Adds a constant to the current class.
-// -----------------------------------------------------------------------------
-
-void cplus_declare_const(char *name, char *iname, DataType *type, char *value) {
-
- char *temp_iname;
-
- if (iname) temp_iname = iname;
- else temp_iname = name;
-
- // If we're in inherit mode, we need to check for duplicates.
- // Possibly issue a warning or perhaps a remapping
-
- if (Inherit_mode) {
- if (current_class->search_member(temp_iname)) {
- return;
- }
- }
-
- CPP_constant *c = new CPP_constant(name, temp_iname, type, value);
- c->de = doc_entry;
- current_class->add_member(c);
-
- // Update this symbol in the symbol table
- update_symbol(name, type, value);
-
- // Add this symbol to local scope of a class
- add_local_type(name, current_class->classname);
-}
-
-// -----------------------------------------------------------------------------
-// void cplus_static_var(char *name, char *iname, DataType *type)
-//
-// Parser entry point for adding a static variable
-//
-// Inputs :
-// name = Name of the member
-// iname = Renamed version (may be NULL)
-// type = Datatype
-//
-// Output : None
-//
-// Side Effects :
-// Adds a static variable to the current class.
-// -----------------------------------------------------------------------------
-
-void cplus_static_var(char *name, char *iname, DataType *type) {
-
- char *temp_iname;
-
- if (iname) temp_iname = iname;
- else temp_iname = name;
-
- // If we're in inherit mode, we need to check for duplicates.
- // Possibly issue a warning or perhaps a remapping
-
- if (Inherit_mode) {
- if (current_class->search_member(temp_iname)) {
- return;
- }
- }
-
- CPP_variable *v = new CPP_variable(name, temp_iname, type, 1);
- v->de = doc_entry;
- current_class->add_member(v);
-}
-
-// -----------------------------------------------------------------------------
-// cplus_add_pragma(char *lang, char *name, char *value)
-//
-// Add a pragma to a class
-// -----------------------------------------------------------------------------
-
-void cplus_add_pragma(char *lang, char *name, char *value)
-{
- Pragma *pp;
- Pragma *p = new Pragma;
- p->filename = input_file;
- p->lineno = line_number;
- p->lang = lang;
- p->name = name;
- p->value = value;
-
- if (!current_class->pragmas) {
- current_class->pragmas = p;
- return;
- }
- pp = current_class->pragmas;
- while (pp->next) {
- pp = pp->next;
- }
- pp->next = p;
-}
-
-// ------------------------------------------------------------------------------
-// C++/Objective-C code generation functions
-//
-// The following functions are responsible for generating the wrapper functions
-// for C++ and Objective-C methods and variables. These functions are usually
-// called by specific language modules, but individual language modules can
-// choose to do something else.
-//
-// The C++ module sets a number of internal state variables before emitting various
-// pieces of code. These variables are often checked implicitly by these
-// procedures even though nothing is passed on the command line.
-//
-// The code generator tries to be somewhat intelligent about what its doing.
-// The member_hash Hash table keeps track of wrapped members and is used for
-// sharing code between base and derived classes.
-// -----------------------------------------------------------------------------
-
-static Hash member_hash; // Hash wrapping member function wrappers to scripting wrappers
-
-// -----------------------------------------------------------------------------
-// void cplus_emit_member_func(char *classname, char *classtype, char *classrename,
-// char *mname, char *mrename, DataType *type,
-// ParmList *l, int mode)
-//
-// This is a generic function to produce a C wrapper around a C++ member function.
-// This function does the following :
-//
-// 1. Create a C wrapper function
-// 2. Wrap the C wrapper function like a normal C function in SWIG
-// 3. Add the function to the scripting language
-// 4. Fill in the documentation entry
-//
-// Specific languages can choose to provide a different mechanism, but this
-// function is used to provide a low-level C++ interface.
-//
-// The mode variable determines whether to create a new function or only to
-// add it to the interpreter. This is used to support the %addmethods directive
-//
-// mode = 0 : Create a wrapper and add it (the normal mode)
-// mode = 1 : Assume wrapper was already made and add it to the
-// interpreter (%addmethods mode)
-//
-// Wrapper functions are usually created as follows :
-//
-// class Foo {
-// int bar(args)
-// }
-//
-// becomes ....
-// Foo_bar(Foo *obj, args) {
-// obj->bar(args);
-// }
-//
-// if %addmethods mode is set AND there is supporting C code detected, make
-// a function from it. The object is always called 'obj'.
-//
-// Then we wrap Foo_bar(). The name "Foo_bar" is actually contained in the parameter
-// cname. This is so language modules can provide their own names (possibly for
-// function overloading).
-//
-// This function makes no internal checks of the SWIG symbol table. This is
-// up to the caller.
-//
-// Objective-C support (added 5/24/97) :
-//
-// If the class member function is part of an objective-C interface, everything
-// works the same except that we change the calling mechanism to issue an
-// Objective-C message.
-//
-// Optimizations (added 12/31/97) :
-//
-// For automatically generated wrapper functions. We now generate macros such
-// as
-// #define Foo_bar(a,b,c) (a->bar(b,c))
-//
-// This should make the wrappers a little faster as well as reducing the amount
-// of wrapper code.
-//
-// Inputs :
-// classname = Name of C++ class
-// classtype = Type of class (struct, union, class)
-// classrename = Renamed class (if any)
-// mname = Member name
-// mrename = Renamed member
-// type = Return type of the function
-// l = Parameter list
-// mode = addmethods mode
-//
-// Output : None
-//
-// Side Effects :
-// Creates C accessor function in the wrapper file.
-// Calls the language module to create a wrapper function.
-// -----------------------------------------------------------------------------
-
-void cplus_emit_member_func(char *classname, char *classtype, char *classrename,
- char *mname, char *mrename, DataType *type, ParmList *l,
- int mode) {
- Parm *p;
- ParmList *newparms;
- int i;
- String wrap;
- String cname,iname;
- String key;
- String argname;
- char *prefix;
- char *prev_wrap = 0;
- char *temp_mname;
-
- cname = "";
- iname = "";
- key = "";
-
- // First generate a proper name for the member function
-
- // Get the base class of this member
- if (!mrename) temp_mname = mname;
- else temp_mname = mrename;
-
- char *bc = cplus_base_class(temp_mname);
- if (!bc) bc = classname;
- if (strlen(bc) == 0) bc = classname;
-
- // Generate the name of the C wrapper function (is always the same, regardless
- // of renaming).
-
- cname << name_member(mname,bc);
-
- // Generate the scripting name of this function
- if (classrename)
- prefix = classrename;
- else
- prefix = classname;
-
- if (mrename)
- iname << name_member(mrename,prefix);
- else
- iname << name_member(mname,prefix);
-
- // Now check to see if we have already wrapped a function like this.
- // If so, we'll just use the existing wrapper.
-
- key << cname << "+";
- l->print_types(key);
- // printf("key = %s\n", (char *) key);
- char *temp = copy_string(iname);
- if ((member_hash.add(key,temp)) == -1) {
- delete [] temp;
- prev_wrap = (char *) member_hash.lookup(key);
- }
-
- // Only generate code if an already existing wrapper doesn't exist
-
- if (!prev_wrap) {
-
- // If mode = 0: Then we go ahead and create a wrapper macro
-
- if (!mode) {
- cname = "";
- cname << iname;
- wrap << "#define " << cname << "(_swigobj";
-
- // Walk down the parameter list and Spit out arguments
-
- i = 0;
- p = l->get_first();
- while (p != 0) {
- if ((p->t->type != T_VOID) || (p->t->is_pointer)) {
- wrap << ",_swigarg" << i;
- i++;
- }
- p = l->get_next();
- }
-
- wrap << ") (";
-
- if (!ObjCClass) {
- wrap << "_swigobj->" << mname << "("; // C++ invocation
- } else {
- wrap << "[ _swigobj " << mname; // Objective C invocation
- }
- i = 0;
- p = l->get_first();
- while(p != 0) {
- if (ObjCClass) wrap << " " << p->objc_separator;
- if ((p->t->type != T_VOID) || (p->t->is_pointer)) {
- wrap << "_swigarg" << i;
- i++;
- }
- p = l->get_next();
- if ((p != 0) && (!ObjCClass))
- wrap << ",";
- }
- if (!ObjCClass)
- wrap << "))\n";
- else
- wrap << "])\n";
-
- // Emit it
- fprintf(f_wrappers,"%s",wrap.get());
- } else {
- if (ccode) {
- wrap << "static ";
- if (type->is_reference) {
- type->is_pointer--;
- }
- wrap << type->print_full();
- if (type->is_reference) {
- wrap << "&";
- type->is_pointer++;
- }
- wrap << " " << cname << "(" << classtype << classname << " *self";
-
- // Walk down the parameter list and Spit out arguments
-
- p = l->get_first();
- while (p != 0) {
- if ((p->t->type != T_VOID) || (p->t->is_pointer)) {
- wrap << ",";
- if ((p->call_type & CALL_REFERENCE) || (p->t->is_reference)) {
- p->t->is_pointer--;
- }
- wrap << p->t->print_full();
- if ((p->call_type & CALL_REFERENCE) || (p->t->is_reference)) {
- p->t->is_pointer++;
- if (p->t->is_reference)
- wrap << "&";
- }
- wrap << " " << p->name;
- }
- p = l->get_next();
- }
-
- wrap << ") " << ccode;
- fprintf(f_wrappers,"%s\n",wrap.get());
- }
- }
-
- // Now add a parameter to the beginning of the function and call
- // a language specific function to add it.
-
- newparms = new ParmList(l);
- p = new Parm(0,0);
- p->t = new DataType;
- p->t->type = T_USER;
- p->t->is_pointer = 1;
- p->t->id = cpp_id;
- p->call_type = 0;
-
- sprintf(p->t->name,"%s%s", classtype,classname);
- p->name = "self";
- newparms->insert(p,0); // Attach parameter to beginning of list
-
- // Now wrap the thing. The name of the function is iname
-
- lang->create_function(cname, iname, type, newparms);
- delete newparms;
- } else {
- // Already wrapped this function. Just patch it up
- lang->create_command(prev_wrap, iname);
- }
-}
-
-
-// -----------------------------------------------------------------------------
-// void cplus_emit_static_func(char *classname, char *classtype, char *classrename,
-// char *mname, char *mrename, DataType *type,
-// ParmList *l, int mode)
-//
-// This is a generic function to produce a wrapper for a C++ static member function
-// or an Objective-C class method.
-//
-// Specific languages can choose to provide a different mechanism, but this
-// function is used to provide a low-level C++ interface.
-//
-// The mode variable determines whether to create a new function or only to
-// add it to the interpreter. This is used to support the %addmethods directive
-//
-// mode = 0 : Create a wrapper and add it (the normal mode)
-// mode = 1 : Assume wrapper was already made and add it to the
-// interpreter (%addmethods mode)
-//
-// Wrapper functions are usually created as follows :
-//
-// class Foo {
-// static int bar(args)
-// }
-//
-// becomes a command called Foo_bar()
-//
-// if %addmethods mode is set AND there is supporting C code detected, make
-// a function from it.
-//
-// Then we wrap Foo_bar(). The name "Foo_bar" is actually contained in the parameter
-// cname. This is so language modules can provide their own names (possibly for
-// function overloading).
-//
-// This function makes no internal checks of the SWIG symbol table. This is
-// up to the caller.
-//
-// Inputs :
-// classname = Name of C++ class
-// classtype = Type of class (struct, union, class)
-// classrename = Renamed version of class (optional)
-// mname = Member name
-// mrename = Renamed member (optional)
-// type = Return type of the function
-// l = Parameter list
-// mode = addmethods mode
-//
-// Output : None
-//
-// -----------------------------------------------------------------------------
-
-void cplus_emit_static_func(char *classname, char *, char *classrename,
- char *mname, char *mrename, DataType *type, ParmList *l,
- int mode) {
- Parm *p;
- String wrap;
- String cname, iname, key;
- int i;
- char *prefix;
- char *prev_wrap = 0;
- char *temp_mname;
-
- cname = "";
- iname = "";
- key = "";
-
- // Generate a function name for the member function
-
- if (!mrename) temp_mname = mname;
- else temp_mname = mrename;
- char *bc = cplus_base_class(temp_mname);
- if (!bc) bc = classname;
- if (strlen(bc) == 0) bc = classname;
-
- // Generate the name of the C wrapper function
- if ((!mode) && (!ObjCClass)) {
- cname << bc << "::" << mname;
- } else {
- cname << name_member(mname,bc);
- }
-
- // Generate the scripting name of this function
- if (classrename)
- prefix = classrename;
- else
- prefix = classname;
-
- if (mrename)
- iname << name_member(mrename,prefix);
- else
- iname << name_member(mname,prefix);
-
- // Perform a hash table lookup to see if we've wrapped anything like this before
-
- key << cname << "+";
- l->print_types(key);
- char *temp = copy_string(iname);
- if ((member_hash.add(key,temp)) == -1) {
- delete [] temp;
- prev_wrap = (char *) member_hash.lookup(key);
- }
-
- if (!prev_wrap) {
- if (!((mode) || (ObjCClass))) {
- // Not an added method and not objective C, just wrap it
- lang->create_function(cname,iname, type, l);
- } else {
- // This is either an added method or an objective C class function
- //
- // If there is attached code, use it.
- // Otherwise, assume the function has been written already and
- // wrap it.
-
- wrap << "static " << type->print_full() << " " << cname << "(";
-
- // Walk down the parameter list and Spit out arguments
- p = l->get_first();
- while (p != 0) {
- if ((p->t->type != T_VOID) || (p->t->is_pointer)) {
- if (p->t->is_reference) {
- p->t->is_pointer--;
- }
- wrap << p->t->print_full();
- if (p->t->is_reference) {
- p->t->is_pointer++;
- wrap << "&";
- }
- wrap << " " << p->name;
- }
- p = l->get_next();
- if (p) wrap << ",";
- }
- wrap << ") ";
- if ((mode) && (ccode)) {
- wrap << ccode;
- } else if (ObjCClass) {
- // This is an objective-C method
-
- wrap << "{\n" << tab4;
-
- // Emit the function call.
-
- if ((type->type != T_VOID) || (type->is_pointer)) {
- // Declare the return value
-
- if (type->is_reference) {
- type->is_pointer--;
- wrap << tab4 << type->print_full() << "& _result = ";
- type->is_pointer++;
- } else {
- wrap << tab4 << type->print_type() << " _result = " << type->print_cast();
- }
- } else {
- wrap << tab4;
- }
- wrap << "[ " << classname << " " << mname; // Objective C invocation
- i = 0;
- p = l->get_first();
- while(p != 0) {
- wrap << " " << p->objc_separator;
- if ((p->t->type != T_VOID) || (p->t->is_pointer)) {
- if (p->t->is_reference) {
- wrap << "*";
- }
- wrap << p->name;
- i++;
- }
- p = l->get_next();
- }
- wrap << "];\n";
-
- if ((type->type != T_VOID) || (type->is_pointer)) {
- if (type->is_reference) {
- wrap << tab4 << "return " << type->print_cast() << " &_result;\n";
- } else {
- wrap << tab4 << "return _result;\n";
- }
- }
- wrap << "}\n";
- }
- if (ObjCClass || (mode && ccode))
- fprintf(f_wrappers,"%s\n",wrap.get());
- lang->create_function(cname,iname,type,l);
- }
- } else {
- // Already wrapped this function. Just hook up to it.
- lang->create_command(prev_wrap, iname);
- }
-}
-
-// -----------------------------------------------------------------------------
-// void cplus_emit_destructor(char *classname, char *classtype, char *classrename,
-// char *mname, char *mrename, int mode)
-//
-// Emit a C wrapper around a C++ destructor.
-//
-// Usually this function is used to do the following :
-// class Foo {
-// ...
-// ~Foo();
-// }
-//
-// becomes ....
-// void delete_Foo(Foo *f) {
-// delete f;
-// }
-//
-// Then we wrap delete_Foo().
-//
-// Inputs :
-// classname = Name of the C++ class
-// classtype = Type of class (struct,class,union)
-// classrename = Renamed class (optional)
-// mname = Name of the destructor
-// mrename = Name of the function in the interpreter
-// mode = addmethods mode (0 or 1)
-//
-// Output : None
-//
-// Side Effects :
-// Creates a destructor function and wraps it.
-// -----------------------------------------------------------------------------
-
-void cplus_emit_destructor(char *classname, char *classtype, char *classrename,
- char *mname, char *mrename, int mode)
-{
- Parm *p;
- DataType *type;
- ParmList *l;
- String wrap;
- String cname,iname;
- char *prefix;
-
- // Construct names for the function
-
- if (classrename)
- prefix = classrename;
- else
- prefix = classname;
-
- cname << name_destroy(classname);
- if (mrename)
- iname << name_destroy(mrename);
- else
- iname << name_destroy(prefix);
-
- if (!mode) {
- // Spit out a helper function for this member function
- wrap << "#define " << cname << "(_swigobj) (";
- if (ObjCClass) {
- wrap << "[_swigobj " << mname << "])\n"; // Name of the member is the destructor
- } else if (CPlusPlus)
- wrap << "delete _swigobj)\n";
- else
- wrap << "free ((char *) _swigobj))\n";
- fprintf(f_wrappers,"%s", wrap.get());
- } else {
- if (ccode) {
- wrap << "static void " << cname << "(" << classtype << classname << " *self) " << ccode;
- fprintf(f_wrappers,"%s\n",wrap.get());
- }
- }
-
- // Make a parameter list for this function
-
- l = new ParmList;
- p = new Parm(0,0);
- p->t = new DataType;
- p->t->type = T_USER;
- p->t->is_pointer = 1;
- p->t->id = cpp_id;
- p->call_type = 0;
- sprintf(p->t->name,"%s%s", classtype, classname);
- p->name = "self";
- l->insert(p,0);
-
- type = new DataType;
- type->type = T_VOID;
- sprintf(type->name,"void");
- type->is_pointer = 0;
- type->id = cpp_id;
-
- // iname is the desired name of the function in the target language
-
- lang->create_function(cname,iname,type,l);
-
- delete type;
- delete l;
-
-}
-
-// -----------------------------------------------------------------------------
-// void cplus_emit_constructor(char *classname, char *classtype, char *classrename,
-// char *mname, char *mrename, ParmList *l, int mode)
-//
-// Creates a C wrapper around a C++ constructor
-//
-// Inputs :
-// classname = name of class
-// classtype = type of class (struct,class,union)
-// classrename = Renamed class (optional)
-// mname = Name of constructor
-// mrename = Renamed constructor (optional)
-// l = Parameter list
-// mode = addmethods mode
-//
-// Output : None
-//
-// Side Effects :
-// Creates a C wrapper and calls the language module to wrap it.
-// -----------------------------------------------------------------------------
-
-void cplus_emit_constructor(char *classname, char *classtype, char *classrename,
- char *mname, char *mrename, ParmList *l, int mode)
-{
- Parm *p;
- int i;
- DataType *type;
- String wrap;
- String fcall,cname,iname,argname;
- char *prefix;
-
- // Construct names for the function
-
- if (classrename)
- prefix = classrename;
- else
- prefix = classname;
-
- cname << name_construct(classname);
- if (mrename)
- iname << name_construct(mrename);
- else
- iname << name_construct(prefix);
-
- // Create a return type
-
- type = new DataType;
- type->type = T_USER;
- sprintf(type->name,"%s%s", classtype,classname);
- type->is_pointer = 1;
- type->id = cpp_id;
-
- if (!mode) {
- wrap << "#define " << iname << "(";
- cname = "";
- cname << iname;
- if (ObjCClass) {
- fcall << type->print_cast() << "[" << classname << " " << mname;
- } else if (CPlusPlus) {
- fcall << "new " << classname << "(";
- } else {
- fcall << type->print_cast() << " calloc(1,sizeof("
- << classtype << classname << "))";
- }
-
- // Walk down the parameter list and spit out arguments
-
- i = 0;
- p = l->get_first();
- while (p != 0) {
- if (ObjCClass) fcall << " " << p->objc_separator;
- if ((p->t->type != T_VOID) || (p->t->is_pointer)) {
- wrap << "_swigarg" << i;
-
- // Emit an argument in the function call if in C++ mode
-
- if ((CPlusPlus) || (ObjCClass)) {
- fcall << "_swigarg" << i;
- }
- }
- i++;
- p = l->get_next();
- if (p) {
- wrap << ",";
- if ((CPlusPlus) && (!ObjCClass))
- fcall << ",";
- }
- }
-
- wrap << ") ";
- if (ObjCClass) fcall << "]";
- else if (CPlusPlus) fcall << ")";
-
- wrap << "(" << fcall << ")\n";
- fprintf(f_wrappers,"%s",wrap.get());
- } else {
- if (ccode) {
- wrap << "static " << classtype << classname << " *" << cname << "(";
-
- // Walk down the parameter list and spit out arguments
-
- p = l->get_first();
- while (p != 0) {
- if ((p->t->type != T_VOID) || (p->t->is_pointer)) {
- if (p->call_type & CALL_REFERENCE) {
- p->t->is_pointer--;
- }
- wrap << p->t->print_real(p->name);
- if (p->call_type & CALL_REFERENCE) {
- p->t->is_pointer++;
- }
- p = l->get_next();
- if (p) {
- wrap << ",";
- }
- } else {
- p = l->get_next();
- }
- }
- wrap << ") " << ccode << "\n";
- fprintf(f_wrappers,"%s\n",wrap.get());
- }
- }
-
- // If we had any C++ references, get rid of them now
-
- if (!mode) {
- p = l->get_first();
- while (p) {
- // p->t->is_reference = 0;
- p = l->get_next();
- }
- }
-
- // We've now created a C wrapper. We're going to add it to the interpreter
-
- lang->create_function(cname, iname, type, l);
- delete type;
-}
-
-// -----------------------------------------------------------------------------
-// void cplus_emit_variable_get(char *classname, char *classtype, char *classrename,
-// char *mname, char *mrename, DataType *type, int mode)
-//
-// Writes a C wrapper to extract a data member
-//
-// Usually this function works as follows :
-//
-// class Foo {
-// double x;
-// }
-//
-// becomes :
-//
-// double Foo_x_get(Foo *obj) {
-// return obj->x;
-// }
-//
-// Optimization : 12/31/97
-//
-// Now emits a macro like this :
-//
-// #define Foo_x_get(obj) (obj->x)
-//
-// Inputs :
-// classname = name of C++ class
-// classtype = type of class (struct, class, union)
-// classrename = Renamed class
-// mname = Member name
-// mrename = Renamed member
-// type = Datatype of the member
-// mode = Addmethods mode
-//
-// Output : None
-//
-// Side Effects :
-// Creates a C accessor function and calls the language module
-// to make a wrapper around it.
-// -----------------------------------------------------------------------------
-
-void cplus_emit_variable_get(char *classname, char *classtype, char *classrename,
- char *mname, char *mrename, DataType *type, int mode) {
-
- Parm *p;
- ParmList *l;
- String wrap;
- String cname, iname, key;
- char *prefix;
- char *tm;
- String source;
- char *temp_mname;
- char *prev_wrap = 0;
-
- cname = "";
- iname = "";
- key = "";
-
- // First generate a proper name for the get function
-
- // Get the base class of this member
- if (!mrename) temp_mname = mname;
- else temp_mname = mrename;
-
- char *bc = cplus_base_class(temp_mname);
- if (!bc) bc = classname;
- if (strlen(bc) == 0) bc = classname;
-
- // Generate the name of the C wrapper function (is always the same, regardless
- // of renaming).
-
- cname << name_get(name_member(mname,bc));
-
- // Generate the scripting name of this function
- if (classrename)
- prefix = classrename;
- else
- prefix = classname;
-
- if (mrename)
- iname << name_get(name_member(mrename,prefix));
- else
- iname << name_get(name_member(mname,prefix));
-
- // Now check to see if we have already wrapped a variable like this.
-
- key << cname;
- char *temp = copy_string(iname);
- if ((member_hash.add(key,temp)) == -1) {
- delete [] temp;
- prev_wrap = (char *) member_hash.lookup(key);
- }
-
- // Only generate code if already existing wrapper doesn't exist
- if (!prev_wrap) {
- if (!mode) {
- // Get any sort of typemap that might exist
-
- source << "obj->" << mname;
-
- // Now write a function to get the value of the variable
-
- tm = typemap_lookup("memberout",typemap_lang,type,mname,source,"result");
-
- if ((type->type == T_USER) && (!type->is_pointer)) {
- type->is_pointer++;
- if (tm) {
- wrap << "static " << type->print_type() << " " << cname << "("
- << classtype << classname << " *obj) {\n"
- << tab4 << type->print_type() << " result;\n"
- << tm << "\n"
- << tab4 << "return result;\n"
- << "}\n";
- } else {
- wrap << "#define " << cname << "(_swigobj) "
- << "(&_swigobj->" << mname << ")\n";
- }
- type->is_pointer--;
- } else {
- if (tm) {
- wrap << "static " << type->print_type() << " " << cname << "("
- << classtype << classname << " *obj) {\n"
- << tab4 << type->print_type() << " result;\n"
- << tm << "\n"
- << tab4 << "return result;\n"
- << "}\n";
- } else {
- wrap << "#define " << cname << "(_swigobj) (";
- if (!type->is_reference) wrap << type->print_cast();
- else
- wrap << "&";
- wrap << " _swigobj->" << mname << ")\n";
- }
- }
- fprintf(f_wrappers,"%s",wrap.get());
- }
-
- // Wrap this function
-
- l = new ParmList;
- p = new Parm(0,0);
- p->t = new DataType;
- p->t->type = T_USER;
- p->t->is_pointer = 1;
- p->t->id = cpp_id;
- p->call_type = 0;
- p->name = "self";
- sprintf(p->t->name,"%s%s", classtype,classname);
- l->insert(p,0);
-
- if ((type->type == T_USER) && (!type->is_pointer)) {
- type->is_pointer++;
- lang->create_function(cname,iname, type, l);
- type->is_pointer--;
- } else {
- int is_ref = type->is_reference;
- type->is_reference = 0;
- lang->create_function(cname,iname, type, l);
- type->is_reference = is_ref;
- }
- delete l;
- } else {
- // Already wrapped this function. Just patch it up
- lang->create_command(prev_wrap,iname);
- }
-
-}
-
-// -----------------------------------------------------------------------------
-// void cplus_emit_variable_set(char *classname, char *classtype, char *mname,
-// char *cname, char *iname, DataType *type, int mode)
-//
-// Writes a C wrapper to set a data member
-//
-// Usually this function works as follows :
-//
-// class Foo {
-// double x;
-// }
-//
-// becomes :
-//
-// double Foo_x_set(Foo *obj, double value) {
-// return (obj->x = value);
-// }
-//
-// Need to handle special cases for char * and for user defined types.
-//
-// 1. char *
-//
-// Will free previous contents (if any) and allocate
-// new storage. Could be risky, but it's a reasonably
-// natural thing to do.
-//
-// 2. User_Defined
-// Will assign value from a pointer.
-// Will return a pointer to current value.
-//
-//
-// Optimization, now defined as a C preprocessor macro
-//
-// Inputs :
-// classname = name of C++ class
-// classtype = type of class (struct, class, union)
-// mname = Member name
-// cname = Name of the C function for this (ie. Foo_bar_get)
-// iname = Interpreter name of ths function
-// type = Datatype of the member
-// mode = Addmethods mode
-//
-// Output : None
-//
-// Side Effects :
-// Creates a C accessor function and calls the language module
-// to wrap it.
-// -----------------------------------------------------------------------------
-
-void cplus_emit_variable_set(char *classname, char *classtype, char *classrename,
- char *mname, char *mrename, DataType *type, int mode) {
-
- Parm *p;
- ParmList *l;
- String wrap;
- int is_user = 0;
- char *tm;
- String target;
- String cname, iname, key;
- char *temp_mname;
- char *prefix;
- char *prev_wrap = 0;
-
- cname = "";
- iname = "";
- key = "";
-
- // First generate a proper name for the get function
-
- // Get the base class of this member
- if (!mrename) temp_mname = mname;
- else temp_mname = mrename;
-
- char *bc = cplus_base_class(temp_mname);
- if (!bc) bc = classname;
- if (strlen(bc) == 0) bc = classname;
-
- // Generate the name of the C wrapper function (is always the same, regardless
- // of renaming).
-
- cname << name_set(name_member(mname,bc));
-
- // Generate the scripting name of this function
- if (classrename)
- prefix = classrename;
- else
- prefix = classname;
-
- if (mrename)
- iname << name_set(name_member(mrename,prefix));
- else
- iname << name_set(name_member(mname,prefix));
-
- // Now check to see if we have already wrapped a variable like this.
-
- key << cname;
- char *temp = copy_string(iname);
- if ((member_hash.add(key,temp)) == -1) {
- delete [] temp;
- prev_wrap = (char *) member_hash.lookup(key);
- }
-
- // Only generate code if already existing wrapper doesn't exist
-
- if (!prev_wrap) {
- if (!mode) {
-
- target << "obj->" << mname;
-
- // Lookup any typemaps that might exist
- tm = typemap_lookup("memberin",typemap_lang,type,mname,"val",target);
-
- // First write a function to set the variable
-
- if (tm) {
- if ((type->type == T_USER) && (!type->is_pointer)) {
- type->is_pointer++;
- is_user = 1;
- }
- wrap << "static " << type->print_type() << " " << cname << "("
- << classtype << classname << " *obj, " << type->print_real("val") << ") {\n";
- if (is_user) {
- type->is_pointer--;
- }
- wrap << tm << "\n";
- // Return the member
- if (is_user) type->is_pointer++;
- wrap << tab4 << "return " << type->print_cast() << " val;\n";
- if (is_user) type->is_pointer--;
- wrap << "}\n";
-
- } else {
- if ((type->type != T_VOID) || (type->is_pointer)){
- if (!type->is_pointer) {
-
- wrap << "#define " << cname << "(_swigobj,_swigval) (";
- // Have a real value here (ie. not a pointer).
- // If it's a user defined type, we'll do something special.
- // Otherwise, just assign it.
-
- if (type->type != T_USER) {
- wrap << "_swigobj->" << mname << " = _swigval";
- } else {
- wrap << "_swigobj->" << mname << " = *(_swigval)";
- }
- wrap << ",_swigval)\n";
- } else {
- // Is a pointer type here. If string, we do something
- // special. Otherwise. No problem.
- if ((type->type == T_CHAR) && (type->is_pointer == 1)) {
- String temp;
- wrap << "static " << type->print_type() << " " << cname << "("
- << classtype << classname << " *obj, " << type->print_real("val") << ") {\n";
- temp << "obj->" << mname;
- if (CPlusPlus) {
- wrap << tab4 << "if (" << temp << ") delete [] " << temp << ";\n"
- << tab4 << temp << " = new char[strlen(val)+1];\n"
- << tab4 << "strcpy((char *)" << temp << ",val);\n";
- } else {
- wrap << tab4 << "if (obj->" << mname << ") free(obj->" << mname << ");\n"
- << tab4 << "obj->" << mname << " = (char *) malloc(strlen(val)+1);\n"
- << tab4 << "strcpy((char *)obj->" << mname << ",val);\n";
- }
- wrap << tab4 << "return (char *) val;\n";
- wrap << "}\n";
- } else {
- // A normal pointer type of some sort
- wrap << "#define " << cname << "(_swigobj,_swigval) (";
- if (type->is_reference) {
- wrap << "_swigobj->" << mname << " = *_swigval, _swigval)\n";
- } else {
- wrap << "_swigobj->" << mname << " = _swigval,_swigval)\n";
- }
- }
- }
- }
- }
- }
- fprintf(f_wrappers,"%s",wrap.get());
- // Now wrap it.
-
- l = new ParmList;
- p = new Parm(0,0);
- p->t = new DataType(type);
- p->t->is_reference = 0;
- p->call_type = 0;
- p->t->id = cpp_id;
- if ((type->type == T_USER) && (!type->is_pointer)) p->t->is_pointer++;
- if (mrename)
- p->name = mrename;
- else
- p->name = mname;
- l->insert(p,0);
- p = new Parm(0,0);
- p->t = new DataType;
- p->t->type = T_USER;
- p->call_type = 0;
- p->t->is_pointer = 1;
- p->t->id = cpp_id;
- sprintf(p->t->name,"%s%s", classtype,classname);
- p->name = "self";
- l->insert(p,0);
-
- if ((type->type == T_USER) && (!type->is_pointer)) {
- type->is_pointer++;
- lang->create_function(cname,iname, type, l);
- type->is_pointer--;
- } else {
- int is_ref = type->is_reference;
- type->is_reference = 0;
- lang->create_function(cname,iname, type, l);
- type->is_reference = is_ref;
- }
- delete l;
- } else {
- lang->create_command(prev_wrap,iname);
- }
-}
-
-// -----------------------------------------------------------------------------
-// void cplus_support_doc(String &f)
-//
-// This function adds a supporting documentation entry to the
-// end of a class. This should only be used if there is an
-// alternative interface available or if additional information is needed.
-//
-// doc_entry should be set to the class entry before calling this. Otherwise,
-// who knows where this text is going to end up!
-//
-// Inputs : f = String with additional text
-//
-// Output : None
-//
-// Side Effects :
-// Adds a text block to the current documentation entry.
-//
-// -----------------------------------------------------------------------------
-
-void cplus_support_doc(String &f) {
-
- DocEntry *de;
- if (doc_entry) {
- de = new DocText(f.get(),doc_entry);
- de->format = 0;
- }
-}
-
-// -----------------------------------------------------------------------------
-// void cplus_register_type(char *typename)
-//
-// Registers a datatype name to be associated with the current class. This
-// typename is placed into a local hash table for later use. For example :
-//
-// class foo {
-// public:
-// enum ENUM { ... };
-// typedef double Real;
-// void bar(ENUM a, Real b);
-// }
-//
-// Then we need to access bar using fully qualified type names such as
-//
-// void wrap_bar(foo::ENUM a, foo::Real b) {
-// bar(a,b);
-// }
-//
-// Inputs : name of the datatype.
-//
-// Output : None
-//
-// Side Effects : Adds datatype to localtypes.
-// -----------------------------------------------------------------------------
-
-void cplus_register_type(char *tname) {
- if (current_class)
- add_local_type(tname, current_class->classname);
-};
-
-// -----------------------------------------------------------------------------
-// void cplus_register_scope(Hash *h)
-//
-// Saves the scope associated with a particular class. It will be needed
-// later if anything inherits from us.
-//
-// Inputs : Hash table h containing the scope
-//
-// Output : None
-//
-// Side Effects : Saves h with current class
-// -----------------------------------------------------------------------------
-
-void cplus_register_scope(Hash *h) {
- if (current_class) {
- current_class->scope = h;
- }
-}
-
-// -----------------------------------------------------------------------------
-// void cplus_inherit_scope(int count, char **baseclass)
-//
-// Given a list of base classes, this function extracts their former scopes
-// and merges them with the current scope. This is needed to properly handle
-// inheritance.
-//
-// Inputs : baseclass = NULL terminated array of base-class names
-//
-// Output : None
-//
-// Side Effects : Updates current scope with new symbols.
-//
-// Copies any special symbols if needed.
-// -----------------------------------------------------------------------------
-
-void cplus_inherit_scope(int count, char **baseclass) {
- CPP_class *bc;
- int i;
- char *key, *val;
- String str;
-
- if (count && current_class) {
- for (i = 0; i < count; i++) {
- bc = CPP_class::search(baseclass[i]);
- if (bc) {
- if (bc->scope)
- DataType::merge_scope(bc->scope);
-
- if (bc->local) {
- // Copy local symbol table
- key = bc->local->firstkey();
- while (key) {
- val = (char *) bc->local->lookup(key);
- str = val;
- // str.replace(bc->classname,current_class->classname);
- localtypes->add(key,copy_string(str));
- key = bc->local->nextkey();
- }
- }
- }
- }
- }
-}
-
projects / wxWidgets.git / blobdiff