Another merge with master.
Updated Doxygen error numbers yet again, as Python errors got added in the meanwhile, pushing the Doxygen ones further off. And re-merged PEP8/whitespace-related conflicts in autodoc_runme.py once again (if anybody is looking for a motivating example about why significant whitespace is bad, here is a great use case).
This commit is contained in:
Vadim Zeitlin
commit
302955a152
448 changed files with 8836 additions and 5079 deletions
|
|
@ -13,9 +13,6 @@
|
|||
|
||||
#include "swigmod.h"
|
||||
#include "cparse.h"
|
||||
|
||||
static int treduce = SWIG_cparse_template_reduce(0);
|
||||
|
||||
#include <ctype.h>
|
||||
#include <errno.h>
|
||||
#include <stdlib.h>
|
||||
|
|
@ -993,6 +990,7 @@ public:
|
|||
|
||||
if (directorsEnabled()) {
|
||||
// Insert director runtime into the f_runtime file (make it occur before %header section)
|
||||
Swig_insert_file("director_common.swg", f_runtime);
|
||||
Swig_insert_file("director.swg", f_runtime);
|
||||
}
|
||||
|
||||
|
|
@ -1212,7 +1210,7 @@ public:
|
|||
const char *py3_end1 = Strchr(rpkg, '.');
|
||||
if (!py3_end1)
|
||||
py3_end1 = (Char(rpkg)) + Len(rpkg);
|
||||
py3_rlen1 = py3_end1 - (Char(rpkg));
|
||||
py3_rlen1 = (int)(py3_end1 - Char(rpkg));
|
||||
} else {
|
||||
rpkg = NewString("");
|
||||
}
|
||||
|
|
@ -1389,7 +1387,7 @@ public:
|
|||
* pythoncode() - Output python code into the shadow file
|
||||
* ------------------------------------------------------------ */
|
||||
|
||||
String *pythoncode(String *code, const_String_or_char_ptr indent) {
|
||||
String *pythoncode(String *code, const_String_or_char_ptr indent, String * file, int line) {
|
||||
String *out = NewString("");
|
||||
String *temp;
|
||||
char *t;
|
||||
|
|
@ -1407,38 +1405,91 @@ public:
|
|||
/* Split the input text into lines */
|
||||
List *clist = SplitLines(temp);
|
||||
Delete(temp);
|
||||
int initial = 0;
|
||||
String *s = 0;
|
||||
Iterator si;
|
||||
/* Get the initial indentation */
|
||||
|
||||
for (si = First(clist); si.item; si = Next(si)) {
|
||||
s = si.item;
|
||||
if (Len(s)) {
|
||||
char *c = Char(s);
|
||||
while (*c) {
|
||||
if (!isspace(*c))
|
||||
break;
|
||||
initial++;
|
||||
c++;
|
||||
}
|
||||
if (*c && !isspace(*c)) {
|
||||
break;
|
||||
} else {
|
||||
initial = 0;
|
||||
}
|
||||
// Line number within the pythoncode.
|
||||
int py_line = 0;
|
||||
|
||||
String * initial = 0;
|
||||
Iterator si;
|
||||
|
||||
/* Get the initial indentation. Skip lines which only contain whitespace
|
||||
* and/or a comment, as the indentation of those doesn't matter:
|
||||
*
|
||||
* A logical line that contains only spaces, tabs, formfeeds and
|
||||
* possibly a comment, is ignored (i.e., no NEWLINE token is
|
||||
* generated).
|
||||
*
|
||||
* see:
|
||||
* https://docs.python.org/2/reference/lexical_analysis.html#blank-lines
|
||||
* https://docs.python.org/3/reference/lexical_analysis.html#blank-lines
|
||||
*/
|
||||
for (si = First(clist); si.item; si = Next(si), ++py_line) {
|
||||
const char *c = Char(si.item);
|
||||
int i;
|
||||
for (i = 0; isspace((unsigned char)c[i]); i++) {
|
||||
// Scan forward until we find a non-space (which may be a nul byte).
|
||||
}
|
||||
char ch = c[i];
|
||||
if (ch && ch != '#') {
|
||||
// Found a line with actual content.
|
||||
initial = NewStringWithSize(c, i);
|
||||
break;
|
||||
}
|
||||
if (ch) {
|
||||
Printv(out, indent, c, NIL);
|
||||
}
|
||||
Putc('\n', out);
|
||||
}
|
||||
while (si.item) {
|
||||
s = si.item;
|
||||
if (Len(s) > initial) {
|
||||
char *c = Char(s);
|
||||
c += initial;
|
||||
|
||||
// Process remaining lines.
|
||||
for ( ; si.item; si = Next(si), ++py_line) {
|
||||
const char *c = Char(si.item);
|
||||
// If no prefixed line was found, the above loop should have completed.
|
||||
assert(initial);
|
||||
|
||||
int i;
|
||||
for (i = 0; isspace((unsigned char)c[i]); i++) {
|
||||
// Scan forward until we find a non-space (which may be a nul byte).
|
||||
}
|
||||
char ch = c[i];
|
||||
if (!ch) {
|
||||
// Line is just whitespace - emit an empty line.
|
||||
Putc('\n', out);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (ch == '#') {
|
||||
// Comment - the indentation doesn't matter to python, but try to
|
||||
// adjust the whitespace for the benefit of human readers (though SWIG
|
||||
// currently seems to always remove any whitespace before a '#' before
|
||||
// we get here, in which case we'll just leave the comment at the start
|
||||
// of the line).
|
||||
if (i >= Len(initial)) {
|
||||
Printv(out, indent, NIL);
|
||||
}
|
||||
|
||||
Printv(out, c + i, "\n", NIL);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (i < Len(initial)) {
|
||||
// There's non-whitespace in the initial prefix of this line.
|
||||
Swig_error(file, line, "Line indented less than expected (line %d of pythoncode)\n", py_line);
|
||||
Printv(out, indent, c, "\n", NIL);
|
||||
} else {
|
||||
Printv(out, "\n", NIL);
|
||||
if (memcmp(c, Char(initial), Len(initial)) == 0) {
|
||||
// Prefix matches initial, so just remove it.
|
||||
Printv(out, indent, c + Len(initial), "\n", NIL);
|
||||
continue;
|
||||
}
|
||||
Swig_warning(WARN_PYTHON_INDENT_MISMATCH,
|
||||
file, line, "Whitespace prefix doesn't match (line %d of pythoncode)\n", py_line);
|
||||
// To avoid gratuitously breaking interface files which worked with
|
||||
// SWIG <= 3.0.5, we remove a prefix of the same number of bytes for
|
||||
// lines which start with different whitespace to the line we got
|
||||
// 'initial' from.
|
||||
Printv(out, indent, c + Len(initial), "\n", NIL);
|
||||
}
|
||||
si = Next(si);
|
||||
}
|
||||
Delete(clist);
|
||||
return out;
|
||||
|
|
@ -1811,10 +1862,17 @@ public:
|
|||
// Only do the autodoc if there isn't a docstring for the class
|
||||
String *str = Getattr(n, "feature:docstring");
|
||||
if (!str || Len(str) == 0) {
|
||||
if (CPlusPlus) {
|
||||
Printf(doc, "Proxy of C++ %s class", real_classname);
|
||||
if (builtin) {
|
||||
String *name = Getattr(n, "name");
|
||||
String *rname = add_explicit_scope(SwigType_namestr(name));
|
||||
Printf(doc, "%s", rname);
|
||||
Delete(rname);
|
||||
} else {
|
||||
Printf(doc, "Proxy of C %s struct", real_classname);
|
||||
if (CPlusPlus) {
|
||||
Printf(doc, "Proxy of C++ %s class", real_classname);
|
||||
} else {
|
||||
Printf(doc, "Proxy of C %s struct", real_classname);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1926,7 +1984,7 @@ public:
|
|||
|
||||
// Avoid unnecessary string allocation in the common case when we don't
|
||||
// need to remove any suffix.
|
||||
return *end == '\0' ? v : NewStringWithSize(s, end - s);
|
||||
return *end == '\0' ? v : NewStringWithSize(s, (int)(end - s));
|
||||
}
|
||||
|
||||
return NIL;
|
||||
|
|
@ -1937,9 +1995,12 @@ public:
|
|||
* Check if string v can be a Python value literal or a
|
||||
* constant. Return NIL if it isn't.
|
||||
* ------------------------------------------------------------ */
|
||||
String *convertValue(String *v, SwigType *t) {
|
||||
String *convertValue(String *v, SwigType *type) {
|
||||
const char *const s = Char(v);
|
||||
char *end;
|
||||
String *result = NIL;
|
||||
bool fail = false;
|
||||
SwigType *resolved_type = 0;
|
||||
|
||||
// Check if this is a number in any base.
|
||||
long value = strtol(s, &end, 0);
|
||||
|
|
@ -1948,93 +2009,108 @@ public:
|
|||
if (errno == ERANGE) {
|
||||
// There was an overflow, we could try representing the value as Python
|
||||
// long integer literal, but for now don't bother with it.
|
||||
return NIL;
|
||||
}
|
||||
fail = true;
|
||||
} else {
|
||||
if (*end != '\0') {
|
||||
// If there is a suffix after the number, we can safely ignore any
|
||||
// combination of "l" and "u", but not anything else (again, stuff like
|
||||
// "LL" could be handled, but we don't bother to do it currently).
|
||||
bool seen_long = false;
|
||||
for (char* p = end; *p != '\0'; ++p) {
|
||||
switch (*p) {
|
||||
case 'l':
|
||||
case 'L':
|
||||
// Bail out on "LL".
|
||||
if (seen_long) {
|
||||
fail = true;
|
||||
break;
|
||||
}
|
||||
seen_long = true;
|
||||
break;
|
||||
|
||||
if (*end != '\0') {
|
||||
// If there is a suffix after the number, we can safely ignore any
|
||||
// combination of "l" and "u", but not anything else (again, stuff like
|
||||
// "LL" could be handled, but we don't bother to do it currently).
|
||||
bool seen_long = false;
|
||||
for (char* p = end; *p != '\0'; ++p) {
|
||||
switch (*p) {
|
||||
case 'l':
|
||||
case 'L':
|
||||
// Bail out on "LL".
|
||||
if (seen_long)
|
||||
return NIL;
|
||||
seen_long = true;
|
||||
break;
|
||||
case 'u':
|
||||
case 'U':
|
||||
break;
|
||||
|
||||
case 'u':
|
||||
case 'U':
|
||||
break;
|
||||
|
||||
default:
|
||||
// Except that our suffix could actually be the fractional part of
|
||||
// a floating point number, so we still have to check for this.
|
||||
return convertDoubleValue(v);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Deal with the values starting with 0 first as they can be octal or
|
||||
// hexadecimal numbers or even pointers.
|
||||
if (s[0] == '0') {
|
||||
if (Len(v) == 1) {
|
||||
// This is just a lone 0, but it needs to be represented differently
|
||||
// in Python depending on whether it's a zero or a null pointer.
|
||||
if (SwigType_ispointer(t))
|
||||
return NewString("None");
|
||||
else
|
||||
return v;
|
||||
} else if (s[1] == 'x' || s[1] == 'X') {
|
||||
// This must have been a hex number, we can use it directly in Python,
|
||||
// so nothing to do here.
|
||||
} else {
|
||||
// This must have been an octal number, we have to change its prefix
|
||||
// to be "0o" in Python 3 only (and as long as we still support Python
|
||||
// 2.5, this can't be done unconditionally).
|
||||
if (py3) {
|
||||
if (end - s > 1) {
|
||||
String *res = NewString("0o");
|
||||
Append(res, NewStringWithSize(s + 1, end - s - 1));
|
||||
return res;
|
||||
default:
|
||||
// Except that our suffix could actually be the fractional part of
|
||||
// a floating point number, so we still have to check for this.
|
||||
result = convertDoubleValue(v);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Avoid unnecessary string allocation in the common case when we don't
|
||||
// need to remove any suffix.
|
||||
return *end == '\0' ? v : NewStringWithSize(s, end - s);
|
||||
if (!fail) {
|
||||
// Allow integers as the default value for a bool parameter.
|
||||
resolved_type = SwigType_typedef_resolve_all(type);
|
||||
if (Cmp(resolved_type, "bool") == 0) {
|
||||
result = NewString(value ? "True" : "False");
|
||||
} else {
|
||||
// Deal with the values starting with 0 first as they can be octal or
|
||||
// hexadecimal numbers or even pointers.
|
||||
if (s[0] == '0') {
|
||||
if (Len(v) == 1) {
|
||||
// This is just a lone 0, but it needs to be represented differently
|
||||
// in Python depending on whether it's a zero or a null pointer.
|
||||
if (SwigType_ispointer(resolved_type))
|
||||
result = NewString("None");
|
||||
else
|
||||
result = v;
|
||||
} else if (s[1] == 'x' || s[1] == 'X') {
|
||||
// This must have been a hex number, we can use it directly in Python,
|
||||
// so nothing to do here.
|
||||
} else {
|
||||
// This must have been an octal number, we have to change its prefix
|
||||
// to be "0o" in Python 3 only (and as long as we still support Python
|
||||
// 2.5, this can't be done unconditionally).
|
||||
if (py3) {
|
||||
if (end - s > 1) {
|
||||
result = NewString("0o");
|
||||
Append(result, NewStringWithSize(s + 1, (int)(end - s - 1)));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Avoid unnecessary string allocation in the common case when we don't
|
||||
// need to remove any suffix.
|
||||
if (!result)
|
||||
result = *end == '\0' ? v : NewStringWithSize(s, (int)(end - s));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Check if this is a floating point number (notice that it wasn't
|
||||
// necessarily parsed as a long above, consider e.g. ".123").
|
||||
if (String *res = convertDoubleValue(v)) {
|
||||
return res;
|
||||
}
|
||||
if (!fail && !result) {
|
||||
result = convertDoubleValue(v);
|
||||
if (!result) {
|
||||
if (Strcmp(v, "true") == 0 || Strcmp(v, "TRUE") == 0)
|
||||
result = NewString("True");
|
||||
else if (Strcmp(v, "false") == 0 || Strcmp(v, "FALSE") == 0)
|
||||
result = NewString("False");
|
||||
else if (Strcmp(v, "NULL") == 0 || Strcmp(v, "nullptr") == 0) {
|
||||
if (!resolved_type)
|
||||
resolved_type = SwigType_typedef_resolve_all(type);
|
||||
result = SwigType_ispointer(resolved_type) ? NewString("None") : NewString("0");
|
||||
}
|
||||
|
||||
if (Strcmp(v, "true") == 0 || Strcmp(v, "TRUE") == 0)
|
||||
return NewString("True");
|
||||
if (Strcmp(v, "false") == 0 || Strcmp(v, "FALSE") == 0)
|
||||
return NewString("False");
|
||||
if (Strcmp(v, "NULL") == 0 || Strcmp(v, "nullptr") == 0)
|
||||
return SwigType_ispointer(t) ? NewString("None") : NewString("0");
|
||||
|
||||
// This could also be an enum type, default value of which could be
|
||||
// representable in Python if it doesn't include any scope (which could,
|
||||
// but currently is not, translated).
|
||||
if (!Strchr(s, ':')) {
|
||||
Node *lookup = Swig_symbol_clookup(v, 0);
|
||||
if (lookup) {
|
||||
if (Cmp(Getattr(lookup, "nodeType"), "enumitem") == 0)
|
||||
return Getattr(lookup, "sym:name");
|
||||
// This could also be an enum type, default value of which could be
|
||||
// representable in Python if it doesn't include any scope (which could,
|
||||
// but currently is not, translated).
|
||||
else if (!Strchr(s, ':')) {
|
||||
Node *lookup = Swig_symbol_clookup(v, 0);
|
||||
if (lookup) {
|
||||
if (Cmp(Getattr(lookup, "nodeType"), "enumitem") == 0)
|
||||
result = Getattr(lookup, "sym:name");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return NIL;
|
||||
Delete(resolved_type);
|
||||
return result;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------
|
||||
|
|
@ -2047,34 +2123,40 @@ public:
|
|||
* at C++ code level where they can always be handled.
|
||||
* ------------------------------------------------------------ */
|
||||
bool is_representable_as_pyargs(Node *n) {
|
||||
bool is_representable = true;
|
||||
|
||||
ParmList *plist = CopyParmList(Getattr(n, "parms"));
|
||||
Swig_typemap_attach_parms("default", plist, NULL);
|
||||
|
||||
Parm *p;
|
||||
Parm *pnext;
|
||||
|
||||
for (p = plist; p; p = pnext) {
|
||||
pnext = NIL;
|
||||
pnext = nextSibling(p);
|
||||
String *tm = Getattr(p, "tmap:in");
|
||||
if (tm) {
|
||||
pnext = Getattr(p, "tmap:in:next");
|
||||
Parm *in_next = Getattr(p, "tmap:in:next");
|
||||
if (in_next)
|
||||
pnext = in_next;
|
||||
if (checkAttribute(p, "tmap:in:numinputs", "0")) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (!pnext) {
|
||||
pnext = nextSibling(p);
|
||||
}
|
||||
|
||||
// "default" typemap can contain arbitrary C++ code, so while it could, in
|
||||
// principle, be possible to examine it and check if it's just something
|
||||
// simple of the form "$1 = expression" and then use convertValue() to
|
||||
// check if expression can be used in Python, but for now we just
|
||||
// pessimistically give up and prefer to handle this at C++ level only.
|
||||
if (Getattr(p, "tmap:default"))
|
||||
return false;
|
||||
|
||||
if (String *value = Getattr(p, "value")) {
|
||||
String *type = Getattr(p, "type");
|
||||
if (!convertValue(value, type)) {
|
||||
is_representable = false;
|
||||
break;
|
||||
}
|
||||
if (!convertValue(value, type))
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return is_representable;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -2116,8 +2198,17 @@ public:
|
|||
if (nn)
|
||||
n = nn;
|
||||
|
||||
/* For overloaded function, just use *args */
|
||||
if (is_real_overloaded(n) || GetFlag(n, "feature:compactdefaultargs") || !is_representable_as_pyargs(n)) {
|
||||
/* We prefer to explicitly list all parameters of the C function in the
|
||||
generated Python code as this makes the function more convenient to use,
|
||||
however in some cases we must replace the real parameters list with just
|
||||
the catch all "*args". This happens when:
|
||||
|
||||
1. The function is overloaded as Python doesn't support this.
|
||||
2. We were explicitly asked to use the "compact" arguments form.
|
||||
3. We were explicitly asked to use default args from C via the "python:cdefaultargs" feature.
|
||||
4. One of the default argument values can't be represented in Python.
|
||||
*/
|
||||
if (is_real_overloaded(n) || GetFlag(n, "feature:compactdefaultargs") || GetFlag(n, "feature:python:cdefaultargs") || !is_representable_as_pyargs(n)) {
|
||||
String *parms = NewString("");
|
||||
if (in_class)
|
||||
Printf(parms, "self, ");
|
||||
|
|
@ -2256,10 +2347,10 @@ public:
|
|||
if (have_docstring(n))
|
||||
Printv(f_dest, tab4, docstring(n, AUTODOC_FUNC), "\n", NIL);
|
||||
if (have_pythonprepend(n))
|
||||
Printv(f_dest, pythoncode(pythonprepend(n), tab4), "\n", NIL);
|
||||
Printv(f_dest, pythoncode(pythonprepend(n), tab4, Getfile(n), Getline(n)), "\n", NIL);
|
||||
if (have_pythonappend(n)) {
|
||||
Printv(f_dest, tab4 "val = ", funcCall(name, callParms), "\n", NIL);
|
||||
Printv(f_dest, pythoncode(pythonappend(n), tab4), "\n", NIL);
|
||||
Printv(f_dest, pythoncode(pythonappend(n), tab4, Getfile(n), Getline(n)), "\n", NIL);
|
||||
Printv(f_dest, tab4 "return val\n", NIL);
|
||||
} else {
|
||||
Printv(f_dest, tab4 "return ", funcCall(name, callParms), "\n", NIL);
|
||||
|
|
@ -2746,14 +2837,12 @@ public:
|
|||
Printv(f->locals, " char * kwnames[] = ", kwargs, ";\n", NIL);
|
||||
}
|
||||
|
||||
if (use_parse || allow_kwargs || !modernargs) {
|
||||
if (builtin && in_class && tuple_arguments == 0) {
|
||||
Printf(parse_args, " if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;\n");
|
||||
} else {
|
||||
Printf(parse_args, ":%s\"", iname);
|
||||
Printv(parse_args, arglist, ")) SWIG_fail;\n", NIL);
|
||||
funpack = 0;
|
||||
}
|
||||
if (builtin && !funpack && in_class && tuple_arguments == 0) {
|
||||
Printf(parse_args, " if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_exception_fail(SWIG_TypeError, \"%s takes no arguments\");\n", iname);
|
||||
} else if (use_parse || allow_kwargs || !modernargs) {
|
||||
Printf(parse_args, ":%s\"", iname);
|
||||
Printv(parse_args, arglist, ")) SWIG_fail;\n", NIL);
|
||||
funpack = 0;
|
||||
} else {
|
||||
Clear(parse_args);
|
||||
if (funpack) {
|
||||
|
|
@ -3120,6 +3209,17 @@ public:
|
|||
}
|
||||
|
||||
/* If this is a builtin type, create a PyGetSetDef entry for this member variable. */
|
||||
if (builtin) {
|
||||
const char *memname = "__dict__";
|
||||
Hash *h = Getattr(builtin_getset, memname);
|
||||
if (!h) {
|
||||
h = NewHash();
|
||||
Setattr(builtin_getset, memname, h);
|
||||
Delete(h);
|
||||
}
|
||||
Setattr(h, "getter", "SwigPyObject_get___dict__");
|
||||
}
|
||||
|
||||
if (builtin_getter) {
|
||||
String *memname = Getattr(n, "membervariableHandler:sym:name");
|
||||
if (!memname)
|
||||
|
|
@ -3853,7 +3953,7 @@ public:
|
|||
else
|
||||
quoted_symname = NewStringf("\"%s\"", symname);
|
||||
}
|
||||
String *quoted_rname = NewStringf("\"%s\"", rname);
|
||||
String *quoted_tp_doc_str = NewStringf("\"%s\"", getSlot(n, "feature:python:tp_doc"));
|
||||
char const *tp_init = builtin_tp_init ? Char(builtin_tp_init) : Swig_directorclass(n) ? "0" : "SwigPyBuiltin_BadInit";
|
||||
String *tp_flags = NewString("Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES");
|
||||
String *py3_tp_flags = NewString("Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE");
|
||||
|
|
@ -3904,7 +4004,7 @@ public:
|
|||
printSlot(f, tp_doc, "tp_doc");
|
||||
Delete(tp_doc);
|
||||
} else {
|
||||
printSlot(f, quoted_rname, "tp_doc");
|
||||
printSlot(f, quoted_tp_doc_str, "tp_doc");
|
||||
}
|
||||
printSlot(f, getSlot(n, "feature:python:tp_traverse"), "tp_traverse", "traverseproc");
|
||||
printSlot(f, getSlot(n, "feature:python:tp_clear"), "tp_clear", "inquiry");
|
||||
|
|
@ -4088,7 +4188,7 @@ public:
|
|||
Delete(tp_flags);
|
||||
Delete(py3_tp_flags);
|
||||
Delete(quoted_symname);
|
||||
Delete(quoted_rname);
|
||||
Delete(quoted_tp_doc_str);
|
||||
Delete(clientdata_klass);
|
||||
Delete(richcompare_func);
|
||||
Delete(getset_name);
|
||||
|
|
@ -4183,7 +4283,18 @@ public:
|
|||
Printv(base_class, abcs, NIL);
|
||||
}
|
||||
|
||||
if (!builtin) {
|
||||
if (builtin) {
|
||||
if (have_docstring(n)) {
|
||||
String *str = cdocstring(n, AUTODOC_CLASS);
|
||||
Setattr(n, "feature:python:tp_doc", str);
|
||||
Delete(str);
|
||||
} else {
|
||||
String *name = Getattr(n, "name");
|
||||
String *rname = add_explicit_scope(SwigType_namestr(name));
|
||||
Setattr(n, "feature:python:tp_doc", rname);
|
||||
Delete(rname);
|
||||
}
|
||||
} else {
|
||||
Printv(f_shadow, "class ", class_name, NIL);
|
||||
|
||||
if (Len(base_class)) {
|
||||
|
|
@ -4462,7 +4573,7 @@ public:
|
|||
have_repr = 1;
|
||||
}
|
||||
if (Getattr(n, "feature:shadow")) {
|
||||
String *pycode = pythoncode(Getattr(n, "feature:shadow"), tab4);
|
||||
String *pycode = pythoncode(Getattr(n, "feature:shadow"), tab4, Getfile(n), Getline(n));
|
||||
String *pyaction = NewStringf("%s.%s", module, fullname);
|
||||
Replaceall(pycode, "$action", pyaction);
|
||||
Delete(pyaction);
|
||||
|
|
@ -4484,12 +4595,12 @@ public:
|
|||
Printv(f_shadow, tab8, docstring(n, AUTODOC_METHOD), "\n", NIL);
|
||||
if (have_pythonprepend(n)) {
|
||||
fproxy = 0;
|
||||
Printv(f_shadow, pythoncode(pythonprepend(n), tab8), "\n", NIL);
|
||||
Printv(f_shadow, pythoncode(pythonprepend(n), tab8, Getfile(n), Getline(n)), "\n", NIL);
|
||||
}
|
||||
if (have_pythonappend(n)) {
|
||||
fproxy = 0;
|
||||
Printv(f_shadow, tab8, "val = ", funcCall(fullname, callParms), "\n", NIL);
|
||||
Printv(f_shadow, pythoncode(pythonappend(n), tab8), "\n", NIL);
|
||||
Printv(f_shadow, pythoncode(pythonappend(n), tab8, Getfile(n), Getline(n)), "\n", NIL);
|
||||
Printv(f_shadow, tab8, "return val\n\n", NIL);
|
||||
} else {
|
||||
Printv(f_shadow, tab8, "return ", funcCall(fullname, callParms), "\n\n", NIL);
|
||||
|
|
@ -4569,10 +4680,10 @@ public:
|
|||
if (have_docstring(n))
|
||||
Printv(f_shadow, tab8, docstring(n, AUTODOC_STATICFUNC), "\n", NIL);
|
||||
if (have_pythonprepend(n))
|
||||
Printv(f_shadow, pythoncode(pythonprepend(n), tab8), "\n", NIL);
|
||||
Printv(f_shadow, pythoncode(pythonprepend(n), tab8, Getfile(n), Getline(n)), "\n", NIL);
|
||||
if (have_pythonappend(n)) {
|
||||
Printv(f_shadow, tab8, "val = ", funcCall(Swig_name_member(NSPACE_TODO, class_name, symname), callParms), "\n", NIL);
|
||||
Printv(f_shadow, pythoncode(pythonappend(n), tab8), "\n", NIL);
|
||||
Printv(f_shadow, pythoncode(pythonappend(n), tab8, Getfile(n), Getline(n)), "\n", NIL);
|
||||
Printv(f_shadow, tab8, "return val\n\n", NIL);
|
||||
} else {
|
||||
Printv(f_shadow, tab8, "return ", funcCall(Swig_name_member(NSPACE_TODO, class_name, symname), callParms), "\n\n", NIL);
|
||||
|
|
@ -4657,7 +4768,7 @@ public:
|
|||
if (!have_constructor && handled_as_init) {
|
||||
if (!builtin) {
|
||||
if (Getattr(n, "feature:shadow")) {
|
||||
String *pycode = pythoncode(Getattr(n, "feature:shadow"), tab4);
|
||||
String *pycode = pythoncode(Getattr(n, "feature:shadow"), tab4, Getfile(n), Getline(n));
|
||||
String *pyaction = NewStringf("%s.%s", module, Swig_name_construct(NSPACE_TODO, symname));
|
||||
Replaceall(pycode, "$action", pyaction);
|
||||
Delete(pyaction);
|
||||
|
|
@ -4686,17 +4797,17 @@ public:
|
|||
if (have_docstring(n))
|
||||
Printv(f_shadow, tab8, docstring(n, AUTODOC_CTOR), "\n", NIL);
|
||||
if (have_pythonprepend(n))
|
||||
Printv(f_shadow, pythoncode(pythonprepend(n), tab8), "\n", NIL);
|
||||
Printv(f_shadow, pythoncode(pythonprepend(n), tab8, Getfile(n), Getline(n)), "\n", NIL);
|
||||
Printv(f_shadow, pass_self, NIL);
|
||||
if (fastinit) {
|
||||
Printv(f_shadow, tab8, module, ".", class_name, "_swiginit(self,", funcCall(Swig_name_construct(NSPACE_TODO, symname), callParms), ")\n", NIL);
|
||||
Printv(f_shadow, tab8, module, ".", class_name, "_swiginit(self, ", funcCall(Swig_name_construct(NSPACE_TODO, symname), callParms), ")\n", NIL);
|
||||
} else {
|
||||
Printv(f_shadow,
|
||||
tab8, "this = ", funcCall(Swig_name_construct(NSPACE_TODO, symname), callParms), "\n",
|
||||
tab8, "try:\n", tab8, tab4, "self.this.append(this)\n", tab8, "except:\n", tab8, tab4, "self.this = this\n", NIL);
|
||||
}
|
||||
if (have_pythonappend(n))
|
||||
Printv(f_shadow, pythoncode(pythonappend(n), tab8), "\n\n", NIL);
|
||||
Printv(f_shadow, pythoncode(pythonappend(n), tab8, Getfile(n), Getline(n)), "\n\n", NIL);
|
||||
Delete(pass_self);
|
||||
}
|
||||
have_constructor = 1;
|
||||
|
|
@ -4705,7 +4816,7 @@ public:
|
|||
/* Hmmm. We seem to be creating a different constructor. We're just going to create a
|
||||
function for it. */
|
||||
if (Getattr(n, "feature:shadow")) {
|
||||
String *pycode = pythoncode(Getattr(n, "feature:shadow"), "");
|
||||
String *pycode = pythoncode(Getattr(n, "feature:shadow"), "", Getfile(n), Getline(n));
|
||||
String *pyaction = NewStringf("%s.%s", module, Swig_name_construct(NSPACE_TODO, symname));
|
||||
Replaceall(pycode, "$action", pyaction);
|
||||
Delete(pyaction);
|
||||
|
|
@ -4719,7 +4830,7 @@ public:
|
|||
if (have_docstring(n))
|
||||
Printv(f_shadow_stubs, tab4, docstring(n, AUTODOC_CTOR), "\n", NIL);
|
||||
if (have_pythonprepend(n))
|
||||
Printv(f_shadow_stubs, pythoncode(pythonprepend(n), tab4), "\n", NIL);
|
||||
Printv(f_shadow_stubs, pythoncode(pythonprepend(n), tab4, Getfile(n), Getline(n)), "\n", NIL);
|
||||
String *subfunc = NULL;
|
||||
/*
|
||||
if (builtin)
|
||||
|
|
@ -4732,7 +4843,7 @@ public:
|
|||
Printv(f_shadow_stubs, tab4, "val.thisown = 1\n", NIL);
|
||||
#endif
|
||||
if (have_pythonappend(n))
|
||||
Printv(f_shadow_stubs, pythoncode(pythonappend(n), tab4), "\n", NIL);
|
||||
Printv(f_shadow_stubs, pythoncode(pythonappend(n), tab4, Getfile(n), Getline(n)), "\n", NIL);
|
||||
Printv(f_shadow_stubs, tab4, "return val\n", NIL);
|
||||
Delete(subfunc);
|
||||
}
|
||||
|
|
@ -4769,7 +4880,7 @@ public:
|
|||
|
||||
if (shadow) {
|
||||
if (Getattr(n, "feature:shadow")) {
|
||||
String *pycode = pythoncode(Getattr(n, "feature:shadow"), tab4);
|
||||
String *pycode = pythoncode(Getattr(n, "feature:shadow"), tab4, Getfile(n), Getline(n));
|
||||
String *pyaction = NewStringf("%s.%s", module, Swig_name_destroy(NSPACE_TODO, symname));
|
||||
Replaceall(pycode, "$action", pyaction);
|
||||
Delete(pyaction);
|
||||
|
|
@ -4787,7 +4898,7 @@ public:
|
|||
if (have_docstring(n))
|
||||
Printv(f_shadow, tab8, docstring(n, AUTODOC_DTOR), "\n", NIL);
|
||||
if (have_pythonprepend(n))
|
||||
Printv(f_shadow, pythoncode(pythonprepend(n), tab8), "\n", NIL);
|
||||
Printv(f_shadow, pythoncode(pythonprepend(n), tab8, Getfile(n), Getline(n)), "\n", NIL);
|
||||
#ifdef USE_THISOWN
|
||||
Printv(f_shadow, tab8, "try:\n", NIL);
|
||||
Printv(f_shadow, tab8, tab4, "if self.thisown:", module, ".", Swig_name_destroy(NSPACE_TODO, symname), "(self)\n", NIL);
|
||||
|
|
@ -4795,7 +4906,7 @@ public:
|
|||
#else
|
||||
#endif
|
||||
if (have_pythonappend(n))
|
||||
Printv(f_shadow, pythoncode(pythonappend(n), tab8), "\n", NIL);
|
||||
Printv(f_shadow, pythoncode(pythonappend(n), tab8, Getfile(n), Getline(n)), "\n", NIL);
|
||||
Printv(f_shadow, tab8, "pass\n", NIL);
|
||||
Printv(f_shadow, "\n", NIL);
|
||||
}
|
||||
|
|
@ -4977,12 +5088,12 @@ public:
|
|||
|
||||
if (!ImportMode && (Cmp(section, "python") == 0 || Cmp(section, "shadow") == 0)) {
|
||||
if (shadow) {
|
||||
String *pycode = pythoncode(code, shadow_indent);
|
||||
String *pycode = pythoncode(code, shadow_indent, Getfile(n), Getline(n));
|
||||
Printv(f_shadow, pycode, NIL);
|
||||
Delete(pycode);
|
||||
}
|
||||
} else if (!ImportMode && (Cmp(section, "pythonbegin") == 0)) {
|
||||
String *pycode = pythoncode(code, "");
|
||||
String *pycode = pythoncode(code, "", Getfile(n), Getline(n));
|
||||
Printv(f_shadow_begin, pycode, NIL);
|
||||
Delete(pycode);
|
||||
} else {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue