Merge branch 'master' into doxygen
The way Python docstrings are indented has changed on master, so use the standard inspect module in Python autodoc unit test to ignore the differences in their indentation level between -builtin and non-builtin cases to make the test still pass with the branch version, which avoids the use of different (but almost identical) values in the test itself.
This commit is contained in:
Vadim Zeitlin
commit
e668c47b70
1094 changed files with 39390 additions and 11483 deletions
|
|
@ -24,6 +24,7 @@
|
|||
%include <lua/luakw.swg>
|
||||
%include <ocaml/ocamlkw.swg>
|
||||
%include <perl5/perlkw.swg>
|
||||
%include <php5/phpkw.swg>
|
||||
%include <php/phpkw.swg>
|
||||
%include <pike/pikekw.swg>
|
||||
%include <python/pythonkw.swg>
|
||||
|
|
|
|||
|
|
@ -81,7 +81,7 @@ typedef struct {
|
|||
|
||||
#ifdef __cplusplus
|
||||
NAME(int nelements) {
|
||||
return new TYPE[nelements];
|
||||
return new TYPE[nelements]();
|
||||
}
|
||||
~NAME() {
|
||||
delete [] self;
|
||||
|
|
|
|||
|
|
@ -29,13 +29,20 @@ typedef struct SWIGCDATA {
|
|||
}
|
||||
%typemap(in) (const void *indata, int inlen) = (char *STRING, int LENGTH);
|
||||
|
||||
#elif SWIGPHP
|
||||
#elif SWIGPHP5
|
||||
|
||||
%typemap(out) SWIGCDATA {
|
||||
ZVAL_STRINGL($result, $1.data, $1.len, 1);
|
||||
}
|
||||
%typemap(in) (const void *indata, int inlen) = (char *STRING, int LENGTH);
|
||||
|
||||
#elif SWIGPHP7
|
||||
|
||||
%typemap(out) SWIGCDATA {
|
||||
ZVAL_STRINGL($result, $1.data, $1.len);
|
||||
}
|
||||
%typemap(in) (const void *indata, int inlen) = (char *STRING, int LENGTH);
|
||||
|
||||
#elif SWIGJAVA
|
||||
|
||||
%apply (char *STRING, int LENGTH) { (const void *indata, int inlen) }
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -409,8 +409,8 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
|
|||
#endif
|
||||
|
||||
%typemap(directorin) SWIGTYPE
|
||||
%{ $input = (void *)&$1; %}
|
||||
%typemap(csdirectorin) SWIGTYPE "new $&csclassname($iminput, false)"
|
||||
%{ $input = (void *)new $1_ltype((const $1_ltype &)$1); %}
|
||||
%typemap(csdirectorin) SWIGTYPE "new $&csclassname($iminput, true)"
|
||||
%typemap(csdirectorout) SWIGTYPE "$&csclassname.getCPtr($cscall).Handle"
|
||||
|
||||
/* Generic pointers and references */
|
||||
|
|
@ -860,7 +860,8 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
|
|||
global::System.IntPtr ret = $imcall;$excode
|
||||
return ret;
|
||||
}
|
||||
|
||||
%typemap(csdirectorin) void *VOID_INT_PTR "$iminput"
|
||||
%typemap(csdirectorout) void *VOID_INT_PTR "$cscall"
|
||||
|
||||
/* Typemaps used for the generation of proxy and type wrapper class code */
|
||||
%typemap(csbase) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
|
||||
|
|
|
|||
|
|
@ -2,9 +2,9 @@
|
|||
#define CSHARP_CSHARPKW_SWG_
|
||||
|
||||
/* Warnings for C# keywords */
|
||||
#define CSHARPKW(x) %keywordwarn("'" `x` "' is a C# keyword, renaming to '_" `x` "'",rename="_%s") `x`
|
||||
#define CSHARPKW(x) %keywordwarn("'" `x` "' is a C# keyword, renaming to '" `x` "_'",rename="%s_") `x`
|
||||
|
||||
#define CSHARPCLASSKW(x) %keywordwarn("'" `x` "' is a special method name used in the C# wrapper classes, class renamed to '_" `x` "'",%$isclass,rename="_%s") `x`
|
||||
#define CSHARPCLASSKW(x) %keywordwarn("'" `x` "' is a special method name used in the C# wrapper classes, class renamed to '" `x` "_'",%$isclass,rename="%s_") `x`
|
||||
|
||||
/*
|
||||
from
|
||||
|
|
|
|||
227
Lib/csharp/std_array.i
Normal file
227
Lib/csharp/std_array.i
Normal file
|
|
@ -0,0 +1,227 @@
|
|||
/* -----------------------------------------------------------------------------
|
||||
* std_array.i
|
||||
*
|
||||
* SWIG typemaps for std::array<T, N>
|
||||
* C# implementation
|
||||
* The C# wrapper is made to look and feel like a C# System.Collections.Generic.IReadOnlyList<> collection.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%{
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <stdexcept>
|
||||
%}
|
||||
|
||||
%include <std_common.i>
|
||||
|
||||
|
||||
%define SWIG_STD_ARRAY_INTERNAL(T, N)
|
||||
%typemap(csinterfaces) std::array< T, N > "global::System.IDisposable, global::System.Collections.IEnumerable\n , global::System.Collections.Generic.IEnumerable<$typemap(cstype, T)>\n";
|
||||
%typemap(cscode) std::array< T, N > %{
|
||||
public $csclassname(global::System.Collections.ICollection c) : this() {
|
||||
if (c == null)
|
||||
throw new global::System.ArgumentNullException("c");
|
||||
int end = global::System.Math.Min(this.Count, c.Count);
|
||||
int i = 0;
|
||||
foreach ($typemap(cstype, T) elem in c) {
|
||||
if (i >= end)
|
||||
break;
|
||||
this[i++] = elem;
|
||||
}
|
||||
}
|
||||
|
||||
public int Count {
|
||||
get {
|
||||
return (int)size();
|
||||
}
|
||||
}
|
||||
|
||||
public $typemap(cstype, T) this[int index] {
|
||||
get {
|
||||
return getitem(index);
|
||||
}
|
||||
set {
|
||||
setitem(index, value);
|
||||
}
|
||||
}
|
||||
|
||||
public bool IsEmpty {
|
||||
get {
|
||||
return empty();
|
||||
}
|
||||
}
|
||||
|
||||
public void CopyTo($typemap(cstype, T)[] array)
|
||||
{
|
||||
CopyTo(0, array, 0, this.Count);
|
||||
}
|
||||
|
||||
public void CopyTo($typemap(cstype, T)[] array, int arrayIndex)
|
||||
{
|
||||
CopyTo(0, array, arrayIndex, this.Count);
|
||||
}
|
||||
|
||||
public void CopyTo(int index, $typemap(cstype, T)[] array, int arrayIndex, int count)
|
||||
{
|
||||
if (array == null)
|
||||
throw new global::System.ArgumentNullException("array");
|
||||
if (index < 0)
|
||||
throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero");
|
||||
if (arrayIndex < 0)
|
||||
throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
|
||||
if (count < 0)
|
||||
throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero");
|
||||
if (array.Rank > 1)
|
||||
throw new global::System.ArgumentException("Multi dimensional array.", "array");
|
||||
if (index+count > this.Count || arrayIndex+count > array.Length)
|
||||
throw new global::System.ArgumentException("Number of elements to copy is too large.");
|
||||
for (int i=0; i<count; i++)
|
||||
array.SetValue(getitemcopy(index+i), arrayIndex+i);
|
||||
}
|
||||
|
||||
global::System.Collections.Generic.IEnumerator<$typemap(cstype, T)> global::System.Collections.Generic.IEnumerable<$typemap(cstype, T)>.GetEnumerator() {
|
||||
return new $csclassnameEnumerator(this);
|
||||
}
|
||||
|
||||
global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() {
|
||||
return new $csclassnameEnumerator(this);
|
||||
}
|
||||
|
||||
public $csclassnameEnumerator GetEnumerator() {
|
||||
return new $csclassnameEnumerator(this);
|
||||
}
|
||||
|
||||
// Type-safe enumerator
|
||||
/// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
|
||||
/// whenever the collection is modified. This has been done for changes in the size of the
|
||||
/// collection but not when one of the elements of the collection is modified as it is a bit
|
||||
/// tricky to detect unmanaged code that modifies the collection under our feet.
|
||||
public sealed class $csclassnameEnumerator : global::System.Collections.IEnumerator
|
||||
, global::System.Collections.Generic.IEnumerator<$typemap(cstype, T)>
|
||||
{
|
||||
private $csclassname collectionRef;
|
||||
private int currentIndex;
|
||||
private object currentObject;
|
||||
private int currentSize;
|
||||
|
||||
public $csclassnameEnumerator($csclassname collection) {
|
||||
collectionRef = collection;
|
||||
currentIndex = -1;
|
||||
currentObject = null;
|
||||
currentSize = collectionRef.Count;
|
||||
}
|
||||
|
||||
// Type-safe iterator Current
|
||||
public $typemap(cstype, T) Current {
|
||||
get {
|
||||
if (currentIndex == -1)
|
||||
throw new global::System.InvalidOperationException("Enumeration not started.");
|
||||
if (currentIndex > currentSize - 1)
|
||||
throw new global::System.InvalidOperationException("Enumeration finished.");
|
||||
if (currentObject == null)
|
||||
throw new global::System.InvalidOperationException("Collection modified.");
|
||||
return ($typemap(cstype, T))currentObject;
|
||||
}
|
||||
}
|
||||
|
||||
// Type-unsafe IEnumerator.Current
|
||||
object global::System.Collections.IEnumerator.Current {
|
||||
get {
|
||||
return Current;
|
||||
}
|
||||
}
|
||||
|
||||
public bool MoveNext() {
|
||||
int size = collectionRef.Count;
|
||||
bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
|
||||
if (moveOkay) {
|
||||
currentIndex++;
|
||||
currentObject = collectionRef[currentIndex];
|
||||
} else {
|
||||
currentObject = null;
|
||||
}
|
||||
return moveOkay;
|
||||
}
|
||||
|
||||
public void Reset() {
|
||||
currentIndex = -1;
|
||||
currentObject = null;
|
||||
if (collectionRef.Count != currentSize) {
|
||||
throw new global::System.InvalidOperationException("Collection modified.");
|
||||
}
|
||||
}
|
||||
|
||||
public void Dispose() {
|
||||
currentIndex = -1;
|
||||
currentObject = null;
|
||||
}
|
||||
}
|
||||
%}
|
||||
|
||||
public:
|
||||
typedef size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef T value_type;
|
||||
typedef value_type* pointer;
|
||||
typedef const value_type* const_pointer;
|
||||
typedef value_type& reference;
|
||||
typedef const value_type& const_reference;
|
||||
|
||||
array();
|
||||
array(const array &other);
|
||||
|
||||
size_type size() const;
|
||||
bool empty() const;
|
||||
|
||||
%rename(Fill) fill;
|
||||
void fill(const value_type& val);
|
||||
|
||||
%rename(Swap) swap;
|
||||
void swap(array& other);
|
||||
|
||||
%extend {
|
||||
T getitemcopy(int index) throw (std::out_of_range) {
|
||||
if (index>=0 && index<(int)$self->size())
|
||||
return (*$self)[index];
|
||||
else
|
||||
throw std::out_of_range("index");
|
||||
}
|
||||
const_reference getitem(int index) throw (std::out_of_range) {
|
||||
if (index>=0 && index<(int)$self->size())
|
||||
return (*$self)[index];
|
||||
else
|
||||
throw std::out_of_range("index");
|
||||
}
|
||||
void setitem(int index, const_reference val) throw (std::out_of_range) {
|
||||
if (index>=0 && index<(int)$self->size())
|
||||
(*$self)[index] = val;
|
||||
else
|
||||
throw std::out_of_range("index");
|
||||
}
|
||||
void Reverse() {
|
||||
std::reverse($self->begin(), $self->end());
|
||||
}
|
||||
void Reverse(int index, int count) throw (std::out_of_range, std::invalid_argument) {
|
||||
if (index < 0)
|
||||
throw std::out_of_range("index");
|
||||
if (count < 0)
|
||||
throw std::out_of_range("count");
|
||||
if (index >= (int)$self->size()+1 || index+count > (int)$self->size())
|
||||
throw std::invalid_argument("invalid range");
|
||||
std::reverse($self->begin()+index, $self->begin()+index+count);
|
||||
}
|
||||
}
|
||||
%enddef
|
||||
|
||||
|
||||
%csmethodmodifiers std::array::empty "private"
|
||||
%csmethodmodifiers std::array::getitemcopy "private"
|
||||
%csmethodmodifiers std::array::getitem "private"
|
||||
%csmethodmodifiers std::array::setitem "private"
|
||||
%csmethodmodifiers std::array::size "private"
|
||||
|
||||
namespace std {
|
||||
template<class T, size_t N> class array {
|
||||
SWIG_STD_ARRAY_INTERNAL(T, N)
|
||||
};
|
||||
}
|
||||
|
|
@ -7,6 +7,7 @@
|
|||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%{
|
||||
#include <typeinfo>
|
||||
#include <stdexcept>
|
||||
%}
|
||||
|
||||
|
|
@ -16,6 +17,7 @@ namespace std
|
|||
struct exception {};
|
||||
}
|
||||
|
||||
%typemap(throws, canthrow=1) std::bad_cast "SWIG_CSharpSetPendingException(SWIG_CSharpInvalidCastException, $1.what());\n return $null;"
|
||||
%typemap(throws, canthrow=1) std::bad_exception "SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, $1.what());\n return $null;"
|
||||
%typemap(throws, canthrow=1) std::domain_error "SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, $1.what());\n return $null;"
|
||||
%typemap(throws, canthrow=1) std::exception "SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, $1.what());\n return $null;"
|
||||
|
|
|
|||
|
|
@ -398,4 +398,5 @@ SWIG_STD_VECTOR_ENHANCED(unsigned long long)
|
|||
SWIG_STD_VECTOR_ENHANCED(float)
|
||||
SWIG_STD_VECTOR_ENHANCED(double)
|
||||
SWIG_STD_VECTOR_ENHANCED(std::string) // also requires a %include <std_string.i>
|
||||
SWIG_STD_VECTOR_ENHANCED(std::wstring) // also requires a %include <std_wstring.i>
|
||||
|
||||
|
|
|
|||
63
Lib/csharp/swiginterface.i
Normal file
63
Lib/csharp/swiginterface.i
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
/* -----------------------------------------------------------------------------
|
||||
* swiginterface.i
|
||||
*
|
||||
* SWIG interface feature and typemaps implementation providing:
|
||||
* %interface
|
||||
* %interface_impl
|
||||
* %interface_custom
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%define INTERFACE_TYPEMAPS(CTYPE...)
|
||||
%typemap(cstype) CTYPE "$&csinterfacename"
|
||||
%typemap(cstype) CTYPE *, CTYPE [], CTYPE & "$csinterfacename"
|
||||
%typemap(cstype) CTYPE *const& "$*csinterfacename"
|
||||
%typemap(csin) CTYPE, CTYPE & "$csinput.GetInterfaceCPtr()"
|
||||
%typemap(csin) CTYPE *, CTYPE *const&, CTYPE [] "$csinput == null ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : $csinput.GetInterfaceCPtr()"
|
||||
%typemap(csout, excode=SWIGEXCODE) CTYPE {
|
||||
$&csclassname ret = new $&csclassname($imcall, true);$excode
|
||||
return ($&csinterfacename)ret;
|
||||
}
|
||||
%typemap(csout, excode=SWIGEXCODE) CTYPE & {
|
||||
$csclassname ret = new $csclassname($imcall, $owner);$excode
|
||||
return ($csinterfacename)ret;
|
||||
}
|
||||
%typemap(csout, excode=SWIGEXCODE) CTYPE *, CTYPE [] {
|
||||
global::System.IntPtr cPtr = $imcall;
|
||||
$csclassname ret = (cPtr == global::System.IntPtr.Zero) ? null : new $csclassname(cPtr, $owner);$excode
|
||||
return ($csinterfacename)ret;
|
||||
}
|
||||
%typemap(csout, excode=SWIGEXCODE) CTYPE *const& {
|
||||
global::System.IntPtr cPtr = $imcall;
|
||||
$*csclassname ret = (cPtr == global::System.IntPtr.Zero) ? null : new $*csclassname(cPtr, $owner);$excode
|
||||
return ($*csinterfacename)ret;
|
||||
}
|
||||
%typemap(csdirectorin) CTYPE "($&csinterfacename)new $&csclassname($iminput, true)"
|
||||
%typemap(csdirectorin) CTYPE & "($csinterfacename)new $csclassname($iminput, false)"
|
||||
%typemap(csdirectorin) CTYPE *, CTYPE [] "($iminput == global::System.IntPtr.Zero) ? null : ($csinterfacename)new $csclassname($iminput, false)"
|
||||
%typemap(csdirectorin) CTYPE *const& "($iminput == global::System.IntPtr.Zero) ? null : ($*csinterfacename)new $*csclassname($iminput, false)"
|
||||
%typemap(csdirectorout) CTYPE, CTYPE *, CTYPE *const&, CTYPE [], CTYPE & "$cscall.GetInterfaceCPtr()"
|
||||
%typemap(csinterfacecode, declaration=" [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]\n global::System.Runtime.InteropServices.HandleRef GetInterfaceCPtr();\n", cptrmethod="$interfacename_GetInterfaceCPtr") CTYPE %{
|
||||
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
|
||||
global::System.Runtime.InteropServices.HandleRef $interfacename.GetInterfaceCPtr() {
|
||||
return new global::System.Runtime.InteropServices.HandleRef(this, $imclassname.$csclazzname$interfacename_GetInterfaceCPtr(swigCPtr.Handle));
|
||||
}
|
||||
%}
|
||||
%enddef
|
||||
|
||||
%define %interface(CTYPE...)
|
||||
%feature("interface", name="%sSwigInterface") CTYPE;
|
||||
INTERFACE_TYPEMAPS(CTYPE)
|
||||
%enddef
|
||||
|
||||
%define %interface_impl(CTYPE...)
|
||||
%rename("%sSwigImpl") CTYPE;
|
||||
%feature("interface", name="%(rstrip:[SwigImpl])s") CTYPE;
|
||||
INTERFACE_TYPEMAPS(CTYPE)
|
||||
%enddef
|
||||
|
||||
%define %interface_custom(PROXY, INTERFACE, CTYPE...)
|
||||
%rename(PROXY) CTYPE;
|
||||
%feature("interface", name=INTERFACE) CTYPE;
|
||||
INTERFACE_TYPEMAPS(CTYPE)
|
||||
%enddef
|
||||
|
||||
|
|
@ -21,7 +21,7 @@
|
|||
%{
|
||||
static TYPE *new_##NAME(int nelements) { %}
|
||||
#ifdef __cplusplus
|
||||
%{ return new TYPE[nelements]; %}
|
||||
%{ return new TYPE[nelements](); %}
|
||||
#else
|
||||
%{ return (TYPE *) calloc(nelements,sizeof(TYPE)); %}
|
||||
#endif
|
||||
|
|
@ -78,7 +78,7 @@ typedef struct {} NAME;
|
|||
%extend NAME {
|
||||
#ifdef __cplusplus
|
||||
NAME(int nelements) {
|
||||
return new TYPE[nelements];
|
||||
return new TYPE[nelements]();
|
||||
}
|
||||
~NAME() {
|
||||
delete [] self;
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@
|
|||
#endif
|
||||
|
||||
%typemap(directorin) SWIGTYPE
|
||||
"$input = (void *)&$1;"
|
||||
"$input = (void *)new $1_ltype((const $1_ltype &)$1);"
|
||||
%typemap(directorout) SWIGTYPE
|
||||
%{ if (!$input) {
|
||||
SWIG_DSetPendingException(SWIG_DIllegalArgumentException, "Unexpected null return for type $1_type");
|
||||
|
|
@ -65,7 +65,7 @@
|
|||
}
|
||||
$result = *($&1_ltype)$input; %}
|
||||
|
||||
%typemap(ddirectorin) SWIGTYPE "new $&dclassname($winput, false)"
|
||||
%typemap(ddirectorin) SWIGTYPE "new $&dclassname($winput, true)"
|
||||
%typemap(ddirectorout) SWIGTYPE "$&dclassname.swigGetCPtr($dcall)"
|
||||
|
||||
%typemap(din) SWIGTYPE "$&dclassname.swigGetCPtr($dinput)"
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@
|
|||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%{
|
||||
#include <typeinfo>
|
||||
#include <stdexcept>
|
||||
%}
|
||||
|
||||
|
|
@ -16,6 +17,7 @@ namespace std
|
|||
struct exception {};
|
||||
}
|
||||
|
||||
%typemap(throws, canthrow=1) std::bad_cast "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
|
||||
%typemap(throws, canthrow=1) std::bad_exception "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
|
||||
%typemap(throws, canthrow=1) std::domain_error "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
|
||||
%typemap(throws, canthrow=1) std::exception "SWIG_DSetPendingException(SWIG_DException, $1.what());\n return $null;"
|
||||
|
|
|
|||
|
|
@ -12,10 +12,17 @@
|
|||
%insert("runtime") "swigerrors.swg"
|
||||
|
||||
|
||||
#ifdef SWIGPHP
|
||||
#ifdef SWIGPHP5
|
||||
%{
|
||||
#include "zend_exceptions.h"
|
||||
#define SWIG_exception(code, msg) zend_throw_exception(NULL, (char*)msg, code TSRMLS_CC)
|
||||
#define SWIG_exception(code, msg) do { zend_throw_exception(NULL, (char*)msg, code TSRMLS_CC); goto thrown; } while (0)
|
||||
%}
|
||||
#endif
|
||||
|
||||
#ifdef SWIGPHP7
|
||||
%{
|
||||
#include "zend_exceptions.h"
|
||||
#define SWIG_exception(code, msg) do { zend_throw_exception(NULL, (char*)msg, code); goto thrown; } while (0)
|
||||
%}
|
||||
#endif
|
||||
|
||||
|
|
@ -258,6 +265,7 @@ SWIGINTERN void SWIG_DThrowException(int code, const char *msg) {
|
|||
}
|
||||
*/
|
||||
%{
|
||||
#include <typeinfo>
|
||||
#include <stdexcept>
|
||||
%}
|
||||
%define SWIG_CATCH_STDEXCEPT
|
||||
|
|
@ -274,6 +282,8 @@ SWIGINTERN void SWIG_DThrowException(int code, const char *msg) {
|
|||
SWIG_exception(SWIG_IndexError, e.what() );
|
||||
} catch (std::runtime_error& e) {
|
||||
SWIG_exception(SWIG_RuntimeError, e.what() );
|
||||
} catch (std::bad_cast& e) {
|
||||
SWIG_exception(SWIG_TypeError, e.what() );
|
||||
} catch (std::exception& e) {
|
||||
SWIG_exception(SWIG_SystemError, e.what() );
|
||||
}
|
||||
|
|
|
|||
|
|
@ -426,10 +426,7 @@
|
|||
/* Strings. */
|
||||
|
||||
%typemap(gotype)
|
||||
char *, char *&, char[ANY], char[],
|
||||
signed char *, signed char *&, signed char[ANY], signed char[],
|
||||
unsigned char *, unsigned char *&, unsigned char[ANY], unsigned char[]
|
||||
"string"
|
||||
char *, char *&, char[ANY], char[] "string"
|
||||
|
||||
/* Needed to avoid confusion with the way the go module handles
|
||||
references. */
|
||||
|
|
@ -437,46 +434,59 @@
|
|||
%typemap(gotype) signed char& "*int8"
|
||||
|
||||
%typemap(in)
|
||||
char *, char[ANY], char[],
|
||||
signed char *, signed char[ANY], signed char[],
|
||||
unsigned char *, unsigned char[ANY], unsigned char[]
|
||||
%{ $1 = ($1_ltype)$input.p; %}
|
||||
char *, char[ANY], char[]
|
||||
%{
|
||||
$1 = ($1_ltype)malloc($input.n + 1);
|
||||
memcpy($1, $input.p, $input.n);
|
||||
$1[$input.n] = '\0';
|
||||
%}
|
||||
|
||||
%typemap(in) char *&, signed char *&, unsigned char *&
|
||||
%{ $1 = ($1_ltype)$input.p; %}
|
||||
%typemap(in) char *& (char *temp)
|
||||
%{
|
||||
temp = (char *)malloc($input.n + 1);
|
||||
memcpy(temp, $input.p, $input.n);
|
||||
temp[$input.n] = '\0';
|
||||
$1 = ($1_ltype)&temp;
|
||||
%}
|
||||
|
||||
%typemap(freearg)
|
||||
char *, char *&, char[ANY], char[]
|
||||
%{ free($1); %}
|
||||
|
||||
%typemap(out,fragment="AllocateString")
|
||||
char *, char *&, char[ANY], char[],
|
||||
signed char *, signed char *&, signed char[ANY], signed char[],
|
||||
unsigned char *, unsigned char *&, unsigned char[ANY], unsigned char[]
|
||||
char *, char *&, char[ANY], char[]
|
||||
%{ $result = Swig_AllocateString((char*)$1, $1 ? strlen((char*)$1) : 0); %}
|
||||
|
||||
%typemap(goout,fragment="CopyString")
|
||||
char *, char *&, char[ANY], char[],
|
||||
signed char *, signed char *&, signed char[ANY], signed char[],
|
||||
unsigned char *, unsigned char *&, unsigned char[ANY], unsigned char[]
|
||||
char *, char *&, char[ANY], char[]
|
||||
%{ $result = swigCopyString($1) %}
|
||||
|
||||
%typemap(directorin,fragment="AllocateString")
|
||||
char *, char *&, char[ANY], char[],
|
||||
signed char *, signed char *&, signed char[ANY], signed char[],
|
||||
unsigned char *, unsigned char *&, unsigned char[ANY], unsigned char[]
|
||||
char *, char *&, char[ANY], char[]
|
||||
%{
|
||||
$input = Swig_AllocateString((char*)$1, $1 ? strlen((char*)$1) : 0);
|
||||
%}
|
||||
|
||||
%typemap(godirectorin,fragment="CopyString")
|
||||
char *, char *&, char[ANY], char[],
|
||||
signed char *, signed char *&, signed char[ANY], signed char[],
|
||||
unsigned char *, unsigned char *&, unsigned char[ANY], unsigned char[]
|
||||
char *, char *&, char[ANY], char[]
|
||||
%{
|
||||
$result = swigCopyString($input)
|
||||
%}
|
||||
|
||||
%typemap(directorout)
|
||||
char *, char *&, char[ANY], char[],
|
||||
signed char *, signed char *&, signed char[ANY], signed char[],
|
||||
unsigned char *, unsigned char *&, unsigned char[ANY], unsigned char[]
|
||||
%typemap(godirectorout)
|
||||
char *, char *&, char[ANY], char[]
|
||||
%{
|
||||
{
|
||||
p := Swig_malloc(len($input) + 1)
|
||||
s := (*[1<<30]byte)(unsafe.Pointer(p))[:len($input) + 1]
|
||||
copy(s, $input)
|
||||
s[len($input)] = 0
|
||||
$result = *(*string)(unsafe.Pointer(&s))
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(directorout, warning=SWIGWARN_TYPEMAP_DIRECTOROUT_PTR_MSG)
|
||||
char *, char *&, char[ANY], char[]
|
||||
%{ $result = ($1_ltype)$input.p; %}
|
||||
|
||||
/* String & length */
|
||||
|
|
@ -574,7 +584,7 @@
|
|||
%typemap(goout) SWIGTYPE ""
|
||||
|
||||
%typemap(directorin) SWIGTYPE
|
||||
%{ $input = ($&1_ltype)&$1; %}
|
||||
%{ $input = new $1_ltype((const $1_ltype &)$1); %}
|
||||
|
||||
%typemap(godirectorin) SWIGTYPE ""
|
||||
|
||||
|
|
|
|||
|
|
@ -8,6 +8,10 @@
|
|||
static void Swig_free(void* p) {
|
||||
free(p);
|
||||
}
|
||||
|
||||
static void* Swig_malloc(int c) {
|
||||
return malloc(c);
|
||||
}
|
||||
%}
|
||||
|
||||
%insert(runtime) %{
|
||||
|
|
@ -60,6 +64,24 @@ typedef size_t uintgo;
|
|||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef SWIGGO_GCCGO
|
||||
// Set the host compiler struct attribute that will be
|
||||
// used to match gc's struct layout. For example, on 386 Windows,
|
||||
// gcc wants to 8-align int64s, but gc does not.
|
||||
// Use __gcc_struct__ to work around http://gcc.gnu.org/PR52991 on x86,
|
||||
// and https://golang.org/issue/5603.
|
||||
// See: https://github.com/golang/go/blob/fcbf04f9b93b4cd8addd05c2ed784118eb50a46c/src/cmd/cgo/out.go#L663
|
||||
%insert(runtime) %{
|
||||
# if !defined(__clang__) && (defined(__i386__) || defined(__x86_64__))
|
||||
# define SWIGSTRUCTPACKED __attribute__((__packed__, __gcc_struct__))
|
||||
# else
|
||||
# define SWIGSTRUCTPACKED __attribute__((__packed__))
|
||||
# endif
|
||||
%}
|
||||
#else
|
||||
# define SWIGSTRUCTPACKED
|
||||
#endif
|
||||
|
||||
%insert(runtime) %{
|
||||
|
||||
typedef struct { char *p; intgo n; } _gostring_;
|
||||
|
|
@ -116,7 +138,7 @@ static char *_swig_topofstack() {
|
|||
static void _swig_gopanic(const char *p) {
|
||||
struct {
|
||||
const char *p;
|
||||
} a;
|
||||
} SWIGSTRUCTPACKED a;
|
||||
a.p = p;
|
||||
crosscall2(_cgo_panic, &a, (int) sizeof a);
|
||||
}
|
||||
|
|
@ -133,7 +155,7 @@ static void *_swig_goallocate(size_t len) {
|
|||
struct {
|
||||
size_t len;
|
||||
void *ret;
|
||||
} a;
|
||||
} SWIGSTRUCTPACKED a;
|
||||
a.len = len;
|
||||
crosscall2(_cgo_allocate, &a, (int) sizeof a);
|
||||
return a.ret;
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@
|
|||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%{
|
||||
#include <typeinfo>
|
||||
#include <stdexcept>
|
||||
%}
|
||||
|
||||
|
|
@ -16,6 +17,7 @@ namespace std
|
|||
struct exception {};
|
||||
}
|
||||
|
||||
%typemap(throws) std::bad_cast %{_swig_gopanic($1.what());%}
|
||||
%typemap(throws) std::bad_exception %{_swig_gopanic($1.what());%}
|
||||
%typemap(throws) std::domain_error %{_swig_gopanic($1.what());%}
|
||||
%typemap(throws) std::exception %{_swig_gopanic($1.what());%}
|
||||
|
|
|
|||
|
|
@ -24,8 +24,21 @@ class string;
|
|||
%typemap(in) string
|
||||
%{ $1.assign($input.p, $input.n); %}
|
||||
|
||||
%typemap(godirectorout) string
|
||||
%{
|
||||
{
|
||||
p := Swig_malloc(len($input))
|
||||
s := (*[1<<30]byte)(unsafe.Pointer(p))[:len($input)]
|
||||
copy(s, $input)
|
||||
$result = *(*string)(unsafe.Pointer(&s))
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(directorout) string
|
||||
%{ $result.assign($input.p, $input.n); %}
|
||||
%{
|
||||
$result.assign($input.p, $input.n);
|
||||
free($input.p);
|
||||
%}
|
||||
|
||||
%typemap(out,fragment="AllocateString") string
|
||||
%{ $result = Swig_AllocateString($1.data(), $1.length()); %}
|
||||
|
|
@ -45,10 +58,21 @@ class string;
|
|||
$1 = &$1_str;
|
||||
%}
|
||||
|
||||
%typemap(godirectorout) const string &
|
||||
%{
|
||||
{
|
||||
p := Swig_malloc(len($input))
|
||||
s := (*[1<<30]byte)(unsafe.Pointer(p))[:len($input)]
|
||||
copy(s, $input)
|
||||
$result = *(*string)(unsafe.Pointer(&s))
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const string &
|
||||
%{
|
||||
static $*1_ltype $1_str;
|
||||
$1_str.assign($input.p, $input.n);
|
||||
free($input.p);
|
||||
$result = &$1_str;
|
||||
%}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
// TODO: STL exception handling
|
||||
// Note that the generic std_except.i file did not work
|
||||
%{
|
||||
#include <typeinfo>
|
||||
#include <stdexcept>
|
||||
%}
|
||||
|
||||
|
|
|
|||
|
|
@ -41,11 +41,11 @@
|
|||
namespace std {
|
||||
|
||||
template<class K, class T> class map {
|
||||
%typemap(in) map<K,T> (std::map<K,T>* m) {
|
||||
%typemap(in) map<K,T> {
|
||||
if (scm_is_null($input)) {
|
||||
$1 = std::map<K,T >();
|
||||
$1 = std::map< K, T >();
|
||||
} else if (scm_is_pair($input)) {
|
||||
$1 = std::map<K,T >();
|
||||
$1 = std::map< K, T >();
|
||||
SCM alist = $input;
|
||||
while (!scm_is_null(alist)) {
|
||||
K* k;
|
||||
|
|
@ -72,15 +72,13 @@ namespace std {
|
|||
SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
|
||||
}
|
||||
}
|
||||
%typemap(in) const map<K,T>& (std::map<K,T> temp,
|
||||
std::map<K,T>* m),
|
||||
const map<K,T>* (std::map<K,T> temp,
|
||||
std::map<K,T>* m) {
|
||||
%typemap(in) const map<K,T>& (std::map<K,T> temp),
|
||||
const map<K,T>* (std::map<K,T> temp) {
|
||||
if (scm_is_null($input)) {
|
||||
temp = std::map<K,T >();
|
||||
temp = std::map< K, T >();
|
||||
$1 = &temp;
|
||||
} else if (scm_is_pair($input)) {
|
||||
temp = std::map<K,T >();
|
||||
temp = std::map< K, T >();
|
||||
$1 = &temp;
|
||||
SCM alist = $input;
|
||||
while (!scm_is_null(alist)) {
|
||||
|
|
@ -109,8 +107,7 @@ namespace std {
|
|||
}
|
||||
%typemap(out) map<K,T> {
|
||||
SCM alist = SCM_EOL;
|
||||
for (std::map<K,T >::reverse_iterator i=$i.rbegin();
|
||||
i!=$i.rend(); ++i) {
|
||||
for (std::map< K, T >::reverse_iterator i=$i.rbegin(); i!=$i.rend(); ++i) {
|
||||
K* key = new K(i->first);
|
||||
T* val = new T(i->second);
|
||||
SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
|
||||
|
|
@ -156,7 +153,7 @@ namespace std {
|
|||
}
|
||||
} else {
|
||||
/* wrapped map? */
|
||||
std::map<K,T >* m;
|
||||
std::map< K, T >* m;
|
||||
if (SWIG_ConvertPtr($input,(void **) &m,
|
||||
$&1_descriptor, 0) == 0)
|
||||
$1 = 1;
|
||||
|
|
@ -201,7 +198,7 @@ namespace std {
|
|||
}
|
||||
} else {
|
||||
/* wrapped map? */
|
||||
std::map<K,T >* m;
|
||||
std::map< K, T >* m;
|
||||
if (SWIG_ConvertPtr($input,(void **) &m,
|
||||
$1_descriptor, 0) == 0)
|
||||
$1 = 1;
|
||||
|
|
@ -222,14 +219,14 @@ namespace std {
|
|||
typedef K key_type;
|
||||
typedef T mapped_type;
|
||||
map();
|
||||
map(const map<K,T> &);
|
||||
map(const map< K, T> &);
|
||||
|
||||
unsigned int size() const;
|
||||
bool empty() const;
|
||||
void clear();
|
||||
%extend {
|
||||
const T& __getitem__(const K& key) throw (std::out_of_range) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
std::map< K, T >::iterator i = self->find(key);
|
||||
if (i != self->end())
|
||||
return i->second;
|
||||
else
|
||||
|
|
@ -239,20 +236,19 @@ namespace std {
|
|||
(*self)[key] = x;
|
||||
}
|
||||
void __delitem__(const K& key) throw (std::out_of_range) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
std::map< K, T >::iterator i = self->find(key);
|
||||
if (i != self->end())
|
||||
self->erase(i);
|
||||
else
|
||||
throw std::out_of_range("key not found");
|
||||
}
|
||||
bool has_key(const K& key) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
std::map< K, T >::iterator i = self->find(key);
|
||||
return i != self->end();
|
||||
}
|
||||
SCM keys() {
|
||||
SCM result = SCM_EOL;
|
||||
for (std::map<K,T >::reverse_iterator i=self->rbegin();
|
||||
i!=self->rend(); ++i) {
|
||||
for (std::map< K, T >::reverse_iterator i=self->rbegin(); i!=self->rend(); ++i) {
|
||||
K* key = new K(i->first);
|
||||
SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
|
||||
result = scm_cons(k,result);
|
||||
|
|
@ -268,11 +264,11 @@ namespace std {
|
|||
%define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO)
|
||||
|
||||
template<class T> class map<K,T> {
|
||||
%typemap(in) map<K,T> (std::map<K,T>* m) {
|
||||
%typemap(in) map<K,T> {
|
||||
if (scm_is_null($input)) {
|
||||
$1 = std::map<K,T >();
|
||||
$1 = std::map< K, T >();
|
||||
} else if (scm_is_pair($input)) {
|
||||
$1 = std::map<K,T >();
|
||||
$1 = std::map< K, T >();
|
||||
SCM alist = $input;
|
||||
while (!scm_is_null(alist)) {
|
||||
T* x;
|
||||
|
|
@ -300,15 +296,13 @@ namespace std {
|
|||
SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
|
||||
}
|
||||
}
|
||||
%typemap(in) const map<K,T>& (std::map<K,T> temp,
|
||||
std::map<K,T>* m),
|
||||
const map<K,T>* (std::map<K,T> temp,
|
||||
std::map<K,T>* m) {
|
||||
%typemap(in) const map<K,T>& (std::map<K,T> temp),
|
||||
const map<K,T>* (std::map<K,T> temp) {
|
||||
if (scm_is_null($input)) {
|
||||
temp = std::map<K,T >();
|
||||
temp = std::map< K, T >();
|
||||
$1 = &temp;
|
||||
} else if (scm_is_pair($input)) {
|
||||
temp = std::map<K,T >();
|
||||
temp = std::map< K, T >();
|
||||
$1 = &temp;
|
||||
SCM alist = $input;
|
||||
while (!scm_is_null(alist)) {
|
||||
|
|
@ -338,8 +332,7 @@ namespace std {
|
|||
}
|
||||
%typemap(out) map<K,T> {
|
||||
SCM alist = SCM_EOL;
|
||||
for (std::map<K,T >::reverse_iterator i=$1.rbegin();
|
||||
i!=$1.rend(); ++i) {
|
||||
for (std::map< K, T >::reverse_iterator i=$1.rbegin(); i!=$1.rend(); ++i) {
|
||||
T* val = new T(i->second);
|
||||
SCM k = CONVERT_TO(i->first);
|
||||
SCM x = SWIG_NewPointerObj(val,$descriptor(T *), 1);
|
||||
|
|
@ -382,7 +375,7 @@ namespace std {
|
|||
}
|
||||
} else {
|
||||
// wrapped map?
|
||||
std::map<K,T >* m;
|
||||
std::map< K, T >* m;
|
||||
if (SWIG_ConvertPtr($input,(void **) &m,
|
||||
$&1_descriptor, 0) == 0)
|
||||
$1 = 1;
|
||||
|
|
@ -425,7 +418,7 @@ namespace std {
|
|||
}
|
||||
} else {
|
||||
// wrapped map?
|
||||
std::map<K,T >* m;
|
||||
std::map< K, T >* m;
|
||||
if (SWIG_ConvertPtr($input,(void **) &m,
|
||||
$1_descriptor, 0) == 0)
|
||||
$1 = 1;
|
||||
|
|
@ -442,14 +435,14 @@ namespace std {
|
|||
%rename("has-key?") has_key;
|
||||
public:
|
||||
map();
|
||||
map(const map<K,T> &);
|
||||
map(const map< K, T > &);
|
||||
|
||||
unsigned int size() const;
|
||||
bool empty() const;
|
||||
void clear();
|
||||
%extend {
|
||||
T& __getitem__(K key) throw (std::out_of_range) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
std::map< K, T >::iterator i = self->find(key);
|
||||
if (i != self->end())
|
||||
return i->second;
|
||||
else
|
||||
|
|
@ -459,20 +452,19 @@ namespace std {
|
|||
(*self)[key] = x;
|
||||
}
|
||||
void __delitem__(K key) throw (std::out_of_range) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
std::map< K, T >::iterator i = self->find(key);
|
||||
if (i != self->end())
|
||||
self->erase(i);
|
||||
else
|
||||
throw std::out_of_range("key not found");
|
||||
}
|
||||
bool has_key(K key) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
std::map< K, T >::iterator i = self->find(key);
|
||||
return i != self->end();
|
||||
}
|
||||
SCM keys() {
|
||||
SCM result = SCM_EOL;
|
||||
for (std::map<K,T >::reverse_iterator i=self->rbegin();
|
||||
i!=self->rend(); ++i) {
|
||||
for (std::map< K, T >::reverse_iterator i=self->rbegin(); i!=self->rend(); ++i) {
|
||||
SCM k = CONVERT_TO(i->first);
|
||||
result = scm_cons(k,result);
|
||||
}
|
||||
|
|
@ -484,11 +476,11 @@ namespace std {
|
|||
|
||||
%define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO)
|
||||
template<class K> class map<K,T> {
|
||||
%typemap(in) map<K,T> (std::map<K,T>* m) {
|
||||
%typemap(in) map<K,T> {
|
||||
if (scm_is_null($input)) {
|
||||
$1 = std::map<K,T >();
|
||||
$1 = std::map< K, T >();
|
||||
} else if (scm_is_pair($input)) {
|
||||
$1 = std::map<K,T >();
|
||||
$1 = std::map< K, T >();
|
||||
SCM alist = $input;
|
||||
while (!scm_is_null(alist)) {
|
||||
K* k;
|
||||
|
|
@ -515,15 +507,13 @@ namespace std {
|
|||
SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
|
||||
}
|
||||
}
|
||||
%typemap(in) const map<K,T>& (std::map<K,T> temp,
|
||||
std::map<K,T>* m),
|
||||
const map<K,T>* (std::map<K,T> temp,
|
||||
std::map<K,T>* m) {
|
||||
%typemap(in) const map<K,T>& (std::map<K,T> temp),
|
||||
const map<K,T>* (std::map<K,T> temp) {
|
||||
if (scm_is_null($input)) {
|
||||
temp = std::map<K,T >();
|
||||
temp = std::map< K, T >();
|
||||
$1 = &temp;
|
||||
} else if (scm_is_pair($input)) {
|
||||
temp = std::map<K,T >();
|
||||
temp = std::map< K, T >();
|
||||
$1 = &temp;
|
||||
SCM alist = $input;
|
||||
while (!scm_is_null(alist)) {
|
||||
|
|
@ -552,8 +542,7 @@ namespace std {
|
|||
}
|
||||
%typemap(out) map<K,T> {
|
||||
SCM alist = SCM_EOL;
|
||||
for (std::map<K,T >::reverse_iterator i=$1.rbegin();
|
||||
i!=$1.rend(); ++i) {
|
||||
for (std::map< K, T >::reverse_iterator i=$1.rbegin(); i!=$1.rend(); ++i) {
|
||||
K* key = new K(i->first);
|
||||
SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
|
||||
SCM x = CONVERT_TO(i->second);
|
||||
|
|
@ -572,7 +561,6 @@ namespace std {
|
|||
K* k;
|
||||
SCM head = SCM_CAR($input);
|
||||
if (scm_is_pair(head)) {
|
||||
SCM key = SCM_CAR(head);
|
||||
SCM val = SCM_CDR(head);
|
||||
if (SWIG_ConvertPtr(val,(void **) &k,
|
||||
$descriptor(K *), 0) != 0) {
|
||||
|
|
@ -595,7 +583,7 @@ namespace std {
|
|||
}
|
||||
} else {
|
||||
// wrapped map?
|
||||
std::map<K,T >* m;
|
||||
std::map< K, T >* m;
|
||||
if (SWIG_ConvertPtr($input,(void **) &m,
|
||||
$&1_descriptor, 0) == 0)
|
||||
$1 = 1;
|
||||
|
|
@ -614,7 +602,6 @@ namespace std {
|
|||
K* k;
|
||||
SCM head = SCM_CAR($input);
|
||||
if (scm_is_pair(head)) {
|
||||
SCM key = SCM_CAR(head);
|
||||
SCM val = SCM_CDR(head);
|
||||
if (SWIG_ConvertPtr(val,(void **) &k,
|
||||
$descriptor(K *), 0) != 0) {
|
||||
|
|
@ -637,7 +624,7 @@ namespace std {
|
|||
}
|
||||
} else {
|
||||
// wrapped map?
|
||||
std::map<K,T >* m;
|
||||
std::map< K, T >* m;
|
||||
if (SWIG_ConvertPtr($input,(void **) &m,
|
||||
$1_descriptor, 0) == 0)
|
||||
$1 = 1;
|
||||
|
|
@ -654,14 +641,14 @@ namespace std {
|
|||
%rename("has-key?") has_key;
|
||||
public:
|
||||
map();
|
||||
map(const map<K,T> &);
|
||||
map(const map< K, T > &);
|
||||
|
||||
unsigned int size() const;
|
||||
bool empty() const;
|
||||
void clear();
|
||||
%extend {
|
||||
T __getitem__(const K& key) throw (std::out_of_range) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
std::map< K, T >::iterator i = self->find(key);
|
||||
if (i != self->end())
|
||||
return i->second;
|
||||
else
|
||||
|
|
@ -671,20 +658,19 @@ namespace std {
|
|||
(*self)[key] = x;
|
||||
}
|
||||
void __delitem__(const K& key) throw (std::out_of_range) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
std::map< K, T >::iterator i = self->find(key);
|
||||
if (i != self->end())
|
||||
self->erase(i);
|
||||
else
|
||||
throw std::out_of_range("key not found");
|
||||
}
|
||||
bool has_key(const K& key) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
std::map< K, T >::iterator i = self->find(key);
|
||||
return i != self->end();
|
||||
}
|
||||
SCM keys() {
|
||||
SCM result = SCM_EOL;
|
||||
for (std::map<K,T >::reverse_iterator i=self->rbegin();
|
||||
i!=self->rend(); ++i) {
|
||||
for (std::map< K, T >::reverse_iterator i=self->rbegin(); i!=self->rend(); ++i) {
|
||||
K* key = new K(i->first);
|
||||
SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
|
||||
result = scm_cons(k,result);
|
||||
|
|
@ -698,11 +684,11 @@ namespace std {
|
|||
%define specialize_std_map_on_both(K,CHECK_K,CONVERT_K_FROM,CONVERT_K_TO,
|
||||
T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO)
|
||||
template<> class map<K,T> {
|
||||
%typemap(in) map<K,T> (std::map<K,T>* m) {
|
||||
%typemap(in) map<K,T> {
|
||||
if (scm_is_null($input)) {
|
||||
$1 = std::map<K,T >();
|
||||
$1 = std::map< K, T >();
|
||||
} else if (scm_is_pair($input)) {
|
||||
$1 = std::map<K,T >();
|
||||
$1 = std::map< K, T >();
|
||||
SCM alist = $input;
|
||||
while (!scm_is_null(alist)) {
|
||||
SCM entry, key, val;
|
||||
|
|
@ -731,15 +717,13 @@ namespace std {
|
|||
SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
|
||||
}
|
||||
}
|
||||
%typemap(in) const map<K,T>& (std::map<K,T> temp,
|
||||
std::map<K,T>* m),
|
||||
const map<K,T>* (std::map<K,T> temp,
|
||||
std::map<K,T>* m) {
|
||||
%typemap(in) const map<K,T>& (std::map<K,T> temp),
|
||||
const map<K,T>* (std::map<K,T> temp) {
|
||||
if (scm_is_null($input)) {
|
||||
temp = std::map<K,T >();
|
||||
temp = std::map< K, T >();
|
||||
$1 = &temp;
|
||||
} else if (scm_is_pair($input)) {
|
||||
temp = std::map<K,T >();
|
||||
temp = std::map< K, T >();
|
||||
$1 = &temp;
|
||||
SCM alist = $input;
|
||||
while (!scm_is_null(alist)) {
|
||||
|
|
@ -769,8 +753,7 @@ namespace std {
|
|||
}
|
||||
%typemap(out) map<K,T> {
|
||||
SCM alist = SCM_EOL;
|
||||
for (std::map<K,T >::reverse_iterator i=$1.rbegin();
|
||||
i!=$1.rend(); ++i) {
|
||||
for (std::map< K, T >::reverse_iterator i=$1.rbegin(); i!=$1.rend(); ++i) {
|
||||
SCM k = CONVERT_K_TO(i->first);
|
||||
SCM x = CONVERT_T_TO(i->second);
|
||||
SCM entry = scm_cons(k,x);
|
||||
|
|
@ -809,7 +792,7 @@ namespace std {
|
|||
}
|
||||
} else {
|
||||
// wrapped map?
|
||||
std::map<K,T >* m;
|
||||
std::map< K, T >* m;
|
||||
if (SWIG_ConvertPtr($input,(void **) &m,
|
||||
$&1_descriptor, 0) == 0)
|
||||
$1 = 1;
|
||||
|
|
@ -849,7 +832,7 @@ namespace std {
|
|||
}
|
||||
} else {
|
||||
// wrapped map?
|
||||
std::map<K,T >* m;
|
||||
std::map< K, T >* m;
|
||||
if (SWIG_ConvertPtr($input,(void **) &m,
|
||||
$1_descriptor, 0) == 0)
|
||||
$1 = 1;
|
||||
|
|
@ -866,14 +849,14 @@ namespace std {
|
|||
%rename("has-key?") has_key;
|
||||
public:
|
||||
map();
|
||||
map(const map<K,T> &);
|
||||
map(const map< K, T> &);
|
||||
|
||||
unsigned int size() const;
|
||||
bool empty() const;
|
||||
void clear();
|
||||
%extend {
|
||||
T __getitem__(K key) throw (std::out_of_range) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
std::map< K, T >::iterator i = self->find(key);
|
||||
if (i != self->end())
|
||||
return i->second;
|
||||
else
|
||||
|
|
@ -883,20 +866,19 @@ namespace std {
|
|||
(*self)[key] = x;
|
||||
}
|
||||
void __delitem__(K key) throw (std::out_of_range) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
std::map< K, T >::iterator i = self->find(key);
|
||||
if (i != self->end())
|
||||
self->erase(i);
|
||||
else
|
||||
throw std::out_of_range("key not found");
|
||||
}
|
||||
bool has_key(K key) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
std::map< K, T >::iterator i = self->find(key);
|
||||
return i != self->end();
|
||||
}
|
||||
SCM keys() {
|
||||
SCM result = SCM_EOL;
|
||||
for (std::map<K,T >::reverse_iterator i=self->rbegin();
|
||||
i!=self->rend(); ++i) {
|
||||
for (std::map< K, T >::reverse_iterator i=self->rbegin(); i!=self->rend(); ++i) {
|
||||
SCM k = CONVERT_K_TO(i->first);
|
||||
result = scm_cons(k,result);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -79,7 +79,7 @@ namespace std {
|
|||
}
|
||||
} else {
|
||||
/* wrapped pair? */
|
||||
std::pair<T,U >* m;
|
||||
std::pair< T, U >* m;
|
||||
if (SWIG_ConvertPtr($input,(void **) &m,
|
||||
$&1_descriptor, 0) == 0)
|
||||
$1 = 1;
|
||||
|
|
@ -105,7 +105,7 @@ namespace std {
|
|||
}
|
||||
} else {
|
||||
/* wrapped pair? */
|
||||
std::pair<T,U >* m;
|
||||
std::pair< T, U >* m;
|
||||
if (SWIG_ConvertPtr($input,(void **) &m,
|
||||
$1_descriptor, 0) == 0)
|
||||
$1 = 1;
|
||||
|
|
@ -183,7 +183,7 @@ namespace std {
|
|||
}
|
||||
} else {
|
||||
/* wrapped pair? */
|
||||
std::pair<T,U >* m;
|
||||
std::pair< T, U >* m;
|
||||
if (SWIG_ConvertPtr($input,(void **) &m,
|
||||
$&1_descriptor, 0) == 0)
|
||||
$1 = 1;
|
||||
|
|
@ -207,7 +207,7 @@ namespace std {
|
|||
}
|
||||
} else {
|
||||
/* wrapped pair? */
|
||||
std::pair<T,U >* m;
|
||||
std::pair< T, U >* m;
|
||||
if (SWIG_ConvertPtr($input,(void **) &m,
|
||||
$1_descriptor, 0) == 0)
|
||||
$1 = 1;
|
||||
|
|
@ -283,7 +283,7 @@ namespace std {
|
|||
}
|
||||
} else {
|
||||
/* wrapped pair? */
|
||||
std::pair<T,U >* m;
|
||||
std::pair< T, U >* m;
|
||||
if (SWIG_ConvertPtr($input,(void **) &m,
|
||||
$&1_descriptor, 0) == 0)
|
||||
$1 = 1;
|
||||
|
|
@ -307,7 +307,7 @@ namespace std {
|
|||
}
|
||||
} else {
|
||||
/* wrapped pair? */
|
||||
std::pair<T,U >* m;
|
||||
std::pair< T, U >* m;
|
||||
if (SWIG_ConvertPtr($input,(void **) &m,
|
||||
$1_descriptor, 0) == 0)
|
||||
$1 = 1;
|
||||
|
|
@ -377,7 +377,7 @@ namespace std {
|
|||
}
|
||||
} else {
|
||||
/* wrapped pair? */
|
||||
std::pair<T,U >* m;
|
||||
std::pair< T, U >* m;
|
||||
if (SWIG_ConvertPtr($input,(void **) &m,
|
||||
$&1_descriptor, 0) == 0)
|
||||
$1 = 1;
|
||||
|
|
@ -398,7 +398,7 @@ namespace std {
|
|||
}
|
||||
} else {
|
||||
/* wrapped pair? */
|
||||
std::pair<T,U >* m;
|
||||
std::pair< T, U >* m;
|
||||
if (SWIG_ConvertPtr($input,(void **) &m,
|
||||
$1_descriptor, 0) == 0)
|
||||
$1 = 1;
|
||||
|
|
|
|||
|
|
@ -44,17 +44,17 @@ namespace std {
|
|||
%typemap(in) vector<T> {
|
||||
if (scm_is_vector($input)) {
|
||||
unsigned long size = scm_c_vector_length($input);
|
||||
$1 = std::vector<T >(size);
|
||||
$1 = std::vector< T >(size);
|
||||
for (unsigned long i=0; i<size; i++) {
|
||||
SCM o = scm_vector_ref($input,scm_from_ulong(i));
|
||||
(($1_type &)$1)[i] =
|
||||
*((T*) SWIG_MustGetPtr(o,$descriptor(T *),$argnum, 0));
|
||||
}
|
||||
} else if (scm_is_null($input)) {
|
||||
$1 = std::vector<T >();
|
||||
$1 = std::vector< T >();
|
||||
} else if (scm_is_pair($input)) {
|
||||
SCM head, tail;
|
||||
$1 = std::vector<T >();
|
||||
$1 = std::vector< T >();
|
||||
tail = $input;
|
||||
while (!scm_is_null(tail)) {
|
||||
head = SCM_CAR(tail);
|
||||
|
|
@ -72,7 +72,7 @@ namespace std {
|
|||
const vector<T>* (std::vector<T> temp) {
|
||||
if (scm_is_vector($input)) {
|
||||
unsigned long size = scm_c_vector_length($input);
|
||||
temp = std::vector<T >(size);
|
||||
temp = std::vector< T >(size);
|
||||
$1 = &temp;
|
||||
for (unsigned long i=0; i<size; i++) {
|
||||
SCM o = scm_vector_ref($input,scm_from_ulong(i));
|
||||
|
|
@ -81,10 +81,10 @@ namespace std {
|
|||
$argnum, 0));
|
||||
}
|
||||
} else if (scm_is_null($input)) {
|
||||
temp = std::vector<T >();
|
||||
temp = std::vector< T >();
|
||||
$1 = &temp;
|
||||
} else if (scm_is_pair($input)) {
|
||||
temp = std::vector<T >();
|
||||
temp = std::vector< T >();
|
||||
$1 = &temp;
|
||||
SCM head, tail;
|
||||
tail = $input;
|
||||
|
|
@ -138,7 +138,7 @@ namespace std {
|
|||
$1 = 0;
|
||||
} else {
|
||||
/* wrapped vector? */
|
||||
std::vector<T >* v;
|
||||
std::vector< T >* v;
|
||||
if (SWIG_ConvertPtr($input,(void **) &v,
|
||||
$&1_descriptor, 0) != -1)
|
||||
$1 = 1;
|
||||
|
|
@ -178,7 +178,7 @@ namespace std {
|
|||
$1 = 0;
|
||||
} else {
|
||||
/* wrapped vector? */
|
||||
std::vector<T >* v;
|
||||
std::vector< T >* v;
|
||||
if (SWIG_ConvertPtr($input,(void **) &v,
|
||||
$1_descriptor, 0) != -1)
|
||||
$1 = 1;
|
||||
|
|
@ -232,7 +232,7 @@ namespace std {
|
|||
%typemap(in) vector<T> {
|
||||
if (scm_is_vector($input)) {
|
||||
unsigned long size = scm_c_vector_length($input);
|
||||
$1 = std::vector<T >(size);
|
||||
$1 = std::vector< T >(size);
|
||||
for (unsigned long i=0; i<size; i++) {
|
||||
SCM o = scm_vector_ref($input,scm_from_ulong(i));
|
||||
if (CHECK(o))
|
||||
|
|
@ -245,7 +245,7 @@ namespace std {
|
|||
} else if (scm_is_pair($input)) {
|
||||
SCM v = scm_vector($input);
|
||||
unsigned long size = scm_c_vector_length(v);
|
||||
$1 = std::vector<T >(size);
|
||||
$1 = std::vector< T >(size);
|
||||
for (unsigned long i=0; i<size; i++) {
|
||||
SCM o = scm_vector_ref(v,scm_from_ulong(i));
|
||||
if (CHECK(o))
|
||||
|
|
@ -262,7 +262,7 @@ namespace std {
|
|||
const vector<T>* (std::vector<T> temp) {
|
||||
if (scm_is_vector($input)) {
|
||||
unsigned long size = scm_c_vector_length($input);
|
||||
temp = std::vector<T >(size);
|
||||
temp = std::vector< T >(size);
|
||||
$1 = &temp;
|
||||
for (unsigned long i=0; i<size; i++) {
|
||||
SCM o = scm_vector_ref($input,scm_from_ulong(i));
|
||||
|
|
@ -272,12 +272,12 @@ namespace std {
|
|||
scm_wrong_type_arg(FUNC_NAME, $argnum, $input);
|
||||
}
|
||||
} else if (scm_is_null($input)) {
|
||||
temp = std::vector<T >();
|
||||
temp = std::vector< T >();
|
||||
$1 = &temp;
|
||||
} else if (scm_is_pair($input)) {
|
||||
SCM v = scm_vector($input);
|
||||
unsigned long size = scm_c_vector_length(v);
|
||||
temp = std::vector<T >(size);
|
||||
temp = std::vector< T >(size);
|
||||
$1 = &temp;
|
||||
for (unsigned long i=0; i<size; i++) {
|
||||
SCM o = scm_vector_ref(v,scm_from_ulong(i));
|
||||
|
|
@ -318,7 +318,7 @@ namespace std {
|
|||
$1 = CHECK(head) ? 1 : 0;
|
||||
} else {
|
||||
/* wrapped vector? */
|
||||
std::vector<T >* v;
|
||||
std::vector< T >* v;
|
||||
$1 = (SWIG_ConvertPtr($input,(void **) &v,
|
||||
$&1_descriptor, 0) != -1) ? 1 : 0;
|
||||
}
|
||||
|
|
@ -345,7 +345,7 @@ namespace std {
|
|||
$1 = CHECK(head) ? 1 : 0;
|
||||
} else {
|
||||
/* wrapped vector? */
|
||||
std::vector<T >* v;
|
||||
std::vector< T >* v;
|
||||
$1 = (SWIG_ConvertPtr($input,(void **) &v,
|
||||
$1_descriptor, 0) != -1) ? 1 : 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ static int SWIG_JavaArrayIn##JFUNCNAME (JNIEnv *jenv, JNITYPE **jarr, CTYPE **ca
|
|||
#ifdef __cplusplus
|
||||
%{ *carr = new CTYPE[sz]; %}
|
||||
#else
|
||||
%{ *carr = (CTYPE*) calloc(sz, sizeof(CTYPE)); %}
|
||||
%{ *carr = (CTYPE*) malloc(sz * sizeof(CTYPE)); %}
|
||||
#endif
|
||||
%{ if (!*carr) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
|
||||
|
|
@ -259,7 +259,7 @@ JAVA_ARRAYS_TYPEMAPS(double, double, jdouble, Double, "[D") /* double[ANY] *
|
|||
#ifdef __cplusplus
|
||||
$1 = new $*1_ltype[sz];
|
||||
#else
|
||||
$1 = ($1_ltype) calloc(sz, sizeof($*1_ltype));
|
||||
$1 = ($1_ltype) malloc(sz * sizeof($*1_ltype));
|
||||
#endif
|
||||
if (!$1) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
|
||||
|
|
@ -289,7 +289,7 @@ JAVA_ARRAYS_TYPEMAPS(double, double, jdouble, Double, "[D") /* double[ANY] *
|
|||
#ifdef __cplusplus
|
||||
$1 = new $*1_ltype[sz];
|
||||
#else
|
||||
$1 = ($1_ltype) calloc(sz, sizeof($*1_ltype));
|
||||
$1 = ($1_ltype) malloc(sz * sizeof($*1_ltype));
|
||||
#endif
|
||||
if (!$1) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
|
||||
|
|
|
|||
|
|
@ -263,8 +263,8 @@
|
|||
|
||||
// Base proxy classes
|
||||
%typemap(javabody) TYPE %{
|
||||
private long swigCPtr;
|
||||
private boolean swigCMemOwnBase;
|
||||
private transient long swigCPtr;
|
||||
private transient boolean swigCMemOwnBase;
|
||||
|
||||
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
|
||||
swigCMemOwnBase = cMemoryOwn;
|
||||
|
|
@ -278,8 +278,8 @@
|
|||
|
||||
// Derived proxy classes
|
||||
%typemap(javabody_derived) TYPE %{
|
||||
private long swigCPtr;
|
||||
private boolean swigCMemOwnDerived;
|
||||
private transient long swigCPtr;
|
||||
private transient boolean swigCMemOwnDerived;
|
||||
|
||||
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
|
||||
super($imclassname.$javaclazznameSWIGSmartPtrUpcast(cPtr), true);
|
||||
|
|
@ -413,8 +413,8 @@
|
|||
|
||||
// Base proxy classes
|
||||
%typemap(javabody) TYPE %{
|
||||
private long swigCPtr;
|
||||
private boolean swigCMemOwnBase;
|
||||
private transient long swigCPtr;
|
||||
private transient boolean swigCMemOwnBase;
|
||||
|
||||
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
|
||||
swigCMemOwnBase = cMemoryOwn;
|
||||
|
|
@ -428,8 +428,8 @@
|
|||
|
||||
// Derived proxy classes
|
||||
%typemap(javabody_derived) TYPE %{
|
||||
private long swigCPtr;
|
||||
private boolean swigCMemOwnDerived;
|
||||
private transient long swigCPtr;
|
||||
private transient boolean swigCMemOwnDerived;
|
||||
|
||||
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
|
||||
super($imclassname.$javaclazznameSWIGSmartPtrUpcast(cPtr), true);
|
||||
|
|
|
|||
|
|
@ -145,8 +145,8 @@
|
|||
|
||||
// Base proxy classes
|
||||
%typemap(javabody) TYPE %{
|
||||
private long swigCPtr;
|
||||
private boolean swigCMemOwn;
|
||||
private transient long swigCPtr;
|
||||
private transient boolean swigCMemOwn;
|
||||
|
||||
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
|
||||
swigCMemOwn = cMemoryOwn;
|
||||
|
|
@ -160,8 +160,8 @@
|
|||
|
||||
// Derived proxy classes
|
||||
%typemap(javabody_derived) TYPE %{
|
||||
private long swigCPtr;
|
||||
private boolean swigCMemOwnDerived;
|
||||
private transient long swigCPtr;
|
||||
private transient boolean swigCMemOwnDerived;
|
||||
|
||||
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
|
||||
super($imclassname.$javaclazznameSWIGSmartPtrUpcast(cPtr), true);
|
||||
|
|
|
|||
|
|
@ -310,8 +310,11 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
|
|||
bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
|
||||
sz = JCALL1(GetArrayLength, jenv, ba);
|
||||
$1 = 0;
|
||||
for(i=0; i<sz; i++) {
|
||||
$1 = ($1 << 8) | ($1_type)(unsigned char)bae[i];
|
||||
if (sz > 0) {
|
||||
$1 = ($1_type)(signed char)bae[0];
|
||||
for(i=1; i<sz; i++) {
|
||||
$1 = ($1 << 8) | ($1_type)(unsigned char)bae[i];
|
||||
}
|
||||
}
|
||||
JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
|
||||
}
|
||||
|
|
@ -334,8 +337,11 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
|
|||
bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
|
||||
sz = JCALL1(GetArrayLength, jenv, ba);
|
||||
$result = 0;
|
||||
for(i=0; i<sz; i++) {
|
||||
$result = ($result << 8) | ($1_type)(unsigned char)bae[i];
|
||||
if (sz > 0) {
|
||||
$result = ($1_type)(signed char)bae[0];
|
||||
for(i=1; i<sz; i++) {
|
||||
$result = ($result << 8) | ($1_type)(unsigned char)bae[i];
|
||||
}
|
||||
}
|
||||
JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
|
||||
}
|
||||
|
|
@ -406,7 +412,6 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
|
|||
if (!$input) return $null;
|
||||
}
|
||||
Swig::LocalRefGuard $1_refguard(jenv, $input);
|
||||
// boohoo
|
||||
}
|
||||
|
||||
%typemap(freearg, noblock=1) char * { if ($1) JCALL2(ReleaseStringUTFChars, jenv, $input, (const char *)$1); }
|
||||
|
|
@ -553,8 +558,11 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
|
|||
sz = JCALL1(GetArrayLength, jenv, ba);
|
||||
$1 = &temp;
|
||||
temp = 0;
|
||||
for(i=0; i<sz; i++) {
|
||||
temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
|
||||
if (sz > 0) {
|
||||
temp = ($*1_ltype)(signed char)bae[0];
|
||||
for(i=1; i<sz; i++) {
|
||||
temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
|
||||
}
|
||||
}
|
||||
JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
|
||||
}
|
||||
|
|
@ -579,8 +587,11 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
|
|||
sz = JCALL1(GetArrayLength, jenv, ba);
|
||||
$result = &temp;
|
||||
temp = 0;
|
||||
for(i=0; i<sz; i++) {
|
||||
temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
|
||||
if (sz > 0) {
|
||||
temp = ($*1_ltype)(signed char)bae[0];
|
||||
for(i=1; i<sz; i++) {
|
||||
temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
|
||||
}
|
||||
}
|
||||
JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
|
||||
}
|
||||
|
|
@ -636,8 +647,8 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
|
|||
|
||||
%typemap(directorin,descriptor="L$packagepath/$&javaclassname;") SWIGTYPE
|
||||
%{ $input = 0;
|
||||
*(($&1_ltype*)&$input) = &$1; %}
|
||||
%typemap(javadirectorin) SWIGTYPE "new $&javaclassname($jniinput, false)"
|
||||
*(($&1_ltype*)&$input) = new $1_ltype((const $1_ltype &)$1); %}
|
||||
%typemap(javadirectorin) SWIGTYPE "new $&javaclassname($jniinput, true)"
|
||||
%typemap(javadirectorout) SWIGTYPE "$&javaclassname.getCPtr($javacall)"
|
||||
|
||||
/* Generic pointers and references */
|
||||
|
|
@ -1148,8 +1159,8 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
|
|||
%define SWIG_JAVABODY_PROXY(PTRCTOR_VISIBILITY, CPTR_VISIBILITY, TYPE...)
|
||||
// Base proxy classes
|
||||
%typemap(javabody) TYPE %{
|
||||
private long swigCPtr;
|
||||
protected boolean swigCMemOwn;
|
||||
private transient long swigCPtr;
|
||||
protected transient boolean swigCMemOwn;
|
||||
|
||||
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
|
||||
swigCMemOwn = cMemoryOwn;
|
||||
|
|
@ -1163,7 +1174,7 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
|
|||
|
||||
// Derived proxy classes
|
||||
%typemap(javabody_derived) TYPE %{
|
||||
private long swigCPtr;
|
||||
private transient long swigCPtr;
|
||||
|
||||
PTRCTOR_VISIBILITY $javaclassname(long cPtr, boolean cMemoryOwn) {
|
||||
super($imclassname.$javaclazznameSWIGUpcast(cPtr), cMemoryOwn);
|
||||
|
|
@ -1179,7 +1190,7 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
|
|||
%define SWIG_JAVABODY_TYPEWRAPPER(PTRCTOR_VISIBILITY, DEFAULTCTOR_VISIBILITY, CPTR_VISIBILITY, TYPE...)
|
||||
// Typewrapper classes
|
||||
%typemap(javabody) TYPE *, TYPE &, TYPE &&, TYPE [] %{
|
||||
private long swigCPtr;
|
||||
private transient long swigCPtr;
|
||||
|
||||
PTRCTOR_VISIBILITY $javaclassname(long cPtr, @SuppressWarnings("unused") boolean futureUse) {
|
||||
swigCPtr = cPtr;
|
||||
|
|
@ -1195,7 +1206,7 @@ SWIGINTERN const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
|
|||
%}
|
||||
|
||||
%typemap(javabody) TYPE (CLASS::*) %{
|
||||
private String swigCMemberPtr;
|
||||
private transient String swigCMemberPtr;
|
||||
|
||||
PTRCTOR_VISIBILITY $javaclassname(String cMemberPtr, @SuppressWarnings("unused") boolean futureUse) {
|
||||
swigCMemberPtr = cMemberPtr;
|
||||
|
|
@ -1330,8 +1341,8 @@ SWIG_PROXY_CONSTRUCTOR(true, true, SWIGTYPE)
|
|||
%typemap(freearg) (char *STRING, size_t LENGTH) ""
|
||||
%typemap(in) (char *STRING, size_t LENGTH) {
|
||||
if ($input) {
|
||||
$1 = (char *) JCALL2(GetByteArrayElements, jenv, $input, 0);
|
||||
$2 = (size_t) JCALL1(GetArrayLength, jenv, $input);
|
||||
$1 = ($1_ltype) JCALL2(GetByteArrayElements, jenv, $input, 0);
|
||||
$2 = ($2_type) JCALL1(GetArrayLength, jenv, $input);
|
||||
} else {
|
||||
$1 = 0;
|
||||
$2 = 0;
|
||||
|
|
|
|||
42
Lib/java/std_array.i
Normal file
42
Lib/java/std_array.i
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
/* -----------------------------------------------------------------------------
|
||||
* std_array.i
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%include <std_common.i>
|
||||
|
||||
namespace std {
|
||||
|
||||
template<class T, size_t N> class array {
|
||||
public:
|
||||
typedef T& reference;
|
||||
typedef const T& const_reference;
|
||||
typedef size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef T value_type;
|
||||
typedef T* pointer;
|
||||
typedef const T* const_pointer;
|
||||
array();
|
||||
array(const array& other);
|
||||
size_type size() const;
|
||||
%rename(isEmpty) empty;
|
||||
bool empty() const;
|
||||
void fill(const T& u);
|
||||
%extend {
|
||||
const_reference get(int i) throw (std::out_of_range) {
|
||||
int size = int(self->size());
|
||||
if (i>=0 && i<size)
|
||||
return (*self)[i];
|
||||
else
|
||||
throw std::out_of_range("array index out of range");
|
||||
}
|
||||
void set(int i, const value_type& val) throw (std::out_of_range) {
|
||||
int size = int(self->size());
|
||||
if (i>=0 && i<size)
|
||||
(*self)[i] = val;
|
||||
else
|
||||
throw std::out_of_range("array index out of range");
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
|
|
@ -7,6 +7,7 @@
|
|||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%{
|
||||
#include <typeinfo>
|
||||
#include <stdexcept>
|
||||
%}
|
||||
|
||||
|
|
@ -16,6 +17,7 @@ namespace std
|
|||
struct exception {};
|
||||
}
|
||||
|
||||
%typemap(throws) std::bad_cast "SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.what());\n return $null;"
|
||||
%typemap(throws) std::bad_exception "SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.what());\n return $null;"
|
||||
%typemap(throws) std::domain_error "SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.what());\n return $null;"
|
||||
%typemap(throws) std::exception "SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.what());\n return $null;"
|
||||
|
|
|
|||
|
|
@ -59,15 +59,16 @@ class wstring;
|
|||
jenv->ReleaseStringChars($input, $1_pstr);
|
||||
%}
|
||||
|
||||
%typemap(directorin,descriptor="Ljava/lang/String;") wstring {
|
||||
%typemap(directorin,descriptor="Ljava/lang/String;") wstring %{
|
||||
jsize $1_len = $1.length();
|
||||
jchar *conv_buf = new jchar[$1_len];
|
||||
jchar *$1_conv_buf = new jchar[$1_len];
|
||||
for (jsize i = 0; i < $1_len; ++i) {
|
||||
conv_buf[i] = (jchar)$1[i];
|
||||
$1_conv_buf[i] = (jchar)$1[i];
|
||||
}
|
||||
$input = jenv->NewString(conv_buf, $1_len);
|
||||
delete [] conv_buf;
|
||||
}
|
||||
$input = jenv->NewString($1_conv_buf, $1_len);
|
||||
Swig::LocalRefGuard $1_refguard(jenv, $input);
|
||||
delete [] $1_conv_buf;
|
||||
%}
|
||||
|
||||
%typemap(out) wstring
|
||||
%{jsize $1_len = $1.length();
|
||||
|
|
@ -136,15 +137,16 @@ class wstring;
|
|||
$result = &$1_str;
|
||||
jenv->ReleaseStringChars($input, $1_pstr); %}
|
||||
|
||||
%typemap(directorin,descriptor="Ljava/lang/String;") const wstring & {
|
||||
%typemap(directorin,descriptor="Ljava/lang/String;") const wstring & %{
|
||||
jsize $1_len = $1.length();
|
||||
jchar *conv_buf = new jchar[$1_len];
|
||||
jchar *$1_conv_buf = new jchar[$1_len];
|
||||
for (jsize i = 0; i < $1_len; ++i) {
|
||||
conv_buf[i] = (jchar)($1)[i];
|
||||
$1_conv_buf[i] = (jchar)($1)[i];
|
||||
}
|
||||
$input = jenv->NewString(conv_buf, $1_len);
|
||||
delete [] conv_buf;
|
||||
}
|
||||
$input = jenv->NewString($1_conv_buf, $1_len);
|
||||
Swig::LocalRefGuard $1_refguard(jenv, $input);
|
||||
delete [] $1_conv_buf;
|
||||
%}
|
||||
|
||||
%typemap(out) const wstring &
|
||||
%{jsize $1_len = $1->length();
|
||||
|
|
|
|||
74
Lib/java/swiginterface.i
Normal file
74
Lib/java/swiginterface.i
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
/* -----------------------------------------------------------------------------
|
||||
* swiginterface.i
|
||||
*
|
||||
* SWIG interface feature and typemaps implementation providing:
|
||||
* %interface
|
||||
* %interface_impl
|
||||
* %interface_custom
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%define INTERFACE_TYPEMAPS(CTYPE...)
|
||||
%typemap(jtype) CTYPE, CTYPE *, CTYPE *const&, CTYPE [], CTYPE & "long"
|
||||
%typemap(jstype) CTYPE "$&javainterfacename"
|
||||
%typemap(jstype) CTYPE *, CTYPE [], CTYPE & "$javainterfacename"
|
||||
%typemap(jstype) CTYPE *const& "$*javainterfacename"
|
||||
%typemap(javain) CTYPE "$javainput.$&interfacename_GetInterfaceCPtr()"
|
||||
%typemap(javain) CTYPE & "$javainput.$interfacename_GetInterfaceCPtr()"
|
||||
%typemap(javain) CTYPE *, CTYPE [] "($javainput == null) ? 0 : $javainput.$interfacename_GetInterfaceCPtr()"
|
||||
%typemap(javain) CTYPE *const& "($javainput == null) ? 0 : $javainput.$*interfacename_GetInterfaceCPtr()"
|
||||
%typemap(javaout) CTYPE {
|
||||
return ($&javainterfacename)new $&javaclassname($jnicall, true);
|
||||
}
|
||||
%typemap(javaout) CTYPE & {
|
||||
return ($javainterfacename)new $javaclassname($jnicall, $owner);
|
||||
}
|
||||
%typemap(javaout) CTYPE *, CTYPE [] {
|
||||
long cPtr = $jnicall;
|
||||
return (cPtr == 0) ? null : ($javainterfacename)new $javaclassname(cPtr, $owner);
|
||||
}
|
||||
%typemap(javaout) CTYPE *const& {
|
||||
long cPtr = $jnicall;
|
||||
return (cPtr == 0) ? null : ($javainterfacename)new $javaclassname(cPtr, $owner);
|
||||
}
|
||||
|
||||
%typemap(javadirectorin) CTYPE "($&javainterfacename)new $&javaclassname($jniinput, true)"
|
||||
%typemap(javadirectorin) CTYPE & "($javainterfacename)new $javaclassname($jniinput, false)"
|
||||
%typemap(javadirectorin) CTYPE *, CTYPE [] "($jniinput == 0) ? null : ($javainterfacename)new $javaclassname($jniinput, false)"
|
||||
%typemap(javadirectorin) CTYPE *const& "($jniinput == 0) ? null : ($*javainterfacename)new $*javaclassname($jniinput, false)"
|
||||
%typemap(javadirectorout) CTYPE "$javacall.$&interfacename_GetInterfaceCPtr()"
|
||||
%typemap(javadirectorout) CTYPE *, CTYPE [], CTYPE & "$javacall.$interfacename_GetInterfaceCPtr()"
|
||||
%typemap(javadirectorout) CTYPE *const& "$javacall.$*interfacename_GetInterfaceCPtr()"
|
||||
%typemap(directorin,descriptor="L$packagepath/$&javainterfacename;") CTYPE
|
||||
%{ $input = 0;
|
||||
*(($&1_ltype*)&$input) = new $1_ltype((const $1_ltype &)$1); %}
|
||||
%typemap(directorin,descriptor="L$packagepath/$javainterfacename;") CTYPE *, CTYPE []
|
||||
%{ *(($&1_ltype)&$input) = ($1_ltype) $1; %}
|
||||
%typemap(directorin,descriptor="L$packagepath/$javainterfacename;") CTYPE &
|
||||
%{ *($&1_ltype)&$input = ($1_ltype) &$1; %}
|
||||
%typemap(directorin,descriptor="L$packagepath/$*javainterfacename;") CTYPE *const&
|
||||
%{ *($&1_ltype)&$input = ($1_ltype) &$1; %}
|
||||
|
||||
%typemap(javainterfacecode, declaration=" long $interfacename_GetInterfaceCPtr();\n", cptrmethod="$interfacename_GetInterfaceCPtr") CTYPE %{
|
||||
public long $interfacename_GetInterfaceCPtr() {
|
||||
return $imclassname.$javaclazzname$interfacename_GetInterfaceCPtr(swigCPtr);
|
||||
}
|
||||
%}
|
||||
%enddef
|
||||
|
||||
%define %interface(CTYPE...)
|
||||
%feature("interface", name="%sSwigInterface") CTYPE;
|
||||
INTERFACE_TYPEMAPS(CTYPE)
|
||||
%enddef
|
||||
|
||||
%define %interface_impl(CTYPE...)
|
||||
%rename("%sSwigImpl") CTYPE;
|
||||
%feature("interface", name="%(rstrip:[SwigImpl])s") CTYPE;
|
||||
INTERFACE_TYPEMAPS(CTYPE)
|
||||
%enddef
|
||||
|
||||
%define %interface_custom(PROXY, INTERFACE, CTYPE...)
|
||||
%rename(PROXY) CTYPE;
|
||||
%feature("interface", name=INTERFACE) CTYPE;
|
||||
INTERFACE_TYPEMAPS(CTYPE)
|
||||
%enddef
|
||||
|
||||
|
|
@ -109,8 +109,11 @@ INPUT_TYPEMAP(double, jdouble, double, "D");
|
|||
bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
|
||||
sz = JCALL1(GetArrayLength, jenv, ba);
|
||||
temp = 0;
|
||||
for(i=0; i<sz; i++) {
|
||||
temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
|
||||
if (sz > 0) {
|
||||
temp = ($*1_ltype)(signed char)bae[0];
|
||||
for(i=1; i<sz; i++) {
|
||||
temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
|
||||
}
|
||||
}
|
||||
JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
|
||||
$1 = &temp;
|
||||
|
|
@ -416,8 +419,11 @@ INOUT_TYPEMAP(double, jdouble, double, Double, "[Ljava/lang/Double;", jdoubleArr
|
|||
bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
|
||||
sz = JCALL1(GetArrayLength, jenv, ba);
|
||||
temp = 0;
|
||||
for(i=0; i<sz; i++) {
|
||||
temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
|
||||
if (sz > 0) {
|
||||
temp = ($*1_ltype)(signed char)bae[0];
|
||||
for(i=1; i<sz; i++) {
|
||||
temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
|
||||
}
|
||||
}
|
||||
JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
|
||||
$1 = &temp;
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@
|
|||
#ifdef __cplusplus
|
||||
$1 = new char*[size+1];
|
||||
#else
|
||||
$1 = (char **)calloc(size+1, sizeof(char *));
|
||||
$1 = (char **)malloc((size+1) * sizeof(char *));
|
||||
#endif
|
||||
for (i = 0; i<size; i++) {
|
||||
jstring j_string = (jstring)JCALL2(GetObjectArrayElement, jenv, $input, i);
|
||||
|
|
@ -37,7 +37,7 @@
|
|||
#ifdef __cplusplus
|
||||
$1[i] = new char [strlen(c_string)+1];
|
||||
#else
|
||||
$1[i] = (char *)calloc(strlen(c_string)+1, sizeof(const char *));
|
||||
$1[i] = (char *)malloc((strlen(c_string)+1) * sizeof(const char *));
|
||||
#endif
|
||||
strcpy($1[i], c_string);
|
||||
JCALL2(ReleaseStringUTFChars, jenv, j_string, c_string);
|
||||
|
|
|
|||
|
|
@ -32,6 +32,7 @@ static JSObjectRef $jswrapper(JSContextRef context, JSObjectRef ctorObject,
|
|||
size_t argc, const JSValueRef argv[], JSValueRef* exception)
|
||||
{
|
||||
SWIG_exception(SWIG_ERROR, "Class $jsname can not be instantiated");
|
||||
fail:
|
||||
return 0;
|
||||
}
|
||||
%}
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
the complex Constructor method, and the Real and Imag complex
|
||||
accessor methods.
|
||||
|
||||
See the std_complex.i and ccomplex.i for concret examples.
|
||||
See the std_complex.i and ccomplex.i for concrete examples.
|
||||
*/
|
||||
|
||||
/* the common from converter */
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@ SWIGINTERN bool JS_veto_set_variable(JSContextRef context, JSObjectRef thisObjec
|
|||
} else {
|
||||
SWIG_exception(SWIG_ERROR, msg);
|
||||
}
|
||||
|
||||
fail:
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -98,18 +98,21 @@ SWIG_AsVal_dec(unsigned long)(JSValueRef obj, unsigned long *val)
|
|||
|
||||
%fragment(SWIG_From_frag(long long),"header",
|
||||
fragment=SWIG_From_frag(long),
|
||||
fragment="<limits.h>") {
|
||||
fragment="SWIG_LongLongAvailable") {
|
||||
%#ifdef SWIG_LONG_LONG_AVAILABLE
|
||||
SWIGINTERNINLINE JSValueRef
|
||||
SWIG_From_dec(long long)(long long value)
|
||||
{
|
||||
return JSValueMakeNumber(context, value);
|
||||
}
|
||||
%#endif
|
||||
}
|
||||
|
||||
%fragment(SWIG_AsVal_frag(long long),"header",
|
||||
fragment=SWIG_AsVal_frag(long),
|
||||
fragment="SWIG_CanCastAsInteger",
|
||||
fragment="<limits.h>") {
|
||||
fragment="SWIG_LongLongAvailable") {
|
||||
%#ifdef SWIG_LONG_LONG_AVAILABLE
|
||||
SWIGINTERN int
|
||||
SWIG_AsVal_dec(long long)(JSValueRef obj, long long* val)
|
||||
{
|
||||
|
|
@ -120,6 +123,7 @@ SWIG_AsVal_dec(long long)(JSValueRef obj, long long* val)
|
|||
|
||||
return SWIG_OK;
|
||||
}
|
||||
%#endif
|
||||
}
|
||||
|
||||
/* unsigned long long */
|
||||
|
|
@ -127,19 +131,22 @@ SWIG_AsVal_dec(long long)(JSValueRef obj, long long* val)
|
|||
|
||||
%fragment(SWIG_From_frag(unsigned long long),"header",
|
||||
fragment=SWIG_From_frag(long long),
|
||||
fragment="<limits.h>") {
|
||||
fragment="SWIG_LongLongAvailable") {
|
||||
%#ifdef SWIG_LONG_LONG_AVAILABLE
|
||||
SWIGINTERN JSValueRef
|
||||
SWIG_From_dec(unsigned long long)(unsigned long long value)
|
||||
{
|
||||
return (value > LONG_MAX) ?
|
||||
JSValueMakeNumber(context, value) : JSValueMakeNumber(context, %numeric_cast(value,long));
|
||||
}
|
||||
%#endif
|
||||
}
|
||||
|
||||
%fragment(SWIG_AsVal_frag(unsigned long long),"header",
|
||||
fragment=SWIG_AsVal_frag(unsigned long),
|
||||
fragment="SWIG_CanCastAsInteger",
|
||||
fragment="<limits.h>") {
|
||||
fragment="SWIG_LongLongAvailable") {
|
||||
%#ifdef SWIG_LONG_LONG_AVAILABLE
|
||||
SWIGINTERN int
|
||||
SWIG_AsVal_dec(unsigned long long)(JSValueRef obj, unsigned long long *val)
|
||||
{
|
||||
|
|
@ -158,6 +165,7 @@ SWIG_AsVal_dec(unsigned long long)(JSValueRef obj, unsigned long long *val)
|
|||
|
||||
return SWIG_OK;
|
||||
}
|
||||
%#endif
|
||||
}
|
||||
|
||||
/* double */
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
* ---------------------------------------------------------------------------*/
|
||||
|
||||
#define SWIG_Error(code, msg) SWIG_JSC_exception(context, exception, code, msg)
|
||||
#define SWIG_exception(code, msg) SWIG_JSC_exception(context, exception, code, msg)
|
||||
#define SWIG_exception(code, msg) do { SWIG_JSC_exception(context, exception, code, msg); SWIG_fail; } while (0)
|
||||
#define SWIG_fail goto fail
|
||||
|
||||
SWIGRUNTIME void SWIG_Javascript_Raise(JSContextRef context, JSValueRef *exception, const char* type) {
|
||||
|
|
|
|||
|
|
@ -36,6 +36,7 @@ static SwigV8ReturnValue $jswrapper(const SwigV8Arguments &args) {
|
|||
SWIGV8_HANDLESCOPE();
|
||||
|
||||
SWIG_exception(SWIG_ERROR, "Class $jsname can not be instantiated");
|
||||
fail:
|
||||
SWIGV8_RETURN(SWIGV8_UNDEFINED());
|
||||
}
|
||||
%}
|
||||
|
|
@ -102,7 +103,7 @@ fail:
|
|||
%{
|
||||
if(args.Length() == $jsargcount) {
|
||||
errorHandler.err.Clear();
|
||||
#if (SWIG_V8_VERSION < 0x031903)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
|
||||
self = $jswrapper(args, errorHandler);
|
||||
if(errorHandler.err.IsEmpty()) {
|
||||
SWIGV8_ESCAPE(self);
|
||||
|
|
@ -124,13 +125,13 @@ fail:
|
|||
%fragment ("js_dtor", "templates")
|
||||
%{
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031710)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
|
||||
static void $jswrapper(v8::Persistent< v8::Value > object, void *parameter) {
|
||||
SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
|
||||
#elif (SWIG_V8_VERSION < 0x031900)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
|
||||
static void $jswrapper(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
|
||||
SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
|
||||
#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
static void $jswrapper(v8::Isolate *isolate, v8::Persistent<v8::Object> *object, SWIGV8_Proxy *proxy) {
|
||||
#else
|
||||
static void $jswrapper(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
|
||||
|
|
@ -148,11 +149,11 @@ static void $jswrapper(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &dat
|
|||
|
||||
object.Clear();
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031710)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
|
||||
object.Dispose();
|
||||
#elif (SWIG_V8_VERSION < 0x031900)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
|
||||
object.Dispose(isolate);
|
||||
#elif (SWIG_V8_VERSION < 0x032100)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
|
||||
object->Dispose(isolate);
|
||||
#else
|
||||
object->Dispose();
|
||||
|
|
@ -168,13 +169,13 @@ static void $jswrapper(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &dat
|
|||
* ----------------------------------------------------------------------------- */
|
||||
%fragment ("js_dtoroverride", "templates")
|
||||
%{
|
||||
#if (SWIG_V8_VERSION < 0x031710)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
|
||||
static void $jswrapper(v8::Persistent<v8::Value> object, void *parameter) {
|
||||
SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
|
||||
#elif (SWIG_V8_VERSION < 0x031900)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
|
||||
static void $jswrapper(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
|
||||
SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
|
||||
#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
static void $jswrapper(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
|
||||
#else
|
||||
static void $jswrapper(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
|
||||
|
|
@ -188,13 +189,13 @@ static void $jswrapper(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &dat
|
|||
}
|
||||
delete proxy;
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031710)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
|
||||
object.Dispose();
|
||||
#elif (SWIG_V8_VERSION < 0x031900)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
|
||||
object.Dispose(isolate);
|
||||
#elif (SWIG_V8_VERSION < 0x032100)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
|
||||
object->Dispose(isolate);
|
||||
#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
object->Dispose();
|
||||
#else
|
||||
object.Clear();
|
||||
|
|
@ -326,7 +327,7 @@ fail:
|
|||
|
||||
if(args.Length() == $jsargcount) {
|
||||
errorHandler.err.Clear();
|
||||
#if (SWIG_V8_VERSION < 0x031903)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
|
||||
jsresult = $jswrapper(args, errorHandler);
|
||||
if(errorHandler.err.IsEmpty()) {
|
||||
SWIGV8_ESCAPE(jsresult);
|
||||
|
|
@ -376,7 +377,7 @@ fail:
|
|||
%{
|
||||
if (SWIGTYPE_p$jsbaseclass->clientdata && !(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p$jsbaseclass->clientdata)->class_templ.IsEmpty()))
|
||||
{
|
||||
#if (SWIG_V8_VERSION < 0x031903)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
|
||||
$jsmangledname_class->Inherit(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p$jsbaseclass->clientdata)->class_templ);
|
||||
#else
|
||||
$jsmangledname_class->Inherit(
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
the complex Constructor method, and the Real and Imag complex
|
||||
accessor methods.
|
||||
|
||||
See the std_complex.i and ccomplex.i for concret examples.
|
||||
See the std_complex.i and ccomplex.i for concrete examples.
|
||||
*/
|
||||
|
||||
/* the common from converter */
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
%insert(runtime) %{
|
||||
|
||||
// Note: since 3.19 there are new CallBack types, since 03.21.9 the old ones have been removed
|
||||
#if (SWIG_V8_VERSION < 0x031903)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
|
||||
typedef v8::InvocationCallback SwigV8FunctionCallback;
|
||||
typedef v8::AccessorGetter SwigV8AccessorGetterCallback;
|
||||
typedef v8::AccessorSetter SwigV8AccessorSetterCallback;
|
||||
|
|
@ -83,6 +83,7 @@ SWIGRUNTIME void JS_veto_set_variable(v8::Local<v8::String> property, v8::Local<
|
|||
} else {
|
||||
SWIG_exception(SWIG_ERROR, msg);
|
||||
}
|
||||
fail: ;
|
||||
}
|
||||
|
||||
%} // v8_helper_functions
|
||||
|
|
|
|||
|
|
@ -112,18 +112,21 @@ int SWIG_AsVal_dec(unsigned long)(v8::Handle<v8::Value> obj, unsigned long *val)
|
|||
|
||||
%fragment(SWIG_From_frag(long long),"header",
|
||||
fragment=SWIG_From_frag(long),
|
||||
fragment="<limits.h>") {
|
||||
fragment="SWIG_LongLongAvailable") {
|
||||
%#ifdef SWIG_LONG_LONG_AVAILABLE
|
||||
SWIGINTERNINLINE
|
||||
v8::Handle<v8::Value> SWIG_From_dec(long long)(long long value)
|
||||
{
|
||||
return SWIGV8_NUMBER_NEW(value);
|
||||
}
|
||||
%#endif
|
||||
}
|
||||
|
||||
%fragment(SWIG_AsVal_frag(long long),"header",
|
||||
fragment=SWIG_AsVal_frag(long),
|
||||
fragment="SWIG_CanCastAsInteger",
|
||||
fragment="<limits.h>") {
|
||||
fragment="SWIG_LongLongAvailable") {
|
||||
%#ifdef SWIG_LONG_LONG_AVAILABLE
|
||||
SWIGINTERN
|
||||
int SWIG_AsVal_dec(long long)(v8::Handle<v8::Value> obj, long long* val)
|
||||
{
|
||||
|
|
@ -134,6 +137,7 @@ int SWIG_AsVal_dec(long long)(v8::Handle<v8::Value> obj, long long* val)
|
|||
|
||||
return SWIG_OK;
|
||||
}
|
||||
%#endif
|
||||
}
|
||||
|
||||
/* unsigned long long */
|
||||
|
|
@ -141,19 +145,22 @@ int SWIG_AsVal_dec(long long)(v8::Handle<v8::Value> obj, long long* val)
|
|||
|
||||
%fragment(SWIG_From_frag(unsigned long long),"header",
|
||||
fragment=SWIG_From_frag(long long),
|
||||
fragment="<limits.h>") {
|
||||
fragment="SWIG_LongLongAvailable") {
|
||||
%#ifdef SWIG_LONG_LONG_AVAILABLE
|
||||
SWIGINTERNINLINE
|
||||
v8::Handle<v8::Value> SWIG_From_dec(unsigned long long)(unsigned long long value)
|
||||
{
|
||||
return (value > LONG_MAX) ?
|
||||
SWIGV8_INTEGER_NEW_UNS(value) : SWIGV8_INTEGER_NEW(%numeric_cast(value,long));
|
||||
}
|
||||
%#endif
|
||||
}
|
||||
|
||||
%fragment(SWIG_AsVal_frag(unsigned long long),"header",
|
||||
fragment=SWIG_AsVal_frag(unsigned long),
|
||||
fragment="SWIG_CanCastAsInteger",
|
||||
fragment="<limits.h>") {
|
||||
fragment="SWIG_LongLongAvailable") {
|
||||
%#ifdef SWIG_LONG_LONG_AVAILABLE
|
||||
SWIGINTERN
|
||||
int SWIG_AsVal_dec(unsigned long long)(v8::Handle<v8::Value> obj, unsigned long long *val)
|
||||
{
|
||||
|
|
@ -171,6 +178,7 @@ int SWIG_AsVal_dec(unsigned long long)(v8::Handle<v8::Value> obj, unsigned long
|
|||
|
||||
return SWIG_OK;
|
||||
}
|
||||
%#endif
|
||||
}
|
||||
|
||||
/* double */
|
||||
|
|
|
|||
|
|
@ -7,13 +7,13 @@
|
|||
|
||||
#define SWIGV8_SETWEAK_VERSION 0x032224
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031803)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031803)
|
||||
#define SWIGV8_STRING_NEW2(cstr, len) v8::String::New(cstr, len)
|
||||
#else
|
||||
#define SWIGV8_STRING_NEW2(cstr, len) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), cstr, v8::String::kNormalString, len)
|
||||
#endif
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031903)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
|
||||
typedef v8::Handle<v8::Value> SwigV8ReturnValue;
|
||||
typedef v8::Arguments SwigV8Arguments;
|
||||
typedef v8::AccessorInfo SwigV8PropertyCallbackInfo;
|
||||
|
|
@ -27,11 +27,11 @@ typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo;
|
|||
#define SWIGV8_RETURN_INFO(val, info) info.GetReturnValue().Set(val); return
|
||||
#endif
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x032117)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032117)
|
||||
#define SWIGV8_HANDLESCOPE() v8::HandleScope scope
|
||||
#define SWIGV8_HANDLESCOPE_ESC() v8::HandleScope scope
|
||||
#define SWIGV8_ESCAPE(val) return scope.Close(val)
|
||||
#elif (SWIG_V8_VERSION < 0x032224)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032224)
|
||||
#define SWIGV8_HANDLESCOPE() v8::HandleScope scope(v8::Isolate::GetCurrent());
|
||||
#define SWIGV8_HANDLESCOPE_ESC() v8::HandleScope scope(v8::Isolate::GetCurrent());
|
||||
#define SWIGV8_ESCAPE(val) return scope.Close(val)
|
||||
|
|
@ -41,7 +41,7 @@ typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo;
|
|||
#define SWIGV8_ESCAPE(val) return scope.Escape(val)
|
||||
#endif
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x032224)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032224)
|
||||
#define SWIGV8_ADJUST_MEMORY(size) v8::V8::AdjustAmountOfExternalAllocatedMemory(size)
|
||||
#define SWIGV8_CURRENT_CONTEXT() v8::Context::GetCurrent()
|
||||
#define SWIGV8_THROW_EXCEPTION(err) v8::ThrowException(err)
|
||||
|
|
@ -55,7 +55,7 @@ typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo;
|
|||
#define SWIGV8_SYMBOL_NEW(sym) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sym)
|
||||
#endif
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x032318)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032318)
|
||||
#define SWIGV8_ARRAY_NEW() v8::Array::New()
|
||||
#define SWIGV8_BOOLEAN_NEW(bool) v8::Boolean::New(bool)
|
||||
#define SWIGV8_EXTERNAL_NEW(val) v8::External::New(val)
|
||||
|
|
@ -83,9 +83,9 @@ typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo;
|
|||
#define SWIGV8_NULL() v8::Null(v8::Isolate::GetCurrent())
|
||||
#endif
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031710)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
|
||||
#define SWIGV8_SET_CLASS_TEMPL(class_templ, class) class_templ = v8::Persistent<v8::FunctionTemplate>::New(class);
|
||||
#elif (SWIG_V8_VERSION < 0x031900)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
|
||||
#define SWIGV8_SET_CLASS_TEMPL(class_templ, class) class_templ = v8::Persistent<v8::FunctionTemplate>::New(v8::Isolate::GetCurrent(), class);
|
||||
#else
|
||||
#define SWIGV8_SET_CLASS_TEMPL(class_templ, class) class_templ.Reset(v8::Isolate::GetCurrent(), class);
|
||||
|
|
@ -97,7 +97,7 @@ typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo;
|
|||
* ---------------------------------------------------------------------------*/
|
||||
|
||||
#define SWIG_Error(code, msg) SWIGV8_ErrorHandler.error(code, msg)
|
||||
#define SWIG_exception(code, msg) SWIGV8_ErrorHandler.error(code, msg)
|
||||
#define SWIG_exception(code, msg) do { SWIGV8_ErrorHandler.error(code, msg); SWIG_fail; } while (0)
|
||||
#define SWIG_fail goto fail
|
||||
#define SWIGV8_OVERLOAD false
|
||||
|
||||
|
|
@ -156,13 +156,13 @@ public:
|
|||
};
|
||||
|
||||
~SWIGV8_Proxy() {
|
||||
#if (SWIG_V8_VERSION < 0x031710)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
|
||||
handle.ClearWeak();
|
||||
handle.Dispose();
|
||||
#elif (SWIG_V8_VERSION < 0x032100)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
|
||||
handle.ClearWeak(v8::Isolate::GetCurrent());
|
||||
handle.Dispose(v8::Isolate::GetCurrent());
|
||||
#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
handle.ClearWeak();
|
||||
handle.Dispose();
|
||||
#else
|
||||
|
|
@ -170,7 +170,7 @@ public:
|
|||
handle.Reset();
|
||||
#endif
|
||||
|
||||
#if (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
handle.Clear();
|
||||
#endif
|
||||
|
||||
|
|
@ -187,11 +187,11 @@ class SWIGV8_ClientData {
|
|||
public:
|
||||
v8::Persistent<v8::FunctionTemplate> class_templ;
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031710)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
|
||||
void (*dtor) (v8::Persistent< v8::Value> object, void *parameter);
|
||||
#elif (SWIG_V8_VERSION < 0x031900)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
|
||||
void (*dtor) (v8::Isolate *isolate, v8::Persistent< v8::Value> object, void *parameter);
|
||||
#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
void (*dtor) (v8::Isolate *isolate, v8::Persistent< v8::Object > *object, SWIGV8_Proxy *proxy);
|
||||
#else
|
||||
void (*dtor) (const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data);
|
||||
|
|
@ -205,7 +205,7 @@ SWIGRUNTIME int SWIG_V8_ConvertInstancePtr(v8::Handle<v8::Object> objRef, void *
|
|||
|
||||
if(objRef->InternalFieldCount() < 1) return SWIG_ERROR;
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031511)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031511)
|
||||
v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0);
|
||||
SWIGV8_Proxy *cdata = static_cast<SWIGV8_Proxy *>(v8::External::Unwrap(cdataRef));
|
||||
#else
|
||||
|
|
@ -233,13 +233,13 @@ SWIGRUNTIME int SWIG_V8_ConvertInstancePtr(v8::Handle<v8::Object> objRef, void *
|
|||
}
|
||||
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031710)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
|
||||
SWIGRUNTIME void SWIGV8_Proxy_DefaultDtor(v8::Persistent< v8::Value > object, void *parameter) {
|
||||
SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
|
||||
#elif (SWIG_V8_VERSION < 0x031900)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
|
||||
SWIGRUNTIME void SWIGV8_Proxy_DefaultDtor(v8::Isolate *, v8::Persistent< v8::Value > object, void *parameter) {
|
||||
SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
|
||||
#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
SWIGRUNTIME void SWIGV8_Proxy_DefaultDtor(v8::Isolate *, v8::Persistent< v8::Object > *object, SWIGV8_Proxy *proxy) {
|
||||
#else
|
||||
SWIGRUNTIME void SWIGV8_Proxy_DefaultDtor(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
|
||||
|
|
@ -257,7 +257,7 @@ SWIGRUNTIME int SWIG_V8_GetInstancePtr(v8::Handle<v8::Value> valRef, void **ptr)
|
|||
|
||||
if(objRef->InternalFieldCount() < 1) return SWIG_ERROR;
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031511)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031511)
|
||||
v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0);
|
||||
SWIGV8_Proxy *cdata = static_cast<SWIGV8_Proxy *>(v8::External::Unwrap(cdataRef));
|
||||
#else
|
||||
|
|
@ -279,34 +279,34 @@ SWIGRUNTIME void SWIGV8_SetPrivateData(v8::Handle<v8::Object> obj, void *ptr, sw
|
|||
cdata->swigCMemOwn = (flags & SWIG_POINTER_OWN) ? 1 : 0;
|
||||
cdata->info = info;
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031511)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031511)
|
||||
obj->SetPointerInInternalField(0, cdata);
|
||||
#else
|
||||
obj->SetAlignedPointerInInternalField(0, cdata);
|
||||
#endif
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031710)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
|
||||
cdata->handle = v8::Persistent<v8::Object>::New(obj);
|
||||
#elif (SWIG_V8_VERSION < 0x031900)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
|
||||
cdata->handle = v8::Persistent<v8::Object>::New(v8::Isolate::GetCurrent(), obj);
|
||||
#else
|
||||
cdata->handle.Reset(v8::Isolate::GetCurrent(), obj);
|
||||
#endif
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031710)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
|
||||
// clientdata must be set for owned data as we need to register the dtor
|
||||
if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
|
||||
cdata->handle.MakeWeak(cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
|
||||
} else {
|
||||
cdata->handle.MakeWeak(cdata, SWIGV8_Proxy_DefaultDtor);
|
||||
}
|
||||
#elif (SWIG_V8_VERSION < 0x031918)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031918)
|
||||
if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
|
||||
cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
|
||||
} else {
|
||||
cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, SWIGV8_Proxy_DefaultDtor);
|
||||
}
|
||||
#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
|
||||
cdata->handle.MakeWeak(cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
|
||||
} else {
|
||||
|
|
@ -320,9 +320,9 @@ SWIGRUNTIME void SWIGV8_SetPrivateData(v8::Handle<v8::Object> obj, void *ptr, sw
|
|||
}
|
||||
#endif
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031710)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
|
||||
cdata->handle.MarkIndependent();
|
||||
#elif (SWIG_V8_VERSION < 0x032100)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
|
||||
cdata->handle.MarkIndependent(v8::Isolate::GetCurrent());
|
||||
#else
|
||||
cdata->handle.MarkIndependent();
|
||||
|
|
@ -351,15 +351,15 @@ SWIGRUNTIME v8::Handle<v8::Value> SWIG_V8_NewPointerObj(void *ptr, swig_type_inf
|
|||
v8::Handle<v8::FunctionTemplate> class_templ;
|
||||
|
||||
if (ptr == NULL) {
|
||||
#if (SWIG_V8_VERSION < 0x031903)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
|
||||
SWIGV8_ESCAPE(SWIGV8_NULL());
|
||||
#else
|
||||
v8::Local<v8::Primitive> result = SWIGV8_NULL();
|
||||
SWIGV8_ESCAPE(result);
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031903)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
|
||||
if(info->clientdata != 0) {
|
||||
class_templ = ((SWIGV8_ClientData*) info->clientdata)->class_templ;
|
||||
} else {
|
||||
|
|
@ -483,7 +483,7 @@ swig_type_info *SwigV8Packed_UnpackData(v8::Handle<v8::Value> valRef, void *ptr,
|
|||
|
||||
v8::Handle<v8::Object> objRef = valRef->ToObject();
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031511)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031511)
|
||||
v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0);
|
||||
sobj = static_cast<SwigV8PackedData*>(v8::External::Unwrap(cdataRef));
|
||||
#else
|
||||
|
|
@ -511,13 +511,13 @@ int SWIGV8_ConvertPacked(v8::Handle<v8::Value> valRef, void *ptr, size_t sz, swi
|
|||
return SWIG_OK;
|
||||
}
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031710)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
|
||||
SWIGRUNTIME void _wrap_SwigV8PackedData_delete(v8::Persistent< v8::Value > object, void *parameter) {
|
||||
SwigV8PackedData *cdata = static_cast<SwigV8PackedData *>(parameter);
|
||||
#elif (SWIG_V8_VERSION < 0x031900)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
|
||||
SWIGRUNTIME void _wrap_SwigV8PackedData_delete(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
|
||||
SwigV8PackedData *cdata = static_cast<SwigV8PackedData *>(parameter);
|
||||
#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
SWIGRUNTIME void _wrap_SwigV8PackedData_delete(v8::Isolate *isolate, v8::Persistent<v8::Object> *object, SwigV8PackedData *cdata) {
|
||||
#else
|
||||
SWIGRUNTIME void _wrap_SwigV8PackedData_delete(const v8::WeakCallbackData<v8::Object, SwigV8PackedData> &data) {
|
||||
|
|
@ -527,15 +527,15 @@ SWIGRUNTIME void _wrap_SwigV8PackedData_delete(const v8::WeakCallbackData<v8::Ob
|
|||
|
||||
delete cdata;
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031710)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
|
||||
object.Clear();
|
||||
object.Dispose();
|
||||
#elif (SWIG_V8_VERSION < 0x031900)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
|
||||
object.Clear();
|
||||
object.Dispose(isolate);
|
||||
#elif (SWIG_V8_VERSION < 0x032100)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
|
||||
object->Dispose(isolate);
|
||||
#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
object->Dispose();
|
||||
#else
|
||||
object.Clear();
|
||||
|
|
@ -552,35 +552,35 @@ v8::Handle<v8::Value> SWIGV8_NewPackedObj(void *data, size_t size, swig_type_inf
|
|||
|
||||
obj->SetHiddenValue(SWIGV8_STRING_NEW("__swig__packed_data__"), SWIGV8_BOOLEAN_NEW(true));
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031511)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031511)
|
||||
obj->SetPointerInInternalField(0, cdata);
|
||||
#else
|
||||
obj->SetAlignedPointerInInternalField(0, cdata);
|
||||
#endif
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031710)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
|
||||
cdata->handle = v8::Persistent<v8::Object>::New(obj);
|
||||
#elif (SWIG_V8_VERSION < 0x031900)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
|
||||
cdata->handle = v8::Persistent<v8::Object>::New(v8::Isolate::GetCurrent(), obj);
|
||||
#else
|
||||
cdata->handle.Reset(v8::Isolate::GetCurrent(), obj);
|
||||
#endif
|
||||
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031710)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
|
||||
cdata->handle.MakeWeak(cdata, _wrap_SwigV8PackedData_delete);
|
||||
#elif (SWIG_V8_VERSION < 0x031918)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031918)
|
||||
cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, _wrap_SwigV8PackedData_delete);
|
||||
#elif (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
|
||||
cdata->handle.MakeWeak(cdata, _wrap_SwigV8PackedData_delete);
|
||||
#else
|
||||
cdata->handle.SetWeak(cdata, _wrap_SwigV8PackedData_delete);
|
||||
// v8::V8::SetWeak(&cdata->handle, cdata, _wrap_SwigV8PackedData_delete);
|
||||
#endif
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031710)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
|
||||
cdata->handle.MarkIndependent();
|
||||
#elif (SWIG_V8_VERSION < 0x032100)
|
||||
#elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
|
||||
cdata->handle.MarkIndependent(v8::Isolate::GetCurrent());
|
||||
#else
|
||||
cdata->handle.MarkIndependent();
|
||||
|
|
@ -600,7 +600,7 @@ v8::Handle<v8::Value> SWIGV8_NewPackedObj(void *data, size_t size, swig_type_inf
|
|||
|
||||
SWIGRUNTIME
|
||||
|
||||
#if (SWIG_V8_VERSION < 0x031903)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
|
||||
v8::Handle<v8::Value> SWIGV8_AppendOutput(v8::Handle<v8::Value> result, v8::Handle<v8::Value> obj) {
|
||||
#else
|
||||
v8::Handle<v8::Value> SWIGV8_AppendOutput(v8::Local<v8::Value> result, v8::Handle<v8::Value> obj) {
|
||||
|
|
@ -610,11 +610,11 @@ v8::Handle<v8::Value> SWIGV8_AppendOutput(v8::Local<v8::Value> result, v8::Handl
|
|||
if (result->IsUndefined()) {
|
||||
result = SWIGV8_ARRAY_NEW();
|
||||
}
|
||||
#if (SWIG_V8_VERSION < 0x031903)
|
||||
#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
|
||||
v8::Handle<v8::Array> arr = v8::Handle<v8::Array>::Cast(result);
|
||||
#else
|
||||
v8::Local<v8::Array> arr = v8::Local<v8::Array>::Cast(result);
|
||||
#endif
|
||||
#endif
|
||||
arr->Set(arr->Length(), obj);
|
||||
|
||||
SWIGV8_ESCAPE(arr);
|
||||
|
|
|
|||
|
|
@ -5,11 +5,22 @@
|
|||
|
||||
// V8 Version Macro
|
||||
// ----------------
|
||||
// v8 does not (until now) provide a version macro - which is still discussed and may come soon.
|
||||
// Until then, we set a default version which can be overridden via command line using V8_VERSION:
|
||||
// swig -javascript -v8 -DV8_VERSION=0x031110
|
||||
//
|
||||
// v8 added version macros V8_MAJOR_VERSION, V8_MINOR_VERSION, V8_BUILD_NUMBER
|
||||
// and V8_PATCH_LEVEL in version 4.3.0. SWIG generated code uses these if
|
||||
// they are defined - to support earlier versions you can specify the V8 version
|
||||
// in use via the command line when you run SWIG:
|
||||
//
|
||||
// swig -c++ -javascript -v8 -DV8_VERSION=0x032530 example.i
|
||||
//
|
||||
// Or code in the interface file using SWIG_V8_VERSION:
|
||||
//
|
||||
// %begin %{#define SWIG_V8_VERSION 0x031110%}
|
||||
//
|
||||
// This is specified as a hex constant, but the constant is read as pairs of
|
||||
// decimal digits, so for V8 3.25.30 use constant 0x032530. This scheme can't
|
||||
// represent components > 99, but this constant is only useful for V8 < 4.3.0,
|
||||
// and no V8 versions from that era had a component > 99.
|
||||
|
||||
%define %swig_v8_define_version(version)
|
||||
%insert("runtime") %{
|
||||
|
|
|
|||
|
|
@ -806,6 +806,44 @@ SWIGINTERN int SWIG_Lua_iterate_bases(lua_State *L, swig_type_info * SWIGUNUSED
|
|||
return result;
|
||||
}
|
||||
|
||||
/* The class.get method helper, performs the lookup of class attributes.
|
||||
* It returns an error code. Number of function return values is passed inside 'ret'.
|
||||
* first_arg is not used in this function because function always has 2 arguments.
|
||||
*/
|
||||
SWIGINTERN int SWIG_Lua_class_do_get_item(lua_State *L, swig_type_info *type, int SWIGUNUSED first_arg, int *ret)
|
||||
{
|
||||
/* there should be 2 params passed in
|
||||
(1) userdata (not the meta table)
|
||||
(2) string name of the attribute
|
||||
*/
|
||||
int bases_search_result;
|
||||
int substack_start = lua_gettop(L)-2;
|
||||
assert(first_arg == substack_start+1);
|
||||
lua_checkstack(L,5);
|
||||
assert(lua_isuserdata(L,-2)); /* just in case */
|
||||
lua_getmetatable(L,-2); /* get the meta table */
|
||||
assert(lua_istable(L,-1)); /* just in case */
|
||||
/* NEW: looks for the __getitem() fn
|
||||
this is a user provided get fn */
|
||||
SWIG_Lua_get_table(L,"__getitem"); /* find the __getitem fn */
|
||||
if (lua_iscfunction(L,-1)) /* if its there */
|
||||
{ /* found it so call the fn & return its value */
|
||||
lua_pushvalue(L,substack_start+1); /* the userdata */
|
||||
lua_pushvalue(L,substack_start+2); /* the parameter */
|
||||
lua_call(L,2,1); /* 2 value in (userdata),1 out (result) */
|
||||
lua_remove(L,-2); /* stack tidy, remove metatable */
|
||||
if(ret) *ret = 1;
|
||||
return SWIG_OK;
|
||||
}
|
||||
lua_pop(L,1);
|
||||
/* Remove the metatable */
|
||||
lua_pop(L,1);
|
||||
/* Search in base classes */
|
||||
bases_search_result = SWIG_Lua_iterate_bases(L,type,substack_start+1,SWIG_Lua_class_do_get_item,ret);
|
||||
return bases_search_result; /* sorry not known */
|
||||
}
|
||||
|
||||
|
||||
/* The class.get method helper, performs the lookup of class attributes.
|
||||
* It returns an error code. Number of function return values is passed inside 'ret'.
|
||||
* first_arg is not used in this function because function always has 2 arguments.
|
||||
|
|
@ -853,19 +891,6 @@ SWIGINTERN int SWIG_Lua_class_do_get(lua_State *L, swig_type_info *type, int SW
|
|||
return SWIG_OK;
|
||||
}
|
||||
lua_pop(L,1); /* remove whatever was there */
|
||||
/* NEW: looks for the __getitem() fn
|
||||
this is a user provided get fn */
|
||||
SWIG_Lua_get_table(L,"__getitem"); /* find the __getitem fn */
|
||||
if (lua_iscfunction(L,-1)) /* if its there */
|
||||
{ /* found it so call the fn & return its value */
|
||||
lua_pushvalue(L,substack_start+1); /* the userdata */
|
||||
lua_pushvalue(L,substack_start+2); /* the parameter */
|
||||
lua_call(L,2,1); /* 2 value in (userdata),1 out (result) */
|
||||
lua_remove(L,-2); /* stack tidy, remove metatable */
|
||||
if(ret) *ret = 1;
|
||||
return SWIG_OK;
|
||||
}
|
||||
lua_pop(L,1);
|
||||
/* Remove the metatable */
|
||||
lua_pop(L,1);
|
||||
/* Search in base classes */
|
||||
|
|
@ -892,6 +917,10 @@ SWIGINTERN int SWIG_Lua_class_get(lua_State *L)
|
|||
if(result == SWIG_OK)
|
||||
return ret;
|
||||
|
||||
result = SWIG_Lua_class_do_get_item(L,type,1,&ret);
|
||||
if(result == SWIG_OK)
|
||||
return ret;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@
|
|||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%{
|
||||
#include <typeinfo>
|
||||
#include <stdexcept>
|
||||
%}
|
||||
%include <exception.i>
|
||||
|
|
@ -27,6 +28,7 @@ namespace std
|
|||
// normally objects which are thrown are returned to the interpreter as errors
|
||||
// (which potentially may have problems if they are not copied)
|
||||
// therefore all classes based upon std::exception are converted to their strings & returned as errors
|
||||
%typemap(throws) std::bad_cast "SWIG_exception(SWIG_TypeError, $1.what());"
|
||||
%typemap(throws) std::bad_exception "SWIG_exception(SWIG_RuntimeError, $1.what());"
|
||||
%typemap(throws) std::domain_error "SWIG_exception(SWIG_ValueError, $1.what());"
|
||||
%typemap(throws) std::exception "SWIG_exception(SWIG_SystemError, $1.what());"
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@
|
|||
%variable_fail(res, "$type", "$name");
|
||||
}
|
||||
if (!argp) {
|
||||
%argument_nullref("$type", $symname, $argnum);
|
||||
%variable_nullref("$type", "$name");
|
||||
} else {
|
||||
$1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
|
||||
if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
|
|
@ -126,7 +126,9 @@
|
|||
%variable_fail(res, "$type", "$name");
|
||||
}
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
|
||||
if (!argp) { %argument_nullref("$type", $symname, $argnum); }
|
||||
if (!argp) {
|
||||
%variable_nullref("$type", "$name");
|
||||
}
|
||||
if (newmem & SWIG_CAST_NEW_MEMORY) {
|
||||
tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
|
|
|
|||
|
|
@ -562,8 +562,8 @@ namespace swig {
|
|||
static int asptr(const octave_value& obj, sequence **seq) {
|
||||
if (!obj.is_defined() || Swig::swig_value_deref(obj)) {
|
||||
sequence *p;
|
||||
if (SWIG_ConvertPtr(obj,(void**)&p,
|
||||
swig::type_info<sequence>(),0) == SWIG_OK) {
|
||||
swig_type_info *descriptor = swig::type_info<sequence>();
|
||||
if (descriptor && SWIG_IsOK(SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) {
|
||||
if (seq) *seq = p;
|
||||
return SWIG_OLDOBJ;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -97,15 +97,20 @@ SWIG_AsVal_dec(bool)(const octave_value& ov, bool *val)
|
|||
|
||||
// long long
|
||||
|
||||
%fragment(SWIG_From_frag(long long),"header") {
|
||||
%fragment(SWIG_From_frag(long long),"header",
|
||||
fragment="SWIG_LongLongAvailable") {
|
||||
%#ifdef SWIG_LONG_LONG_AVAILABLE
|
||||
SWIGINTERNINLINE octave_value SWIG_From_dec(long long) (long long value)
|
||||
{
|
||||
return octave_int64(value);
|
||||
}
|
||||
%#endif
|
||||
}
|
||||
|
||||
|
||||
%fragment(SWIG_AsVal_frag(long long),"header") {
|
||||
%fragment(SWIG_AsVal_frag(long long),"header",
|
||||
fragment="SWIG_LongLongAvailable") {
|
||||
%#ifdef SWIG_LONG_LONG_AVAILABLE
|
||||
SWIGINTERN int SWIG_AsVal_dec(long long)(const octave_value& ov, long long* val)
|
||||
{
|
||||
if (!ov.is_scalar_type())
|
||||
|
|
@ -127,16 +132,22 @@ SWIG_AsVal_dec(bool)(const octave_value& ov, bool *val)
|
|||
}
|
||||
return SWIG_OK;
|
||||
}
|
||||
%#endif
|
||||
}
|
||||
|
||||
%fragment(SWIG_From_frag(unsigned long long),"header") {
|
||||
%fragment(SWIG_From_frag(unsigned long long),"header",
|
||||
fragment="SWIG_LongLongAvailable") {
|
||||
%#ifdef SWIG_LONG_LONG_AVAILABLE
|
||||
SWIGINTERNINLINE octave_value SWIG_From_dec(unsigned long long) (unsigned long long value)
|
||||
{
|
||||
return octave_uint64(value);
|
||||
}
|
||||
%#endif
|
||||
}
|
||||
|
||||
%fragment(SWIG_AsVal_frag(unsigned long long),"header") {
|
||||
%fragment(SWIG_AsVal_frag(unsigned long long),"header",
|
||||
fragment="SWIG_LongLongAvailable") {
|
||||
%#ifdef SWIG_LONG_LONG_AVAILABLE
|
||||
SWIGINTERN int SWIG_AsVal_dec(unsigned long long)(const octave_value& ov, unsigned long long* val)
|
||||
{
|
||||
if (!ov.is_scalar_type())
|
||||
|
|
@ -171,6 +182,7 @@ SWIG_AsVal_dec(bool)(const octave_value& ov, bool *val)
|
|||
}
|
||||
return SWIG_OK;
|
||||
}
|
||||
%#endif
|
||||
}
|
||||
|
||||
// double
|
||||
|
|
|
|||
|
|
@ -363,41 +363,44 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
|
|||
return octave_value_list();
|
||||
}
|
||||
|
||||
bool dispatch_unary_op(const std::string &symbol, octave_value &ret) {
|
||||
member_value_pair *m = find_member(symbol, false);
|
||||
bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const {
|
||||
octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
|
||||
member_value_pair *m = nc_this->find_member(symbol, false);
|
||||
if (!m || m->first->is_static() || m->first->is_global())
|
||||
return false;
|
||||
octave_value_list args;
|
||||
args.append(as_value());
|
||||
octave_value_list argout(member_invoke(m, args, 1));
|
||||
args.append(nc_this->as_value());
|
||||
octave_value_list argout(nc_this->member_invoke(m, args, 1));
|
||||
if (argout.length() < 1)
|
||||
return false;
|
||||
ret = argout(0);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) {
|
||||
member_value_pair *m = find_member(symbol, false);
|
||||
bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const {
|
||||
octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
|
||||
member_value_pair *m = nc_this->find_member(symbol, false);
|
||||
if (!m || m->first->is_static() || m->first->is_global())
|
||||
return false;
|
||||
octave_value_list args;
|
||||
args.append(as_value());
|
||||
args.append(nc_this->as_value());
|
||||
args.append(make_value_hack(rhs));
|
||||
octave_value_list argout(member_invoke(m, args, 1));
|
||||
octave_value_list argout(nc_this->member_invoke(m, args, 1));
|
||||
if (argout.length() < 1)
|
||||
return false;
|
||||
ret = argout(0);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) {
|
||||
member_value_pair *m = find_member(symbol, false);
|
||||
bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const {
|
||||
octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
|
||||
member_value_pair *m = nc_this->find_member(symbol, false);
|
||||
if (!m || m->first->is_static() || m->first->is_global())
|
||||
return false;
|
||||
octave_value_list args;
|
||||
args.append(as_value());
|
||||
args.append(nc_this->as_value());
|
||||
args.append(rhs);
|
||||
octave_value_list argout(member_invoke(m, args, 1));
|
||||
octave_value_list argout(nc_this->member_invoke(m, args, 1));
|
||||
if (argout.length() >= 1)
|
||||
ret = argout(0);
|
||||
return true;
|
||||
|
|
@ -459,22 +462,9 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
|
|||
}
|
||||
|
||||
dim_vector dims(void) const {
|
||||
octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
|
||||
|
||||
// Find the __dims__ method of this object
|
||||
member_value_pair *m = nc_this->find_member("__dims__", false);
|
||||
|
||||
if (!m) return dim_vector(1,1);
|
||||
|
||||
// Call the __dims__ method of this object
|
||||
octave_value_list inarg;
|
||||
inarg.append(nc_this->as_value());
|
||||
octave_value_list outarg = nc_this->member_invoke(m, inarg, 1);
|
||||
|
||||
// __dims__ should return (at least) one output argument
|
||||
if (outarg.length() < 1) return dim_vector(1,1);
|
||||
|
||||
octave_value & out = outarg(0);
|
||||
octave_value out;
|
||||
if (!dispatch_unary_op("__dims__", out))
|
||||
return dim_vector(1,1);
|
||||
|
||||
// Return value should be cell or matrix of integers
|
||||
if (out.is_cell()) {
|
||||
|
|
@ -814,20 +804,38 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
|
|||
}
|
||||
|
||||
virtual std::string string_value(bool force = false) const {
|
||||
octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
|
||||
member_value_pair *m = nc_this->find_member("__str__", false);
|
||||
if (!m) {
|
||||
error("__str__ method not defined");
|
||||
return std::string();
|
||||
octave_value ret;
|
||||
if (!dispatch_unary_op("__str__", ret)) {
|
||||
error("__str__ method not defined");
|
||||
return std::string();
|
||||
}
|
||||
octave_value_list outarg = nc_this->member_invoke(m, octave_value_list(nc_this->as_value()), 1);
|
||||
if (outarg.length() < 1 || !outarg(0).is_string()) {
|
||||
if (!ret.is_string()) {
|
||||
error("__str__ method did not return a string");
|
||||
return std::string();
|
||||
}
|
||||
return outarg(0).string_value();
|
||||
return ret.string_value();
|
||||
}
|
||||
|
||||
virtual double scalar_value(bool frc_str_conv = false) const {
|
||||
octave_value ret;
|
||||
if (!dispatch_unary_op("__float__", ret)) {
|
||||
error("__float__ method not defined");
|
||||
}
|
||||
return ret.scalar_value();
|
||||
}
|
||||
|
||||
#if SWIG_OCTAVE_PREREQ(3,8,0)
|
||||
virtual octave_value map(octave_base_value::unary_mapper_t umap) const {
|
||||
const std::string opname = std::string("__") + octave_base_value::get_umap_name(umap) + std::string("__");
|
||||
octave_value ret;
|
||||
if (!dispatch_unary_op(opname, ret)) {
|
||||
error((opname + std::string(" method not found")).c_str());
|
||||
return octave_value();
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if SWIG_OCTAVE_PREREQ(3,3,52)
|
||||
virtual octave_map map_value() const {
|
||||
return octave_map();
|
||||
|
|
@ -982,10 +990,11 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
|
|||
}
|
||||
|
||||
#if SWIG_OCTAVE_PREREQ(4,0,0)
|
||||
void print(std::ostream &os, bool pr_as_read_syntax = false) {
|
||||
void print(std::ostream &os, bool pr_as_read_syntax = false)
|
||||
#else
|
||||
void print(std::ostream &os, bool pr_as_read_syntax = false) const {
|
||||
void print(std::ostream &os, bool pr_as_read_syntax = false) const
|
||||
#endif
|
||||
{
|
||||
if (is_string()) {
|
||||
os << string_value();
|
||||
return;
|
||||
|
|
@ -1080,6 +1089,14 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
|
|||
virtual std::string string_value(bool force = false) const
|
||||
{ return ptr->string_value(force); }
|
||||
|
||||
virtual double scalar_value(bool frc_str_conv = false) const
|
||||
{ return ptr->scalar_value(frc_str_conv); }
|
||||
|
||||
#if SWIG_OCTAVE_PREREQ(3,8,0)
|
||||
virtual octave_value map(octave_base_value::unary_mapper_t umap) const
|
||||
{ return ptr->map(umap); }
|
||||
#endif
|
||||
|
||||
#if SWIG_OCTAVE_PREREQ(3,3,52)
|
||||
virtual octave_map map_value() const
|
||||
{ return ptr->map_value(); }
|
||||
|
|
@ -1137,7 +1154,17 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
|
|||
#endif
|
||||
{ return ptr->print(os, pr_as_read_syntax); }
|
||||
|
||||
virtual type_conv_info numeric_conversion_function(void) const {
|
||||
return octave_base_value::type_conv_info (default_numeric_conversion_function,
|
||||
octave_scalar::static_type_id ());
|
||||
}
|
||||
|
||||
private:
|
||||
static octave_base_value *default_numeric_conversion_function (const octave_base_value& a) {
|
||||
const octave_swig_ref& v = dynamic_cast<const octave_swig_ref&>(a);
|
||||
return new octave_scalar(v.scalar_value());
|
||||
}
|
||||
|
||||
#if !SWIG_OCTAVE_PREREQ(4,0,0)
|
||||
DECLARE_OCTAVE_ALLOCATOR;
|
||||
#endif
|
||||
|
|
@ -1178,10 +1205,11 @@ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
|
|||
}
|
||||
|
||||
#if SWIG_OCTAVE_PREREQ(4,0,0)
|
||||
void print(std::ostream &os, bool pr_as_read_syntax = false) {
|
||||
void print(std::ostream &os, bool pr_as_read_syntax = false)
|
||||
#else
|
||||
void print(std::ostream &os, bool pr_as_read_syntax = false) const {
|
||||
void print(std::ostream &os, bool pr_as_read_syntax = false) const
|
||||
#endif
|
||||
{
|
||||
indent(os);
|
||||
os << "swig packed type: name = " << (type ? type->name : std::string()) << ", len = " << buf.size(); newline(os);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@
|
|||
#include <octave/dynamic-ld.h>
|
||||
#include <octave/oct-env.h>
|
||||
#include <octave/oct-map.h>
|
||||
#include <octave/ov-scalar.h>
|
||||
#include <octave/ov-fcn-handle.h>
|
||||
#include <octave/parse.h>
|
||||
#include <octave/toplev.h>
|
||||
|
|
@ -182,6 +183,23 @@ DEFUN_DLD( swig_this, args, nargout, swig_this_usage ) {
|
|||
return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
|
||||
}
|
||||
|
||||
static const char *const swig_octave_prereq_usage = "-*- texinfo -*- \n\
|
||||
@deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
|
||||
Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
|
||||
@end deftypefn";
|
||||
|
||||
DEFUN_DLD( swig_octave_prereq, args, nargout, swig_octave_prereq_usage ) {
|
||||
if (args.length() != 3) {
|
||||
error("swig_octave_prereq: must be called with 3 arguments");
|
||||
return octave_value_list();
|
||||
}
|
||||
const int major = args(0).int_value();
|
||||
const int minor = args(1).int_value();
|
||||
const int patch = args(2).int_value();
|
||||
const bool prereq = SWIG_OCTAVE_PREREQ(major, minor, patch);
|
||||
return octave_value(prereq);
|
||||
}
|
||||
|
||||
static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
|
||||
@deftypefn {Loadable Module} {} " SWIG_name_d "\n\
|
||||
Loads the SWIG-generated module `" SWIG_name_d "'.\n\
|
||||
|
|
@ -235,6 +253,9 @@ DEFUN_DLD( SWIG_name, args, nargout, SWIG_name_usage ) {
|
|||
|
||||
octave_function *me = octave_call_stack::current();
|
||||
|
||||
if (!SWIG_Octave_InstallFunction(me, "subclass")) {
|
||||
return octave_value_list();
|
||||
}
|
||||
if (!SWIG_Octave_InstallFunction(me, "swig_type")) {
|
||||
return octave_value_list();
|
||||
}
|
||||
|
|
@ -244,7 +265,7 @@ DEFUN_DLD( SWIG_name, args, nargout, SWIG_name_usage ) {
|
|||
if (!SWIG_Octave_InstallFunction(me, "swig_this")) {
|
||||
return octave_value_list();
|
||||
}
|
||||
if (!SWIG_Octave_InstallFunction(me, "subclass")) {
|
||||
if (!SWIG_Octave_InstallFunction(me, "swig_octave_prereq")) {
|
||||
return octave_value_list();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -42,7 +42,8 @@ namespace swig {
|
|||
struct traits_asptr {
|
||||
static int asptr(const octave_value& obj, Type **val) {
|
||||
Type *p;
|
||||
int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
|
||||
swig_type_info *descriptor = type_info<Type>();
|
||||
int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
|
||||
if (SWIG_IsOK(res)) {
|
||||
if (val) *val = p;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,17 +11,17 @@
|
|||
fragment=SWIG_From_frag(Type),
|
||||
fragment="StdTraits") {
|
||||
namespace swig {
|
||||
template <> struct traits<Type > {
|
||||
template <> struct traits< Type > {
|
||||
typedef value_category category;
|
||||
static const char* type_name() { return #Type; }
|
||||
};
|
||||
template <> struct traits_asval<Type > {
|
||||
};
|
||||
template <> struct traits_asval< Type > {
|
||||
typedef Type value_type;
|
||||
static int asval(octave_value obj, value_type *val) {
|
||||
static int asval(octave_value obj, value_type *val) {
|
||||
return SWIG_AsVal(Type)(obj, val);
|
||||
}
|
||||
};
|
||||
template <> struct traits_from<Type > {
|
||||
template <> struct traits_from< Type > {
|
||||
typedef Type value_type;
|
||||
static octave_value from(const value_type& val) {
|
||||
return SWIG_From(Type)(val);
|
||||
|
|
@ -44,13 +44,13 @@ namespace swig {
|
|||
fragment=SWIG_From_frag(int),
|
||||
fragment="StdTraits") {
|
||||
namespace swig {
|
||||
template <> struct traits_asval<Type > {
|
||||
template <> struct traits_asval< Type > {
|
||||
typedef Type value_type;
|
||||
static int asval(octave_value obj, value_type *val) {
|
||||
static int asval(octave_value obj, value_type *val) {
|
||||
return SWIG_AsVal(int)(obj, (int *)val);
|
||||
}
|
||||
};
|
||||
template <> struct traits_from<Type > {
|
||||
template <> struct traits_from< Type > {
|
||||
typedef Type value_type;
|
||||
static octave_value from(const value_type& val) {
|
||||
return SWIG_From(int)((int)val);
|
||||
|
|
|
|||
|
|
@ -98,7 +98,8 @@
|
|||
res = traits_asptr_stdseq<std::map<K,T>, std::pair<K, T> >::asptr(items, val);
|
||||
} else {
|
||||
map_type *p;
|
||||
res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<map_type>(),0);
|
||||
swig_type_info *descriptor = swig::type_info<map_type>();
|
||||
res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
|
||||
if (SWIG_IsOK(res) && val) *val = p;
|
||||
}
|
||||
return res;
|
||||
|
|
|
|||
|
|
@ -47,7 +47,8 @@
|
|||
return get_pair(c(0),c(1),val);
|
||||
} else {
|
||||
value_type *p;
|
||||
int res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<value_type>(),0);
|
||||
swig_type_info *descriptor = swig::type_info<value_type>();
|
||||
int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
|
||||
if (SWIG_IsOK(res) && val)
|
||||
*val = *p;
|
||||
return res;
|
||||
|
|
@ -100,7 +101,8 @@
|
|||
return get_pair(c(0),c(1),val);
|
||||
} else {
|
||||
value_type *p;
|
||||
int res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<value_type>(),0);
|
||||
swig_type_info *descriptor = swig::type_info<value_type>();
|
||||
int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
|
||||
if (SWIG_IsOK(res) && val)
|
||||
*val = p;
|
||||
return res;
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@ extern "C"
|
|||
XS(SWIG_init) {
|
||||
dXSARGS;
|
||||
int i;
|
||||
(void)items;
|
||||
|
||||
SWIG_InitializeModule(0);
|
||||
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ SWIGINTERNINLINE SV *
|
|||
SWIG_From_dec(long)(long value)
|
||||
{
|
||||
SV *sv;
|
||||
if (value >= IV_MIN && value <= IV_MAX)
|
||||
if (IVSIZE >= sizeof(value) || (value >= IV_MIN && value <= IV_MAX))
|
||||
sv = newSViv(value);
|
||||
else
|
||||
sv = newSVpvf("%ld", value);
|
||||
|
|
@ -46,20 +46,22 @@ SWIG_From_dec(long)(long value)
|
|||
}
|
||||
|
||||
%fragment(SWIG_AsVal_frag(long),"header",
|
||||
fragment="<limits.h>",
|
||||
fragment="<stdlib.h>",
|
||||
fragment="SWIG_CanCastAsInteger") {
|
||||
SWIGINTERN int
|
||||
SWIG_AsVal_dec(long)(SV *obj, long* val)
|
||||
{
|
||||
if (SvUOK(obj)) {
|
||||
UV v = SvUV(obj);
|
||||
if (v <= LONG_MAX) {
|
||||
if (UVSIZE < sizeof(*val) || v <= LONG_MAX) {
|
||||
if (val) *val = v;
|
||||
return SWIG_OK;
|
||||
}
|
||||
return SWIG_OverflowError;
|
||||
} else if (SvIOK(obj)) {
|
||||
IV v = SvIV(obj);
|
||||
if (v >= LONG_MIN && v <= LONG_MAX) {
|
||||
if (IVSIZE <= sizeof(*val) || (v >= LONG_MIN && v <= LONG_MAX)) {
|
||||
if(val) *val = v;
|
||||
return SWIG_OK;
|
||||
}
|
||||
|
|
@ -102,7 +104,7 @@ SWIGINTERNINLINE SV *
|
|||
SWIG_From_dec(unsigned long)(unsigned long value)
|
||||
{
|
||||
SV *sv;
|
||||
if (value <= UV_MAX)
|
||||
if (UVSIZE >= sizeof(value) || value <= UV_MAX)
|
||||
sv = newSVuv(value);
|
||||
else
|
||||
sv = newSVpvf("%lu", value);
|
||||
|
|
@ -111,20 +113,22 @@ SWIG_From_dec(unsigned long)(unsigned long value)
|
|||
}
|
||||
|
||||
%fragment(SWIG_AsVal_frag(unsigned long),"header",
|
||||
fragment="<limits.h>",
|
||||
fragment="<stdlib.h>",
|
||||
fragment="SWIG_CanCastAsInteger") {
|
||||
SWIGINTERN int
|
||||
SWIG_AsVal_dec(unsigned long)(SV *obj, unsigned long *val)
|
||||
{
|
||||
if (SvUOK(obj)) {
|
||||
UV v = SvUV(obj);
|
||||
if (v <= ULONG_MAX) {
|
||||
if (UVSIZE <= sizeof(*val) || v <= ULONG_MAX) {
|
||||
if (val) *val = v;
|
||||
return SWIG_OK;
|
||||
}
|
||||
return SWIG_OverflowError;
|
||||
} else if (SvIOK(obj)) {
|
||||
IV v = SvIV(obj);
|
||||
if (v >= 0 && v <= ULONG_MAX) {
|
||||
if (v >= 0 && (IVSIZE <= sizeof(*val) || v <= ULONG_MAX)) {
|
||||
if (val) *val = v;
|
||||
return SWIG_OK;
|
||||
}
|
||||
|
|
@ -163,14 +167,14 @@ SWIG_AsVal_dec(unsigned long)(SV *obj, unsigned long *val)
|
|||
/* long long */
|
||||
|
||||
%fragment(SWIG_From_frag(long long),"header",
|
||||
fragment=SWIG_From_frag(long),
|
||||
fragment="<limits.h>",
|
||||
fragment="SWIG_LongLongAvailable",
|
||||
fragment="<stdio.h>") {
|
||||
%#ifdef SWIG_LONG_LONG_AVAILABLE
|
||||
SWIGINTERNINLINE SV *
|
||||
SWIG_From_dec(long long)(long long value)
|
||||
{
|
||||
SV *sv;
|
||||
if (value >= IV_MIN && value <= IV_MAX)
|
||||
if (IVSIZE >= sizeof(value) || (value >= IV_MIN && value <= IV_MAX))
|
||||
sv = newSViv((IV)(value));
|
||||
else {
|
||||
//sv = newSVpvf("%lld", value); doesn't work in non 64bit Perl
|
||||
|
|
@ -180,26 +184,28 @@ SWIG_From_dec(long long)(long long value)
|
|||
}
|
||||
return sv_2mortal(sv);
|
||||
}
|
||||
%#endif
|
||||
}
|
||||
|
||||
%fragment(SWIG_AsVal_frag(long long),"header",
|
||||
fragment="<limits.h>",
|
||||
fragment="SWIG_LongLongAvailable",
|
||||
fragment="<stdlib.h>",
|
||||
fragment="SWIG_CanCastAsInteger") {
|
||||
|
||||
%#ifdef SWIG_LONG_LONG_AVAILABLE
|
||||
SWIGINTERN int
|
||||
SWIG_AsVal_dec(long long)(SV *obj, long long *val)
|
||||
{
|
||||
if (SvUOK(obj)) {
|
||||
UV v = SvUV(obj);
|
||||
if (v < LLONG_MAX) {
|
||||
/* pretty sure this could allow v == LLONG MAX */
|
||||
if (UVSIZE < sizeof(*val) || v < LLONG_MAX) {
|
||||
if (val) *val = v;
|
||||
return SWIG_OK;
|
||||
}
|
||||
return SWIG_OverflowError;
|
||||
} else if (SvIOK(obj)) {
|
||||
IV v = SvIV(obj);
|
||||
if (v >= LLONG_MIN && v <= LLONG_MAX) {
|
||||
if (IVSIZE <= sizeof(*val) || (v >= LLONG_MIN && v <= LLONG_MAX)) {
|
||||
if (val) *val = v;
|
||||
return SWIG_OK;
|
||||
}
|
||||
|
|
@ -235,19 +241,20 @@ SWIG_AsVal_dec(long long)(SV *obj, long long *val)
|
|||
}
|
||||
return SWIG_TypeError;
|
||||
}
|
||||
%#endif
|
||||
}
|
||||
|
||||
/* unsigned long long */
|
||||
|
||||
%fragment(SWIG_From_frag(unsigned long long),"header",
|
||||
fragment=SWIG_From_frag(long long),
|
||||
fragment="<limits.h>",
|
||||
fragment="SWIG_LongLongAvailable",
|
||||
fragment="<stdio.h>") {
|
||||
%#ifdef SWIG_LONG_LONG_AVAILABLE
|
||||
SWIGINTERNINLINE SV *
|
||||
SWIG_From_dec(unsigned long long)(unsigned long long value)
|
||||
{
|
||||
SV *sv;
|
||||
if (value <= UV_MAX)
|
||||
if (UVSIZE >= sizeof(value) || value <= UV_MAX)
|
||||
sv = newSVuv((UV)(value));
|
||||
else {
|
||||
//sv = newSVpvf("%llu", value); doesn't work in non 64bit Perl
|
||||
|
|
@ -257,21 +264,25 @@ SWIG_From_dec(unsigned long long)(unsigned long long value)
|
|||
}
|
||||
return sv_2mortal(sv);
|
||||
}
|
||||
%#endif
|
||||
}
|
||||
|
||||
%fragment(SWIG_AsVal_frag(unsigned long long),"header",
|
||||
fragment="<limits.h>",
|
||||
fragment="SWIG_LongLongAvailable",
|
||||
fragment="<stdlib.h>",
|
||||
fragment="SWIG_CanCastAsInteger") {
|
||||
%#ifdef SWIG_LONG_LONG_AVAILABLE
|
||||
SWIGINTERN int
|
||||
SWIG_AsVal_dec(unsigned long long)(SV *obj, unsigned long long *val)
|
||||
{
|
||||
if (SvUOK(obj)) {
|
||||
/* pretty sure this should be conditional on
|
||||
* (UVSIZE <= sizeof(*val) || v <= ULLONG_MAX) */
|
||||
if (val) *val = SvUV(obj);
|
||||
return SWIG_OK;
|
||||
} else if (SvIOK(obj)) {
|
||||
IV v = SvIV(obj);
|
||||
if (v >= 0 && v <= ULLONG_MAX) {
|
||||
if (v >= 0 && (IVSIZE <= sizeof(*val) || v <= ULLONG_MAX)) {
|
||||
if (val) *val = v;
|
||||
return SWIG_OK;
|
||||
} else {
|
||||
|
|
@ -307,6 +318,7 @@ SWIG_AsVal_dec(unsigned long long)(SV *obj, unsigned long long *val)
|
|||
}
|
||||
return SWIG_TypeError;
|
||||
}
|
||||
%#endif
|
||||
}
|
||||
|
||||
/* double */
|
||||
|
|
|
|||
|
|
@ -144,9 +144,9 @@ typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
|
|||
|
||||
# ifdef PERL_OBJECT
|
||||
# define SWIG_croak_null() SWIG_Perl_croak_null(pPerl)
|
||||
static void SWIG_Perl_croak_null(CPerlObj *pPerl)
|
||||
static void SWIGUNUSED SWIG_Perl_croak_null(CPerlObj *pPerl)
|
||||
# else
|
||||
static void SWIG_croak_null()
|
||||
static void SWIGUNUSED SWIG_croak_null()
|
||||
# endif
|
||||
{
|
||||
SV *err = get_sv("@", GV_ADD);
|
||||
|
|
|
|||
|
|
@ -106,7 +106,7 @@ namespace std {
|
|||
}
|
||||
}
|
||||
%typemap(out) list<T> {
|
||||
std::list<T>::const_iterator i;
|
||||
std::list< T >::const_iterator i;
|
||||
unsigned int j;
|
||||
int len = $1.size();
|
||||
SV **svs = new SV*[len];
|
||||
|
|
@ -125,7 +125,7 @@ namespace std {
|
|||
%typecheck(SWIG_TYPECHECK_LIST) list<T> {
|
||||
{
|
||||
/* wrapped list? */
|
||||
std::list<T >* v;
|
||||
std::list< T >* v;
|
||||
if (SWIG_ConvertPtr($input,(void **) &v,
|
||||
$1_&descriptor,0) != -1) {
|
||||
$1 = 1;
|
||||
|
|
@ -158,7 +158,7 @@ namespace std {
|
|||
const list<T>* {
|
||||
{
|
||||
/* wrapped list? */
|
||||
std::list<T >* v;
|
||||
std::list< T >* v;
|
||||
if (SWIG_ConvertPtr($input,(void **) &v,
|
||||
$1_descriptor,0) != -1) {
|
||||
$1 = 1;
|
||||
|
|
@ -265,7 +265,7 @@ namespace std {
|
|||
}
|
||||
}
|
||||
%typemap(out) list<T> {
|
||||
std::list<T>::const_iterator i;
|
||||
std::list< T >::const_iterator i;
|
||||
unsigned int j;
|
||||
int len = $1.size();
|
||||
SV **svs = new SV*[len];
|
||||
|
|
@ -282,7 +282,7 @@ namespace std {
|
|||
%typecheck(SWIG_TYPECHECK_LIST) list<T> {
|
||||
{
|
||||
/* wrapped list? */
|
||||
std::list<T >* v;
|
||||
std::list< T >* v;
|
||||
if (SWIG_ConvertPtr($input,(void **) &v,
|
||||
$1_&descriptor,0) != -1) {
|
||||
$1 = 1;
|
||||
|
|
@ -313,7 +313,7 @@ namespace std {
|
|||
const list<T>* {
|
||||
{
|
||||
/* wrapped list? */
|
||||
std::list<T >* v;
|
||||
std::list< T >* v;
|
||||
if (SWIG_ConvertPtr($input,(void **) &v,
|
||||
$1_descriptor,0) != -1) {
|
||||
$1 = 1;
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ namespace std {
|
|||
void clear();
|
||||
%extend {
|
||||
const T& get(const K& key) throw (std::out_of_range) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
std::map< K, T >::iterator i = self->find(key);
|
||||
if (i != self->end())
|
||||
return i->second;
|
||||
else
|
||||
|
|
@ -45,14 +45,14 @@ namespace std {
|
|||
(*self)[key] = x;
|
||||
}
|
||||
void del(const K& key) throw (std::out_of_range) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
std::map< K, T >::iterator i = self->find(key);
|
||||
if (i != self->end())
|
||||
self->erase(i);
|
||||
else
|
||||
throw std::out_of_range("key not found");
|
||||
}
|
||||
bool has_key(const K& key) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
std::map< K, T >::iterator i = self->find(key);
|
||||
return i != self->end();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -119,7 +119,7 @@ namespace std {
|
|||
%typecheck(SWIG_TYPECHECK_VECTOR) vector<T> {
|
||||
{
|
||||
/* wrapped vector? */
|
||||
std::vector<T >* v;
|
||||
std::vector< T >* v;
|
||||
if (SWIG_ConvertPtr($input,(void **) &v,
|
||||
$&1_descriptor,0) != -1) {
|
||||
$1 = 1;
|
||||
|
|
@ -151,7 +151,7 @@ namespace std {
|
|||
const vector<T>* {
|
||||
{
|
||||
/* wrapped vector? */
|
||||
std::vector<T >* v;
|
||||
std::vector< T >* v;
|
||||
if (SWIG_ConvertPtr($input,(void **) &v,
|
||||
$1_descriptor,0) != -1) {
|
||||
$1 = 1;
|
||||
|
|
@ -292,7 +292,7 @@ namespace std {
|
|||
%typecheck(SWIG_TYPECHECK_VECTOR) vector<T *> {
|
||||
{
|
||||
/* wrapped vector? */
|
||||
std::vector<T *>* v;
|
||||
std::vector< T *>* v;
|
||||
int res = SWIG_ConvertPtr($input,(void **) &v, $&1_descriptor,0);
|
||||
if (SWIG_IsOK(res)) {
|
||||
$1 = 1;
|
||||
|
|
@ -323,7 +323,7 @@ namespace std {
|
|||
%typecheck(SWIG_TYPECHECK_VECTOR) const vector<T *>&,const vector<T *>* {
|
||||
{
|
||||
/* wrapped vector? */
|
||||
std::vector<T *> *v;
|
||||
std::vector< T *> *v;
|
||||
int res = SWIG_ConvertPtr($input,%as_voidptrptr(&v), $1_descriptor,0);
|
||||
if (SWIG_IsOK(res)) {
|
||||
$1 = 1;
|
||||
|
|
@ -466,7 +466,7 @@ namespace std {
|
|||
%typecheck(SWIG_TYPECHECK_VECTOR) vector<T> {
|
||||
{
|
||||
/* wrapped vector? */
|
||||
std::vector<T >* v;
|
||||
std::vector< T >* v;
|
||||
if (SWIG_ConvertPtr($input,(void **) &v,
|
||||
$&1_descriptor,0) != -1) {
|
||||
$1 = 1;
|
||||
|
|
@ -496,7 +496,7 @@ namespace std {
|
|||
const vector<T>* {
|
||||
{
|
||||
/* wrapped vector? */
|
||||
std::vector<T >* v;
|
||||
std::vector< T >* v;
|
||||
if (SWIG_ConvertPtr($input,(void **) &v,
|
||||
$1_descriptor,0) != -1) {
|
||||
$1 = 1;
|
||||
|
|
|
|||
|
|
@ -12,10 +12,12 @@
|
|||
unsigned long,
|
||||
unsigned char,
|
||||
signed char,
|
||||
bool,
|
||||
enum SWIGTYPE
|
||||
"SWIG_LONG_CONSTANT($symname, ($1_type)$value);";
|
||||
|
||||
%typemap(consttab) bool
|
||||
"SWIG_BOOL_CONSTANT($symname, ($1_type)$value);";
|
||||
|
||||
%typemap(consttab) float,
|
||||
double
|
||||
"SWIG_DOUBLE_CONSTANT($symname, $value);";
|
||||
|
|
@ -33,18 +35,13 @@
|
|||
SWIGTYPE &,
|
||||
SWIGTYPE &&,
|
||||
SWIGTYPE [] {
|
||||
zval *z_var;
|
||||
zend_constant c;
|
||||
size_t len = sizeof("$symname") - 1;
|
||||
MAKE_STD_ZVAL(z_var);
|
||||
SWIG_SetPointerZval(z_var, (void*)$value, $1_descriptor, 0);
|
||||
c.value = *z_var;
|
||||
SWIG_SetPointerZval(&c.value, (void*)$value, $1_descriptor, 0);
|
||||
zval_copy_ctor(&c.value);
|
||||
c.name = zend_strndup("$symname", len);
|
||||
c.name_len = len+1;
|
||||
c.flags = CONST_CS | CONST_PERSISTENT;
|
||||
c.name = zend_string_init("$symname", sizeof("$symname") - 1, 0);
|
||||
c.flags = CONST_CS;
|
||||
c.module_number = module_number;
|
||||
zend_register_constant( &c TSRMLS_CC );
|
||||
zend_register_constant(&c);
|
||||
}
|
||||
|
||||
/* Handled as a global variable. */
|
||||
|
|
|
|||
|
|
@ -80,30 +80,30 @@ namespace Swig {
|
|||
|
||||
class Director {
|
||||
protected:
|
||||
zval *swig_self;
|
||||
// "mutable" so we can get a non-const pointer to it in const methods.
|
||||
mutable zval swig_self;
|
||||
typedef std::map<void *, GCItem_var> swig_ownership_map;
|
||||
mutable swig_ownership_map swig_owner;
|
||||
#ifdef ZTS
|
||||
// Store the ZTS context so it's available when C++ calls back to PHP.
|
||||
void *** swig_zts_ctx;
|
||||
#endif
|
||||
public:
|
||||
Director(zval *self TSRMLS_DC) : swig_self(self) {
|
||||
TSRMLS_SET_CTX(swig_zts_ctx);
|
||||
Director(zval *self) {
|
||||
ZVAL_COPY_VALUE(&swig_self, self);
|
||||
}
|
||||
|
||||
static bool swig_is_overridden_method(char *cname, char *lc_fname TSRMLS_DC) {
|
||||
zend_class_entry **ce;
|
||||
zend_function *mptr;
|
||||
|
||||
if (zend_lookup_class(cname, strlen(cname), &ce TSRMLS_CC) != SUCCESS) {
|
||||
return false;
|
||||
static bool swig_is_overridden_method(const char *cname, const char *lc_fname) {
|
||||
bool result = false;
|
||||
zend_string * cname_str = zend_string_init(cname, strlen(cname), 0);
|
||||
zend_class_entry *ce = zend_lookup_class(cname_str);
|
||||
if (ce) {
|
||||
zval * mptr = zend_hash_str_find(&ce->function_table, lc_fname, strlen(lc_fname));
|
||||
if (mptr) {
|
||||
// common.scope points to zend_class_entry for the declaring class,
|
||||
// and there's only one of those per class, so we can just use a
|
||||
// pointer compare here.
|
||||
result = Z_FUNC_P(mptr)->common.scope != ce;
|
||||
}
|
||||
}
|
||||
if (zend_hash_find(&(*ce)->function_table, lc_fname, strlen(lc_fname) + 1, (void **) &mptr) != SUCCESS) {
|
||||
return false;
|
||||
}
|
||||
// common.scope points to the declaring class
|
||||
return strcmp(mptr->common.scope->name, cname);
|
||||
zend_string_release(cname_str);
|
||||
return result;
|
||||
}
|
||||
|
||||
template <typename Type>
|
||||
|
|
@ -119,8 +119,8 @@ namespace Swig {
|
|||
protected:
|
||||
std::string swig_msg;
|
||||
public:
|
||||
DirectorException(int code, const char *hdr, const char *msg TSRMLS_DC) : swig_msg(hdr) {
|
||||
if (msg[0]) {
|
||||
DirectorException(int code, const char *hdr, const char *msg) : swig_msg(hdr) {
|
||||
if (msg && msg[0]) {
|
||||
swig_msg += " ";
|
||||
swig_msg += msg;
|
||||
}
|
||||
|
|
@ -135,20 +135,20 @@ namespace Swig {
|
|||
return swig_msg.c_str();
|
||||
}
|
||||
|
||||
static void raise(int code, const char *hdr, const char *msg TSRMLS_DC) {
|
||||
throw DirectorException(code, hdr, msg TSRMLS_CC);
|
||||
static void raise(int code, const char *hdr, const char *msg) {
|
||||
throw DirectorException(code, hdr, msg);
|
||||
}
|
||||
};
|
||||
|
||||
/* attempt to call a pure virtual method via a director method */
|
||||
class DirectorPureVirtualException : public DirectorException {
|
||||
public:
|
||||
DirectorPureVirtualException(const char *msg TSRMLS_DC)
|
||||
: DirectorException(E_ERROR, "SWIG director pure virtual method called", msg TSRMLS_CC) {
|
||||
DirectorPureVirtualException(const char *msg)
|
||||
: DirectorException(E_ERROR, "SWIG director pure virtual method called", msg) {
|
||||
}
|
||||
|
||||
static void raise(const char *msg TSRMLS_DC) {
|
||||
throw DirectorPureVirtualException(msg TSRMLS_CC);
|
||||
static void raise(const char *msg) {
|
||||
throw DirectorPureVirtualException(msg);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -156,18 +156,18 @@ namespace Swig {
|
|||
class DirectorMethodException : public DirectorException
|
||||
{
|
||||
public:
|
||||
DirectorMethodException(const char *msg TSRMLS_DC)
|
||||
: DirectorException(E_ERROR, "SWIG director method error", msg TSRMLS_CC) {
|
||||
DirectorMethodException()
|
||||
: DirectorException(E_ERROR, "SWIG director method error", NULL) {
|
||||
}
|
||||
|
||||
static void raise(const char *msg TSRMLS_DC) {
|
||||
throw DirectorMethodException(msg TSRMLS_CC);
|
||||
DirectorMethodException(const char *msg)
|
||||
: DirectorException(E_ERROR, "SWIG director method error", msg) {
|
||||
}
|
||||
|
||||
static void raise(const char *msg) {
|
||||
throw DirectorMethodException(msg);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// DirectorMethodException() is documented to be callable with no parameters
|
||||
// so use a macro to insert TSRMLS_CC so any ZTS context gets passed.
|
||||
#define DirectorMethodException() DirectorMethodException("" TSRMLS_CC)
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -4,20 +4,22 @@
|
|||
* Global variables - add the variable to PHP
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%typemap(varinit) char *,
|
||||
char []
|
||||
%typemap(varinit) char *
|
||||
{
|
||||
zval *z_var;
|
||||
MAKE_STD_ZVAL(z_var);
|
||||
z_var->type = IS_STRING;
|
||||
if($1) {
|
||||
z_var->value.str.val = estrdup($1);
|
||||
z_var->value.str.len = strlen($1);
|
||||
zval z_var;
|
||||
if ($1) {
|
||||
ZVAL_STRING(&z_var, $1);
|
||||
} else {
|
||||
z_var->value.str.val = 0;
|
||||
z_var->value.str.len = 0;
|
||||
ZVAL_STR(&z_var, ZSTR_EMPTY_ALLOC());
|
||||
}
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
|
||||
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
|
||||
}
|
||||
|
||||
%typemap(varinit) char []
|
||||
{
|
||||
zval z_var;
|
||||
ZVAL_STRING(&z_var, $1);
|
||||
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
|
||||
}
|
||||
|
||||
%typemap(varinit) int,
|
||||
|
|
@ -31,139 +33,98 @@
|
|||
unsigned char,
|
||||
enum SWIGTYPE
|
||||
{
|
||||
zval *z_var;
|
||||
MAKE_STD_ZVAL(z_var);
|
||||
z_var->type = IS_LONG;
|
||||
z_var->value.lval = (long)$1;
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
|
||||
zval z_var;
|
||||
ZVAL_LONG(&z_var, (long)$1);
|
||||
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
|
||||
}
|
||||
|
||||
%typemap(varinit) bool
|
||||
{
|
||||
zval *z_var;
|
||||
MAKE_STD_ZVAL(z_var);
|
||||
z_var->type = IS_BOOL;
|
||||
z_var->value.lval = ($1)?1:0;
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
|
||||
zval z_var;
|
||||
ZVAL_BOOL(&z_var, ($1)?1:0);
|
||||
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
|
||||
}
|
||||
|
||||
%typemap(varinit) float, double
|
||||
{
|
||||
zval *z_var;
|
||||
MAKE_STD_ZVAL(z_var);
|
||||
z_var->type = IS_DOUBLE;
|
||||
z_var->value.dval = $1;
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var,
|
||||
sizeof(zval *), NULL);
|
||||
zval z_var;
|
||||
ZVAL_DOUBLE(&z_var, (double)$1);
|
||||
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
|
||||
}
|
||||
|
||||
%typemap(varinit) char
|
||||
{
|
||||
zval *z_var;
|
||||
char c[2];
|
||||
MAKE_STD_ZVAL(z_var);
|
||||
c[0] = $1;
|
||||
c[1] = 0;
|
||||
z_var->type = IS_STRING;
|
||||
z_var->value.str.val = estrndup(c, 1);
|
||||
z_var->value.str.len = 1;
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var,
|
||||
sizeof(zval *), NULL);
|
||||
zval z_var;
|
||||
char c = $1;
|
||||
ZVAL_STRINGL(&z_var, &c, 1);
|
||||
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
|
||||
}
|
||||
|
||||
%typemap(varinit) SWIGTYPE *, SWIGTYPE []
|
||||
{
|
||||
zval *z_var;
|
||||
MAKE_STD_ZVAL(z_var);
|
||||
SWIG_SetPointerZval(z_var, (void*)$1, $1_descriptor, 0);
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var,
|
||||
sizeof(zval *), NULL);
|
||||
zval z_var;
|
||||
SWIG_SetPointerZval(&z_var, (void*)$1, $1_descriptor, 0);
|
||||
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
|
||||
}
|
||||
|
||||
%typemap(varinit) SWIGTYPE, SWIGTYPE &, SWIGTYPE &&
|
||||
{
|
||||
zval *z_var;
|
||||
|
||||
MAKE_STD_ZVAL(z_var);
|
||||
SWIG_SetPointerZval(z_var, (void*)&$1, $&1_descriptor, 0);
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void*)&z_var,
|
||||
sizeof(zval *), NULL);
|
||||
zval z_var;
|
||||
SWIG_SetPointerZval(&z_var, (void*)&$1, $&1_descriptor, 0);
|
||||
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
|
||||
}
|
||||
|
||||
%typemap(varinit) char [ANY]
|
||||
{
|
||||
zval *z_var;
|
||||
MAKE_STD_ZVAL(z_var);
|
||||
z_var->type = IS_STRING;
|
||||
if ($1) {
|
||||
/* varinit char [ANY] */
|
||||
ZVAL_STRINGL(z_var,(char*)$1, $1_dim0, 1);
|
||||
}
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void*)&z_var, sizeof(zval *), NULL);
|
||||
zval z_var;
|
||||
/* varinit char [ANY] */
|
||||
ZVAL_STRINGL(&z_var, $1, $1_dim0);
|
||||
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var);
|
||||
}
|
||||
|
||||
%typemap(varinit, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
|
||||
{
|
||||
zval resource;
|
||||
void * p = emalloc(sizeof($1));
|
||||
memcpy(p, &$1, sizeof($1));
|
||||
zval * resource;
|
||||
MAKE_STD_ZVAL(resource);
|
||||
ZEND_REGISTER_RESOURCE(resource, p, swig_member_ptr);
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void*)&resource, sizeof(zval *), NULL);
|
||||
ZVAL_RES(&resource, zend_register_resource(p, swig_member_ptr));
|
||||
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &resource);
|
||||
}
|
||||
|
||||
%typemap(varin) int, unsigned int, short, unsigned short, long, unsigned long, signed char, unsigned char, enum SWIGTYPE
|
||||
{
|
||||
zval **z_var;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
convert_to_long_ex(z_var);
|
||||
if ($1 != ($1_ltype)((*z_var)->value.lval)) {
|
||||
$1 = Z_LVAL_PP(z_var);
|
||||
}
|
||||
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
|
||||
$1 = zval_get_long(z_var);
|
||||
}
|
||||
|
||||
%typemap(varin) bool
|
||||
{
|
||||
zval **z_var;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
convert_to_boolean_ex(z_var);
|
||||
if ($1 != ($1_ltype)((*z_var)->value.lval)) {
|
||||
$1 = Z_LVAL_PP(z_var);
|
||||
}
|
||||
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
|
||||
convert_to_boolean(z_var);
|
||||
$1 = (Z_TYPE_P(z_var) == IS_TRUE);
|
||||
}
|
||||
|
||||
%typemap(varin) double,float
|
||||
{
|
||||
zval **z_var;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
convert_to_double_ex(z_var);
|
||||
if ($1 != ($1_ltype)((*z_var)->value.dval)) {
|
||||
$1 = Z_DVAL_PP(z_var);
|
||||
}
|
||||
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
|
||||
$1 = zval_get_double(z_var);
|
||||
}
|
||||
|
||||
%typemap(varin) char
|
||||
{
|
||||
zval **z_var;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
convert_to_string_ex(z_var);
|
||||
if ($1 != *((*z_var)->value.str.val)) {
|
||||
$1 = *((*z_var)->value.str.val);
|
||||
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
|
||||
convert_to_string(z_var);
|
||||
if ($1 != Z_STRVAL_P(z_var)[0]) {
|
||||
$1 = Z_STRVAL_P(z_var)[0];
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(varin) char *
|
||||
{
|
||||
zval **z_var;
|
||||
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
|
||||
char *s1;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
convert_to_string_ex(z_var);
|
||||
s1 = Z_STRVAL_PP(z_var);
|
||||
convert_to_string(z_var);
|
||||
s1 = Z_STRVAL_P(z_var);
|
||||
if ((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) {
|
||||
if (s1)
|
||||
$1 = estrdup(s1);
|
||||
|
|
@ -175,11 +136,9 @@
|
|||
|
||||
%typemap(varin) SWIGTYPE []
|
||||
{
|
||||
zval **z_var;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
if($1) {
|
||||
SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, $owner);
|
||||
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
|
||||
SWIG_SetPointerZval(z_var, (void*)$1, $1_descriptor, $owner);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -188,8 +147,8 @@
|
|||
zval **z_var;
|
||||
char *s1;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
s1 = Z_STRVAL_PP(z_var);
|
||||
zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1, (void**)&z_var);
|
||||
s1 = Z_STRVAL_P(z_var);
|
||||
if ((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) {
|
||||
if (s1)
|
||||
strncpy($1, s1, $1_dim0);
|
||||
|
|
@ -198,11 +157,11 @@
|
|||
|
||||
%typemap(varin) SWIGTYPE
|
||||
{
|
||||
zval **z_var;
|
||||
zval *z_var;
|
||||
$&1_ltype _temp;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
if (SWIG_ConvertPtr(*z_var, (void**)&_temp, $&1_descriptor, 0) < 0) {
|
||||
z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
|
||||
if (SWIG_ConvertPtr(z_var, (void**)&_temp, $&1_descriptor, 0) < 0) {
|
||||
SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor");
|
||||
}
|
||||
|
||||
|
|
@ -212,11 +171,11 @@
|
|||
|
||||
%typemap(varin) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&
|
||||
{
|
||||
zval **z_var;
|
||||
zval *z_var;
|
||||
$1_ltype _temp;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
if (SWIG_ConvertPtr(*z_var, (void **)&_temp, $1_descriptor, 0) < 0) {
|
||||
z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
|
||||
if (SWIG_ConvertPtr(z_var, (void **)&_temp, $1_descriptor, 0) < 0) {
|
||||
SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor");
|
||||
}
|
||||
|
||||
|
|
@ -225,10 +184,8 @@
|
|||
|
||||
%typemap(varin, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
|
||||
{
|
||||
zval **z_var;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
void * p = (void*)zend_fetch_resource(*z_var TSRMLS_CC, -1, SWIG_MEMBER_PTR, NULL, 1, swig_member_ptr);
|
||||
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
|
||||
void * p = (void*)zend_fetch_resource_ex(z_var, SWIG_MEMBER_PTR, swig_member_ptr);
|
||||
memcpy(&$1, p, sizeof($1));
|
||||
}
|
||||
|
||||
|
|
@ -242,114 +199,96 @@
|
|||
unsigned char,
|
||||
enum SWIGTYPE
|
||||
{
|
||||
zval **z_var;
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
if($1 != ($1_ltype)((*z_var)->value.lval)) {
|
||||
(*z_var)->value.lval = (long)$1;
|
||||
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
|
||||
if ($1 != ($1_ltype)Z_LVAL_P(z_var)) {
|
||||
z_var->value.lval = (long)$1;
|
||||
}
|
||||
}
|
||||
|
||||
//SAMFIX need to cast zval->type, what if zend-hash_find fails? etc?
|
||||
%typemap(varout) bool
|
||||
{
|
||||
zval **z_var;
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
if($1 != ($1_ltype)((*z_var)->value.lval)) {
|
||||
(*z_var)->value.lval = (long)$1;
|
||||
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
|
||||
if ($1 != ($1_ltype)Z_LVAL_P(z_var)) {
|
||||
z_var->value.lval = (long)$1;
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(varout) double, float
|
||||
{
|
||||
zval **z_var;
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
if($1 != ($1_ltype)((*z_var)->value.dval)) {
|
||||
(*z_var)->value.dval = (double)$1;
|
||||
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
|
||||
if ($1 != ($1_ltype)Z_DVAL_P(z_var)) {
|
||||
z_var->value.dval = (double)$1;
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(varout) char
|
||||
{
|
||||
zval **z_var;
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
if($1 != *((*z_var)->value.str.val)) {
|
||||
char c[2];
|
||||
efree((*z_var)->value.str.val);
|
||||
c[0] = $1;
|
||||
c[1] = 0;
|
||||
(*z_var)->value.str.val = estrdup(c);
|
||||
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
|
||||
char c = $1;
|
||||
if ($1 != Z_STRVAL_P(z_val)[0]) {
|
||||
ZVAL_STRING(z_var, &c);
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(varout) char *
|
||||
{
|
||||
zval **z_var;
|
||||
char *s1;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
s1 = Z_STRVAL_PP(z_var);
|
||||
if((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) {
|
||||
if(s1)
|
||||
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
|
||||
const char *s1 = Z_STRVAL_P(z_var);
|
||||
if ((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) {
|
||||
if (s1)
|
||||
efree(s1);
|
||||
if($1) {
|
||||
(*z_var)->value.str.val = estrdup($1);
|
||||
(*z_var)->value.str.len = strlen($1) + 1;
|
||||
if ($1) {
|
||||
(z_var)->value.str.val = estrdup($1);
|
||||
(z_var)->value.str.len = strlen($1) + 1;
|
||||
} else {
|
||||
(*z_var)->value.str.val = 0;
|
||||
(*z_var)->value.str.len = 0;
|
||||
(z_var)->value.str.val = 0;
|
||||
(z_var)->value.str.len = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(varout) SWIGTYPE
|
||||
{
|
||||
zval **z_var;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
SWIG_SetPointerZval(*z_var, (void*)&$1, $&1_descriptor, 0);
|
||||
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
|
||||
SWIG_SetPointerZval(z_var, (void*)&$1, $&1_descriptor, 0);
|
||||
}
|
||||
|
||||
%typemap(varout) SWIGTYPE []
|
||||
{
|
||||
zval **z_var;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
if($1)
|
||||
SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, 0);
|
||||
if($1) {
|
||||
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
|
||||
SWIG_SetPointerZval(z_var, (void*)$1, $1_descriptor, 0);
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(varout) char [ANY]
|
||||
{
|
||||
zval **z_var;
|
||||
char *s1;
|
||||
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
|
||||
const char *s1 = Z_STRVAL_P(z_var);
|
||||
deliberate error cos this code looks bogus to me
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
s1 = Z_STRVAL_PP(z_var);
|
||||
if((s1 == NULL) || strcmp(s1, $1)) {
|
||||
if($1) {
|
||||
(*z_var)->value.str.val = estrdup($1);
|
||||
(*z_var)->value.str.len = strlen($1) + 1;
|
||||
if ((s1 == NULL) || strcmp(s1, $1)) {
|
||||
if ($1) {
|
||||
(z_var)->value.str.val = estrdup($1);
|
||||
(z_var)->value.str.len = strlen($1) + 1;
|
||||
} else {
|
||||
(*z_var)->value.str.val = 0;
|
||||
(*z_var)->value.str.len = 0;
|
||||
(z_var)->value.str.val = 0;
|
||||
(z_var)->value.str.len = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(varout) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&
|
||||
{
|
||||
zval **z_var;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, 0);
|
||||
zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1);
|
||||
SWIG_SetPointerZval(z_var, (void*)$1, $1_descriptor, 0);
|
||||
}
|
||||
|
||||
%typemap(varout, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
|
||||
{
|
||||
zval resource;
|
||||
void * p = emalloc(sizeof($1));
|
||||
memcpy(p, &$1, sizeof($1));
|
||||
zval * resource;
|
||||
MAKE_STD_ZVAL(resource);
|
||||
ZEND_REGISTER_RESOURCE(resource, p, swig_member_ptr);
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void*)&resource, sizeof(zval *), NULL);
|
||||
ZVAL_RES(&resource, zend_register_resource(p, swig_member_ptr));
|
||||
zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &resource);
|
||||
}
|
||||
|
|
|
|||
266
Lib/php/php.swg
266
Lib/php/php.swg
|
|
@ -71,72 +71,72 @@
|
|||
// char array can be in/out, though the passed string may not be big enough...
|
||||
// so we have to size it
|
||||
%typemap(in) char[ANY]
|
||||
{
|
||||
convert_to_string_ex($input);
|
||||
$1 = ($1_ltype) Z_STRVAL_PP($input);
|
||||
}
|
||||
%{
|
||||
convert_to_string(&$input);
|
||||
$1 = ($1_ltype) Z_STRVAL($input);
|
||||
%}
|
||||
|
||||
%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) {
|
||||
convert_to_string_ex($input);
|
||||
$1 = ($1_ltype) Z_STRVAL_PP($input);
|
||||
$2 = ($2_ltype) Z_STRLEN_PP($input);
|
||||
}
|
||||
%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) %{
|
||||
convert_to_string(&$input);
|
||||
$1 = ($1_ltype) Z_STRVAL($input);
|
||||
$2 = ($2_ltype) Z_STRLEN($input);
|
||||
%}
|
||||
|
||||
/* Object passed by value. Convert to a pointer */
|
||||
%typemap(in) SWIGTYPE ($&1_ltype tmp)
|
||||
{
|
||||
if(SWIG_ConvertPtr(*$input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL) {
|
||||
%{
|
||||
if (SWIG_ConvertPtr(&$input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL) {
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
|
||||
}
|
||||
$1 = *tmp;
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(directorout) SWIGTYPE ($&1_ltype tmp)
|
||||
{
|
||||
%{
|
||||
/* If exit was via exception, PHP NULL is returned so skip the conversion. */
|
||||
if (!EG(exception)) {
|
||||
if(SWIG_ConvertPtr($input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL)
|
||||
if (SWIG_ConvertPtr($input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL)
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
|
||||
$result = *tmp;
|
||||
}
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(in) SWIGTYPE *,
|
||||
SWIGTYPE []
|
||||
{
|
||||
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0) {
|
||||
%{
|
||||
if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0) {
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
|
||||
}
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(in) SWIGTYPE &
|
||||
{
|
||||
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) {
|
||||
%{
|
||||
if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) {
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
|
||||
}
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(in) SWIGTYPE &&
|
||||
{
|
||||
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) {
|
||||
%{
|
||||
if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) {
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
|
||||
}
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(in) SWIGTYPE *const& ($*ltype temp)
|
||||
{
|
||||
if(SWIG_ConvertPtr(*$input, (void **) &temp, $*1_descriptor, 0) < 0) {
|
||||
%{
|
||||
if (SWIG_ConvertPtr(&$input, (void **) &temp, $*1_descriptor, 0) < 0) {
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $*1_descriptor");
|
||||
}
|
||||
$1 = ($1_ltype)&temp;
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(in) SWIGTYPE *DISOWN
|
||||
{
|
||||
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, SWIG_POINTER_DISOWN ) < 0) {
|
||||
%{
|
||||
if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, SWIG_POINTER_DISOWN ) < 0) {
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
|
||||
}
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(argout) SWIGTYPE *,
|
||||
SWIGTYPE [],
|
||||
|
|
@ -144,14 +144,14 @@
|
|||
SWIGTYPE &&;
|
||||
|
||||
%typemap(in) void *
|
||||
{
|
||||
if(SWIG_ConvertPtr(*$input, (void **) &$1, 0, 0) < 0) {
|
||||
%{
|
||||
if (SWIG_ConvertPtr(&$input, (void **) &$1, 0, 0) < 0) {
|
||||
/* Allow NULL from php for void* */
|
||||
if ((*$input)->type==IS_NULL) $1=0;
|
||||
if (Z_ISNULL($input)) $1=0;
|
||||
else
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
|
||||
}
|
||||
}
|
||||
%}
|
||||
|
||||
/* Special case when void* is passed by reference so it can be made to point
|
||||
to opaque api structs */
|
||||
|
|
@ -160,9 +160,9 @@
|
|||
{
|
||||
/* If they pass NULL by reference, make it into a void*
|
||||
This bit should go in arginit if arginit support init-ing scripting args */
|
||||
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0) {
|
||||
if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0) {
|
||||
/* So... we didn't get a ref or ptr, but we'll accept NULL by reference */
|
||||
if (!((*$input)->type==IS_NULL && PZVAL_IS_REF(*$input))) {
|
||||
if (!(Z_ISREF($input) && Z_ISNULL_P(Z_REFVAL($input)))) {
|
||||
/* wasn't a pre/ref/thing, OR anything like an int thing */
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument $arg of $symname.");
|
||||
}
|
||||
|
|
@ -170,7 +170,7 @@
|
|||
force=0;
|
||||
if (arg1==NULL) {
|
||||
#ifdef __cplusplus
|
||||
ptr=new $*1_ltype;
|
||||
ptr=new $*1_ltype();
|
||||
#else
|
||||
ptr=($*1_ltype) calloc(1,sizeof($*1_ltype));
|
||||
#endif
|
||||
|
|
@ -181,11 +181,11 @@
|
|||
}
|
||||
%typemap(argout) void **,
|
||||
void *&
|
||||
{
|
||||
%{
|
||||
if (force$argnum) {
|
||||
SWIG_SetPointerZval( *$input, (void*) ptr$argnum, $*1_descriptor, 1);
|
||||
SWIG_SetPointerZval(&$input, (void*) ptr$argnum, $*1_descriptor, 1);
|
||||
}
|
||||
}
|
||||
%}
|
||||
|
||||
/* Typemap for output values */
|
||||
|
||||
|
|
@ -199,35 +199,33 @@
|
|||
unsigned char,
|
||||
bool,
|
||||
size_t
|
||||
{
|
||||
ZVAL_LONG(return_value,$1);
|
||||
}
|
||||
%{
|
||||
RETVAL_LONG($1);
|
||||
%}
|
||||
|
||||
%typemap(out) enum SWIGTYPE
|
||||
{
|
||||
ZVAL_LONG(return_value, (long)$1);
|
||||
}
|
||||
%{
|
||||
RETVAL_LONG((long)$1);
|
||||
%}
|
||||
|
||||
%typemap(out) long long
|
||||
%{
|
||||
if ((long long)LONG_MIN <= $1 && $1 <= (long long)LONG_MAX) {
|
||||
return_value->value.lval = (long)($1);
|
||||
return_value->type = IS_LONG;
|
||||
RETVAL_LONG((long)($1));
|
||||
} else {
|
||||
char temp[256];
|
||||
sprintf(temp, "%lld", (long long)$1);
|
||||
ZVAL_STRING(return_value, temp, 1);
|
||||
RETVAL_STRING(temp);
|
||||
}
|
||||
%}
|
||||
%typemap(out) unsigned long long
|
||||
%{
|
||||
if ($1 <= (unsigned long long)LONG_MAX) {
|
||||
return_value->value.lval = (long)($1);
|
||||
return_value->type = IS_LONG;
|
||||
RETVAL_LONG((long)($1));
|
||||
} else {
|
||||
char temp[256];
|
||||
sprintf(temp, "%llu", (unsigned long long)$1);
|
||||
ZVAL_STRING(return_value, temp, 1);
|
||||
RETVAL_STRING(temp);
|
||||
}
|
||||
%}
|
||||
|
||||
|
|
@ -241,40 +239,38 @@
|
|||
const unsigned char &,
|
||||
const bool &,
|
||||
const size_t &
|
||||
{
|
||||
ZVAL_LONG(return_value,*$1);
|
||||
}
|
||||
%{
|
||||
RETVAL_LONG(*$1);
|
||||
%}
|
||||
|
||||
%typemap(out) const enum SWIGTYPE &
|
||||
{
|
||||
ZVAL_LONG(return_value, (long)*$1);
|
||||
}
|
||||
%{
|
||||
RETVAL_LONG((long)*$1);
|
||||
%}
|
||||
|
||||
%typemap(out) const enum SWIGTYPE &&
|
||||
{
|
||||
ZVAL_LONG(return_value, (long)*$1);
|
||||
}
|
||||
%{
|
||||
RETVAL_LONG((long)*$1);
|
||||
%}
|
||||
|
||||
%typemap(out) const long long &
|
||||
%{
|
||||
if ((long long)LONG_MIN <= *$1 && *$1 <= (long long)LONG_MAX) {
|
||||
return_value->value.lval = (long)(*$1);
|
||||
return_value->type = IS_LONG;
|
||||
RETVAL_LONG((long)(*$1));
|
||||
} else {
|
||||
char temp[256];
|
||||
sprintf(temp, "%lld", (long long)(*$1));
|
||||
ZVAL_STRING(return_value, temp, 1);
|
||||
RETVAL_STRING(temp);
|
||||
}
|
||||
%}
|
||||
%typemap(out) const unsigned long long &
|
||||
%{
|
||||
if (*$1 <= (unsigned long long)LONG_MAX) {
|
||||
return_value->value.lval = (long)(*$1);
|
||||
return_value->type = IS_LONG;
|
||||
RETVAL_LONG((long)(*$1));
|
||||
} else {
|
||||
char temp[256];
|
||||
sprintf(temp, "%llu", (unsigned long long)(*$1));
|
||||
ZVAL_STRING(return_value, temp, 1);
|
||||
RETVAL_STRING(temp);
|
||||
}
|
||||
%}
|
||||
|
||||
|
|
@ -288,85 +284,85 @@
|
|||
unsigned char,
|
||||
size_t,
|
||||
enum SWIGTYPE
|
||||
{
|
||||
%{
|
||||
ZVAL_LONG($input,$1);
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(directorin) enum SWIGTYPE
|
||||
{
|
||||
%{
|
||||
ZVAL_LONG($input, (long)$1_name);
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(directorin) char *, char []
|
||||
{
|
||||
%{
|
||||
if(!$1) {
|
||||
ZVAL_NULL($input);
|
||||
} else {
|
||||
ZVAL_STRING($input, (char *)$1, 1);
|
||||
ZVAL_STRING($input, (const char*)$1);
|
||||
}
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(out) bool
|
||||
{
|
||||
ZVAL_BOOL(return_value,($1)?1:0);
|
||||
}
|
||||
%{
|
||||
RETVAL_BOOL(($1) ? 1 : 0);
|
||||
%}
|
||||
|
||||
%typemap(out) const bool &
|
||||
{
|
||||
ZVAL_BOOL(return_value,(*$1)?1:0);
|
||||
}
|
||||
%{
|
||||
RETVAL_BOOL((*$1) ? 1 : 0);
|
||||
%}
|
||||
|
||||
%typemap(directorin) bool
|
||||
{
|
||||
ZVAL_BOOL($input,($1)?1:0);
|
||||
}
|
||||
%{
|
||||
ZVAL_BOOL($input, ($1) ? 1 : 0);
|
||||
%}
|
||||
|
||||
%typemap(out) float,
|
||||
double
|
||||
{
|
||||
ZVAL_DOUBLE(return_value,$1);
|
||||
}
|
||||
%{
|
||||
RETVAL_DOUBLE($1);
|
||||
%}
|
||||
|
||||
%typemap(out) const float &,
|
||||
const double &
|
||||
{
|
||||
ZVAL_DOUBLE(return_value,*$1);
|
||||
}
|
||||
%{
|
||||
RETVAL_DOUBLE(*$1);
|
||||
%}
|
||||
|
||||
%typemap(directorin) float,
|
||||
double
|
||||
{
|
||||
ZVAL_DOUBLE($input,$1);
|
||||
}
|
||||
%{
|
||||
ZVAL_DOUBLE($input, $1);
|
||||
%}
|
||||
|
||||
%typemap(out) char
|
||||
{
|
||||
ZVAL_STRINGL(return_value,&$1, 1, 1);
|
||||
}
|
||||
%{
|
||||
RETVAL_STRINGL(&$1, 1);
|
||||
%}
|
||||
|
||||
%typemap(out) const char &
|
||||
{
|
||||
ZVAL_STRINGL(return_value,&*$1, 1, 1);
|
||||
}
|
||||
%{
|
||||
RETVAL_STRINGL(&*$1, 1);
|
||||
%}
|
||||
|
||||
%typemap(out) char *,
|
||||
char []
|
||||
{
|
||||
if(!$1) {
|
||||
ZVAL_NULL(return_value);
|
||||
} else {
|
||||
ZVAL_STRING(return_value, (char *)$1, 1);
|
||||
}
|
||||
}
|
||||
%{
|
||||
if (!$1) {
|
||||
RETVAL_NULL();
|
||||
} else {
|
||||
RETVAL_STRING((const char *)$1);
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(out) char *&
|
||||
{
|
||||
if(!*$1) {
|
||||
ZVAL_NULL(return_value);
|
||||
} else {
|
||||
ZVAL_STRING(return_value, (char *)*$1, 1);
|
||||
}
|
||||
}
|
||||
%{
|
||||
if (!*$1) {
|
||||
RETVAL_NULL();
|
||||
} else {
|
||||
RETVAL_STRING((const char *)*$1);
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(out) SWIGTYPE *,
|
||||
SWIGTYPE [],
|
||||
|
|
@ -393,16 +389,12 @@
|
|||
{
|
||||
void * p = emalloc(sizeof($1));
|
||||
memcpy(p, &$1, sizeof($1));
|
||||
zval * resource;
|
||||
MAKE_STD_ZVAL(resource);
|
||||
ZEND_REGISTER_RESOURCE(resource, p, swig_member_ptr);
|
||||
|
||||
SWIG_SetPointerZval(return_value, (void *)&$1, $1_descriptor, $owner);
|
||||
RETVAL_RES(zend_register_resource(p, swig_member_ptr));
|
||||
}
|
||||
|
||||
%typemap(in, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
|
||||
{
|
||||
void * p = (void*)zend_fetch_resource($input TSRMLS_CC, -1, SWIG_MEMBER_PTR, NULL, 1, swig_member_ptr);
|
||||
void * p = (void*)zend_fetch_resource_ex(&$input, SWIG_MEMBER_PTR, swig_member_ptr);
|
||||
memcpy(&$1, p, sizeof($1));
|
||||
}
|
||||
|
||||
|
|
@ -428,9 +420,9 @@
|
|||
#endif
|
||||
|
||||
%typemap(directorin) SWIGTYPE
|
||||
{
|
||||
SWIG_SetPointerZval($input, SWIG_as_voidptr(&$1), $&1_descriptor, 2);
|
||||
}
|
||||
%{
|
||||
SWIG_SetPointerZval($input, SWIG_as_voidptr(new $1_ltype((const $1_ltype &)$1)), $&1_descriptor, 1|2);
|
||||
%}
|
||||
|
||||
%typemap(out) void "";
|
||||
|
||||
|
|
@ -438,7 +430,7 @@
|
|||
{
|
||||
int len = 0;
|
||||
while (len < $1_dim0 && $1[len]) ++len;
|
||||
RETVAL_STRINGL($1, len, 1);
|
||||
RETVAL_STRINGL($1, len);
|
||||
}
|
||||
|
||||
// This typecheck does hard checking for proper argument type. If you want
|
||||
|
|
@ -446,7 +438,13 @@
|
|||
// it yourself before passing it (e.g. (string)4.7 or (int)"6").
|
||||
%define %php_typecheck(_type,_prec,is)
|
||||
%typemap(typecheck,precedence=_prec) _type, const _type &
|
||||
" $1 = (Z_TYPE_PP($input) == is); "
|
||||
" $1 = (Z_TYPE($input) == is);"
|
||||
%enddef
|
||||
|
||||
// Like %php_typecheck but allows either of two values.
|
||||
%define %php_typecheck2(_type,_prec,is1,is2)
|
||||
%typemap(typecheck,precedence=_prec) _type, const _type &
|
||||
" $1 = (Z_TYPE($input) == is1 || Z_TYPE($input) == is2);"
|
||||
%enddef
|
||||
|
||||
%php_typecheck(int,SWIG_TYPECHECK_INTEGER,IS_LONG)
|
||||
|
|
@ -461,18 +459,18 @@
|
|||
%php_typecheck(unsigned char,SWIG_TYPECHECK_UINT8,IS_LONG)
|
||||
%php_typecheck(size_t,SWIG_TYPECHECK_SIZE,IS_LONG)
|
||||
%php_typecheck(enum SWIGTYPE,SWIG_TYPECHECK_INTEGER,IS_LONG)
|
||||
%php_typecheck(bool,SWIG_TYPECHECK_BOOL,IS_BOOL)
|
||||
%php_typecheck2(bool,SWIG_TYPECHECK_BOOL,IS_TRUE,IS_FALSE)
|
||||
%php_typecheck(float,SWIG_TYPECHECK_FLOAT,IS_DOUBLE)
|
||||
%php_typecheck(double,SWIG_TYPECHECK_DOUBLE,IS_DOUBLE)
|
||||
%php_typecheck(char,SWIG_TYPECHECK_CHAR,IS_STRING)
|
||||
|
||||
%typemap(typecheck,precedence=SWIG_TYPECHECK_STRING) char *, char *&, char []
|
||||
" $1 = (Z_TYPE_PP($input) == IS_STRING); "
|
||||
" $1 = (Z_TYPE($input) == IS_STRING); "
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE
|
||||
{
|
||||
void *tmp;
|
||||
_v = (SWIG_ConvertPtr(*$input, (void **)&tmp, $&1_descriptor, 0) >= 0);
|
||||
_v = (SWIG_ConvertPtr(&$input, (void **)&tmp, $&1_descriptor, 0) >= 0);
|
||||
}
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_POINTER)
|
||||
|
|
@ -483,19 +481,19 @@
|
|||
SWIGTYPE *const&
|
||||
{
|
||||
void *tmp;
|
||||
_v = (SWIG_ConvertPtr(*$input, (void**)&tmp, $1_descriptor, 0) >= 0);
|
||||
_v = (SWIG_ConvertPtr(&$input, (void**)&tmp, $1_descriptor, 0) >= 0);
|
||||
}
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *const&
|
||||
{
|
||||
void *tmp;
|
||||
_v = (SWIG_ConvertPtr(*$input, (void**)&tmp, $*1_descriptor, 0) >= 0);
|
||||
_v = (SWIG_ConvertPtr(&$input, (void**)&tmp, $*1_descriptor, 0) >= 0);
|
||||
}
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_VOIDPTR) void *
|
||||
{
|
||||
void *tmp;
|
||||
_v = (SWIG_ConvertPtr(*$input, (void**)&tmp, 0, 0) >= 0);
|
||||
_v = (SWIG_ConvertPtr(&$input, (void**)&tmp, 0, 0) >= 0);
|
||||
}
|
||||
|
||||
/* Exception handling */
|
||||
|
|
@ -505,19 +503,19 @@
|
|||
short,
|
||||
unsigned int,
|
||||
unsigned long,
|
||||
unsigned short {
|
||||
zend_throw_exception(NULL, const_cast<char*>("C++ $1_type exception thrown"), $1 TSRMLS_CC);
|
||||
unsigned short %{
|
||||
zend_throw_exception(NULL, "C++ $1_type exception thrown", $1);
|
||||
return;
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(throws) SWIGTYPE, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE *, SWIGTYPE [], SWIGTYPE [ANY] %{
|
||||
(void)$1;
|
||||
zend_throw_exception(NULL, const_cast<char*>("C++ $1_type exception thrown"), 0 TSRMLS_CC);
|
||||
zend_throw_exception(NULL, "C++ $1_type exception thrown", 0);
|
||||
return;
|
||||
%}
|
||||
|
||||
%typemap(throws) char * %{
|
||||
zend_throw_exception(NULL, const_cast<char*>($1), 0 TSRMLS_CC);
|
||||
zend_throw_exception(NULL, $1, 0);
|
||||
return;
|
||||
%}
|
||||
|
||||
|
|
|
|||
|
|
@ -6,20 +6,20 @@
|
|||
%insert(init) "swiginit.swg"
|
||||
|
||||
%init %{
|
||||
SWIG_php_minit {
|
||||
SWIG_php_minit {
|
||||
SWIG_InitializeModule(0);
|
||||
%}
|
||||
|
||||
%fragment("swig_php_init_member_ptr2", "header") {
|
||||
#define SWIG_MEMBER_PTR ((char*)"CLASS::*")
|
||||
%fragment("swig_php_init_member_ptr2", "header") %{
|
||||
#define SWIG_MEMBER_PTR "CLASS::*"
|
||||
|
||||
static void swig_member_ptr_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) {
|
||||
efree(rsrc->ptr);
|
||||
static void swig_member_ptr_dtor(zend_resource *res) {
|
||||
efree(res->ptr);
|
||||
}
|
||||
|
||||
static int swig_member_ptr = 0;
|
||||
}
|
||||
%}
|
||||
|
||||
%fragment("swig_php_init_member_ptr", "init", fragment="swig_php_init_member_ptr2") {
|
||||
%fragment("swig_php_init_member_ptr", "init", fragment="swig_php_init_member_ptr2") %{
|
||||
swig_member_ptr = zend_register_list_destructors_ex(swig_member_ptr_dtor, NULL, SWIG_MEMBER_PTR, module_number);
|
||||
}
|
||||
%}
|
||||
|
|
|
|||
|
|
@ -661,6 +661,21 @@ PHPCN(generator); // As of PHP 5.5
|
|||
PHPCN(self);
|
||||
PHPCN(static);
|
||||
PHPCN(parent);
|
||||
/* http://php.net/manual/en/migration70.incompatible.php#migration70.incompatible.other.classes */
|
||||
PHPCN(bool); // As of PHP 7.0
|
||||
PHPCN(int); // As of PHP 7.0
|
||||
PHPCN(float); // As of PHP 7.0
|
||||
PHPCN(string); // As of PHP 7.0
|
||||
PHPCN(NULL); // As of PHP 7.0
|
||||
PHPCN(TRUE); // As of PHP 7.0
|
||||
PHPCN(FALSE); // As of PHP 7.0
|
||||
PHPCN(resource); // As of PHP 7.0 (currently works but reserved)
|
||||
PHPCN(object); // As of PHP 7.0 (currently works but reserved)
|
||||
PHPCN(mixed); // As of PHP 7.0 (currently works but reserved)
|
||||
PHPCN(numeric); // As of PHP 7.0 (currently works but reserved)
|
||||
/* http://php.net/manual/en/migration71.incompatible.php#migration71.incompatible.invalid-class-names */
|
||||
PHPCN(iterable); // As of PHP 7.1
|
||||
PHPCN(void); // As of PHP 7.1
|
||||
/* From extensions (which of these are actually predefined depends which
|
||||
* extensions are loaded by default). */
|
||||
PHPCN(xmlwriter);
|
||||
|
|
|
|||
|
|
@ -3,19 +3,23 @@
|
|||
TYPE &REF ($*1_ltype tmp)
|
||||
%{
|
||||
/* First Check for SWIG wrapped type */
|
||||
if ( ZVAL_IS_NULL( *$input ) ) {
|
||||
if (Z_ISNULL($input)) {
|
||||
$1 = 0;
|
||||
} else if ( PZVAL_IS_REF( *$input ) ) {
|
||||
} else if (Z_ISREF($input)) {
|
||||
/* Not swig wrapped type, so we check if it's a PHP reference type */
|
||||
CONVERT_IN( tmp, $*1_ltype, $input );
|
||||
CONVERT_IN(tmp, $*1_ltype, $input);
|
||||
$1 = &tmp;
|
||||
} else {
|
||||
SWIG_PHP_Error( E_ERROR, SWIG_PHP_Arg_Error_Msg($argnum, Expected a reference) );
|
||||
SWIG_PHP_Error(E_ERROR, SWIG_PHP_Arg_Error_Msg($argnum, Expected a reference));
|
||||
}
|
||||
%}
|
||||
%typemap(argout) TYPE *REF,
|
||||
TYPE &REF
|
||||
"CONVERT_OUT(*$input, tmp$argnum );";
|
||||
%{
|
||||
if (Z_ISREF($input)) {
|
||||
CONVERT_OUT(Z_REFVAL($input), tmp$argnum);
|
||||
}
|
||||
%}
|
||||
%enddef
|
||||
|
||||
%pass_by_ref( size_t, CONVERT_INT_IN, ZVAL_LONG );
|
||||
|
|
|
|||
|
|
@ -11,61 +11,31 @@ extern "C" {
|
|||
#include "zend_API.h"
|
||||
#include "zend_exceptions.h"
|
||||
#include "php.h"
|
||||
|
||||
#if PHP_MAJOR_VERSION != 7
|
||||
# error These bindings need PHP7 - to generate PHP5 bindings use: swig -php5
|
||||
#endif
|
||||
|
||||
#include "ext/standard/php_string.h"
|
||||
#include <stdlib.h> /* for abort(), used in generated code. */
|
||||
|
||||
#ifdef ZEND_RAW_FENTRY
|
||||
/* ZEND_RAW_FENTRY was added somewhere between 5.2.0 and 5.2.3 */
|
||||
# define SWIG_ZEND_NAMED_FE(ZN, N, A) ZEND_RAW_FENTRY((char*)#ZN, N, A, 0)
|
||||
#else
|
||||
/* This causes warnings from GCC >= 4.2 (assigning a string literal to char*).
|
||||
* But this seems to be unavoidable without directly assuming knowledge of
|
||||
* the structure, which changed between PHP4 and PHP5. */
|
||||
# define SWIG_ZEND_NAMED_FE(ZN, N, A) ZEND_NAMED_FE(ZN, N, A)
|
||||
#endif
|
||||
/* This indirection is to work around const correctness issues in older PHP.
|
||||
* FIXME: Remove for PHP7? Or might user code be using it? */
|
||||
#define SWIG_ZEND_NAMED_FE(ZN, N, A) ZEND_NAMED_FE(ZN, N, A)
|
||||
|
||||
#ifndef Z_SET_ISREF_P
|
||||
/* For PHP < 5.3 */
|
||||
# define Z_SET_ISREF_P(z) (z)->is_ref = 1
|
||||
#endif
|
||||
#ifndef Z_SET_REFCOUNT_P
|
||||
/* For PHP < 5.3 */
|
||||
# define Z_SET_REFCOUNT_P(z, rc) (z)->refcount = (rc)
|
||||
#endif
|
||||
|
||||
#define SWIG_LONG_CONSTANT(N, V) zend_register_long_constant((char*)#N, sizeof(#N), V, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
|
||||
#define SWIG_DOUBLE_CONSTANT(N, V) zend_register_double_constant((char*)#N, sizeof(#N), V, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
|
||||
#define SWIG_STRING_CONSTANT(N, V) zend_register_stringl_constant((char*)#N, sizeof(#N), (char*)(V), strlen(V), CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
|
||||
#define SWIG_BOOL_CONSTANT(N, V) REGISTER_BOOL_CONSTANT(#N, V, CONST_CS | CONST_PERSISTENT)
|
||||
#define SWIG_LONG_CONSTANT(N, V) REGISTER_LONG_CONSTANT(#N, V, CONST_CS | CONST_PERSISTENT)
|
||||
#define SWIG_DOUBLE_CONSTANT(N, V) REGISTER_DOUBLE_CONSTANT(#N, V, CONST_CS | CONST_PERSISTENT)
|
||||
#define SWIG_STRING_CONSTANT(N, V) REGISTER_STRING_CONSTANT(#N, (char*)V, CONST_CS | CONST_PERSISTENT)
|
||||
#define SWIG_CHAR_CONSTANT(N, V) do {\
|
||||
static char swig_char = (V);\
|
||||
zend_register_stringl_constant((char*)#N, sizeof(#N), &swig_char, 1, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC);\
|
||||
char swig_char = (V);\
|
||||
REGISTER_STRINGL_CONSTANT(#N, &swig_char, 1, CONST_CS | CONST_PERSISTENT);\
|
||||
} while (0)
|
||||
|
||||
/* These TSRMLS_ stuff should already be defined now, but with older php under
|
||||
redhat are not... */
|
||||
#ifndef TSRMLS_D
|
||||
#define TSRMLS_D
|
||||
#endif
|
||||
#ifndef TSRMLS_DC
|
||||
#define TSRMLS_DC
|
||||
#endif
|
||||
#ifndef TSRMLS_C
|
||||
#define TSRMLS_C
|
||||
#endif
|
||||
#ifndef TSRMLS_CC
|
||||
#define TSRMLS_CC
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
/* But in fact SWIG_ConvertPtr is the native interface for getting typed
|
||||
pointer values out of zvals. We need the TSRMLS_ macros for when we
|
||||
make PHP type calls later as we handle php resources */
|
||||
#define SWIG_ConvertPtr(obj,pp,type,flags) SWIG_ZTS_ConvertPtr(obj,pp,type,flags TSRMLS_CC)
|
||||
|
||||
|
||||
#define SWIG_fail goto fail
|
||||
|
||||
static const char *default_error_msg = "Unknown error occurred";
|
||||
|
|
@ -89,14 +59,10 @@ typedef struct {
|
|||
int newobject;
|
||||
} swig_object_wrapper;
|
||||
|
||||
/* empty zend destructor for types without one */
|
||||
static ZEND_RSRC_DTOR_FUNC(SWIG_landfill) { (void)rsrc; }
|
||||
|
||||
#define SWIG_SetPointerZval(a,b,c,d) SWIG_ZTS_SetPointerZval(a,b,c,d TSRMLS_CC)
|
||||
#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
|
||||
|
||||
static void
|
||||
SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject TSRMLS_DC) {
|
||||
SWIG_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject) {
|
||||
/*
|
||||
* First test for Null pointers. Return those as PHP native NULL
|
||||
*/
|
||||
|
|
@ -113,19 +79,19 @@ SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject
|
|||
value->newobject=(newobject & 1);
|
||||
if ((newobject & 2) == 0) {
|
||||
/* Just register the pointer as a resource. */
|
||||
ZEND_REGISTER_RESOURCE(z, value, *(int *)(type->clientdata));
|
||||
ZVAL_RES(z, zend_register_resource(value, *(int *)(type->clientdata)));
|
||||
} else {
|
||||
/*
|
||||
* Wrap the resource in an object, the resource will be accessible
|
||||
* via the "_cPtr" member. This is currently only used by
|
||||
* directorin typemaps.
|
||||
*/
|
||||
zval *resource;
|
||||
zend_class_entry **ce = NULL;
|
||||
zval resource;
|
||||
zend_class_entry *ce = NULL;
|
||||
const char *type_name = type->name+3; /* +3 so: _p_Foo -> Foo */
|
||||
size_t type_name_len;
|
||||
int result;
|
||||
const char * p;
|
||||
HashTable * ht;
|
||||
|
||||
/* Namespace__Foo -> Foo */
|
||||
/* FIXME: ugly and goes wrong for classes with __ in their names. */
|
||||
|
|
@ -134,26 +100,27 @@ SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject
|
|||
}
|
||||
type_name_len = strlen(type_name);
|
||||
|
||||
MAKE_STD_ZVAL(resource);
|
||||
ZEND_REGISTER_RESOURCE(resource, value, *(int *)(type->clientdata));
|
||||
ZVAL_RES(&resource, zend_register_resource(value, *(int *)(type->clientdata)));
|
||||
if (SWIG_PREFIX_LEN > 0) {
|
||||
char * classname = (char*)emalloc(SWIG_PREFIX_LEN + type_name_len + 1);
|
||||
strcpy(classname, SWIG_PREFIX);
|
||||
strcpy(classname + SWIG_PREFIX_LEN, type_name);
|
||||
result = zend_lookup_class(classname, SWIG_PREFIX_LEN + type_name_len, &ce TSRMLS_CC);
|
||||
efree(classname);
|
||||
zend_string * classname = zend_string_alloc(SWIG_PREFIX_LEN + type_name_len, 0);
|
||||
memcpy(classname->val, SWIG_PREFIX, SWIG_PREFIX_LEN);
|
||||
memcpy(classname->val + SWIG_PREFIX_LEN, type_name, type_name_len);
|
||||
ce = zend_lookup_class(classname);
|
||||
zend_string_release(classname);
|
||||
} else {
|
||||
result = zend_lookup_class((char *)type_name, type_name_len, &ce TSRMLS_CC);
|
||||
zend_string * classname = zend_string_init(type_name, type_name_len, 0);
|
||||
ce = zend_lookup_class(classname);
|
||||
zend_string_release(classname);
|
||||
}
|
||||
if (result != SUCCESS) {
|
||||
if (ce == NULL) {
|
||||
/* class does not exist */
|
||||
object_init(z);
|
||||
} else {
|
||||
object_init_ex(z, *ce);
|
||||
ce = zend_standard_class_def;
|
||||
}
|
||||
Z_SET_REFCOUNT_P(z, 1);
|
||||
Z_SET_ISREF_P(z);
|
||||
zend_hash_update(HASH_OF(z), (char*)"_cPtr", sizeof("_cPtr"), (void*)&resource, sizeof(zval*), NULL);
|
||||
|
||||
ALLOC_HASHTABLE(ht);
|
||||
zend_hash_init(ht, 1, NULL, NULL, 0);
|
||||
zend_hash_str_update(ht, "_cPtr", sizeof("_cPtr") - 1, &resource);
|
||||
object_and_properties_init(z, ce, ht);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
|
@ -169,11 +136,11 @@ SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject
|
|||
instance of a resource of the type id, so we have to pass type_name as well.
|
||||
|
||||
The two functions which might call this are:
|
||||
SWIG_ZTS_ConvertResourcePtr which gets the type name from the resource
|
||||
SWIG_ConvertResourcePtr which gets the type name from the resource
|
||||
and the registered zend destructors for which we have one per type each
|
||||
with the type name hard wired in. */
|
||||
static void *
|
||||
SWIG_ZTS_ConvertResourceData(void * p, const char *type_name, swig_type_info *ty TSRMLS_DC) {
|
||||
SWIG_ConvertResourceData(void * p, const char *type_name, swig_type_info *ty) {
|
||||
swig_cast_info *tc;
|
||||
void *result = 0;
|
||||
|
||||
|
|
@ -200,48 +167,53 @@ SWIG_ZTS_ConvertResourceData(void * p, const char *type_name, swig_type_info *ty
|
|||
/* This function returns a pointer of type ty by extracting the pointer
|
||||
and type info from the resource in z. z must be a resource.
|
||||
If it fails, NULL is returned.
|
||||
It uses SWIG_ZTS_ConvertResourceData to do the real work. */
|
||||
It uses SWIG_ConvertResourceData to do the real work. */
|
||||
static void *
|
||||
SWIG_ZTS_ConvertResourcePtr(zval *z, swig_type_info *ty, int flags TSRMLS_DC) {
|
||||
SWIG_ConvertResourcePtr(zval *z, swig_type_info *ty, int flags) {
|
||||
swig_object_wrapper *value;
|
||||
void *p;
|
||||
int type;
|
||||
const char *type_name;
|
||||
|
||||
value = (swig_object_wrapper *) zend_list_find(z->value.lval, &type);
|
||||
if (type==-1) return NULL;
|
||||
if (Z_RES_TYPE_P(z) == -1) return NULL;
|
||||
value = (swig_object_wrapper *) Z_RES_VAL_P(z);
|
||||
if (flags & SWIG_POINTER_DISOWN) {
|
||||
value->newobject = 0;
|
||||
}
|
||||
p = value->ptr;
|
||||
|
||||
type_name=zend_rsrc_list_get_rsrc_type(z->value.lval TSRMLS_CC);
|
||||
type_name=zend_rsrc_list_get_rsrc_type(Z_RES_P(z));
|
||||
|
||||
return SWIG_ZTS_ConvertResourceData(p, type_name, ty TSRMLS_CC);
|
||||
return SWIG_ConvertResourceData(p, type_name, ty);
|
||||
}
|
||||
|
||||
/* We allow passing of a RESOURCE pointing to the object or an OBJECT whose
|
||||
_cPtr is a resource pointing to the object */
|
||||
static int
|
||||
SWIG_ZTS_ConvertPtr(zval *z, void **ptr, swig_type_info *ty, int flags TSRMLS_DC) {
|
||||
SWIG_ConvertPtr(zval *z, void **ptr, swig_type_info *ty, int flags) {
|
||||
if (z == NULL) {
|
||||
*ptr = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
switch (z->type) {
|
||||
switch (Z_TYPE_P(z)) {
|
||||
case IS_OBJECT: {
|
||||
zval ** _cPtr;
|
||||
if (zend_hash_find(HASH_OF(z),(char*)"_cPtr",sizeof("_cPtr"),(void**)&_cPtr)==SUCCESS) {
|
||||
if ((*_cPtr)->type==IS_RESOURCE) {
|
||||
*ptr = SWIG_ZTS_ConvertResourcePtr(*_cPtr, ty, flags TSRMLS_CC);
|
||||
return (*ptr == NULL ? -1 : 0);
|
||||
}
|
||||
HashTable * ht = Z_OBJ_HT_P(z)->get_properties(z);
|
||||
if (ht) {
|
||||
zval * _cPtr = zend_hash_str_find(ht, "_cPtr", sizeof("_cPtr") - 1);
|
||||
if (_cPtr) {
|
||||
if (Z_TYPE_P(_cPtr) == IS_INDIRECT) {
|
||||
_cPtr = Z_INDIRECT_P(_cPtr);
|
||||
}
|
||||
if (Z_TYPE_P(_cPtr) == IS_RESOURCE) {
|
||||
*ptr = SWIG_ConvertResourcePtr(_cPtr, ty, flags);
|
||||
return (*ptr == NULL ? -1 : 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case IS_RESOURCE:
|
||||
*ptr = SWIG_ZTS_ConvertResourcePtr(z, ty, flags TSRMLS_CC);
|
||||
*ptr = SWIG_ConvertResourcePtr(z, ty, flags);
|
||||
return (*ptr == NULL ? -1 : 0);
|
||||
case IS_NULL:
|
||||
*ptr = 0;
|
||||
|
|
@ -253,22 +225,15 @@ SWIG_ZTS_ConvertPtr(zval *z, void **ptr, swig_type_info *ty, int flags TSRMLS_DC
|
|||
|
||||
static char const_name[] = "swig_runtime_data_type_pointer";
|
||||
static swig_module_info *SWIG_Php_GetModule() {
|
||||
zval *pointer;
|
||||
swig_module_info *ret = 0;
|
||||
TSRMLS_FETCH();
|
||||
|
||||
MAKE_STD_ZVAL(pointer);
|
||||
|
||||
if (zend_get_constant(const_name, sizeof(const_name) - 1, pointer TSRMLS_CC)) {
|
||||
if (pointer->type == IS_LONG) {
|
||||
ret = (swig_module_info *) pointer->value.lval;
|
||||
zval *pointer = zend_get_constant_str(const_name, sizeof(const_name) - 1);
|
||||
if (pointer) {
|
||||
if (Z_TYPE_P(pointer) == IS_LONG) {
|
||||
return (swig_module_info *) pointer->value.lval;
|
||||
}
|
||||
}
|
||||
FREE_ZVAL(pointer);
|
||||
return ret;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void SWIG_Php_SetModule(swig_module_info *pointer) {
|
||||
TSRMLS_FETCH();
|
||||
REGISTER_MAIN_LONG_CONSTANT(const_name, (long) pointer, 0);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,53 +24,68 @@ namespace std {
|
|||
class string;
|
||||
|
||||
%typemap(typecheck,precedence=SWIG_TYPECHECK_STRING) string, const string& %{
|
||||
$1 = ( Z_TYPE_PP($input) == IS_STRING ) ? 1 : 0;
|
||||
$1 = (Z_TYPE($input) == IS_STRING) ? 1 : 0;
|
||||
%}
|
||||
|
||||
%typemap(in) string %{
|
||||
convert_to_string_ex($input);
|
||||
$1.assign(Z_STRVAL_PP($input), Z_STRLEN_PP($input));
|
||||
convert_to_string(&$input);
|
||||
$1.assign(Z_STRVAL($input), Z_STRLEN($input));
|
||||
%}
|
||||
|
||||
%typemap(directorout) string %{
|
||||
convert_to_string_ex(&$input);
|
||||
if (!EG(exception)) {
|
||||
convert_to_string($input);
|
||||
$result.assign(Z_STRVAL_P($input), Z_STRLEN_P($input));
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(out) string %{
|
||||
ZVAL_STRINGL($result, const_cast<char*>($1.data()), $1.size(), 1);
|
||||
ZVAL_STRINGL($result, $1.data(), $1.size());
|
||||
%}
|
||||
|
||||
%typemap(directorin) string, const string& %{
|
||||
ZVAL_STRINGL($input, const_cast<char*>($1.data()), $1.size(), 1);
|
||||
ZVAL_STRINGL($input, $1.data(), $1.size());
|
||||
%}
|
||||
|
||||
%typemap(out) const string & %{
|
||||
ZVAL_STRINGL($result, const_cast<char*>($1->data()), $1->size(), 1);
|
||||
ZVAL_STRINGL($result, $1->data(), $1->size());
|
||||
%}
|
||||
|
||||
%typemap(throws) string, const string& %{
|
||||
zend_throw_exception(NULL, const_cast<char*>($1.c_str()), 0 TSRMLS_CC);
|
||||
zend_throw_exception(NULL, $1.c_str(), 0);
|
||||
return;
|
||||
%}
|
||||
|
||||
%typemap(in) const string & ($*1_ltype temp) %{
|
||||
convert_to_string(&$input);
|
||||
temp.assign(Z_STRVAL($input), Z_STRLEN($input));
|
||||
$1 = &temp;
|
||||
%}
|
||||
|
||||
/* These next two handle a function which takes a non-const reference to
|
||||
* a std::string and modifies the string. */
|
||||
%typemap(in) string & ($*1_ltype temp) %{
|
||||
convert_to_string_ex($input);
|
||||
temp.assign(Z_STRVAL_PP($input), Z_STRLEN_PP($input));
|
||||
$1 = &temp;
|
||||
%typemap(in,byref=1) string & ($*1_ltype temp) %{
|
||||
{
|
||||
zval * p = Z_ISREF($input) ? Z_REFVAL($input) : &$input;
|
||||
convert_to_string(p);
|
||||
temp.assign(Z_STRVAL_P(p), Z_STRLEN_P(p));
|
||||
$1 = &temp;
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(directorout) string & ($*1_ltype *temp) %{
|
||||
convert_to_string_ex(&$input);
|
||||
if (!EG(exception)) {
|
||||
convert_to_string($input);
|
||||
temp = new $*1_ltype(Z_STRVAL_P($input), Z_STRLEN_P($input));
|
||||
swig_acquire_ownership(temp);
|
||||
$result = temp;
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(argout) string & %{
|
||||
ZVAL_STRINGL(*($input), const_cast<char*>($1->data()), $1->size(), 1);
|
||||
if (Z_ISREF($input)) {
|
||||
ZVAL_STRINGL(Z_REFVAL($input), $1->data(), $1->size());
|
||||
}
|
||||
%}
|
||||
|
||||
/* SWIG will apply the non-const typemap above to const string& without
|
||||
|
|
|
|||
|
|
@ -27,87 +27,77 @@
|
|||
%define BOOL_TYPEMAP(TYPE)
|
||||
%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
|
||||
%{
|
||||
convert_to_boolean_ex($input);
|
||||
temp = Z_LVAL_PP($input) ? true : false;
|
||||
convert_to_boolean(&$input);
|
||||
temp = (Z_TYPE($input) == IS_TRUE);
|
||||
$1 = &temp;
|
||||
%}
|
||||
%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
|
||||
%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
|
||||
%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
|
||||
{
|
||||
zval *o;
|
||||
MAKE_STD_ZVAL(o);
|
||||
ZVAL_BOOL(o,temp$argnum);
|
||||
t_output_helper( &$result, o TSRMLS_CC );
|
||||
zval o;
|
||||
ZVAL_BOOL(&o, temp$argnum);
|
||||
t_output_helper($result, &o);
|
||||
}
|
||||
%typemap(in) TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
|
||||
%{
|
||||
convert_to_boolean_ex($input);
|
||||
lvalue = (*$input)->value.lval ? true : false;
|
||||
convert_to_boolean($input);
|
||||
lvalue = (Z_TYPE_P($input) == IS_TRUE);
|
||||
$1 = &lvalue;
|
||||
%}
|
||||
%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
|
||||
%{
|
||||
(*$arg)->value.lval = lvalue$argnum ? true : false;
|
||||
(*$arg)->type = IS_BOOL;
|
||||
ZVAL_BOOL(&$arg, lvalue$argnum ? true : false);
|
||||
%}
|
||||
%enddef
|
||||
|
||||
%define DOUBLE_TYPEMAP(TYPE)
|
||||
%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
|
||||
%{
|
||||
convert_to_double_ex($input);
|
||||
temp = (TYPE) Z_DVAL_PP($input);
|
||||
temp = (TYPE) zval_get_double(&$input);
|
||||
$1 = &temp;
|
||||
%}
|
||||
%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
|
||||
%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
|
||||
%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
|
||||
{
|
||||
zval *o;
|
||||
MAKE_STD_ZVAL(o);
|
||||
ZVAL_DOUBLE(o,temp$argnum);
|
||||
t_output_helper( &$result, o TSRMLS_CC );
|
||||
zval o;
|
||||
ZVAL_DOUBLE(&o, temp$argnum);
|
||||
t_output_helper($result, &o);
|
||||
}
|
||||
%typemap(in) TYPE *REFERENCE (TYPE dvalue), TYPE &REFERENCE (TYPE dvalue)
|
||||
%{
|
||||
convert_to_double_ex($input);
|
||||
dvalue = (TYPE) (*$input)->value.dval;
|
||||
dvalue = (TYPE) zval_get_double(&$input);
|
||||
$1 = &dvalue;
|
||||
%}
|
||||
%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
|
||||
%{
|
||||
$1->value.dval = (double)(lvalue$argnum);
|
||||
$1->type = IS_DOUBLE;
|
||||
ZVAL_DOUBLE(&$arg, (double)(lvalue$argnum));
|
||||
%}
|
||||
%enddef
|
||||
|
||||
%define INT_TYPEMAP(TYPE)
|
||||
%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
|
||||
%{
|
||||
convert_to_long_ex($input);
|
||||
temp = (TYPE) Z_LVAL_PP($input);
|
||||
temp = (TYPE) zval_get_long(&$input);
|
||||
$1 = &temp;
|
||||
%}
|
||||
%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
|
||||
%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
|
||||
%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
|
||||
{
|
||||
zval *o;
|
||||
MAKE_STD_ZVAL(o);
|
||||
ZVAL_LONG(o,temp$argnum);
|
||||
t_output_helper( &$result, o TSRMLS_CC );
|
||||
zval o;
|
||||
ZVAL_LONG(&o, temp$argnum);
|
||||
t_output_helper($result, &o);
|
||||
}
|
||||
%typemap(in) TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
|
||||
%{
|
||||
convert_to_long_ex($input);
|
||||
lvalue = (TYPE) (*$input)->value.lval;
|
||||
lvalue = (TYPE) zval_get_long(&$input);
|
||||
$1 = &lvalue;
|
||||
%}
|
||||
%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
|
||||
%{
|
||||
(*$arg)->value.lval = (long)(lvalue$argnum);
|
||||
(*$arg)->type = IS_LONG;
|
||||
ZVAL_LONG(&$arg, (long)(lvalue$argnum));
|
||||
%}
|
||||
%enddef
|
||||
|
||||
|
|
@ -128,16 +118,15 @@ INT_TYPEMAP(signed char);
|
|||
INT_TYPEMAP(long long);
|
||||
%typemap(argout,fragment="t_output_helper") long long *OUTPUT
|
||||
{
|
||||
zval *o;
|
||||
MAKE_STD_ZVAL(o);
|
||||
zval o;
|
||||
if ((long long)LONG_MIN <= temp$argnum && temp$argnum <= (long long)LONG_MAX) {
|
||||
ZVAL_LONG(o, temp$argnum);
|
||||
ZVAL_LONG(&o, (long)temp$argnum);
|
||||
} else {
|
||||
char temp[256];
|
||||
sprintf(temp, "%lld", (long long)temp$argnum);
|
||||
ZVAL_STRING(o, temp, 1);
|
||||
ZVAL_STRING(&o, temp);
|
||||
}
|
||||
t_output_helper( &$result, o TSRMLS_CC );
|
||||
t_output_helper($result, &o);
|
||||
}
|
||||
%typemap(in) TYPE *REFERENCE (long long lvalue)
|
||||
%{
|
||||
|
|
@ -147,38 +136,35 @@ INT_TYPEMAP(long long);
|
|||
%typemap(argout) long long *REFERENCE
|
||||
%{
|
||||
if ((long long)LONG_MIN <= lvalue$argnum && lvalue$argnum <= (long long)LONG_MAX) {
|
||||
(*$arg)->value.lval = (long)(lvalue$argnum);
|
||||
(*$arg)->type = IS_LONG;
|
||||
ZVAL_LONG(&$arg, (long)temp$argnum);
|
||||
} else {
|
||||
char temp[256];
|
||||
sprintf(temp, "%lld", (long long)lvalue$argnum);
|
||||
ZVAL_STRING((*$arg), temp, 1);
|
||||
ZVAL_STRING(&$arg, temp);
|
||||
}
|
||||
%}
|
||||
%typemap(argout) long long &OUTPUT
|
||||
%{
|
||||
if ((long long)LONG_MIN <= *arg$argnum && *arg$argnum <= (long long)LONG_MAX) {
|
||||
($result)->value.lval = (long)(*arg$argnum);
|
||||
($result)->type = IS_LONG;
|
||||
ZVAL_LONG($result, (long)(*arg$argnum));
|
||||
} else {
|
||||
char temp[256];
|
||||
sprintf(temp, "%lld", (long long)(*arg$argnum));
|
||||
ZVAL_STRING($result, temp, 1);
|
||||
ZVAL_STRING($result, temp);
|
||||
}
|
||||
%}
|
||||
INT_TYPEMAP(unsigned long long);
|
||||
%typemap(argout,fragment="t_output_helper") unsigned long long *OUTPUT
|
||||
{
|
||||
zval *o;
|
||||
MAKE_STD_ZVAL(o);
|
||||
zval o;
|
||||
if (temp$argnum <= (unsigned long long)LONG_MAX) {
|
||||
ZVAL_LONG(o, temp$argnum);
|
||||
ZVAL_LONG(&o, temp$argnum);
|
||||
} else {
|
||||
char temp[256];
|
||||
sprintf(temp, "%llu", (unsigned long long)temp$argnum);
|
||||
ZVAL_STRING(o, temp, 1);
|
||||
ZVAL_STRING(&o, temp);
|
||||
}
|
||||
t_output_helper( &$result, o TSRMLS_CC );
|
||||
t_output_helper($result, &o);
|
||||
}
|
||||
%typemap(in) TYPE *REFERENCE (unsigned long long lvalue)
|
||||
%{
|
||||
|
|
@ -188,23 +174,21 @@ INT_TYPEMAP(unsigned long long);
|
|||
%typemap(argout) unsigned long long *REFERENCE
|
||||
%{
|
||||
if (lvalue$argnum <= (unsigned long long)LONG_MAX) {
|
||||
(*$arg)->value.lval = (long)(lvalue$argnum);
|
||||
(*$arg)->type = IS_LONG;
|
||||
ZVAL_LONG($arg, (long)(lvalue$argnum));
|
||||
} else {
|
||||
char temp[256];
|
||||
sprintf(temp, "%llu", (unsigned long long)lvalue$argnum);
|
||||
ZVAL_STRING((*$arg), temp, 1);
|
||||
ZVAL_STRING((*$arg), temp);
|
||||
}
|
||||
%}
|
||||
%typemap(argout) unsigned long long &OUTPUT
|
||||
%{
|
||||
if (*arg$argnum <= (unsigned long long)LONG_MAX) {
|
||||
($result)->value.lval = (long)(*arg$argnum);
|
||||
($result)->type = IS_LONG;
|
||||
ZVAL_LONG($result, (long)(*arg$argnum));
|
||||
} else {
|
||||
char temp[256];
|
||||
sprintf(temp, "%llu", (unsigned long long)(*arg$argnum));
|
||||
ZVAL_STRING($result, temp, 1);
|
||||
ZVAL_STRING($result, temp);
|
||||
}
|
||||
%}
|
||||
|
||||
|
|
@ -270,18 +254,17 @@ INT_TYPEMAP(unsigned long long);
|
|||
|
||||
%typemap(in) char INPUT[ANY] ( char temp[$1_dim0] )
|
||||
%{
|
||||
convert_to_string_ex($input);
|
||||
strncpy(temp,Z_LVAL_PP($input),$1_dim0);
|
||||
convert_to_string(&$input);
|
||||
strncpy(temp, Z_STRVAL($input), $1_dim0);
|
||||
$1 = temp;
|
||||
%}
|
||||
%typemap(in,numinputs=0) char OUTPUT[ANY] ( char temp[$1_dim0] )
|
||||
"$1 = temp;";
|
||||
%typemap(argout,fragment="t_output_helper") char OUTPUT[ANY]
|
||||
{
|
||||
zval *o;
|
||||
MAKE_STD_ZVAL(o);
|
||||
ZVAL_STRINGL(o,temp$argnum,$1_dim0);
|
||||
t_output_helper( &$result, o TSRMLS_CC );
|
||||
zval o;
|
||||
ZVAL_STRINGL(&o, temp$argnum, $1_dim0);
|
||||
t_output_helper($result, &o);
|
||||
}
|
||||
|
||||
%typemap(in,numinputs=0) void **OUTPUT (int force),
|
||||
|
|
@ -289,9 +272,9 @@ INT_TYPEMAP(unsigned long long);
|
|||
%{
|
||||
/* If they pass NULL by reference, make it into a void*
|
||||
This bit should go in arginit if arginit support init-ing scripting args */
|
||||
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0) {
|
||||
if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0) {
|
||||
/* So... we didn't get a ref or ptr, but we'll accept NULL by reference */
|
||||
if (!((*$input)->type==IS_NULL && PZVAL_IS_REF(*$input))) {
|
||||
if (!(Z_ISREF($input) && Z_ISNULL_P(Z_REFVAL($input)))) {
|
||||
/* wasn't a pre/ref/thing, OR anything like an int thing */
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument $arg of $symname.");
|
||||
}
|
||||
|
|
@ -299,7 +282,7 @@ INT_TYPEMAP(unsigned long long);
|
|||
force=0;
|
||||
if (arg1==NULL) {
|
||||
#ifdef __cplusplus
|
||||
ptr=new $*1_ltype;
|
||||
ptr=new $*1_ltype();
|
||||
#else
|
||||
ptr=($*1_ltype) calloc(1,sizeof($*1_ltype));
|
||||
#endif
|
||||
|
|
@ -313,7 +296,7 @@ INT_TYPEMAP(unsigned long long);
|
|||
void *&OUTPUT
|
||||
%{
|
||||
if (force$argnum) { /* pass back arg$argnum through params ($arg) if we can */
|
||||
if (!PZVAL_IS_REF(*$arg)) {
|
||||
if (!Z_ISREF($arg)) {
|
||||
SWIG_PHP_Error(E_WARNING, "Parameter $argnum of $symname wasn't passed by reference");
|
||||
} else {
|
||||
SWIG_SetPointerZval(*$arg, (void *) ptr$argnum, $*1_descriptor, 1);
|
||||
|
|
|
|||
|
|
@ -1,70 +1,65 @@
|
|||
|
||||
%define CONVERT_BOOL_IN(lvar,t,invar)
|
||||
convert_to_boolean_ex(invar);
|
||||
lvar = (t) Z_LVAL_PP(invar);
|
||||
lvar = (t) zval_is_true(&invar);
|
||||
%enddef
|
||||
|
||||
%define CONVERT_INT_IN(lvar,t,invar)
|
||||
convert_to_long_ex(invar);
|
||||
lvar = (t) Z_LVAL_PP(invar);
|
||||
lvar = (t) zval_get_long(&invar);
|
||||
%enddef
|
||||
|
||||
%define CONVERT_LONG_LONG_IN(lvar,t,invar)
|
||||
switch ((*(invar))->type) {
|
||||
switch (Z_TYPE(invar)) {
|
||||
case IS_DOUBLE:
|
||||
lvar = (t) (*(invar))->value.dval;
|
||||
lvar = (t) Z_DVAL(invar);
|
||||
break;
|
||||
case IS_STRING: {
|
||||
char * endptr;
|
||||
errno = 0;
|
||||
lvar = (t) strtoll((*(invar))->value.str.val, &endptr, 10);
|
||||
lvar = (t) strtoll(Z_STRVAL(invar), &endptr, 10);
|
||||
if (*endptr && !errno) break;
|
||||
/* FALL THRU */
|
||||
}
|
||||
default:
|
||||
convert_to_long_ex(invar);
|
||||
lvar = (t) (*(invar))->value.lval;
|
||||
lvar = (t) zval_get_long(&invar);
|
||||
}
|
||||
%enddef
|
||||
|
||||
%define CONVERT_UNSIGNED_LONG_LONG_IN(lvar,t,invar)
|
||||
switch ((*(invar))->type) {
|
||||
switch (Z_TYPE(invar)) {
|
||||
case IS_DOUBLE:
|
||||
lvar = (t) (*(invar))->value.dval;
|
||||
lvar = (t) Z_DVAL(invar);
|
||||
break;
|
||||
case IS_STRING: {
|
||||
char * endptr;
|
||||
errno = 0;
|
||||
lvar = (t) strtoull((*(invar))->value.str.val, &endptr, 10);
|
||||
lvar = (t) strtoull(Z_STRVAL(invar), &endptr, 10);
|
||||
if (*endptr && !errno) break;
|
||||
/* FALL THRU */
|
||||
}
|
||||
default:
|
||||
convert_to_long_ex(invar);
|
||||
lvar = (t) (*(invar))->value.lval;
|
||||
lvar = (t) zval_get_long(&invar);
|
||||
}
|
||||
%enddef
|
||||
|
||||
%define CONVERT_INT_OUT(lvar,invar)
|
||||
lvar = (t) Z_LVAL_PP(invar);
|
||||
lvar = (t) zval_get_long(&invar);
|
||||
%enddef
|
||||
|
||||
%define CONVERT_FLOAT_IN(lvar,t,invar)
|
||||
convert_to_double_ex(invar);
|
||||
lvar = (t) Z_DVAL_PP(invar);
|
||||
lvar = (t) zval_get_double(&invar);
|
||||
%enddef
|
||||
|
||||
%define CONVERT_CHAR_IN(lvar,t,invar)
|
||||
convert_to_string_ex(invar);
|
||||
lvar = (t) *Z_STRVAL_PP(invar);
|
||||
convert_to_string(&invar);
|
||||
lvar = (t) Z_STRVAL(invar)[0];
|
||||
%enddef
|
||||
|
||||
%define CONVERT_STRING_IN(lvar,t,invar)
|
||||
if ((*invar)->type==IS_NULL) {
|
||||
if (Z_ISNULL(invar)) {
|
||||
lvar = (t) 0;
|
||||
} else {
|
||||
convert_to_string_ex(invar);
|
||||
lvar = (t) Z_STRVAL_PP(invar);
|
||||
convert_to_string(&invar);
|
||||
lvar = (t) Z_STRVAL(invar);
|
||||
}
|
||||
%enddef
|
||||
|
||||
|
|
@ -80,35 +75,42 @@
|
|||
%}
|
||||
%typemap(directorout) TYPE
|
||||
%{
|
||||
CONVERT_IN($result,$1_ltype,&$input);
|
||||
if (!EG(exception)) {
|
||||
CONVERT_IN($result, $1_ltype, *$input);
|
||||
} else {
|
||||
typedef $1_ltype swig_result_typedef;
|
||||
$result = swig_result_typedef();
|
||||
}
|
||||
%}
|
||||
%typemap(directorout) const TYPE & ($*1_ltype temp)
|
||||
%{
|
||||
CONVERT_IN(temp,$*1_ltype,&$input);
|
||||
if (!EG(exception)) {
|
||||
CONVERT_IN(temp, $*1_ltype, *$input);
|
||||
} else {
|
||||
typedef $*1_ltype swig_result_typedef;
|
||||
temp = swig_result_typedef();
|
||||
}
|
||||
$result = &temp;
|
||||
%}
|
||||
%enddef
|
||||
|
||||
%fragment("t_output_helper","header") %{
|
||||
static void
|
||||
t_output_helper(zval **target, zval *o TSRMLS_DC) {
|
||||
zval *tmp;
|
||||
if ( (*target)->type == IS_ARRAY ) {
|
||||
t_output_helper(zval *target, zval *o) {
|
||||
zval tmp;
|
||||
if (Z_TYPE_P(target) == IS_ARRAY) {
|
||||
/* it's already an array, just append */
|
||||
add_next_index_zval( *target, o );
|
||||
add_next_index_zval(target, o);
|
||||
return;
|
||||
}
|
||||
if ( (*target)->type == IS_NULL ) {
|
||||
REPLACE_ZVAL_VALUE(target,o,1);
|
||||
FREE_ZVAL(o);
|
||||
if (Z_TYPE_P(target) == IS_NULL) {
|
||||
/* NULL isn't refcounted */
|
||||
ZVAL_COPY_VALUE(target, o);
|
||||
return;
|
||||
}
|
||||
ALLOC_INIT_ZVAL(tmp);
|
||||
*tmp = **target;
|
||||
zval_copy_ctor(tmp);
|
||||
array_init(*target);
|
||||
add_next_index_zval( *target, tmp);
|
||||
add_next_index_zval( *target, o);
|
||||
|
||||
ZVAL_DUP(&tmp, target);
|
||||
array_init(target);
|
||||
add_next_index_zval(target, &tmp);
|
||||
add_next_index_zval(target, o);
|
||||
}
|
||||
%}
|
||||
|
|
|
|||
51
Lib/php5/const.i
Normal file
51
Lib/php5/const.i
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
/* -----------------------------------------------------------------------------
|
||||
* const.i
|
||||
*
|
||||
* Typemaps for constants
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%typemap(consttab) int,
|
||||
unsigned int,
|
||||
short,
|
||||
unsigned short,
|
||||
long,
|
||||
unsigned long,
|
||||
unsigned char,
|
||||
signed char,
|
||||
bool,
|
||||
enum SWIGTYPE
|
||||
"SWIG_LONG_CONSTANT($symname, ($1_type)$value);";
|
||||
|
||||
%typemap(consttab) float,
|
||||
double
|
||||
"SWIG_DOUBLE_CONSTANT($symname, $value);";
|
||||
|
||||
%typemap(consttab) char
|
||||
"SWIG_CHAR_CONSTANT($symname, $value);";
|
||||
|
||||
%typemap(consttab) char *,
|
||||
const char *,
|
||||
char [],
|
||||
const char []
|
||||
"SWIG_STRING_CONSTANT($symname, $value);";
|
||||
|
||||
%typemap(consttab) SWIGTYPE *,
|
||||
SWIGTYPE &,
|
||||
SWIGTYPE &&,
|
||||
SWIGTYPE [] {
|
||||
zval *z_var;
|
||||
zend_constant c;
|
||||
size_t len = sizeof("$symname") - 1;
|
||||
MAKE_STD_ZVAL(z_var);
|
||||
SWIG_SetPointerZval(z_var, (void*)$value, $1_descriptor, 0);
|
||||
c.value = *z_var;
|
||||
zval_copy_ctor(&c.value);
|
||||
c.name = zend_strndup("$symname", len);
|
||||
c.name_len = len+1;
|
||||
c.flags = CONST_CS | CONST_PERSISTENT;
|
||||
c.module_number = module_number;
|
||||
zend_register_constant( &c TSRMLS_CC );
|
||||
}
|
||||
|
||||
/* Handled as a global variable. */
|
||||
%typemap(consttab) SWIGTYPE (CLASS::*) "";
|
||||
170
Lib/php5/director.swg
Normal file
170
Lib/php5/director.swg
Normal file
|
|
@ -0,0 +1,170 @@
|
|||
/* -----------------------------------------------------------------------------
|
||||
* director.swg
|
||||
*
|
||||
* This file contains support for director classes so that PHP proxy
|
||||
* methods can be called from C++.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
#ifndef SWIG_DIRECTOR_PHP_HEADER_
|
||||
#define SWIG_DIRECTOR_PHP_HEADER_
|
||||
|
||||
#include <string>
|
||||
#include <exception>
|
||||
#include <map>
|
||||
|
||||
namespace Swig {
|
||||
|
||||
/* memory handler */
|
||||
struct GCItem {
|
||||
virtual ~GCItem() {
|
||||
}
|
||||
|
||||
virtual int get_own() const {
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
|
||||
struct GCItem_var {
|
||||
GCItem_var(GCItem *item = 0) : _item(item) {
|
||||
}
|
||||
|
||||
GCItem_var& operator=(GCItem *item) {
|
||||
GCItem *tmp = _item;
|
||||
_item = item;
|
||||
delete tmp;
|
||||
return *this;
|
||||
}
|
||||
|
||||
~GCItem_var() {
|
||||
delete _item;
|
||||
}
|
||||
|
||||
GCItem * operator->() const {
|
||||
return _item;
|
||||
}
|
||||
|
||||
private:
|
||||
GCItem *_item;
|
||||
};
|
||||
|
||||
struct GCItem_Object : GCItem {
|
||||
GCItem_Object(int own) : _own(own) {
|
||||
}
|
||||
|
||||
virtual ~GCItem_Object() {
|
||||
}
|
||||
|
||||
int get_own() const {
|
||||
return _own;
|
||||
}
|
||||
|
||||
private:
|
||||
int _own;
|
||||
};
|
||||
|
||||
template <typename Type>
|
||||
struct GCItem_T : GCItem {
|
||||
GCItem_T(Type *ptr) : _ptr(ptr) {
|
||||
}
|
||||
|
||||
virtual ~GCItem_T() {
|
||||
delete _ptr;
|
||||
}
|
||||
|
||||
private:
|
||||
Type *_ptr;
|
||||
};
|
||||
|
||||
class Director {
|
||||
protected:
|
||||
zval *swig_self;
|
||||
typedef std::map<void *, GCItem_var> swig_ownership_map;
|
||||
mutable swig_ownership_map swig_owner;
|
||||
#ifdef ZTS
|
||||
// Store the ZTS context so it's available when C++ calls back to PHP.
|
||||
void *** swig_zts_ctx;
|
||||
#endif
|
||||
public:
|
||||
Director(zval *self TSRMLS_DC) : swig_self(self) {
|
||||
TSRMLS_SET_CTX(swig_zts_ctx);
|
||||
}
|
||||
|
||||
static bool swig_is_overridden_method(char *cname, char *lc_fname TSRMLS_DC) {
|
||||
zend_class_entry **ce;
|
||||
zend_function *mptr;
|
||||
|
||||
if (zend_lookup_class(cname, strlen(cname), &ce TSRMLS_CC) != SUCCESS) {
|
||||
return false;
|
||||
}
|
||||
if (zend_hash_find(&(*ce)->function_table, lc_fname, strlen(lc_fname) + 1, (void **) &mptr) != SUCCESS) {
|
||||
return false;
|
||||
}
|
||||
// common.scope points to the declaring class
|
||||
return strcmp(mptr->common.scope->name, cname);
|
||||
}
|
||||
|
||||
template <typename Type>
|
||||
void swig_acquire_ownership(Type *vptr) const {
|
||||
if (vptr) {
|
||||
swig_owner[vptr] = new GCItem_T<Type>(vptr);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/* base class for director exceptions */
|
||||
class DirectorException : public std::exception {
|
||||
protected:
|
||||
std::string swig_msg;
|
||||
public:
|
||||
DirectorException(int code, const char *hdr, const char *msg TSRMLS_DC) : swig_msg(hdr) {
|
||||
if (msg[0]) {
|
||||
swig_msg += " ";
|
||||
swig_msg += msg;
|
||||
}
|
||||
SWIG_ErrorCode() = code;
|
||||
SWIG_ErrorMsg() = swig_msg.c_str();
|
||||
}
|
||||
|
||||
virtual ~DirectorException() throw() {
|
||||
}
|
||||
|
||||
const char *what() const throw() {
|
||||
return swig_msg.c_str();
|
||||
}
|
||||
|
||||
static void raise(int code, const char *hdr, const char *msg TSRMLS_DC) {
|
||||
throw DirectorException(code, hdr, msg TSRMLS_CC);
|
||||
}
|
||||
};
|
||||
|
||||
/* attempt to call a pure virtual method via a director method */
|
||||
class DirectorPureVirtualException : public DirectorException {
|
||||
public:
|
||||
DirectorPureVirtualException(const char *msg TSRMLS_DC)
|
||||
: DirectorException(E_ERROR, "SWIG director pure virtual method called", msg TSRMLS_CC) {
|
||||
}
|
||||
|
||||
static void raise(const char *msg TSRMLS_DC) {
|
||||
throw DirectorPureVirtualException(msg TSRMLS_CC);
|
||||
}
|
||||
};
|
||||
|
||||
/* any php exception that occurs during a director method call */
|
||||
class DirectorMethodException : public DirectorException
|
||||
{
|
||||
public:
|
||||
DirectorMethodException(const char *msg TSRMLS_DC)
|
||||
: DirectorException(E_ERROR, "SWIG director method error", msg TSRMLS_CC) {
|
||||
}
|
||||
|
||||
static void raise(const char *msg TSRMLS_DC) {
|
||||
throw DirectorMethodException(msg TSRMLS_CC);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// DirectorMethodException() is documented to be callable with no parameters
|
||||
// so use a macro to insert TSRMLS_CC so any ZTS context gets passed.
|
||||
#define DirectorMethodException() DirectorMethodException("" TSRMLS_CC)
|
||||
|
||||
#endif
|
||||
109
Lib/php5/factory.i
Normal file
109
Lib/php5/factory.i
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
/*
|
||||
Implement a more natural wrap for factory methods, for example, if
|
||||
you have:
|
||||
|
||||
---- geometry.h --------
|
||||
struct Geometry {
|
||||
enum GeomType{
|
||||
POINT,
|
||||
CIRCLE
|
||||
};
|
||||
|
||||
virtual ~Geometry() {}
|
||||
virtual int draw() = 0;
|
||||
|
||||
//
|
||||
// Factory method for all the Geometry objects
|
||||
//
|
||||
static Geometry *create(GeomType i);
|
||||
};
|
||||
|
||||
struct Point : Geometry {
|
||||
int draw() { return 1; }
|
||||
double width() { return 1.0; }
|
||||
};
|
||||
|
||||
struct Circle : Geometry {
|
||||
int draw() { return 2; }
|
||||
double radius() { return 1.5; }
|
||||
};
|
||||
|
||||
//
|
||||
// Factory method for all the Geometry objects
|
||||
//
|
||||
Geometry *Geometry::create(GeomType type) {
|
||||
switch (type) {
|
||||
case POINT: return new Point();
|
||||
case CIRCLE: return new Circle();
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
---- geometry.h --------
|
||||
|
||||
|
||||
You can use the %factory with the Geometry::create method as follows:
|
||||
|
||||
%newobject Geometry::create;
|
||||
%factory(Geometry *Geometry::create, Point, Circle);
|
||||
%include "geometry.h"
|
||||
|
||||
and Geometry::create will return a 'Point' or 'Circle' instance
|
||||
instead of the plain 'Geometry' type. For example, in python:
|
||||
|
||||
circle = Geometry.create(Geometry.CIRCLE)
|
||||
r = circle.radius()
|
||||
|
||||
where circle is a Circle proxy instance.
|
||||
|
||||
NOTES: remember to fully qualify all the type names and don't
|
||||
use %factory inside a namespace declaration, ie, instead of
|
||||
|
||||
namespace Foo {
|
||||
%factory(Geometry *Geometry::create, Point, Circle);
|
||||
}
|
||||
|
||||
use
|
||||
|
||||
%factory(Foo::Geometry *Foo::Geometry::create, Foo::Point, Foo::Circle);
|
||||
|
||||
|
||||
*/
|
||||
|
||||
/* for loop for macro with one argument */
|
||||
%define %_formacro_1(macro, arg1,...)macro(arg1)
|
||||
#if #__VA_ARGS__ != "__fordone__"
|
||||
%_formacro_1(macro, __VA_ARGS__)
|
||||
#endif
|
||||
%enddef
|
||||
|
||||
/* for loop for macro with one argument */
|
||||
%define %formacro_1(macro,...)%_formacro_1(macro,__VA_ARGS__,__fordone__)%enddef
|
||||
%define %formacro(macro,...)%_formacro_1(macro,__VA_ARGS__,__fordone__)%enddef
|
||||
|
||||
/* for loop for macro with two arguments */
|
||||
%define %_formacro_2(macro, arg1, arg2, ...)macro(arg1, arg2)
|
||||
#if #__VA_ARGS__ != "__fordone__"
|
||||
%_formacro_2(macro, __VA_ARGS__)
|
||||
#endif
|
||||
%enddef
|
||||
|
||||
/* for loop for macro with two arguments */
|
||||
%define %formacro_2(macro,...)%_formacro_2(macro, __VA_ARGS__, __fordone__)%enddef
|
||||
|
||||
%define %_factory_dispatch(Type)
|
||||
if (!dcast) {
|
||||
Type *dobj = dynamic_cast<Type *>($1);
|
||||
if (dobj) {
|
||||
dcast = 1;
|
||||
SWIG_SetPointerZval(return_value, SWIG_as_voidptr(dobj),$descriptor(Type *), $owner);
|
||||
}
|
||||
}%enddef
|
||||
|
||||
%define %factory(Method,Types...)
|
||||
%typemap(out) Method {
|
||||
int dcast = 0;
|
||||
%formacro(%_factory_dispatch, Types)
|
||||
if (!dcast) {
|
||||
SWIG_SetPointerZval(return_value, SWIG_as_voidptr($1),$descriptor, $owner);
|
||||
}
|
||||
}%enddef
|
||||
361
Lib/php5/globalvar.i
Normal file
361
Lib/php5/globalvar.i
Normal file
|
|
@ -0,0 +1,361 @@
|
|||
/* -----------------------------------------------------------------------------
|
||||
* globalvar.i
|
||||
*
|
||||
* Global variables - add the variable to PHP
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%typemap(varinit) char *
|
||||
{
|
||||
zval *z_var;
|
||||
MAKE_STD_ZVAL(z_var);
|
||||
z_var->type = IS_STRING;
|
||||
if($1) {
|
||||
z_var->value.str.val = estrdup($1);
|
||||
z_var->value.str.len = strlen($1);
|
||||
} else {
|
||||
z_var->value.str.val = 0;
|
||||
z_var->value.str.len = 0;
|
||||
}
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
|
||||
}
|
||||
|
||||
%typemap(varinit) char []
|
||||
{
|
||||
zval *z_var;
|
||||
MAKE_STD_ZVAL(z_var);
|
||||
z_var->type = IS_STRING;
|
||||
z_var->value.str.val = estrdup($1);
|
||||
z_var->value.str.len = strlen($1);
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
|
||||
}
|
||||
|
||||
%typemap(varinit) int,
|
||||
unsigned int,
|
||||
unsigned short,
|
||||
short,
|
||||
unsigned short,
|
||||
long,
|
||||
unsigned long,
|
||||
signed char,
|
||||
unsigned char,
|
||||
enum SWIGTYPE
|
||||
{
|
||||
zval *z_var;
|
||||
MAKE_STD_ZVAL(z_var);
|
||||
z_var->type = IS_LONG;
|
||||
z_var->value.lval = (long)$1;
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
|
||||
}
|
||||
|
||||
%typemap(varinit) bool
|
||||
{
|
||||
zval *z_var;
|
||||
MAKE_STD_ZVAL(z_var);
|
||||
z_var->type = IS_BOOL;
|
||||
z_var->value.lval = ($1)?1:0;
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var, sizeof(zval *), NULL);
|
||||
}
|
||||
|
||||
%typemap(varinit) float, double
|
||||
{
|
||||
zval *z_var;
|
||||
MAKE_STD_ZVAL(z_var);
|
||||
z_var->type = IS_DOUBLE;
|
||||
z_var->value.dval = $1;
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var,
|
||||
sizeof(zval *), NULL);
|
||||
}
|
||||
|
||||
%typemap(varinit) char
|
||||
{
|
||||
zval *z_var;
|
||||
char c[2];
|
||||
MAKE_STD_ZVAL(z_var);
|
||||
c[0] = $1;
|
||||
c[1] = 0;
|
||||
z_var->type = IS_STRING;
|
||||
z_var->value.str.val = estrndup(c, 1);
|
||||
z_var->value.str.len = 1;
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var,
|
||||
sizeof(zval *), NULL);
|
||||
}
|
||||
|
||||
%typemap(varinit) SWIGTYPE *, SWIGTYPE []
|
||||
{
|
||||
zval *z_var;
|
||||
MAKE_STD_ZVAL(z_var);
|
||||
SWIG_SetPointerZval(z_var, (void*)$1, $1_descriptor, 0);
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void *)&z_var,
|
||||
sizeof(zval *), NULL);
|
||||
}
|
||||
|
||||
%typemap(varinit) SWIGTYPE, SWIGTYPE &, SWIGTYPE &&
|
||||
{
|
||||
zval *z_var;
|
||||
|
||||
MAKE_STD_ZVAL(z_var);
|
||||
SWIG_SetPointerZval(z_var, (void*)&$1, $&1_descriptor, 0);
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void*)&z_var,
|
||||
sizeof(zval *), NULL);
|
||||
}
|
||||
|
||||
%typemap(varinit) char [ANY]
|
||||
{
|
||||
zval *z_var;
|
||||
MAKE_STD_ZVAL(z_var);
|
||||
z_var->type = IS_STRING;
|
||||
ZVAL_STRINGL(z_var,(char*)$1, $1_dim0, 1);
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void*)&z_var, sizeof(zval *), NULL);
|
||||
}
|
||||
|
||||
%typemap(varinit, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
|
||||
{
|
||||
void * p = emalloc(sizeof($1));
|
||||
memcpy(p, &$1, sizeof($1));
|
||||
zval * resource;
|
||||
MAKE_STD_ZVAL(resource);
|
||||
ZEND_REGISTER_RESOURCE(resource, p, swig_member_ptr);
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void*)&resource, sizeof(zval *), NULL);
|
||||
}
|
||||
|
||||
%typemap(varin) int, unsigned int, short, unsigned short, long, unsigned long, signed char, unsigned char, enum SWIGTYPE
|
||||
{
|
||||
zval **z_var;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
convert_to_long_ex(z_var);
|
||||
if ($1 != ($1_ltype)((*z_var)->value.lval)) {
|
||||
$1 = Z_LVAL_PP(z_var);
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(varin) bool
|
||||
{
|
||||
zval **z_var;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
convert_to_boolean_ex(z_var);
|
||||
if ($1 != ($1_ltype)((*z_var)->value.lval)) {
|
||||
$1 = Z_LVAL_PP(z_var);
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(varin) double,float
|
||||
{
|
||||
zval **z_var;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
convert_to_double_ex(z_var);
|
||||
if ($1 != ($1_ltype)((*z_var)->value.dval)) {
|
||||
$1 = Z_DVAL_PP(z_var);
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(varin) char
|
||||
{
|
||||
zval **z_var;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
convert_to_string_ex(z_var);
|
||||
if ($1 != *((*z_var)->value.str.val)) {
|
||||
$1 = *((*z_var)->value.str.val);
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(varin) char *
|
||||
{
|
||||
zval **z_var;
|
||||
char *s1;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
convert_to_string_ex(z_var);
|
||||
s1 = Z_STRVAL_PP(z_var);
|
||||
if ((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) {
|
||||
if (s1)
|
||||
$1 = estrdup(s1);
|
||||
else
|
||||
$1 = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
%typemap(varin) SWIGTYPE []
|
||||
{
|
||||
zval **z_var;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
if($1) {
|
||||
SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, $owner);
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(varin) char [ANY]
|
||||
{
|
||||
zval **z_var;
|
||||
char *s1;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
s1 = Z_STRVAL_PP(z_var);
|
||||
if ((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) {
|
||||
if (s1)
|
||||
strncpy($1, s1, $1_dim0);
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(varin) SWIGTYPE
|
||||
{
|
||||
zval **z_var;
|
||||
$&1_ltype _temp;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
if (SWIG_ConvertPtr(*z_var, (void**)&_temp, $&1_descriptor, 0) < 0) {
|
||||
SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor");
|
||||
}
|
||||
|
||||
$1 = *($&1_ltype)_temp;
|
||||
|
||||
}
|
||||
|
||||
%typemap(varin) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&
|
||||
{
|
||||
zval **z_var;
|
||||
$1_ltype _temp;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
if (SWIG_ConvertPtr(*z_var, (void **)&_temp, $1_descriptor, 0) < 0) {
|
||||
SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor");
|
||||
}
|
||||
|
||||
$1 = ($1_ltype)_temp;
|
||||
}
|
||||
|
||||
%typemap(varin, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
|
||||
{
|
||||
zval **z_var;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
void * p = (void*)zend_fetch_resource(*z_var TSRMLS_CC, -1, SWIG_MEMBER_PTR, NULL, 1, swig_member_ptr);
|
||||
memcpy(&$1, p, sizeof($1));
|
||||
}
|
||||
|
||||
%typemap(varout) int,
|
||||
unsigned int,
|
||||
unsigned short,
|
||||
short,
|
||||
long,
|
||||
unsigned long,
|
||||
signed char,
|
||||
unsigned char,
|
||||
enum SWIGTYPE
|
||||
{
|
||||
zval **z_var;
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
if($1 != ($1_ltype)((*z_var)->value.lval)) {
|
||||
(*z_var)->value.lval = (long)$1;
|
||||
}
|
||||
}
|
||||
|
||||
//SAMFIX need to cast zval->type, what if zend-hash_find fails? etc?
|
||||
%typemap(varout) bool
|
||||
{
|
||||
zval **z_var;
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
if($1 != ($1_ltype)((*z_var)->value.lval)) {
|
||||
(*z_var)->value.lval = (long)$1;
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(varout) double, float
|
||||
{
|
||||
zval **z_var;
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
if($1 != ($1_ltype)((*z_var)->value.dval)) {
|
||||
(*z_var)->value.dval = (double)$1;
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(varout) char
|
||||
{
|
||||
zval **z_var;
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
if($1 != *((*z_var)->value.str.val)) {
|
||||
char c[2];
|
||||
efree((*z_var)->value.str.val);
|
||||
c[0] = $1;
|
||||
c[1] = 0;
|
||||
(*z_var)->value.str.val = estrdup(c);
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(varout) char *
|
||||
{
|
||||
zval **z_var;
|
||||
char *s1;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
s1 = Z_STRVAL_PP(z_var);
|
||||
if((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) {
|
||||
if(s1)
|
||||
efree(s1);
|
||||
if($1) {
|
||||
(*z_var)->value.str.val = estrdup($1);
|
||||
(*z_var)->value.str.len = strlen($1) + 1;
|
||||
} else {
|
||||
(*z_var)->value.str.val = 0;
|
||||
(*z_var)->value.str.len = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(varout) SWIGTYPE
|
||||
{
|
||||
zval **z_var;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
SWIG_SetPointerZval(*z_var, (void*)&$1, $&1_descriptor, 0);
|
||||
}
|
||||
|
||||
%typemap(varout) SWIGTYPE []
|
||||
{
|
||||
zval **z_var;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
if($1)
|
||||
SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, 0);
|
||||
}
|
||||
|
||||
%typemap(varout) char [ANY]
|
||||
{
|
||||
zval **z_var;
|
||||
char *s1;
|
||||
deliberate error cos this code looks bogus to me
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
s1 = Z_STRVAL_PP(z_var);
|
||||
if((s1 == NULL) || strcmp(s1, $1)) {
|
||||
if($1) {
|
||||
(*z_var)->value.str.val = estrdup($1);
|
||||
(*z_var)->value.str.len = strlen($1) + 1;
|
||||
} else {
|
||||
(*z_var)->value.str.val = 0;
|
||||
(*z_var)->value.str.len = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(varout) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&
|
||||
{
|
||||
zval **z_var;
|
||||
|
||||
zend_hash_find(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void**)&z_var);
|
||||
SWIG_SetPointerZval(*z_var, (void*)$1, $1_descriptor, 0);
|
||||
}
|
||||
|
||||
%typemap(varout, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
|
||||
{
|
||||
void * p = emalloc(sizeof($1));
|
||||
memcpy(p, &$1, sizeof($1));
|
||||
zval * resource;
|
||||
MAKE_STD_ZVAL(resource);
|
||||
ZEND_REGISTER_RESOURCE(resource, p, swig_member_ptr);
|
||||
zend_hash_add(&EG(symbol_table), (char*)"$1", sizeof("$1"), (void*)&resource, sizeof(zval *), NULL);
|
||||
}
|
||||
529
Lib/php5/php.swg
Normal file
529
Lib/php5/php.swg
Normal file
|
|
@ -0,0 +1,529 @@
|
|||
/* -----------------------------------------------------------------------------
|
||||
* php.swg
|
||||
*
|
||||
* PHP configuration file
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%runtime "swigrun.swg" // Common C API type-checking code
|
||||
%runtime "phprun.swg" // PHP runtime functions
|
||||
|
||||
%include <phpinit.swg> // PHP initialization routine.
|
||||
|
||||
%include <globalvar.i> // Global variables.
|
||||
%include <const.i>
|
||||
|
||||
// use %init %{ "/*code goes here*/ " %}
|
||||
// or %minit %{ "/* code goes here*/ " %} to
|
||||
// insert code in the PHP_MINIT_FUNCTION
|
||||
#define %minit %insert("init")
|
||||
|
||||
// use %rinit %{ "/* code goes here*/ " %} to
|
||||
// insert code in the PHP_RINIT_FUNCTION
|
||||
#define %rinit %insert("rinit")
|
||||
|
||||
// use %shutdown %{ " /*code goes here*/ " %} to
|
||||
// insert code in the PHP_MSHUTDOWN_FUNCTION
|
||||
#define %shutdown %insert("shutdown")
|
||||
#define %mshutdown %insert("shutdown")
|
||||
|
||||
// use %rshutdown %{ " /*code goes here*/" %} to
|
||||
// insert code in the PHP_RSHUTDOWN_FUNCTION
|
||||
#define %rshutdown %insert("rshutdown")
|
||||
|
||||
/* Typemaps for input parameters by value */
|
||||
|
||||
%include <utils.i>
|
||||
|
||||
%pass_by_val(bool,CONVERT_BOOL_IN);
|
||||
|
||||
%pass_by_val(size_t, CONVERT_INT_IN);
|
||||
|
||||
%pass_by_val(enum SWIGTYPE, CONVERT_INT_IN);
|
||||
|
||||
%pass_by_val(signed int, CONVERT_INT_IN);
|
||||
%pass_by_val(int,CONVERT_INT_IN);
|
||||
%pass_by_val(unsigned int,CONVERT_INT_IN);
|
||||
|
||||
%pass_by_val(signed short, CONVERT_INT_IN);
|
||||
%pass_by_val(short,CONVERT_INT_IN);
|
||||
%pass_by_val(unsigned short, CONVERT_INT_IN);
|
||||
|
||||
%pass_by_val(signed long, CONVERT_INT_IN);
|
||||
%pass_by_val(long, CONVERT_INT_IN);
|
||||
%pass_by_val(unsigned long, CONVERT_INT_IN);
|
||||
|
||||
%pass_by_val(signed long long, CONVERT_LONG_LONG_IN);
|
||||
%pass_by_val(long long, CONVERT_LONG_LONG_IN);
|
||||
%pass_by_val(unsigned long long, CONVERT_UNSIGNED_LONG_LONG_IN);
|
||||
|
||||
%pass_by_val(signed char, CONVERT_INT_IN);
|
||||
%pass_by_val(char, CONVERT_CHAR_IN);
|
||||
%pass_by_val(unsigned char, CONVERT_INT_IN);
|
||||
|
||||
%pass_by_val(float, CONVERT_FLOAT_IN);
|
||||
|
||||
%pass_by_val(double, CONVERT_FLOAT_IN);
|
||||
|
||||
%pass_by_val(char *, CONVERT_STRING_IN);
|
||||
%typemap(in) char *& = const char *&;
|
||||
%typemap(directorout) char *& = const char *&;
|
||||
|
||||
// char array can be in/out, though the passed string may not be big enough...
|
||||
// so we have to size it
|
||||
%typemap(in) char[ANY]
|
||||
{
|
||||
convert_to_string_ex($input);
|
||||
$1 = ($1_ltype) Z_STRVAL_PP($input);
|
||||
}
|
||||
|
||||
%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) {
|
||||
convert_to_string_ex($input);
|
||||
$1 = ($1_ltype) Z_STRVAL_PP($input);
|
||||
$2 = ($2_ltype) Z_STRLEN_PP($input);
|
||||
}
|
||||
|
||||
/* Object passed by value. Convert to a pointer */
|
||||
%typemap(in) SWIGTYPE ($&1_ltype tmp)
|
||||
{
|
||||
if(SWIG_ConvertPtr(*$input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL) {
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
|
||||
}
|
||||
$1 = *tmp;
|
||||
}
|
||||
|
||||
%typemap(directorout) SWIGTYPE ($&1_ltype tmp)
|
||||
{
|
||||
/* If exit was via exception, PHP NULL is returned so skip the conversion. */
|
||||
if (!EG(exception)) {
|
||||
if(SWIG_ConvertPtr($input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL)
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
|
||||
$result = *tmp;
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(in) SWIGTYPE *,
|
||||
SWIGTYPE []
|
||||
{
|
||||
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0) {
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(in) SWIGTYPE &
|
||||
{
|
||||
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) {
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(in) SWIGTYPE &&
|
||||
{
|
||||
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) {
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor");
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(in) SWIGTYPE *const& ($*ltype temp)
|
||||
{
|
||||
if(SWIG_ConvertPtr(*$input, (void **) &temp, $*1_descriptor, 0) < 0) {
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $*1_descriptor");
|
||||
}
|
||||
$1 = ($1_ltype)&temp;
|
||||
}
|
||||
|
||||
%typemap(in) SWIGTYPE *DISOWN
|
||||
{
|
||||
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, SWIG_POINTER_DISOWN ) < 0) {
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(argout) SWIGTYPE *,
|
||||
SWIGTYPE [],
|
||||
SWIGTYPE &,
|
||||
SWIGTYPE &&;
|
||||
|
||||
%typemap(in) void *
|
||||
{
|
||||
if(SWIG_ConvertPtr(*$input, (void **) &$1, 0, 0) < 0) {
|
||||
/* Allow NULL from php for void* */
|
||||
if ((*$input)->type==IS_NULL) $1=0;
|
||||
else
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor");
|
||||
}
|
||||
}
|
||||
|
||||
/* Special case when void* is passed by reference so it can be made to point
|
||||
to opaque api structs */
|
||||
%typemap(in) void ** ($*1_ltype ptr, int force),
|
||||
void *& ($*1_ltype ptr, int force)
|
||||
{
|
||||
/* If they pass NULL by reference, make it into a void*
|
||||
This bit should go in arginit if arginit support init-ing scripting args */
|
||||
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0) {
|
||||
/* So... we didn't get a ref or ptr, but we'll accept NULL by reference */
|
||||
if (!((*$input)->type==IS_NULL && PZVAL_IS_REF(*$input))) {
|
||||
/* wasn't a pre/ref/thing, OR anything like an int thing */
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument $arg of $symname.");
|
||||
}
|
||||
}
|
||||
force=0;
|
||||
if (arg1==NULL) {
|
||||
#ifdef __cplusplus
|
||||
ptr=new $*1_ltype();
|
||||
#else
|
||||
ptr=($*1_ltype) calloc(1,sizeof($*1_ltype));
|
||||
#endif
|
||||
$1=&ptr;
|
||||
/* have to passback arg$arg too */
|
||||
force=1;
|
||||
}
|
||||
}
|
||||
%typemap(argout) void **,
|
||||
void *&
|
||||
{
|
||||
if (force$argnum) {
|
||||
SWIG_SetPointerZval( *$input, (void*) ptr$argnum, $*1_descriptor, 1);
|
||||
}
|
||||
}
|
||||
|
||||
/* Typemap for output values */
|
||||
|
||||
%typemap(out) int,
|
||||
unsigned int,
|
||||
short,
|
||||
unsigned short,
|
||||
long,
|
||||
unsigned long,
|
||||
signed char,
|
||||
unsigned char,
|
||||
bool,
|
||||
size_t
|
||||
{
|
||||
ZVAL_LONG(return_value,$1);
|
||||
}
|
||||
|
||||
%typemap(out) enum SWIGTYPE
|
||||
{
|
||||
ZVAL_LONG(return_value, (long)$1);
|
||||
}
|
||||
|
||||
%typemap(out) long long
|
||||
%{
|
||||
if ((long long)LONG_MIN <= $1 && $1 <= (long long)LONG_MAX) {
|
||||
return_value->value.lval = (long)($1);
|
||||
return_value->type = IS_LONG;
|
||||
} else {
|
||||
char temp[256];
|
||||
sprintf(temp, "%lld", (long long)$1);
|
||||
ZVAL_STRING(return_value, temp, 1);
|
||||
}
|
||||
%}
|
||||
%typemap(out) unsigned long long
|
||||
%{
|
||||
if ($1 <= (unsigned long long)LONG_MAX) {
|
||||
return_value->value.lval = (long)($1);
|
||||
return_value->type = IS_LONG;
|
||||
} else {
|
||||
char temp[256];
|
||||
sprintf(temp, "%llu", (unsigned long long)$1);
|
||||
ZVAL_STRING(return_value, temp, 1);
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(out) const int &,
|
||||
const unsigned int &,
|
||||
const short &,
|
||||
const unsigned short &,
|
||||
const long &,
|
||||
const unsigned long &,
|
||||
const signed char &,
|
||||
const unsigned char &,
|
||||
const bool &,
|
||||
const size_t &
|
||||
{
|
||||
ZVAL_LONG(return_value,*$1);
|
||||
}
|
||||
|
||||
%typemap(out) const enum SWIGTYPE &
|
||||
{
|
||||
ZVAL_LONG(return_value, (long)*$1);
|
||||
}
|
||||
|
||||
%typemap(out) const enum SWIGTYPE &&
|
||||
{
|
||||
ZVAL_LONG(return_value, (long)*$1);
|
||||
}
|
||||
|
||||
%typemap(out) const long long &
|
||||
%{
|
||||
if ((long long)LONG_MIN <= *$1 && *$1 <= (long long)LONG_MAX) {
|
||||
return_value->value.lval = (long)(*$1);
|
||||
return_value->type = IS_LONG;
|
||||
} else {
|
||||
char temp[256];
|
||||
sprintf(temp, "%lld", (long long)(*$1));
|
||||
ZVAL_STRING(return_value, temp, 1);
|
||||
}
|
||||
%}
|
||||
%typemap(out) const unsigned long long &
|
||||
%{
|
||||
if (*$1 <= (unsigned long long)LONG_MAX) {
|
||||
return_value->value.lval = (long)(*$1);
|
||||
return_value->type = IS_LONG;
|
||||
} else {
|
||||
char temp[256];
|
||||
sprintf(temp, "%llu", (unsigned long long)(*$1));
|
||||
ZVAL_STRING(return_value, temp, 1);
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(directorin) int,
|
||||
unsigned int,
|
||||
short,
|
||||
unsigned short,
|
||||
long,
|
||||
unsigned long,
|
||||
signed char,
|
||||
unsigned char,
|
||||
size_t,
|
||||
enum SWIGTYPE
|
||||
{
|
||||
ZVAL_LONG($input,$1);
|
||||
}
|
||||
|
||||
%typemap(directorin) enum SWIGTYPE
|
||||
{
|
||||
ZVAL_LONG($input, (long)$1_name);
|
||||
}
|
||||
|
||||
%typemap(directorin) char *, char []
|
||||
{
|
||||
if(!$1) {
|
||||
ZVAL_NULL($input);
|
||||
} else {
|
||||
ZVAL_STRING($input, (char *)$1, 1);
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(out) bool
|
||||
{
|
||||
ZVAL_BOOL(return_value,($1)?1:0);
|
||||
}
|
||||
|
||||
%typemap(out) const bool &
|
||||
{
|
||||
ZVAL_BOOL(return_value,(*$1)?1:0);
|
||||
}
|
||||
|
||||
%typemap(directorin) bool
|
||||
{
|
||||
ZVAL_BOOL($input,($1)?1:0);
|
||||
}
|
||||
|
||||
%typemap(out) float,
|
||||
double
|
||||
{
|
||||
ZVAL_DOUBLE(return_value,$1);
|
||||
}
|
||||
|
||||
%typemap(out) const float &,
|
||||
const double &
|
||||
{
|
||||
ZVAL_DOUBLE(return_value,*$1);
|
||||
}
|
||||
|
||||
%typemap(directorin) float,
|
||||
double
|
||||
{
|
||||
ZVAL_DOUBLE($input,$1);
|
||||
}
|
||||
|
||||
%typemap(out) char
|
||||
{
|
||||
ZVAL_STRINGL(return_value,&$1, 1, 1);
|
||||
}
|
||||
|
||||
%typemap(out) const char &
|
||||
{
|
||||
ZVAL_STRINGL(return_value,&*$1, 1, 1);
|
||||
}
|
||||
|
||||
%typemap(out) char *,
|
||||
char []
|
||||
{
|
||||
if(!$1) {
|
||||
ZVAL_NULL(return_value);
|
||||
} else {
|
||||
ZVAL_STRING(return_value, (char *)$1, 1);
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(out) char *&
|
||||
{
|
||||
if(!*$1) {
|
||||
ZVAL_NULL(return_value);
|
||||
} else {
|
||||
ZVAL_STRING(return_value, (char *)*$1, 1);
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(out) SWIGTYPE *,
|
||||
SWIGTYPE [],
|
||||
SWIGTYPE &,
|
||||
SWIGTYPE &&
|
||||
%{
|
||||
SWIG_SetPointerZval(return_value, (void *)$1, $1_descriptor, $owner);
|
||||
%}
|
||||
|
||||
%typemap(out) SWIGTYPE *const&
|
||||
%{
|
||||
SWIG_SetPointerZval(return_value, (void *)*$1, $*1_descriptor, $owner);
|
||||
%}
|
||||
|
||||
%typemap(directorin) SWIGTYPE *,
|
||||
SWIGTYPE [],
|
||||
SWIGTYPE &,
|
||||
SWIGTYPE &&
|
||||
%{
|
||||
SWIG_SetPointerZval($input, (void *)&$1, $1_descriptor, ($owner)|2);
|
||||
%}
|
||||
|
||||
%typemap(out, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
|
||||
{
|
||||
void * p = emalloc(sizeof($1));
|
||||
memcpy(p, &$1, sizeof($1));
|
||||
ZEND_REGISTER_RESOURCE(return_value, p, swig_member_ptr);
|
||||
}
|
||||
|
||||
%typemap(in, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*)
|
||||
{
|
||||
void * p = (void*)zend_fetch_resource($input TSRMLS_CC, -1, SWIG_MEMBER_PTR, NULL, 1, swig_member_ptr);
|
||||
memcpy(&$1, p, sizeof($1));
|
||||
}
|
||||
|
||||
%typemap(out) SWIGTYPE *DYNAMIC,
|
||||
SWIGTYPE &DYNAMIC
|
||||
{
|
||||
swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor, (void **) &$1);
|
||||
SWIG_SetPointerZval(return_value, (void *)$1, ty, $owner);
|
||||
}
|
||||
|
||||
%typemap(out) SWIGTYPE
|
||||
#ifdef __cplusplus
|
||||
{
|
||||
$&1_ltype resultobj = new $1_ltype((const $1_ltype &) $1);
|
||||
SWIG_SetPointerZval(return_value, (void *)resultobj, $&1_descriptor, 1);
|
||||
}
|
||||
#else
|
||||
{
|
||||
$&1_ltype resultobj = ($&1_ltype) emalloc(sizeof($1_type));
|
||||
memcpy(resultobj, &$1, sizeof($1_type));
|
||||
SWIG_SetPointerZval(return_value, (void *)resultobj, $&1_descriptor, 1);
|
||||
}
|
||||
#endif
|
||||
|
||||
%typemap(directorin) SWIGTYPE
|
||||
{
|
||||
SWIG_SetPointerZval($input, SWIG_as_voidptr(new $1_ltype((const $1_ltype &)$1)), $&1_descriptor, 1|2);
|
||||
}
|
||||
|
||||
%typemap(out) void "";
|
||||
|
||||
%typemap(out) char [ANY]
|
||||
{
|
||||
int len = 0;
|
||||
while (len < $1_dim0 && $1[len]) ++len;
|
||||
RETVAL_STRINGL($1, len, 1);
|
||||
}
|
||||
|
||||
// This typecheck does hard checking for proper argument type. If you want
|
||||
// an argument to be converted from a different PHP type, you must convert
|
||||
// it yourself before passing it (e.g. (string)4.7 or (int)"6").
|
||||
%define %php_typecheck(_type,_prec,is)
|
||||
%typemap(typecheck,precedence=_prec) _type, const _type &
|
||||
" $1 = (Z_TYPE_PP($input) == is); "
|
||||
%enddef
|
||||
|
||||
%php_typecheck(int,SWIG_TYPECHECK_INTEGER,IS_LONG)
|
||||
%php_typecheck(unsigned int,SWIG_TYPECHECK_UINT32,IS_LONG)
|
||||
%php_typecheck(short,SWIG_TYPECHECK_INT16,IS_LONG)
|
||||
%php_typecheck(unsigned short,SWIG_TYPECHECK_UINT16,IS_LONG)
|
||||
%php_typecheck(long,SWIG_TYPECHECK_INT32,IS_LONG)
|
||||
%php_typecheck(unsigned long,SWIG_TYPECHECK_UINT32,IS_LONG)
|
||||
%php_typecheck(long long,SWIG_TYPECHECK_INT64,IS_LONG)
|
||||
%php_typecheck(unsigned long long,SWIG_TYPECHECK_UINT64,IS_LONG)
|
||||
%php_typecheck(signed char,SWIG_TYPECHECK_INT8,IS_LONG)
|
||||
%php_typecheck(unsigned char,SWIG_TYPECHECK_UINT8,IS_LONG)
|
||||
%php_typecheck(size_t,SWIG_TYPECHECK_SIZE,IS_LONG)
|
||||
%php_typecheck(enum SWIGTYPE,SWIG_TYPECHECK_INTEGER,IS_LONG)
|
||||
%php_typecheck(bool,SWIG_TYPECHECK_BOOL,IS_BOOL)
|
||||
%php_typecheck(float,SWIG_TYPECHECK_FLOAT,IS_DOUBLE)
|
||||
%php_typecheck(double,SWIG_TYPECHECK_DOUBLE,IS_DOUBLE)
|
||||
%php_typecheck(char,SWIG_TYPECHECK_CHAR,IS_STRING)
|
||||
|
||||
%typemap(typecheck,precedence=SWIG_TYPECHECK_STRING) char *, char *&, char []
|
||||
" $1 = (Z_TYPE_PP($input) == IS_STRING); "
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE
|
||||
{
|
||||
void *tmp;
|
||||
_v = (SWIG_ConvertPtr(*$input, (void **)&tmp, $&1_descriptor, 0) >= 0);
|
||||
}
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_POINTER)
|
||||
SWIGTYPE *,
|
||||
SWIGTYPE [],
|
||||
SWIGTYPE &,
|
||||
SWIGTYPE &&,
|
||||
SWIGTYPE *const&
|
||||
{
|
||||
void *tmp;
|
||||
_v = (SWIG_ConvertPtr(*$input, (void**)&tmp, $1_descriptor, 0) >= 0);
|
||||
}
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *const&
|
||||
{
|
||||
void *tmp;
|
||||
_v = (SWIG_ConvertPtr(*$input, (void**)&tmp, $*1_descriptor, 0) >= 0);
|
||||
}
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_VOIDPTR) void *
|
||||
{
|
||||
void *tmp;
|
||||
_v = (SWIG_ConvertPtr(*$input, (void**)&tmp, 0, 0) >= 0);
|
||||
}
|
||||
|
||||
/* Exception handling */
|
||||
|
||||
%typemap(throws) int,
|
||||
long,
|
||||
short,
|
||||
unsigned int,
|
||||
unsigned long,
|
||||
unsigned short {
|
||||
zend_throw_exception(NULL, const_cast<char*>("C++ $1_type exception thrown"), $1 TSRMLS_CC);
|
||||
return;
|
||||
}
|
||||
|
||||
%typemap(throws) SWIGTYPE, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE *, SWIGTYPE [], SWIGTYPE [ANY] %{
|
||||
(void)$1;
|
||||
zend_throw_exception(NULL, const_cast<char*>("C++ $1_type exception thrown"), 0 TSRMLS_CC);
|
||||
return;
|
||||
%}
|
||||
|
||||
%typemap(throws) char * %{
|
||||
zend_throw_exception(NULL, const_cast<char*>($1), 0 TSRMLS_CC);
|
||||
return;
|
||||
%}
|
||||
|
||||
/* Array reference typemaps */
|
||||
%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
|
||||
%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) }
|
||||
|
||||
/* const pointers */
|
||||
%apply SWIGTYPE * { SWIGTYPE *const }
|
||||
|
||||
|
||||
/* php keywords */
|
||||
%include <phpkw.swg>
|
||||
25
Lib/php5/phpinit.swg
Normal file
25
Lib/php5/phpinit.swg
Normal file
|
|
@ -0,0 +1,25 @@
|
|||
|
||||
/* ------------------------------------------------------------
|
||||
* The start of the PHP initialization function
|
||||
* ------------------------------------------------------------ */
|
||||
|
||||
%insert(init) "swiginit.swg"
|
||||
|
||||
%init %{
|
||||
SWIG_php_minit {
|
||||
SWIG_InitializeModule(0);
|
||||
%}
|
||||
|
||||
%fragment("swig_php_init_member_ptr2", "header") {
|
||||
#define SWIG_MEMBER_PTR ((char*)"CLASS::*")
|
||||
|
||||
static void swig_member_ptr_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) {
|
||||
efree(rsrc->ptr);
|
||||
}
|
||||
|
||||
static int swig_member_ptr = 0;
|
||||
}
|
||||
|
||||
%fragment("swig_php_init_member_ptr", "init", fragment="swig_php_init_member_ptr2") {
|
||||
swig_member_ptr = zend_register_list_destructors_ex(swig_member_ptr_dtor, NULL, SWIG_MEMBER_PTR, module_number);
|
||||
}
|
||||
866
Lib/php5/phpkw.swg
Normal file
866
Lib/php5/phpkw.swg
Normal file
|
|
@ -0,0 +1,866 @@
|
|||
/* -----------------------------------------------------------------------------
|
||||
* phpkw.swg
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
/* Keyword (case insensitive) */
|
||||
#define PHPKW(x) %keywordwarn("'" `x` "' is a PHP keyword, renaming to 'c_" `x` "'",sourcefmt="%(lower)s",rename="c_%s") `x`
|
||||
|
||||
/* Class (case insensitive) */
|
||||
#define PHPCN(x) %keywordwarn("'" `x` "' is a PHP reserved class name, renaming to 'c_" `x` "'",%$isclass,sourcefmt="%(lower)s",rename="c_%s") `x`
|
||||
|
||||
/* Constant (case insensitive) */
|
||||
#define PHPBN1a(x) %namewarn(%warningmsg(SWIGWARN_PARSE_BUILTIN_NAME, "enum conflicts with a built-in constant '"`x`"' in PHP"),%$isenumitem,sourcefmt="%(lower)s") `x`
|
||||
#define PHPBN1b(x) %namewarn(%warningmsg(SWIGWARN_PARSE_BUILTIN_NAME, "constant conflicts with a built-in constant '"`x`"' in PHP"),%$isconstant,sourcefmt="%(lower)s") `x`
|
||||
%define PHPBN1(X)
|
||||
PHPBN1a(X); PHPBN1b(X)
|
||||
%enddef
|
||||
|
||||
/* Constant (case sensitive) */
|
||||
#define PHPBN2a(x) %namewarn(%warningmsg(SWIGWARN_PARSE_BUILTIN_NAME, "enum conflicts with a built-in constant '"`x`"' in PHP"),%$isenumitem) `x`
|
||||
#define PHPBN2b(x) %namewarn(%warningmsg(SWIGWARN_PARSE_BUILTIN_NAME, "constant conflicts with a built-in constant '"`x`"' in PHP"),%$isconstant) `x`
|
||||
%define PHPBN2(X)
|
||||
PHPBN2a(X); PHPBN2b(X)
|
||||
%enddef
|
||||
|
||||
#define PHPFN(x) %keywordwarn("'" `x` "' is a PHP built-in function, renaming to 'c_" `x` "'",sourcefmt="%(lower)s",%$isfunction,%$not %$ismember,rename="c_%s") `x`
|
||||
|
||||
/* From: http://php.net/manual/en/reserved.keywords.php
|
||||
* "You cannot use any of the following words as constants, class names,
|
||||
* function or method names. Using them as variable names is generally OK, but
|
||||
* could lead to confusion."
|
||||
*/
|
||||
/* Check is case insensitive - these *MUST* be listed in lower case here */
|
||||
PHPKW(__halt_compiler);
|
||||
PHPKW(abstract);
|
||||
PHPKW(and);
|
||||
PHPKW(array);
|
||||
PHPKW(as);
|
||||
PHPKW(break);
|
||||
PHPKW(callable); // As of PHP 5.4
|
||||
PHPKW(case);
|
||||
PHPKW(catch);
|
||||
PHPKW(class);
|
||||
PHPKW(clone);
|
||||
PHPKW(const);
|
||||
PHPKW(continue);
|
||||
PHPKW(declare);
|
||||
PHPKW(default);
|
||||
PHPKW(die); // "Language construct"
|
||||
PHPKW(do);
|
||||
PHPKW(echo); // "Language construct"
|
||||
PHPKW(else);
|
||||
PHPKW(elseif);
|
||||
PHPKW(empty); // "Language construct"
|
||||
PHPKW(enddeclare);
|
||||
PHPKW(endfor);
|
||||
PHPKW(endforeach);
|
||||
PHPKW(endif);
|
||||
PHPKW(endswitch);
|
||||
PHPKW(endwhile);
|
||||
PHPKW(eval); // "Language construct"
|
||||
PHPKW(exit); // "Language construct"
|
||||
PHPKW(extends);
|
||||
PHPKW(final);
|
||||
PHPKW(finally); // As of PHP 5.5
|
||||
PHPKW(for);
|
||||
PHPKW(foreach);
|
||||
PHPKW(function);
|
||||
PHPKW(global);
|
||||
PHPKW(goto); // As of PHP 5.3
|
||||
PHPKW(if);
|
||||
PHPKW(implements);
|
||||
PHPKW(include); // "Language construct"
|
||||
PHPKW(include_once); // "Language construct"
|
||||
PHPKW(instanceof);
|
||||
PHPKW(insteadof); // As of PHP 5.4
|
||||
PHPKW(interface);
|
||||
PHPKW(isset); // "Language construct"
|
||||
PHPKW(list); // "Language construct"
|
||||
PHPKW(namespace); // As of PHP 5.3
|
||||
PHPKW(new);
|
||||
PHPKW(or);
|
||||
PHPKW(print); // "Language construct"
|
||||
PHPKW(private);
|
||||
PHPKW(protected);
|
||||
PHPKW(public);
|
||||
PHPKW(require); // "Language construct"
|
||||
PHPKW(require_once); // "Language construct"
|
||||
PHPKW(return); // "Language construct"
|
||||
PHPKW(static);
|
||||
PHPKW(switch);
|
||||
PHPKW(throw);
|
||||
PHPKW(trait); // As of PHP 5.4
|
||||
PHPKW(try);
|
||||
PHPKW(unset); // "Language construct"
|
||||
PHPKW(use);
|
||||
PHPKW(var);
|
||||
PHPKW(while);
|
||||
PHPKW(xor);
|
||||
PHPKW(yield); // As of PHP 5.5
|
||||
|
||||
// Compile-time "magic" constants
|
||||
// From: http://php.net/manual/en/reserved.keywords.php
|
||||
// also at: http://php.net/manual/en/language.constants.predefined.php
|
||||
/* These *MUST* be listed in lower case here */
|
||||
PHPKW(__class__);
|
||||
PHPKW(__dir__); // As of PHP 5.3
|
||||
PHPKW(__file__);
|
||||
PHPKW(__function__);
|
||||
PHPKW(__line__);
|
||||
PHPKW(__method__);
|
||||
PHPKW(__namespace__); // As of PHP 5.3
|
||||
PHPKW(__trait__); // As of PHP 5.4
|
||||
|
||||
/* We classify these as built-in names since they conflict, but PHP still runs */
|
||||
|
||||
/* Predefined case-insensitive constants */
|
||||
/* These *MUST* be listed in lower case here */
|
||||
PHPBN1(null);
|
||||
PHPBN1(true);
|
||||
PHPBN1(false);
|
||||
|
||||
/* "Core Predefined Constants" from http://php.net/manual/en/reserved.constants.php */
|
||||
/* These are case sensitive */
|
||||
PHPBN2(PHP_VERSION);
|
||||
PHPBN2(PHP_MAJOR_VERSION); // As of PHP 5.2.7
|
||||
PHPBN2(PHP_MINOR_VERSION); // As of PHP 5.2.7
|
||||
PHPBN2(PHP_RELEASE_VERSION); // As of PHP 5.2.7
|
||||
PHPBN2(PHP_VERSION_ID); // As of PHP 5.2.7
|
||||
PHPBN2(PHP_EXTRA_VERSION); // As of PHP 5.2.7
|
||||
PHPBN2(PHP_ZTS); // As of PHP 5.2.7
|
||||
PHPBN2(PHP_DEBUG); // As of PHP 5.2.7
|
||||
PHPBN2(PHP_MAXPATHLEN); // As of PHP 5.3.0
|
||||
PHPBN2(PHP_OS);
|
||||
PHPBN2(PHP_SAPI);
|
||||
PHPBN2(PHP_EOL); // As of PHP 5.0.2
|
||||
PHPBN2(PHP_INT_MAX); // As of PHP 5.0.5
|
||||
PHPBN2(PHP_INT_SIZE); // As of PHP 5.0.5
|
||||
PHPBN2(DEFAULT_INCLUDE_PATH);
|
||||
PHPBN2(PEAR_INSTALL_DIR);
|
||||
PHPBN2(PEAR_EXTENSION_DIR);
|
||||
PHPBN2(PHP_EXTENSION_DIR);
|
||||
PHPBN2(PHP_PREFIX);
|
||||
PHPBN2(PHP_BINDIR);
|
||||
PHPBN2(PHP_BINARY); // As of PHP 5.4
|
||||
PHPBN2(PHP_MANDIR); // As of PHP 5.3.7
|
||||
PHPBN2(PHP_LIBDIR);
|
||||
PHPBN2(PHP_DATADIR);
|
||||
PHPBN2(PHP_SYSCONFDIR);
|
||||
PHPBN2(PHP_LOCALSTATEDIR);
|
||||
PHPBN2(PHP_CONFIG_FILE_PATH);
|
||||
PHPBN2(PHP_CONFIG_FILE_SCAN_DIR);
|
||||
PHPBN2(PHP_SHLIB_SUFFIX);
|
||||
PHPBN2(E_ERROR);
|
||||
PHPBN2(E_WARNING);
|
||||
PHPBN2(E_PARSE);
|
||||
PHPBN2(E_NOTICE);
|
||||
PHPBN2(E_CORE_ERROR);
|
||||
PHPBN2(E_CORE_WARNING);
|
||||
PHPBN2(E_COMPILE_ERROR);
|
||||
PHPBN2(E_COMPILE_WARNING);
|
||||
PHPBN2(E_USER_ERROR);
|
||||
PHPBN2(E_USER_WARNING);
|
||||
PHPBN2(E_USER_NOTICE);
|
||||
PHPBN2(E_DEPRECATED); // As of PHP 5.3.0
|
||||
PHPBN2(E_USER_DEPRECATED); // As of PHP 5.3.0
|
||||
PHPBN2(E_ALL);
|
||||
PHPBN2(E_STRICT);
|
||||
PHPBN2(__COMPILER_HALT_OFFSET__); // As of PHP 5.1.0
|
||||
// TRUE, FALSE, NULL are listed on the same page, but are actually
|
||||
// case-insensitive, whereas all the other constants listed there seem to be
|
||||
// case-sensitive, so we handle TRUE, FALSE, NULL in PHPBN1.
|
||||
PHPBN2(PHP_OUTPUT_HANDLER_START);
|
||||
PHPBN2(PHP_OUTPUT_HANDLER_CONT);
|
||||
PHPBN2(PHP_OUTPUT_HANDLER_END);
|
||||
/* These don't actually seem to be set (tested on Linux, I guess they're
|
||||
* Windows only?) */
|
||||
PHPBN2(PHP_WINDOWS_NT_DOMAIN_CONTROLLER); // As of PHP 5.3
|
||||
PHPBN2(PHP_WINDOWS_NT_SERVER); // As of PHP 5.3
|
||||
PHPBN2(PHP_WINDOWS_NT_WORKSTATION); // As of PHP 5.3
|
||||
PHPBN2(PHP_WINDOWS_VERSION_BUILD); // As of PHP 5.3
|
||||
PHPBN2(PHP_WINDOWS_VERSION_MAJOR); // As of PHP 5.3
|
||||
PHPBN2(PHP_WINDOWS_VERSION_MINOR); // As of PHP 5.3
|
||||
PHPBN2(PHP_WINDOWS_VERSION_PLATFORM); // As of PHP 5.3
|
||||
PHPBN2(PHP_WINDOWS_VERSION_PRODUCTTYPE); // As of PHP 5.3
|
||||
PHPBN2(PHP_WINDOWS_VERSION_SP_MAJOR); // As of PHP 5.3
|
||||
PHPBN2(PHP_WINDOWS_VERSION_SP_MINOR); // As of PHP 5.3
|
||||
PHPBN2(PHP_WINDOWS_VERSION_SUITEMASK); // As of PHP 5.3
|
||||
/* "Standard Predefined Constants" from http://php.net/manual/en/reserved.constants.php */
|
||||
PHPBN2(EXTR_OVERWRITE);
|
||||
PHPBN2(EXTR_SKIP);
|
||||
PHPBN2(EXTR_PREFIX_SAME);
|
||||
PHPBN2(EXTR_PREFIX_ALL);
|
||||
PHPBN2(EXTR_PREFIX_INVALID);
|
||||
PHPBN2(EXTR_PREFIX_IF_EXISTS);
|
||||
PHPBN2(EXTR_IF_EXISTS);
|
||||
PHPBN2(SORT_ASC);
|
||||
PHPBN2(SORT_DESC);
|
||||
PHPBN2(SORT_REGULAR);
|
||||
PHPBN2(SORT_NUMERIC);
|
||||
PHPBN2(SORT_STRING);
|
||||
PHPBN2(CASE_LOWER);
|
||||
PHPBN2(CASE_UPPER);
|
||||
PHPBN2(COUNT_NORMAL);
|
||||
PHPBN2(COUNT_RECURSIVE);
|
||||
PHPBN2(ASSERT_ACTIVE);
|
||||
PHPBN2(ASSERT_CALLBACK);
|
||||
PHPBN2(ASSERT_BAIL);
|
||||
PHPBN2(ASSERT_WARNING);
|
||||
PHPBN2(ASSERT_QUIET_EVAL);
|
||||
PHPBN2(CONNECTION_ABORTED);
|
||||
PHPBN2(CONNECTION_NORMAL);
|
||||
PHPBN2(CONNECTION_TIMEOUT);
|
||||
PHPBN2(INI_USER);
|
||||
PHPBN2(INI_PERDIR);
|
||||
PHPBN2(INI_SYSTEM);
|
||||
PHPBN2(INI_ALL);
|
||||
PHPBN2(INI_SCANNER_NORMAL); // As of PHP 5.3
|
||||
PHPBN2(INI_SCANNER_RAW); // As of PHP 5.3
|
||||
PHPBN2(M_E);
|
||||
PHPBN2(M_LOG2E);
|
||||
PHPBN2(M_LOG10E);
|
||||
PHPBN2(M_LN2);
|
||||
PHPBN2(M_LN10);
|
||||
PHPBN2(M_PI);
|
||||
PHPBN2(M_PI_2);
|
||||
PHPBN2(M_PI_4);
|
||||
PHPBN2(M_1_PI);
|
||||
PHPBN2(M_2_PI);
|
||||
PHPBN2(M_2_SQRTPI);
|
||||
PHPBN2(M_SQRT2);
|
||||
PHPBN2(M_SQRT1_2);
|
||||
PHPBN2(M_EULER); // As of PHP 5.2
|
||||
PHPBN2(M_LNPI); // As of PHP 5.2
|
||||
PHPBN2(M_SQRT3); // As of PHP 5.2
|
||||
PHPBN2(M_SQRTPI); // As of PHP 5.2
|
||||
PHPBN2(CRYPT_SALT_LENGTH);
|
||||
PHPBN2(CRYPT_STD_DES);
|
||||
PHPBN2(CRYPT_EXT_DES);
|
||||
PHPBN2(CRYPT_MD5);
|
||||
PHPBN2(CRYPT_BLOWFISH);
|
||||
PHPBN2(DIRECTORY_SEPARATOR);
|
||||
PHPBN2(SEEK_SET);
|
||||
PHPBN2(SEEK_CUR);
|
||||
PHPBN2(SEEK_END);
|
||||
PHPBN2(LOCK_SH);
|
||||
PHPBN2(LOCK_EX);
|
||||
PHPBN2(LOCK_UN);
|
||||
PHPBN2(LOCK_NB);
|
||||
PHPBN2(HTML_SPECIALCHARS);
|
||||
PHPBN2(HTML_ENTITIES);
|
||||
PHPBN2(ENT_COMPAT);
|
||||
PHPBN2(ENT_QUOTES);
|
||||
PHPBN2(ENT_NOQUOTES);
|
||||
PHPBN2(INFO_GENERAL);
|
||||
PHPBN2(INFO_CREDITS);
|
||||
PHPBN2(INFO_CONFIGURATION);
|
||||
PHPBN2(INFO_MODULES);
|
||||
PHPBN2(INFO_ENVIRONMENT);
|
||||
PHPBN2(INFO_VARIABLES);
|
||||
PHPBN2(INFO_LICENSE);
|
||||
PHPBN2(INFO_ALL);
|
||||
PHPBN2(CREDITS_GROUP);
|
||||
PHPBN2(CREDITS_GENERAL);
|
||||
PHPBN2(CREDITS_SAPI);
|
||||
PHPBN2(CREDITS_MODULES);
|
||||
PHPBN2(CREDITS_DOCS);
|
||||
PHPBN2(CREDITS_FULLPAGE);
|
||||
PHPBN2(CREDITS_QA);
|
||||
PHPBN2(CREDITS_ALL);
|
||||
PHPBN2(STR_PAD_LEFT);
|
||||
PHPBN2(STR_PAD_RIGHT);
|
||||
PHPBN2(STR_PAD_BOTH);
|
||||
PHPBN2(PATHINFO_DIRNAME);
|
||||
PHPBN2(PATHINFO_BASENAME);
|
||||
PHPBN2(PATHINFO_EXTENSION);
|
||||
PHPBN2(PATHINFO_FILENAME); // As of PHP 5.2
|
||||
PHPBN2(PATH_SEPARATOR);
|
||||
PHPBN2(CHAR_MAX);
|
||||
PHPBN2(LC_CTYPE);
|
||||
PHPBN2(LC_NUMERIC);
|
||||
PHPBN2(LC_TIME);
|
||||
PHPBN2(LC_COLLATE);
|
||||
PHPBN2(LC_MONETARY);
|
||||
PHPBN2(LC_ALL);
|
||||
PHPBN2(LC_MESSAGES);
|
||||
PHPBN2(ABDAY_1);
|
||||
PHPBN2(ABDAY_2);
|
||||
PHPBN2(ABDAY_3);
|
||||
PHPBN2(ABDAY_4);
|
||||
PHPBN2(ABDAY_5);
|
||||
PHPBN2(ABDAY_6);
|
||||
PHPBN2(ABDAY_7);
|
||||
PHPBN2(DAY_1);
|
||||
PHPBN2(DAY_2);
|
||||
PHPBN2(DAY_3);
|
||||
PHPBN2(DAY_4);
|
||||
PHPBN2(DAY_5);
|
||||
PHPBN2(DAY_6);
|
||||
PHPBN2(DAY_7);
|
||||
PHPBN2(ABMON_1);
|
||||
PHPBN2(ABMON_2);
|
||||
PHPBN2(ABMON_3);
|
||||
PHPBN2(ABMON_4);
|
||||
PHPBN2(ABMON_5);
|
||||
PHPBN2(ABMON_6);
|
||||
PHPBN2(ABMON_7);
|
||||
PHPBN2(ABMON_8);
|
||||
PHPBN2(ABMON_9);
|
||||
PHPBN2(ABMON_10);
|
||||
PHPBN2(ABMON_11);
|
||||
PHPBN2(ABMON_12);
|
||||
PHPBN2(MON_1);
|
||||
PHPBN2(MON_2);
|
||||
PHPBN2(MON_3);
|
||||
PHPBN2(MON_4);
|
||||
PHPBN2(MON_5);
|
||||
PHPBN2(MON_6);
|
||||
PHPBN2(MON_7);
|
||||
PHPBN2(MON_8);
|
||||
PHPBN2(MON_9);
|
||||
PHPBN2(MON_10);
|
||||
PHPBN2(MON_11);
|
||||
PHPBN2(MON_12);
|
||||
PHPBN2(AM_STR);
|
||||
PHPBN2(PM_STR);
|
||||
PHPBN2(D_T_FMT);
|
||||
PHPBN2(D_FMT);
|
||||
PHPBN2(T_FMT);
|
||||
PHPBN2(T_FMT_AMPM);
|
||||
PHPBN2(ERA);
|
||||
PHPBN2(ERA_YEAR);
|
||||
PHPBN2(ERA_D_T_FMT);
|
||||
PHPBN2(ERA_D_FMT);
|
||||
PHPBN2(ERA_T_FMT);
|
||||
PHPBN2(ALT_DIGITS);
|
||||
PHPBN2(INT_CURR_SYMBOL);
|
||||
PHPBN2(CURRENCY_SYMBOL);
|
||||
PHPBN2(CRNCYSTR);
|
||||
PHPBN2(MON_DECIMAL_POINT);
|
||||
PHPBN2(MON_THOUSANDS_SEP);
|
||||
PHPBN2(MON_GROUPING);
|
||||
PHPBN2(POSITIVE_SIGN);
|
||||
PHPBN2(NEGATIVE_SIGN);
|
||||
PHPBN2(INT_FRAC_DIGITS);
|
||||
PHPBN2(FRAC_DIGITS);
|
||||
PHPBN2(P_CS_PRECEDES);
|
||||
PHPBN2(P_SEP_BY_SPACE);
|
||||
PHPBN2(N_CS_PRECEDES);
|
||||
PHPBN2(N_SEP_BY_SPACE);
|
||||
PHPBN2(P_SIGN_POSN);
|
||||
PHPBN2(N_SIGN_POSN);
|
||||
PHPBN2(DECIMAL_POINT);
|
||||
PHPBN2(RADIXCHAR);
|
||||
PHPBN2(THOUSANDS_SEP);
|
||||
PHPBN2(THOUSEP);
|
||||
PHPBN2(GROUPING);
|
||||
PHPBN2(YESEXPR);
|
||||
PHPBN2(NOEXPR);
|
||||
PHPBN2(YESSTR);
|
||||
PHPBN2(NOSTR);
|
||||
PHPBN2(CODESET);
|
||||
PHPBN2(LOG_EMERG);
|
||||
PHPBN2(LOG_ALERT);
|
||||
PHPBN2(LOG_CRIT);
|
||||
PHPBN2(LOG_ERR);
|
||||
PHPBN2(LOG_WARNING);
|
||||
PHPBN2(LOG_NOTICE);
|
||||
PHPBN2(LOG_INFO);
|
||||
PHPBN2(LOG_DEBUG);
|
||||
PHPBN2(LOG_KERN);
|
||||
PHPBN2(LOG_USER);
|
||||
PHPBN2(LOG_MAIL);
|
||||
PHPBN2(LOG_DAEMON);
|
||||
PHPBN2(LOG_AUTH);
|
||||
PHPBN2(LOG_SYSLOG);
|
||||
PHPBN2(LOG_LPR);
|
||||
PHPBN2(LOG_NEWS);
|
||||
PHPBN2(LOG_UUCP);
|
||||
PHPBN2(LOG_CRON);
|
||||
PHPBN2(LOG_AUTHPRIV);
|
||||
PHPBN2(LOG_LOCAL0);
|
||||
PHPBN2(LOG_LOCAL1);
|
||||
PHPBN2(LOG_LOCAL2);
|
||||
PHPBN2(LOG_LOCAL3);
|
||||
PHPBN2(LOG_LOCAL4);
|
||||
PHPBN2(LOG_LOCAL5);
|
||||
PHPBN2(LOG_LOCAL6);
|
||||
PHPBN2(LOG_LOCAL7);
|
||||
PHPBN2(LOG_PID);
|
||||
PHPBN2(LOG_CONS);
|
||||
PHPBN2(LOG_ODELAY);
|
||||
PHPBN2(LOG_NDELAY);
|
||||
PHPBN2(LOG_NOWAIT);
|
||||
PHPBN2(LOG_PERROR);
|
||||
|
||||
/* Added in PHP 5.2 */
|
||||
PHPBN2(PREG_BACKTRACK_LIMIT_ERROR);
|
||||
PHPBN2(PREG_BAD_UTF8_ERROR);
|
||||
PHPBN2(PREG_INTERNAL_ERROR);
|
||||
PHPBN2(PREG_NO_ERROR);
|
||||
PHPBN2(PREG_RECURSION_LIMIT_ERROR);
|
||||
PHPBN2(UPLOAD_ERR_EXTENSION);
|
||||
PHPBN2(STREAM_SHUT_RD);
|
||||
PHPBN2(STREAM_SHUT_WR);
|
||||
PHPBN2(STREAM_SHUT_RDWR);
|
||||
PHPBN2(CURLE_FILESIZE_EXCEEDED);
|
||||
PHPBN2(CURLE_FTP_SSL_FAILED);
|
||||
PHPBN2(CURLE_LDAP_INVALID_URL);
|
||||
PHPBN2(CURLFTPAUTH_DEFAULT);
|
||||
PHPBN2(CURLFTPAUTH_SSL);
|
||||
PHPBN2(CURLFTPAUTH_TLS);
|
||||
PHPBN2(CURLFTPSSL_ALL);
|
||||
PHPBN2(CURLFTPSSL_CONTROL);
|
||||
PHPBN2(CURLFTPSSL_NONE);
|
||||
PHPBN2(CURLFTPSSL_TRY);
|
||||
PHPBN2(CURLOPT_FTP_SSL);
|
||||
PHPBN2(CURLOPT_FTPSSLAUTH);
|
||||
PHPBN2(CURLOPT_TCP_NODELAY); // Added in PHP 5.2.1
|
||||
PHPBN2(CURLOPT_TIMEOUT_MS); // Added in PHP 5.2.3
|
||||
PHPBN2(CURLOPT_CONNECTTIMEOUT_MS); // Added in PHP 5.2.3
|
||||
PHPBN2(GMP_VERSION); // Added in PHP 5.2.2
|
||||
PHPBN2(SWFTEXTFIELD_USEFONT);
|
||||
PHPBN2(SWFTEXTFIELD_AUTOSIZE);
|
||||
PHPBN2(SWF_SOUND_NOT_COMPRESSED);
|
||||
PHPBN2(SWF_SOUND_ADPCM_COMPRESSED);
|
||||
PHPBN2(SWF_SOUND_MP3_COMPRESSED);
|
||||
PHPBN2(SWF_SOUND_NOT_COMPRESSED_LE);
|
||||
PHPBN2(SWF_SOUND_NELLY_COMPRESSED);
|
||||
PHPBN2(SWF_SOUND_5KHZ);
|
||||
PHPBN2(SWF_SOUND_11KHZ);
|
||||
PHPBN2(SWF_SOUND_22KHZ);
|
||||
PHPBN2(SWF_SOUND_44KHZ);
|
||||
PHPBN2(SWF_SOUND_8BITS);
|
||||
PHPBN2(SWF_SOUND_16BITS);
|
||||
PHPBN2(SWF_SOUND_MONO);
|
||||
PHPBN2(SWF_SOUND_STEREO);
|
||||
PHPBN2(OPENSSL_VERSION_NUMBER);
|
||||
PHPBN2(SNMP_OID_OUTPUT_FULL);
|
||||
PHPBN2(SNMP_OID_OUTPUT_NUMERIC);
|
||||
PHPBN2(MSG_EAGAIN);
|
||||
PHPBN2(MSG_ENOMSG);
|
||||
|
||||
/* Added in PHP 5.3 */
|
||||
PHPBN2(CURLOPT_PROGRESSFUNCTION);
|
||||
PHPBN2(IMG_FILTER_PIXELATE);
|
||||
PHPBN2(JSON_ERROR_CTRL_CHAR);
|
||||
PHPBN2(JSON_ERROR_DEPTH);
|
||||
PHPBN2(JSON_ERROR_NONE);
|
||||
PHPBN2(JSON_ERROR_STATE_MISMATCH);
|
||||
PHPBN2(JSON_ERROR_SYNTAX);
|
||||
PHPBN2(JSON_FORCE_OBJECT);
|
||||
PHPBN2(JSON_HEX_TAG);
|
||||
PHPBN2(JSON_HEX_AMP);
|
||||
PHPBN2(JSON_HEX_APOS);
|
||||
PHPBN2(JSON_HEX_QUOT);
|
||||
PHPBN2(LDAP_OPT_NETWORK_TIMEOUT);
|
||||
PHPBN2(LIBXML_LOADED_VERSION);
|
||||
PHPBN2(PREG_BAD_UTF8_OFFSET_ERROR);
|
||||
PHPBN2(BUS_ADRALN);
|
||||
PHPBN2(BUS_ADRERR);
|
||||
PHPBN2(BUS_OBJERR);
|
||||
PHPBN2(CLD_CONTIUNED);
|
||||
PHPBN2(CLD_DUMPED);
|
||||
PHPBN2(CLD_EXITED);
|
||||
PHPBN2(CLD_KILLED);
|
||||
PHPBN2(CLD_STOPPED);
|
||||
PHPBN2(CLD_TRAPPED);
|
||||
PHPBN2(FPE_FLTDIV);
|
||||
PHPBN2(FPE_FLTINV);
|
||||
PHPBN2(FPE_FLTOVF);
|
||||
PHPBN2(FPE_FLTRES);
|
||||
PHPBN2(FPE_FLTSUB);
|
||||
PHPBN2(FPE_FLTUND);
|
||||
PHPBN2(FPE_INTDIV);
|
||||
PHPBN2(FPE_INTOVF);
|
||||
PHPBN2(ILL_BADSTK);
|
||||
PHPBN2(ILL_COPROC);
|
||||
PHPBN2(ILL_ILLADR);
|
||||
PHPBN2(ILL_ILLOPC);
|
||||
PHPBN2(ILL_ILLOPN);
|
||||
PHPBN2(ILL_ILLTRP);
|
||||
PHPBN2(ILL_PRVOPC);
|
||||
PHPBN2(ILL_PRVREG);
|
||||
PHPBN2(POLL_ERR);
|
||||
PHPBN2(POLL_HUP);
|
||||
PHPBN2(POLL_IN);
|
||||
PHPBN2(POLL_MSG);
|
||||
PHPBN2(POLL_OUT);
|
||||
PHPBN2(POLL_PRI);
|
||||
PHPBN2(SEGV_ACCERR);
|
||||
PHPBN2(SEGV_MAPERR);
|
||||
PHPBN2(SI_ASYNCIO);
|
||||
PHPBN2(SI_KERNEL);
|
||||
PHPBN2(SI_MESGQ);
|
||||
PHPBN2(SI_NOINFO);
|
||||
PHPBN2(SI_QUEUE);
|
||||
PHPBN2(SI_SIGIO);
|
||||
PHPBN2(SI_TIMER);
|
||||
PHPBN2(SI_TKILL);
|
||||
PHPBN2(SI_USER);
|
||||
PHPBN2(SIG_BLOCK);
|
||||
PHPBN2(SIG_SETMASK);
|
||||
PHPBN2(SIG_UNBLOCK);
|
||||
PHPBN2(TRAP_BRKPT);
|
||||
PHPBN2(TRAP_TRACE);
|
||||
|
||||
/* Added in PHP 5.4 */
|
||||
PHPBN2(ENT_DISALLOWED);
|
||||
PHPBN2(ENT_HTML401);
|
||||
PHPBN2(ENT_HTML5);
|
||||
PHPBN2(ENT_SUBSTITUTE);
|
||||
PHPBN2(ENT_XML1);
|
||||
PHPBN2(ENT_XHTML);
|
||||
PHPBN2(IPPROTO_IP);
|
||||
PHPBN2(IPPROTO_IPV6);
|
||||
PHPBN2(IPV6_MULTICAST_HOPS);
|
||||
PHPBN2(IPV6_MULTICAST_IF);
|
||||
PHPBN2(IPV6_MULTICAST_LOOP);
|
||||
PHPBN2(IP_MULTICAST_IF);
|
||||
PHPBN2(IP_MULTICAST_LOOP);
|
||||
PHPBN2(IP_MULTICAST_TTL);
|
||||
PHPBN2(MCAST_JOIN_GROUP);
|
||||
PHPBN2(MCAST_LEAVE_GROUP);
|
||||
PHPBN2(MCAST_BLOCK_SOURCE);
|
||||
PHPBN2(MCAST_UNBLOCK_SOURCE);
|
||||
PHPBN2(MCAST_JOIN_SOURCE_GROUP);
|
||||
PHPBN2(MCAST_LEAVE_SOURCE_GROUP);
|
||||
PHPBN2(CURLOPT_MAX_RECV_SPEED_LARGE);
|
||||
PHPBN2(CURLOPT_MAX_SEND_SPEED_LARGE);
|
||||
PHPBN2(LIBXML_HTML_NODEFDTD);
|
||||
PHPBN2(LIBXML_HTML_NOIMPLIED);
|
||||
PHPBN2(LIBXML_PEDANTIC);
|
||||
PHPBN2(OPENSSL_CIPHER_AES_128_CBC);
|
||||
PHPBN2(OPENSSL_CIPHER_AES_192_CBC);
|
||||
PHPBN2(OPENSSL_CIPHER_AES_256_CBC);
|
||||
PHPBN2(OPENSSL_RAW_DATA);
|
||||
PHPBN2(OPENSSL_ZERO_PADDING);
|
||||
PHPBN2(PHP_OUTPUT_HANDLER_CLEAN);
|
||||
PHPBN2(PHP_OUTPUT_HANDLER_CLEANABLE);
|
||||
PHPBN2(PHP_OUTPUT_HANDLER_DISABLED);
|
||||
PHPBN2(PHP_OUTPUT_HANDLER_FINAL);
|
||||
PHPBN2(PHP_OUTPUT_HANDLER_FLUSH);
|
||||
PHPBN2(PHP_OUTPUT_HANDLER_FLUSHABLE);
|
||||
PHPBN2(PHP_OUTPUT_HANDLER_REMOVABLE);
|
||||
PHPBN2(PHP_OUTPUT_HANDLER_STARTED);
|
||||
PHPBN2(PHP_OUTPUT_HANDLER_STDFLAGS);
|
||||
PHPBN2(PHP_OUTPUT_HANDLER_WRITE);
|
||||
PHPBN2(PHP_SESSION_ACTIVE);
|
||||
PHPBN2(PHP_SESSION_DISABLED);
|
||||
PHPBN2(PHP_SESSION_NONE);
|
||||
PHPBN2(STREAM_META_ACCESS);
|
||||
PHPBN2(STREAM_META_GROUP);
|
||||
PHPBN2(STREAM_META_GROUP_NAME);
|
||||
PHPBN2(STREAM_META_OWNER);
|
||||
PHPBN2(STREAM_META_OWNER_NAME);
|
||||
PHPBN2(STREAM_META_TOUCH);
|
||||
PHPBN2(ZLIB_ENCODING_DEFLATE);
|
||||
PHPBN2(ZLIB_ENCODING_GZIP);
|
||||
PHPBN2(ZLIB_ENCODING_RAW);
|
||||
PHPBN2(U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR);
|
||||
PHPBN2(IDNA_CHECK_BIDI);
|
||||
PHPBN2(IDNA_CHECK_CONTEXTJ);
|
||||
PHPBN2(IDNA_NONTRANSITIONAL_TO_ASCII);
|
||||
PHPBN2(IDNA_NONTRANSITIONAL_TO_UNICODE);
|
||||
PHPBN2(INTL_IDNA_VARIANT_2003);
|
||||
PHPBN2(INTL_IDNA_VARIANT_UTS46);
|
||||
PHPBN2(IDNA_ERROR_EMPTY_LABEL);
|
||||
PHPBN2(IDNA_ERROR_LABEL_TOO_LONG);
|
||||
PHPBN2(IDNA_ERROR_DOMAIN_NAME_TOO_LONG);
|
||||
PHPBN2(IDNA_ERROR_LEADING_HYPHEN);
|
||||
PHPBN2(IDNA_ERROR_TRAILING_HYPHEN);
|
||||
PHPBN2(IDNA_ERROR_HYPHEN_3_4);
|
||||
PHPBN2(IDNA_ERROR_LEADING_COMBINING_MARK);
|
||||
PHPBN2(IDNA_ERROR_DISALLOWED);
|
||||
PHPBN2(IDNA_ERROR_PUNYCODE);
|
||||
PHPBN2(IDNA_ERROR_LABEL_HAS_DOT);
|
||||
PHPBN2(IDNA_ERROR_INVALID_ACE_LABEL);
|
||||
PHPBN2(IDNA_ERROR_BIDI);
|
||||
PHPBN2(IDNA_ERROR_CONTEXTJ);
|
||||
PHPBN2(JSON_PRETTY_PRINT);
|
||||
PHPBN2(JSON_UNESCAPED_SLASHES);
|
||||
PHPBN2(JSON_NUMERIC_CHECK);
|
||||
PHPBN2(JSON_UNESCAPED_UNICODE);
|
||||
PHPBN2(JSON_BIGINT_AS_STRING);
|
||||
|
||||
/* Added in PHP 5.5 */
|
||||
PHPBN2(IMG_AFFINE_TRANSLATE);
|
||||
PHPBN2(IMG_AFFINE_SCALE);
|
||||
PHPBN2(IMG_AFFINE_ROTATE);
|
||||
PHPBN2(IMG_AFFINE_SHEAR_HORIZONTAL);
|
||||
PHPBN2(IMG_AFFINE_SHEAR_VERTICAL);
|
||||
PHPBN2(IMG_CROP_DEFAULT);
|
||||
PHPBN2(IMG_CROP_TRANSPARENT);
|
||||
PHPBN2(IMG_CROP_BLACK);
|
||||
PHPBN2(IMG_CROP_WHITE);
|
||||
PHPBN2(IMG_CROP_SIDES);
|
||||
PHPBN2(IMG_FLIP_BOTH);
|
||||
PHPBN2(IMG_FLIP_HORIZONTAL);
|
||||
PHPBN2(IMG_FLIP_VERTICAL);
|
||||
PHPBN2(IMG_BELL);
|
||||
PHPBN2(IMG_BESSEL);
|
||||
PHPBN2(IMG_BICUBIC);
|
||||
PHPBN2(IMG_BICUBIC_FIXED);
|
||||
PHPBN2(IMG_BLACKMAN);
|
||||
PHPBN2(IMG_BOX);
|
||||
PHPBN2(IMG_BSPLINE);
|
||||
PHPBN2(IMG_CATMULLROM);
|
||||
PHPBN2(IMG_GAUSSIAN);
|
||||
PHPBN2(IMG_GENERALIZED_CUBIC);
|
||||
PHPBN2(IMG_HERMITE);
|
||||
PHPBN2(IMG_HAMMING);
|
||||
PHPBN2(IMG_HANNING);
|
||||
PHPBN2(IMG_MITCHELL);
|
||||
PHPBN2(IMG_POWER);
|
||||
PHPBN2(IMG_QUADRATIC);
|
||||
PHPBN2(IMG_SINC);
|
||||
PHPBN2(IMG_NEAREST_NEIGHBOUR);
|
||||
PHPBN2(IMG_WEIGHTED4);
|
||||
PHPBN2(IMG_TRIANGLE);
|
||||
PHPBN2(JSON_ERROR_RECURSION);
|
||||
PHPBN2(JSON_ERROR_INF_OR_NAN);
|
||||
PHPBN2(JSON_ERROR_UNSUPPORTED_TYPE);
|
||||
PHPBN2(MYSQLI_SERVER_PUBLIC_KEY);
|
||||
|
||||
/* Added in PHP 5.6 */
|
||||
PHPBN2(LDAP_ESCAPE_DN);
|
||||
PHPBN2(LDAP_ESCAPE_FILTER);
|
||||
PHPBN2(OPENSSL_DEFAULT_STREAM_CIPHERS);
|
||||
PHPBN2(STREAM_CRYPTO_METHOD_ANY_CLIENT);
|
||||
PHPBN2(STREAM_CRYPTO_METHOD_ANY_SERVER);
|
||||
PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT);
|
||||
PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_0_SERVER);
|
||||
PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT);
|
||||
PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_1_SERVER);
|
||||
PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT);
|
||||
PHPBN2(STREAM_CRYPTO_METHOD_TLSv1_2_SERVER);
|
||||
PHPBN2(PGSQL_CONNECT_ASYNC);
|
||||
PHPBN2(PGSQL_CONNECTION_AUTH_OK);
|
||||
PHPBN2(PGSQL_CONNECTION_AWAITING_RESPONSE);
|
||||
PHPBN2(PGSQL_CONNECTION_MADE);
|
||||
PHPBN2(PGSQL_CONNECTION_SETENV);
|
||||
PHPBN2(PGSQL_CONNECTION_SSL_STARTUP);
|
||||
PHPBN2(PGSQL_CONNECTION_STARTED);
|
||||
PHPBN2(PGSQL_DML_ESCAPE);
|
||||
PHPBN2(PGSQL_POLLING_ACTIVE);
|
||||
PHPBN2(PGSQL_POLLING_FAILED);
|
||||
PHPBN2(PGSQL_POLLING_OK);
|
||||
PHPBN2(PGSQL_POLLING_READING);
|
||||
PHPBN2(PGSQL_POLLING_WRITING);
|
||||
|
||||
/* Class names reserved by PHP (case insensitive) */
|
||||
PHPCN(directory);
|
||||
PHPCN(stdclass);
|
||||
PHPCN(__php_incomplete_class);
|
||||
/* Added in PHP5. */
|
||||
PHPCN(exception);
|
||||
PHPCN(errorexception); // As of PHP 5.1
|
||||
PHPCN(php_user_filter);
|
||||
PHPCN(closure); // As of PHP 5.3
|
||||
PHPCN(generator); // As of PHP 5.5
|
||||
PHPCN(self);
|
||||
PHPCN(static);
|
||||
PHPCN(parent);
|
||||
/* From extensions (which of these are actually predefined depends which
|
||||
* extensions are loaded by default). */
|
||||
PHPCN(xmlwriter);
|
||||
PHPCN(libxmlerror);
|
||||
PHPCN(simplexmlelement);
|
||||
PHPCN(soapclient);
|
||||
PHPCN(soapvar);
|
||||
PHPCN(soapserver);
|
||||
PHPCN(soapfault);
|
||||
PHPCN(soapparam);
|
||||
PHPCN(soapheader);
|
||||
PHPCN(recursiveiteratoriterator);
|
||||
PHPCN(filteriterator);
|
||||
PHPCN(recursivefilteriterator);
|
||||
PHPCN(parentiterator);
|
||||
PHPCN(limititerator);
|
||||
PHPCN(cachingiterator);
|
||||
PHPCN(recursivecachingiterator);
|
||||
PHPCN(iteratoriterator);
|
||||
PHPCN(norewinditerator);
|
||||
PHPCN(appenditerator);
|
||||
PHPCN(infiniteiterator);
|
||||
PHPCN(emptyiterator);
|
||||
PHPCN(arrayobject);
|
||||
PHPCN(arrayiterator);
|
||||
PHPCN(recursivearrayiterator);
|
||||
PHPCN(splfileinfo);
|
||||
PHPCN(directoryiterator);
|
||||
PHPCN(recursivedirectoryiterator);
|
||||
PHPCN(splfileobject);
|
||||
PHPCN(spltempfileobject);
|
||||
PHPCN(simplexmliterator);
|
||||
PHPCN(logicexception);
|
||||
PHPCN(badfunctioncallexception);
|
||||
PHPCN(badmethodcallexception);
|
||||
PHPCN(domainexception);
|
||||
PHPCN(invalidargumentexception);
|
||||
PHPCN(lengthexception);
|
||||
PHPCN(outofrangeexception);
|
||||
PHPCN(runtimeexception);
|
||||
PHPCN(outofboundsexception);
|
||||
PHPCN(overflowexception);
|
||||
PHPCN(rangeexception);
|
||||
PHPCN(underflowexception);
|
||||
PHPCN(unexpectedvalueexception);
|
||||
PHPCN(splobjectstorage);
|
||||
PHPCN(reflectionexception);
|
||||
PHPCN(reflection);
|
||||
PHPCN(reflectionfunction);
|
||||
PHPCN(reflectionparameter);
|
||||
PHPCN(reflectionmethod);
|
||||
PHPCN(reflectionclass);
|
||||
PHPCN(reflectionobject);
|
||||
PHPCN(reflectionproperty);
|
||||
PHPCN(reflectionextension);
|
||||
PHPCN(domexception);
|
||||
PHPCN(domstringlist);
|
||||
PHPCN(domnamelist);
|
||||
PHPCN(domimplementationlist);
|
||||
PHPCN(domimplementationsource);
|
||||
PHPCN(domimplementation);
|
||||
PHPCN(domnode);
|
||||
PHPCN(domnamespacenode);
|
||||
PHPCN(domdocumentfragment);
|
||||
PHPCN(domdocument);
|
||||
PHPCN(domnodelist);
|
||||
PHPCN(domnamednodemap);
|
||||
PHPCN(domcharacterdata);
|
||||
PHPCN(domattr);
|
||||
PHPCN(domelement);
|
||||
PHPCN(domtext);
|
||||
PHPCN(domcomment);
|
||||
PHPCN(domtypeinfo);
|
||||
PHPCN(domuserdatahandler);
|
||||
PHPCN(domdomerror);
|
||||
PHPCN(domerrorhandler);
|
||||
PHPCN(domlocator);
|
||||
PHPCN(domconfiguration);
|
||||
PHPCN(domcdatasection);
|
||||
PHPCN(domdocumenttype);
|
||||
PHPCN(domnotation);
|
||||
PHPCN(domentity);
|
||||
PHPCN(domentityreference);
|
||||
PHPCN(domprocessinginstruction);
|
||||
PHPCN(domstringextend);
|
||||
PHPCN(domxpath);
|
||||
PHPCN(xmlreader);
|
||||
PHPCN(sqlitedatabase);
|
||||
PHPCN(sqliteresult);
|
||||
PHPCN(sqliteunbuffered);
|
||||
PHPCN(sqliteexception);
|
||||
PHPCN(datetime);
|
||||
|
||||
/* Built-in PHP functions (incomplete). */
|
||||
/* Includes Array Functions - http://php.net/manual/en/ref.array.php */
|
||||
/* Check is case insensitive - these *MUST* be listed in lower case here */
|
||||
PHPFN(acos);
|
||||
PHPFN(array_change_key_case);
|
||||
PHPFN(array_chunk);
|
||||
PHPFN(array_column);
|
||||
PHPFN(array_combine);
|
||||
PHPFN(array_count_values);
|
||||
PHPFN(array_diff);
|
||||
PHPFN(array_diff_assoc);
|
||||
PHPFN(array_diff_key);
|
||||
PHPFN(array_diff_uassoc);
|
||||
PHPFN(array_diff_ukey);
|
||||
PHPFN(array_fill);
|
||||
PHPFN(array_fill_keys);
|
||||
PHPFN(array_filter);
|
||||
PHPFN(array_flip);
|
||||
PHPFN(array_intersect);
|
||||
PHPFN(array_intersect_assoc);
|
||||
PHPFN(array_intersect_key);
|
||||
PHPFN(array_intersect_uassoc);
|
||||
PHPFN(array_intersect_ukey);
|
||||
PHPFN(array_key_exists);
|
||||
PHPFN(array_keys);
|
||||
PHPFN(array_map);
|
||||
PHPFN(array_merge);
|
||||
PHPFN(array_merge_recursive);
|
||||
PHPFN(array_multisort);
|
||||
PHPFN(array_pad);
|
||||
PHPFN(array_pop);
|
||||
PHPFN(array_product);
|
||||
PHPFN(array_push);
|
||||
PHPFN(array_rand);
|
||||
PHPFN(array_reduce);
|
||||
PHPFN(array_replace);
|
||||
PHPFN(array_replace_recursive);
|
||||
PHPFN(array_reverse);
|
||||
PHPFN(array_search);
|
||||
PHPFN(array_shift);
|
||||
PHPFN(array_slice);
|
||||
PHPFN(array_splice);
|
||||
PHPFN(array_sum);
|
||||
PHPFN(array_udiff);
|
||||
PHPFN(array_udiff_assoc);
|
||||
PHPFN(array_udiff_uassoc);
|
||||
PHPFN(array_uintersect);
|
||||
PHPFN(array_uintersect_assoc);
|
||||
PHPFN(array_uintersect_uassoc);
|
||||
PHPFN(array_unique);
|
||||
PHPFN(array_unshift);
|
||||
PHPFN(array_values);
|
||||
PHPFN(array_walk);
|
||||
PHPFN(array_walk_recursive);
|
||||
PHPFN(arsort);
|
||||
PHPFN(asin);
|
||||
PHPFN(asort);
|
||||
PHPFN(atan);
|
||||
PHPFN(atan2);
|
||||
PHPFN(ceil);
|
||||
PHPFN(compact);
|
||||
PHPFN(cos);
|
||||
PHPFN(cosh);
|
||||
PHPFN(count);
|
||||
PHPFN(current);
|
||||
PHPFN(each);
|
||||
PHPFN(end);
|
||||
PHPFN(exp);
|
||||
PHPFN(extract);
|
||||
PHPFN(floor);
|
||||
PHPFN(fmod);
|
||||
PHPFN(in_array);
|
||||
PHPFN(key);
|
||||
PHPFN(key_exists);
|
||||
PHPFN(krsort);
|
||||
PHPFN(ksort);
|
||||
PHPFN(log);
|
||||
PHPFN(log10);
|
||||
PHPFN(max);
|
||||
PHPFN(min);
|
||||
PHPFN(natcasesort);
|
||||
PHPFN(natsort);
|
||||
PHPFN(next);
|
||||
PHPFN(pos);
|
||||
PHPFN(pow);
|
||||
PHPFN(prev);
|
||||
PHPFN(range);
|
||||
PHPFN(reset);
|
||||
PHPFN(rsort);
|
||||
PHPFN(shuffle);
|
||||
PHPFN(sin);
|
||||
PHPFN(sinh);
|
||||
PHPFN(sizeof);
|
||||
PHPFN(sort);
|
||||
PHPFN(sqrt);
|
||||
PHPFN(tan);
|
||||
PHPFN(tanh);
|
||||
PHPFN(uasort);
|
||||
PHPFN(uksort);
|
||||
PHPFN(usort);
|
||||
|
||||
#undef PHPKW
|
||||
#undef PHPBN1a
|
||||
#undef PHPBN1b
|
||||
#undef PHPBN1
|
||||
#undef PHPBN2a
|
||||
#undef PHPBN2b
|
||||
#undef PHPBN2
|
||||
#undef PHPCN
|
||||
#undef PHPFN
|
||||
42
Lib/php5/phppointers.i
Normal file
42
Lib/php5/phppointers.i
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
%define %pass_by_ref( TYPE, CONVERT_IN, CONVERT_OUT )
|
||||
%typemap(in, byref=1) TYPE *REF ($*1_ltype tmp),
|
||||
TYPE &REF ($*1_ltype tmp)
|
||||
%{
|
||||
/* First Check for SWIG wrapped type */
|
||||
if ( ZVAL_IS_NULL( *$input ) ) {
|
||||
$1 = 0;
|
||||
} else if ( PZVAL_IS_REF( *$input ) ) {
|
||||
/* Not swig wrapped type, so we check if it's a PHP reference type */
|
||||
CONVERT_IN( tmp, $*1_ltype, $input );
|
||||
$1 = &tmp;
|
||||
} else {
|
||||
SWIG_PHP_Error( E_ERROR, SWIG_PHP_Arg_Error_Msg($argnum, Expected a reference) );
|
||||
}
|
||||
%}
|
||||
%typemap(argout) TYPE *REF,
|
||||
TYPE &REF
|
||||
"CONVERT_OUT(*$input, tmp$argnum );";
|
||||
%enddef
|
||||
|
||||
%pass_by_ref( size_t, CONVERT_INT_IN, ZVAL_LONG );
|
||||
|
||||
%pass_by_ref( signed int, CONVERT_INT_IN, ZVAL_LONG );
|
||||
%pass_by_ref( int, CONVERT_INT_IN, ZVAL_LONG );
|
||||
%pass_by_ref( unsigned int, CONVERT_INT_IN, ZVAL_LONG );
|
||||
|
||||
%pass_by_ref( signed short, CONVERT_INT_IN, ZVAL_LONG );
|
||||
%pass_by_ref( short, CONVERT_INT_IN, ZVAL_LONG );
|
||||
%pass_by_ref( unsigned short, CONVERT_INT_IN, ZVAL_LONG );
|
||||
|
||||
%pass_by_ref( signed long, CONVERT_INT_IN, ZVAL_LONG );
|
||||
%pass_by_ref( long, CONVERT_INT_IN, ZVAL_LONG );
|
||||
%pass_by_ref( unsigned long, CONVERT_INT_IN, ZVAL_LONG );
|
||||
|
||||
%pass_by_ref( signed char, CONVERT_INT_IN, ZVAL_LONG );
|
||||
%pass_by_ref( char, CONVERT_CHAR_IN, ZVAL_STRING );
|
||||
%pass_by_ref( unsigned char, CONVERT_INT_IN, ZVAL_LONG );
|
||||
|
||||
%pass_by_ref( float, CONVERT_FLOAT_IN, ZVAL_DOUBLE );
|
||||
%pass_by_ref( double, CONVERT_FLOAT_IN, ZVAL_DOUBLE );
|
||||
|
||||
%pass_by_ref( char *, CONVERT_CHAR_IN, ZVAL_STRING );
|
||||
280
Lib/php5/phprun.swg
Normal file
280
Lib/php5/phprun.swg
Normal file
|
|
@ -0,0 +1,280 @@
|
|||
/* -----------------------------------------------------------------------------
|
||||
* phprun.swg
|
||||
*
|
||||
* PHP runtime library
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
#include "zend.h"
|
||||
#include "zend_API.h"
|
||||
#include "zend_exceptions.h"
|
||||
#include "php.h"
|
||||
|
||||
#if PHP_MAJOR_VERSION != 5
|
||||
# error These bindings need PHP5 - to generate PHP7 bindings use: swig -php7
|
||||
#endif
|
||||
|
||||
#include "ext/standard/php_string.h"
|
||||
#include <stdlib.h> /* for abort(), used in generated code. */
|
||||
|
||||
#ifdef ZEND_RAW_FENTRY
|
||||
/* ZEND_RAW_FENTRY was added somewhere between 5.2.0 and 5.2.3 */
|
||||
# define SWIG_ZEND_NAMED_FE(ZN, N, A) ZEND_RAW_FENTRY((char*)#ZN, N, A, 0)
|
||||
#else
|
||||
/* This causes warnings from GCC >= 4.2 (assigning a string literal to char*).
|
||||
* But this seems to be unavoidable without directly assuming knowledge of
|
||||
* the structure, which changed between PHP4 and PHP5. */
|
||||
# define SWIG_ZEND_NAMED_FE(ZN, N, A) ZEND_NAMED_FE(ZN, N, A)
|
||||
#endif
|
||||
|
||||
#ifndef ZEND_FE_END
|
||||
# define ZEND_FE_END { NULL, NULL, NULL }
|
||||
#endif
|
||||
|
||||
#ifndef Z_SET_ISREF_P
|
||||
/* For PHP < 5.3 */
|
||||
# define Z_SET_ISREF_P(z) (z)->is_ref = 1
|
||||
#endif
|
||||
#ifndef Z_SET_REFCOUNT_P
|
||||
/* For PHP < 5.3 */
|
||||
# define Z_SET_REFCOUNT_P(z, rc) (z)->refcount = (rc)
|
||||
#endif
|
||||
|
||||
#define SWIG_LONG_CONSTANT(N, V) zend_register_long_constant((char*)#N, sizeof(#N), V, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
|
||||
#define SWIG_DOUBLE_CONSTANT(N, V) zend_register_double_constant((char*)#N, sizeof(#N), V, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
|
||||
#define SWIG_STRING_CONSTANT(N, V) zend_register_stringl_constant((char*)#N, sizeof(#N), (char*)(V), strlen(V), CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC)
|
||||
#define SWIG_CHAR_CONSTANT(N, V) do {\
|
||||
static char swig_char = (V);\
|
||||
zend_register_stringl_constant((char*)#N, sizeof(#N), &swig_char, 1, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC);\
|
||||
} while (0)
|
||||
|
||||
/* These TSRMLS_ stuff should already be defined now, but with older php under
|
||||
redhat are not... */
|
||||
#ifndef TSRMLS_D
|
||||
#define TSRMLS_D
|
||||
#endif
|
||||
#ifndef TSRMLS_DC
|
||||
#define TSRMLS_DC
|
||||
#endif
|
||||
#ifndef TSRMLS_C
|
||||
#define TSRMLS_C
|
||||
#endif
|
||||
#ifndef TSRMLS_CC
|
||||
#define TSRMLS_CC
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
/* But in fact SWIG_ConvertPtr is the native interface for getting typed
|
||||
pointer values out of zvals. We need the TSRMLS_ macros for when we
|
||||
make PHP type calls later as we handle php resources */
|
||||
#define SWIG_ConvertPtr(obj,pp,type,flags) SWIG_ZTS_ConvertPtr(obj,pp,type,flags TSRMLS_CC)
|
||||
|
||||
|
||||
#define SWIG_fail goto fail
|
||||
|
||||
static const char *default_error_msg = "Unknown error occurred";
|
||||
static int default_error_code = E_ERROR;
|
||||
|
||||
#define SWIG_PHP_Arg_Error_Msg(argnum,extramsg) "Error in argument " #argnum " "#extramsg
|
||||
|
||||
#define SWIG_PHP_Error(code,msg) do { SWIG_ErrorCode() = code; SWIG_ErrorMsg() = msg; SWIG_fail; } while (0)
|
||||
|
||||
#define SWIG_contract_assert(expr,msg) \
|
||||
if (!(expr) ) { zend_printf("Contract Assert Failed %s\n",msg ); } else
|
||||
|
||||
/* Standard SWIG API */
|
||||
#define SWIG_GetModule(clientdata) SWIG_Php_GetModule()
|
||||
#define SWIG_SetModule(clientdata, pointer) SWIG_Php_SetModule(pointer)
|
||||
|
||||
/* used to wrap returned objects in so we know whether they are newobject
|
||||
and need freeing, or not */
|
||||
typedef struct {
|
||||
void * ptr;
|
||||
int newobject;
|
||||
} swig_object_wrapper;
|
||||
|
||||
#define SWIG_SetPointerZval(a,b,c,d) SWIG_ZTS_SetPointerZval(a,b,c,d TSRMLS_CC)
|
||||
#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
|
||||
|
||||
static void
|
||||
SWIG_ZTS_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject TSRMLS_DC) {
|
||||
/*
|
||||
* First test for Null pointers. Return those as PHP native NULL
|
||||
*/
|
||||
if (!ptr ) {
|
||||
ZVAL_NULL(z);
|
||||
return;
|
||||
}
|
||||
if (type->clientdata) {
|
||||
swig_object_wrapper *value;
|
||||
if (! (*(int *)(type->clientdata)))
|
||||
zend_error(E_ERROR, "Type: %s failed to register with zend",type->name);
|
||||
value=(swig_object_wrapper *)emalloc(sizeof(swig_object_wrapper));
|
||||
value->ptr=ptr;
|
||||
value->newobject=(newobject & 1);
|
||||
if ((newobject & 2) == 0) {
|
||||
/* Just register the pointer as a resource. */
|
||||
ZEND_REGISTER_RESOURCE(z, value, *(int *)(type->clientdata));
|
||||
} else {
|
||||
/*
|
||||
* Wrap the resource in an object, the resource will be accessible
|
||||
* via the "_cPtr" member. This is currently only used by
|
||||
* directorin typemaps.
|
||||
*/
|
||||
zval *resource;
|
||||
zend_class_entry **ce = NULL;
|
||||
const char *type_name = type->name+3; /* +3 so: _p_Foo -> Foo */
|
||||
size_t type_name_len;
|
||||
int result;
|
||||
const char * p;
|
||||
|
||||
/* Namespace__Foo -> Foo */
|
||||
/* FIXME: ugly and goes wrong for classes with __ in their names. */
|
||||
while ((p = strstr(type_name, "__")) != NULL) {
|
||||
type_name = p + 2;
|
||||
}
|
||||
type_name_len = strlen(type_name);
|
||||
|
||||
MAKE_STD_ZVAL(resource);
|
||||
ZEND_REGISTER_RESOURCE(resource, value, *(int *)(type->clientdata));
|
||||
if (SWIG_PREFIX_LEN > 0) {
|
||||
char * classname = (char*)emalloc(SWIG_PREFIX_LEN + type_name_len + 1);
|
||||
strcpy(classname, SWIG_PREFIX);
|
||||
strcpy(classname + SWIG_PREFIX_LEN, type_name);
|
||||
result = zend_lookup_class(classname, SWIG_PREFIX_LEN + type_name_len, &ce TSRMLS_CC);
|
||||
efree(classname);
|
||||
} else {
|
||||
result = zend_lookup_class((char *)type_name, type_name_len, &ce TSRMLS_CC);
|
||||
}
|
||||
if (result != SUCCESS) {
|
||||
/* class does not exist */
|
||||
object_init(z);
|
||||
} else {
|
||||
object_init_ex(z, *ce);
|
||||
}
|
||||
Z_SET_REFCOUNT_P(z, 1);
|
||||
Z_SET_ISREF_P(z);
|
||||
zend_hash_update(HASH_OF(z), (char*)"_cPtr", sizeof("_cPtr"), (void*)&resource, sizeof(zval*), NULL);
|
||||
}
|
||||
return;
|
||||
}
|
||||
zend_error(E_ERROR, "Type: %s not registered with zend",type->name);
|
||||
}
|
||||
|
||||
/* This pointer conversion routine takes the native pointer p (along with
|
||||
its type name) and converts it by calling appropriate casting functions
|
||||
according to ty. The resultant pointer is returned, or NULL is returned
|
||||
if the pointer can't be cast.
|
||||
|
||||
Sadly PHP has no API to find a type name from a type id, only from an
|
||||
instance of a resource of the type id, so we have to pass type_name as well.
|
||||
|
||||
The two functions which might call this are:
|
||||
SWIG_ZTS_ConvertResourcePtr which gets the type name from the resource
|
||||
and the registered zend destructors for which we have one per type each
|
||||
with the type name hard wired in. */
|
||||
static void *
|
||||
SWIG_ZTS_ConvertResourceData(void * p, const char *type_name, swig_type_info *ty TSRMLS_DC) {
|
||||
swig_cast_info *tc;
|
||||
void *result = 0;
|
||||
|
||||
if (!ty) {
|
||||
/* They don't care about the target type, so just pass on the pointer! */
|
||||
return p;
|
||||
}
|
||||
|
||||
if (! type_name) {
|
||||
/* can't convert p to ptr type ty if we don't know what type p is */
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* convert and cast p from type_name to ptr as ty. */
|
||||
tc = SWIG_TypeCheck(type_name, ty);
|
||||
if (tc) {
|
||||
int newmemory = 0;
|
||||
result = SWIG_TypeCast(tc, p, &newmemory);
|
||||
assert(!newmemory); /* newmemory handling not yet implemented */
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/* This function returns a pointer of type ty by extracting the pointer
|
||||
and type info from the resource in z. z must be a resource.
|
||||
If it fails, NULL is returned.
|
||||
It uses SWIG_ZTS_ConvertResourceData to do the real work. */
|
||||
static void *
|
||||
SWIG_ZTS_ConvertResourcePtr(zval *z, swig_type_info *ty, int flags TSRMLS_DC) {
|
||||
swig_object_wrapper *value;
|
||||
void *p;
|
||||
int type;
|
||||
const char *type_name;
|
||||
|
||||
value = (swig_object_wrapper *) zend_list_find(z->value.lval, &type);
|
||||
if (type==-1) return NULL;
|
||||
if (flags & SWIG_POINTER_DISOWN) {
|
||||
value->newobject = 0;
|
||||
}
|
||||
p = value->ptr;
|
||||
|
||||
type_name=zend_rsrc_list_get_rsrc_type(z->value.lval TSRMLS_CC);
|
||||
|
||||
return SWIG_ZTS_ConvertResourceData(p, type_name, ty TSRMLS_CC);
|
||||
}
|
||||
|
||||
/* We allow passing of a RESOURCE pointing to the object or an OBJECT whose
|
||||
_cPtr is a resource pointing to the object */
|
||||
static int
|
||||
SWIG_ZTS_ConvertPtr(zval *z, void **ptr, swig_type_info *ty, int flags TSRMLS_DC) {
|
||||
if (z == NULL) {
|
||||
*ptr = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
switch (z->type) {
|
||||
case IS_OBJECT: {
|
||||
zval ** _cPtr;
|
||||
if (zend_hash_find(HASH_OF(z),(char*)"_cPtr",sizeof("_cPtr"),(void**)&_cPtr)==SUCCESS) {
|
||||
if ((*_cPtr)->type==IS_RESOURCE) {
|
||||
*ptr = SWIG_ZTS_ConvertResourcePtr(*_cPtr, ty, flags TSRMLS_CC);
|
||||
return (*ptr == NULL ? -1 : 0);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case IS_RESOURCE:
|
||||
*ptr = SWIG_ZTS_ConvertResourcePtr(z, ty, flags TSRMLS_CC);
|
||||
return (*ptr == NULL ? -1 : 0);
|
||||
case IS_NULL:
|
||||
*ptr = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
static char const_name[] = "swig_runtime_data_type_pointer";
|
||||
static swig_module_info *SWIG_Php_GetModule() {
|
||||
zval *pointer;
|
||||
swig_module_info *ret = 0;
|
||||
TSRMLS_FETCH();
|
||||
|
||||
MAKE_STD_ZVAL(pointer);
|
||||
|
||||
if (zend_get_constant(const_name, sizeof(const_name) - 1, pointer TSRMLS_CC)) {
|
||||
if (pointer->type == IS_LONG) {
|
||||
ret = (swig_module_info *) pointer->value.lval;
|
||||
}
|
||||
}
|
||||
FREE_ZVAL(pointer);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void SWIG_Php_SetModule(swig_module_info *pointer) {
|
||||
TSRMLS_FETCH();
|
||||
REGISTER_MAIN_LONG_CONSTANT(const_name, (long) pointer, 0);
|
||||
}
|
||||
10
Lib/php5/std_common.i
Normal file
10
Lib/php5/std_common.i
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
/* -----------------------------------------------------------------------------
|
||||
* std_common.i
|
||||
*
|
||||
* SWIG typemaps for STL - common utilities
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%include <std/std_except.i>
|
||||
|
||||
%apply size_t { std::size_t };
|
||||
|
||||
1
Lib/php5/std_deque.i
Normal file
1
Lib/php5/std_deque.i
Normal file
|
|
@ -0,0 +1 @@
|
|||
%include <std/_std_deque.i>
|
||||
76
Lib/php5/std_map.i
Normal file
76
Lib/php5/std_map.i
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
/* -----------------------------------------------------------------------------
|
||||
* std_map.i
|
||||
*
|
||||
* SWIG typemaps for std::map
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%include <std_common.i>
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// std::map
|
||||
// ------------------------------------------------------------------------
|
||||
|
||||
%{
|
||||
#include <map>
|
||||
#include <algorithm>
|
||||
#include <stdexcept>
|
||||
%}
|
||||
|
||||
// exported class
|
||||
|
||||
namespace std {
|
||||
|
||||
template<class K, class T> class map {
|
||||
// add typemaps here
|
||||
public:
|
||||
typedef size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef K key_type;
|
||||
typedef T mapped_type;
|
||||
map();
|
||||
map(const map<K,T> &);
|
||||
|
||||
unsigned int size() const;
|
||||
void clear();
|
||||
%extend {
|
||||
const T& get(const K& key) throw (std::out_of_range) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
if (i != self->end())
|
||||
return i->second;
|
||||
else
|
||||
throw std::out_of_range("key not found");
|
||||
}
|
||||
void set(const K& key, const T& x) {
|
||||
(*self)[key] = x;
|
||||
}
|
||||
void del(const K& key) throw (std::out_of_range) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
if (i != self->end())
|
||||
self->erase(i);
|
||||
else
|
||||
throw std::out_of_range("key not found");
|
||||
}
|
||||
bool has_key(const K& key) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
return i != self->end();
|
||||
}
|
||||
bool is_empty() const {
|
||||
return self->empty();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// Legacy macros (deprecated)
|
||||
%define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO)
|
||||
#warning "specialize_std_map_on_key ignored - macro is deprecated and no longer necessary"
|
||||
%enddef
|
||||
|
||||
%define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO)
|
||||
#warning "specialize_std_map_on_value ignored - macro is deprecated and no longer necessary"
|
||||
%enddef
|
||||
|
||||
%define specialize_std_map_on_both(K,CHECK_K,CONVERT_K_FROM,CONVERT_K_TO, T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO)
|
||||
#warning "specialize_std_map_on_both ignored - macro is deprecated and no longer necessary"
|
||||
%enddef
|
||||
|
||||
}
|
||||
34
Lib/php5/std_pair.i
Normal file
34
Lib/php5/std_pair.i
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
/* -----------------------------------------------------------------------------
|
||||
* std_pair.i
|
||||
*
|
||||
* SWIG typemaps for std::pair
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%include <std_common.i>
|
||||
%include <exception.i>
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// std::pair
|
||||
// ------------------------------------------------------------------------
|
||||
|
||||
%{
|
||||
#include <utility>
|
||||
%}
|
||||
|
||||
namespace std {
|
||||
|
||||
template<class T, class U> struct pair {
|
||||
|
||||
pair();
|
||||
pair(T first, U second);
|
||||
pair(const pair& p);
|
||||
|
||||
template <class U1, class U2> pair(const pair<U1, U2> &p);
|
||||
|
||||
T first;
|
||||
U second;
|
||||
};
|
||||
|
||||
// add specializations here
|
||||
|
||||
}
|
||||
79
Lib/php5/std_string.i
Normal file
79
Lib/php5/std_string.i
Normal file
|
|
@ -0,0 +1,79 @@
|
|||
/* -----------------------------------------------------------------------------
|
||||
* std_string.i
|
||||
*
|
||||
* SWIG typemaps for std::string types
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// std::string is typemapped by value
|
||||
// This can prevent exporting methods which return a string
|
||||
// in order for the user to modify it.
|
||||
// However, I think I'll wait until someone asks for it...
|
||||
// ------------------------------------------------------------------------
|
||||
|
||||
%include <exception.i>
|
||||
|
||||
%{
|
||||
#include <string>
|
||||
%}
|
||||
|
||||
namespace std {
|
||||
|
||||
%naturalvar string;
|
||||
|
||||
class string;
|
||||
|
||||
%typemap(typecheck,precedence=SWIG_TYPECHECK_STRING) string, const string& %{
|
||||
$1 = ( Z_TYPE_PP($input) == IS_STRING ) ? 1 : 0;
|
||||
%}
|
||||
|
||||
%typemap(in) string %{
|
||||
convert_to_string_ex($input);
|
||||
$1.assign(Z_STRVAL_PP($input), Z_STRLEN_PP($input));
|
||||
%}
|
||||
|
||||
%typemap(directorout) string %{
|
||||
convert_to_string_ex(&$input);
|
||||
$result.assign(Z_STRVAL_P($input), Z_STRLEN_P($input));
|
||||
%}
|
||||
|
||||
%typemap(out) string %{
|
||||
ZVAL_STRINGL($result, const_cast<char*>($1.data()), $1.size(), 1);
|
||||
%}
|
||||
|
||||
%typemap(directorin) string, const string& %{
|
||||
ZVAL_STRINGL($input, const_cast<char*>($1.data()), $1.size(), 1);
|
||||
%}
|
||||
|
||||
%typemap(out) const string & %{
|
||||
ZVAL_STRINGL($result, const_cast<char*>($1->data()), $1->size(), 1);
|
||||
%}
|
||||
|
||||
%typemap(throws) string, const string& %{
|
||||
zend_throw_exception(NULL, const_cast<char*>($1.c_str()), 0 TSRMLS_CC);
|
||||
return;
|
||||
%}
|
||||
|
||||
/* These next two handle a function which takes a non-const reference to
|
||||
* a std::string and modifies the string. */
|
||||
%typemap(in) string & ($*1_ltype temp) %{
|
||||
convert_to_string_ex($input);
|
||||
temp.assign(Z_STRVAL_PP($input), Z_STRLEN_PP($input));
|
||||
$1 = &temp;
|
||||
%}
|
||||
|
||||
%typemap(directorout) string & ($*1_ltype *temp) %{
|
||||
convert_to_string_ex(&$input);
|
||||
temp = new $*1_ltype(Z_STRVAL_P($input), Z_STRLEN_P($input));
|
||||
swig_acquire_ownership(temp);
|
||||
$result = temp;
|
||||
%}
|
||||
|
||||
%typemap(argout) string & %{
|
||||
ZVAL_STRINGL(*($input), const_cast<char*>($1->data()), $1->size(), 1);
|
||||
%}
|
||||
|
||||
/* SWIG will apply the non-const typemap above to const string& without
|
||||
* this more specific typemap. */
|
||||
%typemap(argout) const string & "";
|
||||
}
|
||||
102
Lib/php5/std_vector.i
Normal file
102
Lib/php5/std_vector.i
Normal file
|
|
@ -0,0 +1,102 @@
|
|||
/* -----------------------------------------------------------------------------
|
||||
* std_vector.i
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%include <std_common.i>
|
||||
|
||||
%{
|
||||
#include <vector>
|
||||
#include <stdexcept>
|
||||
%}
|
||||
|
||||
namespace std {
|
||||
|
||||
template<class T> class vector {
|
||||
public:
|
||||
typedef size_t size_type;
|
||||
typedef T value_type;
|
||||
typedef const value_type& const_reference;
|
||||
vector();
|
||||
vector(size_type n);
|
||||
size_type size() const;
|
||||
size_type capacity() const;
|
||||
void reserve(size_type n);
|
||||
void clear();
|
||||
%rename(push) push_back;
|
||||
void push_back(const value_type& x);
|
||||
%extend {
|
||||
bool is_empty() const {
|
||||
return $self->empty();
|
||||
}
|
||||
T pop() throw (std::out_of_range) {
|
||||
if (self->size() == 0)
|
||||
throw std::out_of_range("pop from empty vector");
|
||||
T x = self->back();
|
||||
self->pop_back();
|
||||
return x;
|
||||
}
|
||||
const_reference get(int i) throw (std::out_of_range) {
|
||||
int size = int(self->size());
|
||||
if (i>=0 && i<size)
|
||||
return (*self)[i];
|
||||
else
|
||||
throw std::out_of_range("vector index out of range");
|
||||
}
|
||||
void set(int i, const value_type& val) throw (std::out_of_range) {
|
||||
int size = int(self->size());
|
||||
if (i>=0 && i<size)
|
||||
(*self)[i] = val;
|
||||
else
|
||||
throw std::out_of_range("vector index out of range");
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// bool specialization
|
||||
template<> class vector<bool> {
|
||||
public:
|
||||
typedef size_t size_type;
|
||||
typedef bool value_type;
|
||||
typedef bool const_reference;
|
||||
vector();
|
||||
vector(size_type n);
|
||||
size_type size() const;
|
||||
size_type capacity() const;
|
||||
void reserve(size_type n);
|
||||
void clear();
|
||||
%rename(push) push_back;
|
||||
void push_back(const value_type& x);
|
||||
%extend {
|
||||
bool is_empty() const {
|
||||
return $self->empty();
|
||||
}
|
||||
bool pop() throw (std::out_of_range) {
|
||||
if (self->size() == 0)
|
||||
throw std::out_of_range("pop from empty vector");
|
||||
bool x = self->back();
|
||||
self->pop_back();
|
||||
return x;
|
||||
}
|
||||
bool get(int i) throw (std::out_of_range) {
|
||||
int size = int(self->size());
|
||||
if (i>=0 && i<size)
|
||||
return (*self)[i];
|
||||
else
|
||||
throw std::out_of_range("vector index out of range");
|
||||
}
|
||||
void set(int i, const value_type& val) throw (std::out_of_range) {
|
||||
int size = int(self->size());
|
||||
if (i>=0 && i<size)
|
||||
(*self)[i] = val;
|
||||
else
|
||||
throw std::out_of_range("vector index out of range");
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
%define specialize_std_vector(T)
|
||||
#warning "specialize_std_vector - specialization for type T no longer needed"
|
||||
%enddef
|
||||
|
||||
|
||||
12
Lib/php5/stl.i
Normal file
12
Lib/php5/stl.i
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
/* -----------------------------------------------------------------------------
|
||||
* stl.i
|
||||
*
|
||||
* Initial STL definition. extended as needed in each language
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%include <std_common.i>
|
||||
%include <std_string.i>
|
||||
%include <std_vector.i>
|
||||
%include <std_map.i>
|
||||
%include <std_pair.i>
|
||||
|
||||
322
Lib/php5/typemaps.i
Normal file
322
Lib/php5/typemaps.i
Normal file
|
|
@ -0,0 +1,322 @@
|
|||
/* -----------------------------------------------------------------------------
|
||||
* typemaps.i.
|
||||
*
|
||||
* SWIG Typemap library for PHP.
|
||||
*
|
||||
* This library provides standard typemaps for modifying SWIG's behavior.
|
||||
* With enough entries in this file, I hope that very few people actually
|
||||
* ever need to write a typemap.
|
||||
*
|
||||
* Define macros to define the following typemaps:
|
||||
*
|
||||
* TYPE *INPUT. Argument is passed in as native variable by value.
|
||||
* TYPE *OUTPUT. Argument is returned as an array from the function call.
|
||||
* TYPE *INOUT. Argument is passed in by value, and out as part of returned list
|
||||
* TYPE *REFERENCE. Argument is passed in as native variable with value
|
||||
* semantics. Variable value is changed with result.
|
||||
* Use like this:
|
||||
* int foo(int *REFERENCE);
|
||||
*
|
||||
* $a = 0;
|
||||
* $rc = foo($a);
|
||||
*
|
||||
* Even though $a looks like it's passed by value,
|
||||
* its value can be changed by foo().
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%define BOOL_TYPEMAP(TYPE)
|
||||
%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
|
||||
%{
|
||||
convert_to_boolean_ex($input);
|
||||
temp = Z_LVAL_PP($input) ? true : false;
|
||||
$1 = &temp;
|
||||
%}
|
||||
%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
|
||||
%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
|
||||
%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
|
||||
{
|
||||
zval *o;
|
||||
MAKE_STD_ZVAL(o);
|
||||
ZVAL_BOOL(o,temp$argnum);
|
||||
t_output_helper( &$result, o TSRMLS_CC );
|
||||
}
|
||||
%typemap(in) TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
|
||||
%{
|
||||
convert_to_boolean_ex($input);
|
||||
lvalue = (*$input)->value.lval ? true : false;
|
||||
$1 = &lvalue;
|
||||
%}
|
||||
%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
|
||||
%{
|
||||
(*$arg)->value.lval = lvalue$argnum ? true : false;
|
||||
(*$arg)->type = IS_BOOL;
|
||||
%}
|
||||
%enddef
|
||||
|
||||
%define DOUBLE_TYPEMAP(TYPE)
|
||||
%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
|
||||
%{
|
||||
convert_to_double_ex($input);
|
||||
temp = (TYPE) Z_DVAL_PP($input);
|
||||
$1 = &temp;
|
||||
%}
|
||||
%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
|
||||
%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
|
||||
%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
|
||||
{
|
||||
zval *o;
|
||||
MAKE_STD_ZVAL(o);
|
||||
ZVAL_DOUBLE(o,temp$argnum);
|
||||
t_output_helper( &$result, o TSRMLS_CC );
|
||||
}
|
||||
%typemap(in) TYPE *REFERENCE (TYPE dvalue), TYPE &REFERENCE (TYPE dvalue)
|
||||
%{
|
||||
convert_to_double_ex($input);
|
||||
dvalue = (TYPE) (*$input)->value.dval;
|
||||
$1 = &dvalue;
|
||||
%}
|
||||
%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
|
||||
%{
|
||||
$1->value.dval = (double)(lvalue$argnum);
|
||||
$1->type = IS_DOUBLE;
|
||||
%}
|
||||
%enddef
|
||||
|
||||
%define INT_TYPEMAP(TYPE)
|
||||
%typemap(in) TYPE *INPUT(TYPE temp), TYPE &INPUT(TYPE temp)
|
||||
%{
|
||||
convert_to_long_ex($input);
|
||||
temp = (TYPE) Z_LVAL_PP($input);
|
||||
$1 = &temp;
|
||||
%}
|
||||
%typemap(argout) TYPE *INPUT, TYPE &INPUT "";
|
||||
%typemap(in,numinputs=0) TYPE *OUTPUT(TYPE temp), TYPE &OUTPUT(TYPE temp) "$1 = &temp;";
|
||||
%typemap(argout,fragment="t_output_helper") TYPE *OUTPUT, TYPE &OUTPUT
|
||||
{
|
||||
zval *o;
|
||||
MAKE_STD_ZVAL(o);
|
||||
ZVAL_LONG(o,temp$argnum);
|
||||
t_output_helper( &$result, o TSRMLS_CC );
|
||||
}
|
||||
%typemap(in) TYPE *REFERENCE (TYPE lvalue), TYPE &REFERENCE (TYPE lvalue)
|
||||
%{
|
||||
convert_to_long_ex($input);
|
||||
lvalue = (TYPE) (*$input)->value.lval;
|
||||
$1 = &lvalue;
|
||||
%}
|
||||
%typemap(argout) TYPE *REFERENCE, TYPE &REFERENCE
|
||||
%{
|
||||
(*$arg)->value.lval = (long)(lvalue$argnum);
|
||||
(*$arg)->type = IS_LONG;
|
||||
%}
|
||||
%enddef
|
||||
|
||||
BOOL_TYPEMAP(bool);
|
||||
|
||||
DOUBLE_TYPEMAP(float);
|
||||
DOUBLE_TYPEMAP(double);
|
||||
|
||||
INT_TYPEMAP(int);
|
||||
INT_TYPEMAP(short);
|
||||
INT_TYPEMAP(long);
|
||||
INT_TYPEMAP(unsigned int);
|
||||
INT_TYPEMAP(unsigned short);
|
||||
INT_TYPEMAP(unsigned long);
|
||||
INT_TYPEMAP(unsigned char);
|
||||
INT_TYPEMAP(signed char);
|
||||
|
||||
INT_TYPEMAP(long long);
|
||||
%typemap(argout,fragment="t_output_helper") long long *OUTPUT
|
||||
{
|
||||
zval *o;
|
||||
MAKE_STD_ZVAL(o);
|
||||
if ((long long)LONG_MIN <= temp$argnum && temp$argnum <= (long long)LONG_MAX) {
|
||||
ZVAL_LONG(o, temp$argnum);
|
||||
} else {
|
||||
char temp[256];
|
||||
sprintf(temp, "%lld", (long long)temp$argnum);
|
||||
ZVAL_STRING(o, temp, 1);
|
||||
}
|
||||
t_output_helper( &$result, o TSRMLS_CC );
|
||||
}
|
||||
%typemap(in) TYPE *REFERENCE (long long lvalue)
|
||||
%{
|
||||
CONVERT_LONG_LONG_IN(lvalue, long long, $input)
|
||||
$1 = &lvalue;
|
||||
%}
|
||||
%typemap(argout) long long *REFERENCE
|
||||
%{
|
||||
if ((long long)LONG_MIN <= lvalue$argnum && lvalue$argnum <= (long long)LONG_MAX) {
|
||||
(*$arg)->value.lval = (long)(lvalue$argnum);
|
||||
(*$arg)->type = IS_LONG;
|
||||
} else {
|
||||
char temp[256];
|
||||
sprintf(temp, "%lld", (long long)lvalue$argnum);
|
||||
ZVAL_STRING((*$arg), temp, 1);
|
||||
}
|
||||
%}
|
||||
%typemap(argout) long long &OUTPUT
|
||||
%{
|
||||
if ((long long)LONG_MIN <= *arg$argnum && *arg$argnum <= (long long)LONG_MAX) {
|
||||
($result)->value.lval = (long)(*arg$argnum);
|
||||
($result)->type = IS_LONG;
|
||||
} else {
|
||||
char temp[256];
|
||||
sprintf(temp, "%lld", (long long)(*arg$argnum));
|
||||
ZVAL_STRING($result, temp, 1);
|
||||
}
|
||||
%}
|
||||
INT_TYPEMAP(unsigned long long);
|
||||
%typemap(argout,fragment="t_output_helper") unsigned long long *OUTPUT
|
||||
{
|
||||
zval *o;
|
||||
MAKE_STD_ZVAL(o);
|
||||
if (temp$argnum <= (unsigned long long)LONG_MAX) {
|
||||
ZVAL_LONG(o, temp$argnum);
|
||||
} else {
|
||||
char temp[256];
|
||||
sprintf(temp, "%llu", (unsigned long long)temp$argnum);
|
||||
ZVAL_STRING(o, temp, 1);
|
||||
}
|
||||
t_output_helper( &$result, o TSRMLS_CC );
|
||||
}
|
||||
%typemap(in) TYPE *REFERENCE (unsigned long long lvalue)
|
||||
%{
|
||||
CONVERT_UNSIGNED_LONG_LONG_IN(lvalue, unsigned long long, $input)
|
||||
$1 = &lvalue;
|
||||
%}
|
||||
%typemap(argout) unsigned long long *REFERENCE
|
||||
%{
|
||||
if (lvalue$argnum <= (unsigned long long)LONG_MAX) {
|
||||
(*$arg)->value.lval = (long)(lvalue$argnum);
|
||||
(*$arg)->type = IS_LONG;
|
||||
} else {
|
||||
char temp[256];
|
||||
sprintf(temp, "%llu", (unsigned long long)lvalue$argnum);
|
||||
ZVAL_STRING((*$arg), temp, 1);
|
||||
}
|
||||
%}
|
||||
%typemap(argout) unsigned long long &OUTPUT
|
||||
%{
|
||||
if (*arg$argnum <= (unsigned long long)LONG_MAX) {
|
||||
($result)->value.lval = (long)(*arg$argnum);
|
||||
($result)->type = IS_LONG;
|
||||
} else {
|
||||
char temp[256];
|
||||
sprintf(temp, "%llu", (unsigned long long)(*arg$argnum));
|
||||
ZVAL_STRING($result, temp, 1);
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(in) bool *INOUT = bool *INPUT;
|
||||
%typemap(in) float *INOUT = float *INPUT;
|
||||
%typemap(in) double *INOUT = double *INPUT;
|
||||
|
||||
%typemap(in) int *INOUT = int *INPUT;
|
||||
%typemap(in) short *INOUT = short *INPUT;
|
||||
%typemap(in) long *INOUT = long *INPUT;
|
||||
%typemap(in) long long *INOUT = long long *INPUT;
|
||||
%typemap(in) unsigned *INOUT = unsigned *INPUT;
|
||||
%typemap(in) unsigned short *INOUT = unsigned short *INPUT;
|
||||
%typemap(in) unsigned long *INOUT = unsigned long *INPUT;
|
||||
%typemap(in) unsigned char *INOUT = unsigned char *INPUT;
|
||||
%typemap(in) unsigned long long *INOUT = unsigned long long *INPUT;
|
||||
%typemap(in) signed char *INOUT = signed char *INPUT;
|
||||
|
||||
%typemap(in) bool &INOUT = bool *INPUT;
|
||||
%typemap(in) float &INOUT = float *INPUT;
|
||||
%typemap(in) double &INOUT = double *INPUT;
|
||||
|
||||
%typemap(in) int &INOUT = int *INPUT;
|
||||
%typemap(in) short &INOUT = short *INPUT;
|
||||
%typemap(in) long &INOUT = long *INPUT;
|
||||
%typemap(in) long long &INOUT = long long *INPUT;
|
||||
%typemap(in) long long &INPUT = long long *INPUT;
|
||||
%typemap(in) unsigned &INOUT = unsigned *INPUT;
|
||||
%typemap(in) unsigned short &INOUT = unsigned short *INPUT;
|
||||
%typemap(in) unsigned long &INOUT = unsigned long *INPUT;
|
||||
%typemap(in) unsigned char &INOUT = unsigned char *INPUT;
|
||||
%typemap(in) unsigned long long &INOUT = unsigned long long *INPUT;
|
||||
%typemap(in) unsigned long long &INPUT = unsigned long long *INPUT;
|
||||
%typemap(in) signed char &INOUT = signed char *INPUT;
|
||||
|
||||
%typemap(argout) bool *INOUT = bool *OUTPUT;
|
||||
%typemap(argout) float *INOUT = float *OUTPUT;
|
||||
%typemap(argout) double *INOUT= double *OUTPUT;
|
||||
|
||||
%typemap(argout) int *INOUT = int *OUTPUT;
|
||||
%typemap(argout) short *INOUT = short *OUTPUT;
|
||||
%typemap(argout) long *INOUT= long *OUTPUT;
|
||||
%typemap(argout) long long *INOUT= long long *OUTPUT;
|
||||
%typemap(argout) unsigned short *INOUT= unsigned short *OUTPUT;
|
||||
%typemap(argout) unsigned long *INOUT = unsigned long *OUTPUT;
|
||||
%typemap(argout) unsigned char *INOUT = unsigned char *OUTPUT;
|
||||
%typemap(argout) unsigned long long *INOUT = unsigned long long *OUTPUT;
|
||||
%typemap(argout) signed char *INOUT = signed char *OUTPUT;
|
||||
|
||||
%typemap(argout) bool &INOUT = bool *OUTPUT;
|
||||
%typemap(argout) float &INOUT = float *OUTPUT;
|
||||
%typemap(argout) double &INOUT= double *OUTPUT;
|
||||
|
||||
%typemap(argout) int &INOUT = int *OUTPUT;
|
||||
%typemap(argout) short &INOUT = short *OUTPUT;
|
||||
%typemap(argout) long &INOUT= long *OUTPUT;
|
||||
%typemap(argout) long long &INOUT= long long *OUTPUT;
|
||||
%typemap(argout) unsigned short &INOUT= unsigned short *OUTPUT;
|
||||
%typemap(argout) unsigned long &INOUT = unsigned long *OUTPUT;
|
||||
%typemap(argout) unsigned char &INOUT = unsigned char *OUTPUT;
|
||||
%typemap(argout) unsigned long long &INOUT = unsigned long long *OUTPUT;
|
||||
%typemap(argout) signed char &INOUT = signed char *OUTPUT;
|
||||
|
||||
%typemap(in) char INPUT[ANY] ( char temp[$1_dim0] )
|
||||
%{
|
||||
convert_to_string_ex($input);
|
||||
strncpy(temp,Z_STRVAL_PP($input),$1_dim0);
|
||||
$1 = temp;
|
||||
%}
|
||||
%typemap(in,numinputs=0) char OUTPUT[ANY] ( char temp[$1_dim0] )
|
||||
"$1 = temp;";
|
||||
%typemap(argout,fragment="t_output_helper") char OUTPUT[ANY]
|
||||
{
|
||||
zval *o;
|
||||
MAKE_STD_ZVAL(o);
|
||||
ZVAL_STRINGL(o,temp$argnum,$1_dim0);
|
||||
t_output_helper( &$result, o TSRMLS_CC );
|
||||
}
|
||||
|
||||
%typemap(in,numinputs=0) void **OUTPUT (int force),
|
||||
void *&OUTPUT (int force)
|
||||
%{
|
||||
/* If they pass NULL by reference, make it into a void*
|
||||
This bit should go in arginit if arginit support init-ing scripting args */
|
||||
if(SWIG_ConvertPtr(*$input, (void **) &$1, $1_descriptor, 0) < 0) {
|
||||
/* So... we didn't get a ref or ptr, but we'll accept NULL by reference */
|
||||
if (!((*$input)->type==IS_NULL && PZVAL_IS_REF(*$input))) {
|
||||
/* wasn't a pre/ref/thing, OR anything like an int thing */
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument $arg of $symname.");
|
||||
}
|
||||
}
|
||||
force=0;
|
||||
if (arg1==NULL) {
|
||||
#ifdef __cplusplus
|
||||
ptr=new $*1_ltype();
|
||||
#else
|
||||
ptr=($*1_ltype) calloc(1,sizeof($*1_ltype));
|
||||
#endif
|
||||
$1=&ptr;
|
||||
/* have to passback arg$arg too */
|
||||
force=1;
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(argout) void **OUTPUT,
|
||||
void *&OUTPUT
|
||||
%{
|
||||
if (force$argnum) { /* pass back arg$argnum through params ($arg) if we can */
|
||||
if (!PZVAL_IS_REF(*$arg)) {
|
||||
SWIG_PHP_Error(E_WARNING, "Parameter $argnum of $symname wasn't passed by reference");
|
||||
} else {
|
||||
SWIG_SetPointerZval(*$arg, (void *) ptr$argnum, $*1_descriptor, 1);
|
||||
}
|
||||
}
|
||||
%}
|
||||
114
Lib/php5/utils.i
Normal file
114
Lib/php5/utils.i
Normal file
|
|
@ -0,0 +1,114 @@
|
|||
|
||||
%define CONVERT_BOOL_IN(lvar,t,invar)
|
||||
convert_to_boolean_ex(invar);
|
||||
lvar = (t) Z_LVAL_PP(invar);
|
||||
%enddef
|
||||
|
||||
%define CONVERT_INT_IN(lvar,t,invar)
|
||||
convert_to_long_ex(invar);
|
||||
lvar = (t) Z_LVAL_PP(invar);
|
||||
%enddef
|
||||
|
||||
%define CONVERT_LONG_LONG_IN(lvar,t,invar)
|
||||
switch ((*(invar))->type) {
|
||||
case IS_DOUBLE:
|
||||
lvar = (t) (*(invar))->value.dval;
|
||||
break;
|
||||
case IS_STRING: {
|
||||
char * endptr;
|
||||
errno = 0;
|
||||
lvar = (t) strtoll((*(invar))->value.str.val, &endptr, 10);
|
||||
if (*endptr && !errno) break;
|
||||
/* FALL THRU */
|
||||
}
|
||||
default:
|
||||
convert_to_long_ex(invar);
|
||||
lvar = (t) (*(invar))->value.lval;
|
||||
}
|
||||
%enddef
|
||||
|
||||
%define CONVERT_UNSIGNED_LONG_LONG_IN(lvar,t,invar)
|
||||
switch ((*(invar))->type) {
|
||||
case IS_DOUBLE:
|
||||
lvar = (t) (*(invar))->value.dval;
|
||||
break;
|
||||
case IS_STRING: {
|
||||
char * endptr;
|
||||
errno = 0;
|
||||
lvar = (t) strtoull((*(invar))->value.str.val, &endptr, 10);
|
||||
if (*endptr && !errno) break;
|
||||
/* FALL THRU */
|
||||
}
|
||||
default:
|
||||
convert_to_long_ex(invar);
|
||||
lvar = (t) (*(invar))->value.lval;
|
||||
}
|
||||
%enddef
|
||||
|
||||
%define CONVERT_INT_OUT(lvar,invar)
|
||||
lvar = (t) Z_LVAL_PP(invar);
|
||||
%enddef
|
||||
|
||||
%define CONVERT_FLOAT_IN(lvar,t,invar)
|
||||
convert_to_double_ex(invar);
|
||||
lvar = (t) Z_DVAL_PP(invar);
|
||||
%enddef
|
||||
|
||||
%define CONVERT_CHAR_IN(lvar,t,invar)
|
||||
convert_to_string_ex(invar);
|
||||
lvar = (t) *Z_STRVAL_PP(invar);
|
||||
%enddef
|
||||
|
||||
%define CONVERT_STRING_IN(lvar,t,invar)
|
||||
if ((*invar)->type==IS_NULL) {
|
||||
lvar = (t) 0;
|
||||
} else {
|
||||
convert_to_string_ex(invar);
|
||||
lvar = (t) Z_STRVAL_PP(invar);
|
||||
}
|
||||
%enddef
|
||||
|
||||
%define %pass_by_val( TYPE, CONVERT_IN )
|
||||
%typemap(in) TYPE
|
||||
%{
|
||||
CONVERT_IN($1,$1_ltype,$input);
|
||||
%}
|
||||
%typemap(in) const TYPE & ($*1_ltype temp)
|
||||
%{
|
||||
CONVERT_IN(temp,$*1_ltype,$input);
|
||||
$1 = &temp;
|
||||
%}
|
||||
%typemap(directorout) TYPE
|
||||
%{
|
||||
CONVERT_IN($result,$1_ltype,&$input);
|
||||
%}
|
||||
%typemap(directorout) const TYPE & ($*1_ltype temp)
|
||||
%{
|
||||
CONVERT_IN(temp,$*1_ltype,&$input);
|
||||
$result = &temp;
|
||||
%}
|
||||
%enddef
|
||||
|
||||
%fragment("t_output_helper","header") %{
|
||||
static void
|
||||
t_output_helper(zval **target, zval *o TSRMLS_DC) {
|
||||
zval *tmp;
|
||||
if ( (*target)->type == IS_ARRAY ) {
|
||||
/* it's already an array, just append */
|
||||
add_next_index_zval( *target, o );
|
||||
return;
|
||||
}
|
||||
if ( (*target)->type == IS_NULL ) {
|
||||
REPLACE_ZVAL_VALUE(target,o,1);
|
||||
FREE_ZVAL(o);
|
||||
return;
|
||||
}
|
||||
ALLOC_INIT_ZVAL(tmp);
|
||||
*tmp = **target;
|
||||
zval_copy_ctor(tmp);
|
||||
array_init(*target);
|
||||
add_next_index_zval( *target, tmp);
|
||||
add_next_index_zval( *target, o);
|
||||
|
||||
}
|
||||
%}
|
||||
|
|
@ -15,7 +15,6 @@ complex.i C99 or C++ complex type
|
|||
cstring.i Various forms of C character string handling
|
||||
cwstring.i Various forms of C wchar_t string handling
|
||||
embed.i embedding the Python interpreter in something else
|
||||
embed15.i embedding the Python interpreter in something else
|
||||
file.i FILE C type
|
||||
implicit.i Allow the use of implicit C++ constructors
|
||||
wchar.i wchar_t C type
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@
|
|||
%variable_fail(res, "$type", "$name");
|
||||
}
|
||||
if (!argp) {
|
||||
%argument_nullref("$type", $symname, $argnum);
|
||||
%variable_nullref("$type", "$name");
|
||||
} else {
|
||||
$1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
|
||||
if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
|
|
@ -137,7 +137,9 @@
|
|||
%variable_fail(res, "$type", "$name");
|
||||
}
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
|
||||
if (!argp) { %argument_nullref("$type", $symname, $argnum); }
|
||||
if (!argp) {
|
||||
%variable_nullref("$type", "$name");
|
||||
}
|
||||
if (newmem & SWIG_CAST_NEW_MEMORY) {
|
||||
tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
|
||||
|
|
|
|||
|
|
@ -1,211 +1,29 @@
|
|||
#define SWIGPY_UNARYFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN PyObject * \
|
||||
wrapper##_closure(PyObject *a) { \
|
||||
return wrapper(a, NULL); \
|
||||
}
|
||||
|
||||
#define SWIGPY_DESTRUCTOR_CLOSURE(wrapper) \
|
||||
SWIGINTERN void \
|
||||
wrapper##_closure(PyObject *a) { \
|
||||
SwigPyObject *sobj; \
|
||||
sobj = (SwigPyObject *)a; \
|
||||
Py_XDECREF(sobj->dict); \
|
||||
if (sobj->own) { \
|
||||
PyObject *o = wrapper(a, NULL); \
|
||||
Py_XDECREF(o); \
|
||||
} \
|
||||
if (PyType_IS_GC(a->ob_type)) { \
|
||||
PyObject_GC_Del(a); \
|
||||
} else { \
|
||||
PyObject_Del(a); \
|
||||
} \
|
||||
}
|
||||
|
||||
#define SWIGPY_INQUIRY_CLOSURE(wrapper) \
|
||||
SWIGINTERN int \
|
||||
wrapper##_closure(PyObject *a) { \
|
||||
PyObject *pyresult; \
|
||||
int result; \
|
||||
pyresult = wrapper(a, NULL); \
|
||||
result = pyresult && PyObject_IsTrue(pyresult) ? 1 : 0; \
|
||||
Py_XDECREF(pyresult); \
|
||||
return result; \
|
||||
}
|
||||
|
||||
#define SWIGPY_BINARYFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN PyObject * \
|
||||
wrapper##_closure(PyObject *a, PyObject *b) { \
|
||||
PyObject *tuple, *result; \
|
||||
tuple = PyTuple_New(1); \
|
||||
assert(tuple); \
|
||||
PyTuple_SET_ITEM(tuple, 0, b); \
|
||||
Py_XINCREF(b); \
|
||||
result = wrapper(a, tuple); \
|
||||
Py_DECREF(tuple); \
|
||||
return result; \
|
||||
}
|
||||
|
||||
typedef ternaryfunc ternarycallfunc;
|
||||
|
||||
#define SWIGPY_TERNARYFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN PyObject * \
|
||||
wrapper##_closure(PyObject *a, PyObject *b, PyObject *c) { \
|
||||
PyObject *tuple, *result; \
|
||||
tuple = PyTuple_New(2); \
|
||||
assert(tuple); \
|
||||
PyTuple_SET_ITEM(tuple, 0, b); \
|
||||
PyTuple_SET_ITEM(tuple, 1, c); \
|
||||
Py_XINCREF(b); \
|
||||
Py_XINCREF(c); \
|
||||
result = wrapper(a, tuple); \
|
||||
Py_DECREF(tuple); \
|
||||
return result; \
|
||||
}
|
||||
|
||||
#define SWIGPY_TERNARYCALLFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN PyObject * \
|
||||
wrapper##_closure(PyObject *callable_object, PyObject *args, PyObject *) { \
|
||||
return wrapper(callable_object, args); \
|
||||
}
|
||||
|
||||
#define SWIGPY_LENFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN Py_ssize_t \
|
||||
wrapper##_closure(PyObject *a) { \
|
||||
PyObject *resultobj; \
|
||||
Py_ssize_t result; \
|
||||
resultobj = wrapper(a, NULL); \
|
||||
result = PyNumber_AsSsize_t(resultobj, NULL); \
|
||||
Py_DECREF(resultobj); \
|
||||
return result; \
|
||||
}
|
||||
|
||||
#define SWIGPY_SSIZESSIZEARGFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN PyObject * \
|
||||
wrapper##_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c) { \
|
||||
PyObject *tuple, *result; \
|
||||
tuple = PyTuple_New(2); \
|
||||
assert(tuple); \
|
||||
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b)); \
|
||||
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c)); \
|
||||
result = wrapper(a, tuple); \
|
||||
Py_DECREF(tuple); \
|
||||
return result; \
|
||||
}
|
||||
|
||||
#define SWIGPY_SSIZESSIZEOBJARGPROC_CLOSURE(wrapper) \
|
||||
SWIGINTERN int \
|
||||
wrapper##_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) { \
|
||||
PyObject *tuple, *resultobj; \
|
||||
int result; \
|
||||
tuple = PyTuple_New(d ? 3 : 2); \
|
||||
assert(tuple); \
|
||||
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b)); \
|
||||
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c)); \
|
||||
if (d) { \
|
||||
PyTuple_SET_ITEM(tuple, 2, d); \
|
||||
Py_INCREF(d); \
|
||||
} \
|
||||
resultobj = wrapper(a, tuple); \
|
||||
result = resultobj ? 0 : -1; \
|
||||
Py_DECREF(tuple); \
|
||||
Py_XDECREF(resultobj); \
|
||||
return result; \
|
||||
}
|
||||
|
||||
#define SWIGPY_SSIZEARGFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN PyObject * \
|
||||
wrapper##_closure(PyObject *a, Py_ssize_t b) { \
|
||||
PyObject *tuple, *result; \
|
||||
tuple = PyTuple_New(1); \
|
||||
assert(tuple); \
|
||||
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b)); \
|
||||
result = wrapper(a, tuple); \
|
||||
Py_DECREF(tuple); \
|
||||
return result; \
|
||||
}
|
||||
|
||||
#define SWIGPY_FUNPACK_SSIZEARGFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN PyObject * \
|
||||
wrapper##_closure(PyObject *a, Py_ssize_t b) { \
|
||||
PyObject *arg, *result; \
|
||||
arg = _PyLong_FromSsize_t(b); \
|
||||
result = wrapper(a, arg); \
|
||||
Py_DECREF(arg); \
|
||||
return result; \
|
||||
}
|
||||
|
||||
#define SWIGPY_SSIZEOBJARGPROC_CLOSURE(wrapper) \
|
||||
SWIGINTERN int \
|
||||
wrapper##_closure(PyObject *a, Py_ssize_t b, PyObject *c) { \
|
||||
PyObject *tuple, *resultobj; \
|
||||
int result; \
|
||||
tuple = PyTuple_New(2); \
|
||||
assert(tuple); \
|
||||
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b)); \
|
||||
PyTuple_SET_ITEM(tuple, 1, c); \
|
||||
Py_XINCREF(c); \
|
||||
resultobj = wrapper(a, tuple); \
|
||||
result = resultobj ? 0 : -1; \
|
||||
Py_XDECREF(resultobj); \
|
||||
Py_DECREF(tuple); \
|
||||
return result; \
|
||||
}
|
||||
|
||||
#define SWIGPY_OBJOBJARGPROC_CLOSURE(wrapper) \
|
||||
SWIGINTERN int \
|
||||
wrapper##_closure(PyObject *a, PyObject *b, PyObject *c) { \
|
||||
PyObject *tuple, *resultobj; \
|
||||
int result; \
|
||||
tuple = PyTuple_New(c ? 2 : 1); \
|
||||
assert(tuple); \
|
||||
PyTuple_SET_ITEM(tuple, 0, b); \
|
||||
Py_XINCREF(b); \
|
||||
if (c) { \
|
||||
PyTuple_SET_ITEM(tuple, 1, c); \
|
||||
Py_XINCREF(c); \
|
||||
} \
|
||||
resultobj = wrapper(a, tuple); \
|
||||
result = resultobj ? 0 : -1; \
|
||||
Py_XDECREF(resultobj); \
|
||||
Py_DECREF(tuple); \
|
||||
return result; \
|
||||
}
|
||||
|
||||
#define SWIGPY_REPRFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN PyObject * \
|
||||
wrapper##_closure(PyObject *a) { \
|
||||
return wrapper(a, NULL); \
|
||||
}
|
||||
|
||||
#define SWIGPY_HASHFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN long \
|
||||
wrapper##_closure(PyObject *a) { \
|
||||
PyObject *pyresult; \
|
||||
long result; \
|
||||
pyresult = wrapper(a, NULL); \
|
||||
if (!pyresult || !PyLong_Check(pyresult)) \
|
||||
return -1; \
|
||||
result = PyLong_AsLong(pyresult); \
|
||||
Py_DECREF(pyresult); \
|
||||
return result; \
|
||||
}
|
||||
|
||||
#define SWIGPY_ITERNEXT_CLOSURE(wrapper) \
|
||||
SWIGINTERN PyObject * \
|
||||
wrapper##_closure(PyObject *a) { \
|
||||
PyObject *result; \
|
||||
result = wrapper(a, NULL); \
|
||||
if (result && result == Py_None) { \
|
||||
Py_DECREF(result); \
|
||||
result = NULL; \
|
||||
} \
|
||||
return result; \
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
SWIGINTERN Py_hash_t
|
||||
SwigPyObject_hash(PyObject *obj) {
|
||||
SwigPyObject *sobj = (SwigPyObject *)obj;
|
||||
void *ptr = sobj->ptr;
|
||||
return (Py_hash_t)ptr;
|
||||
}
|
||||
|
||||
SWIGINTERN Py_hash_t
|
||||
SWIG_PyNumber_AsPyHash(PyObject *obj) {
|
||||
Py_hash_t result = -1;
|
||||
#if PY_VERSION_HEX < 0x03020000
|
||||
if (PyLong_Check(obj))
|
||||
result = PyLong_AsLong(obj);
|
||||
#else
|
||||
if (PyNumber_Check(obj))
|
||||
result = PyNumber_AsSsize_t(obj, NULL);
|
||||
#endif
|
||||
else
|
||||
PyErr_Format(PyExc_TypeError, "Wrong type for hash function");
|
||||
return result;
|
||||
}
|
||||
|
||||
SWIGINTERN int
|
||||
SwigPyBuiltin_BadInit(PyObject *self, PyObject *SWIGUNUSEDPARM(args), PyObject *SWIGUNUSEDPARM(kwds)) {
|
||||
PyErr_Format(PyExc_TypeError, "Cannot create new instances of type '%.300s'", self->ob_type->tp_name);
|
||||
|
|
@ -213,11 +31,10 @@ SwigPyBuiltin_BadInit(PyObject *self, PyObject *SWIGUNUSEDPARM(args), PyObject *
|
|||
}
|
||||
|
||||
SWIGINTERN void
|
||||
SwigPyBuiltin_BadDealloc(PyObject *pyobj) {
|
||||
SwigPyObject *sobj;
|
||||
sobj = (SwigPyObject *)pyobj;
|
||||
SwigPyBuiltin_BadDealloc(PyObject *obj) {
|
||||
SwigPyObject *sobj = (SwigPyObject *)obj;
|
||||
if (sobj->own) {
|
||||
PyErr_Format(PyExc_TypeError, "Swig detected a memory leak in type '%.300s': no callable destructor found.", pyobj->ob_type->tp_name);
|
||||
PyErr_Format(PyExc_TypeError, "Swig detected a memory leak in type '%.300s': no callable destructor found.", obj->ob_type->tp_name);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -347,9 +164,13 @@ SwigPyStaticVar_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value)
|
|||
}
|
||||
|
||||
SWIGINTERN int
|
||||
SwigPyObjectType_setattro(PyTypeObject *type, PyObject *name, PyObject *value) {
|
||||
SwigPyObjectType_setattro(PyObject *typeobject, PyObject *name, PyObject *value) {
|
||||
PyObject *attribute;
|
||||
PyTypeObject *type;
|
||||
descrsetfunc local_set;
|
||||
|
||||
assert(PyType_Check(typeobject));
|
||||
type = (PyTypeObject *)typeobject;
|
||||
attribute = _PyType_Lookup(type, name);
|
||||
if (attribute != NULL) {
|
||||
/* Implement descriptor functionality, if any */
|
||||
|
|
@ -378,16 +199,15 @@ SwigPyStaticVar_Type(void) {
|
|||
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(&PyType_Type, 0)
|
||||
#else
|
||||
PyObject_HEAD_INIT(&PyType_Type)
|
||||
0,
|
||||
0, /* ob_size */
|
||||
#endif
|
||||
"swig_static_var_getset_descriptor",
|
||||
sizeof(PyGetSetDescrObject),
|
||||
0,
|
||||
"swig_static_var_getset_descriptor", /* tp_name */
|
||||
sizeof(PyGetSetDescrObject), /* tp_basicsize */
|
||||
0, /* tp_itemsize */
|
||||
(destructor)SwigPyStaticVar_dealloc, /* tp_dealloc */
|
||||
0, /* tp_print */
|
||||
0, /* tp_getattr */
|
||||
|
|
@ -433,10 +253,19 @@ SwigPyStaticVar_Type(void) {
|
|||
0, /* tp_del */
|
||||
#endif
|
||||
#if PY_VERSION_HEX >= 0x02060000
|
||||
0, /* tp_version */
|
||||
0, /* tp_version_tag */
|
||||
#endif
|
||||
#if PY_VERSION_HEX >= 0x03040000
|
||||
0, /* tp_finalize */
|
||||
#endif
|
||||
#ifdef COUNT_ALLOCS
|
||||
0,0,0,0 /* tp_alloc -> tp_next */
|
||||
0, /* tp_allocs */
|
||||
0, /* tp_frees */
|
||||
0, /* tp_maxalloc */
|
||||
#if PY_VERSION_HEX >= 0x02050000
|
||||
0, /* tp_prev */
|
||||
#endif
|
||||
0 /* tp_next */
|
||||
#endif
|
||||
};
|
||||
staticvar_type = tmp;
|
||||
|
|
@ -451,6 +280,95 @@ SwigPyStaticVar_Type(void) {
|
|||
return &staticvar_type;
|
||||
}
|
||||
|
||||
SWIGINTERN PyTypeObject*
|
||||
SwigPyObjectType(void) {
|
||||
static char swigpyobjecttype_doc[] = "Metaclass for SWIG wrapped types";
|
||||
static PyTypeObject swigpyobjecttype_type;
|
||||
static int type_init = 0;
|
||||
if (!type_init) {
|
||||
const PyTypeObject tmp = {
|
||||
#if PY_VERSION_HEX >= 0x03000000
|
||||
PyVarObject_HEAD_INIT(&PyType_Type, 0)
|
||||
#else
|
||||
PyObject_HEAD_INIT(&PyType_Type)
|
||||
0, /* ob_size */
|
||||
#endif
|
||||
"SwigPyObjectType", /* tp_name */
|
||||
PyType_Type.tp_basicsize, /* tp_basicsize */
|
||||
0, /* tp_itemsize */
|
||||
0, /* tp_dealloc */
|
||||
0, /* tp_print */
|
||||
0, /* tp_getattr */
|
||||
0, /* tp_setattr */
|
||||
0, /* tp_compare */
|
||||
0, /* tp_repr */
|
||||
0, /* tp_as_number */
|
||||
0, /* tp_as_sequence */
|
||||
0, /* tp_as_mapping */
|
||||
0, /* tp_hash */
|
||||
0, /* tp_call */
|
||||
0, /* tp_str */
|
||||
0, /* tp_getattro */
|
||||
SwigPyObjectType_setattro, /* tp_setattro */
|
||||
0, /* tp_as_buffer */
|
||||
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
|
||||
swigpyobjecttype_doc, /* tp_doc */
|
||||
0, /* tp_traverse */
|
||||
0, /* tp_clear */
|
||||
0, /* tp_richcompare */
|
||||
0, /* tp_weaklistoffset */
|
||||
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 */
|
||||
#if PY_VERSION_HEX >= 0x02030000
|
||||
0, /* tp_del */
|
||||
#endif
|
||||
#if PY_VERSION_HEX >= 0x02060000
|
||||
0, /* tp_version_tag */
|
||||
#endif
|
||||
#if PY_VERSION_HEX >= 0x03040000
|
||||
0, /* tp_finalize */
|
||||
#endif
|
||||
#ifdef COUNT_ALLOCS
|
||||
0, /* tp_allocs */
|
||||
0, /* tp_frees */
|
||||
0, /* tp_maxalloc */
|
||||
#if PY_VERSION_HEX >= 0x02050000
|
||||
0, /* tp_prev */
|
||||
#endif
|
||||
0 /* tp_next */
|
||||
#endif
|
||||
};
|
||||
swigpyobjecttype_type = tmp;
|
||||
type_init = 1;
|
||||
swigpyobjecttype_type.tp_base = &PyType_Type;
|
||||
#if PY_VERSION_HEX < 0x02020000
|
||||
swigpyobjecttype_type.ob_type = &PyType_Type;
|
||||
#else
|
||||
if (PyType_Ready(&swigpyobjecttype_type) < 0)
|
||||
return NULL;
|
||||
#endif
|
||||
}
|
||||
return &swigpyobjecttype_type;
|
||||
}
|
||||
|
||||
SWIGINTERN PyGetSetDescrObject *
|
||||
SwigPyStaticVar_new_getset(PyTypeObject *type, PyGetSetDef *getset) {
|
||||
|
||||
|
|
@ -509,6 +427,295 @@ SwigPyBuiltin_SetMetaType (PyTypeObject *type, PyTypeObject *metatype)
|
|||
#endif
|
||||
}
|
||||
|
||||
|
||||
/* Start of callback function macros for use in PyTypeObject */
|
||||
|
||||
typedef PyObject *(*SwigPyWrapperFunction)(PyObject *, PyObject *);
|
||||
|
||||
#define SWIGPY_UNARYFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN PyObject * \
|
||||
wrapper##_unaryfunc_closure(PyObject *a) { \
|
||||
return SwigPyBuiltin_unaryfunc_closure(wrapper, a); \
|
||||
}
|
||||
SWIGINTERN PyObject *
|
||||
SwigPyBuiltin_unaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
|
||||
return wrapper(a, NULL);
|
||||
}
|
||||
|
||||
#define SWIGPY_DESTRUCTOR_CLOSURE(wrapper) \
|
||||
SWIGINTERN void \
|
||||
wrapper##_destructor_closure(PyObject *a) { \
|
||||
SwigPyBuiltin_destructor_closure(wrapper, #wrapper, a); \
|
||||
}
|
||||
SWIGINTERN void
|
||||
SwigPyBuiltin_destructor_closure(SwigPyWrapperFunction wrapper, const char *wrappername, PyObject *a) {
|
||||
SwigPyObject *sobj;
|
||||
sobj = (SwigPyObject *)a;
|
||||
Py_XDECREF(sobj->dict);
|
||||
if (sobj->own) {
|
||||
PyObject *o;
|
||||
PyObject *val = 0, *type = 0, *tb = 0;
|
||||
PyErr_Fetch(&val, &type, &tb);
|
||||
o = wrapper(a, NULL);
|
||||
if (!o) {
|
||||
PyObject *deallocname = PyString_FromString(wrappername);
|
||||
PyErr_WriteUnraisable(deallocname);
|
||||
Py_DECREF(deallocname);
|
||||
}
|
||||
PyErr_Restore(val, type, tb);
|
||||
Py_XDECREF(o);
|
||||
}
|
||||
if (PyType_IS_GC(a->ob_type)) {
|
||||
PyObject_GC_Del(a);
|
||||
} else {
|
||||
PyObject_Del(a);
|
||||
}
|
||||
}
|
||||
|
||||
#define SWIGPY_INQUIRY_CLOSURE(wrapper) \
|
||||
SWIGINTERN int \
|
||||
wrapper##_inquiry_closure(PyObject *a) { \
|
||||
return SwigPyBuiltin_inquiry_closure(wrapper, a); \
|
||||
}
|
||||
SWIGINTERN int
|
||||
SwigPyBuiltin_inquiry_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
|
||||
PyObject *pyresult;
|
||||
int result;
|
||||
pyresult = wrapper(a, NULL);
|
||||
result = pyresult && PyObject_IsTrue(pyresult) ? 1 : 0;
|
||||
Py_XDECREF(pyresult);
|
||||
return result;
|
||||
}
|
||||
|
||||
#define SWIGPY_GETITERFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN PyObject * \
|
||||
wrapper##_getiterfunc_closure(PyObject *a) { \
|
||||
return SwigPyBuiltin_getiterfunc_closure(wrapper, a); \
|
||||
}
|
||||
SWIGINTERN PyObject *
|
||||
SwigPyBuiltin_getiterfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
|
||||
return wrapper(a, NULL);
|
||||
}
|
||||
|
||||
#define SWIGPY_BINARYFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN PyObject * \
|
||||
wrapper##_binaryfunc_closure(PyObject *a, PyObject *b) { \
|
||||
return SwigPyBuiltin_binaryfunc_closure(wrapper, a, b); \
|
||||
}
|
||||
SWIGINTERN PyObject *
|
||||
SwigPyBuiltin_binaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b) {
|
||||
PyObject *tuple, *result;
|
||||
tuple = PyTuple_New(1);
|
||||
assert(tuple);
|
||||
PyTuple_SET_ITEM(tuple, 0, b);
|
||||
Py_XINCREF(b);
|
||||
result = wrapper(a, tuple);
|
||||
Py_DECREF(tuple);
|
||||
return result;
|
||||
}
|
||||
|
||||
typedef ternaryfunc ternarycallfunc;
|
||||
|
||||
#define SWIGPY_TERNARYFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN PyObject * \
|
||||
wrapper##_ternaryfunc_closure(PyObject *a, PyObject *b, PyObject *c) { \
|
||||
return SwigPyBuiltin_ternaryfunc_closure(wrapper, a, b, c); \
|
||||
}
|
||||
SWIGINTERN PyObject *
|
||||
SwigPyBuiltin_ternaryfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
|
||||
PyObject *tuple, *result;
|
||||
tuple = PyTuple_New(2);
|
||||
assert(tuple);
|
||||
PyTuple_SET_ITEM(tuple, 0, b);
|
||||
PyTuple_SET_ITEM(tuple, 1, c);
|
||||
Py_XINCREF(b);
|
||||
Py_XINCREF(c);
|
||||
result = wrapper(a, tuple);
|
||||
Py_DECREF(tuple);
|
||||
return result;
|
||||
}
|
||||
|
||||
#define SWIGPY_TERNARYCALLFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN PyObject * \
|
||||
wrapper##_ternarycallfunc_closure(PyObject *a, PyObject *b, PyObject *c) { \
|
||||
return SwigPyBuiltin_ternarycallfunc_closure(wrapper, a, b, c); \
|
||||
}
|
||||
SWIGINTERN PyObject *
|
||||
SwigPyBuiltin_ternarycallfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
|
||||
(void) c;
|
||||
return wrapper(a, b);
|
||||
}
|
||||
|
||||
#define SWIGPY_LENFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN Py_ssize_t \
|
||||
wrapper##_lenfunc_closure(PyObject *a) { \
|
||||
return SwigPyBuiltin_lenfunc_closure(wrapper, a); \
|
||||
}
|
||||
SWIGINTERN Py_ssize_t
|
||||
SwigPyBuiltin_lenfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
|
||||
PyObject *resultobj;
|
||||
Py_ssize_t result;
|
||||
resultobj = wrapper(a, NULL);
|
||||
result = PyNumber_AsSsize_t(resultobj, NULL);
|
||||
Py_DECREF(resultobj);
|
||||
return result;
|
||||
}
|
||||
|
||||
#define SWIGPY_SSIZESSIZEARGFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN PyObject * \
|
||||
wrapper##_ssizessizeargfunc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c) { \
|
||||
return SwigPyBuiltin_ssizessizeargfunc_closure(wrapper, a, b, c); \
|
||||
}
|
||||
SWIGINTERN PyObject *
|
||||
SwigPyBuiltin_ssizessizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c) {
|
||||
PyObject *tuple, *result;
|
||||
tuple = PyTuple_New(2);
|
||||
assert(tuple);
|
||||
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
|
||||
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
|
||||
result = wrapper(a, tuple);
|
||||
Py_DECREF(tuple);
|
||||
return result;
|
||||
}
|
||||
|
||||
#define SWIGPY_SSIZESSIZEOBJARGPROC_CLOSURE(wrapper) \
|
||||
SWIGINTERN int \
|
||||
wrapper##_ssizessizeobjargproc_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) { \
|
||||
return SwigPyBuiltin_ssizessizeobjargproc_closure(wrapper, a, b, c, d); \
|
||||
}
|
||||
SWIGINTERN int
|
||||
SwigPyBuiltin_ssizessizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) {
|
||||
PyObject *tuple, *resultobj;
|
||||
int result;
|
||||
tuple = PyTuple_New(d ? 3 : 2);
|
||||
assert(tuple);
|
||||
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
|
||||
PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c));
|
||||
if (d) {
|
||||
PyTuple_SET_ITEM(tuple, 2, d);
|
||||
Py_INCREF(d);
|
||||
}
|
||||
resultobj = wrapper(a, tuple);
|
||||
result = resultobj ? 0 : -1;
|
||||
Py_DECREF(tuple);
|
||||
Py_XDECREF(resultobj);
|
||||
return result;
|
||||
}
|
||||
|
||||
#define SWIGPY_SSIZEARGFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN PyObject * \
|
||||
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) { \
|
||||
return SwigPyBuiltin_funpack_ssizeargfunc_closure(wrapper, a, b); \
|
||||
}
|
||||
SWIGINTERN PyObject *
|
||||
SwigPyBuiltin_funpack_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
|
||||
PyObject *tuple, *result;
|
||||
tuple = PyTuple_New(1);
|
||||
assert(tuple);
|
||||
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
|
||||
result = wrapper(a, tuple);
|
||||
Py_DECREF(tuple);
|
||||
return result;
|
||||
}
|
||||
|
||||
#define SWIGPY_FUNPACK_SSIZEARGFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN PyObject * \
|
||||
wrapper##_ssizeargfunc_closure(PyObject *a, Py_ssize_t b) { \
|
||||
return SwigPyBuiltin_ssizeargfunc_closure(wrapper, a, b); \
|
||||
}
|
||||
SWIGINTERN PyObject *
|
||||
SwigPyBuiltin_ssizeargfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b) {
|
||||
PyObject *arg, *result;
|
||||
arg = _PyLong_FromSsize_t(b);
|
||||
result = wrapper(a, arg);
|
||||
Py_DECREF(arg);
|
||||
return result;
|
||||
}
|
||||
|
||||
#define SWIGPY_SSIZEOBJARGPROC_CLOSURE(wrapper) \
|
||||
SWIGINTERN int \
|
||||
wrapper##_ssizeobjargproc_closure(PyObject *a, Py_ssize_t b, PyObject *c) { \
|
||||
return SwigPyBuiltin_ssizeobjargproc_closure(wrapper, a, b, c); \
|
||||
}
|
||||
SWIGINTERN int
|
||||
SwigPyBuiltin_ssizeobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, Py_ssize_t b, PyObject *c) {
|
||||
PyObject *tuple, *resultobj;
|
||||
int result;
|
||||
tuple = PyTuple_New(2);
|
||||
assert(tuple);
|
||||
PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b));
|
||||
PyTuple_SET_ITEM(tuple, 1, c);
|
||||
Py_XINCREF(c);
|
||||
resultobj = wrapper(a, tuple);
|
||||
result = resultobj ? 0 : -1;
|
||||
Py_XDECREF(resultobj);
|
||||
Py_DECREF(tuple);
|
||||
return result;
|
||||
}
|
||||
|
||||
#define SWIGPY_OBJOBJARGPROC_CLOSURE(wrapper) \
|
||||
SWIGINTERN int \
|
||||
wrapper##_objobjargproc_closure(PyObject *a, PyObject *b, PyObject *c) { \
|
||||
return SwigPyBuiltin_objobjargproc_closure(wrapper, a, b, c); \
|
||||
}
|
||||
SWIGINTERN int
|
||||
SwigPyBuiltin_objobjargproc_closure(SwigPyWrapperFunction wrapper, PyObject *a, PyObject *b, PyObject *c) {
|
||||
PyObject *tuple, *resultobj;
|
||||
int result;
|
||||
tuple = PyTuple_New(c ? 2 : 1);
|
||||
assert(tuple);
|
||||
PyTuple_SET_ITEM(tuple, 0, b);
|
||||
Py_XINCREF(b);
|
||||
if (c) {
|
||||
PyTuple_SET_ITEM(tuple, 1, c);
|
||||
Py_XINCREF(c);
|
||||
}
|
||||
resultobj = wrapper(a, tuple);
|
||||
result = resultobj ? 0 : -1;
|
||||
Py_XDECREF(resultobj);
|
||||
Py_DECREF(tuple);
|
||||
return result;
|
||||
}
|
||||
|
||||
#define SWIGPY_REPRFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN PyObject * \
|
||||
wrapper##_reprfunc_closure(PyObject *a) { \
|
||||
return SwigPyBuiltin_reprfunc_closure(wrapper, a); \
|
||||
}
|
||||
SWIGINTERN PyObject *
|
||||
SwigPyBuiltin_reprfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
|
||||
return wrapper(a, NULL);
|
||||
}
|
||||
|
||||
#define SWIGPY_HASHFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN Py_hash_t \
|
||||
wrapper##_hashfunc_closure(PyObject *a) { \
|
||||
return SwigPyBuiltin_hashfunc_closure(wrapper, a); \
|
||||
}
|
||||
SWIGINTERN Py_hash_t
|
||||
SwigPyBuiltin_hashfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
|
||||
PyObject *pyresult;
|
||||
Py_hash_t result;
|
||||
pyresult = wrapper(a, NULL);
|
||||
if (!pyresult)
|
||||
return -1;
|
||||
result = SWIG_PyNumber_AsPyHash(pyresult);
|
||||
Py_DECREF(pyresult);
|
||||
return result;
|
||||
}
|
||||
|
||||
#define SWIGPY_ITERNEXTFUNC_CLOSURE(wrapper) \
|
||||
SWIGINTERN PyObject * \
|
||||
wrapper##_iternextfunc_closure(PyObject *a) { \
|
||||
return SwigPyBuiltin_iternextfunc_closure(wrapper, a);\
|
||||
}
|
||||
SWIGINTERN PyObject *
|
||||
SwigPyBuiltin_iternextfunc_closure(SwigPyWrapperFunction wrapper, PyObject *a) {
|
||||
return wrapper(a, NULL);
|
||||
}
|
||||
|
||||
/* End of callback function macros for use in PyTypeObject */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
//
|
||||
// embed.i
|
||||
// SWIG file embedding the Python interpreter in something else.
|
||||
// This file is based on Python-1.5. It will not work with
|
||||
// earlier versions.
|
||||
// This file is deprecated and no longer actively maintained, but it still
|
||||
// seems to work with Python 2.7. Status with Python 3 is unknown.
|
||||
//
|
||||
// This file makes it possible to extend Python and all of its
|
||||
// built-in functions without having to hack its setup script.
|
||||
|
|
@ -24,13 +24,8 @@ present in your current Python executable (including any special
|
|||
purpose modules you have enabled such as Tkinter). Thus, you
|
||||
may need to provide additional link libraries when compiling.
|
||||
|
||||
This library file only works with Python 1.5. A version
|
||||
compatible with Python 1.4 is available as embed14.i and
|
||||
a Python1.3 version is available as embed13.i. As far as
|
||||
I know, this module is C++ safe.
|
||||
As far as I know, this module is C++ safe.
|
||||
%}
|
||||
#else
|
||||
%echo "embed.i : Using Python 1.5"
|
||||
#endif
|
||||
|
||||
%wrapper %{
|
||||
|
|
@ -51,12 +46,12 @@ extern "C" {
|
|||
#endif
|
||||
#include <config.c>
|
||||
|
||||
#undef _PyImport_Inittab
|
||||
#undef _PyImport_Inittab
|
||||
|
||||
/* Now define our own version of it.
|
||||
Hopefully someone does not have more than 1000 built-in modules */
|
||||
|
||||
struct _inittab SWIG_Import_Inittab[1000];
|
||||
struct _inittab SWIG_Import_Inittab[1000];
|
||||
|
||||
static int swig_num_modules = 0;
|
||||
|
||||
|
|
@ -68,18 +63,18 @@ static void swig_add_module(char *name, void (*initfunc)()) {
|
|||
swig_num_modules++;
|
||||
SWIG_Import_Inittab[swig_num_modules].name = (char *) 0;
|
||||
SWIG_Import_Inittab[swig_num_modules].initfunc = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* Function to add all of Python's build in modules to our interpreter */
|
||||
/* Function to add all of Python's built-in modules to our interpreter */
|
||||
|
||||
static void swig_add_builtin() {
|
||||
int i = 0;
|
||||
while (swig_inittab[i].name) {
|
||||
swig_add_module(swig_inittab[i].name, swig_inittab[i].initfunc);
|
||||
i++;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
#ifdef SWIGMODINIT
|
||||
SWIGMODINIT
|
||||
SWIGMODINIT
|
||||
#endif
|
||||
/* Add SWIG builtin function */
|
||||
swig_add_module(SWIG_name, SWIG_init);
|
||||
|
|
@ -109,7 +104,3 @@ main(int argc, char **argv) {
|
|||
}
|
||||
|
||||
%}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,115 +0,0 @@
|
|||
/* -----------------------------------------------------------------------------
|
||||
* embed15.i
|
||||
*
|
||||
* SWIG file embedding the Python interpreter in something else.
|
||||
* This file is based on Python-1.5. It will not work with
|
||||
* earlier versions.
|
||||
*
|
||||
* This file makes it possible to extend Python and all of its
|
||||
* built-in functions without having to hack its setup script.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
#ifdef AUTODOC
|
||||
%subsection "embed.i"
|
||||
%text %{
|
||||
This module provides support for building a new version of the
|
||||
Python executable. This will be necessary on systems that do
|
||||
not support shared libraries and may be necessary with C++
|
||||
extensions. This file contains everything you need to build
|
||||
a new version of Python from include files and libraries normally
|
||||
installed with the Python language.
|
||||
|
||||
This module will automatically grab all of the Python modules
|
||||
present in your current Python executable (including any special
|
||||
purpose modules you have enabled such as Tkinter). Thus, you
|
||||
may need to provide additional link libraries when compiling.
|
||||
|
||||
This library file only works with Python 1.5. A version
|
||||
compatible with Python 1.4 is available as embed14.i and
|
||||
a Python1.3 version is available as embed13.i. As far as
|
||||
I know, this module is C++ safe.
|
||||
%}
|
||||
#else
|
||||
%echo "embed.i : Using Python 1.5"
|
||||
#endif
|
||||
|
||||
%wrapper %{
|
||||
|
||||
#include <Python.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
#endif
|
||||
void SWIG_init(); /* Forward reference */
|
||||
|
||||
#define _PyImport_Inittab swig_inittab
|
||||
|
||||
/* Grab Python's inittab[] structure */
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
#include <config.c>
|
||||
|
||||
#undef _PyImport_Inittab
|
||||
|
||||
/* Now define our own version of it.
|
||||
Hopefully someone does not have more than 1000 built-in modules */
|
||||
|
||||
struct _inittab SWIG_Import_Inittab[1000];
|
||||
|
||||
static int swig_num_modules = 0;
|
||||
|
||||
/* Function for adding modules to Python */
|
||||
|
||||
static void swig_add_module(char *name, void (*initfunc)()) {
|
||||
SWIG_Import_Inittab[swig_num_modules].name = name;
|
||||
SWIG_Import_Inittab[swig_num_modules].initfunc = initfunc;
|
||||
swig_num_modules++;
|
||||
SWIG_Import_Inittab[swig_num_modules].name = (char *) 0;
|
||||
SWIG_Import_Inittab[swig_num_modules].initfunc = 0;
|
||||
}
|
||||
|
||||
/* Function to add all of Python's build in modules to our interpreter */
|
||||
|
||||
static void swig_add_builtin() {
|
||||
int i = 0;
|
||||
while (swig_inittab[i].name) {
|
||||
swig_add_module(swig_inittab[i].name, swig_inittab[i].initfunc);
|
||||
i++;
|
||||
}
|
||||
#ifdef SWIGMODINIT
|
||||
SWIGMODINIT
|
||||
#endif
|
||||
/* Add SWIG builtin function */
|
||||
swig_add_module(SWIG_name, SWIG_init);
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int Py_Main(int, char **);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
extern struct _inittab *PyImport_Inittab;
|
||||
|
||||
int
|
||||
main(int argc, char **argv) {
|
||||
swig_add_builtin();
|
||||
PyImport_Inittab = SWIG_Import_Inittab;
|
||||
return Py_Main(argc,argv);
|
||||
}
|
||||
|
||||
%}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -4,7 +4,7 @@
|
|||
the complex Constructor method, and the Real and Imag complex
|
||||
accessor methods.
|
||||
|
||||
See the std_complex.i and ccomplex.i for concret examples.
|
||||
See the std_complex.i and ccomplex.i for concrete examples.
|
||||
*/
|
||||
|
||||
/* the common from converter */
|
||||
|
|
|
|||
|
|
@ -206,7 +206,7 @@ namespace swig {
|
|||
if (step == 0) {
|
||||
throw std::invalid_argument("slice step cannot be zero");
|
||||
} else if (step > 0) {
|
||||
// Required range: 0 <= i < size, 0 <= j < size
|
||||
// Required range: 0 <= i < size, 0 <= j < size, i <= j
|
||||
if (i < 0) {
|
||||
ii = 0;
|
||||
} else if (i < (Difference)size) {
|
||||
|
|
@ -214,13 +214,15 @@ namespace swig {
|
|||
} else if (insert && (i >= (Difference)size)) {
|
||||
ii = (Difference)size;
|
||||
}
|
||||
if ( j < 0 ) {
|
||||
if (j < 0) {
|
||||
jj = 0;
|
||||
} else {
|
||||
jj = (j < (Difference)size) ? j : (Difference)size;
|
||||
}
|
||||
if (jj < ii)
|
||||
jj = ii;
|
||||
} else {
|
||||
// Required range: -1 <= i < size-1, -1 <= j < size-1
|
||||
// Required range: -1 <= i < size-1, -1 <= j < size-1, i >= j
|
||||
if (i < -1) {
|
||||
ii = -1;
|
||||
} else if (i < (Difference) size) {
|
||||
|
|
@ -233,6 +235,8 @@ namespace swig {
|
|||
} else {
|
||||
jj = (j < (Difference)size ) ? j : (Difference)(size-1);
|
||||
}
|
||||
if (ii < jj)
|
||||
ii = jj;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -252,6 +256,19 @@ namespace swig {
|
|||
return pos;
|
||||
}
|
||||
|
||||
template <class Sequence>
|
||||
inline void
|
||||
erase(Sequence* seq, const typename Sequence::iterator& position) {
|
||||
seq->erase(position);
|
||||
}
|
||||
|
||||
template <class Sequence>
|
||||
struct traits_reserve {
|
||||
static void reserve(Sequence & /*seq*/, typename Sequence::size_type /*n*/) {
|
||||
// This should be specialized for types that support reserve
|
||||
}
|
||||
};
|
||||
|
||||
template <class Sequence, class Difference>
|
||||
inline Sequence*
|
||||
getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) {
|
||||
|
|
@ -269,6 +286,7 @@ namespace swig {
|
|||
return new Sequence(sb, se);
|
||||
} else {
|
||||
Sequence *sequence = new Sequence();
|
||||
swig::traits_reserve<Sequence>::reserve(*sequence, (jj - ii + step - 1) / step);
|
||||
typename Sequence::const_iterator it = sb;
|
||||
while (it!=se) {
|
||||
sequence->push_back(*it);
|
||||
|
|
@ -279,17 +297,16 @@ namespace swig {
|
|||
}
|
||||
} else {
|
||||
Sequence *sequence = new Sequence();
|
||||
if (ii > jj) {
|
||||
typename Sequence::const_reverse_iterator sb = self->rbegin();
|
||||
typename Sequence::const_reverse_iterator se = self->rbegin();
|
||||
std::advance(sb,size-ii-1);
|
||||
std::advance(se,size-jj-1);
|
||||
typename Sequence::const_reverse_iterator it = sb;
|
||||
while (it!=se) {
|
||||
sequence->push_back(*it);
|
||||
for (Py_ssize_t c=0; c<-step && it!=se; ++c)
|
||||
it++;
|
||||
}
|
||||
swig::traits_reserve<Sequence>::reserve(*sequence, (ii - jj - step - 1) / -step);
|
||||
typename Sequence::const_reverse_iterator sb = self->rbegin();
|
||||
typename Sequence::const_reverse_iterator se = self->rbegin();
|
||||
std::advance(sb,size-ii-1);
|
||||
std::advance(se,size-jj-1);
|
||||
typename Sequence::const_reverse_iterator it = sb;
|
||||
while (it!=se) {
|
||||
sequence->push_back(*it);
|
||||
for (Py_ssize_t c=0; c<-step && it!=se; ++c)
|
||||
it++;
|
||||
}
|
||||
return sequence;
|
||||
}
|
||||
|
|
@ -303,12 +320,11 @@ namespace swig {
|
|||
Difference jj = 0;
|
||||
swig::slice_adjust(i, j, step, size, ii, jj, true);
|
||||
if (step > 0) {
|
||||
if (jj < ii)
|
||||
jj = ii;
|
||||
if (step == 1) {
|
||||
size_t ssize = jj - ii;
|
||||
if (ssize <= is.size()) {
|
||||
// expanding/staying the same size
|
||||
swig::traits_reserve<Sequence>::reserve(*self, self->size() - ssize + is.size());
|
||||
typename Sequence::iterator sb = self->begin();
|
||||
typename InputSeq::const_iterator isit = is.begin();
|
||||
std::advance(sb,ii);
|
||||
|
|
@ -342,8 +358,6 @@ namespace swig {
|
|||
}
|
||||
}
|
||||
} else {
|
||||
if (jj > ii)
|
||||
jj = ii;
|
||||
size_t replacecount = (ii - jj - step - 1) / -step;
|
||||
if (is.size() != replacecount) {
|
||||
char msg[1024];
|
||||
|
|
@ -369,37 +383,33 @@ namespace swig {
|
|||
Difference jj = 0;
|
||||
swig::slice_adjust(i, j, step, size, ii, jj, true);
|
||||
if (step > 0) {
|
||||
if (jj > ii) {
|
||||
typename Sequence::iterator sb = self->begin();
|
||||
std::advance(sb,ii);
|
||||
if (step == 1) {
|
||||
typename Sequence::iterator se = self->begin();
|
||||
std::advance(se,jj);
|
||||
self->erase(sb,se);
|
||||
} else {
|
||||
typename Sequence::iterator it = sb;
|
||||
size_t delcount = (jj - ii + step - 1) / step;
|
||||
while (delcount) {
|
||||
it = self->erase(it);
|
||||
for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
|
||||
it++;
|
||||
delcount--;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (ii > jj) {
|
||||
typename Sequence::reverse_iterator sb = self->rbegin();
|
||||
std::advance(sb,size-ii-1);
|
||||
typename Sequence::reverse_iterator it = sb;
|
||||
size_t delcount = (ii - jj - step - 1) / -step;
|
||||
typename Sequence::iterator sb = self->begin();
|
||||
std::advance(sb,ii);
|
||||
if (step == 1) {
|
||||
typename Sequence::iterator se = self->begin();
|
||||
std::advance(se,jj);
|
||||
self->erase(sb,se);
|
||||
} else {
|
||||
typename Sequence::iterator it = sb;
|
||||
size_t delcount = (jj - ii + step - 1) / step;
|
||||
while (delcount) {
|
||||
it = typename Sequence::reverse_iterator(self->erase((++it).base()));
|
||||
for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
|
||||
it = self->erase(it);
|
||||
for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
|
||||
it++;
|
||||
delcount--;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
typename Sequence::reverse_iterator sb = self->rbegin();
|
||||
std::advance(sb,size-ii-1);
|
||||
typename Sequence::reverse_iterator it = sb;
|
||||
size_t delcount = (ii - jj - step - 1) / -step;
|
||||
while (delcount) {
|
||||
it = typename Sequence::reverse_iterator(self->erase((++it).base()));
|
||||
for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
|
||||
it++;
|
||||
delcount--;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -415,7 +425,7 @@ namespace swig
|
|||
template <class T>
|
||||
struct SwigPySequence_Ref
|
||||
{
|
||||
SwigPySequence_Ref(PyObject* seq, int index)
|
||||
SwigPySequence_Ref(PyObject* seq, Py_ssize_t index)
|
||||
: _seq(seq), _index(index)
|
||||
{
|
||||
}
|
||||
|
|
@ -427,7 +437,7 @@ namespace swig
|
|||
return swig::as<T>(item, true);
|
||||
} catch (std::exception& e) {
|
||||
char msg[1024];
|
||||
sprintf(msg, "in sequence element %d ", _index);
|
||||
sprintf(msg, "in sequence element %d ", (int)_index);
|
||||
if (!PyErr_Occurred()) {
|
||||
::%type_error(swig::type_name<T>());
|
||||
}
|
||||
|
|
@ -445,7 +455,7 @@ namespace swig
|
|||
|
||||
private:
|
||||
PyObject* _seq;
|
||||
int _index;
|
||||
Py_ssize_t _index;
|
||||
};
|
||||
|
||||
template <class T>
|
||||
|
|
@ -466,13 +476,13 @@ namespace swig
|
|||
typedef Reference reference;
|
||||
typedef T value_type;
|
||||
typedef T* pointer;
|
||||
typedef int difference_type;
|
||||
typedef Py_ssize_t difference_type;
|
||||
|
||||
SwigPySequence_InputIterator()
|
||||
{
|
||||
}
|
||||
|
||||
SwigPySequence_InputIterator(PyObject* seq, int index)
|
||||
SwigPySequence_InputIterator(PyObject* seq, Py_ssize_t index)
|
||||
: _seq(seq), _index(index)
|
||||
{
|
||||
}
|
||||
|
|
@ -552,6 +562,7 @@ namespace swig
|
|||
difference_type _index;
|
||||
};
|
||||
|
||||
// STL container wrapper around a Python sequence
|
||||
template <class T>
|
||||
struct SwigPySequence_Cont
|
||||
{
|
||||
|
|
@ -559,8 +570,8 @@ namespace swig
|
|||
typedef const SwigPySequence_Ref<T> const_reference;
|
||||
typedef T value_type;
|
||||
typedef T* pointer;
|
||||
typedef int difference_type;
|
||||
typedef int size_type;
|
||||
typedef Py_ssize_t difference_type;
|
||||
typedef size_t size_type;
|
||||
typedef const pointer const_pointer;
|
||||
typedef SwigPySequence_InputIterator<T, reference> iterator;
|
||||
typedef SwigPySequence_InputIterator<T, const_reference> const_iterator;
|
||||
|
|
@ -621,13 +632,13 @@ namespace swig
|
|||
|
||||
bool check(bool set_err = true) const
|
||||
{
|
||||
int s = size();
|
||||
for (int i = 0; i < s; ++i) {
|
||||
Py_ssize_t s = size();
|
||||
for (Py_ssize_t i = 0; i < s; ++i) {
|
||||
swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i);
|
||||
if (!swig::check<value_type>(item)) {
|
||||
if (set_err) {
|
||||
char msg[1024];
|
||||
sprintf(msg, "in sequence element %d", i);
|
||||
sprintf(msg, "in sequence element %d", (int)i);
|
||||
SWIG_Error(SWIG_RuntimeError, msg);
|
||||
}
|
||||
return false;
|
||||
|
|
@ -748,7 +759,6 @@ namespace swig
|
|||
return self->size();
|
||||
}
|
||||
}
|
||||
|
||||
%enddef
|
||||
|
||||
|
||||
|
|
@ -756,7 +766,7 @@ namespace swig
|
|||
%define %swig_sequence_methods_common(Sequence...)
|
||||
%swig_sequence_iterator(%arg(Sequence))
|
||||
%swig_container_methods(%arg(Sequence))
|
||||
|
||||
|
||||
%fragment("SwigPySequence_Base");
|
||||
|
||||
#if defined(SWIGPYTHON_BUILTIN)
|
||||
|
|
@ -769,14 +779,6 @@ namespace swig
|
|||
#endif // SWIGPYTHON_BUILTIN
|
||||
|
||||
%extend {
|
||||
value_type pop() throw (std::out_of_range) {
|
||||
if (self->size() == 0)
|
||||
throw std::out_of_range("pop from empty container");
|
||||
Sequence::value_type x = self->back();
|
||||
self->pop_back();
|
||||
return x;
|
||||
}
|
||||
|
||||
/* typemap for slice object support */
|
||||
%typemap(in) PySliceObject* {
|
||||
if (!PySlice_Check($input)) {
|
||||
|
|
@ -794,7 +796,11 @@ namespace swig
|
|||
return swig::getslice(self, i, j, 1);
|
||||
}
|
||||
|
||||
void __setslice__(difference_type i, difference_type j, const Sequence& v = Sequence()) throw (std::out_of_range, std::invalid_argument) {
|
||||
void __setslice__(difference_type i, difference_type j) throw (std::out_of_range, std::invalid_argument) {
|
||||
swig::setslice(self, i, j, 1, Sequence());
|
||||
}
|
||||
|
||||
void __setslice__(difference_type i, difference_type j, const Sequence& v) throw (std::out_of_range, std::invalid_argument) {
|
||||
swig::setslice(self, i, j, 1, v);
|
||||
}
|
||||
|
||||
|
|
@ -803,11 +809,10 @@ namespace swig
|
|||
}
|
||||
#endif
|
||||
|
||||
void __delitem__(difference_type i) throw (std::out_of_range) {
|
||||
self->erase(swig::getpos(self,i));
|
||||
void __delitem__(difference_type i) throw (std::out_of_range, std::invalid_argument) {
|
||||
swig::erase(self, swig::getpos(self, i));
|
||||
}
|
||||
|
||||
|
||||
/* Overloaded methods for Python 3 compatibility
|
||||
* (Also useful in Python 2.x)
|
||||
*/
|
||||
|
|
@ -858,12 +863,11 @@ namespace swig
|
|||
Sequence::difference_type jd = j;
|
||||
swig::delslice(self, id, jd, step);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
%enddef
|
||||
|
||||
%define %swig_sequence_methods(Sequence...)
|
||||
%define %swig_sequence_methods_non_resizable(Sequence...)
|
||||
%swig_sequence_methods_common(%arg(Sequence))
|
||||
%extend {
|
||||
const value_type& __getitem__(difference_type i) const throw (std::out_of_range) {
|
||||
|
|
@ -876,19 +880,32 @@ namespace swig
|
|||
|
||||
#if defined(SWIGPYTHON_BUILTIN)
|
||||
// This will be called through the mp_ass_subscript slot to delete an entry.
|
||||
void __setitem__(difference_type i) throw (std::out_of_range) {
|
||||
self->erase(swig::getpos(self,i));
|
||||
void __setitem__(difference_type i) throw (std::out_of_range, std::invalid_argument) {
|
||||
swig::erase(self, swig::getpos(self, i));
|
||||
}
|
||||
#endif
|
||||
|
||||
}
|
||||
%enddef
|
||||
|
||||
%define %swig_sequence_methods(Sequence...)
|
||||
%swig_sequence_methods_non_resizable(%arg(Sequence))
|
||||
%extend {
|
||||
value_type pop() throw (std::out_of_range) {
|
||||
if (self->size() == 0)
|
||||
throw std::out_of_range("pop from empty container");
|
||||
Sequence::value_type x = self->back();
|
||||
self->pop_back();
|
||||
return x;
|
||||
}
|
||||
|
||||
void append(const value_type& x) {
|
||||
self->push_back(x);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
%enddef
|
||||
|
||||
%define %swig_sequence_methods_val(Sequence...)
|
||||
%define %swig_sequence_methods_non_resizable_val(Sequence...)
|
||||
%swig_sequence_methods_common(%arg(Sequence))
|
||||
%extend {
|
||||
value_type __getitem__(difference_type i) throw (std::out_of_range) {
|
||||
|
|
@ -901,16 +918,28 @@ namespace swig
|
|||
|
||||
#if defined(SWIGPYTHON_BUILTIN)
|
||||
// This will be called through the mp_ass_subscript slot to delete an entry.
|
||||
void __setitem__(difference_type i) throw (std::out_of_range) {
|
||||
self->erase(swig::getpos(self,i));
|
||||
void __setitem__(difference_type i) throw (std::out_of_range, std::invalid_argument) {
|
||||
swig::erase(self, swig::getpos(self, i));
|
||||
}
|
||||
#endif
|
||||
}
|
||||
%enddef
|
||||
|
||||
%define %swig_sequence_methods_val(Sequence...)
|
||||
%swig_sequence_methods_non_resizable_val(%arg(Sequence))
|
||||
%extend {
|
||||
value_type pop() throw (std::out_of_range) {
|
||||
if (self->size() == 0)
|
||||
throw std::out_of_range("pop from empty container");
|
||||
Sequence::value_type x = self->back();
|
||||
self->pop_back();
|
||||
return x;
|
||||
}
|
||||
|
||||
void append(value_type x) {
|
||||
self->push_back(x);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
%enddef
|
||||
|
||||
|
||||
|
|
@ -943,8 +972,8 @@ namespace swig {
|
|||
static int asptr(PyObject *obj, sequence **seq) {
|
||||
if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
|
||||
sequence *p;
|
||||
if (::SWIG_ConvertPtr(obj,(void**)&p,
|
||||
swig::type_info<sequence>(),0) == SWIG_OK) {
|
||||
swig_type_info *descriptor = swig::type_info<sequence>();
|
||||
if (descriptor && SWIG_IsOK(::SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) {
|
||||
if (seq) *seq = p;
|
||||
return SWIG_OLDOBJ;
|
||||
}
|
||||
|
|
@ -983,15 +1012,14 @@ namespace swig {
|
|||
%#ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
|
||||
swig_type_info *desc = swig::type_info<sequence>();
|
||||
if (desc && desc->clientdata) {
|
||||
return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
|
||||
return SWIG_InternalNewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
|
||||
}
|
||||
%#endif
|
||||
size_type size = seq.size();
|
||||
if (size <= (size_type)INT_MAX) {
|
||||
PyObject *obj = PyTuple_New((int)size);
|
||||
int i = 0;
|
||||
for (const_iterator it = seq.begin();
|
||||
it != seq.end(); ++it, ++i) {
|
||||
PyObject *obj = PyTuple_New((Py_ssize_t)size);
|
||||
Py_ssize_t i = 0;
|
||||
for (const_iterator it = seq.begin(); it != seq.end(); ++it, ++i) {
|
||||
PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
|
||||
}
|
||||
return obj;
|
||||
|
|
|
|||
|
|
@ -97,10 +97,6 @@ PyString_FromFormat(const char *fmt, ...) {
|
|||
}
|
||||
#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
|
||||
|
|
@ -215,4 +211,5 @@ typedef destructor freefunc;
|
|||
#if PY_VERSION_HEX < 0x03020000
|
||||
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
|
||||
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
|
||||
#define Py_hash_t long
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -145,7 +145,6 @@ swig_varlink_type(void) {
|
|||
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
|
||||
|
|
@ -183,10 +182,19 @@ swig_varlink_type(void) {
|
|||
0, /* tp_del */
|
||||
#endif
|
||||
#if PY_VERSION_HEX >= 0x02060000
|
||||
0, /* tp_version */
|
||||
0, /* tp_version_tag */
|
||||
#endif
|
||||
#if PY_VERSION_HEX >= 0x03040000
|
||||
0, /* tp_finalize */
|
||||
#endif
|
||||
#ifdef COUNT_ALLOCS
|
||||
0,0,0,0 /* tp_alloc -> tp_next */
|
||||
0, /* tp_allocs */
|
||||
0, /* tp_frees */
|
||||
0, /* tp_maxalloc */
|
||||
#if PY_VERSION_HEX >= 0x02050000
|
||||
0, /* tp_prev */
|
||||
#endif
|
||||
0 /* tp_next */
|
||||
#endif
|
||||
};
|
||||
varlink_type = tmp;
|
||||
|
|
@ -366,13 +374,13 @@ SWIG_init(void) {
|
|||
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;
|
||||
PyTypeObject *swigpyobject;
|
||||
SwigPyClientData *cd;
|
||||
PyObject *public_interface, *public_symbol;
|
||||
PyObject *this_descr;
|
||||
|
|
@ -387,14 +395,9 @@ SWIG_init(void) {
|
|||
(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);
|
||||
/* Metaclass is used to implement static member variables */
|
||||
metatype = SwigPyObjectType();
|
||||
assert(metatype);
|
||||
Py_DECREF(metatype_args);
|
||||
metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
|
||||
assert(PyType_Ready(metatype) >= 0);
|
||||
#endif
|
||||
|
||||
/* Fix SwigMethods to carry the callback ptrs when needed */
|
||||
|
|
@ -412,13 +415,15 @@ SWIG_init(void) {
|
|||
SWIG_InitializeModule(0);
|
||||
|
||||
#ifdef SWIGPYTHON_BUILTIN
|
||||
swigpyobject = SwigPyObject_TypeOnce();
|
||||
|
||||
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) {
|
||||
SwigPyObject_clientdata.pytype = swigpyobject;
|
||||
} else if (swigpyobject->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;
|
||||
|
|
|
|||
|
|
@ -18,31 +18,35 @@
|
|||
where <slot> is the name of a field in a PyTypeObject, PyNumberMethods,
|
||||
PyMappingMethods, PySequenceMethods, or PyBufferProcs. For example:
|
||||
|
||||
%{
|
||||
|
||||
static long myHashFunc (PyObject *pyobj) {
|
||||
MyClass *cobj;
|
||||
// Convert pyobj to cobj
|
||||
return (cobj->field1 * (cobj->field2 << 7));
|
||||
}
|
||||
|
||||
%}
|
||||
|
||||
%feature("python:tp_hash") MyClass "myHashFunc";
|
||||
|
||||
class MyClass {
|
||||
public:
|
||||
...
|
||||
};
|
||||
|
||||
%{
|
||||
// Note: Py_hash_t was introduced in Python 3.2
|
||||
static Py_hash_t myHashFunc(PyObject *pyobj) {
|
||||
MyClass *cobj;
|
||||
// Convert pyobj to cobj
|
||||
return (cobj->field1 * (cobj->field2 << 7));
|
||||
}
|
||||
%}
|
||||
|
||||
NOTE: It is the responsibility of the programmer (that's you) to ensure
|
||||
that a statically defined slot function has the correct signature.
|
||||
|
||||
If, instead, you want to dispatch to an instance method, you can
|
||||
use %feature("python:slot"). For example:
|
||||
|
||||
%feature("python:slot", "tp_hash", functype="hashfunc") MyClass::myHashFunc;
|
||||
|
||||
class MyClass {
|
||||
public:
|
||||
long myHashFunc () const;
|
||||
Py_hash_t myHashFunc () const;
|
||||
...
|
||||
};
|
||||
|
||||
%feature("python:slot", "tp_hash", functype="hashfunc") MyClass::myHashFunc;
|
||||
|
||||
NOTE: Some python slots use a method signature which does not
|
||||
match the signature of SWIG-wrapped methods. For those slots,
|
||||
|
|
@ -58,20 +62,21 @@
|
|||
operator overloads for comparison (operator==, operator<, etc.), they
|
||||
will be called from the generated rich compare function. If you
|
||||
want to explicitly choose a method to handle a certain comparison
|
||||
operation, you may use %feature("python:slot") like this:
|
||||
operation, you may use a different feature, %feature("python:compare")
|
||||
like this:
|
||||
|
||||
%feature("python:compare", "Py_LT") MyClass::lessThan;
|
||||
|
||||
class MyClass {
|
||||
public:
|
||||
bool lessThan (const MyClass& x) const;
|
||||
bool lessThan(const MyClass& other) const;
|
||||
...
|
||||
};
|
||||
|
||||
%feature("python:slot", "Py_LT") MyClass::lessThan;
|
||||
|
||||
... where "Py_LT" is one of the rich comparison opcodes defined in the
|
||||
python header file object.h.
|
||||
|
||||
If there's no method defined to handle a particular comparsion operation,
|
||||
If there's no method defined to handle a particular comparison operation,
|
||||
the default behavior is to compare pointer values of the wrapped
|
||||
C++ objects.
|
||||
|
||||
|
|
@ -103,7 +108,6 @@
|
|||
%pybinoperator(__neg__, *::operator-(), unaryfunc, nb_negative);
|
||||
%pybinoperator(__neg__, *::operator-() const, unaryfunc, nb_negative);
|
||||
%pybinoperator(__mul__, *::operator*, binaryfunc, nb_multiply);
|
||||
%pybinoperator(__div__, *::operator/, binaryfunc, nb_div);
|
||||
%pybinoperator(__mod__, *::operator%, binaryfunc, nb_remainder);
|
||||
%pybinoperator(__lshift__, *::operator<<, binaryfunc, nb_lshift);
|
||||
%pybinoperator(__rshift__, *::operator>>, binaryfunc, nb_rshift);
|
||||
|
|
@ -117,8 +121,6 @@
|
|||
%pycompare(__eq__, *::operator==, Py_EQ);
|
||||
%pycompare(__ne__, *::operator!=, Py_NE);
|
||||
|
||||
%feature("python:slot", "nb_truediv", functype="binaryfunc") *::operator/;
|
||||
|
||||
/* Special cases */
|
||||
%rename(__invert__) *::operator~;
|
||||
%feature("python:slot", "nb_invert", functype="unaryfunc") *::operator~;
|
||||
|
|
@ -127,6 +129,7 @@
|
|||
|
||||
#if defined(SWIGPYTHON_BUILTIN)
|
||||
%pybinoperator(__nonzero__, *::operator bool, inquiry, nb_nonzero);
|
||||
%pybinoperator(__truediv__, *::operator/ , binaryfunc, nb_divide);
|
||||
#else
|
||||
%feature("shadow") *::operator bool %{
|
||||
def __nonzero__(self):
|
||||
|
|
@ -134,6 +137,13 @@ def __nonzero__(self):
|
|||
__bool__ = __nonzero__
|
||||
%};
|
||||
%rename(__nonzero__) *::operator bool;
|
||||
%feature("shadow") *::operator/ %{
|
||||
def __truediv__(self, *args):
|
||||
return $action(self, *args)
|
||||
__div__ = __truediv__
|
||||
%};
|
||||
%rename(__truediv__) *::operator/;
|
||||
%pythonmaybecall *::operator/;
|
||||
#endif
|
||||
|
||||
/* Ignored operators */
|
||||
|
|
@ -151,11 +161,11 @@ __bool__ = __nonzero__
|
|||
|
||||
They translate the inplace C++ operators (+=, -=, ...) into the
|
||||
corresponding python equivalents(__iadd__,__isub__), etc,
|
||||
disabling the ownership of the input 'self' pointer, and assigning
|
||||
disabling the ownership of the input 'this' pointer, and assigning
|
||||
it to the returning object:
|
||||
|
||||
%feature("del") *::Operator;
|
||||
%feature("new") *::Operator;
|
||||
%feature("del") *::Operator; // disables ownership by generating SWIG_POINTER_DISOWN
|
||||
%feature("new") *::Operator; // claims ownership by generating SWIG_POINTER_OWN
|
||||
|
||||
This makes the most common case safe, ie:
|
||||
|
||||
|
|
@ -174,8 +184,8 @@ __bool__ = __nonzero__
|
|||
that never get deleted (maybe, not sure, it depends). But if that is
|
||||
the case, you could recover the old behaviour using
|
||||
|
||||
%feature("del","") A::operator+=;
|
||||
%feature("new","") A::operator+=;
|
||||
%feature("del","0") A::operator+=;
|
||||
%feature("new","0") A::operator+=;
|
||||
|
||||
which recovers the old behaviour for the class 'A', or if you are
|
||||
100% sure your entire system works fine in the old way, use:
|
||||
|
|
@ -183,6 +193,12 @@ __bool__ = __nonzero__
|
|||
%feature("del","") *::operator+=;
|
||||
%feature("new","") *::operator+=;
|
||||
|
||||
The default behaviour assumes that the 'this' pointer's memory is
|
||||
already owned by the SWIG object; it relinquishes ownership then
|
||||
takes it back. This may not be the case though as the SWIG object
|
||||
might be owned by memory managed elsewhere, eg after calling a
|
||||
function that returns a C++ reference. In such case you will need
|
||||
to use the features above to recover the old behaviour too.
|
||||
*/
|
||||
|
||||
#if defined(SWIGPYTHON_BUILTIN)
|
||||
|
|
@ -194,7 +210,6 @@ __bool__ = __nonzero__
|
|||
%pyinplaceoper(__iadd__ , *::operator +=, binaryfunc, nb_inplace_add);
|
||||
%pyinplaceoper(__isub__ , *::operator -=, binaryfunc, nb_inplace_subtract);
|
||||
%pyinplaceoper(__imul__ , *::operator *=, binaryfunc, nb_inplace_multiply);
|
||||
%pyinplaceoper(__idiv__ , *::operator /=, binaryfunc, nb_inplace_divide);
|
||||
%pyinplaceoper(__imod__ , *::operator %=, binaryfunc, nb_inplace_remainder);
|
||||
%pyinplaceoper(__iand__ , *::operator &=, binaryfunc, nb_inplace_and);
|
||||
%pyinplaceoper(__ior__ , *::operator |=, binaryfunc, nb_inplace_or);
|
||||
|
|
@ -202,6 +217,19 @@ __bool__ = __nonzero__
|
|||
%pyinplaceoper(__ilshift__, *::operator <<=, binaryfunc, nb_inplace_lshift);
|
||||
%pyinplaceoper(__irshift__, *::operator >>=, binaryfunc, nb_inplace_rshift);
|
||||
|
||||
/* Special cases */
|
||||
#if defined(SWIGPYTHON_BUILTIN)
|
||||
%pyinplaceoper(__itruediv__ , *::operator /=, binaryfunc, nb_inplace_divide);
|
||||
#else
|
||||
%delobject *::operator /=;
|
||||
%newobject *::operator /=;
|
||||
%feature("shadow") *::operator /= %{
|
||||
def __itruediv__(self, *args):
|
||||
return $action(self, *args)
|
||||
__idiv__ = __itruediv__
|
||||
%};
|
||||
%rename(__itruediv__) *::operator /=;
|
||||
#endif
|
||||
|
||||
/* Finally, in python we need to mark the binary operations to fail as
|
||||
'maybecall' methods */
|
||||
|
|
@ -216,6 +244,7 @@ __bool__ = __nonzero__
|
|||
%pybinopermaybecall(neg);
|
||||
%pybinopermaybecall(mul);
|
||||
%pybinopermaybecall(div);
|
||||
%pybinopermaybecall(truediv);
|
||||
%pybinopermaybecall(mod);
|
||||
%pybinopermaybecall(lshift);
|
||||
%pybinopermaybecall(rshift);
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ SWIGINTERNINLINE PyObject*
|
|||
/* long */
|
||||
|
||||
%fragment(SWIG_From_frag(long),"header") {
|
||||
%define_as(SWIG_From_dec(long), PyLong_FromLong)
|
||||
%define_as(SWIG_From_dec(long), PyInt_FromLong)
|
||||
}
|
||||
|
||||
%fragment(SWIG_AsVal_frag(long),"header",
|
||||
|
|
@ -75,16 +75,20 @@ SWIGINTERNINLINE PyObject*
|
|||
SWIGINTERN int
|
||||
SWIG_AsVal_dec(long)(PyObject *obj, long* val)
|
||||
{
|
||||
%#if PY_VERSION_HEX < 0x03000000
|
||||
if (PyInt_Check(obj)) {
|
||||
if (val) *val = PyInt_AsLong(obj);
|
||||
return SWIG_OK;
|
||||
} else if (PyLong_Check(obj)) {
|
||||
} else
|
||||
%#endif
|
||||
if (PyLong_Check(obj)) {
|
||||
long v = PyLong_AsLong(obj);
|
||||
if (!PyErr_Occurred()) {
|
||||
if (val) *val = v;
|
||||
return SWIG_OK;
|
||||
} else {
|
||||
PyErr_Clear();
|
||||
return SWIG_OverflowError;
|
||||
}
|
||||
}
|
||||
%#ifdef SWIG_PYTHON_CAST_MODE
|
||||
|
|
@ -119,7 +123,7 @@ SWIGINTERNINLINE PyObject*
|
|||
SWIG_From_dec(unsigned long)(unsigned long value)
|
||||
{
|
||||
return (value > LONG_MAX) ?
|
||||
PyLong_FromUnsignedLong(value) : PyLong_FromLong(%numeric_cast(value,long));
|
||||
PyLong_FromUnsignedLong(value) : PyInt_FromLong(%numeric_cast(value,long));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -146,18 +150,7 @@ SWIG_AsVal_dec(unsigned long)(PyObject *obj, unsigned long *val)
|
|||
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
|
||||
return SWIG_OverflowError;
|
||||
}
|
||||
}
|
||||
%#ifdef SWIG_PYTHON_CAST_MODE
|
||||
|
|
@ -187,20 +180,22 @@ SWIG_AsVal_dec(unsigned long)(PyObject *obj, unsigned long *val)
|
|||
/* long long */
|
||||
|
||||
%fragment(SWIG_From_frag(long long),"header",
|
||||
fragment=SWIG_From_frag(long),
|
||||
fragment="<limits.h>") {
|
||||
fragment="SWIG_LongLongAvailable") {
|
||||
%#ifdef SWIG_LONG_LONG_AVAILABLE
|
||||
SWIGINTERNINLINE PyObject*
|
||||
SWIG_From_dec(long long)(long long value)
|
||||
{
|
||||
return ((value < LONG_MIN) || (value > LONG_MAX)) ?
|
||||
PyLong_FromLongLong(value) : PyLong_FromLong(%numeric_cast(value,long));
|
||||
PyLong_FromLongLong(value) : PyInt_FromLong(%numeric_cast(value,long));
|
||||
}
|
||||
%#endif
|
||||
}
|
||||
|
||||
%fragment(SWIG_AsVal_frag(long long),"header",
|
||||
fragment=SWIG_AsVal_frag(long),
|
||||
fragment="SWIG_CanCastAsInteger",
|
||||
fragment="<limits.h>") {
|
||||
fragment="SWIG_LongLongAvailable") {
|
||||
%#ifdef SWIG_LONG_LONG_AVAILABLE
|
||||
SWIGINTERN int
|
||||
SWIG_AsVal_dec(long long)(PyObject *obj, long long *val)
|
||||
{
|
||||
|
|
@ -212,6 +207,7 @@ SWIG_AsVal_dec(long long)(PyObject *obj, long long *val)
|
|||
return SWIG_OK;
|
||||
} else {
|
||||
PyErr_Clear();
|
||||
res = SWIG_OverflowError;
|
||||
}
|
||||
} else {
|
||||
long v;
|
||||
|
|
@ -227,6 +223,8 @@ SWIG_AsVal_dec(long long)(PyObject *obj, long long *val)
|
|||
const double mant_min = -mant_max;
|
||||
double d;
|
||||
res = SWIG_AsVal(double)(obj,&d);
|
||||
if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, mant_min, mant_max))
|
||||
return SWIG_OverflowError;
|
||||
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
|
||||
if (val) *val = (long long)(d);
|
||||
return SWIG_AddCast(res);
|
||||
|
|
@ -236,25 +234,28 @@ SWIG_AsVal_dec(long long)(PyObject *obj, long long *val)
|
|||
%#endif
|
||||
return res;
|
||||
}
|
||||
%#endif
|
||||
}
|
||||
|
||||
/* unsigned long long */
|
||||
|
||||
%fragment(SWIG_From_frag(unsigned long long),"header",
|
||||
fragment=SWIG_From_frag(long long),
|
||||
fragment="<limits.h>") {
|
||||
fragment="SWIG_LongLongAvailable") {
|
||||
%#ifdef SWIG_LONG_LONG_AVAILABLE
|
||||
SWIGINTERNINLINE PyObject*
|
||||
SWIG_From_dec(unsigned long long)(unsigned long long value)
|
||||
{
|
||||
return (value > LONG_MAX) ?
|
||||
PyLong_FromUnsignedLongLong(value) : PyLong_FromLong(%numeric_cast(value,long));
|
||||
PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(%numeric_cast(value,long));
|
||||
}
|
||||
%#endif
|
||||
}
|
||||
|
||||
%fragment(SWIG_AsVal_frag(unsigned long long),"header",
|
||||
fragment=SWIG_AsVal_frag(unsigned long),
|
||||
fragment="SWIG_CanCastAsInteger",
|
||||
fragment="<limits.h>") {
|
||||
fragment="SWIG_LongLongAvailable") {
|
||||
%#ifdef SWIG_LONG_LONG_AVAILABLE
|
||||
SWIGINTERN int
|
||||
SWIG_AsVal_dec(unsigned long long)(PyObject *obj, unsigned long long *val)
|
||||
{
|
||||
|
|
@ -266,6 +267,7 @@ SWIG_AsVal_dec(unsigned long long)(PyObject *obj, unsigned long long *val)
|
|||
return SWIG_OK;
|
||||
} else {
|
||||
PyErr_Clear();
|
||||
res = SWIG_OverflowError;
|
||||
}
|
||||
} else {
|
||||
unsigned long v;
|
||||
|
|
@ -280,6 +282,8 @@ SWIG_AsVal_dec(unsigned long long)(PyObject *obj, unsigned long long *val)
|
|||
const double mant_max = 1LL << DBL_MANT_DIG;
|
||||
double d;
|
||||
res = SWIG_AsVal(double)(obj,&d);
|
||||
if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
|
||||
return SWIG_OverflowError;
|
||||
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
|
||||
if (val) *val = (unsigned long long)(d);
|
||||
return SWIG_AddCast(res);
|
||||
|
|
@ -289,6 +293,7 @@ SWIG_AsVal_dec(unsigned long long)(PyObject *obj, unsigned long long *val)
|
|||
%#endif
|
||||
return res;
|
||||
}
|
||||
%#endif
|
||||
}
|
||||
|
||||
/* double */
|
||||
|
|
@ -305,9 +310,11 @@ SWIG_AsVal_dec(double)(PyObject *obj, double *val)
|
|||
if (PyFloat_Check(obj)) {
|
||||
if (val) *val = PyFloat_AsDouble(obj);
|
||||
return SWIG_OK;
|
||||
%#if PY_VERSION_HEX < 0x03000000
|
||||
} else if (PyInt_Check(obj)) {
|
||||
if (val) *val = PyInt_AsLong(obj);
|
||||
if (val) *val = (double) PyInt_AsLong(obj);
|
||||
return SWIG_OK;
|
||||
%#endif
|
||||
} else if (PyLong_Check(obj)) {
|
||||
double v = PyLong_AsDouble(obj);
|
||||
if (!PyErr_Occurred()) {
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue