/trunk/Source/Modules/lang.cxx
C++ | 2114 lines | 1520 code | 245 blank | 349 comment | 431 complexity | 485c5f59523f975a11d4b5a7ab8eefc9 MD5 | raw file
Possible License(s): LGPL-2.1, Cube, GPL-3.0, 0BSD, GPL-2.0
Large files files are truncated, but you can click here to view the full file
- /* -----------------------------------------------------------------------------
- * This file is part of SWIG, which is licensed as a whole under version 3
- * (or any later version) of the GNU General Public License. Some additional
- * terms also apply to certain portions of SWIG. The full details of the SWIG
- * license and copyrights can be found in the LICENSE and COPYRIGHT files
- * included with the SWIG source code as distributed by the SWIG developers
- * and at http://www.swig.org/legal.html.
- *
- * lang.cxx
- *
- * Language base class functions. Default C++ handling is also implemented here.
- * ----------------------------------------------------------------------------- */
- char cvsroot_lang_cxx[] = "$Id: lang.cxx 12830 2011-10-30 21:51:50Z wsfulton $";
- #include "swigmod.h"
- #include "cparse.h"
- #include <ctype.h>
- /* default mode settings */
- static int director_mode = 0;
- static int director_protected_mode = 1;
- static int all_protected_mode = 0;
- static int naturalvar_mode = 0;
- Language* Language::this_ = 0;
- /* Set director_protected_mode */
- void Wrapper_director_mode_set(int flag) {
- director_mode = flag;
- }
- void Wrapper_director_protected_mode_set(int flag) {
- director_protected_mode = flag;
- }
- void Wrapper_all_protected_mode_set(int flag) {
- all_protected_mode = flag;
- }
- void Wrapper_naturalvar_mode_set(int flag) {
- naturalvar_mode = flag;
- }
- extern "C" {
- int Swig_director_mode() {
- return director_mode;
- }
- int Swig_director_protected_mode() {
- return director_protected_mode;
- }
- int Swig_all_protected_mode() {
- return all_protected_mode;
- }
- void Language_replace_special_variables(String *method, String *tm, Parm *parm) {
- Language::instance()->replaceSpecialVariables(method, tm, parm);
- }
- }
- /* Some status variables used during parsing */
- static int InClass = 0; /* Parsing C++ or not */
- static String *ClassName = 0; /* This is the real name of the current class */
- static String *ClassPrefix = 0; /* Class prefix */
- static String *NSpace = 0; /* Namespace for the nspace feature */
- static String *ClassType = 0; /* Fully qualified type name to use */
- static String *DirectorClassName = 0; /* Director name of the current class */
- int Abstract = 0;
- int ImportMode = 0;
- int IsVirtual = 0;
- static String *AttributeFunctionGet = 0;
- static String *AttributeFunctionSet = 0;
- static Node *CurrentClass = 0;
- int line_number = 0;
- String *input_file = 0;
- int SmartPointer = 0;
- static Hash *classhash;
- extern int GenerateDefault;
- extern int ForceExtern;
- extern int AddExtern;
- /* import modes */
- #define IMPORT_MODE 1
- #define IMPORT_MODULE 2
- /* ----------------------------------------------------------------------
- * Dispatcher::emit_one()
- *
- * Dispatch a single node
- * ---------------------------------------------------------------------- */
- int Dispatcher::emit_one(Node *n) {
- String *wrn;
- int ret = SWIG_OK;
- char *tag = Char(nodeType(n));
- if (!tag) {
- /* Printf(stderr,"SWIG: Fatal internal error. Malformed parse tree
- node!\n"); */
- return SWIG_OK;
- }
- /* Do not proceed if marked with an error */
- if (Getattr(n, "error"))
- return SWIG_OK;
- /* Look for warnings */
- wrn = Getattr(n, "feature:warnfilter");
- if (wrn) {
- Swig_warnfilter(wrn, 1);
- }
- /* ============================================================
- * C/C++ parsing
- * ============================================================ */
- if (strcmp(tag, "extern") == 0) {
- ret = externDeclaration(n);
- } else if (strcmp(tag, "cdecl") == 0) {
- ret = cDeclaration(n);
- } else if (strcmp(tag, "enum") == 0) {
- ret = enumDeclaration(n);
- } else if (strcmp(tag, "enumitem") == 0) {
- ret = enumvalueDeclaration(n);
- } else if (strcmp(tag, "enumforward") == 0) {
- ret = enumforwardDeclaration(n);
- } else if (strcmp(tag, "class") == 0) {
- ret = classDeclaration(n);
- } else if (strcmp(tag, "classforward") == 0) {
- ret = classforwardDeclaration(n);
- } else if (strcmp(tag, "constructor") == 0) {
- ret = constructorDeclaration(n);
- } else if (strcmp(tag, "destructor") == 0) {
- ret = destructorDeclaration(n);
- } else if (strcmp(tag, "access") == 0) {
- ret = accessDeclaration(n);
- } else if (strcmp(tag, "using") == 0) {
- ret = usingDeclaration(n);
- } else if (strcmp(tag, "namespace") == 0) {
- ret = namespaceDeclaration(n);
- } else if (strcmp(tag, "template") == 0) {
- ret = templateDeclaration(n);
- }
- /* ===============================================================
- * SWIG directives
- * =============================================================== */
- else if (strcmp(tag, "top") == 0) {
- ret = top(n);
- } else if (strcmp(tag, "extend") == 0) {
- ret = extendDirective(n);
- } else if (strcmp(tag, "apply") == 0) {
- ret = applyDirective(n);
- } else if (strcmp(tag, "clear") == 0) {
- ret = clearDirective(n);
- } else if (strcmp(tag, "constant") == 0) {
- ret = constantDirective(n);
- } else if (strcmp(tag, "fragment") == 0) {
- ret = fragmentDirective(n);
- } else if (strcmp(tag, "import") == 0) {
- ret = importDirective(n);
- } else if (strcmp(tag, "include") == 0) {
- ret = includeDirective(n);
- } else if (strcmp(tag, "insert") == 0) {
- ret = insertDirective(n);
- } else if (strcmp(tag, "module") == 0) {
- ret = moduleDirective(n);
- } else if (strcmp(tag, "native") == 0) {
- ret = nativeDirective(n);
- } else if (strcmp(tag, "pragma") == 0) {
- ret = pragmaDirective(n);
- } else if (strcmp(tag, "typemap") == 0) {
- ret = typemapDirective(n);
- } else if (strcmp(tag, "typemapcopy") == 0) {
- ret = typemapcopyDirective(n);
- } else if (strcmp(tag, "typemapitem") == 0) {
- ret = typemapitemDirective(n);
- } else if (strcmp(tag, "types") == 0) {
- ret = typesDirective(n);
- } else {
- Swig_error(input_file, line_number, "Unrecognized parse tree node type '%s'\n", tag);
- ret = SWIG_ERROR;
- }
- if (wrn) {
- Swig_warnfilter(wrn, 0);
- }
- return ret;
- }
- /* ----------------------------------------------------------------------
- * Dispatcher::emit_children()
- *
- * Emit all children that match the given type. type = 0 means all types.
- * ---------------------------------------------------------------------- */
- int Dispatcher::emit_children(Node *n) {
- Node *c;
- char *eo = Char(Getattr(n, "feature:emitonlychildren"));
- for (c = firstChild(n); c; c = nextSibling(c)) {
- if (eo) {
- const char *tag = Char(nodeType(c));
- if (strcmp(tag, "cdecl") == 0) {
- if (checkAttribute(c, "storage", "typedef"))
- tag = "typedef";
- }
- if (strstr(eo, tag) == 0) {
- continue;
- }
- }
- emit_one(c);
- }
- return SWIG_OK;
- }
- /* Stubs for dispatcher class. We don't do anything by default---up to derived class
- to fill in traversal code */
- int Dispatcher::defaultHandler(Node *) {
- return SWIG_OK;
- }
- int Dispatcher::extendDirective(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::applyDirective(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::clearDirective(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::constantDirective(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::fragmentDirective(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::importDirective(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::includeDirective(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::insertDirective(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::moduleDirective(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::nativeDirective(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::pragmaDirective(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::typemapDirective(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::typemapitemDirective(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::typemapcopyDirective(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::typesDirective(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::cDeclaration(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::externDeclaration(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::enumDeclaration(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::enumvalueDeclaration(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::enumforwardDeclaration(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::classDeclaration(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::templateDeclaration(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::classforwardDeclaration(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::constructorDeclaration(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::destructorDeclaration(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::accessDeclaration(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::usingDeclaration(Node *n) {
- return defaultHandler(n);
- }
- int Dispatcher::namespaceDeclaration(Node *n) {
- return defaultHandler(n);
- }
- /* Allocators */
- Language::Language():
- none_comparison(NewString("$arg != 0")),
- director_ctor_code(NewString("")),
- director_prot_ctor_code(0),
- symtabs(NewHash()),
- classtypes(NewHash()),
- enumtypes(NewHash()),
- overloading(0),
- multiinput(0),
- cplus_runtime(0),
- directors(0) {
- Hash *symbols = NewHash();
- Setattr(symtabs, "", symbols); // create top level/global symbol table scope
- argc_template_string = NewString("argc");
- argv_template_string = NewString("argv[%d]");
- /* Default director constructor code, passed to Swig_ConstructorToFunction */
- Printv(director_ctor_code, "if ( $comparison ) { /* subclassed */\n", " $director_new \n", "} else {\n", " $nondirector_new \n", "}\n", NIL);
- /*
- Default director 'protected' constructor code, disabled by
- default. Each language that needs it, has to define it.
- */
- director_prot_ctor_code = 0;
- director_multiple_inheritance = 1;
- director_language = 0;
- assert(!this_);
- this_ = this;
- }
- Language::~Language() {
- Delete(symtabs);
- Delete(classtypes);
- Delete(enumtypes);
- Delete(director_ctor_code);
- Delete(none_comparison);
- this_ = 0;
- }
- /* ----------------------------------------------------------------------
- emit_one()
- ---------------------------------------------------------------------- */
- int Language::emit_one(Node *n) {
- int ret;
- int oldext;
- if (!n)
- return SWIG_OK;
- if (GetFlag(n, "feature:ignore")
- && !Getattr(n, "feature:onlychildren"))
- return SWIG_OK;
- oldext = Extend;
- if (Getattr(n, "feature:extend"))
- Extend = 1;
- line_number = Getline(n);
- input_file = Getfile(n);
- /*
- symtab = Getattr(n,"symtab");
- if (symtab) {
- symtab = Swig_symbol_setscope(symtab);
- }
- */
- ret = Dispatcher::emit_one(n);
- /*
- if (symtab) {
- Swig_symbol_setscope(symtab);
- }
- */
- Extend = oldext;
- return ret;
- }
- static Parm *nonvoid_parms(Parm *p) {
- if (p) {
- SwigType *t = Getattr(p, "type");
- if (SwigType_type(t) == T_VOID)
- return 0;
- }
- return p;
- }
- /* -----------------------------------------------------------------------------
- * cplus_value_type()
- *
- * Returns the alternative value type needed in C++ for class value
- * types. When swig is not sure about using a plain $ltype value,
- * since the class doesn't have a default constructor, or it can't be
- * assigned, you will get back 'SwigValueWrapper<type >'.
- *
- * ----------------------------------------------------------------------------- */
- SwigType *cplus_value_type(SwigType *t) {
- return SwigType_alttype(t, 0);
- }
- static Node *first_nontemplate(Node *n) {
- while (n) {
- if (Strcmp(nodeType(n), "template") != 0)
- return n;
- n = Getattr(n, "sym:nextSibling");
- }
- return n;
- }
- /* --------------------------------------------------------------------------
- * swig_pragma()
- *
- * Handle swig pragma directives.
- * -------------------------------------------------------------------------- */
- void swig_pragma(char *lang, char *name, char *value) {
- if (strcmp(lang, "swig") == 0) {
- if ((strcmp(name, "make_default") == 0) || ((strcmp(name, "makedefault") == 0))) {
- GenerateDefault = 1;
- } else if ((strcmp(name, "no_default") == 0) || ((strcmp(name, "nodefault") == 0))) {
- Swig_warning(WARN_DEPRECATED_NODEFAULT, "SWIG", 1, "dangerous, use %%nodefaultctor, %%nodefaultdtor instead.\n");
- GenerateDefault = 0;
- } else if (strcmp(name, "attributefunction") == 0) {
- String *nvalue = NewString(value);
- char *s = strchr(Char(nvalue), ':');
- if (!s) {
- Swig_error(input_file, line_number, "Bad value for attributefunction. Expected \"fmtget:fmtset\".\n");
- } else {
- *s = 0;
- AttributeFunctionGet = NewString(Char(nvalue));
- AttributeFunctionSet = NewString(s + 1);
- }
- Delete(nvalue);
- } else if (strcmp(name, "noattributefunction") == 0) {
- AttributeFunctionGet = 0;
- AttributeFunctionSet = 0;
- }
- }
- }
- /* --------------------------------------------------------------------------
- * use_naturalvar_mode()
- * -------------------------------------------------------------------------- */
- int use_naturalvar_mode(Node *n) {
- if (Getattr(n, "unnamed"))
- return 0;
- int nvar = naturalvar_mode || GetFlag(n, "feature:naturalvar");
- if (!nvar) {
- /* look for feature in the class */
- SwigType *ty = Getattr(n, "type");
- SwigType *fullty = SwigType_typedef_resolve_all(ty);
- if (SwigType_isclass(fullty)) {
- Node *m = Copy(n);
- SwigType *tys = SwigType_strip_qualifiers(fullty);
- Swig_features_get(Swig_cparse_features(), 0, tys, 0, m);
- nvar = GetFlag(m, "feature:naturalvar");
- Delete(tys);
- Delete(m);
- }
- Delete(fullty);
- }
- return nvar ? CWRAP_NATURAL_VAR : 0;
- }
- /* ----------------------------------------------------------------------
- * Language::top() - Top of parsing tree
- * ---------------------------------------------------------------------- */
- int Language::top(Node *n) {
- Node *mod = Getattr(n, "module");
- if (mod) {
- Node *options = Getattr(mod, "options");
- if (options) {
- if (Getattr(options, "naturalvar")) {
- naturalvar_mode = 1;
- }
- if (Getattr(options, "nonaturalvar")) {
- naturalvar_mode = 0;
- }
- }
- }
- classhash = Getattr(n, "classes");
- return emit_children(n);
- }
- /* ----------------------------------------------------------------------
- * Language::extendDirective()
- * ---------------------------------------------------------------------- */
- int Language::extendDirective(Node *n) {
- int oldam = Extend;
- AccessMode oldmode = cplus_mode;
- Extend = CWRAP_EXTEND;
- cplus_mode = PUBLIC;
- emit_children(n);
- Extend = oldam;
- cplus_mode = oldmode;
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::applyDirective()
- * ---------------------------------------------------------------------- */
- int Language::applyDirective(Node *n) {
- Parm *pattern = Getattr(n, "pattern");
- Node *c = firstChild(n);
- while (c) {
- Parm *apattern = Getattr(c, "pattern");
- if (ParmList_len(pattern) != ParmList_len(apattern)) {
- Swig_error(input_file, line_number, "Can't apply (%s) to (%s). Number of arguments don't match.\n", ParmList_str(pattern), ParmList_str(apattern));
- } else {
- if (!Swig_typemap_apply(pattern, apattern)) {
- Swig_warning(WARN_TYPEMAP_APPLY_UNDEF, input_file, line_number, "Can't apply (%s). No typemaps are defined.\n", ParmList_str(pattern));
- }
- }
- c = nextSibling(c);
- }
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::clearDirective()
- * ---------------------------------------------------------------------- */
- int Language::clearDirective(Node *n) {
- Node *p;
- for (p = firstChild(n); p; p = nextSibling(p)) {
- ParmList *pattern = Getattr(p, "pattern");
- Swig_typemap_clear_apply(pattern);
- }
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::constantDirective()
- * ---------------------------------------------------------------------- */
- int Language::constantDirective(Node *n) {
- if (CurrentClass && (cplus_mode != PUBLIC))
- return SWIG_NOWRAP;
- if (!GetFlag(n, "feature:allowexcept")) {
- UnsetFlag(n, "feature:except");
- }
- if (Getattr(n, "feature:exceptvar")) {
- Setattr(n, "feature:except", Getattr(n, "feature:exceptvar"));
- }
- if (!ImportMode) {
- Swig_require("constantDirective", n, "name", "?value", NIL);
- String *name = Getattr(n, "name");
- String *value = Getattr(n, "value");
- if (!value) {
- value = Copy(name);
- } else {
- /* if (checkAttribute(n,"type","char")) {
- value = NewString(value);
- } else {
- value = NewStringf("%(escape)s", value);
- }
- */
- Setattr(n, "rawvalue", value);
- value = NewStringf("%(escape)s", value);
- if (!Len(value))
- Append(value, "\\0");
- /* Printf(stdout,"'%s' = '%s'\n", name, value); */
- }
- Setattr(n, "value", value);
- this->constantWrapper(n);
- Swig_restore(n);
- return SWIG_OK;
- }
- return SWIG_NOWRAP;
- }
- /* ----------------------------------------------------------------------
- * Language::fragmentDirective()
- * ---------------------------------------------------------------------- */
- int Language::fragmentDirective(Node *n) {
- Swig_fragment_register(n);
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::importDirective()
- * ---------------------------------------------------------------------- */
- int Language::importDirective(Node *n) {
- int oldim = ImportMode;
- ImportMode = IMPORT_MODE;
- emit_children(n);
- ImportMode = oldim;
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::includeDirective()
- * ---------------------------------------------------------------------- */
- int Language::includeDirective(Node *n) {
- emit_children(n);
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::insertDirective()
- * ---------------------------------------------------------------------- */
- int Language::insertDirective(Node *n) {
- /* %insert directive */
- if ((!ImportMode) || Getattr(n, "generated")) {
- String *code = Getattr(n, "code");
- String *section = Getattr(n, "section");
- File *f = 0;
- if (!section) { /* %{ ... %} */
- f = Swig_filebyname("header");
- } else {
- f = Swig_filebyname(section);
- }
- if (f) {
- Printf(f, "%s\n", code);
- } else {
- Swig_error(input_file, line_number, "Unknown target '%s' for %%insert directive.\n", section);
- }
- return SWIG_OK;
- } else {
- return SWIG_NOWRAP;
- }
- }
- /* ----------------------------------------------------------------------
- * Language::moduleDirective()
- * ---------------------------------------------------------------------- */
- int Language::moduleDirective(Node *n) {
- (void) n;
- /* %module directive */
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::nativeDirective()
- * ---------------------------------------------------------------------- */
- int Language::nativeDirective(Node *n) {
- if (!ImportMode) {
- return nativeWrapper(n);
- } else {
- return SWIG_NOWRAP;
- }
- }
- /* ----------------------------------------------------------------------
- * Language::pragmaDirective()
- * ---------------------------------------------------------------------- */
- int Language::pragmaDirective(Node *n) {
- /* %pragma directive */
- if (!ImportMode) {
- String *lan = Getattr(n, "lang");
- String *name = Getattr(n, "name");
- String *value = Getattr(n, "value");
- swig_pragma(Char(lan), Char(name), Char(value));
- /* pragma(Char(lan),Char(name),Char(value)); */
- return SWIG_OK;
- }
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::typemapDirective()
- * ---------------------------------------------------------------------- */
- int Language::typemapDirective(Node *n) {
- /* %typemap directive */
- String *method = Getattr(n, "method");
- String *code = Getattr(n, "code");
- Parm *kwargs = Getattr(n, "kwargs");
- Node *items = firstChild(n);
- static int namewarn = 0;
- if (code && (Strstr(code, "$source") || (Strstr(code, "$target")))) {
- Swig_warning(WARN_TYPEMAP_SOURCETARGET, Getfile(n), Getline(n), "Deprecated typemap feature ($source/$target).\n");
- if (!namewarn) {
- Swig_warning(WARN_TYPEMAP_SOURCETARGET, Getfile(n), Getline(n), "The use of $source and $target in a typemap declaration is deprecated.\n\
- For typemaps related to argument input (in,ignore,default,arginit,check), replace\n\
- $source by $input and $target by $1. For typemaps related to return values (out,\n\
- argout,ret,except), replace $source by $1 and $target by $result. See the file\n\
- Doc/Manual/Typemaps.html for complete details.\n");
- namewarn = 1;
- }
- }
- if (Strcmp(method, "except") == 0) {
- Swig_warning(WARN_DEPRECATED_EXCEPT_TM, Getfile(n), Getline(n), "%%typemap(except) is deprecated. Use the %%exception directive.\n");
- }
- if (Strcmp(method, "in") == 0) {
- Hash *k;
- k = kwargs;
- while (k) {
- if (checkAttribute(k, "name", "numinputs")) {
- if (!multiinput && (GetInt(k, "value") > 1)) {
- Swig_error(Getfile(n), Getline(n), "Multiple-input typemaps (numinputs > 1) not supported by this target language module.\n");
- return SWIG_ERROR;
- }
- break;
- }
- k = nextSibling(k);
- }
- if (!k) {
- k = NewHash();
- Setattr(k, "name", "numinputs");
- Setattr(k, "value", "1");
- set_nextSibling(k, kwargs);
- Setattr(n, "kwargs", k);
- kwargs = k;
- }
- }
- if (Strcmp(method, "ignore") == 0) {
- Swig_warning(WARN_DEPRECATED_IGNORE_TM, Getfile(n), Getline(n), "%%typemap(ignore) has been replaced by %%typemap(in,numinputs=0).\n");
- Clear(method);
- Append(method, "in");
- Hash *k = NewHash();
- Setattr(k, "name", "numinputs");
- Setattr(k, "value", "0");
- set_nextSibling(k, kwargs);
- Setattr(n, "kwargs", k);
- kwargs = k;
- }
- /* Replace $descriptor() macros */
- if (code) {
- Setfile(code, Getfile(n));
- Setline(code, Getline(n));
- Swig_cparse_replace_descriptor(code);
- }
- while (items) {
- Parm *pattern = Getattr(items, "pattern");
- Parm *parms = Getattr(items, "parms");
- if (code) {
- Swig_typemap_register(method, pattern, code, parms, kwargs);
- } else {
- Swig_typemap_clear(method, pattern);
- }
- items = nextSibling(items);
- }
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::typemapcopyDirective()
- * ---------------------------------------------------------------------- */
- int Language::typemapcopyDirective(Node *n) {
- String *method = Getattr(n, "method");
- Parm *pattern = Getattr(n, "pattern");
- Node *items = firstChild(n);
- int nsrc = 0;
- nsrc = ParmList_len(pattern);
- while (items) {
- ParmList *npattern = Getattr(items, "pattern");
- if (nsrc != ParmList_len(npattern)) {
- Swig_error(input_file, line_number, "Can't copy typemap. Number of types differ.\n");
- } else {
- if (Swig_typemap_copy(method, pattern, npattern) < 0) {
- Swig_error(input_file, line_number, "Can't copy typemap (%s) %s = %s\n", method, ParmList_str(pattern), ParmList_str(npattern));
- }
- }
- items = nextSibling(items);
- }
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::typesDirective()
- * ---------------------------------------------------------------------- */
- int Language::typesDirective(Node *n) {
- Parm *parms = Getattr(n, "parms");
- String *convcode = Getattr(n, "convcode"); /* optional user supplied conversion code for custom casting */
- while (parms) {
- SwigType *t = Getattr(parms, "type");
- String *v = Getattr(parms, "value");
- if (!v) {
- SwigType_remember(t);
- } else {
- if (SwigType_issimple(t)) {
- SwigType_inherit(t, v, 0, convcode);
- }
- }
- parms = nextSibling(parms);
- }
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::cDeclaration()
- * ---------------------------------------------------------------------- */
- int Language::cDeclaration(Node *n) {
- String *name = Getattr(n, "name");
- String *symname = Getattr(n, "sym:name");
- SwigType *type = Getattr(n, "type");
- SwigType *decl = Getattr(n, "decl");
- String *storage = Getattr(n, "storage");
- Node *over;
- File *f_header = 0;
- SwigType *ty, *fullty;
- /* discards nodes following the access control rules */
- if (cplus_mode != PUBLIC || !is_public(n)) {
- /* except for friends, they are not affected by access control */
- int isfriend = storage && (Cmp(storage, "friend") == 0);
- if (!isfriend) {
- /* Check what the director needs. If the method is pure virtual, it is always needed.
- * Also wrap non-virtual protected members if asked for (allprotected mode). */
- if (!(directorsEnabled() && ((is_member_director(CurrentClass, n) && need_nonpublic_member(n)) || is_non_virtual_protected_access(n)))) {
- return SWIG_NOWRAP;
- }
- // Prevent wrapping protected overloaded director methods more than once -
- // This bit of code is only needed due to the cDeclaration call in classHandler()
- String *wrapname = NewStringf("nonpublic_%s%s", symname, Getattr(n, "sym:overname"));
- if (Getattr(CurrentClass, wrapname)) {
- Delete(wrapname);
- return SWIG_NOWRAP;
- }
- SetFlag(CurrentClass, wrapname);
- Delete(wrapname);
- }
- }
- if (Cmp(storage, "typedef") == 0) {
- Swig_save("cDeclaration", n, "type", NIL);
- SwigType *t = Copy(type);
- if (t) {
- SwigType_push(t, decl);
- Setattr(n, "type", t);
- typedefHandler(n);
- }
- Swig_restore(n);
- return SWIG_OK;
- }
- /* If in import mode, we proceed no further */
- if (ImportMode)
- return SWIG_NOWRAP;
- /* If we're in extend mode and there is code, replace the $descriptor macros */
- if (Extend) {
- String *code = Getattr(n, "code");
- if (code) {
- Setfile(code, Getfile(n));
- Setline(code, Getline(n));
- Swig_cparse_replace_descriptor(code);
- }
- }
- /* Overloaded symbol check */
- over = Swig_symbol_isoverloaded(n);
- if (!overloading) {
- if (over)
- over = first_nontemplate(over);
- if (over && (over != n)) {
- Swig_warning(WARN_LANG_OVERLOAD_DECL, input_file, line_number, "Overloaded declaration ignored. %s\n", Swig_name_decl(n));
- Swig_warning(WARN_LANG_OVERLOAD_DECL, Getfile(over), Getline(over), "Previous declaration is %s\n", Swig_name_decl(over));
- return SWIG_NOWRAP;
- }
- }
- if (symname && !validIdentifier(symname)) {
- Swig_warning(WARN_LANG_IDENTIFIER, input_file, line_number, "Can't wrap '%s' unless renamed to a valid identifier.\n", symname);
- return SWIG_NOWRAP;
- }
- ty = NewString(type);
- SwigType_push(ty, decl);
- fullty = SwigType_typedef_resolve_all(ty);
- if (SwigType_isfunction(fullty)) {
- if (!SwigType_isfunction(ty)) {
- Delete(ty);
- ty = fullty;
- fullty = 0;
- ParmList *parms = SwigType_function_parms(ty, n);
- Setattr(n, "parms", parms);
- }
- /* Transform the node into a 'function' node and emit */
- if (!CurrentClass) {
- f_header = Swig_filebyname("header");
- if (AddExtern) {
- if (f_header) {
- if ((Cmp(storage, "extern") == 0) || (ForceExtern && !storage)) {
- /* we don't need the 'extern' part in the C/C++ declaration,
- and it produces some problems when namespace and SUN
- Studio is used.
- Printf(f_header,"extern %s", SwigType_str(ty,name));
- In fact generating extern declarations is quite error prone and is
- no longer the default. Getting it right seems impossible with namespaces
- and default arguments and when a method is declared with the various Windows
- calling conventions - SWIG doesn't understand Windows (non standard) calling
- conventions in the first place, so can't regenerate them.
- */
- String *str = SwigType_str(ty, name);
- Printf(f_header, "%s", str);
- Delete(str);
- {
- DOH *t = Getattr(n, "throws");
- if (t) {
- Printf(f_header, " throw(");
- while (t) {
- Printf(f_header, "%s", Getattr(t, "type"));
- t = nextSibling(t);
- if (t)
- Printf(f_header, ",");
- }
- Printf(f_header, ")");
- }
- }
- Printf(f_header, ";\n");
- } else if (Cmp(storage, "externc") == 0) {
- /* here 'extern "C"' is needed */
- String *str = SwigType_str(ty, name);
- Printf(f_header, "extern \"C\" %s;\n", str);
- Delete(str);
- }
- }
- }
- }
- /* This needs to check qualifiers */
- if (SwigType_isqualifier(ty)) {
- SwigType *qual = SwigType_pop(ty);
- Setattr(n, "qualifier", qual);
- Delete(qual);
- }
- Delete(SwigType_pop_function(ty));
- DohIncref(type);
- Setattr(n, "type", ty);
- if (GetFlag(n, "feature:onlychildren") && !GetFlag(n, "feature:ignore")) {
- // Found an unignored templated method that has a an empty template instantiation (%template())
- // Ignore it unless it has been %rename'd
- if (Strncmp(symname, "__dummy_", 8) == 0) {
- SetFlag(n, "feature:ignore");
- Swig_warning(WARN_LANG_TEMPLATE_METHOD_IGNORE, input_file, line_number,
- "%%template() contains no name. Template method ignored: %s\n", Swig_name_decl(n));
- }
- }
- if (!GetFlag(n, "feature:ignore"))
- functionHandler(n);
- Setattr(n, "type", type);
- Delete(ty);
- Delete(type);
- return SWIG_OK;
- } else {
- /* Some kind of variable declaration */
- String *declaration = Copy(decl);
- Delattr(n, "decl");
- if (Getattr(n, "nested"))
- SetFlag(n, "feature:immutable");
- if (!CurrentClass) {
- if ((Cmp(storage, "extern") == 0) || ForceExtern) {
- f_header = Swig_filebyname("header");
- if (AddExtern) {
- if (f_header) {
- String *str = SwigType_str(ty, name);
- Printf(f_header, "extern %s;\n", str);
- Delete(str);
- }
- }
- }
- }
- if (!SwigType_ismutable(ty)) {
- SetFlag(n, "feature:immutable");
- }
- /* If an array and elements are const, then read-only */
- if (SwigType_isarray(ty)) {
- SwigType *tya = SwigType_array_type(ty);
- if (SwigType_isconst(tya)) {
- SetFlag(n, "feature:immutable");
- }
- Delete(tya);
- }
- DohIncref(type);
- Setattr(n, "type", ty);
- variableHandler(n);
- Setattr(n, "type", type);
- Setattr(n, "decl", declaration);
- Delete(ty);
- Delete(type);
- Delete(fullty);
- return SWIG_OK;
- }
- }
- /* ----------------------------------------------------------------------
- * Language::functionHandler()
- * ---------------------------------------------------------------------- */
- int Language::functionHandler(Node *n) {
- String *storage = Getattr(n, "storage");
- int isfriend = CurrentClass && Cmp(storage, "friend") == 0;
- int isstatic = CurrentClass && Cmp(storage, "static") == 0 && !(SmartPointer && Getattr(n, "allocate:smartpointeraccess"));
- Parm *p = Getattr(n, "parms");
- if (GetFlag(n, "feature:del")) {
- /* the method acts like a delete operator, ie, we need to disown the parameter */
- if (CurrentClass && !isstatic && !isfriend) {
- SetFlag(n, "feature:self:disown");
- } else {
- if (p)
- SetFlag(p, "wrap:disown");
- }
- }
- if (!CurrentClass) {
- globalfunctionHandler(n);
- } else {
- if (isstatic) {
- staticmemberfunctionHandler(n);
- } else if (isfriend) {
- int oldInClass = InClass;
- InClass = 0;
- globalfunctionHandler(n);
- InClass = oldInClass;
- } else {
- Node *explicit_n = 0;
- if (directorsEnabled() && is_member_director(CurrentClass, n) && !extraDirectorProtectedCPPMethodsRequired()) {
- bool virtual_but_not_pure_virtual = (!(Cmp(storage, "virtual")) && (Cmp(Getattr(n, "value"), "0") != 0));
- if (virtual_but_not_pure_virtual) {
- // Add additional wrapper which makes an explicit call to the virtual method (ie not a virtual call)
- explicit_n = Copy(n);
- String *new_symname = Copy(Getattr(n, "sym:name"));
- String *suffix = Getattr(parentNode(n), "sym:name");
- Printv(new_symname, "SwigExplicit", suffix, NIL);
- Setattr(explicit_n, "sym:name", new_symname);
- Delattr(explicit_n, "storage");
- Delattr(explicit_n, "override");
- Delattr(explicit_n, "hides");
- SetFlag(explicit_n, "explicitcall");
- Setattr(n, "explicitcallnode", explicit_n);
- }
- }
- memberfunctionHandler(n);
- if (explicit_n) {
- memberfunctionHandler(explicit_n);
- Delattr(explicit_n, "explicitcall");
- Delete(explicit_n);
- }
- }
- }
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::globalfunctionHandler()
- * ---------------------------------------------------------------------- */
- int Language::globalfunctionHandler(Node *n) {
- Swig_require("globalfunctionHandler", n, "name", "sym:name", "type", "?parms", NIL);
- String *name = Getattr(n, "name");
- String *symname = Getattr(n, "sym:name");
- SwigType *type = Getattr(n, "type");
- ParmList *parms = Getattr(n, "parms");
- /* Check for callback mode */
- String *cb = GetFlagAttr(n, "feature:callback");
- if (cb) {
- String *cbname = Getattr(n, "feature:callback:name");
- if (!cbname) {
- cbname = NewStringf(cb, symname);
- Setattr(n, "feature:callback:name", cbname);
- }
- callbackfunctionHandler(n);
- if (Cmp(cbname, symname) == 0) {
- Delete(cbname);
- Swig_restore(n);
- return SWIG_NOWRAP;
- }
- Delete(cbname);
- }
- Setattr(n, "parms", nonvoid_parms(parms));
- String *call = Swig_cfunction_call(name, parms);
- String *cres = Swig_cresult(type, Swig_cresult_name(), call);
- Setattr(n, "wrap:action", cres);
- Delete(cres);
- Delete(call);
- functionWrapper(n);
- Swig_restore(n);
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::callbackfunctionHandler()
- * ---------------------------------------------------------------------- */
- int Language::callbackfunctionHandler(Node *n) {
- Swig_require("callbackfunctionHandler", n, "name", "*sym:name", "*type", "?value", NIL);
- String *symname = Getattr(n, "sym:name");
- String *type = Getattr(n, "type");
- String *name = Getattr(n, "name");
- String *parms = Getattr(n, "parms");
- String *cb = GetFlagAttr(n, "feature:callback");
- String *cbname = Getattr(n, "feature:callback:name");
- String *calltype = NewStringf("(%s (*)(%s))(%s)", SwigType_str(type, 0), ParmList_str(parms), SwigType_namestr(name));
- SwigType *cbty = Copy(type);
- SwigType_add_function(cbty, parms);
- SwigType_add_pointer(cbty);
- if (!cbname) {
- cbname = NewStringf(cb, symname);
- Setattr(n, "feature:callback:name", cbname);
- }
- Setattr(n, "sym:name", cbname);
- Setattr(n, "type", cbty);
- Setattr(n, "value", calltype);
- Node *ns = symbolLookup(cbname);
- if (!ns)
- constantWrapper(n);
- Delete(cbname);
- Delete(cbty);
- Swig_restore(n);
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::memberfunctionHandler()
- * ---------------------------------------------------------------------- */
- int Language::memberfunctionHandler(Node *n) {
- Swig_require("memberfunctionHandler", n, "*name", "*sym:name", "*type", "?parms", "?value", NIL);
- String *storage = Getattr(n, "storage");
- String *name = Getattr(n, "name");
- String *symname = Getattr(n, "sym:name");
- SwigType *type = Getattr(n, "type");
- String *value = Getattr(n, "value");
- ParmList *parms = Getattr(n, "parms");
- String *cb = GetFlagAttr(n, "feature:callback");
- if (Cmp(storage, "virtual") == 0) {
- if (Cmp(value, "0") == 0) {
- IsVirtual = PURE_VIRTUAL;
- } else {
- IsVirtual = PLAIN_VIRTUAL;
- }
- } else {
- IsVirtual = 0;
- }
- if (cb) {
- Node *cbn = NewHash();
- String *cbname = Getattr(n, "feature:callback:name");
- if (!cbname) {
- cbname = NewStringf(cb, symname);
- }
- SwigType *cbty = Copy(type);
- SwigType_add_function(cbty, parms);
- SwigType_add_memberpointer(cbty, ClassName);
- String *cbvalue = NewStringf("&%s::%s", ClassName, name);
- Setattr(cbn, "sym:name", cbname);
- Setattr(cbn, "type", cbty);
- Setattr(cbn, "value", cbvalue);
- Setattr(cbn, "name", name);
- Setfile(cbn, Getfile(n));
- Setline(cbn, Getline(n));
- memberconstantHandler(cbn);
- Setattr(n, "feature:callback:name", Swig_name_member(NSpace, ClassPrefix, cbname));
- Delete(cb);
- Delete(cbn);
- Delete(cbvalue);
- Delete(cbty);
- Delete(cbname);
- if (Cmp(cbname, symname) == 0) {
- Swig_restore(n);
- return SWIG_NOWRAP;
- }
- }
- String *fname = Swig_name_member(NSpace, ClassPrefix, symname);
- if (Extend && SmartPointer) {
- if (!Getattr(n, "classname")) {
- Setattr(n, "classname", Getattr(CurrentClass, "allocate:smartpointerbase"));
- }
- }
- // Set up the type for the cast to this class for use when wrapping const director (virtual) methods.
- // Note: protected director methods or when allprotected mode turned on.
- String *director_type = 0;
- if (!is_public(n) && (is_member_director(CurrentClass, n) || GetFlag(n, "explicitcall") || is_non_virtual_protected_access(n))) {
- director_type = Copy(DirectorClassName);
- String *qualifier = Getattr(n, "qualifier");
- if (qualifier)
- SwigType_push(director_type, qualifier);
- SwigType_add_pointer(director_type);
- }
- int DirectorExtraCall = 0;
- if (directorsEnabled() && is_member_director(CurrentClass, n) && !SmartPointer)
- if (extraDirectorProtectedCPPMethodsRequired())
- DirectorExtraCall = CWRAP_DIRECTOR_TWO_CALLS;
- if (GetFlag(n, "explicitcall"))
- DirectorExtraCall = CWRAP_DIRECTOR_ONE_CALL;
- Swig_MethodToFunction(n, NSpace, ClassType, Getattr(n, "template") ? SmartPointer : Extend | SmartPointer | DirectorExtraCall, director_type,
- is_member_director(CurrentClass, n));
- Setattr(n, "sym:name", fname);
- functionWrapper(n);
- Delete(director_type);
- Delete(fname);
- Swig_restore(n);
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::staticmemberfunctionHandler()
- * ---------------------------------------------------------------------- */
- int Language::staticmemberfunctionHandler(Node *n) {
- Swig_require("staticmemberfunctionHandler", n, "*name", "*sym:name", "*type", NIL);
- Swig_save("staticmemberfunctionHandler", n, "storage", NIL);
- String *name = Getattr(n, "name");
- String *symname = Getattr(n, "sym:name");
- SwigType *type = Getattr(n, "type");
- ParmList *parms = Getattr(n, "parms");
- String *cb = GetFlagAttr(n, "feature:callback");
- String *cname, *mrename;
- if (!Extend) {
- Node *sb = Getattr(n, "cplus:staticbase");
- String *sname = Getattr(sb, "name");
- if (is_non_virtual_protected_access(n))
- cname = NewStringf("%s::%s", DirectorClassName, name);
- else
- cname = NewStringf("%s::%s", sname, name);
- } else {
- String *mname = Swig_name_mangle(ClassName);
- cname = Swig_name_member(NSpace, mname, name);
- Delete(mname);
- }
- mrename = Swig_name_member(NSpace, ClassPrefix, symname);
- if (Extend) {
- String *code = Getattr(n, "code");
- String *defaultargs = Getattr(n, "defaultargs");
- String *mangled = Swig_name_mangle(mrename);
- Delete(mrename);
- mrename = mangled;
- if (Getattr(n, "sym:overloaded") && code) {
- Append(cname, Getattr(defaultargs ? defaultargs : n, "sym:overname"));
- }
- if (!defaultargs && code) {
- /* Hmmm. An added static member. We have to create a little wrapper for this */
- Swig_add_extension_code(n, cname, parms, type, code, CPlusPlus, 0);
- }
- }
- Setattr(n, "name", cname);
- Setattr(n, "sym:name", mrename);
- if (cb) {
- String *cbname = NewStringf(cb, symname);
- Setattr(n, "feature:callback:name", Swig_name_member(NSpace, ClassPrefix, cbname));
- Setattr(n, "feature:callback:staticname", name);
- }
- Delattr(n, "storage");
- globalfunctionHandler(n);
- Delete(cname);
- Delete(mrename);
- Swig_restore(n);
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::variableHandler()
- * ---------------------------------------------------------------------- */
- int Language::variableHandler(Node *n) {
- /* If not a smart-pointer access or added method. We clear
- feature:except. There is no way C++ or C would throw
- an exception merely for accessing a member data.
- Caveat: Some compilers seem to route attribute access through
- methods which can generate exceptions. The feature:allowexcept
- allows this. Also, the feature:exceptvar can be used to match
- only variables.
- */
- if (!(Extend | SmartPointer)) {
- if (!GetFlag(n, "feature:allowexcept")) {
- UnsetFlag(n, "feature:except");
- }
- if (Getattr(n, "feature:exceptvar")) {
- Setattr(n, "feature:except", Getattr(n, "feature:exceptvar"));
- }
- }
- if (!CurrentClass) {
- globalvariableHandler(n);
- } else {
- String *storage = Getattr(n, "storage");
- Swig_save("variableHandler", n, "feature:immutable", NIL);
- if (SmartPointer) {
- /* If a smart-pointer and it's a constant access, we have to set immutable */
- if (!Getattr(CurrentClass, "allocate:smartpointermutable")) {
- SetFlag(n, "feature:immutable");
- }
- }
- if ((Cmp(storage, "static") == 0) && !(SmartPointer && Getattr(n, "allocate:smartpointeraccess"))) {
- staticmembervariableHandler(n);
- } else {
- membervariableHandler(n);
- }
- Swig_restore(n);
- }
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::globalvariableHandler()
- * ---------------------------------------------------------------------- */
- int Language::globalvariableHandler(Node *n) {
- variableWrapper(n);
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::membervariableHandler()
- * ---------------------------------------------------------------------- */
- int Language::membervariableHandler(Node *n) {
- Swig_require("membervariableHandler", n, "*name", "*sym:name", "*type", NIL);
- Swig_save("membervariableHandler", n, "parms", NIL);
- String *name = Getattr(n, "name");
- String *symname = Getattr(n, "sym:name");
- SwigType *type = Getattr(n, "type");
- if (!AttributeFunctionGet) {
- String *mname = Swig_name_member(0, ClassPrefix, symname);
- String *mrename_get = Swig_name_get(NSpace, mname);
- String *mrename_set = Swig_name_set(NSpace, mname);
- Delete(mname);
- /* Create a function to set the value of the variable */
- int assignable = is_assignable(n);
- if (SmartPointer) {
- if (!Getattr(CurrentClass, "allocate:smartpointermutable")) {
- assignable = 0;
- }
- }
- if (assignable) {
- int make_set_wrapper = 1;
- String *tm = 0;
- String *target = 0;
- if (!Extend) {
- if (SmartPointer) {
- if (checkAttribute(n, "storage", "static")) {
- Node *sn = Getattr(n, "cplus:staticbase");
- String *base = Getattr(sn, "name");
- target = NewStringf("%s::%s", base, name);
- } else {
- String *pname = Swig_cparm_name(0, 0);
- target = NewStringf("(*%s)->%s", pname, name);
- Delete(pname);
- }
- } else {
- String *pname = is_non_virtual_protected_access(n) ? NewString("darg") : Swig_cparm_name(0, 0);
- target = NewStringf("%s->%s", pname, name);
- Delete(pname);
- }
- tm = Swig_typemap_lookup("memberin", n, target, 0);
- }
- int flags = Extend | SmartPointer | use_naturalvar_mode(n);
- if (is_non_virtual_protected_access(n))
- flags = flags | CWRAP_ALL_PROTECTED_ACCESS;
- Swig_MembersetToFunction(n, ClassType, flags);
- Setattr(n, "memberset", "1");
- if (!Extend) {
- /* Check for a member in typemap here */
- if (!tm) {
- if (SwigType_isarray(type)) {
- Swig_warning(WARN_TYPEMAP_VARIN_UNDEF, input_file, line_number, "Unable to set variable of type %s.\n", SwigType_str(type, 0));
- make_set_wrapper = 0;
- }
- } else {
- String *pname0 = Swig_cparm_name(0, 0);
- String *pname1 = Swig_cparm_name(0, 1);
- Replace(tm, "$source", pname1, DOH_REPLACE_ANY);
- Replace(tm, "$target", target, DOH_REPLACE_ANY);
- Replace(tm, "$input", pname1, DOH_REPLACE_ANY);
- Replace(tm, "$self", pname0, DOH_REPLACE_ANY);
- Setattr(n, "wrap:action", tm);
- Delete(tm);
- Delete(pname0);
- Delete(pname1);
- }
- Delete(target);
- }
- if (make_set_wrapper) {
- Setattr(n, "sym:name", mrename_set);
- functionWrapper(n);
- } else {
- SetFlag(n, "feature:immutable");
- }
- /* Restore parameters */
- Setattr(n, "type", type);
- Setattr(n, "name", name);
- Setattr(n, "sym:name", symname);
- /* Delete all attached typemaps and typemap attributes */
- Iterator ki;
- for (ki = First(n); ki.key; ki = Next(ki)) {
- if (Strncmp(ki.key, "tmap:", 5) == 0)
- Delattr(n, ki.key);
- }
- }
- /* Emit get function */
- {
- int flags = Extend | SmartPointer | use_naturalvar_mode(n);
- if (is_non_virtual_protected_access(n))
- flags = flags | CWRAP_ALL_PROTECTED_ACCESS;
- Swig_MembergetToFunction(n, ClassType, flags);
- Setattr(n, "sym:name", mrename_get);
- Setattr(n, "memberget", "1");
- functionWrapper(n);
- }
- Delete(mrename_get);
- Delete(mrename_set);
- } else {
- /* This code is used to support the attributefunction directive
- where member variables are converted automagically to
- accessor functions */
- #if 0
- Parm *p;
- String *gname;
- SwigType *vty;
- p = NewParm(type, 0, n);
- gname = NewStringf(AttributeFunctionGet, symname);
- if (!Extend) {
- ActionFunc = Copy(Swig_cmemberget_call(name, type));
- cpp_member_func(Char(gname), Char(gname), type, 0);
- Delete(ActionFunc);
- } else {
- String *cname = Swig_name_get(NSpace, name);
- cpp_member_func(Char(cname), Char(gname), type, 0);
- Delete(cname);
- }
- Delete(gname);
- if (!GetFlag(n, "feature:immutable")) {
- gname = NewStringf(AttributeFunctionSet, symname);
- vty = NewString("void");
- if (!Extend) {
- ActionFunc = Copy(Swig_cmemberset_call(name, type));
- cpp_member_func(Char(gname), Char(gname), vty, p);
- Delete(ActionFunc);
- } else {
- String *cname = Swig_name_set(NSpace, name);
- cpp_member_func(Char(cname), Char(gname), vty, p);
- Delete(cname);
- }
- Delete(gname);
- }
- ActionFunc = 0;
- #endif
- }
- Swig_restore(n);
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::staticmembervariableHandler()
- * ---------------------------------------------------------------------- */
- int Language::staticmembervariableHandler(Node *n) {
- Swig_require("staticmembervariableHandler", n, "*name", "*sym:name", "*type", "?value", NIL);
- String *value = Getattr(n, "value");
- String *classname = !SmartPointer ? (is_non_virtual_protected_access(n) ? DirectorClassName : ClassName) : Getattr(CurrentClass, "allocate:smartpointerbase");
- if (!value || !Getattr(n, "hasconsttype")) {
- String *name = Getattr(n, "name");
- String *symname = Getattr(n, "sym:name");
- String *cname, *mrename;
- /* Create the variable name */
- mrename = Swig_name_member(0, ClassPrefix, symname);
- cname = NewStringf("%s::%s", classname, name);
- Setattr(n, "sym:name", mrename);
- Setattr(n, "name", cname);
- /* Wrap as an ordinary global variable */
- variableWrapper(n);
- Delete(mrename);
- Delete(cname);
- } else {
- /* This is a C++ static member declaration with an initializer and it's const.
- Certain C++ compilers optimize this out so that there is no linkage to a
- memory address. Example:
- class Foo {
- public:
- static const int x = 3;
- };
- Some discussion of this in section 9.4 of the C++ draft standard.
- Also, we have to manage the case:
- class Foo {
- public:
- %extend {
- static const int x = 3;
- }
- };
- in which there's no actual Foo::x variable to refer to. In this case,
- the best we can do is to wrap the given value verbatim.
- */
- String *name = Getattr(n, "name");
- String *cname = NewStringf("%s::%s", classname, name);
- if (Extend) {
- /* the variable is a synthesized one.
- There's nothing we can do; we just keep the given value */
- } else {
- /* we refer to the value as Foo::x */
- String *value = SwigType_namestr(cname);
- Setattr(n, "value", value);
- }
- SwigType *t1 = SwigType_typedef_resolve_all(Getattr(n, "type"));
- SwigType *t2 = SwigType_strip_qualifiers(t1);
- Setattr(n, "type", t2);
- Delete(t1);
- Delete(t2);
- SetFlag(n, "wrappedasconstant");
- memberconstantHandler(n);
- Delete(cname);
- }
- Swig_restore(n);
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::externDeclaration()
- * ---------------------------------------------------------------------- */
- int Language::externDeclaration(Node *n) {
- return emit_children(n);
- }
- /* ----------------------------------------------------------------------
- * Language::enumDeclaration()
- * ---------------------------------------------------------------------- */
- int Language::enumDeclaration(Node *n) {
- String *oldNSpace = NSpace;
- NSpace = Getattr(n, "sym:nspace");
- if (!ImportMode) {
- emit_children(n);
- }
- NSpace = oldNSpace;
- return SWIG_OK;
- }
- /* ----------------------------------------------------------------------
- * Language::enumvalueDeclaration()
- * ---------------------------------------------------------------------- */
- int Language…
Large files files are truncated, but you can click here to view the full file