String *Swig_new_subdirectory(String *basedirectory, String *subdirectory) {
String *error = 0;
int current_directory = Len(basedirectory) == 0;
if (current_directory || is_directory(basedirectory)) {
Iterator it;
String *dir = NewString(basedirectory);
List *subdirs = Split(subdirectory, SWIG_FILE_DELIMITER[0], INT_MAX);
for (it = First(subdirs); it.item; it = Next(it)) {
int result;
String *subdirectory = it.item;
Printf(dir, "%s", subdirectory);
#ifdef _WIN32
result = _mkdir(Char(dir));
#else
result = mkdir(Char(dir), 0777);
#endif
if (result != 0 && errno != EEXIST) {
error = NewStringf("Cannot create directory %s: %s", dir, strerror(errno));
break;
}
if (!is_directory(dir)) {
error = NewStringf("Cannot create directory %s: it may already exist but not be a directory", dir);
break;
}
Printf(dir, SWIG_FILE_DELIMITER);
}
} else {
error = NewStringf("Cannot create subdirectory %s under the base directory %s. Either the base does not exist as a directory or it is not readable.", subdirectory, basedirectory);
}
return error;
}
/* Create a name applying rename/namewarn if needed */
static String *apply_rename(String *newname, int fullname, String *prefix, String *name) {
String *result = 0;
if (newname && Len(newname)) {
if (Strcmp(newname, "$ignore") == 0) {
result = Copy(newname);
} else {
char *cnewname = Char(newname);
if (cnewname) {
int destructor = name && (*(Char(name)) == '~');
String *fmt = newname;
/* use name as a fmt, but avoid C++ "%" and "%=" operators */
if (Len(newname) > 1 && strchr(cnewname, '%') && !(strcmp(cnewname, "%=") == 0)) {
if (fullname && prefix) {
result = NewStringf(fmt, prefix, name);
} else {
result = NewStringf(fmt, name);
}
} else {
result = Copy(newname);
}
if (destructor && result && (*(Char(result)) != '~')) {
Insert(result, 0, "~");
}
}
}
}
return result;
}
/* -----------------------------------------------------------------------------
* Swig_cargs()
*
* Emit all of the local variables for a list of parameters. Returns the
* number of parameters.
* Default values for the local variables are only emitted if the compact default
* argument behaviour is required.
* ----------------------------------------------------------------------------- */
int Swig_cargs(Wrapper *w, ParmList *p) {
int i = 0;
int compactdefargs = ParmList_is_compactdefargs(p);
while (p != 0) {
String *lname = Swig_cparm_name(p, i);
SwigType *pt = Getattr(p, k_type);
if ((SwigType_type(pt) != T_VOID)) {
String *local = 0;
String *type = Getattr(p, k_type);
/* default values only emitted if in compact default args mode */
String *pvalue = (compactdefargs) ? Getattr(p, k_value) : 0;
SwigType *altty = SwigType_alttype(type, 0);
int tycode = SwigType_type(type);
if (tycode == T_REFERENCE) {
if (pvalue) {
SwigType *tvalue;
String *defname, *defvalue, *rvalue, *qvalue;
rvalue = SwigType_typedef_resolve_all(pvalue);
qvalue = SwigType_typedef_qualified(rvalue);
defname = NewStringf("%s_defvalue", lname);
tvalue = Copy(type);
SwigType_del_reference(tvalue);
tycode = SwigType_type(tvalue);
if (tycode != T_USER) {
/* plain primitive type, we copy the the def value */
String *lstr = SwigType_lstr(tvalue, defname);
defvalue = NewStringf("%s = %s", lstr, qvalue);
Delete(lstr);
} else {
/* user type, we copy the reference value */
String *str = SwigType_str(type, defname);
defvalue = NewStringf("%s = %s", str, qvalue);
Delete(str);
}
Wrapper_add_localv(w, defname, defvalue, NIL);
Delete(tvalue);
Delete(rvalue);
Delete(qvalue);
Delete(defname);
Delete(defvalue);
}
} else if (!pvalue && ((tycode == T_POINTER) || (tycode == T_STRING))) {
pvalue = (String *) "0";
}
if (!altty) {
local = Swig_clocal(pt, lname, pvalue);
} else {
local = Swig_clocal(altty, lname, pvalue);
Delete(altty);
}
Wrapper_add_localv(w, lname, local, NIL);
Delete(local);
i++;
}
Delete(lname);
p = nextSibling(p);
}
return (i);
}
void Swig_name_nameobj_add(Hash *name_hash, List *name_list, String *prefix, String *name, SwigType *decl, Hash *nameobj) {
String *nname = 0;
if (name && Len(name)) {
String *target_fmt = Getattr(nameobj, "targetfmt");
nname = prefix ? NewStringf("%s::%s", prefix, name) : NewString(name);
if (target_fmt) {
String *tmp = NewStringf(target_fmt, nname);
Delete(nname);
nname = tmp;
}
}
if (!nname || !Len(nname) || Getattr(nameobj, "fullname") || /* any of these options trigger a 'list' nameobj */
Getattr(nameobj, "sourcefmt") || Getattr(nameobj, "matchlist") || Getattr(nameobj, "regextarget")) {
if (decl)
Setattr(nameobj, "decl", decl);
if (nname && Len(nname))
Setattr(nameobj, "targetname", nname);
/* put the new nameobj at the beginnig of the list, such that the
last inserted rule take precedence */
Insert(name_list, 0, nameobj);
} else {
/* here we add an old 'hash' nameobj, simple and fast */
Swig_name_object_set(name_hash, nname, decl, nameobj);
}
Delete(nname);
}
int
Swig_MembersetToFunction(Node *n, String *classname, int flags) {
String *name;
ParmList *parms;
Parm *p;
SwigType *t;
SwigType *ty;
SwigType *type;
String *membername;
String *mangled;
String *self= 0;
if (flags & CWRAP_SMART_POINTER) {
self = NewString("(*this)->");
}
name = Getattr(n,"name");
type = Getattr(n,"type");
membername = Swig_name_member(classname, Swig_name_set(name));
mangled = Swig_name_mangle(membername);
t = NewString(classname);
SwigType_add_pointer(t);
parms = NewParm(t,"self");
Delete(t);
ty = Swig_wrapped_var_type(type);
p = NewParm(ty,name);
set_nextSibling(parms,p);
/* If the type is a pointer or reference. We mark it with a special wrap:disown attribute */
if (SwigType_check_decl(type,"p.")) {
Setattr(p,"wrap:disown","1");
}
Delete(p);
if (flags & CWRAP_EXTEND) {
String *code = Getattr(n,"code");
if (code) {
String *s = NewStringf("void %s(%s)", mangled, ParmList_str(parms));
Printv(s,code,"\n",NIL);
Setattr(n,"wrap:code",s);
Delete(s);
}
Setattr(n,"wrap:action", NewStringf("%s;\n", Swig_cfunction_call(mangled,parms)));
} else {
Setattr(n,"wrap:action", NewStringf("%s;\n", Swig_cmemberset_call(name,type,self)));
}
Setattr(n,"type","void");
Setattr(n,"parms", parms);
Delete(parms);
Delete(ty);
Delete(membername);
Delete(mangled);
Delete(self);
return SWIG_OK;
}
String *ParmList_str_multibrackets(ParmList *p) {
String *out;
String *parm_str = ParmList_str_defaultargs(p);
if (ParmList_len(p) > 1)
out = NewStringf("(%s)", parm_str);
else
out = NewStringf("%s", parm_str);
Delete(parm_str);
return out;
}
Hash *Swig_name_nameobj_lget(List *namelist, Node *n, String *prefix, String *name, String *decl) {
Hash *res = 0;
if (namelist) {
int len = Len(namelist);
int i;
int match = 0;
for (i = 0; !match && (i < len); i++) {
Hash *rn = Getitem(namelist, i);
String *rdecl = Getattr(rn, "decl");
if (rdecl && (!decl || !Equal(rdecl, decl))) {
continue;
} else if (Swig_name_match_nameobj(rn, n)) {
String *tname = Getattr(rn, "targetname");
if (tname) {
String *sfmt = Getattr(rn, "sourcefmt");
String *sname = 0;
int fullname = GetFlag(rn, "fullname");
int regextarget = GetFlag(rn, "regextarget");
if (sfmt) {
if (fullname && prefix) {
String *pname = NewStringf("%s::%s", prefix, name);
sname = NewStringf(sfmt, pname);
Delete(pname);
} else {
sname = NewStringf(sfmt, name);
}
} else {
if (fullname && prefix) {
sname = NewStringf("%s::%s", prefix, name);
} else {
sname = name;
DohIncref(name);
}
}
match = regextarget ? Swig_name_regexmatch_value(n, tname, sname)
: Swig_name_match_value(tname, sname);
Delete(sname);
} else {
/* Applying the renaming rule may fail if it contains a %(regex)s expression that doesn't match the given name. */
String *sname = NewStringf(Getattr(rn, "name"), name);
if (sname) {
if (Len(sname))
match = 1;
Delete(sname);
}
}
}
if (match) {
res = rn;
break;
}
}
}
return res;
}
static String *Swig_wrapped_var_assign(SwigType *t, const String_or_char *name, int varcref) {
if (SwigType_isclass(t)) {
if (varcref) {
return NewStringf("%s", name);
} else {
return NewStringf("&%s", name);
}
} else {
return SwigType_lcaststr(t, name);
}
}
DOH *
Swig_name_object_get(Hash *namehash, String *prefix, String *name, SwigType *decl) {
String *tname;
DOH *rn = 0;
Hash *n;
char *ncdecl = 0;
if (!namehash) return 0;
/* DB: This removed to more tightly control feature/name matching */
/* if ((decl) && (SwigType_isqualifier(decl))) {
ncdecl = strchr(Char(decl),'.');
ncdecl++;
}
*/
/* Perform a class-based lookup (if class prefix supplied) */
if (prefix) {
if (Len(prefix)) {
tname = NewStringf("%s::%s",prefix,name);
n = Getattr(namehash,tname);
rn = get_object(n,decl);
if ((!rn) && ncdecl) rn = get_object(n,ncdecl);
if (!rn) rn = get_object(n,0);
Delete(tname);
}
/* A wildcard-based class lookup */
if (!rn) {
tname = NewStringf("*::%s",name);
n = Getattr(namehash,tname);
rn = get_object(n,decl);
if ((!rn) && ncdecl) rn = get_object(n,ncdecl);
if (!rn) rn = get_object(n,0);
Delete(tname);
}
} else {
/* Lookup in the global namespace only */
tname = NewStringf("::%s",name);
n = Getattr(namehash,tname);
rn = get_object(n,decl);
if ((!rn) && ncdecl) rn = get_object(n,ncdecl);
if (!rn) rn = get_object(n,0);
Delete(tname);
}
/* Catch-all */
if (!rn) {
n = Getattr(namehash,name);
rn = get_object(n,decl);
if ((!rn) && ncdecl) rn = get_object(n,ncdecl);
if (!rn) rn = get_object(n,0);
}
return rn;
}
/* -----------------------------------------------------------------------------
* extension_code()
*
* Generates an extension function (a function defined in %extend)
*
* return_type function_name(parms) code
*
* ----------------------------------------------------------------------------- */
static String *extension_code(const String *function_name, ParmList *parms, SwigType *return_type, const String *code, int cplusplus, const String *self) {
String *parms_str = cplusplus ? ParmList_str_defaultargs(parms) : ParmList_str(parms);
String *sig = NewStringf("%s(%s)", function_name, parms_str);
String *rt_sig = SwigType_str(return_type, sig);
String *body = NewStringf("SWIGINTERN %s", rt_sig);
Printv(body, code, "\n", NIL);
if (self)
Replaceall(body, "$self", self);
Delete(parms_str);
Delete(sig);
Delete(rt_sig);
return body;
}
int Swig_DestructorToFunction(Node *n, String *classname, int cplus, int flags) {
SwigType *type;
Parm *p;
type = NewString(classname);
SwigType_add_pointer(type);
p = NewParm(type, k_self);
Setattr(p, k_self, "1");
Setattr(p, k_hidden, "1");
Setattr(p, k_wrapdisown, "1");
Delete(type);
type = NewString("void");
if (flags & CWRAP_EXTEND) {
String *cres;
String *call;
String *membername, *mangled, *code;
membername = Swig_name_destroy(classname);
mangled = Swig_name_mangle(membername);
code = Getattr(n, k_code);
if (code) {
Swig_add_extension_code(n, mangled, p, type, code, cparse_cplusplus, k_self);
}
call = Swig_cfunction_call(mangled, p);
cres = NewStringf("%s;\n", call);
Setattr(n, k_wrapaction, cres);
Delete(membername);
Delete(mangled);
Delete(call);
Delete(cres);
} else {
if (cplus) {
String *call = Swig_cppdestructor_call(n);
String *cres = NewStringf("%s\n", call);
Setattr(n, k_wrapaction, cres);
Delete(call);
Delete(cres);
} else {
String *call = Swig_cdestructor_call(n);
String *cres = NewStringf("%s\n", call);
Setattr(n, k_wrapaction, cres);
Delete(call);
Delete(cres);
}
}
Setattr(n, k_type, type);
Setattr(n, k_parms, p);
Delete(type);
Delete(p);
return SWIG_OK;
}
static String *Swig_wrapped_var_deref(SwigType *t, String_or_char *name, int varcref) {
if (SwigType_isclass(t)) {
if (varcref) {
if (cparse_cplusplus) {
return NewStringf("*%s", name);
} else {
return NewStringf("%s", name);
}
} else {
return NewStringf("*%s", name);
}
} else {
return SwigType_rcaststr(t, name);
}
}
void Swig_restore(Node *n) {
String *temp;
int len;
List *l;
String *ns;
Iterator ki;
ns = Getattr(n, "view");
assert(ns);
l = NewList();
temp = NewStringf("%s:", ns);
len = Len(temp);
for (ki = First(n); ki.key; ki = Next(ki)) {
if (Strncmp(temp, ki.key, len) == 0) {
Append(l, ki.key);
}
}
for (ki = First(l); ki.item; ki = Next(ki)) {
DOH *obj = Getattr(n, ki.item);
Setattr(n, Char(ki.item) + len, obj);
Delattr(n, ki.item);
}
Delete(l);
Delete(temp);
}
static
void SwigType_add_default(String *def, SwigType *nr) {
if (Strcmp(nr, "SWIGTYPE") == 0) {
Append(def, "SWIGTYPE");
} else {
String *q = SwigType_isqualifier(nr) ? SwigType_pop(nr) : 0;
if (q && strstr(Char(nr), "SWIGTYPE")) {
Append(def, nr);
} else {
String *nd = SwigType_default(nr);
if (nd) {
String *bdef = nd;
if (q) {
bdef = NewStringf("%s%s", q, nd);
if ((Strcmp(nr, bdef) == 0)) {
Delete(bdef);
bdef = nd;
} else {
Delete(nd);
}
}
Append(def, bdef);
Delete(bdef);
} else {
Append(def, nr);
}
}
Delete(q);
}
}
int Swig_VarsetToFunction(Node *n, int flags) {
String *name, *nname;
ParmList *parms;
SwigType *type, *ty;
int varcref = flags & CWRAP_NATURAL_VAR;
name = Getattr(n, "name");
type = Getattr(n, "type");
nname = SwigType_namestr(name);
ty = Swig_wrapped_var_type(type, varcref);
parms = NewParm(ty, name);
if (flags & CWRAP_EXTEND) {
String *sname = Swig_name_set(name);
String *mangled = Swig_name_mangle(sname);
String *call = Swig_cfunction_call(mangled, parms);
String *cres = NewStringf("%s;", call);
Setattr(n, "wrap:action", cres);
Delete(cres);
Delete(call);
Delete(mangled);
Delete(sname);
} else {
if (!Strstr(type, "enum $unnamed")) {
String *pname = Swig_cparm_name(0, 0);
String *dref = Swig_wrapped_var_deref(type, pname, varcref);
String *call = NewStringf("%s = %s;", nname, dref);
Setattr(n, "wrap:action", call);
Delete(call);
Delete(dref);
Delete(pname);
} else {
String *pname = Swig_cparm_name(0, 0);
String *call = NewStringf("if (sizeof(int) == sizeof(%s)) *(int*)(void*)&(%s) = %s;", nname, nname, pname);
Setattr(n, "wrap:action", call);
Delete(pname);
Delete(call);
}
}
Setattr(n, "type", "void");
Setattr(n, "parms", parms);
Delete(parms);
Delete(ty);
Delete(nname);
return SWIG_OK;
}
String *
Swig_wrapped_var_deref(SwigType *t, String_or_char *name) {
if (SwigType_isclass(t)) {
return NewStringf("*%s",name);
} else {
return SwigType_rcaststr(t,name);
}
}
String *Swig_cparm_name(Parm *p, int i) {
String *name = NewStringf("arg%d", i + 1);
if (p) {
Setattr(p, k_lname, name);
}
return name;
}
void Swig_require(const char *ns, Node *n, ...) {
va_list ap;
char *name;
DOH *obj;
va_start(ap, n);
name = va_arg(ap, char *);
while (name) {
int newref = 0;
int opt = 0;
if (*name == '*') {
newref = 1;
name++;
} else if (*name == '?') {
newref = 1;
opt = 1;
name++;
}
obj = Getattr(n, name);
if (!opt && !obj) {
Swig_error(Getfile(n), Getline(n), "Fatal error (Swig_require). Missing attribute '%s' in node '%s'.\n", name, nodeType(n));
assert(obj);
}
if (!obj)
obj = DohNone;
if (newref) {
/* Save a copy of the attribute */
Setattr(n, NewStringf("%s:%s", ns, name), obj);
}
name = va_arg(ap, char *);
}
va_end(ap);
/* Save the view */
{
String *view = Getattr(n, "view");
if (view) {
if (Strcmp(view, ns) != 0) {
Setattr(n, NewStringf("%s:view", ns), view);
Setattr(n, "view", NewString(ns));
}
} else {
Setattr(n, "view", NewString(ns));
}
}
}
int Swig_cargs(Wrapper *w, ParmList *p) {
int i;
SwigType *pt;
String *pvalue;
String *pname;
String *local;
String *lname;
SwigType *altty;
String *type;
int tycode;
i = 0;
while (p != 0) {
lname = Swig_cparm_name(p,i);
pt = Getattr(p,"type");
if ((SwigType_type(pt) != T_VOID)) {
pname = Getattr(p,"name");
pvalue = Getattr(p,"value");
altty = Getattr(p,"alttype");
type = Getattr(p,"type");
tycode = SwigType_type(type);
if (tycode == T_REFERENCE) {
if (pvalue) {
String *defname, *defvalue;
defname = NewStringf("%s_defvalue", lname);
defvalue = NewStringf("%s = %s", SwigType_str(type,defname), pvalue);
Wrapper_add_localv(w,defname, defvalue, NIL);
Delete(defname);
Delete(defvalue);
}
} else if (!pvalue && (tycode == T_POINTER)) {
pvalue = (String *) "0";
}
if (!altty) {
local = Swig_clocal(pt,lname,pvalue);
} else {
local = Swig_clocal(altty,lname, pvalue);
}
Wrapper_add_localv(w,lname,local,NIL);
i++;
}
p = nextSibling(p);
}
return(i);
}
SwigType *SwigType_add_qualifier(SwigType *t, const_String_or_char_ptr qual) {
String *newq;
int sz, added = 0;
char *q, *cqual;
char *c = Char(t);
cqual = Char(qual);
if (!(strncmp(c, "q(", 2) == 0)) {
String *temp = NewStringf("q(%s).", cqual);
Insert(t, 0, temp);
Delete(temp);
return t;
}
/* The type already has a qualifier on it. In this case, we first check to
see if the qualifier is already specified. In that case do nothing.
If it is a new qualifier, we add it to the qualifier list in alphabetical
order */
sz = element_size(c);
if (strstr(c, cqual)) {
/* Qualifier already added */
return t;
}
/* Add the qualifier to the existing list. */
newq = NewString("q(");
q = c + 2;
q = strtok(q, " ).");
while (q) {
if (strcmp(cqual, q) < 0) {
/* New qualifier is less that current qualifier. We need to insert it */
Append(newq, cqual);
Append(newq, " ");
Append(newq, q);
added = 1;
} else {
Append(newq, q);
}
q = strtok(NULL, " ).");
if (q) {
Append(newq, " ");
}
}
if (!added) {
Append(newq, " ");
Append(newq, cqual);
}
Append(newq, ").");
Delslice(t, 0, sz);
Insert(t, 0, newq);
Delete(newq);
return t;
}
static void replace_nspace(String *name, const_String_or_char_ptr nspace) {
if (nspace) {
String *namspace = NewStringf("%s_", nspace);
Replaceall(namspace, NSPACE_SEPARATOR, "_");
Replace(name, "%n", namspace, DOH_REPLACE_ANY);
Delete(namspace);
} else {
Replace(name, "%n", "", DOH_REPLACE_ANY);
}
}
SwigType *SwigType_add_qualifier(SwigType *t, const_String_or_char_ptr qual) {
List *qlist;
String *allq, *newq;
int i, sz;
const char *cqprev = 0;
const char *c = Char(t);
const char *cqual = Char(qual);
/* if 't' has no qualifiers and 'qual' is a single qualifier, simply add it */
if ((strncmp(c, "q(", 2) != 0) && (strstr(cqual, " ") == 0)) {
String *temp = NewStringf("q(%s).", cqual);
Insert(t, 0, temp);
Delete(temp);
return t;
}
/* create string of all qualifiers */
if (strncmp(c, "q(", 2) == 0) {
allq = SwigType_parm(t);
Append(allq, " ");
SwigType_del_element(t); /* delete old qualifier list from 't' */
} else {
allq = NewStringEmpty();
}
Append(allq, qual);
/* create list of all qualifiers from string */
qlist = Split(allq, ' ', INT_MAX);
Delete(allq);
/* sort in alphabetical order */
SortList(qlist, Strcmp);
/* create new qualifier string from unique elements of list */
sz = Len(qlist);
newq = NewString("q(");
for (i = 0; i < sz; ++i) {
String *q = Getitem(qlist, i);
const char *cq = Char(q);
if (cqprev == 0 || strcmp(cqprev, cq) != 0) {
if (i > 0) {
Append(newq, " ");
}
Append(newq, q);
cqprev = cq;
}
}
Append(newq, ").");
Delete(qlist);
/* replace qualifier string with new one */
Insert(t, 0, newq);
Delete(newq);
return t;
}
String *Swig_cppdestructor_call(Node *n) {
String *unref = Swig_unref_call(n);
if (unref) {
return unref;
} else {
String *pname = Swig_cparm_name(0, 0);
String *call = NewStringf("delete %s;", pname);
Delete(pname);
return call;
}
}
int
Swig_DestructorToFunction(Node *n, String *classname, int cplus, int flags)
{
SwigType *type;
Parm *p;
type = NewString(classname);
SwigType_add_pointer(type);
p = NewParm(type,"self");
Delete(type);
type = NewString("void");
if (flags & CWRAP_EXTEND) {
String *membername, *mangled, *code;
membername = Swig_name_destroy(classname);
mangled = Swig_name_mangle(membername);
code = Getattr(n,"code");
if (code) {
String *s = NewStringf("void %s(%s)", mangled, ParmList_str(p));
Printv(s,code,"\n",NIL);
Setattr(n,"wrap:code",s);
Delete(s);
}
Setattr(n,"wrap:action", NewStringf("%s;\n", Swig_cfunction_call(mangled,p)));
Delete(membername);
Delete(mangled);
} else {
if (cplus) {
String* action = NewString("");
Printf(action, "%s;\n", Swig_cppdestructor_call());
Setattr(n,"wrap:action", action);
} else {
Setattr(n,"wrap:action", NewStringf("%s;\n", Swig_cdestructor_call()));
}
}
Setattr(n,"type",type);
Setattr(n,"parms", p);
Delete(type);
Delete(p);
return SWIG_OK;
}
String *Swig_new_subdirectory(String *basedirectory, String *subdirectory) {
String *error = 0;
struct stat st;
int current_directory = basedirectory ? (Len(basedirectory) == 0 ? 1 : 0) : 0;
if (current_directory || is_directory(basedirectory)) {
Iterator it;
String *dir = basedirectory ? NewString(basedirectory) : NewString("");
List *subdirs = Split(subdirectory, SWIG_FILE_DELIMITER[0], INT_MAX);
for (it = First(subdirs); it.item; it = Next(it)) {
int statdir;
String *subdirectory = it.item;
Printf(dir, "%s", subdirectory);
statdir = stat(Char(dir), &st);
if (statdir == 0) {
Printf(dir, SWIG_FILE_DELIMITER);
if (S_ISDIR(st.st_mode)) {
continue;
} else {
error = NewStringf("Cannot create directory %s", dir);
break;
}
} else {
#ifdef _WIN32
int result = _mkdir(Char(dir));
#else
int result = mkdir(Char(dir), 0777);
#endif
Printf(dir, SWIG_FILE_DELIMITER);
if (result != 0 && errno != EEXIST) {
error = NewStringf("Cannot create directory %s", dir);
break;
}
}
}
} else {
error = NewStringf("Cannot create subdirectory %s under the base directory %s. Either the base does not exist as a directory or it is not readable.", subdirectory, basedirectory);
}
return error;
}
void Swig_warn(const char *filename, int line, const char *msg) {
String *key;
if (!warnings) {
warnings = NewHash();
}
key = NewStringf("%s:%d", filename, line);
if (!Getattr(warnings, key)) {
Printf(stderr, "swig-dev warning:%s:%d:%s\n", filename, line, msg);
Setattr(warnings, key, key);
}
Delete(key);
}
String *Swig_string_strip(String *s) {
String *ns;
if (!Len(s)) {
ns = NewString(s);
} else {
const char *cs = Char(s);
const char *ce = Strchr(cs, ']');
if (*cs != '[' || !ce) {
ns = NewString(s);
} else {
String *fmt = NewStringf("%%.%ds", ce-cs-1);
String *prefix = NewStringf(fmt, cs+1);
if (0 == Strncmp(ce+1, prefix, Len(prefix))) {
ns = NewString(ce+1+Len(prefix));
} else {
ns = NewString(ce+1);
}
}
}
return ns;
}
void Swig_name_object_inherit(Hash *namehash, String *base, String *derived) {
Iterator ki;
String *bprefix;
String *dprefix;
char *cbprefix;
int plen;
if (!namehash)
return;
bprefix = NewStringf("%s::", base);
dprefix = NewStringf("%s::", derived);
cbprefix = Char(bprefix);
plen = strlen(cbprefix);
for (ki = First(namehash); ki.key; ki = Next(ki)) {
char *k = Char(ki.key);
if (strncmp(k, cbprefix, plen) == 0) {
Iterator oi;
String *nkey = NewStringf("%s%s", dprefix, k + plen);
Hash *n = ki.item;
Hash *newh = Getattr(namehash, nkey);
if (!newh) {
newh = NewHash();
Setattr(namehash, nkey, newh);
Delete(newh);
}
for (oi = First(n); oi.key; oi = Next(oi)) {
if (!Getattr(newh, oi.key)) {
String *ci = Copy(oi.item);
Setattr(newh, oi.key, ci);
Delete(ci);
}
}
Delete(nkey);
}
}
Delete(bprefix);
Delete(dprefix);
}
void Swig_save(const char *ns, Node *n, ...) {
va_list ap;
char *name;
DOH *obj;
va_start(ap, n);
name = va_arg(ap, char *);
while (name) {
if (*name == '*') {
name++;
} else if (*name == '?') {
name++;
}
obj = Getattr(n, name);
if (!obj)
obj = DohNone;
/* Save a copy of the attribute */
if (Setattr(n, NewStringf("%s:%s", ns, name), obj)) {
Printf(stderr, "Swig_save('%s','%s'): Warning, attribute '%s' was already saved.\n", ns, nodeType(n), name);
}
name = va_arg(ap, char *);
}
va_end(ap);
/* Save the view */
{
String *view = Getattr(n, "view");
if (view) {
if (Strcmp(view, ns) != 0) {
Setattr(n, NewStringf("%s:view", ns), view);
Setattr(n, "view", NewString(ns));
}
} else {
Setattr(n, "view", NewString(ns));
}
}
}
int
Swig_MembergetToFunction(Node *n, String *classname, int flags) {
String *name;
ParmList *parms;
SwigType *t;
SwigType *ty;
SwigType *type;
String *membername;
String *mangled;
String *self = 0;
if (flags & CWRAP_SMART_POINTER) {
self = NewString("(*this)->");
}
name = Getattr(n,"name");
type = Getattr(n,"type");
membername = Swig_name_member(classname, Swig_name_get(name));
mangled = Swig_name_mangle(membername);
t = NewString(classname);
SwigType_add_pointer(t);
parms = NewParm(t,"self");
Delete(t);
ty = Swig_wrapped_var_type(type);
if (flags & CWRAP_EXTEND) {
String *code = Getattr(n,"code");
if (code) {
String *tmp = NewStringf("%s(%s)", mangled, ParmList_str(parms));
String *s = SwigType_str(ty,tmp);
Delete(tmp);
Printv(s,code,"\n",NIL);
Setattr(n,"wrap:code",s);
Delete(s);
}
Setattr(n,"wrap:action", Swig_cresult(ty,"result",Swig_cfunction_call(mangled,parms)));
} else {
Setattr(n,"wrap:action", Swig_cresult(ty,"result",Swig_cmemberget_call(name,type,self)));
}
Setattr(n,"type",ty);
Setattr(n,"parms", parms);
Delete(parms);
Delete(ty);
Delete(membername);
Delete(mangled);
return SWIG_OK;
}
