<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[137284] branches/gsoc15-dependency/base/src/machista1.0</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="https://trac.macports.org/changeset/137284">137284</a></dd>
<dt>Author</dt> <dd>ijackson@macports.org</dd>
<dt>Date</dt> <dd>2015-06-07 22:38:08 -0700 (Sun, 07 Jun 2015)</dd>
</dl>
<h3>Log Message</h3>
<pre>Revert gsoc15-dependency to <a href="https://trac.macports.org/changeset/136782">revision 136782</a></pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#branchesgsoc15dependencybasesrcmachista10machistai">branches/gsoc15-dependency/base/src/machista1.0/machista.i</a></li>
<li><a href="#branchesgsoc15dependencybasesrcmachista10machista_wrapc">branches/gsoc15-dependency/base/src/machista1.0/machista_wrap.c</a></li>
</ul>
<h3>Removed Paths</h3>
<ul>
<li><a href="#branchesgsoc15dependencybasesrcmachista10machistapy">branches/gsoc15-dependency/base/src/machista1.0/machista.py</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="branchesgsoc15dependencybasesrcmachista10machistai"></a>
<div class="modfile"><h4>Modified: branches/gsoc15-dependency/base/src/machista1.0/machista.i (137283 => 137284)</h4>
<pre class="diff"><span>
<span class="info">--- branches/gsoc15-dependency/base/src/machista1.0/machista.i 2015-06-08 02:21:01 UTC (rev 137283)
+++ branches/gsoc15-dependency/base/src/machista1.0/machista.i 2015-06-08 05:38:08 UTC (rev 137284)
</span><span class="lines">@@ -2,7 +2,6 @@
</span><span class="cx"> %module machista
</span><span class="cx">
</span><span class="cx"> %{
</span><del>- #include <tcl.h>
</del><span class="cx"> #include "libmachista.h"
</span><span class="cx"> %}
</span><span class="cx">
</span><span class="lines">@@ -125,24 +124,12 @@
</span><span class="cx"> * said pointer and pass a pointer to it to macho_parse_file. Using numinputs=0
</span><span class="cx"> * causes SIWG to stop expecting the parameter when calling from Tcl.
</span><span class="cx"> */
</span><del>-#if defined(SWIGTCL)
</del><span class="cx"> %typemap(argout) const struct macho **result {
</span><span class="cx"> Tcl_ListObjAppendElement(interp, $result, SWIG_NewInstanceObj(SWIG_as_voidptr(*$1), $descriptor(struct macho *), 0));
</span><span class="cx"> }
</span><span class="cx"> %typemap(in, numinputs=0) const struct macho ** (struct macho *res) {
</span><span class="cx"> $1 = &res;
</span><span class="cx"> }
</span><del>-#endif
-
-#if defined(SWIGPYTHON)
-%typemap(argout) const struct macho **result {
- PyTuple_Pack(2, $result, SWIG_NewInstanceObj(SWIG_as_voidptr(*$1), $descriptor(struct macho *), 0));
-}
-%typemap(in, numinputs=0) const struct macho ** (struct macho *res) {
- $1 = &res;
-}
-#endif
-
</del><span class="cx"> %rename(parse_file) macho_parse_file;
</span><span class="cx"> int macho_parse_file(struct macho_handle *handle, const char *filename, const struct macho **result);
</span><span class="cx">
</span></span></pre></div>
<a id="branchesgsoc15dependencybasesrcmachista10machistapy"></a>
<div class="delfile"><h4>Deleted: branches/gsoc15-dependency/base/src/machista1.0/machista.py (137283 => 137284)</h4>
<pre class="diff"><span>
<span class="info">--- branches/gsoc15-dependency/base/src/machista1.0/machista.py 2015-06-08 02:21:01 UTC (rev 137283)
+++ branches/gsoc15-dependency/base/src/machista1.0/machista.py 2015-06-08 05:38:08 UTC (rev 137284)
</span><span class="lines">@@ -1,224 +0,0 @@
</span><del>-# This file was automatically generated by SWIG (http://www.swig.org).
-# Version 3.0.5
-#
-# Do not make changes to this file unless you know what you are doing--modify
-# the SWIG interface file instead.
-
-
-
-
-
-from sys import version_info
-if version_info >= (2, 6, 0):
- def swig_import_helper():
- from os.path import dirname
- import imp
- fp = None
- try:
- fp, pathname, description = imp.find_module('_machista', [dirname(__file__)])
- except ImportError:
- import _machista
- return _machista
- if fp is not None:
- try:
- _mod = imp.load_module('_machista', fp, pathname, description)
- finally:
- fp.close()
- return _mod
- _machista = swig_import_helper()
- del swig_import_helper
-else:
- import _machista
-del version_info
-try:
- _swig_property = property
-except NameError:
- pass # Python < 2.2 doesn't have 'property'.
-
-
-def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
- if (name == "thisown"):
- return self.this.own(value)
- if (name == "this"):
- if type(value).__name__ == 'SwigPyObject':
- self.__dict__[name] = value
- return
- method = class_type.__swig_setmethods__.get(name, None)
- if method:
- return method(self, value)
- if (not static):
- if _newclass:
- object.__setattr__(self, name, value)
- else:
- self.__dict__[name] = value
- else:
- raise AttributeError("You cannot add attributes to %s" % self)
-
-
-def _swig_setattr(self, class_type, name, value):
- return _swig_setattr_nondynamic(self, class_type, name, value, 0)
-
-
-def _swig_getattr_nondynamic(self, class_type, name, static=1):
- if (name == "thisown"):
- return self.this.own()
- method = class_type.__swig_getmethods__.get(name, None)
- if method:
- return method(self)
- if (not static):
- return object.__getattr__(self, name)
- else:
- raise AttributeError(name)
-
-def _swig_getattr(self, class_type, name):
- return _swig_getattr_nondynamic(self, class_type, name, 0)
-
-
-def _swig_repr(self):
- try:
- strthis = "proxy of " + self.this.__repr__()
- except:
- strthis = ""
- return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
-
-try:
- _object = object
- _newclass = 1
-except AttributeError:
- class _object:
- pass
- _newclass = 0
-
-
-
-_machista.SUCCESS_swigconstant(_machista)
-SUCCESS = _machista.SUCCESS
-
-_machista.EFILE_swigconstant(_machista)
-EFILE = _machista.EFILE
-
-_machista.EMMAP_swigconstant(_machista)
-EMMAP = _machista.EMMAP
-
-_machista.EMEM_swigconstant(_machista)
-EMEM = _machista.EMEM
-
-_machista.ERANGE_swigconstant(_machista)
-ERANGE = _machista.ERANGE
-
-_machista.EMAGIC_swigconstant(_machista)
-EMAGIC = _machista.EMAGIC
-class macho_handle(_object):
- __swig_setmethods__ = {}
- __setattr__ = lambda self, name, value: _swig_setattr(self, macho_handle, name, value)
- __swig_getmethods__ = {}
- __getattr__ = lambda self, name: _swig_getattr(self, macho_handle, name)
-
- def __init__(self, *args, **kwargs):
- raise AttributeError("No constructor defined")
- __repr__ = _swig_repr
-macho_handle_swigregister = _machista.macho_handle_swigregister
-macho_handle_swigregister(macho_handle)
-
-class macho_loadcmd(_object):
- __swig_setmethods__ = {}
- __setattr__ = lambda self, name, value: _swig_setattr(self, macho_loadcmd, name, value)
- __swig_getmethods__ = {}
- __getattr__ = lambda self, name: _swig_getattr(self, macho_loadcmd, name)
-
- def __init__(self, *args, **kwargs):
- raise AttributeError("No constructor defined")
- __repr__ = _swig_repr
- __swig_getmethods__["mlt_install_name"] = _machista.macho_loadcmd_mlt_install_name_get
- if _newclass:
- mlt_install_name = _swig_property(_machista.macho_loadcmd_mlt_install_name_get)
- __swig_getmethods__["mlt_type"] = _machista.macho_loadcmd_mlt_type_get
- if _newclass:
- mlt_type = _swig_property(_machista.macho_loadcmd_mlt_type_get)
- __swig_getmethods__["mlt_comp_version"] = _machista.macho_loadcmd_mlt_comp_version_get
- if _newclass:
- mlt_comp_version = _swig_property(_machista.macho_loadcmd_mlt_comp_version_get)
- __swig_getmethods__["mlt_version"] = _machista.macho_loadcmd_mlt_version_get
- if _newclass:
- mlt_version = _swig_property(_machista.macho_loadcmd_mlt_version_get)
- __swig_getmethods__["next"] = _machista.macho_loadcmd_next_get
- if _newclass:
- next = _swig_property(_machista.macho_loadcmd_next_get)
-macho_loadcmd_swigregister = _machista.macho_loadcmd_swigregister
-macho_loadcmd_swigregister(macho_loadcmd)
-
-class macho_arch(_object):
- __swig_setmethods__ = {}
- __setattr__ = lambda self, name, value: _swig_setattr(self, macho_arch, name, value)
- __swig_getmethods__ = {}
- __getattr__ = lambda self, name: _swig_getattr(self, macho_arch, name)
-
- def __init__(self, *args, **kwargs):
- raise AttributeError("No constructor defined")
- __repr__ = _swig_repr
- __swig_getmethods__["mat_install_name"] = _machista.macho_arch_mat_install_name_get
- if _newclass:
- mat_install_name = _swig_property(_machista.macho_arch_mat_install_name_get)
- __swig_getmethods__["mat_rpath"] = _machista.macho_arch_mat_rpath_get
- if _newclass:
- mat_rpath = _swig_property(_machista.macho_arch_mat_rpath_get)
- __swig_getmethods__["mat_arch"] = _machista.macho_arch_mat_arch_get
- if _newclass:
- mat_arch = _swig_property(_machista.macho_arch_mat_arch_get)
- __swig_getmethods__["mat_comp_version"] = _machista.macho_arch_mat_comp_version_get
- if _newclass:
- mat_comp_version = _swig_property(_machista.macho_arch_mat_comp_version_get)
- __swig_getmethods__["mat_version"] = _machista.macho_arch_mat_version_get
- if _newclass:
- mat_version = _swig_property(_machista.macho_arch_mat_version_get)
- __swig_getmethods__["mat_loadcmds"] = _machista.macho_arch_mat_loadcmds_get
- if _newclass:
- mat_loadcmds = _swig_property(_machista.macho_arch_mat_loadcmds_get)
- __swig_getmethods__["next"] = _machista.macho_arch_next_get
- if _newclass:
- next = _swig_property(_machista.macho_arch_next_get)
-macho_arch_swigregister = _machista.macho_arch_swigregister
-macho_arch_swigregister(macho_arch)
-
-class macho(_object):
- __swig_setmethods__ = {}
- __setattr__ = lambda self, name, value: _swig_setattr(self, macho, name, value)
- __swig_getmethods__ = {}
- __getattr__ = lambda self, name: _swig_getattr(self, macho, name)
-
- def __init__(self, *args, **kwargs):
- raise AttributeError("No constructor defined")
- __repr__ = _swig_repr
- __swig_getmethods__["mt_archs"] = _machista.macho_mt_archs_get
- if _newclass:
- mt_archs = _swig_property(_machista.macho_mt_archs_get)
-macho_swigregister = _machista.macho_swigregister
-macho_swigregister(macho)
-
-
-def create_handle():
- return _machista.create_handle()
-create_handle = _machista.create_handle
-
-def destroy_handle(INPUT):
- return _machista.destroy_handle(INPUT)
-destroy_handle = _machista.destroy_handle
-
-def parse_file(handle, filename):
- return _machista.parse_file(handle, filename)
-parse_file = _machista.parse_file
-
-def strerror(err):
- return _machista.strerror(err)
-strerror = _machista.strerror
-
-def get_arch_name(arg1):
- return _machista.get_arch_name(arg1)
-get_arch_name = _machista.get_arch_name
-
-def format_dylib_version(arg1):
- return _machista.format_dylib_version(arg1)
-format_dylib_version = _machista.format_dylib_version
-# This file is compatible with both classic and new-style classes.
-
-
</del></span></pre></div>
<a id="branchesgsoc15dependencybasesrcmachista10machista_wrapc"></a>
<div class="modfile"><h4>Modified: branches/gsoc15-dependency/base/src/machista1.0/machista_wrap.c (137283 => 137284)</h4>
<pre class="diff"><span>
<span class="info">--- branches/gsoc15-dependency/base/src/machista1.0/machista_wrap.c 2015-06-08 02:21:01 UTC (rev 137283)
+++ branches/gsoc15-dependency/base/src/machista1.0/machista_wrap.c 2015-06-08 05:38:08 UTC (rev 137284)
</span><span class="lines">@@ -1,15 +1,14 @@
</span><span class="cx"> /* ----------------------------------------------------------------------------
</span><span class="cx"> * This file was automatically generated by SWIG (http://www.swig.org).
</span><del>- * Version 3.0.5
- *
- * This file is not intended to be easily readable and contains a number of
</del><ins>+ * Version 1.3.40
+ *
+ * This file is not intended to be easily readable and contains a number of
</ins><span class="cx"> * coding conventions designed to improve portability and efficiency. Do not make
</span><del>- * changes to this file unless you know what you are doing--modify the SWIG
- * interface file instead.
</del><ins>+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
</ins><span class="cx"> * ----------------------------------------------------------------------------- */
</span><span class="cx">
</span><del>-#define SWIGPYTHON
-#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
</del><ins>+#define SWIGTCL
</ins><span class="cx">
</span><span class="cx"> /* -----------------------------------------------------------------------------
</span><span class="cx"> * This section contains generic SWIG labels for method/variable
</span><span class="lines">@@ -42,28 +41,28 @@
</span><span class="cx"> #ifndef SWIGUNUSED
</span><span class="cx"> # if defined(__GNUC__)
</span><span class="cx"> # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
</span><del>-# define SWIGUNUSED __attribute__ ((__unused__))
</del><ins>+# define SWIGUNUSED __attribute__ ((__unused__))
</ins><span class="cx"> # else
</span><span class="cx"> # define SWIGUNUSED
</span><span class="cx"> # endif
</span><span class="cx"> # elif defined(__ICC)
</span><del>-# define SWIGUNUSED __attribute__ ((__unused__))
</del><ins>+# define SWIGUNUSED __attribute__ ((__unused__))
</ins><span class="cx"> # else
</span><del>-# define SWIGUNUSED
</del><ins>+# define SWIGUNUSED
</ins><span class="cx"> # endif
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> #ifndef SWIG_MSC_UNSUPPRESS_4505
</span><span class="cx"> # if defined(_MSC_VER)
</span><span class="cx"> # pragma warning(disable : 4505) /* unreferenced local function has been removed */
</span><del>-# endif
</del><ins>+# endif
</ins><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> #ifndef SWIGUNUSEDPARM
</span><span class="cx"> # ifdef __cplusplus
</span><span class="cx"> # define SWIGUNUSEDPARM(p)
</span><span class="cx"> # else
</span><del>-# define SWIGUNUSEDPARM(p) p SWIGUNUSED
</del><ins>+# define SWIGUNUSEDPARM(p) p SWIGUNUSED
</ins><span class="cx"> # endif
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="lines">@@ -106,7 +105,7 @@
</span><span class="cx"> # define SWIGSTDCALL __stdcall
</span><span class="cx"> # else
</span><span class="cx"> # define SWIGSTDCALL
</span><del>-# endif
</del><ins>+# endif
</ins><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
</span><span class="lines">@@ -121,14 +120,12 @@
</span><span class="cx">
</span><span class="cx">
</span><span class="cx">
</span><del>-#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
-/* Use debug wrappers with the Python release dll */
-# undef _DEBUG
-# include <Python.h>
-# define _DEBUG
-#else
-# include <Python.h>
-#endif
</del><ins>+#include <stdio.h>
+#include <tcl.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <ctype.h>
</ins><span class="cx">
</span><span class="cx"> /* -----------------------------------------------------------------------------
</span><span class="cx"> * swigrun.swg
</span><span class="lines">@@ -154,7 +151,7 @@
</span><span class="cx"> You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
</span><span class="cx"> creating a static or dynamic library from the SWIG runtime code.
</span><span class="cx"> In 99.9% of the cases, SWIG just needs to declare them as 'static'.
</span><del>-
</del><ins>+
</ins><span class="cx"> But only do this if strictly necessary, ie, if you have problems
</span><span class="cx"> with your compiler or suchlike.
</span><span class="cx"> */
</span><span class="lines">@@ -180,16 +177,16 @@
</span><span class="cx"> #define SWIG_POINTER_OWN 0x1
</span><span class="cx">
</span><span class="cx">
</span><del>-/*
</del><ins>+/*
</ins><span class="cx"> Flags/methods for returning states.
</span><del>-
- The SWIG conversion methods, as ConvertPtr, return an integer
</del><ins>+
+ The SWIG conversion methods, as ConvertPtr, return and integer
</ins><span class="cx"> that tells if the conversion was successful or not. And if not,
</span><span class="cx"> an error code can be returned (see swigerrors.swg for the codes).
</span><del>-
</del><ins>+
</ins><span class="cx"> Use the following macros/flags to set or process the returning
</span><span class="cx"> states.
</span><del>-
</del><ins>+
</ins><span class="cx"> In old versions of SWIG, code such as the following was usually written:
</span><span class="cx">
</span><span class="cx"> if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
</span><span class="lines">@@ -222,23 +219,23 @@
</span><span class="cx"> } else {
</span><span class="cx"> // fail code
</span><span class="cx"> }
</span><del>-
</del><ins>+
</ins><span class="cx"> I.e., now SWIG_ConvertPtr can return new objects and you can
</span><span class="cx"> identify the case and take care of the deallocation. Of course that
</span><span class="cx"> also requires SWIG_ConvertPtr to return new result values, such as
</span><span class="cx">
</span><del>- int SWIG_ConvertPtr(obj, ptr,...) {
- if (<obj is ok>) {
- if (<need new object>) {
- *ptr = <ptr to new allocated object>;
- return SWIG_NEWOBJ;
- } else {
- *ptr = <ptr to old object>;
- return SWIG_OLDOBJ;
- }
- } else {
- return SWIG_BADOBJ;
- }
</del><ins>+ int SWIG_ConvertPtr(obj, ptr,...) {
+ if (<obj is ok>) {
+ if (<need new object>) {
+ *ptr = <ptr to new allocated object>;
+ return SWIG_NEWOBJ;
+ } else {
+ *ptr = <ptr to old object>;
+ return SWIG_OLDOBJ;
+ }
+ } else {
+ return SWIG_BADOBJ;
+ }
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
</span><span class="lines">@@ -252,17 +249,17 @@
</span><span class="cx"> int fooi(int);
</span><span class="cx">
</span><span class="cx"> and you call
</span><del>-
</del><ins>+
</ins><span class="cx"> food(1) // cast rank '1' (1 -> 1.0)
</span><span class="cx"> fooi(1) // cast rank '0'
</span><span class="cx">
</span><span class="cx"> just use the SWIG_AddCast()/SWIG_CheckState()
</span><span class="cx"> */
</span><span class="cx">
</span><del>-#define SWIG_OK (0)
</del><ins>+#define SWIG_OK (0)
</ins><span class="cx"> #define SWIG_ERROR (-1)
</span><span class="cx"> #define SWIG_IsOK(r) (r >= 0)
</span><del>-#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
</del><ins>+#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
</ins><span class="cx">
</span><span class="cx"> /* The CastRankLimit says how many bits are used for the cast rank */
</span><span class="cx"> #define SWIG_CASTRANKLIMIT (1 << 8)
</span><span class="lines">@@ -293,14 +290,14 @@
</span><span class="cx"> # endif
</span><span class="cx"> # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
</span><span class="cx"> # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
</span><del>-SWIGINTERNINLINE int SWIG_AddCast(int r) {
</del><ins>+SWIGINTERNINLINE int SWIG_AddCast(int r) {
</ins><span class="cx"> return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
</span><span class="cx"> }
</span><del>-SWIGINTERNINLINE int SWIG_CheckState(int r) {
- return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
</del><ins>+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+ return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
</ins><span class="cx"> }
</span><span class="cx"> #else /* no cast-rank mode */
</span><del>-# define SWIG_AddCast(r) (r)
</del><ins>+# define SWIG_AddCast
</ins><span class="cx"> # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="lines">@@ -344,7 +341,7 @@
</span><span class="cx"> void *clientdata; /* Language specific module data */
</span><span class="cx"> } swig_module_info;
</span><span class="cx">
</span><del>-/*
</del><ins>+/*
</ins><span class="cx"> Compare two type names skipping the space characters, therefore
</span><span class="cx"> "char*" == "char *" and "Class<int>" == "Class<int >", etc.
</span><span class="cx">
</span><span class="lines">@@ -364,18 +361,18 @@
</span><span class="cx">
</span><span class="cx"> /*
</span><span class="cx"> Check type equivalence in a name list like <name1>|<name2>|...
</span><del>- Return 0 if equal, -1 if nb < tb, 1 if nb > tb
</del><ins>+ Return 0 if not equal, 1 if equal
</ins><span class="cx"> */
</span><span class="cx"> SWIGRUNTIME int
</span><del>-SWIG_TypeCmp(const char *nb, const char *tb) {
- int equiv = 1;
</del><ins>+SWIG_TypeEquiv(const char *nb, const char *tb) {
+ int equiv = 0;
</ins><span class="cx"> const char* te = tb + strlen(tb);
</span><span class="cx"> const char* ne = nb;
</span><del>- while (equiv != 0 && *ne) {
</del><ins>+ while (!equiv && *ne) {
</ins><span class="cx"> for (nb = ne; *ne; ++ne) {
</span><span class="cx"> if (*ne == '|') break;
</span><span class="cx"> }
</span><del>- equiv = SWIG_TypeNameComp(nb, ne, tb, te);
</del><ins>+ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
</ins><span class="cx"> if (*ne) ++ne;
</span><span class="cx"> }
</span><span class="cx"> return equiv;
</span><span class="lines">@@ -383,13 +380,24 @@
</span><span class="cx">
</span><span class="cx"> /*
</span><span class="cx"> Check type equivalence in a name list like <name1>|<name2>|...
</span><del>- Return 0 if not equal, 1 if equal
</del><ins>+ Return 0 if equal, -1 if nb < tb, 1 if nb > tb
</ins><span class="cx"> */
</span><span class="cx"> SWIGRUNTIME int
</span><del>-SWIG_TypeEquiv(const char *nb, const char *tb) {
- return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
</del><ins>+SWIG_TypeCompare(const char *nb, const char *tb) {
+ int equiv = 0;
+ const char* te = tb + strlen(tb);
+ const char* ne = nb;
+ while (!equiv && *ne) {
+ for (nb = ne; *ne; ++ne) {
+ if (*ne == '|') break;
+ }
+ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
+ if (*ne) ++ne;
+ }
+ return equiv;
</ins><span class="cx"> }
</span><span class="cx">
</span><ins>+
</ins><span class="cx"> /*
</span><span class="cx"> Check the typename
</span><span class="cx"> */
</span><span class="lines">@@ -417,7 +425,7 @@
</span><span class="cx"> return 0;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-/*
</del><ins>+/*
</ins><span class="cx"> Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
</span><span class="cx"> */
</span><span class="cx"> SWIGRUNTIME swig_cast_info *
</span><span class="lines">@@ -452,7 +460,7 @@
</span><span class="cx"> return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-/*
</del><ins>+/*
</ins><span class="cx"> Dynamic pointer casting. Down an inheritance hierarchy
</span><span class="cx"> */
</span><span class="cx"> SWIGRUNTIME swig_type_info *
</span><span class="lines">@@ -496,7 +504,7 @@
</span><span class="cx"> return type->name;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-/*
</del><ins>+/*
</ins><span class="cx"> Set the clientdata field for a type
</span><span class="cx"> */
</span><span class="cx"> SWIGRUNTIME void
</span><span class="lines">@@ -504,14 +512,14 @@
</span><span class="cx"> swig_cast_info *cast = ti->cast;
</span><span class="cx"> /* if (ti->clientdata == clientdata) return; */
</span><span class="cx"> ti->clientdata = clientdata;
</span><del>-
</del><ins>+
</ins><span class="cx"> while (cast) {
</span><span class="cx"> if (!cast->converter) {
</span><span class="cx"> swig_type_info *tc = cast->type;
</span><span class="cx"> if (!tc->clientdata) {
</span><span class="cx"> SWIG_TypeClientData(tc, clientdata);
</span><span class="cx"> }
</span><del>- }
</del><ins>+ }
</ins><span class="cx"> cast = cast->next;
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -520,31 +528,31 @@
</span><span class="cx"> SWIG_TypeClientData(ti, clientdata);
</span><span class="cx"> ti->owndata = 1;
</span><span class="cx"> }
</span><del>-
</del><ins>+
</ins><span class="cx"> /*
</span><span class="cx"> Search for a swig_type_info structure only by mangled name
</span><span class="cx"> Search is a O(log #types)
</span><del>-
- We start searching at module start, and finish searching when start == end.
</del><ins>+
+ We start searching at module start, and finish searching when start == end.
</ins><span class="cx"> Note: if start == end at the beginning of the function, we go all the way around
</span><span class="cx"> the circular list.
</span><span class="cx"> */
</span><span class="cx"> SWIGRUNTIME swig_type_info *
</span><del>-SWIG_MangledTypeQueryModule(swig_module_info *start,
- swig_module_info *end,
</del><ins>+SWIG_MangledTypeQueryModule(swig_module_info *start,
+ swig_module_info *end,
</ins><span class="cx"> const char *name) {
</span><span class="cx"> swig_module_info *iter = start;
</span><span class="cx"> do {
</span><span class="cx"> if (iter->size) {
</span><del>- size_t l = 0;
- size_t r = iter->size - 1;
</del><ins>+ register size_t l = 0;
+ register size_t r = iter->size - 1;
</ins><span class="cx"> do {
</span><span class="cx"> /* since l+r >= 0, we can (>> 1) instead (/ 2) */
</span><del>- size_t i = (l + r) >> 1;
</del><ins>+ register size_t i = (l + r) >> 1;
</ins><span class="cx"> const char *iname = iter->types[i]->name;
</span><span class="cx"> if (iname) {
</span><del>- int compare = strcmp(name, iname);
- if (compare == 0) {
</del><ins>+ register int compare = strcmp(name, iname);
+ if (compare == 0) {
</ins><span class="cx"> return iter->types[i];
</span><span class="cx"> } else if (compare < 0) {
</span><span class="cx"> if (i) {
</span><span class="lines">@@ -569,14 +577,14 @@
</span><span class="cx"> Search for a swig_type_info structure for either a mangled name or a human readable name.
</span><span class="cx"> It first searches the mangled names of the types, which is a O(log #types)
</span><span class="cx"> If a type is not found it then searches the human readable names, which is O(#types).
</span><del>-
- We start searching at module start, and finish searching when start == end.
</del><ins>+
+ We start searching at module start, and finish searching when start == end.
</ins><span class="cx"> Note: if start == end at the beginning of the function, we go all the way around
</span><span class="cx"> the circular list.
</span><span class="cx"> */
</span><span class="cx"> SWIGRUNTIME swig_type_info *
</span><del>-SWIG_TypeQueryModule(swig_module_info *start,
- swig_module_info *end,
</del><ins>+SWIG_TypeQueryModule(swig_module_info *start,
+ swig_module_info *end,
</ins><span class="cx"> const char *name) {
</span><span class="cx"> /* STEP 1: Search the name field using binary search */
</span><span class="cx"> swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
</span><span class="lines">@@ -587,7 +595,7 @@
</span><span class="cx"> of the str field (the human readable name) */
</span><span class="cx"> swig_module_info *iter = start;
</span><span class="cx"> do {
</span><del>- size_t i = 0;
</del><ins>+ register size_t i = 0;
</ins><span class="cx"> for (; i < iter->size; ++i) {
</span><span class="cx"> if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
</span><span class="cx"> return iter->types[i];
</span><span class="lines">@@ -595,56 +603,56 @@
</span><span class="cx"> iter = iter->next;
</span><span class="cx"> } while (iter != end);
</span><span class="cx"> }
</span><del>-
</del><ins>+
</ins><span class="cx"> /* neither found a match */
</span><span class="cx"> return 0;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-/*
</del><ins>+/*
</ins><span class="cx"> Pack binary data into a string
</span><span class="cx"> */
</span><span class="cx"> SWIGRUNTIME char *
</span><span class="cx"> SWIG_PackData(char *c, void *ptr, size_t sz) {
</span><span class="cx"> static const char hex[17] = "0123456789abcdef";
</span><del>- const unsigned char *u = (unsigned char *) ptr;
- const unsigned char *eu = u + sz;
</del><ins>+ register const unsigned char *u = (unsigned char *) ptr;
+ register const unsigned char *eu = u + sz;
</ins><span class="cx"> for (; u != eu; ++u) {
</span><del>- unsigned char uu = *u;
</del><ins>+ register unsigned char uu = *u;
</ins><span class="cx"> *(c++) = hex[(uu & 0xf0) >> 4];
</span><span class="cx"> *(c++) = hex[uu & 0xf];
</span><span class="cx"> }
</span><span class="cx"> return c;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-/*
</del><ins>+/*
</ins><span class="cx"> Unpack binary data from a string
</span><span class="cx"> */
</span><span class="cx"> SWIGRUNTIME const char *
</span><span class="cx"> SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
</span><del>- unsigned char *u = (unsigned char *) ptr;
- const unsigned char *eu = u + sz;
</del><ins>+ register unsigned char *u = (unsigned char *) ptr;
+ register const unsigned char *eu = u + sz;
</ins><span class="cx"> for (; u != eu; ++u) {
</span><del>- char d = *(c++);
- unsigned char uu;
</del><ins>+ register char d = *(c++);
+ register unsigned char uu;
</ins><span class="cx"> if ((d >= '0') && (d <= '9'))
</span><span class="cx"> uu = ((d - '0') << 4);
</span><span class="cx"> else if ((d >= 'a') && (d <= 'f'))
</span><span class="cx"> uu = ((d - ('a'-10)) << 4);
</span><del>- else
</del><ins>+ else
</ins><span class="cx"> return (char *) 0;
</span><span class="cx"> d = *(c++);
</span><span class="cx"> if ((d >= '0') && (d <= '9'))
</span><span class="cx"> uu |= (d - '0');
</span><span class="cx"> else if ((d >= 'a') && (d <= 'f'))
</span><span class="cx"> uu |= (d - ('a'-10));
</span><del>- else
</del><ins>+ else
</ins><span class="cx"> return (char *) 0;
</span><span class="cx"> *u = uu;
</span><span class="cx"> }
</span><span class="cx"> return c;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-/*
</del><ins>+/*
</ins><span class="cx"> Pack 'void *' into a string buffer.
</span><span class="cx"> */
</span><span class="cx"> SWIGRUNTIME char *
</span><span class="lines">@@ -704,383 +712,102 @@
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> /* Errors in SWIG */
</span><del>-#define SWIG_UnknownError -1
-#define SWIG_IOError -2
-#define SWIG_RuntimeError -3
-#define SWIG_IndexError -4
-#define SWIG_TypeError -5
-#define SWIG_DivisionByZero -6
-#define SWIG_OverflowError -7
-#define SWIG_SyntaxError -8
-#define SWIG_ValueError -9
</del><ins>+#define SWIG_UnknownError -1
+#define SWIG_IOError -2
+#define SWIG_RuntimeError -3
+#define SWIG_IndexError -4
+#define SWIG_TypeError -5
+#define SWIG_DivisionByZero -6
+#define SWIG_OverflowError -7
+#define SWIG_SyntaxError -8
+#define SWIG_ValueError -9
</ins><span class="cx"> #define SWIG_SystemError -10
</span><span class="cx"> #define SWIG_AttributeError -11
</span><del>-#define SWIG_MemoryError -12
</del><ins>+#define SWIG_MemoryError -12
</ins><span class="cx"> #define SWIG_NullReferenceError -13
</span><span class="cx">
</span><span class="cx">
</span><span class="cx">
</span><del>-/* Compatibility macros for Python 3 */
-#if PY_VERSION_HEX >= 0x03000000
-
-#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
-#define PyInt_Check(x) PyLong_Check(x)
-#define PyInt_AsLong(x) PyLong_AsLong(x)
-#define PyInt_FromLong(x) PyLong_FromLong(x)
-#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
-#define PyString_Check(name) PyBytes_Check(name)
-#define PyString_FromString(x) PyUnicode_FromString(x)
-#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
-#define PyString_AsString(str) PyBytes_AsString(str)
-#define PyString_Size(str) PyBytes_Size(str)
-#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
-#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
-#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
-#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
-
-#endif
-
-#ifndef Py_TYPE
-# define Py_TYPE(op) ((op)->ob_type)
-#endif
-
-/* SWIG APIs for compatibility of both Python 2 & 3 */
-
-#if PY_VERSION_HEX >= 0x03000000
-# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
-#else
-# define SWIG_Python_str_FromFormat PyString_FromFormat
-#endif
-
-
-/* Warning: This function will allocate a new string in Python 3,
- * so please call SWIG_Python_str_DelForPy3(x) to free the space.
- */
-SWIGINTERN char*
-SWIG_Python_str_AsChar(PyObject *str)
-{
-#if PY_VERSION_HEX >= 0x03000000
- char *cstr;
- char *newstr;
- Py_ssize_t len;
- str = PyUnicode_AsUTF8String(str);
- PyBytes_AsStringAndSize(str, &cstr, &len);
- newstr = (char *) malloc(len+1);
- memcpy(newstr, cstr, len+1);
- Py_XDECREF(str);
- return newstr;
-#else
- return PyString_AsString(str);
-#endif
-}
-
-#if PY_VERSION_HEX >= 0x03000000
-# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
-#else
-# define SWIG_Python_str_DelForPy3(x)
-#endif
-
-
-SWIGINTERN PyObject*
-SWIG_Python_str_FromChar(const char *c)
-{
-#if PY_VERSION_HEX >= 0x03000000
- return PyUnicode_FromString(c);
-#else
- return PyString_FromString(c);
-#endif
-}
-
-/* Add PyOS_snprintf for old Pythons */
-#if PY_VERSION_HEX < 0x02020000
-# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
-# define PyOS_snprintf _snprintf
-# else
-# define PyOS_snprintf snprintf
-# endif
-#endif
-
-/* A crude PyString_FromFormat implementation for old Pythons */
-#if PY_VERSION_HEX < 0x02020000
-
-#ifndef SWIG_PYBUFFER_SIZE
-# define SWIG_PYBUFFER_SIZE 1024
-#endif
-
-static PyObject *
-PyString_FromFormat(const char *fmt, ...) {
- va_list ap;
- char buf[SWIG_PYBUFFER_SIZE * 2];
- int res;
- va_start(ap, fmt);
- res = vsnprintf(buf, sizeof(buf), fmt, ap);
- va_end(ap);
- return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
-}
-#endif
-
-/* Add PyObject_Del for old Pythons */
-#if PY_VERSION_HEX < 0x01060000
-# define PyObject_Del(op) PyMem_DEL((op))
-#endif
-#ifndef PyObject_DEL
-# define PyObject_DEL PyObject_Del
-#endif
-
-/* A crude PyExc_StopIteration exception for old Pythons */
-#if PY_VERSION_HEX < 0x02020000
-# ifndef PyExc_StopIteration
-# define PyExc_StopIteration PyExc_RuntimeError
-# endif
-# ifndef PyObject_GenericGetAttr
-# define PyObject_GenericGetAttr 0
-# endif
-#endif
-
-/* Py_NotImplemented is defined in 2.1 and up. */
-#if PY_VERSION_HEX < 0x02010000
-# ifndef Py_NotImplemented
-# define Py_NotImplemented PyExc_RuntimeError
-# endif
-#endif
-
-/* A crude PyString_AsStringAndSize implementation for old Pythons */
-#if PY_VERSION_HEX < 0x02010000
-# ifndef PyString_AsStringAndSize
-# define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
-# endif
-#endif
-
-/* PySequence_Size for old Pythons */
-#if PY_VERSION_HEX < 0x02000000
-# ifndef PySequence_Size
-# define PySequence_Size PySequence_Length
-# endif
-#endif
-
-/* PyBool_FromLong for old Pythons */
-#if PY_VERSION_HEX < 0x02030000
-static
-PyObject *PyBool_FromLong(long ok)
-{
- PyObject *result = ok ? Py_True : Py_False;
- Py_INCREF(result);
- return result;
-}
-#endif
-
-/* Py_ssize_t for old Pythons */
-/* This code is as recommended by: */
-/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
-#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
-typedef int Py_ssize_t;
-# define PY_SSIZE_T_MAX INT_MAX
-# define PY_SSIZE_T_MIN INT_MIN
-typedef inquiry lenfunc;
-typedef intargfunc ssizeargfunc;
-typedef intintargfunc ssizessizeargfunc;
-typedef intobjargproc ssizeobjargproc;
-typedef intintobjargproc ssizessizeobjargproc;
-typedef getreadbufferproc readbufferproc;
-typedef getwritebufferproc writebufferproc;
-typedef getsegcountproc segcountproc;
-typedef getcharbufferproc charbufferproc;
-static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
-{
- long result = 0;
- PyObject *i = PyNumber_Int(x);
- if (i) {
- result = PyInt_AsLong(i);
- Py_DECREF(i);
- }
- return result;
-}
-#endif
-
-#if PY_VERSION_HEX < 0x02050000
-#define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
-#endif
-
-#if PY_VERSION_HEX < 0x02040000
-#define Py_VISIT(op) \
- do { \
- if (op) { \
- int vret = visit((op), arg); \
- if (vret) \
- return vret; \
- } \
- } while (0)
-#endif
-
-#if PY_VERSION_HEX < 0x02030000
-typedef struct {
- PyTypeObject type;
- PyNumberMethods as_number;
- PyMappingMethods as_mapping;
- PySequenceMethods as_sequence;
- PyBufferProcs as_buffer;
- PyObject *name, *slots;
-} PyHeapTypeObject;
-#endif
-
-#if PY_VERSION_HEX < 0x02030000
-typedef destructor freefunc;
-#endif
-
-#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
- (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
- (PY_MAJOR_VERSION > 3))
-# define SWIGPY_USE_CAPSULE
-# define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
-#endif
-
-#if PY_VERSION_HEX < 0x03020000
-#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
-#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
-#endif
-
</del><span class="cx"> /* -----------------------------------------------------------------------------
</span><span class="cx"> * error manipulation
</span><span class="cx"> * ----------------------------------------------------------------------------- */
</span><span class="cx">
</span><del>-SWIGRUNTIME PyObject*
-SWIG_Python_ErrorType(int code) {
- PyObject* type = 0;
</del><ins>+SWIGINTERN const char*
+SWIG_Tcl_ErrorType(int code) {
+ const char* type = 0;
</ins><span class="cx"> switch(code) {
</span><span class="cx"> case SWIG_MemoryError:
</span><del>- type = PyExc_MemoryError;
</del><ins>+ type = "MemoryError";
</ins><span class="cx"> break;
</span><span class="cx"> case SWIG_IOError:
</span><del>- type = PyExc_IOError;
</del><ins>+ type = "IOError";
</ins><span class="cx"> break;
</span><span class="cx"> case SWIG_RuntimeError:
</span><del>- type = PyExc_RuntimeError;
</del><ins>+ type = "RuntimeError";
</ins><span class="cx"> break;
</span><span class="cx"> case SWIG_IndexError:
</span><del>- type = PyExc_IndexError;
</del><ins>+ type = "IndexError";
</ins><span class="cx"> break;
</span><span class="cx"> case SWIG_TypeError:
</span><del>- type = PyExc_TypeError;
</del><ins>+ type = "TypeError";
</ins><span class="cx"> break;
</span><span class="cx"> case SWIG_DivisionByZero:
</span><del>- type = PyExc_ZeroDivisionError;
</del><ins>+ type = "ZeroDivisionError";
</ins><span class="cx"> break;
</span><span class="cx"> case SWIG_OverflowError:
</span><del>- type = PyExc_OverflowError;
</del><ins>+ type = "OverflowError";
</ins><span class="cx"> break;
</span><span class="cx"> case SWIG_SyntaxError:
</span><del>- type = PyExc_SyntaxError;
</del><ins>+ type = "SyntaxError";
</ins><span class="cx"> break;
</span><span class="cx"> case SWIG_ValueError:
</span><del>- type = PyExc_ValueError;
</del><ins>+ type = "ValueError";
</ins><span class="cx"> break;
</span><span class="cx"> case SWIG_SystemError:
</span><del>- type = PyExc_SystemError;
</del><ins>+ type = "SystemError";
</ins><span class="cx"> break;
</span><span class="cx"> case SWIG_AttributeError:
</span><del>- type = PyExc_AttributeError;
</del><ins>+ type = "AttributeError";
</ins><span class="cx"> break;
</span><span class="cx"> default:
</span><del>- type = PyExc_RuntimeError;
</del><ins>+ type = "RuntimeError";
</ins><span class="cx"> }
</span><span class="cx"> return type;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGRUNTIME void
-SWIG_Python_AddErrorMsg(const char* mesg)
</del><ins>+SWIGINTERN void
+SWIG_Tcl_SetErrorObj(Tcl_Interp *interp, const char *ctype, Tcl_Obj *obj)
</ins><span class="cx"> {
</span><del>- PyObject *type = 0;
- PyObject *value = 0;
- PyObject *traceback = 0;
</del><ins>+ Tcl_ResetResult(interp);
+ Tcl_SetObjResult(interp, obj);
+ Tcl_SetErrorCode(interp, "SWIG", ctype, NULL);
+}
</ins><span class="cx">
</span><del>- if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
- if (value) {
- char *tmp;
- PyObject *old_str = PyObject_Str(value);
- PyErr_Clear();
- Py_XINCREF(type);
</del><ins>+SWIGINTERN void
+SWIG_Tcl_SetErrorMsg(Tcl_Interp *interp, const char *ctype, const char *mesg)
+{
+ Tcl_ResetResult(interp);
+ Tcl_SetErrorCode(interp, "SWIG", ctype, NULL);
+ Tcl_AppendResult(interp, ctype, " ", mesg, NULL);
+ /*
+ Tcl_AddErrorInfo(interp, ctype);
+ Tcl_AddErrorInfo(interp, " ");
+ Tcl_AddErrorInfo(interp, mesg);
+ */
+}
</ins><span class="cx">
</span><del>- PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
- SWIG_Python_str_DelForPy3(tmp);
- Py_DECREF(old_str);
- Py_DECREF(value);
- } else {
- PyErr_SetString(PyExc_RuntimeError, mesg);
- }
</del><ins>+SWIGINTERNINLINE void
+SWIG_Tcl_AddErrorMsg(Tcl_Interp *interp, const char* mesg)
+{
+ Tcl_AddErrorInfo(interp, mesg);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-#if defined(SWIG_PYTHON_NO_THREADS)
-# if defined(SWIG_PYTHON_THREADS)
-# undef SWIG_PYTHON_THREADS
-# endif
-#endif
-#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
-# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
-# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
-# define SWIG_PYTHON_USE_GIL
-# endif
-# endif
-# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
-# ifndef SWIG_PYTHON_INITIALIZE_THREADS
-# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
-# endif
-# ifdef __cplusplus /* C++ code */
- class SWIG_Python_Thread_Block {
- bool status;
- PyGILState_STATE state;
- public:
- void end() { if (status) { PyGILState_Release(state); status = false;} }
- SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
- ~SWIG_Python_Thread_Block() { end(); }
- };
- class SWIG_Python_Thread_Allow {
- bool status;
- PyThreadState *save;
- public:
- void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
- SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
- ~SWIG_Python_Thread_Allow() { end(); }
- };
-# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
-# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
-# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
-# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
-# else /* C code */
-# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
-# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
-# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
-# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
-# endif
-# else /* Old thread way, not implemented, user must provide it */
-# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
-# define SWIG_PYTHON_INITIALIZE_THREADS
-# endif
-# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
-# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
-# endif
-# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
-# define SWIG_PYTHON_THREAD_END_BLOCK
-# endif
-# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
-# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
-# endif
-# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
-# define SWIG_PYTHON_THREAD_END_ALLOW
-# endif
-# endif
-#else /* No thread support */
-# define SWIG_PYTHON_INITIALIZE_THREADS
-# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
-# define SWIG_PYTHON_THREAD_END_BLOCK
-# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
-# define SWIG_PYTHON_THREAD_END_ALLOW
-#endif
</del><span class="cx">
</span><ins>+
</ins><span class="cx"> /* -----------------------------------------------------------------------------
</span><del>- * Python API portion that goes into the runtime
</del><ins>+ * SWIG API. Portion that goes into the runtime
</ins><span class="cx"> * ----------------------------------------------------------------------------- */
</span><del>-
</del><span class="cx"> #ifdef __cplusplus
</span><span class="cx"> extern "C" {
</span><span class="cx"> #endif
</span><span class="lines">@@ -1090,1813 +817,795 @@
</span><span class="cx"> * ----------------------------------------------------------------------------- */
</span><span class="cx">
</span><span class="cx"> /* Constant Types */
</span><del>-#define SWIG_PY_POINTER 4
-#define SWIG_PY_BINARY 5
</del><ins>+#define SWIG_TCL_POINTER 4
+#define SWIG_TCL_BINARY 5
</ins><span class="cx">
</span><span class="cx"> /* Constant information structure */
</span><span class="cx"> typedef struct swig_const_info {
</span><del>- int type;
- char *name;
- long lvalue;
- double dvalue;
- void *pvalue;
- swig_type_info **ptype;
</del><ins>+ int type;
+ char *name;
+ long lvalue;
+ double dvalue;
+ void *pvalue;
+ swig_type_info **ptype;
</ins><span class="cx"> } swig_const_info;
</span><span class="cx">
</span><ins>+typedef int (*swig_wrapper)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
+typedef int (*swig_wrapper_func)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
+typedef char *(*swig_variable_func)(ClientData, Tcl_Interp *, char *, char *, int);
+typedef void (*swig_delete_func)(ClientData);
</ins><span class="cx">
</span><del>-/* -----------------------------------------------------------------------------
- * Wrapper of PyInstanceMethod_New() used in Python 3
- * It is exported to the generated module, used for -fastproxy
- * ----------------------------------------------------------------------------- */
-#if PY_VERSION_HEX >= 0x03000000
-SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
-{
- return PyInstanceMethod_New(func);
</del><ins>+typedef struct swig_method {
+ const char *name;
+ swig_wrapper method;
+} swig_method;
+
+typedef struct swig_attribute {
+ const char *name;
+ swig_wrapper getmethod;
+ swig_wrapper setmethod;
+} swig_attribute;
+
+typedef struct swig_class {
+ const char *name;
+ swig_type_info **type;
+ swig_wrapper constructor;
+ void (*destructor)(void *);
+ swig_method *methods;
+ swig_attribute *attributes;
+ struct swig_class **bases;
+ const char **base_names;
+ swig_module_info *module;
+} swig_class;
+
+typedef struct swig_instance {
+ Tcl_Obj *thisptr;
+ void *thisvalue;
+ swig_class *classptr;
+ int destroy;
+ Tcl_Command cmdtok;
+} swig_instance;
+
+/* Structure for command table */
+typedef struct {
+ const char *name;
+ int (*wrapper)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
+ ClientData clientdata;
+} swig_command_info;
+
+/* Structure for variable linking table */
+typedef struct {
+ const char *name;
+ void *addr;
+ char * (*get)(ClientData, Tcl_Interp *, char *, char *, int);
+ char * (*set)(ClientData, Tcl_Interp *, char *, char *, int);
+} swig_var_info;
+
+
+/* -----------------------------------------------------------------------------*
+ * Install a constant object
+ * -----------------------------------------------------------------------------*/
+
+static Tcl_HashTable swigconstTable;
+static int swigconstTableinit = 0;
+
+SWIGINTERN void
+SWIG_Tcl_SetConstantObj(Tcl_Interp *interp, const char* name, Tcl_Obj *obj) {
+ int newobj;
+ Tcl_ObjSetVar2(interp,Tcl_NewStringObj(name,-1), NULL, obj, TCL_GLOBAL_ONLY);
+ Tcl_SetHashValue(Tcl_CreateHashEntry(&swigconstTable, name, &newobj), (ClientData) obj);
</ins><span class="cx"> }
</span><del>-#else
-SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
-{
- return NULL;
</del><ins>+
+SWIGINTERN Tcl_Obj *
+SWIG_Tcl_GetConstantObj(const char *key) {
+ Tcl_HashEntry *entryPtr;
+ if (!swigconstTableinit) return 0;
+ entryPtr = Tcl_FindHashEntry(&swigconstTable, key);
+ if (entryPtr) {
+ return (Tcl_Obj *) Tcl_GetHashValue(entryPtr);
+ }
+ return 0;
</ins><span class="cx"> }
</span><del>-#endif
</del><span class="cx">
</span><span class="cx"> #ifdef __cplusplus
</span><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx">
</span><ins>+
</ins><span class="cx"> /* -----------------------------------------------------------------------------
</span><del>- * pyrun.swg
</del><ins>+ * See the LICENSE file for information on copyright, usage and redistribution
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
</ins><span class="cx"> *
</span><del>- * This file contains the runtime support for Python modules
- * and includes code for managing global variables and pointer
- * type checking.
</del><ins>+ * tclrun.swg
</ins><span class="cx"> *
</span><ins>+ * This file contains the runtime support for Tcl modules and includes
+ * code for managing global variables and pointer type checking.
</ins><span class="cx"> * ----------------------------------------------------------------------------- */
</span><span class="cx">
</span><span class="cx"> /* Common SWIG API */
</span><span class="cx">
</span><span class="cx"> /* for raw pointers */
</span><del>-#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
-#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
-#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
</del><ins>+#define SWIG_ConvertPtr(oc, ptr, ty, flags) SWIG_Tcl_ConvertPtr(interp, oc, ptr, ty, flags)
+#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Tcl_NewPointerObj(ptr, type, flags)
</ins><span class="cx">
</span><del>-#ifdef SWIGPYTHON_BUILTIN
-#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
-#else
-#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
-#endif
-
-#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
-
-#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
-#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
-#define swig_owntype int
-
</del><span class="cx"> /* for raw packed data */
</span><del>-#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
-#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
</del><ins>+#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Tcl_ConvertPacked(interp, obj, ptr, sz, ty)
+#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Tcl_NewPackedObj(ptr, sz, type)
</ins><span class="cx">
</span><span class="cx"> /* for class or struct pointers */
</span><del>-#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
-#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
</del><ins>+#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(thisvalue, type, flags) SWIG_Tcl_NewInstanceObj(interp, thisvalue, type, flags)
</ins><span class="cx">
</span><span class="cx"> /* for C or C++ function pointers */
</span><del>-#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
-#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
</del><ins>+#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Tcl_NewPointerObj(ptr, type, 0)
</ins><span class="cx">
</span><span class="cx"> /* for C++ member pointers, ie, member methods */
</span><del>-#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
-#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
</del><ins>+#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Tcl_ConvertPacked(interp,obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Tcl_NewPackedObj(ptr, sz, type)
</ins><span class="cx">
</span><span class="cx">
</span><span class="cx"> /* Runtime API */
</span><span class="cx">
</span><del>-#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
-#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
-#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
</del><ins>+#define SWIG_GetModule(clientdata) SWIG_Tcl_GetModule((Tcl_Interp *) (clientdata))
+#define SWIG_SetModule(clientdata, pointer) SWIG_Tcl_SetModule((Tcl_Interp *) (clientdata), pointer)
</ins><span class="cx">
</span><del>-#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
-#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
-#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
-#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
-#define SWIG_fail goto fail
</del><span class="cx">
</span><del>-
-/* Runtime API implementation */
-
</del><span class="cx"> /* Error manipulation */
</span><span class="cx">
</span><del>-SWIGINTERN void
-SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
- SWIG_PYTHON_THREAD_BEGIN_BLOCK;
- PyErr_SetObject(errtype, obj);
- Py_DECREF(obj);
- SWIG_PYTHON_THREAD_END_BLOCK;
-}
</del><ins>+#define SWIG_ErrorType(code) SWIG_Tcl_ErrorType(code)
+#define SWIG_Error(code, msg) SWIG_Tcl_SetErrorMsg(interp, SWIG_Tcl_ErrorType(code), msg)
+#define SWIG_fail goto fail
</ins><span class="cx">
</span><del>-SWIGINTERN void
-SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
- SWIG_PYTHON_THREAD_BEGIN_BLOCK;
- PyErr_SetString(errtype, msg);
- SWIG_PYTHON_THREAD_END_BLOCK;
-}
</del><span class="cx">
</span><del>-#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
</del><ins>+/* Tcl-specific SWIG API */
</ins><span class="cx">
</span><del>-/* Set a constant value */
</del><ins>+#define SWIG_Acquire(ptr) SWIG_Tcl_Acquire(ptr)
+#define SWIG_MethodCommand SWIG_Tcl_MethodCommand
+#define SWIG_Disown(ptr) SWIG_Tcl_Disown(ptr)
+#define SWIG_ConvertPtrFromString(c, ptr, ty, flags) SWIG_Tcl_ConvertPtrFromString(interp, c, ptr, ty, flags)
+#define SWIG_MakePtr(c, ptr, ty, flags) SWIG_Tcl_MakePtr(c, ptr, ty, flags)
+#define SWIG_PointerTypeFromString(c) SWIG_Tcl_PointerTypeFromString(c)
+#define SWIG_GetArgs SWIG_Tcl_GetArgs
+#define SWIG_GetConstantObj(key) SWIG_Tcl_GetConstantObj(key)
+#define SWIG_ObjectConstructor SWIG_Tcl_ObjectConstructor
+#define SWIG_Thisown(ptr) SWIG_Tcl_Thisown(ptr)
+#define SWIG_ObjectDelete SWIG_Tcl_ObjectDelete
</ins><span class="cx">
</span><del>-#if defined(SWIGPYTHON_BUILTIN)
</del><span class="cx">
</span><del>-SWIGINTERN void
-SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
- PyObject *s = PyString_InternFromString(key);
- PyList_Append(seq, s);
- Py_DECREF(s);
-}
-
-SWIGINTERN void
-SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
-#if PY_VERSION_HEX < 0x02030000
- PyDict_SetItemString(d, (char *)name, obj);
-#else
- PyDict_SetItemString(d, name, obj);
-#endif
- Py_DECREF(obj);
- if (public_interface)
- SwigPyBuiltin_AddPublicSymbol(public_interface, name);
-}
-
-#else
-
-SWIGINTERN void
-SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
-#if PY_VERSION_HEX < 0x02030000
- PyDict_SetItemString(d, (char *)name, obj);
-#else
- PyDict_SetItemString(d, name, obj);
-#endif
- Py_DECREF(obj);
-}
-
-#endif
-
-/* Append a value to the result obj */
-
-SWIGINTERN PyObject*
-SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
-#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
- if (!result) {
- result = obj;
- } else if (result == Py_None) {
- Py_DECREF(result);
- result = obj;
- } else {
- if (!PyList_Check(result)) {
- PyObject *o2 = result;
- result = PyList_New(1);
- PyList_SetItem(result, 0, o2);
- }
- PyList_Append(result,obj);
- Py_DECREF(obj);
- }
- return result;
-#else
- PyObject* o2;
- PyObject* o3;
- if (!result) {
- result = obj;
- } else if (result == Py_None) {
- Py_DECREF(result);
- result = obj;
- } else {
- if (!PyTuple_Check(result)) {
- o2 = result;
- result = PyTuple_New(1);
- PyTuple_SET_ITEM(result, 0, o2);
- }
- o3 = PyTuple_New(1);
- PyTuple_SET_ITEM(o3, 0, obj);
- o2 = result;
- result = PySequence_Concat(o2, o3);
- Py_DECREF(o2);
- Py_DECREF(o3);
- }
- return result;
-#endif
-}
-
-/* Unpack the argument tuple */
-
-SWIGINTERN int
-SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
-{
- if (!args) {
- if (!min && !max) {
- return 1;
- } else {
- PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
- name, (min == max ? "" : "at least "), (int)min);
- return 0;
- }
- }
- if (!PyTuple_Check(args)) {
- if (min <= 1 && max >= 1) {
- int i;
- objs[0] = args;
- for (i = 1; i < max; ++i) {
- objs[i] = 0;
- }
- return 2;
- }
- PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
- return 0;
- } else {
- Py_ssize_t l = PyTuple_GET_SIZE(args);
- if (l < min) {
- PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
- name, (min == max ? "" : "at least "), (int)min, (int)l);
- return 0;
- } else if (l > max) {
- PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
- name, (min == max ? "" : "at most "), (int)max, (int)l);
- return 0;
- } else {
- int i;
- for (i = 0; i < l; ++i) {
- objs[i] = PyTuple_GET_ITEM(args, i);
- }
- for (; l < max; ++l) {
- objs[l] = 0;
- }
- return i + 1;
- }
- }
-}
-
-/* A functor is a function object with one single object argument */
-#if PY_VERSION_HEX >= 0x02020000
-#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
-#else
-#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
-#endif
-
-/*
- Helper for static pointer initialization for both C and C++ code, for example
- static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
-*/
-#ifdef __cplusplus
-#define SWIG_STATIC_POINTER(var) var
-#else
-#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
-#endif
-
</del><ins>+#define SWIG_TCL_DECL_ARGS_2(arg1, arg2) (Tcl_Interp *interp SWIGUNUSED, arg1, arg2)
+#define SWIG_TCL_CALL_ARGS_2(arg1, arg2) (interp, arg1, arg2)
</ins><span class="cx"> /* -----------------------------------------------------------------------------
</span><del>- * Pointer declarations
</del><ins>+ * pointers/data manipulation
</ins><span class="cx"> * ----------------------------------------------------------------------------- */
</span><span class="cx">
</span><del>-/* Flags for new pointer objects */
-#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
-#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
</del><ins>+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION 0
+#define SWIG_GetConstant SWIG_GetConstantObj
+#define SWIG_Tcl_GetConstant SWIG_Tcl_GetConstantObj
</ins><span class="cx">
</span><del>-#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
</del><ins>+#include "assert.h"
</ins><span class="cx">
</span><del>-#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
-#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
-
</del><span class="cx"> #ifdef __cplusplus
</span><span class="cx"> extern "C" {
</span><ins>+#if 0
+} /* cc-mode */
</ins><span class="cx"> #endif
</span><del>-
-/* How to access Py_None */
-#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
-# ifndef SWIG_PYTHON_NO_BUILD_NONE
-# ifndef SWIG_PYTHON_BUILD_NONE
-# define SWIG_PYTHON_BUILD_NONE
-# endif
-# endif
</del><span class="cx"> #endif
</span><span class="cx">
</span><del>-#ifdef SWIG_PYTHON_BUILD_NONE
-# ifdef Py_None
-# undef Py_None
-# define Py_None SWIG_Py_None()
-# endif
-SWIGRUNTIMEINLINE PyObject *
-_SWIG_Py_None(void)
-{
- PyObject *none = Py_BuildValue((char*)"");
- Py_DECREF(none);
- return none;
</del><ins>+/* Object support */
+
+SWIGRUNTIME Tcl_HashTable*
+SWIG_Tcl_ObjectTable(void) {
+ static Tcl_HashTable swigobjectTable;
+ static int swigobjectTableinit = 0;
+ if (!swigobjectTableinit) {
+ Tcl_InitHashTable(&swigobjectTable, TCL_ONE_WORD_KEYS);
+ swigobjectTableinit = 1;
+ }
+ return &swigobjectTable;
</ins><span class="cx"> }
</span><del>-SWIGRUNTIME PyObject *
-SWIG_Py_None(void)
-{
- static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
- return none;
-}
-#endif
</del><span class="cx">
</span><del>-/* The python void return value */
-
-SWIGRUNTIMEINLINE PyObject *
-SWIG_Py_Void(void)
-{
- PyObject *none = Py_None;
- Py_INCREF(none);
- return none;
</del><ins>+/* Acquire ownership of a pointer */
+SWIGRUNTIME void
+SWIG_Tcl_Acquire(void *ptr) {
+ int newobj;
+ Tcl_CreateHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr, &newobj);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-/* SwigPyClientData */
-
-typedef struct {
- PyObject *klass;
- PyObject *newraw;
- PyObject *newargs;
- PyObject *destroy;
- int delargs;
- int implicitconv;
- PyTypeObject *pytype;
-} SwigPyClientData;
-
-SWIGRUNTIMEINLINE int
-SWIG_Python_CheckImplicit(swig_type_info *ty)
-{
- SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
- return data ? data->implicitconv : 0;
</del><ins>+SWIGRUNTIME int
+SWIG_Tcl_Thisown(void *ptr) {
+ if (Tcl_FindHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr)) {
+ return 1;
+ }
+ return 0;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-SWIGRUNTIMEINLINE PyObject *
-SWIG_Python_ExceptionType(swig_type_info *desc) {
- SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
- PyObject *klass = data ? data->klass : 0;
- return (klass ? klass : PyExc_RuntimeError);
</del><ins>+/* Disown a pointer. Returns 1 if we owned it to begin with */
+SWIGRUNTIME int
+SWIG_Tcl_Disown(void *ptr) {
+ Tcl_HashEntry *entryPtr = Tcl_FindHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr);
+ if (entryPtr) {
+ Tcl_DeleteHashEntry(entryPtr);
+ return 1;
+ }
+ return 0;
</ins><span class="cx"> }
</span><span class="cx">
</span><ins>+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Tcl_ConvertPtrFromString(Tcl_Interp *interp, const char *c, void **ptr, swig_type_info *ty, int flags) {
+ swig_cast_info *tc;
+ /* Pointer values must start with leading underscore */
+ while (*c != '_') {
+ *ptr = (void *) 0;
+ if (strcmp(c,"NULL") == 0) return SWIG_OK;
</ins><span class="cx">
</span><del>-SWIGRUNTIME SwigPyClientData *
-SwigPyClientData_New(PyObject* obj)
-{
- if (!obj) {
- return 0;
- } else {
- SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
- /* the klass element */
- data->klass = obj;
- Py_INCREF(data->klass);
- /* the newraw method and newargs arguments used to create a new raw instance */
- if (PyClass_Check(obj)) {
- data->newraw = 0;
- data->newargs = obj;
- Py_INCREF(obj);
- } else {
-#if (PY_VERSION_HEX < 0x02020000)
- data->newraw = 0;
-#else
- data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
-#endif
- if (data->newraw) {
- Py_INCREF(data->newraw);
- data->newargs = PyTuple_New(1);
- PyTuple_SetItem(data->newargs, 0, obj);
- } else {
- data->newargs = obj;
</del><ins>+ /* Empty string: not a pointer */
+ if (*c == 0) return SWIG_ERROR;
+
+ /* Hmmm. It could be an object name. */
+
+ /* Check if this is a command at all. Prevents <c> cget -this */
+ /* from being called when c is not a command, firing the unknown proc */
+ if (Tcl_VarEval(interp,"info commands ", c, (char *) NULL) == TCL_OK) {
+ Tcl_Obj *result = Tcl_GetObjResult(interp);
+ if (*(Tcl_GetStringFromObj(result, NULL)) == 0) {
+ /* It's not a command, so it can't be a pointer */
+ Tcl_ResetResult(interp);
+ return SWIG_ERROR;
</ins><span class="cx"> }
</span><del>- Py_INCREF(data->newargs);
- }
- /* the destroy method, aka as the C++ delete method */
- data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
- if (PyErr_Occurred()) {
- PyErr_Clear();
- data->destroy = 0;
- }
- if (data->destroy) {
- int flags;
- Py_INCREF(data->destroy);
- flags = PyCFunction_GET_FLAGS(data->destroy);
-#ifdef METH_O
- data->delargs = !(flags & (METH_O));
-#else
- data->delargs = 0;
-#endif
</del><span class="cx"> } else {
</span><del>- data->delargs = 0;
</del><ins>+ /* This will only fail if the argument is multiple words. */
+ /* Multiple words are also not commands. */
+ Tcl_ResetResult(interp);
+ return SWIG_ERROR;
</ins><span class="cx"> }
</span><del>- data->implicitconv = 0;
- data->pytype = 0;
- return data;
- }
-}
</del><span class="cx">
</span><del>-SWIGRUNTIME void
-SwigPyClientData_Del(SwigPyClientData *data) {
- Py_XDECREF(data->newraw);
- Py_XDECREF(data->newargs);
- Py_XDECREF(data->destroy);
-}
</del><ins>+ /* Check if this is really a SWIG pointer */
+ if (Tcl_VarEval(interp,c," cget -this", (char *) NULL) != TCL_OK) {
+ Tcl_ResetResult(interp);
+ return SWIG_ERROR;
+ }
</ins><span class="cx">
</span><del>-/* =============== SwigPyObject =====================*/
</del><ins>+ c = Tcl_GetStringFromObj(Tcl_GetObjResult(interp), NULL);
+ }
</ins><span class="cx">
</span><del>-typedef struct {
- PyObject_HEAD
- void *ptr;
- swig_type_info *ty;
- int own;
- PyObject *next;
-#ifdef SWIGPYTHON_BUILTIN
- PyObject *dict;
-#endif
-} SwigPyObject;
-
-SWIGRUNTIME PyObject *
-SwigPyObject_long(SwigPyObject *v)
-{
- return PyLong_FromVoidPtr(v->ptr);
-}
-
-SWIGRUNTIME PyObject *
-SwigPyObject_format(const char* fmt, SwigPyObject *v)
-{
- PyObject *res = NULL;
- PyObject *args = PyTuple_New(1);
- if (args) {
- if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
- PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
- if (ofmt) {
-#if PY_VERSION_HEX >= 0x03000000
- res = PyUnicode_Format(ofmt,args);
-#else
- res = PyString_Format(ofmt,args);
-#endif
- Py_DECREF(ofmt);
- }
- Py_DECREF(args);
</del><ins>+ c++;
+ c = SWIG_UnpackData(c,ptr,sizeof(void *));
+ if (ty) {
+ tc = c ? SWIG_TypeCheck(c,ty) : 0;
+ if (!tc) {
+ return SWIG_ERROR;
</ins><span class="cx"> }
</span><ins>+ if (flags & SWIG_POINTER_DISOWN) {
+ SWIG_Disown((void *) *ptr);
+ }
+ {
+ int newmemory = 0;
+ *ptr = SWIG_TypeCast(tc,(void *) *ptr,&newmemory);
+ assert(!newmemory); /* newmemory handling not yet implemented */
+ }
</ins><span class="cx"> }
</span><del>- return res;
</del><ins>+ return SWIG_OK;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-SWIGRUNTIME PyObject *
-SwigPyObject_oct(SwigPyObject *v)
-{
- return SwigPyObject_format("%o",v);
</del><ins>+/* Convert a pointer value */
+SWIGRUNTIMEINLINE int
+SWIG_Tcl_ConvertPtr(Tcl_Interp *interp, Tcl_Obj *oc, void **ptr, swig_type_info *ty, int flags) {
+ return SWIG_Tcl_ConvertPtrFromString(interp, Tcl_GetStringFromObj(oc,NULL), ptr, ty, flags);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-SWIGRUNTIME PyObject *
-SwigPyObject_hex(SwigPyObject *v)
-{
- return SwigPyObject_format("%x",v);
-}
-
-SWIGRUNTIME PyObject *
-#ifdef METH_NOARGS
-SwigPyObject_repr(SwigPyObject *v)
-#else
-SwigPyObject_repr(SwigPyObject *v, PyObject *args)
-#endif
-{
- const char *name = SWIG_TypePrettyName(v->ty);
- PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
- if (v->next) {
-# ifdef METH_NOARGS
- PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
-# else
- PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
-# endif
-# if PY_VERSION_HEX >= 0x03000000
- PyObject *joined = PyUnicode_Concat(repr, nrep);
- Py_DecRef(repr);
- Py_DecRef(nrep);
- repr = joined;
-# else
- PyString_ConcatAndDel(&repr,nrep);
-# endif
</del><ins>+/* Convert a pointer value */
+SWIGRUNTIME char *
+SWIG_Tcl_PointerTypeFromString(char *c) {
+ char d;
+ /* Pointer values must start with leading underscore. NULL has no type */
+ if (*c != '_') {
+ return 0;
</ins><span class="cx"> }
</span><del>- return repr;
</del><ins>+ c++;
+ /* Extract hex value from pointer */
+ while ((d = *c)) {
+ if (!(((d >= '0') && (d <= '9')) || ((d >= 'a') && (d <= 'f')))) break;
+ c++;
+ }
+ return c;
</ins><span class="cx"> }
</span><span class="cx">
</span><ins>+/* Convert a packed value value */
</ins><span class="cx"> SWIGRUNTIME int
</span><del>-SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
-{
- void *i = v->ptr;
- void *j = w->ptr;
- return (i < j) ? -1 : ((i > j) ? 1 : 0);
-}
</del><ins>+SWIG_Tcl_ConvertPacked(Tcl_Interp *SWIGUNUSEDPARM(interp) , Tcl_Obj *obj, void *ptr, int sz, swig_type_info *ty) {
+ swig_cast_info *tc;
+ const char *c;
</ins><span class="cx">
</span><del>-/* Added for Python 3.x, would it also be useful for Python 2.x? */
-SWIGRUNTIME PyObject*
-SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
-{
- PyObject* res;
- if( op != Py_EQ && op != Py_NE ) {
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
</del><ins>+ if (!obj) goto type_error;
+ c = Tcl_GetStringFromObj(obj,NULL);
+ /* Pointer values must start with leading underscore */
+ if (*c != '_') goto type_error;
+ c++;
+ c = SWIG_UnpackData(c,ptr,sz);
+ if (ty) {
+ tc = SWIG_TypeCheck(c,ty);
+ if (!tc) goto type_error;
</ins><span class="cx"> }
</span><del>- res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
- return res;
-}
</del><ins>+ return SWIG_OK;
</ins><span class="cx">
</span><ins>+ type_error:
</ins><span class="cx">
</span><del>-SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
-
-#ifdef SWIGPYTHON_BUILTIN
-static swig_type_info *SwigPyObject_stype = 0;
-SWIGRUNTIME PyTypeObject*
-SwigPyObject_type(void) {
- SwigPyClientData *cd;
- assert(SwigPyObject_stype);
- cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
- assert(cd);
- assert(cd->pytype);
- return cd->pytype;
</del><ins>+ return SWIG_ERROR;
</ins><span class="cx"> }
</span><del>-#else
-SWIGRUNTIME PyTypeObject*
-SwigPyObject_type(void) {
- static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
- return type;
-}
-#endif
</del><span class="cx">
</span><del>-SWIGRUNTIMEINLINE int
-SwigPyObject_Check(PyObject *op) {
-#ifdef SWIGPYTHON_BUILTIN
- PyTypeObject *target_tp = SwigPyObject_type();
- if (PyType_IsSubtype(op->ob_type, target_tp))
- return 1;
- return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
-#else
- return (Py_TYPE(op) == SwigPyObject_type())
- || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
-#endif
-}
</del><span class="cx">
</span><del>-SWIGRUNTIME PyObject *
-SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
-
</del><ins>+/* Take a pointer and convert it to a string */
</ins><span class="cx"> SWIGRUNTIME void
</span><del>-SwigPyObject_dealloc(PyObject *v)
-{
- SwigPyObject *sobj = (SwigPyObject *) v;
- PyObject *next = sobj->next;
- if (sobj->own == SWIG_POINTER_OWN) {
- swig_type_info *ty = sobj->ty;
- SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
- PyObject *destroy = data ? data->destroy : 0;
- if (destroy) {
- /* destroy is always a VARARGS method */
- PyObject *res;
- if (data->delargs) {
- /* we need to create a temporary object to carry the destroy operation */
- PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
- res = SWIG_Python_CallFunctor(destroy, tmp);
- Py_DECREF(tmp);
- } else {
- PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
- PyObject *mself = PyCFunction_GET_SELF(destroy);
- res = ((*meth)(mself, v));
- }
- Py_XDECREF(res);
- }
-#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
- else {
- const char *name = SWIG_TypePrettyName(ty);
- printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
- }
-#endif
- }
- Py_XDECREF(next);
- PyObject_DEL(v);
-}
-
-SWIGRUNTIME PyObject*
-SwigPyObject_append(PyObject* v, PyObject* next)
-{
- SwigPyObject *sobj = (SwigPyObject *) v;
-#ifndef METH_O
- PyObject *tmp = 0;
- if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
- next = tmp;
-#endif
- if (!SwigPyObject_Check(next)) {
- return NULL;
- }
- sobj->next = next;
- Py_INCREF(next);
- return SWIG_Py_Void();
-}
-
-SWIGRUNTIME PyObject*
-#ifdef METH_NOARGS
-SwigPyObject_next(PyObject* v)
-#else
-SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
-#endif
-{
- SwigPyObject *sobj = (SwigPyObject *) v;
- if (sobj->next) {
- Py_INCREF(sobj->next);
- return sobj->next;
</del><ins>+SWIG_Tcl_MakePtr(char *c, void *ptr, swig_type_info *ty, int flags) {
+ if (ptr) {
+ *(c++) = '_';
+ c = SWIG_PackData(c,&ptr,sizeof(void *));
+ strcpy(c,ty->name);
</ins><span class="cx"> } else {
</span><del>- return SWIG_Py_Void();
</del><ins>+ strcpy(c,(char *)"NULL");
</ins><span class="cx"> }
</span><ins>+ flags = 0;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-SWIGINTERN PyObject*
-#ifdef METH_NOARGS
-SwigPyObject_disown(PyObject *v)
-#else
-SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
-#endif
-{
- SwigPyObject *sobj = (SwigPyObject *)v;
- sobj->own = 0;
- return SWIG_Py_Void();
</del><ins>+/* Create a new pointer object */
+SWIGRUNTIMEINLINE Tcl_Obj *
+SWIG_Tcl_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
+ Tcl_Obj *robj;
+ char result[SWIG_BUFFER_SIZE];
+ SWIG_MakePtr(result,ptr,type,flags);
+ robj = Tcl_NewStringObj(result,-1);
+ return robj;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-SWIGINTERN PyObject*
-#ifdef METH_NOARGS
-SwigPyObject_acquire(PyObject *v)
-#else
-SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
-#endif
-{
- SwigPyObject *sobj = (SwigPyObject *)v;
- sobj->own = SWIG_POINTER_OWN;
- return SWIG_Py_Void();
</del><ins>+SWIGRUNTIME Tcl_Obj *
+SWIG_Tcl_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+ char result[1024];
+ char *r = result;
+ if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+ *(r++) = '_';
+ r = SWIG_PackData(r,ptr,sz);
+ strcpy(r,type->name);
+ return Tcl_NewStringObj(result,-1);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-SWIGINTERN PyObject*
-SwigPyObject_own(PyObject *v, PyObject *args)
-{
- PyObject *val = 0;
-#if (PY_VERSION_HEX < 0x02020000)
- if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
-#elif (PY_VERSION_HEX < 0x02050000)
- if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
-#else
- if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
-#endif
- {
- return NULL;
- }
- else
- {
- SwigPyObject *sobj = (SwigPyObject *)v;
- PyObject *obj = PyBool_FromLong(sobj->own);
- if (val) {
-#ifdef METH_NOARGS
- if (PyObject_IsTrue(val)) {
- SwigPyObject_acquire(v);
- } else {
- SwigPyObject_disown(v);
- }
-#else
- if (PyObject_IsTrue(val)) {
- SwigPyObject_acquire(v,args);
- } else {
- SwigPyObject_disown(v,args);
- }
-#endif
- }
- return obj;
- }
-}
</del><ins>+/* -----------------------------------------------------------------------------*
+ * Get type list
+ * -----------------------------------------------------------------------------*/
</ins><span class="cx">
</span><del>-#ifdef METH_O
-static PyMethodDef
-swigobject_methods[] = {
- {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
- {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"},
- {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
- {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
- {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
- {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
- {0, 0, 0, 0}
-};
-#else
-static PyMethodDef
-swigobject_methods[] = {
- {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
- {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
- {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
- {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
- {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
- {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
- {0, 0, 0, 0}
-};
-#endif
</del><ins>+SWIGRUNTIME swig_module_info *
+SWIG_Tcl_GetModule(Tcl_Interp *interp) {
+ const char *data;
+ swig_module_info *ret = 0;
+
+ /* first check if pointer already created */
+ data = Tcl_GetVar(interp, (char *)"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TCL_GLOBAL_ONLY);
+ if (data) {
+ SWIG_UnpackData(data, &ret, sizeof(swig_type_info **));
+ }
</ins><span class="cx">
</span><del>-#if PY_VERSION_HEX < 0x02020000
-SWIGINTERN PyObject *
-SwigPyObject_getattr(SwigPyObject *sobj,char *name)
-{
- return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
</del><ins>+ return ret;
</ins><span class="cx"> }
</span><del>-#endif
</del><span class="cx">
</span><del>-SWIGRUNTIME PyTypeObject*
-SwigPyObject_TypeOnce(void) {
- static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
</del><ins>+SWIGRUNTIME void
+SWIG_Tcl_SetModule(Tcl_Interp *interp, swig_module_info *module) {
+ char buf[SWIG_BUFFER_SIZE];
+ char *data;
</ins><span class="cx">
</span><del>- static PyNumberMethods SwigPyObject_as_number = {
- (binaryfunc)0, /*nb_add*/
- (binaryfunc)0, /*nb_subtract*/
- (binaryfunc)0, /*nb_multiply*/
- /* nb_divide removed in Python 3 */
-#if PY_VERSION_HEX < 0x03000000
- (binaryfunc)0, /*nb_divide*/
-#endif
- (binaryfunc)0, /*nb_remainder*/
- (binaryfunc)0, /*nb_divmod*/
- (ternaryfunc)0,/*nb_power*/
- (unaryfunc)0, /*nb_negative*/
- (unaryfunc)0, /*nb_positive*/
- (unaryfunc)0, /*nb_absolute*/
- (inquiry)0, /*nb_nonzero*/
- 0, /*nb_invert*/
- 0, /*nb_lshift*/
- 0, /*nb_rshift*/
- 0, /*nb_and*/
- 0, /*nb_xor*/
- 0, /*nb_or*/
-#if PY_VERSION_HEX < 0x03000000
- 0, /*nb_coerce*/
-#endif
- (unaryfunc)SwigPyObject_long, /*nb_int*/
-#if PY_VERSION_HEX < 0x03000000
- (unaryfunc)SwigPyObject_long, /*nb_long*/
-#else
- 0, /*nb_reserved*/
-#endif
- (unaryfunc)0, /*nb_float*/
-#if PY_VERSION_HEX < 0x03000000
- (unaryfunc)SwigPyObject_oct, /*nb_oct*/
- (unaryfunc)SwigPyObject_hex, /*nb_hex*/
-#endif
-#if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
-#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
-#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
-#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
- 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
-#endif
- };
-
- static PyTypeObject swigpyobject_type;
- static int type_init = 0;
- if (!type_init) {
- const PyTypeObject tmp = {
- /* PyObject header changed in Python 3 */
-#if PY_VERSION_HEX >= 0x03000000
- PyVarObject_HEAD_INIT(NULL, 0)
-#else
- PyObject_HEAD_INIT(NULL)
- 0, /* ob_size */
-#endif
- (char *)"SwigPyObject", /* tp_name */
- sizeof(SwigPyObject), /* tp_basicsize */
- 0, /* tp_itemsize */
- (destructor)SwigPyObject_dealloc, /* tp_dealloc */
- 0, /* tp_print */
-#if PY_VERSION_HEX < 0x02020000
- (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
-#else
- (getattrfunc)0, /* tp_getattr */
-#endif
- (setattrfunc)0, /* tp_setattr */
-#if PY_VERSION_HEX >= 0x03000000
- 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
-#else
- (cmpfunc)SwigPyObject_compare, /* tp_compare */
-#endif
- (reprfunc)SwigPyObject_repr, /* tp_repr */
- &SwigPyObject_as_number, /* tp_as_number */
- 0, /* tp_as_sequence */
- 0, /* tp_as_mapping */
- (hashfunc)0, /* tp_hash */
- (ternaryfunc)0, /* tp_call */
- 0, /* tp_str */
- PyObject_GenericGetAttr, /* tp_getattro */
- 0, /* tp_setattro */
- 0, /* tp_as_buffer */
- Py_TPFLAGS_DEFAULT, /* tp_flags */
- swigobject_doc, /* tp_doc */
- 0, /* tp_traverse */
- 0, /* tp_clear */
- (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
- 0, /* tp_weaklistoffset */
-#if PY_VERSION_HEX >= 0x02020000
- 0, /* tp_iter */
- 0, /* tp_iternext */
- swigobject_methods, /* tp_methods */
- 0, /* tp_members */
- 0, /* tp_getset */
- 0, /* tp_base */
- 0, /* tp_dict */
- 0, /* tp_descr_get */
- 0, /* tp_descr_set */
- 0, /* tp_dictoffset */
- 0, /* tp_init */
- 0, /* tp_alloc */
- 0, /* tp_new */
- 0, /* tp_free */
- 0, /* tp_is_gc */
- 0, /* tp_bases */
- 0, /* tp_mro */
- 0, /* tp_cache */
- 0, /* tp_subclasses */
- 0, /* tp_weaklist */
-#endif
-#if PY_VERSION_HEX >= 0x02030000
- 0, /* tp_del */
-#endif
-#if PY_VERSION_HEX >= 0x02060000
- 0, /* tp_version */
-#endif
-#ifdef COUNT_ALLOCS
- 0,0,0,0 /* tp_alloc -> tp_next */
-#endif
- };
- swigpyobject_type = tmp;
- type_init = 1;
-#if PY_VERSION_HEX < 0x02020000
- swigpyobject_type.ob_type = &PyType_Type;
-#else
- if (PyType_Ready(&swigpyobject_type) < 0)
- return NULL;
-#endif
- }
- return &swigpyobject_type;
</del><ins>+ /* create a new pointer */
+ data = SWIG_PackData(buf, &module, sizeof(swig_type_info **));
+ *data = 0;
+ Tcl_SetVar(interp, (char *)"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, buf, 0);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-SWIGRUNTIME PyObject *
-SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
-{
- SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
- if (sobj) {
- sobj->ptr = ptr;
- sobj->ty = ty;
- sobj->own = own;
- sobj->next = 0;
- }
- return (PyObject *)sobj;
-}
</del><ins>+/* -----------------------------------------------------------------------------*
+ * Object auxiliars
+ * -----------------------------------------------------------------------------*/
</ins><span class="cx">
</span><del>-/* -----------------------------------------------------------------------------
- * Implements a simple Swig Packed type, and use it instead of string
- * ----------------------------------------------------------------------------- */
</del><span class="cx">
</span><del>-typedef struct {
- PyObject_HEAD
- void *pack;
- swig_type_info *ty;
- size_t size;
-} SwigPyPacked;
-
-SWIGRUNTIME int
-SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
-{
- char result[SWIG_BUFFER_SIZE];
- fputs("<Swig Packed ", fp);
- if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
- fputs("at ", fp);
- fputs(result, fp);
</del><ins>+SWIGRUNTIME void
+SWIG_Tcl_ObjectDelete(ClientData clientData) {
+ swig_instance *si = (swig_instance *) clientData;
+ if ((si) && (si->destroy) && (SWIG_Disown(si->thisvalue))) {
+ if (si->classptr->destructor) {
+ (si->classptr->destructor)(si->thisvalue);
+ }
</ins><span class="cx"> }
</span><del>- fputs(v->ty->name,fp);
- fputs(">", fp);
- return 0;
</del><ins>+ Tcl_DecrRefCount(si->thisptr);
+ free(si);
</ins><span class="cx"> }
</span><del>-
-SWIGRUNTIME PyObject *
-SwigPyPacked_repr(SwigPyPacked *v)
-{
- char result[SWIG_BUFFER_SIZE];
- if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
- return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
- } else {
- return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
- }
-}
</del><span class="cx">
</span><del>-SWIGRUNTIME PyObject *
-SwigPyPacked_str(SwigPyPacked *v)
-{
- char result[SWIG_BUFFER_SIZE];
- if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
- return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
- } else {
- return SWIG_Python_str_FromChar(v->ty->name);
- }
-}
-
</del><ins>+/* Function to invoke object methods given an instance */
</ins><span class="cx"> SWIGRUNTIME int
</span><del>-SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
-{
- size_t i = v->size;
- size_t j = w->size;
- int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
- return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
-}
</del><ins>+SWIG_Tcl_MethodCommand(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST _objv[]) {
+ char *method, *attrname;
+ swig_instance *inst = (swig_instance *) clientData;
+ swig_method *meth;
+ swig_attribute *attr;
+ Tcl_Obj *oldarg;
+ Tcl_Obj **objv;
+ int rcode;
+ swig_class *cls;
+ swig_class *cls_stack[64];
+ int cls_stack_bi[64];
+ int cls_stack_top = 0;
+ int numconf = 2;
+ int bi;
</ins><span class="cx">
</span><del>-SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
-
-SWIGRUNTIME PyTypeObject*
-SwigPyPacked_type(void) {
- static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
- return type;
-}
-
-SWIGRUNTIMEINLINE int
-SwigPyPacked_Check(PyObject *op) {
- return ((op)->ob_type == SwigPyPacked_TypeOnce())
- || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
-}
-
-SWIGRUNTIME void
-SwigPyPacked_dealloc(PyObject *v)
-{
- if (SwigPyPacked_Check(v)) {
- SwigPyPacked *sobj = (SwigPyPacked *) v;
- free(sobj->pack);
</del><ins>+ objv = (Tcl_Obj **) _objv;
+ if (objc < 2) {
+ Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
+ return TCL_ERROR;
</ins><span class="cx"> }
</span><del>- PyObject_DEL(v);
-}
-
-SWIGRUNTIME PyTypeObject*
-SwigPyPacked_TypeOnce(void) {
- static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
- static PyTypeObject swigpypacked_type;
- static int type_init = 0;
- if (!type_init) {
- const PyTypeObject tmp = {
- /* PyObject header changed in Python 3 */
-#if PY_VERSION_HEX>=0x03000000
- PyVarObject_HEAD_INIT(NULL, 0)
-#else
- PyObject_HEAD_INIT(NULL)
- 0, /* ob_size */
-#endif
- (char *)"SwigPyPacked", /* tp_name */
- sizeof(SwigPyPacked), /* tp_basicsize */
- 0, /* tp_itemsize */
- (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
- (printfunc)SwigPyPacked_print, /* tp_print */
- (getattrfunc)0, /* tp_getattr */
- (setattrfunc)0, /* tp_setattr */
-#if PY_VERSION_HEX>=0x03000000
- 0, /* tp_reserved in 3.0.1 */
-#else
- (cmpfunc)SwigPyPacked_compare, /* tp_compare */
-#endif
- (reprfunc)SwigPyPacked_repr, /* tp_repr */
- 0, /* tp_as_number */
- 0, /* tp_as_sequence */
- 0, /* tp_as_mapping */
- (hashfunc)0, /* tp_hash */
- (ternaryfunc)0, /* tp_call */
- (reprfunc)SwigPyPacked_str, /* tp_str */
- PyObject_GenericGetAttr, /* tp_getattro */
- 0, /* tp_setattro */
- 0, /* tp_as_buffer */
- Py_TPFLAGS_DEFAULT, /* tp_flags */
- swigpacked_doc, /* tp_doc */
- 0, /* tp_traverse */
- 0, /* tp_clear */
- 0, /* tp_richcompare */
- 0, /* tp_weaklistoffset */
-#if PY_VERSION_HEX >= 0x02020000
- 0, /* tp_iter */
- 0, /* tp_iternext */
- 0, /* tp_methods */
- 0, /* tp_members */
- 0, /* tp_getset */
- 0, /* tp_base */
- 0, /* tp_dict */
- 0, /* tp_descr_get */
- 0, /* tp_descr_set */
- 0, /* tp_dictoffset */
- 0, /* tp_init */
- 0, /* tp_alloc */
- 0, /* tp_new */
- 0, /* tp_free */
- 0, /* tp_is_gc */
- 0, /* tp_bases */
- 0, /* tp_mro */
- 0, /* tp_cache */
- 0, /* tp_subclasses */
- 0, /* tp_weaklist */
-#endif
-#if PY_VERSION_HEX >= 0x02030000
- 0, /* tp_del */
-#endif
-#if PY_VERSION_HEX >= 0x02060000
- 0, /* tp_version */
-#endif
-#ifdef COUNT_ALLOCS
- 0,0,0,0 /* tp_alloc -> tp_next */
-#endif
- };
- swigpypacked_type = tmp;
- type_init = 1;
-#if PY_VERSION_HEX < 0x02020000
- swigpypacked_type.ob_type = &PyType_Type;
-#else
- if (PyType_Ready(&swigpypacked_type) < 0)
- return NULL;
-#endif
</del><ins>+ method = Tcl_GetStringFromObj(objv[1],NULL);
+ if (strcmp(method,"-acquire") == 0) {
+ inst->destroy = 1;
+ SWIG_Acquire(inst->thisvalue);
+ return TCL_OK;
</ins><span class="cx"> }
</span><del>- return &swigpypacked_type;
-}
-
-SWIGRUNTIME PyObject *
-SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
-{
- SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
- if (sobj) {
- void *pack = malloc(size);
- if (pack) {
- memcpy(pack, ptr, size);
- sobj->pack = pack;
- sobj->ty = ty;
- sobj->size = size;
- } else {
- PyObject_DEL((PyObject *) sobj);
- sobj = 0;
</del><ins>+ if (strcmp(method,"-disown") == 0) {
+ if (inst->destroy) {
+ SWIG_Disown(inst->thisvalue);
</ins><span class="cx"> }
</span><ins>+ inst->destroy = 0;
+ return TCL_OK;
</ins><span class="cx"> }
</span><del>- return (PyObject *) sobj;
-}
-
-SWIGRUNTIME swig_type_info *
-SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
-{
- if (SwigPyPacked_Check(obj)) {
- SwigPyPacked *sobj = (SwigPyPacked *)obj;
- if (sobj->size != size) return 0;
- memcpy(ptr, sobj->pack, size);
- return sobj->ty;
- } else {
- return 0;
</del><ins>+ if (strcmp(method,"-delete") == 0) {
+ Tcl_DeleteCommandFromToken(interp,inst->cmdtok);
+ return TCL_OK;
</ins><span class="cx"> }
</span><del>-}
-
-/* -----------------------------------------------------------------------------
- * pointers/data manipulation
- * ----------------------------------------------------------------------------- */
-
-SWIGRUNTIMEINLINE PyObject *
-_SWIG_This(void)
-{
- return SWIG_Python_str_FromChar("this");
-}
-
-static PyObject *swig_this = NULL;
-
-SWIGRUNTIME PyObject *
-SWIG_This(void)
-{
- if (swig_this == NULL)
- swig_this = _SWIG_This();
- return swig_this;
-}
-
-/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
-
-/* TODO: I don't know how to implement the fast getset in Python 3 right now */
-#if PY_VERSION_HEX>=0x03000000
-#define SWIG_PYTHON_SLOW_GETSET_THIS
-#endif
-
-SWIGRUNTIME SwigPyObject *
-SWIG_Python_GetSwigThis(PyObject *pyobj)
-{
- PyObject *obj;
-
- if (SwigPyObject_Check(pyobj))
- return (SwigPyObject *) pyobj;
-
-#ifdef SWIGPYTHON_BUILTIN
- (void)obj;
-# ifdef PyWeakref_CheckProxy
- if (PyWeakref_CheckProxy(pyobj)) {
- pyobj = PyWeakref_GET_OBJECT(pyobj);
- if (pyobj && SwigPyObject_Check(pyobj))
- return (SwigPyObject*) pyobj;
- }
-# endif
- return NULL;
-#else
-
- obj = 0;
-
-#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
- if (PyInstance_Check(pyobj)) {
- obj = _PyInstance_Lookup(pyobj, SWIG_This());
- } else {
- PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
- if (dictptr != NULL) {
- PyObject *dict = *dictptr;
- obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
- } else {
-#ifdef PyWeakref_CheckProxy
- if (PyWeakref_CheckProxy(pyobj)) {
- PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
- return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
</del><ins>+ cls_stack[cls_stack_top] = inst->classptr;
+ cls_stack_bi[cls_stack_top] = -1;
+ cls = inst->classptr;
+ while (1) {
+ bi = cls_stack_bi[cls_stack_top];
+ cls = cls_stack[cls_stack_top];
+ if (bi != -1) {
+ if (!cls->bases[bi] && cls->base_names[bi]) {
+ /* lookup and cache the base class */
+ swig_type_info *info = SWIG_TypeQueryModule(cls->module, cls->module, cls->base_names[bi]);
+ if (info) cls->bases[bi] = (swig_class *) info->clientdata;
</ins><span class="cx"> }
</span><del>-#endif
- obj = PyObject_GetAttr(pyobj,SWIG_This());
- if (obj) {
- Py_DECREF(obj);
- } else {
- if (PyErr_Occurred()) PyErr_Clear();
- return 0;
</del><ins>+ cls = cls->bases[bi];
+ if (cls) {
+ cls_stack_bi[cls_stack_top]++;
+ cls_stack_top++;
+ cls_stack[cls_stack_top] = cls;
+ cls_stack_bi[cls_stack_top] = -1;
+ continue;
</ins><span class="cx"> }
</span><span class="cx"> }
</span><del>- }
-#else
- obj = PyObject_GetAttr(pyobj,SWIG_This());
- if (obj) {
- Py_DECREF(obj);
- } else {
- if (PyErr_Occurred()) PyErr_Clear();
- return 0;
- }
-#endif
- if (obj && !SwigPyObject_Check(obj)) {
- /* a PyObject is called 'this', try to get the 'real this'
- SwigPyObject from it */
- return SWIG_Python_GetSwigThis(obj);
- }
- return (SwigPyObject *)obj;
-#endif
-}
-
-/* Acquire a pointer value */
-
-SWIGRUNTIME int
-SWIG_Python_AcquirePtr(PyObject *obj, int own) {
- if (own == SWIG_POINTER_OWN) {
- SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
- if (sobj) {
- int oldown = sobj->own;
- sobj->own = own;
- return oldown;
</del><ins>+ if (!cls) {
+ cls_stack_top--;
+ if (cls_stack_top < 0) break;
+ else continue;
</ins><span class="cx"> }
</span><del>- }
- return 0;
-}
</del><ins>+ cls_stack_bi[cls_stack_top]++;
</ins><span class="cx">
</span><del>-/* Convert a pointer value */
-
-SWIGRUNTIME int
-SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
- int res;
- SwigPyObject *sobj;
- int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
-
- if (!obj)
- return SWIG_ERROR;
- if (obj == Py_None && !implicit_conv) {
- if (ptr)
- *ptr = 0;
- return SWIG_OK;
- }
-
- res = SWIG_ERROR;
-
- sobj = SWIG_Python_GetSwigThis(obj);
- if (own)
- *own = 0;
- while (sobj) {
- void *vptr = sobj->ptr;
- if (ty) {
- swig_type_info *to = sobj->ty;
- if (to == ty) {
- /* no type cast needed */
- if (ptr) *ptr = vptr;
- break;
- } else {
- swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
- if (!tc) {
- sobj = (SwigPyObject *)sobj->next;
</del><ins>+ meth = cls->methods;
+ /* Check for methods */
+ while (meth && meth->name) {
+ if (strcmp(meth->name,method) == 0) {
+ oldarg = objv[1];
+ objv[1] = inst->thisptr;
+ Tcl_IncrRefCount(inst->thisptr);
+ rcode = (*meth->method)(clientData,interp,objc,objv);
+ objv[1] = oldarg;
+ Tcl_DecrRefCount(inst->thisptr);
+ return rcode;
+ }
+ meth++;
+ }
+ /* Check class methods for a match */
+ if (strcmp(method,"cget") == 0) {
+ if (objc < 3) {
+ Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
+ return TCL_ERROR;
+ }
+ attrname = Tcl_GetStringFromObj(objv[2],NULL);
+ attr = cls->attributes;
+ while (attr && attr->name) {
+ if ((strcmp(attr->name, attrname) == 0) && (attr->getmethod)) {
+ oldarg = objv[1];
+ objv[1] = inst->thisptr;
+ Tcl_IncrRefCount(inst->thisptr);
+ rcode = (*attr->getmethod)(clientData,interp,2, objv);
+ objv[1] = oldarg;
+ Tcl_DecrRefCount(inst->thisptr);
+ return rcode;
+ }
+ attr++;
+ }
+ if (strcmp(attrname, "-this") == 0) {
+ Tcl_SetObjResult(interp, Tcl_DuplicateObj(inst->thisptr));
+ return TCL_OK;
+ }
+ if (strcmp(attrname, "-thisown") == 0) {
+ if (SWIG_Thisown(inst->thisvalue)) {
+ Tcl_SetResult(interp,(char*)"1",TCL_STATIC);
</ins><span class="cx"> } else {
</span><del>- if (ptr) {
- int newmemory = 0;
- *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
- if (newmemory == SWIG_CAST_NEW_MEMORY) {
- assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
- if (own)
- *own = *own | SWIG_CAST_NEW_MEMORY;
- }
- }
- break;
</del><ins>+ Tcl_SetResult(interp,(char*)"0",TCL_STATIC);
</ins><span class="cx"> }
</span><ins>+ return TCL_OK;
</ins><span class="cx"> }
</span><del>- } else {
- if (ptr) *ptr = vptr;
- break;
- }
- }
- if (sobj) {
- if (own)
- *own = *own | sobj->own;
- if (flags & SWIG_POINTER_DISOWN) {
- sobj->own = 0;
- }
- res = SWIG_OK;
- } else {
- if (implicit_conv) {
- SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
- if (data && !data->implicitconv) {
- PyObject *klass = data->klass;
- if (klass) {
- PyObject *impconv;
- data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
- impconv = SWIG_Python_CallFunctor(klass, obj);
- data->implicitconv = 0;
- if (PyErr_Occurred()) {
- PyErr_Clear();
- impconv = 0;
</del><ins>+ } else if (strcmp(method, "configure") == 0) {
+ int i;
+ if (objc < 4) {
+ Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
+ return TCL_ERROR;
+ }
+ i = 2;
+ while (i < objc) {
+ attrname = Tcl_GetStringFromObj(objv[i],NULL);
+ attr = cls->attributes;
+ while (attr && attr->name) {
+ if ((strcmp(attr->name, attrname) == 0) && (attr->setmethod)) {
+ oldarg = objv[i];
+ objv[i] = inst->thisptr;
+ Tcl_IncrRefCount(inst->thisptr);
+ rcode = (*attr->setmethod)(clientData,interp,3, &objv[i-1]);
+ objv[i] = oldarg;
+ Tcl_DecrRefCount(inst->thisptr);
+ if (rcode != TCL_OK) return rcode;
+ numconf += 2;
</ins><span class="cx"> }
</span><del>- if (impconv) {
- SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
- if (iobj) {
- void *vptr;
- res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
- if (SWIG_IsOK(res)) {
- if (ptr) {
- *ptr = vptr;
- /* transfer the ownership to 'ptr' */
- iobj->own = 0;
- res = SWIG_AddCast(res);
- res = SWIG_AddNewMask(res);
- } else {
- res = SWIG_AddCast(res);
- }
- }
- }
- Py_DECREF(impconv);
- }
</del><ins>+ attr++;
</ins><span class="cx"> }
</span><ins>+ i+=2;
</ins><span class="cx"> }
</span><span class="cx"> }
</span><del>- if (!SWIG_IsOK(res) && obj == Py_None) {
- if (ptr)
- *ptr = 0;
- if (PyErr_Occurred())
- PyErr_Clear();
- res = SWIG_OK;
- }
</del><span class="cx"> }
</span><del>- return res;
-}
-
-/* Convert a function ptr value */
-
-SWIGRUNTIME int
-SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
- if (!PyCFunction_Check(obj)) {
- return SWIG_ConvertPtr(obj, ptr, ty, 0);
- } else {
- void *vptr = 0;
-
- /* here we get the method pointer for callbacks */
- const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
- const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
- if (desc)
- desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
- if (!desc)
- return SWIG_ERROR;
- if (ty) {
- swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
- if (tc) {
- int newmemory = 0;
- *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
- assert(!newmemory); /* newmemory handling not yet implemented */
- } else {
- return SWIG_ERROR;
- }
</del><ins>+ if (strcmp(method,"configure") == 0) {
+ if (numconf >= objc) {
+ return TCL_OK;
</ins><span class="cx"> } else {
</span><del>- *ptr = vptr;
</del><ins>+ Tcl_SetResult(interp,(char *) "Invalid attribute name.", TCL_STATIC);
+ return TCL_ERROR;
</ins><span class="cx"> }
</span><del>- return SWIG_OK;
</del><span class="cx"> }
</span><del>-}
-
-/* Convert a packed value value */
-
-SWIGRUNTIME int
-SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
- swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
- if (!to) return SWIG_ERROR;
- if (ty) {
- if (to != ty) {
- /* check type cast? */
- swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
- if (!tc) return SWIG_ERROR;
- }
</del><ins>+ if (strcmp(method,"cget") == 0) {
+ Tcl_SetResult(interp,(char *) "Invalid attribute name.", TCL_STATIC);
+ return TCL_ERROR;
</ins><span class="cx"> }
</span><del>- return SWIG_OK;
-}
-
-/* -----------------------------------------------------------------------------
- * Create a new pointer object
- * ----------------------------------------------------------------------------- */
-
-/*
- Create a new instance object, without calling __init__, and set the
- 'this' attribute.
-*/
-
-SWIGRUNTIME PyObject*
-SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
-{
-#if (PY_VERSION_HEX >= 0x02020000)
- PyObject *inst = 0;
- PyObject *newraw = data->newraw;
- if (newraw) {
- inst = PyObject_Call(newraw, data->newargs, NULL);
- if (inst) {
-#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
- PyObject **dictptr = _PyObject_GetDictPtr(inst);
- if (dictptr != NULL) {
- PyObject *dict = *dictptr;
- if (dict == NULL) {
- dict = PyDict_New();
- *dictptr = dict;
- PyDict_SetItem(dict, SWIG_This(), swig_this);
- }
</del><ins>+ Tcl_SetResult(interp, (char *) "Invalid method. Must be one of: configure cget -acquire -disown -delete", TCL_STATIC);
+ cls = inst->classptr;
+ bi = 0;
+ while (cls) {
+ meth = cls->methods;
+ while (meth && meth->name) {
+ char *cr = (char *) Tcl_GetStringResult(interp);
+ size_t meth_len = strlen(meth->name);
+ char* where = strchr(cr,':');
+ while(where) {
+ where = strstr(where, meth->name);
+ if(where) {
+ if(where[-1] == ' ' && (where[meth_len] == ' ' || where[meth_len]==0)) {
+ break;
+ } else {
+ where++;
+ }
+ }
</ins><span class="cx"> }
</span><del>-#else
- PyObject *key = SWIG_This();
- PyObject_SetAttr(inst, key, swig_this);
-#endif
- }
- } else {
-#if PY_VERSION_HEX >= 0x03000000
- inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
- if (inst) {
- PyObject_SetAttr(inst, SWIG_This(), swig_this);
- Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
- }
-#else
- PyObject *dict = PyDict_New();
- if (dict) {
- PyDict_SetItem(dict, SWIG_This(), swig_this);
- inst = PyInstance_NewRaw(data->newargs, dict);
- Py_DECREF(dict);
- }
-#endif
- }
- return inst;
-#else
-#if (PY_VERSION_HEX >= 0x02010000)
- PyObject *inst = 0;
- PyObject *dict = PyDict_New();
- if (dict) {
- PyDict_SetItem(dict, SWIG_This(), swig_this);
- inst = PyInstance_NewRaw(data->newargs, dict);
- Py_DECREF(dict);
- }
- return (PyObject *) inst;
-#else
- PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
- if (inst == NULL) {
- return NULL;
- }
- inst->in_class = (PyClassObject *)data->newargs;
- Py_INCREF(inst->in_class);
- inst->in_dict = PyDict_New();
- if (inst->in_dict == NULL) {
- Py_DECREF(inst);
- return NULL;
- }
-#ifdef Py_TPFLAGS_HAVE_WEAKREFS
- inst->in_weakreflist = NULL;
-#endif
-#ifdef Py_TPFLAGS_GC
- PyObject_GC_Init(inst);
-#endif
- PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
- return (PyObject *) inst;
-#endif
-#endif
-}
</del><span class="cx">
</span><del>-SWIGRUNTIME void
-SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
-{
- PyObject *dict;
-#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
- PyObject **dictptr = _PyObject_GetDictPtr(inst);
- if (dictptr != NULL) {
- dict = *dictptr;
- if (dict == NULL) {
- dict = PyDict_New();
- *dictptr = dict;
- }
- PyDict_SetItem(dict, SWIG_This(), swig_this);
- return;
- }
-#endif
- dict = PyObject_GetAttrString(inst, (char*)"__dict__");
- PyDict_SetItem(dict, SWIG_This(), swig_this);
- Py_DECREF(dict);
-}
-
-
-SWIGINTERN PyObject *
-SWIG_Python_InitShadowInstance(PyObject *args) {
- PyObject *obj[2];
- if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
- return NULL;
- } else {
- SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
- if (sthis) {
- SwigPyObject_append((PyObject*) sthis, obj[1]);
- } else {
- SWIG_Python_SetSwigThis(obj[0], obj[1]);
</del><ins>+ if (!where)
+ Tcl_AppendElement(interp, (char *) meth->name);
+ meth++;
</ins><span class="cx"> }
</span><del>- return SWIG_Py_Void();
</del><ins>+ cls = inst->classptr->bases[bi++];
</ins><span class="cx"> }
</span><ins>+ return TCL_ERROR;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-/* Create a new pointer object */
-
-SWIGRUNTIME PyObject *
-SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
- SwigPyClientData *clientdata;
- PyObject * robj;
- int own;
-
- if (!ptr)
- return SWIG_Py_Void();
-
- clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
- own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
- if (clientdata && clientdata->pytype) {
- SwigPyObject *newobj;
- if (flags & SWIG_BUILTIN_TP_INIT) {
- newobj = (SwigPyObject*) self;
- if (newobj->ptr) {
- PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
- while (newobj->next)
- newobj = (SwigPyObject *) newobj->next;
- newobj->next = next_self;
- newobj = (SwigPyObject *)next_self;
</del><ins>+/* This function takes the current result and turns it into an object command */
+SWIGRUNTIME Tcl_Obj *
+SWIG_Tcl_NewInstanceObj(Tcl_Interp *interp, void *thisvalue, swig_type_info *type, int flags) {
+ Tcl_Obj *robj = SWIG_NewPointerObj(thisvalue, type,0);
+ /* Check to see if this pointer belongs to a class or not */
+ if ((type->clientdata) && (interp)) {
+ Tcl_CmdInfo ci;
+ char *name;
+ name = Tcl_GetStringFromObj(robj,NULL);
+ if (!Tcl_GetCommandInfo(interp,name, &ci) || (flags)) {
+ swig_instance *newinst = (swig_instance *) malloc(sizeof(swig_instance));
+ newinst->thisptr = Tcl_DuplicateObj(robj);
+ Tcl_IncrRefCount(newinst->thisptr);
+ newinst->thisvalue = thisvalue;
+ newinst->classptr = (swig_class *) type->clientdata;
+ newinst->destroy = flags;
+ newinst->cmdtok = Tcl_CreateObjCommand(interp, Tcl_GetStringFromObj(robj,NULL), (swig_wrapper_func) SWIG_MethodCommand, (ClientData) newinst, (swig_delete_func) SWIG_ObjectDelete);
+ if (flags) {
+ SWIG_Acquire(thisvalue);
</ins><span class="cx"> }
</span><del>- } else {
- newobj = PyObject_New(SwigPyObject, clientdata->pytype);
</del><span class="cx"> }
</span><del>- if (newobj) {
- newobj->ptr = ptr;
- newobj->ty = type;
- newobj->own = own;
- newobj->next = 0;
-#ifdef SWIGPYTHON_BUILTIN
- newobj->dict = 0;
-#endif
- return (PyObject*) newobj;
- }
- return SWIG_Py_Void();
</del><span class="cx"> }
</span><del>-
- assert(!(flags & SWIG_BUILTIN_TP_INIT));
-
- robj = SwigPyObject_New(ptr, type, own);
- if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
- PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
- Py_DECREF(robj);
- robj = inst;
- }
</del><span class="cx"> return robj;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-/* Create a new packed object */
</del><ins>+/* Function to create objects */
+SWIGRUNTIME int
+SWIG_Tcl_ObjectConstructor(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
+ Tcl_Obj *newObj = 0;
+ void *thisvalue = 0;
+ swig_instance *newinst = 0;
+ swig_class *classptr = (swig_class *) clientData;
+ swig_wrapper cons = 0;
+ char *name = 0;
+ int firstarg = 0;
+ int thisarg = 0;
+ int destroy = 1;
</ins><span class="cx">
</span><del>-SWIGRUNTIMEINLINE PyObject *
-SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
- return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
-}
-
-/* -----------------------------------------------------------------------------*
- * Get type list
- * -----------------------------------------------------------------------------*/
-
-#ifdef SWIG_LINK_RUNTIME
-void *SWIG_ReturnGlobalTypeList(void *);
-#endif
-
-SWIGRUNTIME swig_module_info *
-SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
- static void *type_pointer = (void *)0;
- /* first check if module already created */
- if (!type_pointer) {
-#ifdef SWIG_LINK_RUNTIME
- type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
-#else
-# ifdef SWIGPY_USE_CAPSULE
- type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
-# else
- type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
- (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
-# endif
- if (PyErr_Occurred()) {
- PyErr_Clear();
- type_pointer = (void *)0;
- }
-#endif
</del><ins>+ if (!classptr) {
+ Tcl_SetResult(interp, (char *) "swig: internal runtime error. No class object defined.", TCL_STATIC);
+ return TCL_ERROR;
</ins><span class="cx"> }
</span><del>- return (swig_module_info *) type_pointer;
-}
-
-#if PY_MAJOR_VERSION < 2
-/* PyModule_AddObject function was introduced in Python 2.0. The following function
- is copied out of Python/modsupport.c in python version 2.3.4 */
-SWIGINTERN int
-PyModule_AddObject(PyObject *m, char *name, PyObject *o)
-{
- PyObject *dict;
- if (!PyModule_Check(m)) {
- PyErr_SetString(PyExc_TypeError,
- "PyModule_AddObject() needs module as first arg");
- return SWIG_ERROR;
- }
- if (!o) {
- PyErr_SetString(PyExc_TypeError,
- "PyModule_AddObject() needs non-NULL value");
- return SWIG_ERROR;
- }
-
- dict = PyModule_GetDict(m);
- if (dict == NULL) {
- /* Internal error -- modules must have a dict! */
- PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
- PyModule_GetName(m));
- return SWIG_ERROR;
- }
- if (PyDict_SetItemString(dict, name, o))
- return SWIG_ERROR;
- Py_DECREF(o);
- return SWIG_OK;
-}
-#endif
-
-SWIGRUNTIME void
-#ifdef SWIGPY_USE_CAPSULE
-SWIG_Python_DestroyModule(PyObject *obj)
-#else
-SWIG_Python_DestroyModule(void *vptr)
-#endif
-{
-#ifdef SWIGPY_USE_CAPSULE
- swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
-#else
- swig_module_info *swig_module = (swig_module_info *) vptr;
-#endif
- swig_type_info **types = swig_module->types;
- size_t i;
- for (i =0; i < swig_module->size; ++i) {
- swig_type_info *ty = types[i];
- if (ty->owndata) {
- SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
- if (data) SwigPyClientData_Del(data);
</del><ins>+ cons = classptr->constructor;
+ if (objc > 1) {
+ char *s = Tcl_GetStringFromObj(objv[1],NULL);
+ if (strcmp(s,"-this") == 0) {
+ thisarg = 2;
+ cons = 0;
+ } else if (strcmp(s,"-args") == 0) {
+ firstarg = 1;
+ } else if (objc == 2) {
+ firstarg = 1;
+ name = s;
+ } else if (objc >= 3) {
+ char *s1;
+ name = s;
+ s1 = Tcl_GetStringFromObj(objv[2],NULL);
+ if (strcmp(s1,"-this") == 0) {
+ thisarg = 3;
+ cons = 0;
+ } else {
+ firstarg = 1;
+ }
</ins><span class="cx"> }
</span><span class="cx"> }
</span><del>- Py_DECREF(SWIG_This());
- swig_this = NULL;
-}
-
-SWIGRUNTIME void
-SWIG_Python_SetModule(swig_module_info *swig_module) {
-#if PY_VERSION_HEX >= 0x03000000
- /* Add a dummy module object into sys.modules */
- PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
-#else
- static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
- PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
-#endif
-#ifdef SWIGPY_USE_CAPSULE
- PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
- if (pointer && module) {
- PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
</del><ins>+ if (cons) {
+ int result;
+ result = (*cons)(0, interp, objc-firstarg, &objv[firstarg]);
+ if (result != TCL_OK) {
+ return result;
+ }
+ newObj = Tcl_DuplicateObj(Tcl_GetObjResult(interp));
+ if (!name) name = Tcl_GetStringFromObj(newObj,NULL);
+ } else if (thisarg > 0) {
+ if (thisarg < objc) {
+ destroy = 0;
+ newObj = Tcl_DuplicateObj(objv[thisarg]);
+ if (!name) name = Tcl_GetStringFromObj(newObj,NULL);
+ } else {
+ Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
+ return TCL_ERROR;
+ }
</ins><span class="cx"> } else {
</span><del>- Py_XDECREF(pointer);
</del><ins>+ Tcl_SetResult(interp, (char *) "No constructor available.", TCL_STATIC);
+ return TCL_ERROR;
</ins><span class="cx"> }
</span><del>-#else
- PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
- if (pointer && module) {
- PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
- } else {
- Py_XDECREF(pointer);
</del><ins>+ if (SWIG_Tcl_ConvertPtr(interp,newObj, (void **) &thisvalue, *(classptr->type), 0) != SWIG_OK) {
+ Tcl_DecrRefCount(newObj);
+ return TCL_ERROR;
</ins><span class="cx"> }
</span><del>-#endif
-}
-
-/* The python cached type query */
-SWIGRUNTIME PyObject *
-SWIG_Python_TypeCache(void) {
- static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
- return cache;
-}
-
-SWIGRUNTIME swig_type_info *
-SWIG_Python_TypeQuery(const char *type)
-{
- PyObject *cache = SWIG_Python_TypeCache();
- PyObject *key = SWIG_Python_str_FromChar(type);
- PyObject *obj = PyDict_GetItem(cache, key);
- swig_type_info *descriptor;
- if (obj) {
-#ifdef SWIGPY_USE_CAPSULE
- descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
-#else
- descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
-#endif
- } else {
- swig_module_info *swig_module = SWIG_GetModule(0);
- descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
- if (descriptor) {
-#ifdef SWIGPY_USE_CAPSULE
- obj = PyCapsule_New((void*) descriptor, NULL, NULL);
-#else
- obj = PyCObject_FromVoidPtr(descriptor, NULL);
-#endif
- PyDict_SetItem(cache, key, obj);
- Py_DECREF(obj);
- }
</del><ins>+ newinst = (swig_instance *) malloc(sizeof(swig_instance));
+ newinst->thisptr = newObj;
+ Tcl_IncrRefCount(newObj);
+ newinst->thisvalue = thisvalue;
+ newinst->classptr = classptr;
+ newinst->destroy = destroy;
+ if (destroy) {
+ SWIG_Acquire(thisvalue);
</ins><span class="cx"> }
</span><del>- Py_DECREF(key);
- return descriptor;
</del><ins>+ newinst->cmdtok = Tcl_CreateObjCommand(interp,name, (swig_wrapper) SWIG_MethodCommand, (ClientData) newinst, (swig_delete_func) SWIG_ObjectDelete);
+ return TCL_OK;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-/*
- For backward compatibility only
-*/
-#define SWIG_POINTER_EXCEPTION 0
-#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
-#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
-
</del><ins>+/* -----------------------------------------------------------------------------*
+ * Get arguments
+ * -----------------------------------------------------------------------------*/
</ins><span class="cx"> SWIGRUNTIME int
</span><del>-SWIG_Python_AddErrMesg(const char* mesg, int infront)
-{
- if (PyErr_Occurred()) {
- PyObject *type = 0;
- PyObject *value = 0;
- PyObject *traceback = 0;
- PyErr_Fetch(&type, &value, &traceback);
- if (value) {
- char *tmp;
- PyObject *old_str = PyObject_Str(value);
- Py_XINCREF(type);
- PyErr_Clear();
- if (infront) {
- PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
</del><ins>+SWIG_Tcl_GetArgs(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], const char *fmt, ...) {
+ int argno = 0, opt = 0;
+ long tempi;
+ double tempd;
+ const char *c;
+ va_list ap;
+ void *vptr;
+ Tcl_Obj *obj = 0;
+ swig_type_info *ty;
+
+ va_start(ap,fmt);
+ for (c = fmt; (*c && (*c != ':') && (*c != ';')); c++,argno++) {
+ if (*c == '|') {
+ opt = 1;
+ c++;
+ }
+ if (argno >= (objc-1)) {
+ if (!opt) {
+ Tcl_SetResult(interp, (char *) "Wrong number of arguments ", TCL_STATIC);
+ goto argerror;
</ins><span class="cx"> } else {
</span><del>- PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
</del><ins>+ va_end(ap);
+ return TCL_OK;
</ins><span class="cx"> }
</span><del>- SWIG_Python_str_DelForPy3(tmp);
- Py_DECREF(old_str);
</del><span class="cx"> }
</span><del>- return 1;
- } else {
- return 0;
- }
-}
-
-SWIGRUNTIME int
-SWIG_Python_ArgFail(int argnum)
-{
- if (PyErr_Occurred()) {
- /* add information about failing argument */
- char mesg[256];
- PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
- return SWIG_Python_AddErrMesg(mesg, 1);
- } else {
- return 0;
- }
-}
</del><span class="cx">
</span><del>-SWIGRUNTIMEINLINE const char *
-SwigPyObject_GetDesc(PyObject *self)
-{
- SwigPyObject *v = (SwigPyObject *)self;
- swig_type_info *ty = v ? v->ty : 0;
- return ty ? ty->str : "";
-}
-
-SWIGRUNTIME void
-SWIG_Python_TypeError(const char *type, PyObject *obj)
-{
- if (type) {
-#if defined(SWIG_COBJECT_TYPES)
- if (obj && SwigPyObject_Check(obj)) {
- const char *otype = (const char *) SwigPyObject_GetDesc(obj);
- if (otype) {
- PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
- type, otype);
- return;
</del><ins>+ vptr = va_arg(ap,void *);
+ if (vptr) {
+ if (isupper(*c)) {
+ obj = SWIG_Tcl_GetConstantObj(Tcl_GetStringFromObj(objv[argno+1],0));
+ if (!obj) obj = objv[argno+1];
+ } else {
+ obj = objv[argno+1];
</ins><span class="cx"> }
</span><del>- } else
-#endif
- {
- const char *otype = (obj ? obj->ob_type->tp_name : 0);
- if (otype) {
- PyObject *str = PyObject_Str(obj);
- const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
- if (cstr) {
- PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
- type, otype, cstr);
- SWIG_Python_str_DelForPy3(cstr);
- } else {
- PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
- type, otype);
- }
- Py_XDECREF(str);
- return;
</del><ins>+ switch(*c) {
+ case 'i': case 'I':
+ case 'l': case 'L':
+ case 'h': case 'H':
+ case 'b': case 'B':
+ if (Tcl_GetLongFromObj(interp,obj,&tempi) != TCL_OK) goto argerror;
+ if ((*c == 'i') || (*c == 'I')) *((int *)vptr) = (int)tempi;
+ else if ((*c == 'l') || (*c == 'L')) *((long *)vptr) = (long)tempi;
+ else if ((*c == 'h') || (*c == 'H')) *((short*)vptr) = (short)tempi;
+ else if ((*c == 'b') || (*c == 'B')) *((unsigned char *)vptr) = (unsigned char)tempi;
+ break;
+ case 'f': case 'F':
+ case 'd': case 'D':
+ if (Tcl_GetDoubleFromObj(interp,obj,&tempd) != TCL_OK) goto argerror;
+ if ((*c == 'f') || (*c == 'F')) *((float *) vptr) = (float)tempd;
+ else if ((*c == 'd') || (*c == 'D')) *((double*) vptr) = tempd;
+ break;
+ case 's': case 'S':
+ if (*(c+1) == '#') {
+ int *vlptr = (int *) va_arg(ap, void *);
+ *((char **) vptr) = Tcl_GetStringFromObj(obj, vlptr);
+ c++;
+ } else {
+ *((char **)vptr) = Tcl_GetStringFromObj(obj,NULL);
+ }
+ break;
+ case 'c': case 'C':
+ *((char *)vptr) = *(Tcl_GetStringFromObj(obj,NULL));
+ break;
+ case 'p': case 'P':
+ ty = (swig_type_info *) va_arg(ap, void *);
+ if (SWIG_Tcl_ConvertPtr(interp, obj, (void **) vptr, ty, 0) != SWIG_OK) goto argerror;
+ break;
+ case 'o': case 'O':
+ *((Tcl_Obj **)vptr) = objv[argno+1];
+ break;
+ default:
+ break;
</ins><span class="cx"> }
</span><del>- }
- PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
- } else {
- PyErr_Format(PyExc_TypeError, "unexpected type is received");
</del><ins>+ }
</ins><span class="cx"> }
</span><del>-}
</del><span class="cx">
</span><del>-
-/* Convert a pointer value, signal an exception on a type mismatch */
-SWIGRUNTIME void *
-SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
- void *result;
- if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
- PyErr_Clear();
-#if SWIG_POINTER_EXCEPTION
- if (flags) {
- SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
- SWIG_Python_ArgFail(argnum);
- }
-#endif
</del><ins>+ if ((*c != ';') && ((objc-1) > argno)) {
+ Tcl_SetResult(interp, (char *) "Wrong # args.", TCL_STATIC);
+ goto argerror;
</ins><span class="cx"> }
</span><del>- return result;
-}
</del><ins>+ va_end(ap);
+ return TCL_OK;
</ins><span class="cx">
</span><del>-#ifdef SWIGPYTHON_BUILTIN
-SWIGRUNTIME int
-SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
- PyTypeObject *tp = obj->ob_type;
- PyObject *descr;
- PyObject *encoded_name;
- descrsetfunc f;
- int res = -1;
-
-# ifdef Py_USING_UNICODE
- if (PyString_Check(name)) {
- name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
- if (!name)
- return -1;
- } else if (!PyUnicode_Check(name))
-# else
- if (!PyString_Check(name))
-# endif
</del><ins>+ argerror:
</ins><span class="cx"> {
</span><del>- PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
- return -1;
- } else {
- Py_INCREF(name);
</del><ins>+ char temp[32];
+ sprintf(temp,"%d", argno+1);
+ c = strchr(fmt,':');
+ if (!c) c = strchr(fmt,';');
+ if (!c) c = (char *)"";
+ Tcl_AppendResult(interp,c," argument ", temp, NULL);
+ va_end(ap);
+ return TCL_ERROR;
</ins><span class="cx"> }
</span><del>-
- if (!tp->tp_dict) {
- if (PyType_Ready(tp) < 0)
- goto done;
- }
-
- descr = _PyType_Lookup(tp, name);
- f = NULL;
- if (descr != NULL)
- f = descr->ob_type->tp_descr_set;
- if (!f) {
- if (PyString_Check(name)) {
- encoded_name = name;
- Py_INCREF(name);
- } else {
- encoded_name = PyUnicode_AsUTF8String(name);
- }
- PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
- Py_DECREF(encoded_name);
- } else {
- res = f(descr, obj, value);
- }
-
- done:
- Py_DECREF(name);
- return res;
</del><span class="cx"> }
</span><del>-#endif
</del><span class="cx">
</span><del>-
</del><span class="cx"> #ifdef __cplusplus
</span><ins>+#if 0
+{ /* cc-mode */
+#endif
</ins><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="lines">@@ -2925,25 +1634,14 @@
</span><span class="cx">
</span><span class="cx"> /* -------- TYPES TABLE (END) -------- */
</span><span class="cx">
</span><del>-#if (PY_VERSION_HEX <= 0x02000000)
-# if !defined(SWIG_PYTHON_CLASSIC)
-# error "This python version requires swig to be run with the '-classic' option"
-# endif
-#endif
</del><ins>+#define SWIG_init Machista_Init
+#define SWIG_name "machista"
+#define SWIG_prefix "machista::"
+#define SWIG_namespace "machista"
</ins><span class="cx">
</span><del>-/*-----------------------------------------------
- @(target):= _machista.so
- ------------------------------------------------*/
-#if PY_VERSION_HEX >= 0x03000000
-# define SWIG_init PyInit__machista
</del><ins>+#define SWIG_version "1.0"
</ins><span class="cx">
</span><del>-#else
-# define SWIG_init init_machista
-
-#endif
-#define SWIG_name "_machista"
-
-#define SWIGVERSION 0x030005
</del><ins>+#define SWIGVERSION 0x010340
</ins><span class="cx"> #define SWIG_VERSION SWIGVERSION
</span><span class="cx">
</span><span class="cx">
</span><span class="lines">@@ -2951,7 +1649,28 @@
</span><span class="cx"> #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
</span><span class="cx">
</span><span class="cx">
</span><del>- #include <tcl.h>
</del><ins>+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef MAC_TCL
+#pragma export on
+#endif
+SWIGEXPORT int SWIG_init(Tcl_Interp *);
+#ifdef MAC_TCL
+#pragma export off
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+/* Compatibility version for TCL stubs */
+#ifndef SWIG_TCL_STUBS_VERSION
+#define SWIG_TCL_STUBS_VERSION "8.1"
+#endif
+
+
+
</ins><span class="cx"> #include "libmachista.h"
</span><span class="cx">
</span><span class="cx">
</span><span class="lines">@@ -2962,278 +1681,111 @@
</span><span class="cx"> #include <stdint.h>
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERNINLINE PyObject*
- SWIG_From_int (int value)
-{
- return PyInt_FromLong((long) value);
-}
</del><ins>+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+# define LLONG_MAX __LONG_LONG_MAX__
+# define LLONG_MIN (-LLONG_MAX - 1LL)
+# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
</ins><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERN swig_type_info*
-SWIG_pchar_descriptor(void)
</del><ins>+SWIGINTERNINLINE Tcl_Obj*
+SWIG_From_long (long value)
</ins><span class="cx"> {
</span><del>- static int init = 0;
- static swig_type_info* info = 0;
- if (!init) {
- info = SWIG_TypeQuery("_p_char");
- init = 1;
</del><ins>+ if (((long) INT_MIN <= value) && (value <= (long) INT_MAX)) {
+ return Tcl_NewIntObj((int)(value));
+ } else {
+ return Tcl_NewLongObj(value);
</ins><span class="cx"> }
</span><del>- return info;
</del><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERNINLINE PyObject *
</del><ins>+SWIGINTERNINLINE Tcl_Obj *
+SWIG_From_int (int value)
+{
+ return SWIG_From_long (value);
+}
+
+
+SWIGINTERNINLINE Tcl_Obj *
</ins><span class="cx"> SWIG_FromCharPtrAndSize(const char* carray, size_t size)
</span><span class="cx"> {
</span><del>- if (carray) {
- if (size > INT_MAX) {
- swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
- return pchar_descriptor ?
- SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
- } else {
-#if PY_VERSION_HEX >= 0x03000000
-#if PY_VERSION_HEX >= 0x03010000
- return PyUnicode_DecodeUTF8(carray, (int)(size), "surrogateescape");
-#else
- return PyUnicode_FromStringAndSize(carray, (int)(size));
-#endif
-#else
- return PyString_FromStringAndSize(carray, (int)(size));
-#endif
- }
- } else {
- return SWIG_Py_Void();
- }
</del><ins>+ return (size < INT_MAX) ? Tcl_NewStringObj(carray, (int)(size)) : NULL;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERNINLINE PyObject *
</del><ins>+SWIGINTERNINLINE Tcl_Obj *
</ins><span class="cx"> SWIG_FromCharPtr(const char *cptr)
</span><span class="cx"> {
</span><span class="cx"> return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERNINLINE PyObject*
- SWIG_From_unsigned_SS_int (unsigned int value)
-{
- return PyInt_FromSize_t((size_t) value);
-}
</del><ins>+#include <stdio.h>
+#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
+# ifndef snprintf
+# define snprintf _snprintf
+# endif
+#endif
</ins><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERN int
-SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
</del><ins>+SWIGINTERNINLINE Tcl_Obj*
+SWIG_From_unsigned_SS_long (unsigned long value)
</ins><span class="cx"> {
</span><del>-#if PY_VERSION_HEX>=0x03000000
- if (PyUnicode_Check(obj))
-#else
- if (PyString_Check(obj))
-#endif
- {
- char *cstr; Py_ssize_t len;
-#if PY_VERSION_HEX>=0x03000000
- if (!alloc && cptr) {
- /* We can't allow converting without allocation, since the internal
- representation of string in Python 3 is UCS-2/UCS-4 but we require
- a UTF-8 representation.
- TODO(bhy) More detailed explanation */
- return SWIG_RuntimeError;
- }
- obj = PyUnicode_AsUTF8String(obj);
- PyBytes_AsStringAndSize(obj, &cstr, &len);
- if(alloc) *alloc = SWIG_NEWOBJ;
-#else
- PyString_AsStringAndSize(obj, &cstr, &len);
-#endif
- if (cptr) {
- if (alloc) {
- /*
- In python the user should not be able to modify the inner
- string representation. To warranty that, if you define
- SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
- buffer is always returned.
-
- The default behavior is just to return the pointer value,
- so, be careful.
- */
-#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
- if (*alloc != SWIG_OLDOBJ)
-#else
- if (*alloc == SWIG_NEWOBJ)
-#endif
- {
- *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
- *alloc = SWIG_NEWOBJ;
- }
- else {
- *cptr = cstr;
- *alloc = SWIG_OLDOBJ;
- }
- } else {
- #if PY_VERSION_HEX>=0x03000000
- assert(0); /* Should never reach here in Python 3 */
- #endif
- *cptr = SWIG_Python_str_AsChar(obj);
- }
- }
- if (psize) *psize = len + 1;
-#if PY_VERSION_HEX>=0x03000000
- Py_XDECREF(obj);
-#endif
- return SWIG_OK;
</del><ins>+ if (value < (unsigned long) LONG_MAX) {
+ return SWIG_From_long ((long)(value));
</ins><span class="cx"> } else {
</span><del>- swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
- if (pchar_descriptor) {
- void* vptr = 0;
- if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
- if (cptr) *cptr = (char *) vptr;
- if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
- if (alloc) *alloc = SWIG_OLDOBJ;
- return SWIG_OK;
- }
- }
</del><ins>+ char temp[256];
+ sprintf(temp, "%lu", value);
+ return Tcl_NewStringObj(temp,-1);
</ins><span class="cx"> }
</span><del>- return SWIG_TypeError;
</del><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><ins>+SWIGINTERNINLINE Tcl_Obj *
+SWIG_From_unsigned_SS_int (unsigned int value)
+{
+ return SWIG_From_unsigned_SS_long (value);
+}
</ins><span class="cx">
</span><span class="cx">
</span><del>-
-#include <limits.h>
-#if !defined(SWIG_NO_LLONG_MAX)
-# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
-# define LLONG_MAX __LONG_LONG_MAX__
-# define LLONG_MIN (-LLONG_MAX - 1LL)
-# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
-# endif
-#endif
-
-
</del><span class="cx"> SWIGINTERN int
</span><del>-SWIG_AsVal_double (PyObject *obj, double *val)
-{
- int res = SWIG_TypeError;
- if (PyFloat_Check(obj)) {
- if (val) *val = PyFloat_AsDouble(obj);
</del><ins>+SWIG_AsCharPtrAndSize(Tcl_Obj *obj, char** cptr, size_t* psize, int *alloc)
+{
+ int len = 0;
+ char *cstr = Tcl_GetStringFromObj(obj, &len);
+ if (cstr) {
+ if (cptr) *cptr = cstr;
+ if (psize) *psize = len + 1;
+ if (alloc) *alloc = SWIG_OLDOBJ;
</ins><span class="cx"> return SWIG_OK;
</span><del>- } else if (PyInt_Check(obj)) {
- if (val) *val = PyInt_AsLong(obj);
- return SWIG_OK;
- } else if (PyLong_Check(obj)) {
- double v = PyLong_AsDouble(obj);
- if (!PyErr_Occurred()) {
- if (val) *val = v;
- return SWIG_OK;
- } else {
- PyErr_Clear();
- }
</del><span class="cx"> }
</span><del>-#ifdef SWIG_PYTHON_CAST_MODE
- {
- int dispatch = 0;
- double d = PyFloat_AsDouble(obj);
- if (!PyErr_Occurred()) {
- if (val) *val = d;
- return SWIG_AddCast(SWIG_OK);
- } else {
- PyErr_Clear();
- }
- if (!dispatch) {
- long v = PyLong_AsLong(obj);
- if (!PyErr_Occurred()) {
- if (val) *val = v;
- return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
- } else {
- PyErr_Clear();
- }
- }
- }
-#endif
- return res;
</del><ins>+ return SWIG_TypeError;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-#include <float.h>
</del><span class="cx">
</span><span class="cx">
</span><del>-#include <math.h>
</del><span class="cx">
</span><del>-
-SWIGINTERNINLINE int
-SWIG_CanCastAsInteger(double *d, double min, double max) {
- double x = *d;
- if ((min <= x && x <= max)) {
- double fx = floor(x);
- double cx = ceil(x);
- double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
- if ((errno == EDOM) || (errno == ERANGE)) {
- errno = 0;
- } else {
- double summ, reps, diff;
- if (rd < x) {
- diff = x - rd;
- } else if (rd > x) {
- diff = rd - x;
- } else {
- return 1;
- }
- summ = rd + x;
- reps = diff/summ;
- if (reps < 8*DBL_EPSILON) {
- *d = rd;
- return 1;
- }
- }
- }
- return 0;
-}
-
-
</del><span class="cx"> SWIGINTERN int
</span><del>-SWIG_AsVal_long (PyObject *obj, long* val)
</del><ins>+SWIG_AsVal_long SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, long* val)
</ins><span class="cx"> {
</span><del>- if (PyInt_Check(obj)) {
- if (val) *val = PyInt_AsLong(obj);
</del><ins>+ long v;
+ if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
+ if (val) *val = (long) v;
</ins><span class="cx"> return SWIG_OK;
</span><del>- } else if (PyLong_Check(obj)) {
- long v = PyLong_AsLong(obj);
- if (!PyErr_Occurred()) {
- if (val) *val = v;
- return SWIG_OK;
- } else {
- PyErr_Clear();
- }
</del><span class="cx"> }
</span><del>-#ifdef SWIG_PYTHON_CAST_MODE
- {
- int dispatch = 0;
- long v = PyInt_AsLong(obj);
- if (!PyErr_Occurred()) {
- if (val) *val = v;
- return SWIG_AddCast(SWIG_OK);
- } else {
- PyErr_Clear();
- }
- if (!dispatch) {
- double d;
- int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
- if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
- if (val) *val = (long)(d);
- return res;
- }
- }
- }
-#endif
</del><span class="cx"> return SWIG_TypeError;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><span class="cx"> SWIGINTERN int
</span><del>-SWIG_AsVal_int (PyObject * obj, int *val)
</del><ins>+SWIG_AsVal_int SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, int *val)
</ins><span class="cx"> {
</span><span class="cx"> long v;
</span><del>- int res = SWIG_AsVal_long (obj, &v);
</del><ins>+ int res = SWIG_AsVal_long SWIG_TCL_CALL_ARGS_2(obj, &v);
</ins><span class="cx"> if (SWIG_IsOK(res)) {
</span><span class="cx"> if ((v < INT_MIN || v > INT_MAX)) {
</span><span class="cx"> return SWIG_OverflowError;
</span><span class="lines">@@ -3246,69 +1798,49 @@
</span><span class="cx">
</span><span class="cx">
</span><span class="cx"> SWIGINTERN int
</span><del>-SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
-{
-#if PY_VERSION_HEX < 0x03000000
- if (PyInt_Check(obj)) {
- long v = PyInt_AsLong(obj);
</del><ins>+SWIG_AsVal_unsigned_SS_long SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, unsigned long *val) {
+ long v;
+ if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
</ins><span class="cx"> if (v >= 0) {
</span><del>- if (val) *val = v;
</del><ins>+ if (val) *val = (unsigned long) v;
</ins><span class="cx"> return SWIG_OK;
</span><del>- } else {
- return SWIG_OverflowError;
</del><span class="cx"> }
</span><del>- } else
-#endif
- if (PyLong_Check(obj)) {
- unsigned long v = PyLong_AsUnsignedLong(obj);
- if (!PyErr_Occurred()) {
- if (val) *val = v;
- return SWIG_OK;
- } else {
- PyErr_Clear();
-#if PY_VERSION_HEX >= 0x03000000
- {
- long v = PyLong_AsLong(obj);
- if (!PyErr_Occurred()) {
- if (v < 0) {
- return SWIG_OverflowError;
- }
- } else {
- PyErr_Clear();
- }
- }
-#endif
- }
</del><ins>+ /* If v is negative, then this could be a negative number, or an
+ unsigned value which doesn't fit in a signed long, so try to
+ get it as a string so we can distinguish these cases. */
</ins><span class="cx"> }
</span><del>-#ifdef SWIG_PYTHON_CAST_MODE
</del><span class="cx"> {
</span><del>- int dispatch = 0;
- unsigned long v = PyLong_AsUnsignedLong(obj);
- if (!PyErr_Occurred()) {
- if (val) *val = v;
- return SWIG_AddCast(SWIG_OK);
- } else {
- PyErr_Clear();
- }
- if (!dispatch) {
- double d;
- int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
- if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
- if (val) *val = (unsigned long)(d);
- return res;
</del><ins>+ int len = 0;
+ const char *nptr = Tcl_GetStringFromObj(obj, &len);
+ if (nptr && len > 0) {
+ char *endptr;
+ unsigned long v;
+ if (*nptr == '-') return SWIG_OverflowError;
+ errno = 0;
+ v = strtoul(nptr, &endptr,0);
+ if (nptr[0] == '\0' || *endptr != '\0')
+ return SWIG_TypeError;
+ if (v == ULONG_MAX && errno == ERANGE) {
+ errno = 0;
+ return SWIG_OverflowError;
+ } else {
+ if (*endptr == '\0') {
+ if (val) *val = v;
+ return SWIG_OK;
+ }
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>-#endif
</del><ins>+
</ins><span class="cx"> return SWIG_TypeError;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><span class="cx"> SWIGINTERN int
</span><del>-SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
</del><ins>+SWIG_AsVal_unsigned_SS_int SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, unsigned int *val)
</ins><span class="cx"> {
</span><span class="cx"> unsigned long v;
</span><del>- int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
</del><ins>+ int res = SWIG_AsVal_unsigned_SS_long SWIG_TCL_CALL_ARGS_2(obj, &v);
</ins><span class="cx"> if (SWIG_IsOK(res)) {
</span><span class="cx"> if ((v > UINT_MAX)) {
</span><span class="cx"> return SWIG_OverflowError;
</span><span class="lines">@@ -3322,422 +1854,363 @@
</span><span class="cx"> #ifdef __cplusplus
</span><span class="cx"> extern "C" {
</span><span class="cx"> #endif
</span><del>-SWIGINTERN PyObject *SUCCESS_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *module;
- PyObject *d;
- if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
- d = PyModule_GetDict(module);
- if (!d) return NULL;
- SWIG_Python_SetConstant(d, "SUCCESS",SWIG_From_int((int)((0x00))));
- return SWIG_Py_Void();
-}
-
-
-SWIGINTERN PyObject *EFILE_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *module;
- PyObject *d;
- if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
- d = PyModule_GetDict(module);
- if (!d) return NULL;
- SWIG_Python_SetConstant(d, "EFILE",SWIG_From_int((int)((0x01))));
- return SWIG_Py_Void();
-}
-
-
-SWIGINTERN PyObject *EMMAP_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *module;
- PyObject *d;
- if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
- d = PyModule_GetDict(module);
- if (!d) return NULL;
- SWIG_Python_SetConstant(d, "EMMAP",SWIG_From_int((int)((0x02))));
- return SWIG_Py_Void();
-}
-
-
-SWIGINTERN PyObject *EMEM_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *module;
- PyObject *d;
- if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
- d = PyModule_GetDict(module);
- if (!d) return NULL;
- SWIG_Python_SetConstant(d, "EMEM",SWIG_From_int((int)((0x04))));
- return SWIG_Py_Void();
-}
-
-
-SWIGINTERN PyObject *ERANGE_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *module;
- PyObject *d;
- if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
- d = PyModule_GetDict(module);
- if (!d) return NULL;
- SWIG_Python_SetConstant(d, "ERANGE",SWIG_From_int((int)((0x08))));
- return SWIG_Py_Void();
-}
-
-
-SWIGINTERN PyObject *EMAGIC_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *module;
- PyObject *d;
- if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
- d = PyModule_GetDict(module);
- if (!d) return NULL;
- SWIG_Python_SetConstant(d, "EMAGIC",SWIG_From_int((int)((0x10))));
- return SWIG_Py_Void();
-}
-
-
-SWIGINTERN PyObject *macho_handle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_macho_handle, SWIG_NewClientData(obj));
- return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject *_wrap_macho_loadcmd_mlt_install_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
</del><ins>+static swig_method swig_macho_handle_methods[] = {
+ {0,0}
+};
+static swig_attribute swig_macho_handle_attributes[] = {
+ {0,0,0}
+};
+static swig_class *swig_macho_handle_bases[] = {0};
+static const char * swig_macho_handle_base_names[] = {0};
+static swig_class _wrap_class_macho_handle = { "macho_handle", &SWIGTYPE_p_macho_handle,0,0, swig_macho_handle_methods, swig_macho_handle_attributes, swig_macho_handle_bases,swig_macho_handle_base_names, &swig_module };
+SWIGINTERN int
+_wrap_macho_loadcmd_mlt_install_name_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
</ins><span class="cx"> struct macho_loadcmd *arg1 = (struct macho_loadcmd *) 0 ;
</span><span class="cx"> void *argp1 = 0 ;
</span><span class="cx"> int res1 = 0 ;
</span><del>- PyObject * obj0 = 0 ;
</del><span class="cx"> char *result = 0 ;
</span><span class="cx">
</span><del>- if (!PyArg_ParseTuple(args,(char *)"O:macho_loadcmd_mlt_install_name_get",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_macho_loadcmd, 0 | 0 );
</del><ins>+ if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_loadcmd_mlt_install_name_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
+ res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_loadcmd, 0 | 0 );
</ins><span class="cx"> if (!SWIG_IsOK(res1)) {
</span><span class="cx"> SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_loadcmd_mlt_install_name_get" "', argument " "1"" of type '" "struct macho_loadcmd *""'");
</span><span class="cx"> }
</span><span class="cx"> arg1 = (struct macho_loadcmd *)(argp1);
</span><span class="cx"> result = (char *) ((arg1)->mlt_install_name);
</span><del>- resultobj = SWIG_FromCharPtr((const char *)result);
- return resultobj;
</del><ins>+ Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)result));
+ return TCL_OK;
</ins><span class="cx"> fail:
</span><del>- return NULL;
</del><ins>+ return TCL_ERROR;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERN PyObject *_wrap_macho_loadcmd_mlt_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
</del><ins>+SWIGINTERN int
+_wrap_macho_loadcmd_mlt_type_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
</ins><span class="cx"> struct macho_loadcmd *arg1 = (struct macho_loadcmd *) 0 ;
</span><span class="cx"> void *argp1 = 0 ;
</span><span class="cx"> int res1 = 0 ;
</span><del>- PyObject * obj0 = 0 ;
</del><span class="cx"> uint32_t result;
</span><span class="cx">
</span><del>- if (!PyArg_ParseTuple(args,(char *)"O:macho_loadcmd_mlt_type_get",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_macho_loadcmd, 0 | 0 );
</del><ins>+ if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_loadcmd_mlt_type_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
+ res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_loadcmd, 0 | 0 );
</ins><span class="cx"> if (!SWIG_IsOK(res1)) {
</span><span class="cx"> SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_loadcmd_mlt_type_get" "', argument " "1"" of type '" "struct macho_loadcmd *""'");
</span><span class="cx"> }
</span><span class="cx"> arg1 = (struct macho_loadcmd *)(argp1);
</span><span class="cx"> result = (uint32_t) ((arg1)->mlt_type);
</span><del>- resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
- return resultobj;
</del><ins>+ Tcl_SetObjResult(interp,SWIG_From_unsigned_SS_int((unsigned int)(result)));
+ return TCL_OK;
</ins><span class="cx"> fail:
</span><del>- return NULL;
</del><ins>+ return TCL_ERROR;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERN PyObject *_wrap_macho_loadcmd_mlt_comp_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
</del><ins>+SWIGINTERN int
+_wrap_macho_loadcmd_mlt_comp_version_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
</ins><span class="cx"> struct macho_loadcmd *arg1 = (struct macho_loadcmd *) 0 ;
</span><span class="cx"> void *argp1 = 0 ;
</span><span class="cx"> int res1 = 0 ;
</span><del>- PyObject * obj0 = 0 ;
</del><span class="cx"> uint32_t result;
</span><span class="cx">
</span><del>- if (!PyArg_ParseTuple(args,(char *)"O:macho_loadcmd_mlt_comp_version_get",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_macho_loadcmd, 0 | 0 );
</del><ins>+ if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_loadcmd_mlt_comp_version_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
+ res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_loadcmd, 0 | 0 );
</ins><span class="cx"> if (!SWIG_IsOK(res1)) {
</span><span class="cx"> SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_loadcmd_mlt_comp_version_get" "', argument " "1"" of type '" "struct macho_loadcmd *""'");
</span><span class="cx"> }
</span><span class="cx"> arg1 = (struct macho_loadcmd *)(argp1);
</span><span class="cx"> result = (uint32_t) ((arg1)->mlt_comp_version);
</span><del>- resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
- return resultobj;
</del><ins>+ Tcl_SetObjResult(interp,SWIG_From_unsigned_SS_int((unsigned int)(result)));
+ return TCL_OK;
</ins><span class="cx"> fail:
</span><del>- return NULL;
</del><ins>+ return TCL_ERROR;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERN PyObject *_wrap_macho_loadcmd_mlt_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
</del><ins>+SWIGINTERN int
+_wrap_macho_loadcmd_mlt_version_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
</ins><span class="cx"> struct macho_loadcmd *arg1 = (struct macho_loadcmd *) 0 ;
</span><span class="cx"> void *argp1 = 0 ;
</span><span class="cx"> int res1 = 0 ;
</span><del>- PyObject * obj0 = 0 ;
</del><span class="cx"> uint32_t result;
</span><span class="cx">
</span><del>- if (!PyArg_ParseTuple(args,(char *)"O:macho_loadcmd_mlt_version_get",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_macho_loadcmd, 0 | 0 );
</del><ins>+ if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_loadcmd_mlt_version_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
+ res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_loadcmd, 0 | 0 );
</ins><span class="cx"> if (!SWIG_IsOK(res1)) {
</span><span class="cx"> SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_loadcmd_mlt_version_get" "', argument " "1"" of type '" "struct macho_loadcmd *""'");
</span><span class="cx"> }
</span><span class="cx"> arg1 = (struct macho_loadcmd *)(argp1);
</span><span class="cx"> result = (uint32_t) ((arg1)->mlt_version);
</span><del>- resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
- return resultobj;
</del><ins>+ Tcl_SetObjResult(interp,SWIG_From_unsigned_SS_int((unsigned int)(result)));
+ return TCL_OK;
</ins><span class="cx"> fail:
</span><del>- return NULL;
</del><ins>+ return TCL_ERROR;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERN PyObject *_wrap_macho_loadcmd_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
</del><ins>+SWIGINTERN int
+_wrap_macho_loadcmd_next_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
</ins><span class="cx"> struct macho_loadcmd *arg1 = (struct macho_loadcmd *) 0 ;
</span><span class="cx"> void *argp1 = 0 ;
</span><span class="cx"> int res1 = 0 ;
</span><del>- PyObject * obj0 = 0 ;
</del><span class="cx"> struct macho_loadcmd *result = 0 ;
</span><span class="cx">
</span><del>- if (!PyArg_ParseTuple(args,(char *)"O:macho_loadcmd_next_get",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_macho_loadcmd, 0 | 0 );
</del><ins>+ if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_loadcmd_next_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
+ res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_loadcmd, 0 | 0 );
</ins><span class="cx"> if (!SWIG_IsOK(res1)) {
</span><span class="cx"> SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_loadcmd_next_get" "', argument " "1"" of type '" "struct macho_loadcmd *""'");
</span><span class="cx"> }
</span><span class="cx"> arg1 = (struct macho_loadcmd *)(argp1);
</span><span class="cx"> result = (struct macho_loadcmd *) ((arg1)->next);
</span><del>- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_macho_loadcmd, 0 | 0 );
- return resultobj;
</del><ins>+ Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_macho_loadcmd,0));
+ return TCL_OK;
</ins><span class="cx"> fail:
</span><del>- return NULL;
</del><ins>+ return TCL_ERROR;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERN PyObject *macho_loadcmd_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_macho_loadcmd, SWIG_NewClientData(obj));
- return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject *_wrap_macho_arch_mat_install_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
</del><ins>+static swig_method swig_macho_loadcmd_methods[] = {
+ {0,0}
+};
+static swig_attribute swig_macho_loadcmd_attributes[] = {
+ { "-mlt_install_name",_wrap_macho_loadcmd_mlt_install_name_get, 0 },
+ { "-mlt_type",_wrap_macho_loadcmd_mlt_type_get, 0 },
+ { "-mlt_comp_version",_wrap_macho_loadcmd_mlt_comp_version_get, 0 },
+ { "-mlt_version",_wrap_macho_loadcmd_mlt_version_get, 0 },
+ { "-next",_wrap_macho_loadcmd_next_get, 0 },
+ {0,0,0}
+};
+static swig_class *swig_macho_loadcmd_bases[] = {0};
+static const char * swig_macho_loadcmd_base_names[] = {0};
+static swig_class _wrap_class_macho_loadcmd = { "macho_loadcmd", &SWIGTYPE_p_macho_loadcmd,0,0, swig_macho_loadcmd_methods, swig_macho_loadcmd_attributes, swig_macho_loadcmd_bases,swig_macho_loadcmd_base_names, &swig_module };
+SWIGINTERN int
+_wrap_macho_arch_mat_install_name_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
</ins><span class="cx"> struct macho_arch *arg1 = (struct macho_arch *) 0 ;
</span><span class="cx"> void *argp1 = 0 ;
</span><span class="cx"> int res1 = 0 ;
</span><del>- PyObject * obj0 = 0 ;
</del><span class="cx"> char *result = 0 ;
</span><span class="cx">
</span><del>- if (!PyArg_ParseTuple(args,(char *)"O:macho_arch_mat_install_name_get",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_macho_arch, 0 | 0 );
</del><ins>+ if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_arch_mat_install_name_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
+ res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_arch, 0 | 0 );
</ins><span class="cx"> if (!SWIG_IsOK(res1)) {
</span><span class="cx"> SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_arch_mat_install_name_get" "', argument " "1"" of type '" "struct macho_arch *""'");
</span><span class="cx"> }
</span><span class="cx"> arg1 = (struct macho_arch *)(argp1);
</span><span class="cx"> result = (char *) ((arg1)->mat_install_name);
</span><del>- resultobj = SWIG_FromCharPtr((const char *)result);
- return resultobj;
</del><ins>+ Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)result));
+ return TCL_OK;
</ins><span class="cx"> fail:
</span><del>- return NULL;
</del><ins>+ return TCL_ERROR;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERN PyObject *_wrap_macho_arch_mat_rpath_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
</del><ins>+SWIGINTERN int
+_wrap_macho_arch_mat_rpath_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
</ins><span class="cx"> struct macho_arch *arg1 = (struct macho_arch *) 0 ;
</span><span class="cx"> void *argp1 = 0 ;
</span><span class="cx"> int res1 = 0 ;
</span><del>- PyObject * obj0 = 0 ;
</del><span class="cx"> char *result = 0 ;
</span><span class="cx">
</span><del>- if (!PyArg_ParseTuple(args,(char *)"O:macho_arch_mat_rpath_get",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_macho_arch, 0 | 0 );
</del><ins>+ if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_arch_mat_rpath_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
+ res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_arch, 0 | 0 );
</ins><span class="cx"> if (!SWIG_IsOK(res1)) {
</span><span class="cx"> SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_arch_mat_rpath_get" "', argument " "1"" of type '" "struct macho_arch *""'");
</span><span class="cx"> }
</span><span class="cx"> arg1 = (struct macho_arch *)(argp1);
</span><span class="cx"> result = (char *) ((arg1)->mat_rpath);
</span><del>- resultobj = SWIG_FromCharPtr((const char *)result);
- return resultobj;
</del><ins>+ Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)result));
+ return TCL_OK;
</ins><span class="cx"> fail:
</span><del>- return NULL;
</del><ins>+ return TCL_ERROR;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERN PyObject *_wrap_macho_arch_mat_arch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
</del><ins>+SWIGINTERN int
+_wrap_macho_arch_mat_arch_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
</ins><span class="cx"> struct macho_arch *arg1 = (struct macho_arch *) 0 ;
</span><span class="cx"> void *argp1 = 0 ;
</span><span class="cx"> int res1 = 0 ;
</span><del>- PyObject * obj0 = 0 ;
</del><span class="cx"> cpu_type_t result;
</span><span class="cx">
</span><del>- if (!PyArg_ParseTuple(args,(char *)"O:macho_arch_mat_arch_get",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_macho_arch, 0 | 0 );
</del><ins>+ if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_arch_mat_arch_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
+ res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_arch, 0 | 0 );
</ins><span class="cx"> if (!SWIG_IsOK(res1)) {
</span><span class="cx"> SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_arch_mat_arch_get" "', argument " "1"" of type '" "struct macho_arch *""'");
</span><span class="cx"> }
</span><span class="cx"> arg1 = (struct macho_arch *)(argp1);
</span><span class="cx"> result = (cpu_type_t) ((arg1)->mat_arch);
</span><del>- resultobj = SWIG_From_int((int)(result));
- return resultobj;
</del><ins>+ Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
+ return TCL_OK;
</ins><span class="cx"> fail:
</span><del>- return NULL;
</del><ins>+ return TCL_ERROR;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERN PyObject *_wrap_macho_arch_mat_comp_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
</del><ins>+SWIGINTERN int
+_wrap_macho_arch_mat_comp_version_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
</ins><span class="cx"> struct macho_arch *arg1 = (struct macho_arch *) 0 ;
</span><span class="cx"> void *argp1 = 0 ;
</span><span class="cx"> int res1 = 0 ;
</span><del>- PyObject * obj0 = 0 ;
</del><span class="cx"> uint32_t result;
</span><span class="cx">
</span><del>- if (!PyArg_ParseTuple(args,(char *)"O:macho_arch_mat_comp_version_get",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_macho_arch, 0 | 0 );
</del><ins>+ if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_arch_mat_comp_version_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
+ res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_arch, 0 | 0 );
</ins><span class="cx"> if (!SWIG_IsOK(res1)) {
</span><span class="cx"> SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_arch_mat_comp_version_get" "', argument " "1"" of type '" "struct macho_arch *""'");
</span><span class="cx"> }
</span><span class="cx"> arg1 = (struct macho_arch *)(argp1);
</span><span class="cx"> result = (uint32_t) ((arg1)->mat_comp_version);
</span><del>- resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
- return resultobj;
</del><ins>+ Tcl_SetObjResult(interp,SWIG_From_unsigned_SS_int((unsigned int)(result)));
+ return TCL_OK;
</ins><span class="cx"> fail:
</span><del>- return NULL;
</del><ins>+ return TCL_ERROR;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERN PyObject *_wrap_macho_arch_mat_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
</del><ins>+SWIGINTERN int
+_wrap_macho_arch_mat_version_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
</ins><span class="cx"> struct macho_arch *arg1 = (struct macho_arch *) 0 ;
</span><span class="cx"> void *argp1 = 0 ;
</span><span class="cx"> int res1 = 0 ;
</span><del>- PyObject * obj0 = 0 ;
</del><span class="cx"> uint32_t result;
</span><span class="cx">
</span><del>- if (!PyArg_ParseTuple(args,(char *)"O:macho_arch_mat_version_get",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_macho_arch, 0 | 0 );
</del><ins>+ if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_arch_mat_version_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
+ res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_arch, 0 | 0 );
</ins><span class="cx"> if (!SWIG_IsOK(res1)) {
</span><span class="cx"> SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_arch_mat_version_get" "', argument " "1"" of type '" "struct macho_arch *""'");
</span><span class="cx"> }
</span><span class="cx"> arg1 = (struct macho_arch *)(argp1);
</span><span class="cx"> result = (uint32_t) ((arg1)->mat_version);
</span><del>- resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
- return resultobj;
</del><ins>+ Tcl_SetObjResult(interp,SWIG_From_unsigned_SS_int((unsigned int)(result)));
+ return TCL_OK;
</ins><span class="cx"> fail:
</span><del>- return NULL;
</del><ins>+ return TCL_ERROR;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERN PyObject *_wrap_macho_arch_mat_loadcmds_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
</del><ins>+SWIGINTERN int
+_wrap_macho_arch_mat_loadcmds_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
</ins><span class="cx"> struct macho_arch *arg1 = (struct macho_arch *) 0 ;
</span><span class="cx"> void *argp1 = 0 ;
</span><span class="cx"> int res1 = 0 ;
</span><del>- PyObject * obj0 = 0 ;
</del><span class="cx"> struct macho_loadcmd *result = 0 ;
</span><span class="cx">
</span><del>- if (!PyArg_ParseTuple(args,(char *)"O:macho_arch_mat_loadcmds_get",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_macho_arch, 0 | 0 );
</del><ins>+ if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_arch_mat_loadcmds_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
+ res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_arch, 0 | 0 );
</ins><span class="cx"> if (!SWIG_IsOK(res1)) {
</span><span class="cx"> SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_arch_mat_loadcmds_get" "', argument " "1"" of type '" "struct macho_arch *""'");
</span><span class="cx"> }
</span><span class="cx"> arg1 = (struct macho_arch *)(argp1);
</span><span class="cx"> result = (struct macho_loadcmd *) ((arg1)->mat_loadcmds);
</span><del>- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_macho_loadcmd, 0 | 0 );
- return resultobj;
</del><ins>+ Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_macho_loadcmd,0));
+ return TCL_OK;
</ins><span class="cx"> fail:
</span><del>- return NULL;
</del><ins>+ return TCL_ERROR;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERN PyObject *_wrap_macho_arch_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
</del><ins>+SWIGINTERN int
+_wrap_macho_arch_next_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
</ins><span class="cx"> struct macho_arch *arg1 = (struct macho_arch *) 0 ;
</span><span class="cx"> void *argp1 = 0 ;
</span><span class="cx"> int res1 = 0 ;
</span><del>- PyObject * obj0 = 0 ;
</del><span class="cx"> struct macho_arch *result = 0 ;
</span><span class="cx">
</span><del>- if (!PyArg_ParseTuple(args,(char *)"O:macho_arch_next_get",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_macho_arch, 0 | 0 );
</del><ins>+ if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_arch_next_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
+ res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_arch, 0 | 0 );
</ins><span class="cx"> if (!SWIG_IsOK(res1)) {
</span><span class="cx"> SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_arch_next_get" "', argument " "1"" of type '" "struct macho_arch *""'");
</span><span class="cx"> }
</span><span class="cx"> arg1 = (struct macho_arch *)(argp1);
</span><span class="cx"> result = (struct macho_arch *) ((arg1)->next);
</span><del>- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_macho_arch, 0 | 0 );
- return resultobj;
</del><ins>+ Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_macho_arch,0));
+ return TCL_OK;
</ins><span class="cx"> fail:
</span><del>- return NULL;
</del><ins>+ return TCL_ERROR;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERN PyObject *macho_arch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_macho_arch, SWIG_NewClientData(obj));
- return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject *_wrap_macho_mt_archs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
</del><ins>+static swig_method swig_macho_arch_methods[] = {
+ {0,0}
+};
+static swig_attribute swig_macho_arch_attributes[] = {
+ { "-mat_install_name",_wrap_macho_arch_mat_install_name_get, 0 },
+ { "-mat_rpath",_wrap_macho_arch_mat_rpath_get, 0 },
+ { "-mat_arch",_wrap_macho_arch_mat_arch_get, 0 },
+ { "-mat_comp_version",_wrap_macho_arch_mat_comp_version_get, 0 },
+ { "-mat_version",_wrap_macho_arch_mat_version_get, 0 },
+ { "-mat_loadcmds",_wrap_macho_arch_mat_loadcmds_get, 0 },
+ { "-next",_wrap_macho_arch_next_get, 0 },
+ {0,0,0}
+};
+static swig_class *swig_macho_arch_bases[] = {0};
+static const char * swig_macho_arch_base_names[] = {0};
+static swig_class _wrap_class_macho_arch = { "macho_arch", &SWIGTYPE_p_macho_arch,0,0, swig_macho_arch_methods, swig_macho_arch_attributes, swig_macho_arch_bases,swig_macho_arch_base_names, &swig_module };
+SWIGINTERN int
+_wrap_macho_mt_archs_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
</ins><span class="cx"> struct macho *arg1 = (struct macho *) 0 ;
</span><span class="cx"> void *argp1 = 0 ;
</span><span class="cx"> int res1 = 0 ;
</span><del>- PyObject * obj0 = 0 ;
</del><span class="cx"> struct macho_arch *result = 0 ;
</span><span class="cx">
</span><del>- if (!PyArg_ParseTuple(args,(char *)"O:macho_mt_archs_get",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_macho, 0 | 0 );
</del><ins>+ if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_mt_archs_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
+ res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho, 0 | 0 );
</ins><span class="cx"> if (!SWIG_IsOK(res1)) {
</span><span class="cx"> SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_mt_archs_get" "', argument " "1"" of type '" "struct macho *""'");
</span><span class="cx"> }
</span><span class="cx"> arg1 = (struct macho *)(argp1);
</span><span class="cx"> result = (struct macho_arch *) ((arg1)->mt_archs);
</span><del>- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_macho_arch, 0 | 0 );
- return resultobj;
</del><ins>+ Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_macho_arch,0));
+ return TCL_OK;
</ins><span class="cx"> fail:
</span><del>- return NULL;
</del><ins>+ return TCL_ERROR;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERN PyObject *macho_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *obj;
- if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_macho, SWIG_NewClientData(obj));
- return SWIG_Py_Void();
-}
-
-SWIGINTERN PyObject *_wrap_create_handle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
</del><ins>+static swig_method swig_macho_methods[] = {
+ {0,0}
+};
+static swig_attribute swig_macho_attributes[] = {
+ { "-mt_archs",_wrap_macho_mt_archs_get, 0 },
+ {0,0,0}
+};
+static swig_class *swig_macho_bases[] = {0};
+static const char * swig_macho_base_names[] = {0};
+static swig_class _wrap_class_macho = { "macho", &SWIGTYPE_p_macho,0,0, swig_macho_methods, swig_macho_attributes, swig_macho_bases,swig_macho_base_names, &swig_module };
+SWIGINTERN int
+_wrap_create_handle(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
</ins><span class="cx"> struct macho_handle *result = 0 ;
</span><span class="cx">
</span><del>- if (!PyArg_ParseTuple(args,(char *)":create_handle")) SWIG_fail;
</del><ins>+ if (SWIG_GetArgs(interp, objc, objv,":machista::create_handle ") == TCL_ERROR) SWIG_fail;
</ins><span class="cx"> result = (struct macho_handle *)macho_create_handle();
</span><del>- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_macho_handle, 0 | 0 );
- return resultobj;
</del><ins>+ Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_macho_handle,0));
+ return TCL_OK;
</ins><span class="cx"> fail:
</span><del>- return NULL;
</del><ins>+ return TCL_ERROR;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERN PyObject *_wrap_destroy_handle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
</del><ins>+SWIGINTERN int
+_wrap_destroy_handle(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
</ins><span class="cx"> struct macho_handle *arg1 = (struct macho_handle *) 0 ;
</span><span class="cx"> void *argp1 = 0 ;
</span><span class="cx"> int res1 = 0 ;
</span><del>- PyObject * obj0 = 0 ;
</del><span class="cx">
</span><del>- if (!PyArg_ParseTuple(args,(char *)"O:destroy_handle",&obj0)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_macho_handle, 0 | 0 );
</del><ins>+ if (SWIG_GetArgs(interp, objc, objv,"o:machista::destroy_handle INPUT ",(void *)0) == TCL_ERROR) SWIG_fail;
+ res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_handle, 0 | 0 );
</ins><span class="cx"> if (!SWIG_IsOK(res1)) {
</span><span class="cx"> SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "destroy_handle" "', argument " "1"" of type '" "struct macho_handle *""'");
</span><span class="cx"> }
</span><span class="cx"> arg1 = (struct macho_handle *)(argp1);
</span><span class="cx"> macho_destroy_handle(arg1);
</span><del>- resultobj = SWIG_Py_Void();
- return resultobj;
</del><ins>+
+ return TCL_OK;
</ins><span class="cx"> fail:
</span><del>- return NULL;
</del><ins>+ return TCL_ERROR;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERN PyObject *_wrap_parse_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
</del><ins>+SWIGINTERN int
+_wrap_parse_file(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
</ins><span class="cx"> struct macho_handle *arg1 = (struct macho_handle *) 0 ;
</span><span class="cx"> char *arg2 = (char *) 0 ;
</span><span class="cx"> struct macho **arg3 = (struct macho **) 0 ;
</span><span class="lines">@@ -3747,149 +2220,145 @@
</span><span class="cx"> char *buf2 = 0 ;
</span><span class="cx"> int alloc2 = 0 ;
</span><span class="cx"> struct macho *res3 ;
</span><del>- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
</del><span class="cx"> int result;
</span><span class="cx">
</span><span class="cx"> {
</span><span class="cx"> arg3 = &res3;
</span><span class="cx"> }
</span><del>- if (!PyArg_ParseTuple(args,(char *)"OO:parse_file",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_macho_handle, 0 | 0 );
</del><ins>+ if (SWIG_GetArgs(interp, objc, objv,"oo:machista::parse_file handle filename ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
+ res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_handle, 0 | 0 );
</ins><span class="cx"> if (!SWIG_IsOK(res1)) {
</span><span class="cx"> SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_file" "', argument " "1"" of type '" "struct macho_handle *""'");
</span><span class="cx"> }
</span><span class="cx"> arg1 = (struct macho_handle *)(argp1);
</span><del>- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
</del><ins>+ res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2);
</ins><span class="cx"> if (!SWIG_IsOK(res2)) {
</span><span class="cx"> SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parse_file" "', argument " "2"" of type '" "char const *""'");
</span><span class="cx"> }
</span><span class="cx"> arg2 = (char *)(buf2);
</span><span class="cx"> result = (int)macho_parse_file(arg1,(char const *)arg2,(struct macho const **)arg3);
</span><del>- resultobj = SWIG_From_int((int)(result));
</del><ins>+ Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
</ins><span class="cx"> {
</span><del>- PyTuple_Pack(2, resultobj, SWIG_NewInstanceObj(SWIG_as_voidptr(*arg3), SWIGTYPE_p_macho, 0));
</del><ins>+ Tcl_ListObjAppendElement(interp, (Tcl_GetObjResult(interp)), SWIG_NewInstanceObj(SWIG_as_voidptr(*arg3), SWIGTYPE_p_macho, 0));
</ins><span class="cx"> }
</span><span class="cx"> if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
</span><del>- return resultobj;
</del><ins>+ return TCL_OK;
</ins><span class="cx"> fail:
</span><span class="cx"> if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
</span><del>- return NULL;
</del><ins>+ return TCL_ERROR;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERN PyObject *_wrap_strerror(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
</del><ins>+SWIGINTERN int
+_wrap_strerror(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
</ins><span class="cx"> int arg1 ;
</span><span class="cx"> int val1 ;
</span><span class="cx"> int ecode1 = 0 ;
</span><del>- PyObject * obj0 = 0 ;
</del><span class="cx"> char *result = 0 ;
</span><span class="cx">
</span><del>- if (!PyArg_ParseTuple(args,(char *)"O:strerror",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
</del><ins>+ if (SWIG_GetArgs(interp, objc, objv,"o:machista::strerror err ",(void *)0) == TCL_ERROR) SWIG_fail;
+ ecode1 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[1], &val1);
</ins><span class="cx"> if (!SWIG_IsOK(ecode1)) {
</span><span class="cx"> SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "strerror" "', argument " "1"" of type '" "int""'");
</span><span class="cx"> }
</span><span class="cx"> arg1 = (int)(val1);
</span><span class="cx"> result = (char *)macho_strerror(arg1);
</span><del>- resultobj = SWIG_FromCharPtr((const char *)result);
- return resultobj;
</del><ins>+ Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)result));
+ return TCL_OK;
</ins><span class="cx"> fail:
</span><del>- return NULL;
</del><ins>+ return TCL_ERROR;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERN PyObject *_wrap_get_arch_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
</del><ins>+SWIGINTERN int
+_wrap_get_arch_name(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
</ins><span class="cx"> cpu_type_t arg1 ;
</span><span class="cx"> int val1 ;
</span><span class="cx"> int ecode1 = 0 ;
</span><del>- PyObject * obj0 = 0 ;
</del><span class="cx"> char *result = 0 ;
</span><span class="cx">
</span><del>- if (!PyArg_ParseTuple(args,(char *)"O:get_arch_name",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
</del><ins>+ if (SWIG_GetArgs(interp, objc, objv,"o:machista::get_arch_name cpu_type_t ",(void *)0) == TCL_ERROR) SWIG_fail;
+ ecode1 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[1], &val1);
</ins><span class="cx"> if (!SWIG_IsOK(ecode1)) {
</span><span class="cx"> SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_arch_name" "', argument " "1"" of type '" "cpu_type_t""'");
</span><span class="cx"> }
</span><span class="cx"> arg1 = (cpu_type_t)(val1);
</span><span class="cx"> result = (char *)macho_get_arch_name(arg1);
</span><del>- resultobj = SWIG_FromCharPtr((const char *)result);
- return resultobj;
</del><ins>+ Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)result));
+ return TCL_OK;
</ins><span class="cx"> fail:
</span><del>- return NULL;
</del><ins>+ return TCL_ERROR;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-SWIGINTERN PyObject *_wrap_format_dylib_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
</del><ins>+SWIGINTERN int
+_wrap_format_dylib_version(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
</ins><span class="cx"> uint32_t arg1 ;
</span><span class="cx"> unsigned int val1 ;
</span><span class="cx"> int ecode1 = 0 ;
</span><del>- PyObject * obj0 = 0 ;
</del><span class="cx"> char *result = 0 ;
</span><span class="cx">
</span><del>- if (!PyArg_ParseTuple(args,(char *)"O:format_dylib_version",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
</del><ins>+ if (SWIG_GetArgs(interp, objc, objv,"o:machista::format_dylib_version uint32_t ",(void *)0) == TCL_ERROR) SWIG_fail;
+ ecode1 = SWIG_AsVal_unsigned_SS_int SWIG_TCL_CALL_ARGS_2(objv[1], &val1);
</ins><span class="cx"> if (!SWIG_IsOK(ecode1)) {
</span><span class="cx"> SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "format_dylib_version" "', argument " "1"" of type '" "uint32_t""'");
</span><span class="cx"> }
</span><span class="cx"> arg1 = (uint32_t)(val1);
</span><span class="cx"> result = (char *)macho_format_dylib_version(arg1);
</span><del>- resultobj = SWIG_FromCharPtr((const char *)result);
</del><ins>+ Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)result));
</ins><span class="cx"> {
</span><span class="cx"> free(result);
</span><span class="cx"> }
</span><del>- return resultobj;
</del><ins>+ return TCL_OK;
</ins><span class="cx"> fail:
</span><del>- return NULL;
</del><ins>+ return TCL_ERROR;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx">
</span><del>-static PyMethodDef SwigMethods[] = {
- { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
- { (char *)"SUCCESS_swigconstant", SUCCESS_swigconstant, METH_VARARGS, NULL},
- { (char *)"EFILE_swigconstant", EFILE_swigconstant, METH_VARARGS, NULL},
- { (char *)"EMMAP_swigconstant", EMMAP_swigconstant, METH_VARARGS, NULL},
- { (char *)"EMEM_swigconstant", EMEM_swigconstant, METH_VARARGS, NULL},
- { (char *)"ERANGE_swigconstant", ERANGE_swigconstant, METH_VARARGS, NULL},
- { (char *)"EMAGIC_swigconstant", EMAGIC_swigconstant, METH_VARARGS, NULL},
- { (char *)"macho_handle_swigregister", macho_handle_swigregister, METH_VARARGS, NULL},
- { (char *)"macho_loadcmd_mlt_install_name_get", _wrap_macho_loadcmd_mlt_install_name_get, METH_VARARGS, NULL},
- { (char *)"macho_loadcmd_mlt_type_get", _wrap_macho_loadcmd_mlt_type_get, METH_VARARGS, NULL},
- { (char *)"macho_loadcmd_mlt_comp_version_get", _wrap_macho_loadcmd_mlt_comp_version_get, METH_VARARGS, NULL},
- { (char *)"macho_loadcmd_mlt_version_get", _wrap_macho_loadcmd_mlt_version_get, METH_VARARGS, NULL},
- { (char *)"macho_loadcmd_next_get", _wrap_macho_loadcmd_next_get, METH_VARARGS, NULL},
- { (char *)"macho_loadcmd_swigregister", macho_loadcmd_swigregister, METH_VARARGS, NULL},
- { (char *)"macho_arch_mat_install_name_get", _wrap_macho_arch_mat_install_name_get, METH_VARARGS, NULL},
- { (char *)"macho_arch_mat_rpath_get", _wrap_macho_arch_mat_rpath_get, METH_VARARGS, NULL},
- { (char *)"macho_arch_mat_arch_get", _wrap_macho_arch_mat_arch_get, METH_VARARGS, NULL},
- { (char *)"macho_arch_mat_comp_version_get", _wrap_macho_arch_mat_comp_version_get, METH_VARARGS, NULL},
- { (char *)"macho_arch_mat_version_get", _wrap_macho_arch_mat_version_get, METH_VARARGS, NULL},
- { (char *)"macho_arch_mat_loadcmds_get", _wrap_macho_arch_mat_loadcmds_get, METH_VARARGS, NULL},
- { (char *)"macho_arch_next_get", _wrap_macho_arch_next_get, METH_VARARGS, NULL},
- { (char *)"macho_arch_swigregister", macho_arch_swigregister, METH_VARARGS, NULL},
- { (char *)"macho_mt_archs_get", _wrap_macho_mt_archs_get, METH_VARARGS, NULL},
- { (char *)"macho_swigregister", macho_swigregister, METH_VARARGS, NULL},
- { (char *)"create_handle", _wrap_create_handle, METH_VARARGS, NULL},
- { (char *)"destroy_handle", _wrap_destroy_handle, METH_VARARGS, NULL},
- { (char *)"parse_file", _wrap_parse_file, METH_VARARGS, NULL},
- { (char *)"strerror", _wrap_strerror, METH_VARARGS, NULL},
- { (char *)"get_arch_name", _wrap_get_arch_name, METH_VARARGS, NULL},
- { (char *)"format_dylib_version", _wrap_format_dylib_version, METH_VARARGS, NULL},
- { NULL, NULL, 0, NULL }
</del><ins>+
+static swig_command_info swig_commands[] = {
+ { SWIG_prefix "macho_handle", (swig_wrapper_func) SWIG_ObjectConstructor, (ClientData)&_wrap_class_macho_handle},
+ { SWIG_prefix "macho_loadcmd_mlt_install_name_get", (swig_wrapper_func) _wrap_macho_loadcmd_mlt_install_name_get, NULL},
+ { SWIG_prefix "macho_loadcmd_mlt_type_get", (swig_wrapper_func) _wrap_macho_loadcmd_mlt_type_get, NULL},
+ { SWIG_prefix "macho_loadcmd_mlt_comp_version_get", (swig_wrapper_func) _wrap_macho_loadcmd_mlt_comp_version_get, NULL},
+ { SWIG_prefix "macho_loadcmd_mlt_version_get", (swig_wrapper_func) _wrap_macho_loadcmd_mlt_version_get, NULL},
+ { SWIG_prefix "macho_loadcmd_next_get", (swig_wrapper_func) _wrap_macho_loadcmd_next_get, NULL},
+ { SWIG_prefix "macho_loadcmd", (swig_wrapper_func) SWIG_ObjectConstructor, (ClientData)&_wrap_class_macho_loadcmd},
+ { SWIG_prefix "macho_arch_mat_install_name_get", (swig_wrapper_func) _wrap_macho_arch_mat_install_name_get, NULL},
+ { SWIG_prefix "macho_arch_mat_rpath_get", (swig_wrapper_func) _wrap_macho_arch_mat_rpath_get, NULL},
+ { SWIG_prefix "macho_arch_mat_arch_get", (swig_wrapper_func) _wrap_macho_arch_mat_arch_get, NULL},
+ { SWIG_prefix "macho_arch_mat_comp_version_get", (swig_wrapper_func) _wrap_macho_arch_mat_comp_version_get, NULL},
+ { SWIG_prefix "macho_arch_mat_version_get", (swig_wrapper_func) _wrap_macho_arch_mat_version_get, NULL},
+ { SWIG_prefix "macho_arch_mat_loadcmds_get", (swig_wrapper_func) _wrap_macho_arch_mat_loadcmds_get, NULL},
+ { SWIG_prefix "macho_arch_next_get", (swig_wrapper_func) _wrap_macho_arch_next_get, NULL},
+ { SWIG_prefix "macho_arch", (swig_wrapper_func) SWIG_ObjectConstructor, (ClientData)&_wrap_class_macho_arch},
+ { SWIG_prefix "macho_mt_archs_get", (swig_wrapper_func) _wrap_macho_mt_archs_get, NULL},
+ { SWIG_prefix "macho", (swig_wrapper_func) SWIG_ObjectConstructor, (ClientData)&_wrap_class_macho},
+ { SWIG_prefix "create_handle", (swig_wrapper_func) _wrap_create_handle, NULL},
+ { SWIG_prefix "destroy_handle", (swig_wrapper_func) _wrap_destroy_handle, NULL},
+ { SWIG_prefix "parse_file", (swig_wrapper_func) _wrap_parse_file, NULL},
+ { SWIG_prefix "strerror", (swig_wrapper_func) _wrap_strerror, NULL},
+ { SWIG_prefix "get_arch_name", (swig_wrapper_func) _wrap_get_arch_name, NULL},
+ { SWIG_prefix "format_dylib_version", (swig_wrapper_func) _wrap_format_dylib_version, NULL},
+ {0, 0, 0}
</ins><span class="cx"> };
</span><span class="cx">
</span><ins>+static swig_var_info swig_variables[] = {
+ {0,0,0,0}
+};
</ins><span class="cx">
</span><ins>+static swig_const_info swig_constants[] = {
+ {0,0,0,0,0,0}
+};
+
</ins><span class="cx"> /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
</span><span class="cx">
</span><span class="cx"> static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
</span><span class="cx"> static swig_type_info _swigt__p_int = {"_p_int", "int *|cpu_type_t *", 0, 0, (void*)0, 0};
</span><del>-static swig_type_info _swigt__p_macho = {"_p_macho", "struct macho *|macho *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_macho_arch = {"_p_macho_arch", "struct macho_arch *|macho_arch *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_macho_handle = {"_p_macho_handle", "macho_handle *|struct macho_handle *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_macho_loadcmd = {"_p_macho_loadcmd", "struct macho_loadcmd *|macho_loadcmd *", 0, 0, (void*)0, 0};
</del><ins>+static swig_type_info _swigt__p_macho = {"_p_macho", "struct macho *|macho *", 0, 0, (void*)&_wrap_class_macho, 0};
+static swig_type_info _swigt__p_macho_arch = {"_p_macho_arch", "struct macho_arch *|macho_arch *", 0, 0, (void*)&_wrap_class_macho_arch, 0};
+static swig_type_info _swigt__p_macho_handle = {"_p_macho_handle", "macho_handle *|struct macho_handle *", 0, 0, (void*)&_wrap_class_macho_handle, 0};
+static swig_type_info _swigt__p_macho_loadcmd = {"_p_macho_loadcmd", "struct macho_loadcmd *|macho_loadcmd *", 0, 0, (void*)&_wrap_class_macho_loadcmd, 0};
</ins><span class="cx"> static swig_type_info _swigt__p_p_macho = {"_p_p_macho", "struct macho **", 0, 0, (void*)0, 0};
</span><span class="cx"> static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uint32_t *|unsigned int *", 0, 0, (void*)0, 0};
</span><span class="cx">
</span><span class="lines">@@ -3927,26 +2396,23 @@
</span><span class="cx">
</span><span class="cx"> /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
</span><span class="cx">
</span><del>-static swig_const_info swig_const_table[] = {
-{0, 0, 0, 0.0, 0, 0}};
-
</del><span class="cx"> #ifdef __cplusplus
</span><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx"> /* -----------------------------------------------------------------------------
</span><span class="cx"> * Type initialization:
</span><del>- * This problem is tough by the requirement that no dynamic
- * memory is used. Also, since swig_type_info structures store pointers to
</del><ins>+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
</ins><span class="cx"> * swig_cast_info structures and swig_cast_info structures store pointers back
</span><del>- * to swig_type_info structures, we need some lookup code at initialization.
- * The idea is that swig generates all the structures that are needed.
- * The runtime then collects these partially filled structures.
- * The SWIG_InitializeModule function takes these initial arrays out of
</del><ins>+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
</ins><span class="cx"> * swig_module, and does all the lookup, filling in the swig_module.types
</span><span class="cx"> * array with the correct data and linking the correct swig_cast_info
</span><span class="cx"> * structures together.
</span><span class="cx"> *
</span><del>- * The generated swig_type_info structures are assigned statically to an initial
</del><ins>+ * The generated swig_type_info structures are assigned staticly to an initial
</ins><span class="cx"> * array. We just loop through that array, and handle each type individually.
</span><span class="cx"> * First we lookup if this type has been already loaded, and if so, use the
</span><span class="cx"> * loaded structure instead of the generated one. Then we have to fill in the
</span><span class="lines">@@ -3956,17 +2422,17 @@
</span><span class="cx"> * a column is one of the swig_cast_info structures for that type.
</span><span class="cx"> * The cast_initial array is actually an array of arrays, because each row has
</span><span class="cx"> * a variable number of columns. So to actually build the cast linked list,
</span><del>- * we find the array of casts associated with the type, and loop through it
</del><ins>+ * we find the array of casts associated with the type, and loop through it
</ins><span class="cx"> * adding the casts to the list. The one last trick we need to do is making
</span><span class="cx"> * sure the type pointer in the swig_cast_info struct is correct.
</span><span class="cx"> *
</span><del>- * First off, we lookup the cast->type name to see if it is already loaded.
</del><ins>+ * First off, we lookup the cast->type name to see if it is already loaded.
</ins><span class="cx"> * There are three cases to handle:
</span><span class="cx"> * 1) If the cast->type has already been loaded AND the type we are adding
</span><span class="cx"> * casting info to has not been loaded (it is in this module), THEN we
</span><span class="cx"> * replace the cast->type pointer with the type pointer that has already
</span><span class="cx"> * been loaded.
</span><del>- * 2) If BOTH types (the one we are adding casting info to, and the
</del><ins>+ * 2) If BOTH types (the one we are adding casting info to, and the
</ins><span class="cx"> * cast->type) are loaded, THEN the cast info has already been loaded by
</span><span class="cx"> * the previous module so we just ignore it.
</span><span class="cx"> * 3) Finally, if cast->type has not already been loaded, then we add that
</span><span class="lines">@@ -3990,7 +2456,7 @@
</span><span class="cx"> SWIG_InitializeModule(void *clientdata) {
</span><span class="cx"> size_t i;
</span><span class="cx"> swig_module_info *module_head, *iter;
</span><del>- int init;
</del><ins>+ int found, init;
</ins><span class="cx">
</span><span class="cx"> /* check to see if the circular list has been setup, if not, set it up */
</span><span class="cx"> if (swig_module.next==0) {
</span><span class="lines">@@ -4009,23 +2475,27 @@
</span><span class="cx"> /* This is the first module loaded for this interpreter */
</span><span class="cx"> /* so set the swig module into the interpreter */
</span><span class="cx"> SWIG_SetModule(clientdata, &swig_module);
</span><ins>+ module_head = &swig_module;
</ins><span class="cx"> } else {
</span><span class="cx"> /* the interpreter has loaded a SWIG module, but has it loaded this one? */
</span><ins>+ found=0;
</ins><span class="cx"> iter=module_head;
</span><span class="cx"> do {
</span><span class="cx"> if (iter==&swig_module) {
</span><del>- /* Our module is already in the list, so there's nothing more to do. */
- return;
</del><ins>+ found=1;
+ break;
</ins><span class="cx"> }
</span><span class="cx"> iter=iter->next;
</span><span class="cx"> } while (iter!= module_head);
</span><span class="cx">
</span><del>- /* otherwise we must add our module into the list */
</del><ins>+ /* if the is found in the list, then all is done and we may leave */
+ if (found) return;
+ /* otherwise we must add out module into the list */
</ins><span class="cx"> swig_module.next = module_head->next;
</span><span class="cx"> module_head->next = &swig_module;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- /* When multiple interpreters are used, a module could have already been initialized in
</del><ins>+ /* When multiple interpeters are used, a module could have already been initialized in
</ins><span class="cx"> a different interpreter, but not yet have a pointer in this interpreter.
</span><span class="cx"> In this case, we do not want to continue adding types... everything should be
</span><span class="cx"> set up already */
</span><span class="lines">@@ -4165,247 +2635,31 @@
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx">
</span><del>-
</del><span class="cx"> #ifdef __cplusplus
</span><span class="cx"> extern "C" {
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- /* Python-specific SWIG API */
-#define SWIG_newvarlink() SWIG_Python_newvarlink()
-#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
-#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
-
</del><span class="cx"> /* -----------------------------------------------------------------------------
</span><del>- * global variable support code.
- * ----------------------------------------------------------------------------- */
-
- typedef struct swig_globalvar {
- char *name; /* Name of global variable */
- PyObject *(*get_attr)(void); /* Return the current value */
- int (*set_attr)(PyObject *); /* Set the value */
- struct swig_globalvar *next;
- } swig_globalvar;
-
- typedef struct swig_varlinkobject {
- PyObject_HEAD
- swig_globalvar *vars;
- } swig_varlinkobject;
-
- SWIGINTERN PyObject *
- swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
-#if PY_VERSION_HEX >= 0x03000000
- return PyUnicode_InternFromString("<Swig global variables>");
-#else
- return PyString_FromString("<Swig global variables>");
-#endif
- }
-
- SWIGINTERN PyObject *
- swig_varlink_str(swig_varlinkobject *v) {
-#if PY_VERSION_HEX >= 0x03000000
- PyObject *str = PyUnicode_InternFromString("(");
- PyObject *tail;
- PyObject *joined;
- swig_globalvar *var;
- for (var = v->vars; var; var=var->next) {
- tail = PyUnicode_FromString(var->name);
- joined = PyUnicode_Concat(str, tail);
- Py_DecRef(str);
- Py_DecRef(tail);
- str = joined;
- if (var->next) {
- tail = PyUnicode_InternFromString(", ");
- joined = PyUnicode_Concat(str, tail);
- Py_DecRef(str);
- Py_DecRef(tail);
- str = joined;
- }
- }
- tail = PyUnicode_InternFromString(")");
- joined = PyUnicode_Concat(str, tail);
- Py_DecRef(str);
- Py_DecRef(tail);
- str = joined;
-#else
- PyObject *str = PyString_FromString("(");
- swig_globalvar *var;
- for (var = v->vars; var; var=var->next) {
- PyString_ConcatAndDel(&str,PyString_FromString(var->name));
- if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
- }
- PyString_ConcatAndDel(&str,PyString_FromString(")"));
-#endif
- return str;
- }
-
- SWIGINTERN int
- swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
- char *tmp;
- PyObject *str = swig_varlink_str(v);
- fprintf(fp,"Swig global variables ");
- fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
- SWIG_Python_str_DelForPy3(tmp);
- Py_DECREF(str);
- return 0;
- }
-
- SWIGINTERN void
- swig_varlink_dealloc(swig_varlinkobject *v) {
- swig_globalvar *var = v->vars;
- while (var) {
- swig_globalvar *n = var->next;
- free(var->name);
- free(var);
- var = n;
- }
- }
-
- SWIGINTERN PyObject *
- swig_varlink_getattr(swig_varlinkobject *v, char *n) {
- PyObject *res = NULL;
- swig_globalvar *var = v->vars;
- while (var) {
- if (strcmp(var->name,n) == 0) {
- res = (*var->get_attr)();
- break;
- }
- var = var->next;
- }
- if (res == NULL && !PyErr_Occurred()) {
- PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
- }
- return res;
- }
-
- SWIGINTERN int
- swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
- int res = 1;
- swig_globalvar *var = v->vars;
- while (var) {
- if (strcmp(var->name,n) == 0) {
- res = (*var->set_attr)(p);
- break;
- }
- var = var->next;
- }
- if (res == 1 && !PyErr_Occurred()) {
- PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
- }
- return res;
- }
-
- SWIGINTERN PyTypeObject*
- swig_varlink_type(void) {
- static char varlink__doc__[] = "Swig var link object";
- static PyTypeObject varlink_type;
- static int type_init = 0;
- if (!type_init) {
- const PyTypeObject tmp = {
- /* PyObject header changed in Python 3 */
-#if PY_VERSION_HEX >= 0x03000000
- PyVarObject_HEAD_INIT(NULL, 0)
-#else
- PyObject_HEAD_INIT(NULL)
- 0, /* ob_size */
-#endif
- (char *)"swigvarlink", /* tp_name */
- sizeof(swig_varlinkobject), /* tp_basicsize */
- 0, /* tp_itemsize */
- (destructor) swig_varlink_dealloc, /* tp_dealloc */
- (printfunc) swig_varlink_print, /* tp_print */
- (getattrfunc) swig_varlink_getattr, /* tp_getattr */
- (setattrfunc) swig_varlink_setattr, /* tp_setattr */
- 0, /* tp_compare */
- (reprfunc) swig_varlink_repr, /* tp_repr */
- 0, /* tp_as_number */
- 0, /* tp_as_sequence */
- 0, /* tp_as_mapping */
- 0, /* tp_hash */
- 0, /* tp_call */
- (reprfunc) swig_varlink_str, /* tp_str */
- 0, /* tp_getattro */
- 0, /* tp_setattro */
- 0, /* tp_as_buffer */
- 0, /* tp_flags */
- varlink__doc__, /* tp_doc */
- 0, /* tp_traverse */
- 0, /* tp_clear */
- 0, /* tp_richcompare */
- 0, /* tp_weaklistoffset */
-#if PY_VERSION_HEX >= 0x02020000
- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
-#endif
-#if PY_VERSION_HEX >= 0x02030000
- 0, /* tp_del */
-#endif
-#if PY_VERSION_HEX >= 0x02060000
- 0, /* tp_version */
-#endif
-#ifdef COUNT_ALLOCS
- 0,0,0,0 /* tp_alloc -> tp_next */
-#endif
- };
- varlink_type = tmp;
- type_init = 1;
-#if PY_VERSION_HEX < 0x02020000
- varlink_type.ob_type = &PyType_Type;
-#else
- if (PyType_Ready(&varlink_type) < 0)
- return NULL;
-#endif
- }
- return &varlink_type;
- }
-
- /* Create a variable linking object for use later */
- SWIGINTERN PyObject *
- SWIG_Python_newvarlink(void) {
- swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
- if (result) {
- result->vars = 0;
- }
- return ((PyObject*) result);
- }
-
- SWIGINTERN void
- SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
- swig_varlinkobject *v = (swig_varlinkobject *) p;
- swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
- if (gv) {
- size_t size = strlen(name)+1;
- gv->name = (char *)malloc(size);
- if (gv->name) {
- strncpy(gv->name,name,size);
- gv->get_attr = get_attr;
- gv->set_attr = set_attr;
- gv->next = v->vars;
- }
- }
- v->vars = gv;
- }
-
- SWIGINTERN PyObject *
- SWIG_globals(void) {
- static PyObject *_SWIG_globals = 0;
- if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
- return _SWIG_globals;
- }
-
- /* -----------------------------------------------------------------------------
</del><span class="cx"> * constants/methods manipulation
</span><span class="cx"> * ----------------------------------------------------------------------------- */
</span><span class="cx">
</span><span class="cx"> /* Install Constants */
</span><ins>+
</ins><span class="cx"> SWIGINTERN void
</span><del>- SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
- PyObject *obj = 0;
- size_t i;
- for (i = 0; constants[i].type; ++i) {
</del><ins>+ SWIG_Tcl_InstallConstants(Tcl_Interp *interp, swig_const_info constants[]) {
+ int i;
+ Tcl_Obj *obj;
+
+ if (!swigconstTableinit) {
+ Tcl_InitHashTable(&swigconstTable, TCL_STRING_KEYS);
+ swigconstTableinit = 1;
+ }
+ for (i = 0; constants[i].type; i++) {
</ins><span class="cx"> switch(constants[i].type) {
</span><del>- case SWIG_PY_POINTER:
- obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
</del><ins>+ case SWIG_TCL_POINTER:
+ obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
</ins><span class="cx"> break;
</span><del>- case SWIG_PY_BINARY:
</del><ins>+ case SWIG_TCL_BINARY:
</ins><span class="cx"> obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
</span><span class="cx"> break;
</span><span class="cx"> default:
</span><span class="lines">@@ -4413,58 +2667,11 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> if (obj) {
</span><del>- PyDict_SetItemString(d, constants[i].name, obj);
- Py_DECREF(obj);
</del><ins>+ SWIG_Tcl_SetConstantObj(interp, constants[i].name, obj);
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- /* -----------------------------------------------------------------------------*/
- /* Fix SwigMethods to carry the callback ptrs when needed */
- /* -----------------------------------------------------------------------------*/
-
- SWIGINTERN void
- SWIG_Python_FixMethods(PyMethodDef *methods,
- swig_const_info *const_table,
- swig_type_info **types,
- swig_type_info **types_initial) {
- size_t i;
- for (i = 0; methods[i].ml_name; ++i) {
- const char *c = methods[i].ml_doc;
- if (c && (c = strstr(c, "swig_ptr: "))) {
- int j;
- swig_const_info *ci = 0;
- const char *name = c + 10;
- for (j = 0; const_table[j].type; ++j) {
- if (strncmp(const_table[j].name, name,
- strlen(const_table[j].name)) == 0) {
- ci = &(const_table[j]);
- break;
- }
- }
- if (ci) {
- void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
- if (ptr) {
- size_t shift = (ci->ptype) - types;
- swig_type_info *ty = types_initial[shift];
- size_t ldoc = (c - methods[i].ml_doc);
- size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
- char *ndoc = (char*)malloc(ldoc + lptr + 10);
- if (ndoc) {
- char *buff = ndoc;
- strncpy(buff, methods[i].ml_doc, ldoc);
- buff += ldoc;
- strncpy(buff, "swig_ptr: ", 10);
- buff += 10;
- SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
- methods[i].ml_doc = ndoc;
- }
- }
- }
- }
- }
- }
-
</del><span class="cx"> #ifdef __cplusplus
</span><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="lines">@@ -4473,142 +2680,55 @@
</span><span class="cx"> * Partial Init method
</span><span class="cx"> * -----------------------------------------------------------------------------*/
</span><span class="cx">
</span><del>-#ifdef __cplusplus
-extern "C"
-#endif
-
-SWIGEXPORT
-#if PY_VERSION_HEX >= 0x03000000
-PyObject*
-#else
-void
-#endif
-SWIG_init(void) {
- PyObject *m, *d, *md;
-#if PY_VERSION_HEX >= 0x03000000
- static struct PyModuleDef SWIG_module = {
-# if PY_VERSION_HEX >= 0x03020000
- PyModuleDef_HEAD_INIT,
-# else
- {
- PyObject_HEAD_INIT(NULL)
- NULL, /* m_init */
- 0, /* m_index */
- NULL, /* m_copy */
- },
-# endif
- (char *) SWIG_name,
- NULL,
- -1,
- SwigMethods,
- NULL,
- NULL,
- NULL,
- NULL
- };
-#endif
-
-#if defined(SWIGPYTHON_BUILTIN)
- static SwigPyClientData SwigPyObject_clientdata = {
- 0, 0, 0, 0, 0, 0, 0
- };
- static PyGetSetDef this_getset_def = {
- (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
- };
- static SwigPyGetSet thisown_getset_closure = {
- (PyCFunction) SwigPyObject_own,
- (PyCFunction) SwigPyObject_own
- };
- static PyGetSetDef thisown_getset_def = {
- (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
- };
- PyObject *metatype_args;
- PyTypeObject *builtin_pytype;
- int builtin_base_count;
- swig_type_info *builtin_basetype;
- PyObject *tuple;
- PyGetSetDescrObject *static_getset;
- PyTypeObject *metatype;
- SwigPyClientData *cd;
- PyObject *public_interface, *public_symbol;
- PyObject *this_descr;
- PyObject *thisown_descr;
- PyObject *self = 0;
</del><ins>+SWIGEXPORT int SWIG_init(Tcl_Interp *interp) {
</ins><span class="cx"> int i;
</span><del>-
- (void)builtin_pytype;
- (void)builtin_base_count;
- (void)builtin_basetype;
- (void)tuple;
- (void)static_getset;
- (void)self;
-
- /* metatype is used to implement static member variables. */
- metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
- assert(metatype_args);
- metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
- assert(metatype);
- Py_DECREF(metatype_args);
- metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
- assert(PyType_Ready(metatype) >= 0);
</del><ins>+ if (interp == 0) return TCL_ERROR;
+#ifdef USE_TCL_STUBS
+ /* (char*) cast is required to avoid compiler warning/error for Tcl < 8.4. */
+ if (Tcl_InitStubs(interp, (char*)SWIG_TCL_STUBS_VERSION, 0) == NULL) {
+ return TCL_ERROR;
+ }
+#endif
+#ifdef USE_TK_STUBS
+ /* (char*) cast is required to avoid compiler warning/error. */
+ if (Tk_InitStubs(interp, (char*)SWIG_TCL_STUBS_VERSION, 0) == NULL) {
+ return TCL_ERROR;
+ }
</ins><span class="cx"> #endif
</span><span class="cx">
</span><del>- /* Fix SwigMethods to carry the callback ptrs when needed */
- SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
</del><ins>+ Tcl_PkgProvide(interp, (char*)SWIG_name, (char*)SWIG_version);
</ins><span class="cx">
</span><del>-#if PY_VERSION_HEX >= 0x03000000
- m = PyModule_Create(&SWIG_module);
-#else
- m = Py_InitModule((char *) SWIG_name, SwigMethods);
</del><ins>+#ifdef SWIG_namespace
+ Tcl_Eval(interp, "namespace eval " SWIG_namespace " { }");
</ins><span class="cx"> #endif
</span><span class="cx">
</span><del>- md = d = PyModule_GetDict(m);
- (void)md;
</del><ins>+ SWIG_InitializeModule((void *) interp);
+ SWIG_PropagateClientData();
</ins><span class="cx">
</span><del>- SWIG_InitializeModule(0);
-
-#ifdef SWIGPYTHON_BUILTIN
- SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
- assert(SwigPyObject_stype);
- cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
- if (!cd) {
- SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
- SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
- } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
- PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
-# if PY_VERSION_HEX >= 0x03000000
- return NULL;
-# else
- return;
-# endif
</del><ins>+ for (i = 0; swig_commands[i].name; i++) {
+ Tcl_CreateObjCommand(interp, (char *) swig_commands[i].name, (swig_wrapper_func) swig_commands[i].wrapper,
+ swig_commands[i].clientdata, NULL);
</ins><span class="cx"> }
</span><ins>+ for (i = 0; swig_variables[i].name; i++) {
+ Tcl_SetVar(interp, (char *) swig_variables[i].name, (char *) "", TCL_GLOBAL_ONLY);
+ Tcl_TraceVar(interp, (char *) swig_variables[i].name, TCL_TRACE_READS | TCL_GLOBAL_ONLY,
+ (Tcl_VarTraceProc *) swig_variables[i].get, (ClientData) swig_variables[i].addr);
+ Tcl_TraceVar(interp, (char *) swig_variables[i].name, TCL_TRACE_WRITES | TCL_GLOBAL_ONLY,
+ (Tcl_VarTraceProc *) swig_variables[i].set, (ClientData) swig_variables[i].addr);
+ }
</ins><span class="cx">
</span><del>- /* All objects have a 'this' attribute */
- this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
- (void)this_descr;
</del><ins>+ SWIG_Tcl_InstallConstants(interp, swig_constants);
</ins><span class="cx">
</span><del>- /* All objects have a 'thisown' attribute */
- thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
- (void)thisown_descr;
</del><span class="cx">
</span><del>- public_interface = PyList_New(0);
- public_symbol = 0;
- (void)public_symbol;
-
- PyDict_SetItemString(md, "__all__", public_interface);
- Py_DECREF(public_interface);
- for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
- SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
- for (i = 0; swig_const_table[i].name != 0; ++i)
- SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
-#endif
-
- SWIG_InstallConstants(d,swig_const_table);
-
-#if PY_VERSION_HEX >= 0x03000000
- return m;
-#else
- return;
-#endif
</del><ins>+ SWIG_Tcl_SetConstantObj(interp, "machista::SUCCESS", SWIG_From_int((int)((0x00))));
+ SWIG_Tcl_SetConstantObj(interp, "machista::EFILE", SWIG_From_int((int)((0x01))));
+ SWIG_Tcl_SetConstantObj(interp, "machista::EMMAP", SWIG_From_int((int)((0x02))));
+ SWIG_Tcl_SetConstantObj(interp, "machista::EMEM", SWIG_From_int((int)((0x04))));
+ SWIG_Tcl_SetConstantObj(interp, "machista::ERANGE", SWIG_From_int((int)((0x08))));
+ SWIG_Tcl_SetConstantObj(interp, "machista::EMAGIC", SWIG_From_int((int)((0x10))));
+ return TCL_OK;
</ins><span class="cx"> }
</span><ins>+SWIGEXPORT int Machista_SafeInit(Tcl_Interp *interp) {
+ return SWIG_init(interp);
+}
</ins><span class="cx">
</span></span></pre>
</div>
</div>
</body>
</html>