Nested classes support
Closes #89 Squash merge branch 'master' of https://github.com/wkalinin/swig into wkalinin-nested By Vladimir Kalinin * 'master' of https://github.com/wkalinin/swig: CPlusPlusOut mode for Octave nested class illustration fixed "Abstract" flag for nested classes added an example enabled anonymous nested structs runtime test porting warnings disabled porting fixes java runtime tests ported nested class closing bracket offset fixed removed double nested template (not supported by %template parsing) template_nested test extended parent field made public property access fixed replaced tabs with spaces warning W-reorder deprecated warnings removed, derived_nested runtime test added optimized string indenting Nested classes indenting nested classes docs fixed the order in which flattened inner classes are added after the outer Private nested classes were getting into the type table. Java getProxyName() fix for nested classes fixes the case when nested classes is forward declared Fix for a case when a nested class inherits from the same base as the outer. (Base class constructor declaration is found first in this case) merge fix nested C struct first immediate declaration incorrectly renamed sample fixed tests updated to reflect nested classes support Java nested classes support (1) flattening should remove the link to the outer class access mode correctly set/restored for nested classes nested templates should be skipped while flattening (template nodes themselves, not expanded versions) also non-public nested classes should be ignored If nested classes are not supported, default behaviour is flattening, not ignoring flag "nested" is preserved, so, the nested classes can be ignored by user nested workaround test updated template instantiated within a class is marked as nested for ignoring purposes %ignore not applied to the nested classed, because "nested" flag is set too late typedef name takes precedence over the real name (reason?) unnamed structs should be processed for all the languages nested C struct instances are wrapped as "immutable" tree building typedef declaration for unnamed C structures fixed nested classes "flattening" fixed %ignoring nested classes renamed "nested" attribute to "nested:outer" added "nested" flag, to be used with $ignore (it is not removed while flattening) added nestedClassesSupported() function to the Language interface renamed "nested" attribute to "nested:outer" added "nested" flag, to be used with $ignore (it is not removed while flattening) added nestedClassesSupported() function to the Language interface tree iteration fix dirclassname variable names unified memory issue fixed merge error ignore unnamed structs for C++ unnamed nested C structs naming & unnesting class added to classes hash under typedef name private nested classes skipped test updated due to nested templates support anonymous structs with inheritance fixed nested_class test to allow anonymous structs w/o declarator tests updated: nested workaround removed from namespace_class.i propagated nested template declaration to the C++ file injected members scope nested tempplates fixes, nested structures in "C" mode parsing added utility function "appendSibling" (like "appendChild") nested unnamed structures parsing fixes, access mode restored on nested class end, tdname is properly patched with outer class name prefix memory management fixes nested templates (1) Nested unnamed structs Nested class support (1) Nested class support (1)
This commit is contained in:
Vladimir Kalinin
William S Fulton
parent
fcd0480364
commit
b63c4839fe
39 changed files with 1449 additions and 1111 deletions
|
|
@ -178,6 +178,20 @@ class TypePass:private Dispatcher {
|
|||
}
|
||||
continue;
|
||||
}
|
||||
// A case when both outer and nested classes inherit from the same parent. Constructor may be found instead of the class itself.
|
||||
} else if (GetFlag(cls, "nested") && checkAttribute(bcls, "nodeType", "constructor")) {
|
||||
bcls = Getattr(bcls, "parentNode");
|
||||
if (Getattr(bcls, "typepass:visit")) {
|
||||
if (!Getattr(bcls, "feature:onlychildren")) {
|
||||
if (!ilist)
|
||||
ilist = alist = NewList();
|
||||
Append(ilist, bcls);
|
||||
} else {
|
||||
Swig_warning(WARN_TYPE_UNDEFINED_CLASS, Getfile(bname), Getline(bname), "Base class '%s' has no name as it is an empty template instantiated with '%%template()'. Ignored.\n", SwigType_namestr(bname));
|
||||
Swig_warning(WARN_TYPE_UNDEFINED_CLASS, Getfile(bcls), Getline(bcls), "The %%template directive must be written before '%s' is used as a base class and be declared with a name.\n", SwigType_namestr(bname));
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (Strcmp(nodeType(bcls), "classforward") != 0) {
|
||||
Swig_error(Getfile(bname), Getline(bname), "'%s' is not a valid base class.\n", SwigType_namestr(bname));
|
||||
|
|
@ -463,6 +477,18 @@ class TypePass:private Dispatcher {
|
|||
SwigType_typedef(unnamed, tdname);
|
||||
}
|
||||
|
||||
// name of the outer class should already be patched to contain it's outer classes names, but not to contain namespaces
|
||||
// namespace name (if present) is added after processing child nodes
|
||||
if (Getattr(n, "nested:outer") && name) {
|
||||
String* outerName = Getattr(Getattr(n, "nested:outer"), "name");
|
||||
name = NewStringf("%s::%s", outerName, name);
|
||||
Setattr(n, "name", name);
|
||||
if (tdname) {
|
||||
tdname = NewStringf("%s::%s", outerName, tdname);
|
||||
Setattr(n, "tdname", tdname);
|
||||
}
|
||||
}
|
||||
|
||||
if (nsname && name) {
|
||||
nname = NewStringf("%s::%s", nsname, name);
|
||||
String *tdname = Getattr(n, "tdname");
|
||||
|
|
@ -479,7 +505,7 @@ class TypePass:private Dispatcher {
|
|||
SwigType_attach_symtab(Getattr(n, "symtab"));
|
||||
|
||||
/* Inherit type definitions into the class */
|
||||
if (name) {
|
||||
if (name && !(GetFlag(n, "nested") && GetFlag(n, "feature:flatnested") && !checkAttribute(n, "access", "public"))) {
|
||||
cplus_inherit_types(n, 0, nname ? nname : (fname ? fname : name));
|
||||
}
|
||||
|
||||
|
|
@ -1258,3 +1284,432 @@ void Swig_process_types(Node *n) {
|
|||
return;
|
||||
TypePass::pass(n);
|
||||
}
|
||||
|
||||
// Nested classes processing section
|
||||
static Hash* classhash = 0;
|
||||
|
||||
static String *make_name(Node *n, String *name,SwigType *decl) {
|
||||
int destructor = name && (*(Char(name)) == '~');
|
||||
if (String* yyrename = Getattr(n, "class_rename")) {
|
||||
String *s = NewString(yyrename);
|
||||
Delattr(n, "class_rename");
|
||||
if (destructor && (*(Char(s)) != '~')) {
|
||||
Insert(s,0,"~");
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
if (!name) return 0;
|
||||
return Swig_name_make(n,0,name,decl,0);
|
||||
}
|
||||
|
||||
// C version of add_symbols()
|
||||
static void add_symbols_c(Node *n) {
|
||||
String *decl;
|
||||
String *wrn = 0;
|
||||
String *symname = 0;
|
||||
int iscdecl = Cmp(nodeType(n),"cdecl") == 0;
|
||||
Setattr(n,"ismember","1");
|
||||
Setattr(n,"access", "public");
|
||||
if (Getattr(n,"sym:name"))
|
||||
return;
|
||||
decl = Getattr(n,"decl");
|
||||
if (!SwigType_isfunction(decl)) {
|
||||
String *name = Getattr(n,"name");
|
||||
String *makename = Getattr(n,"parser:makename");
|
||||
if (iscdecl) {
|
||||
String *storage = Getattr(n, "storage");
|
||||
if (Cmp(storage,"typedef") == 0) {
|
||||
Setattr(n,"kind","typedef");
|
||||
} else {
|
||||
SwigType *type = Getattr(n,"type");
|
||||
String *value = Getattr(n,"value");
|
||||
Setattr(n,"kind","variable");
|
||||
if (value && Len(value)) {
|
||||
Setattr(n,"hasvalue","1");
|
||||
}
|
||||
if (type) {
|
||||
SwigType *ty;
|
||||
SwigType *tmp = 0;
|
||||
if (decl) {
|
||||
ty = tmp = Copy(type);
|
||||
SwigType_push(ty,decl);
|
||||
} else {
|
||||
ty = type;
|
||||
}
|
||||
if (!SwigType_ismutable(ty)) {
|
||||
SetFlag(n,"hasconsttype");
|
||||
SetFlag(n,"feature:immutable");
|
||||
}
|
||||
if (tmp) Delete(tmp);
|
||||
}
|
||||
if (!type) {
|
||||
Printf(stderr,"notype name %s\n", name);
|
||||
}
|
||||
}
|
||||
}
|
||||
Swig_features_get(Swig_cparse_features(), 0, name, 0, n);
|
||||
if (makename) {
|
||||
symname = make_name(n, makename, 0);
|
||||
Delattr(n,"parser:makename"); /* temporary information, don't leave it hanging around */
|
||||
} else {
|
||||
makename = name;
|
||||
symname = make_name(n, makename, 0);
|
||||
}
|
||||
|
||||
if (!symname) {
|
||||
symname = Copy(Getattr(n,"unnamed"));
|
||||
}
|
||||
if (symname) {
|
||||
wrn = Swig_name_warning(n, 0, symname,0);
|
||||
}
|
||||
} else {
|
||||
String *name = Getattr(n,"name");
|
||||
SwigType *fdecl = Copy(decl);
|
||||
SwigType *fun = SwigType_pop_function(fdecl);
|
||||
if (iscdecl) {
|
||||
Setattr(n,"kind","function");
|
||||
}
|
||||
|
||||
Swig_features_get(Swig_cparse_features(),0,name,fun,n);
|
||||
|
||||
symname = make_name(n, name, fun);
|
||||
wrn = Swig_name_warning(n, 0, symname,fun);
|
||||
|
||||
Delete(fdecl);
|
||||
Delete(fun);
|
||||
|
||||
}
|
||||
if (!symname)
|
||||
return;
|
||||
if (GetFlag(n,"feature:ignore")) {
|
||||
/* Only add to C symbol table and continue */
|
||||
Swig_symbol_add(0, n);
|
||||
} else if (strncmp(Char(symname),"$ignore",7) == 0) {
|
||||
char *c = Char(symname)+7;
|
||||
SetFlag(n,"feature:ignore");
|
||||
if (strlen(c)) {
|
||||
SWIG_WARN_NODE_BEGIN(n);
|
||||
Swig_warning(0,Getfile(n), Getline(n), "%s\n",c+1);
|
||||
SWIG_WARN_NODE_END(n);
|
||||
}
|
||||
Swig_symbol_add(0, n);
|
||||
} else {
|
||||
Node *c;
|
||||
if ((wrn) && (Len(wrn))) {
|
||||
String *metaname = symname;
|
||||
if (!Getmeta(metaname,"already_warned")) {
|
||||
SWIG_WARN_NODE_BEGIN(n);
|
||||
Swig_warning(0,Getfile(n),Getline(n), "%s\n", wrn);
|
||||
SWIG_WARN_NODE_END(n);
|
||||
Setmeta(metaname,"already_warned","1");
|
||||
}
|
||||
}
|
||||
c = Swig_symbol_add(symname,n);
|
||||
|
||||
if (c != n) {
|
||||
/* symbol conflict attempting to add in the new symbol */
|
||||
if (Getattr(n,"sym:weak")) {
|
||||
Setattr(n,"sym:name",symname);
|
||||
} else {
|
||||
String *e = NewStringEmpty();
|
||||
String *en = NewStringEmpty();
|
||||
String *ec = NewStringEmpty();
|
||||
int redefined = Swig_need_redefined_warn(n,c,true);
|
||||
if (redefined) {
|
||||
Printf(en,"Identifier '%s' redefined (ignored)",symname);
|
||||
Printf(ec,"previous definition of '%s'",symname);
|
||||
} else {
|
||||
Printf(en,"Redundant redeclaration of '%s'",symname);
|
||||
Printf(ec,"previous declaration of '%s'",symname);
|
||||
}
|
||||
if (Cmp(symname,Getattr(n,"name"))) {
|
||||
Printf(en," (Renamed from '%s')", SwigType_namestr(Getattr(n,"name")));
|
||||
}
|
||||
Printf(en,",");
|
||||
if (Cmp(symname,Getattr(c,"name"))) {
|
||||
Printf(ec," (Renamed from '%s')", SwigType_namestr(Getattr(c,"name")));
|
||||
}
|
||||
Printf(ec,".");
|
||||
SWIG_WARN_NODE_BEGIN(n);
|
||||
if (redefined) {
|
||||
Swig_warning(WARN_PARSE_REDEFINED,Getfile(n),Getline(n),"%s\n",en);
|
||||
Swig_warning(WARN_PARSE_REDEFINED,Getfile(c),Getline(c),"%s\n",ec);
|
||||
} else {
|
||||
Swig_warning(WARN_PARSE_REDUNDANT,Getfile(n),Getline(n),"%s\n",en);
|
||||
Swig_warning(WARN_PARSE_REDUNDANT,Getfile(c),Getline(c),"%s\n",ec);
|
||||
}
|
||||
SWIG_WARN_NODE_END(n);
|
||||
Printf(e,"%s:%d:%s\n%s:%d:%s\n",Getfile(n),Getline(n),en,
|
||||
Getfile(c),Getline(c),ec);
|
||||
Setattr(n,"error",e);
|
||||
Delete(e);
|
||||
Delete(en);
|
||||
Delete(ec);
|
||||
}
|
||||
}
|
||||
}
|
||||
Delete(symname);
|
||||
}
|
||||
|
||||
/* Strips C-style and C++-style comments from string in-place. */
|
||||
static void strip_comments(char *string) {
|
||||
int state = 0; /*
|
||||
* 0 - not in comment
|
||||
* 1 - in c-style comment
|
||||
* 2 - in c++-style comment
|
||||
* 3 - in string
|
||||
* 4 - after reading / not in comments
|
||||
* 5 - after reading * in c-style comments
|
||||
* 6 - after reading \ in strings
|
||||
*/
|
||||
char * c = string;
|
||||
while (*c) {
|
||||
switch (state) {
|
||||
case 0:
|
||||
if (*c == '\"')
|
||||
state = 3;
|
||||
else if (*c == '/')
|
||||
state = 4;
|
||||
break;
|
||||
case 1:
|
||||
if (*c == '*')
|
||||
state = 5;
|
||||
*c = ' ';
|
||||
break;
|
||||
case 2:
|
||||
if (*c == '\n')
|
||||
state = 0;
|
||||
else
|
||||
*c = ' ';
|
||||
break;
|
||||
case 3:
|
||||
if (*c == '\"')
|
||||
state = 0;
|
||||
else if (*c == '\\')
|
||||
state = 6;
|
||||
break;
|
||||
case 4:
|
||||
if (*c == '/') {
|
||||
*(c-1) = ' ';
|
||||
*c = ' ';
|
||||
state = 2;
|
||||
} else if (*c == '*') {
|
||||
*(c-1) = ' ';
|
||||
*c = ' ';
|
||||
state = 1;
|
||||
} else
|
||||
state = 0;
|
||||
break;
|
||||
case 5:
|
||||
if (*c == '/')
|
||||
state = 0;
|
||||
else
|
||||
state = 1;
|
||||
*c = ' ';
|
||||
break;
|
||||
case 6:
|
||||
state = 3;
|
||||
break;
|
||||
}
|
||||
++c;
|
||||
}
|
||||
}
|
||||
|
||||
// Create an %insert with a typedef to make a new name visible to C
|
||||
// the code is moved from parser.y, dump_nested() function with minor changes
|
||||
static Node* create_insert(Node* n, bool noTypedef = false) {
|
||||
// format a typedef
|
||||
String* ccode = Getattr(n, "code");
|
||||
Push(ccode, " ");
|
||||
if (noTypedef) {
|
||||
Push(ccode, Getattr(n, "name"));
|
||||
Push(ccode, " ");
|
||||
Push(ccode, Getattr(n, "kind"));
|
||||
} else {
|
||||
Push(ccode, Getattr(n, "kind"));
|
||||
Push(ccode, "typedef ");
|
||||
Append(ccode, " ");
|
||||
Append(ccode, Getattr(n, "tdname"));
|
||||
}
|
||||
Append(ccode, ";");
|
||||
|
||||
|
||||
/* Strip comments - further code may break in presence of comments. */
|
||||
strip_comments(Char(ccode));
|
||||
|
||||
/* Make all SWIG created typedef structs/unions/classes unnamed else
|
||||
redefinition errors occur - nasty hack alert.*/
|
||||
if (!noTypedef) {
|
||||
const char* types_array[3] = {"struct", "union", "class"};
|
||||
for (int i = 0; i < 3; i++) {
|
||||
char* code_ptr = Char(ccode);
|
||||
while (code_ptr) {
|
||||
/* Replace struct name (as in 'struct name {...}' ) with whitespace
|
||||
name will be between struct and opening brace */
|
||||
|
||||
code_ptr = strstr(code_ptr, types_array[i]);
|
||||
if (code_ptr) {
|
||||
char *open_bracket_pos;
|
||||
code_ptr += strlen(types_array[i]);
|
||||
open_bracket_pos = strchr(code_ptr, '{');
|
||||
if (open_bracket_pos) {
|
||||
/* Make sure we don't have something like struct A a; */
|
||||
char* semi_colon_pos = strchr(code_ptr, ';');
|
||||
if (!(semi_colon_pos && (semi_colon_pos < open_bracket_pos)))
|
||||
while (code_ptr < open_bracket_pos)
|
||||
*code_ptr++ = ' ';
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
{
|
||||
/* Remove SWIG directive %constant which may be left in the SWIG created typedefs */
|
||||
char* code_ptr = Char(ccode);
|
||||
while (code_ptr) {
|
||||
code_ptr = strstr(code_ptr, "%constant");
|
||||
if (code_ptr) {
|
||||
char* directive_end_pos = strchr(code_ptr, ';');
|
||||
if (directive_end_pos) {
|
||||
while (code_ptr <= directive_end_pos)
|
||||
*code_ptr++ = ' ';
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Node *newnode = NewHash();
|
||||
set_nodeType(newnode ,"insert");
|
||||
Setfile(newnode ,Getfile(n));
|
||||
Setline(newnode ,Getline(n));
|
||||
String *code = NewStringEmpty();
|
||||
Wrapper_pretty_print(ccode, code);
|
||||
Setattr(newnode, "code", code);
|
||||
Delete(code);
|
||||
Delattr(n, "code");
|
||||
return newnode;
|
||||
}
|
||||
|
||||
static void insertNodeAfter(Node *n, Node* c)
|
||||
{
|
||||
Node* g = parentNode(n);
|
||||
set_parentNode(c, g);
|
||||
Node* ns = nextSibling(n);
|
||||
if (Node* outer = Getattr(c, "nested:outer")) {
|
||||
while (ns && outer == Getattr(ns, "nested:outer")) {
|
||||
n = ns;
|
||||
ns = nextSibling(n);
|
||||
}
|
||||
}
|
||||
if (!ns) {
|
||||
set_lastChild(g, c);
|
||||
}
|
||||
else {
|
||||
set_nextSibling(c, ns);
|
||||
set_previousSibling(ns, c);
|
||||
}
|
||||
set_nextSibling(n, c);
|
||||
set_previousSibling(c, n);
|
||||
}
|
||||
|
||||
void Swig_name_unnamed_c_structs(Node *n) {
|
||||
if (!classhash)
|
||||
classhash = Getattr(n, "classes");
|
||||
Node* c = firstChild(n);
|
||||
while (c) {
|
||||
Node* next = nextSibling(c);
|
||||
if (String* declName = Getattr(c, "nested:unnamed")) {
|
||||
if (Node* outer = Getattr(c, "nested:outer")) {
|
||||
// generate a name
|
||||
String* name = NewStringf("%s_%s", Getattr(outer, "name"), declName);
|
||||
Delattr(c, "nested:unnamed");
|
||||
// set the name to the class and symbol table
|
||||
Setattr(c, "tdname", name);
|
||||
Setattr(c, "name", name);
|
||||
Swig_symbol_setscope(Getattr(c,"symtab"));
|
||||
Swig_symbol_setscopename(name);
|
||||
// now that we have a name - gather base symbols
|
||||
if (List* publicBases = Getattr(c,"baselist")) {
|
||||
List* bases = Swig_make_inherit_list(name, publicBases, 0);
|
||||
Swig_inherit_base_symbols(bases);
|
||||
Delete(bases);
|
||||
}
|
||||
Setattr(classhash,name,c);
|
||||
Swig_symbol_popscope();
|
||||
// process declarations following this type (assign correct new type)
|
||||
SwigType* ty = Copy(name);
|
||||
Node* decl = nextSibling(c);
|
||||
List* declList = NewList();
|
||||
while (decl && Getattr(decl, "nested:unnamedtype") == c) {
|
||||
Setattr(decl, "type", ty);
|
||||
Append(declList, decl);
|
||||
Delattr(decl, "nested:unnamedtype");
|
||||
SetFlag(decl, "feature:immutable");
|
||||
add_symbols_c(decl);
|
||||
decl = nextSibling(decl);
|
||||
}
|
||||
Delete(ty);
|
||||
// Check for extensions
|
||||
/* // TODO: we can save extensions hash like class hash and move check_extensions() after nesting processing
|
||||
if (extendhash) {
|
||||
if (Node *am = Getattr(extendhash, name)) {
|
||||
// Merge the extension into the symbol table
|
||||
merge_extensions(c, am);
|
||||
append_previous_extension(c, am);
|
||||
Delattr(extendhash, clsname);
|
||||
}
|
||||
}*/
|
||||
Swig_symbol_setscope(Swig_symbol_global_scope());
|
||||
add_symbols_c(c);
|
||||
|
||||
Node* ins = create_insert(c);
|
||||
insertNodeAfter(c, ins);
|
||||
removeNode(c);
|
||||
insertNodeAfter(n, c);
|
||||
Delete(ins);
|
||||
Delattr(c, "nested:outer");
|
||||
}else {
|
||||
// global unnamed struct - ignore it
|
||||
c = next;
|
||||
continue;
|
||||
}
|
||||
} else if (CPlusPlusOut) {
|
||||
if (Getattr(c, "nested:outer")) {
|
||||
Node* ins = create_insert(c, true);
|
||||
insertNodeAfter(c, ins);
|
||||
Delete(ins);
|
||||
Delattr(c, "nested:outer");
|
||||
}
|
||||
}
|
||||
// process children
|
||||
Swig_name_unnamed_c_structs(c);
|
||||
c = next;
|
||||
}
|
||||
}
|
||||
static void remove_outer_class_reference(Node *n)
|
||||
{
|
||||
for (Node* c = firstChild(n); c; c = nextSibling(c)) {
|
||||
if (GetFlag(c, "feature:flatnested")) {
|
||||
Delattr(c, "nested:outer");
|
||||
remove_outer_class_reference(c);
|
||||
}
|
||||
}
|
||||
}
|
||||
void Swig_process_nested_classes(Node *n) {
|
||||
Node* c = firstChild(n);
|
||||
while (c) {
|
||||
Node* next = nextSibling(c);
|
||||
if (!Getattr(c,"templatetype")) {
|
||||
if (GetFlag(c, "nested") && GetFlag(c, "feature:flatnested")) {
|
||||
removeNode(c);
|
||||
if (!checkAttribute(c, "access", "public"))
|
||||
SetFlag(c, "feature:ignore");
|
||||
else
|
||||
insertNodeAfter(n, c);
|
||||
}
|
||||
Swig_process_nested_classes(c);
|
||||
}
|
||||
c = next;
|
||||
}
|
||||
remove_outer_class_reference(n);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue