jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Perl added to the Unified typemap library, cleaner way to use the library, and 'normalized' macro names

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@7707 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Marcelo Matus 2005-10-24 14:59:05 +00:00
commit 3c65cea431
112 changed files with 3262 additions and 3375 deletions
Download patch file Download diff file Expand all files Collapse all files

9
Lib/tcl/cstring.i
View file

@ -1,10 +1 @@
%include <typemaps/cstring.swg>
%include <tclstrings.swg>
%typemap_cstrings(%cstring,
char,
SWIG_AsCharPtr,
SWIG_AsCharPtrAndSize,
SWIG_FromCharPtr,
SWIG_FromCharPtrAndSize);

12
Lib/tcl/cwstring.i
View file

@ -1,10 +1,2 @@
%include <typemaps/cstring.swg>
%include <pywstrings.swg>
%typemap_cstrings(%cwstring,
wchar_t,
SWIG_AsWCharPtr,
SWIG_AsWCharPtrAndSize,
SWIG_FromWCharPtr,
SWIG_FromWCharArray);
%include <tclwstrings.swg>
%include <typemaps/cwstring.swg>

35
Lib/tcl/std_string.i
View file

@ -1,37 +1,2 @@
//
// std::string
//
#ifndef SWIG_STD_BASIC_STRING
#define SWIG_STD_STRING
%{
#include <string>
%}
namespace std
{
class string;
}
%include <typemaps/std_string.swg>
%include <tclstrings.swg>
%fragment("Tcl_std_string_asptr","header",fragment="SWIG_AsCharPtrAndSize") {
%tcl_asptr_decl(std::string)
}
%fragment("Tcl_std_string_asval","header",fragment="Tcl_std_string_asptr") {
%tcl_asptr_decl(std::string)
}
%std_string_asptr_frag(std::string, char, SWIG_AsCharPtrAndSize, "Tcl_std_string_asptr")
%std_string_asval_frag(std::string, "Tcl_std_string_asval")
%std_string_from(std::string, SWIG_FromCharPtrAndSize)
%typemap_asptrfromn(SWIG_CCode(STRING), std::string);
#else
%include <std/std_string.i>
#endif

37
Lib/tcl/std_wstring.i
View file

@ -1,37 +1,2 @@
//
// std::wstring
//
#ifndef SWIG_STD_BASIC_STRING
#define SWIG_STD_WSTRING
%{
#include <string>
%}
namespace std
{
class wstring;
}
%include <typemaps/std_string.i>
%include <tclwstrings.swg>
%fragment("Tcl_std_wstring_asptr","header",fragment="SWIG_AsCharPtrAndSize") {
%tcl_asptr_decl(std::wstring)
}
%fragment("Tcl_std_wstring_asval","header",fragment="Tcl_std_wstring_asptr") {
%tcl_asptr_decl(std::wstring)
}
%std_string_asptr_frag(std::wstring, wchar_t, SWIG_AsCharPtrAndSize, "Tcl_std_wstring_asptr")
%std_string_asval_frag(std::wstring, "Tcl_std_wstring_asval")
%std_string_from(std::wstring, SWIG_FromCharPtrAndSize)
%typemap_asptrfromn(SWIG_CCode(UNISTRING), std::wstring);
#else
%include <std/std_string.i>
#endif
%include <typemaps/std_wstring.swg>

2
Lib/tcl/tclerrors.swg
View file

@ -64,6 +64,8 @@ SWIG_Tcl_SetErrorMsg(Tcl_Interp *interp, const char *ctype, const char *mesg)
{
Tcl_ResetResult(interp);
Tcl_SetErrorCode(interp, "SWIG", ctype, NULL);
Tcl_AddErrorInfo(interp, ctype);
Tcl_AddErrorInfo(interp, " ");
Tcl_AddErrorInfo(interp, mesg);
}

2
Lib/tcl/tclinit.swg
View file

@ -50,7 +50,7 @@ SWIG_Tcl_InstallConstants(Tcl_Interp *interp, swig_const_info constants[]) {
obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
break;
case SWIG_TCL_BINARY:
obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype),0);
obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
break;
default:
obj = 0;

33
Lib/tcl/tclmacros.swg
View file

@ -1,26 +1,15 @@
/*
in Tcl we need to pass the interp value, so, we
define decl/call macros as needed.
*/
#define SWIG_ASPTR_DECL_ARGS SWIG_TCL_DECL_ARGS_2
#define SWIG_ASPTR_CALL_ARGS SWIG_TCL_CALL_ARGS_2
#define SWIG_ASVAL_DECL_ARGS SWIG_TCL_DECL_ARGS_2
#define SWIG_ASVAL_CALL_ARGS SWIG_TCL_CALL_ARGS_2
%include <typemaps/swigmacros.swg>
/* aux macros to deal with the interp argument */
#undef SWIG_As_dec
#undef SWIG_AsPtr_dec
#undef SWIG_AsVal_dec
#define SWIG_Tcl_AsVal(Type...) SWIG_Tcl_ ## AsVal ## _ ## #@Type
#define SWIG_AsVal_dec(Type...) SWIG_ ## AsVal_dec ## _ ## #@Type
#define SWIG_Tcl_AsPtr(Type...) SWIG_Tcl_ ## AsPtr ## _ ## #@Type
#define SWIG_AsPtr_dec(Type...) SWIG_ ## AsPtr_dec ## _ ## #@Type
%define %tcl_asval_decl(Type...)
%#define SWIG_AsVal_dec(Type)(obj,val) SWIG_Tcl_AsVal(Type)(Tcl_Interp *interp, obj, val)
%#define SWIG_AsVal(Type)(obj,val) SWIG_Tcl_AsVal(Type)(interp, obj, val)
%enddef
%define %tcl_asptr_decl(Type...)
%#define SWIG_AsPtr_dec(Type)(obj,ptr) SWIG_Tcl_AsPtr(Type)(Tcl_Interp *interp, obj, ptr)
%#define SWIG_AsPtr(Type)(obj,ptr) SWIG_Tcl_AsPtr(Type)(interp, obj, ptr)
%enddef

223
Lib/tcl/tclprimtypes.swg
View file

@ -1,25 +1,3 @@
%include <typemaps/primtypes.swg>
/* Macro for 'signed long' derived types */
%define %type_slong(Type, Frag, Min, Max)
%derived_type_from(long, Type)
%fragment("Tcl_asval_"{Type},"header",fragment=Frag) %{
%tcl_asval_decl(Type)
%}
%signed_derived_type_asval(long, Type, "Tcl_asval_"{Type} , Min, Max)
%enddef
/* Macro for 'unsigned long' derived types */
%define %type_ulong(Type, Frag, Max)
%derived_type_from(unsigned long, Type)
%fragment("Tcl_asval_"{Type},"header",fragment=Frag) %{
%tcl_asval_decl(Type)
%}
%unsigned_derived_type_asval(unsigned long, Type, "Tcl_asval_"{Type}, Max)
%enddef
/* ------------------------------------------------------------
* Primitive Types
* ------------------------------------------------------------ */
@ -27,12 +5,10 @@
/* boolean */
%fragment(SWIG_From_frag(bool),"header") {
SWIG_define(SWIG_From_dec(bool), Tcl_NewBooleanObj)
%define_as(SWIG_From_dec(bool), Tcl_NewBooleanObj)
}
%fragment(SWIG_AsVal_frag(bool),"header") {
%tcl_asval_decl(bool)
SWIGINTERN int
SWIG_AsVal_dec(bool)(Tcl_Obj *obj, bool *val)
{
@ -45,29 +21,6 @@ SWIG_AsVal_dec(bool)(Tcl_Obj *obj, bool *val)
}
}
/* signed/unsigned char */
%type_slong(signed char, "<limits.h>", SCHAR_MIN, SCHAR_MAX)
%type_ulong(unsigned char, "<limits.h>", UCHAR_MAX)
/* short/unsigned short */
%type_slong(short, "<limits.h>", SHRT_MIN, SHRT_MAX)
%type_ulong(unsigned short, "<limits.h>", USHRT_MAX)
/* int/unsigned int */
%type_slong(int, "<limits.h>", INT_MIN, INT_MAX)
%type_ulong(unsigned int, "<limits.h>", UINT_MAX)
/* signed/unsigned wchar_t */
#ifdef __cplusplus
%type_slong(signed wchar_t, "<wchar.h>", WCHAR_MIN, WCHAR_MAX)
%type_ulong(unsigned wchar_t, "<wchar.h>", UWCHAR_MAX)
#endif
/* long */
%fragment(SWIG_From_frag(long),"header",
@ -76,7 +29,7 @@ SWIGINTERNINLINE Tcl_Obj*
SWIG_From_dec(long)(long value)
{
if (((long) INT_MIN <= value) && (value <= (long) INT_MAX)) {
return Tcl_NewIntObj(SWIG_numeric_cast(value,int));
return Tcl_NewIntObj(%numeric_cast(value,int));
} else {
return Tcl_NewLongObj(value);
}
@ -84,8 +37,6 @@ SWIG_From_dec(long)(long value)
}
%fragment(SWIG_AsVal_frag(long),"header") {
%tcl_asval_decl(long)
SWIGINTERN int
SWIG_AsVal_dec(long)(Tcl_Obj *obj, long* val)
{
@ -106,7 +57,7 @@ SWIGINTERNINLINE Tcl_Obj*
SWIG_From_dec(unsigned long)(unsigned long value)
{
if (value < (unsigned long) LONG_MAX) {
return SWIG_From(long)(SWIG_numeric_cast(value, long));
return SWIG_From(long)(%numeric_cast(value, long));
} else {
char temp[256];
snprintf(temp, sizeof(temp),"%lu", value);
@ -116,25 +67,34 @@ SWIG_From_dec(unsigned long)(unsigned long value)
}
%fragment(SWIG_AsVal_frag(unsigned long),"header") {
%tcl_asval_decl(unsigned long)
SWIGINTERN int
SWIG_AsVal_dec(unsigned long)(Tcl_Obj *obj, unsigned long *val) {
int len = 0;
const char *nptr = Tcl_GetStringFromObj(obj, &len);
if (nptr && len > 0) {
char *endptr;
unsigned long v = strtoul(nptr, &endptr,0);
if (errno == ERANGE) {
errno = 0;
return SWIG_OverflowError;
long v;
if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
if (v > 0) {
if (val) *val = (long) v;
return SWIG_OK;
} else {
if (*endptr == '\0') {
if (val) *val = v;
return SWIG_OK;
return SWIG_OverflowError;
}
} else {
int len = 0;
const char *nptr = Tcl_GetStringFromObj(obj, &len);
if (nptr && len > 0) {
char *endptr;
unsigned long v = strtoul(nptr, &endptr,0);
if (errno == ERANGE) {
errno = 0;
return SWIG_OverflowError;
} else {
if (*endptr == '\0') {
if (val) *val = v;
return SWIG_OK;
}
}
}
}
return SWIG_TypeError;
}
}
@ -148,7 +108,7 @@ SWIGINTERNINLINE Tcl_Obj*
SWIG_From_dec(long long)(long long value)
{
if (((long long) LONG_MIN <= value) && (value <= (long long) LONG_MAX)) {
return SWIG_From(long)(SWIG_numeric_cast(value,long));
return SWIG_From(long)(%numeric_cast(value,long));
} else {
char temp[256];
snprintf(temp, sizeof(temp),"%lld", value);
@ -158,23 +118,27 @@ SWIG_From_dec(long long)(long long value)
}
%fragment(SWIG_AsVal_frag(long long),"header") {
%tcl_asval_decl(long long)
SWIGINTERN int
SWIG_AsVal_dec(long long)(Tcl_Obj *obj, long long *val)
{
int len = 0;
const char *nptr = Tcl_GetStringFromObj(obj, &len);
if (nptr && len > 0) {
char *endptr;
long long v = strtoll(nptr, &endptr,0);
if (errno == ERANGE) {
errno = 0;
return SWIG_OverflowError;
} else {
if (*endptr == '\0') {
if (val) *val = v;
return SWIG_OK;
long v;
if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
if (val) *val = v;
return SWIG_OK;
} else {
int len = 0;
const char *nptr = Tcl_GetStringFromObj(obj, &len);
if (nptr && len > 0) {
char *endptr;
long long v = strtoll(nptr, &endptr,0);
if (errno == ERANGE) {
errno = 0;
return SWIG_OverflowError;
} else {
if (*endptr == '\0') {
if (val) *val = v;
return SWIG_OK;
}
}
}
}
@ -191,7 +155,7 @@ SWIGINTERNINLINE Tcl_Obj*
SWIG_From_dec(unsigned long long)(unsigned long long value)
{
if (value < (unsigned long long) LONG_MAX) {
return SWIG_From(long long)(SWIG_numeric_cast(value, long long));
return SWIG_From(long long)(%numeric_cast(value, long long));
} else {
char temp[256];
snprintf(temp, sizeof(temp),"%llu", value);
@ -202,23 +166,31 @@ SWIG_From_dec(unsigned long long)(unsigned long long value)
%fragment(SWIG_AsVal_frag(unsigned long long),"header",
fragment=SWIG_AsVal_frag(unsigned long)) {
%tcl_asval_decl(unsigned long long)
SWIGINTERN int
SWIG_AsVal_dec(unsigned long long)(Tcl_Obj *obj, unsigned long long *val)
{
int len = 0;
const char *nptr = Tcl_GetStringFromObj(obj, &len);
if (nptr && len > 0) {
char *endptr;
unsigned long long v = strtoull(nptr, &endptr,0);
if (errno == ERANGE) {
errno = 0;
return SWIG_OverflowError;
long v;
if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
if (v > 0) {
if (val) *val = (long) v;
return SWIG_OK;
} else {
if (*endptr == '\0') {
if (val) *val = v;
return SWIG_OK;
return SWIG_OverflowError;
}
} else {
int len = 0;
const char *nptr = Tcl_GetStringFromObj(obj, &len);
if (nptr && len > 0) {
char *endptr;
unsigned long long v = strtoull(nptr, &endptr,0);
if (errno == ERANGE) {
errno = 0;
return SWIG_OverflowError;
} else {
if (*endptr == '\0') {
if (val) *val = v;
return SWIG_OK;
}
}
}
}
@ -226,23 +198,13 @@ SWIG_AsVal_dec(unsigned long long)(Tcl_Obj *obj, unsigned long long *val)
}
}
/* float */
%derived_type_from(double, float)
%fragment("Tcl_asval_float","header",fragment="<float.h>") {
%tcl_asval_decl(float)
}
%signed_derived_type_asval(double, float, "Tcl_asval_float", -FLT_MAX, FLT_MAX)
/* double */
%fragment(SWIG_From_frag(double),"header") {
SWIG_define(SWIG_From_dec(double), Tcl_NewDoubleObj)
%define_as(SWIG_From(double), Tcl_NewDoubleObj)
}
%fragment(SWIG_AsVal_frag(double),"header") {
%tcl_asval_decl(double)
SWIGINTERN int
SWIG_AsVal_dec(double)(Tcl_Obj *obj, double *val)
{
@ -255,54 +217,3 @@ SWIG_AsVal_dec(double)(Tcl_Obj *obj, double *val)
}
}
/* char */
%fragment(SWIG_From_frag(char),"header") {
SWIGINTERNINLINE Tcl_Obj*
SWIG_From_dec(char)(char c)
{
return Tcl_NewStringObj(&c,1);
}
}
%fragment(SWIG_AsVal_frag(char),"header",
fragment="SWIG_AsCharArray",
fragment=SWIG_AsVal_frag(signed char)) {
%tcl_asval_decl(char)
SWIGINTERNINLINE int
SWIG_AsVal_dec(char)(Tcl_Obj *obj, char *val)
{
return SWIG_AsCharArray(obj, val, 1) == SWIG_OK ? SWIG_OK : SWIG_TypeError;
}
}
/* wchar_t */
%fragment(SWIG_From_frag(wchar_t),"header") {
SWIGINTERNINLINE Tcl_Obj*
SWIG_From_dec(wchar_t)(wchar_t c)
{
return Tcl_NewUnicodeObj(&c, 1);
}
}
%fragment(SWIG_AsVal_frag(wchar_t),"header",
fragment="SWIG_AsWCharArray",
fragment="<wchar.h>",
fragment=SWIG_AsVal_frag(long)) {
%tcl_asval_decl(wchar_t)
SWIGINTERNINLINE int
SWIG_AsVal_dec(wchar_t)(Tcl_Obj *obj, wchar_t *val)
{
return (SWIG_AsWCharArray(obj, val, 1) == SWIG_OK) ? SWIG_OK : SWIG_TypeError;
}
}
/* ------------------------------------------------------------
* Apply the primitive typemap for all the types with checkcode
* ------------------------------------------------------------ */
%apply_checkctypes(%typemap_primitive)

17
Lib/tcl/tclrun.swg
View file

@ -14,20 +14,20 @@
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Tcl_NewPointerObj(ptr, type, flags)
/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Tcl_ConvertPacked(interp, obj, ptr, sz, ty, flags)
#define SWIG_NewPackedObj(ptr, sz, type, flags) SWIG_Tcl_NewPackedObj(ptr, sz, type, flags)
#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Tcl_ConvertPacked(interp, obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Tcl_NewPackedObj(ptr, sz, type)
/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, flags)
#define SWIG_NewInstanceObj(thisvalue, type, flags) SWIG_Tcl_NewInstanceObj(interp, thisvalue, type, flags)
/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type, flags) SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, flags)
#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, 0)
#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Tcl_NewPointerObj(ptr, type, 0)
/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty, flags) SWIG_Tcl_ConvertPacked(interp,obj, ptr, sz, ty, flags)
#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Tcl_NewPackedObj(ptr, sz, type, 0)
#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Tcl_ConvertPacked(interp,obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Tcl_NewPackedObj(ptr, sz, type)
/* Runtime API */
@ -58,6 +58,8 @@
#define SWIG_ObjectDelete SWIG_Tcl_ObjectDelete
#define SWIG_TCL_DECL_ARGS_2(arg1, arg2) (Tcl_Interp *interp, arg1, arg2)
#define SWIG_TCL_CALL_ARGS_2(arg1, arg2) (interp, arg1, arg2)
/* -----------------------------------------------------------------------------
* pointers/data manipulation
* ----------------------------------------------------------------------------- */
@ -165,7 +167,7 @@ SWIG_Tcl_PointerTypeFromString(char *c) {
/* Convert a packed value value */
SWIGRUNTIME int
SWIG_Tcl_ConvertPacked(Tcl_Interp *interp, Tcl_Obj *obj, void *ptr, int sz, swig_type_info *ty, int flags) {
SWIG_Tcl_ConvertPacked(Tcl_Interp *interp, Tcl_Obj *obj, void *ptr, int sz, swig_type_info *ty) {
swig_cast_info *tc;
const char *c;
@ -211,14 +213,13 @@ SWIG_Tcl_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
}
SWIGRUNTIME Tcl_Obj *
SWIG_Tcl_NewPackedObj(void *ptr, int sz, swig_type_info *type, int flags) {
SWIG_Tcl_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
char result[1024];
char *r = result;
if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
*(r++) = '_';
r = SWIG_PackData(r,ptr,sz);
strcpy(r,type->name);
flags = 0;
return Tcl_NewStringObj(result,-1);
}

7
Lib/tcl/tclstrings.swg
View file

@ -24,13 +24,8 @@ SWIG_AsCharPtrAndSize(Tcl_Obj *obj, char** cptr, size_t* psize, int *alloc)
SWIGINTERNINLINE Tcl_Obj *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
return (size < INT_MAX) ? Tcl_NewStringObj(carray, SWIG_numeric_cast(size,int)) : NULL;
return (size < INT_MAX) ? Tcl_NewStringObj(carray, %numeric_cast(size,int)) : NULL;
}
}
/* ------------------------------------------------------------
* The plain char * handling
* ------------------------------------------------------------ */
%include <typemaps/strings.swg>
%typemap_string(char, Char, SWIG_AsCharPtrAndSize, SWIG_FromCharPtrAndSize, strlen)

2
Lib/tcl/tclswigtype.swg
View file

@ -1,5 +1,3 @@
%include <typemaps/swigtype.swg>
%typemap(out) SWIGTYPE = SWIGTYPE INSTANCE;
%typemap(out) SWIGTYPE * = SWIGTYPE *INSTANCE;
%typemap(out) SWIGTYPE & = SWIGTYPE &INSTANCE;

24
Lib/tcl/tcltypemaps.swg
View file

@ -11,27 +11,21 @@
* Basic definitions
* ----------------------------------------------------------------------------- */
%define_swig_object(Tcl_Obj *)
#define SWIG_Object Tcl_Obj *
#define VOID_Object NULL
#define SWIG_VoidObject() NULL
#define SWIG_SetResultObj(obj) $result = obj
#define SWIG_AppendResultObj(obj) $result = (Tcl_ListObjAppendElement(NULL,$result,obj) == TCL_OK) ? $result : NULL
#define SWIG_SetConstantObj(name, obj) SWIG_Tcl_SetConstantObj(interp, name, obj)
#define SWIG_AppendOutput(result,obj) (Tcl_ListObjAppendElement(NULL,result,obj) == TCL_OK) ? result : NULL
#define SWIG_SetConstant(name, obj) SWIG_Tcl_SetConstantObj(interp, name, obj)
#define SWIG_Raise(obj,type,desc) SWIG_Tcl_SetErrorObj(interp,type,obj)
#define SWIG_DirOutFail(code, msg) /* no directors supported */
/* -----------------------------------------------------------------------------
* All the typemaps
* ----------------------------------------------------------------------------- */
%include <typemaps/exception.swg>
%include <tclswigtype.swg>
%include <typemaps/void.swg>
%include <typemaps/valtypes.swg>
%include <typemaps/ptrtypes.swg>
%include <typemaps/swigobject.swg>
%include <typemaps/inoutlist.swg>
%include <tclprimtypes.swg>
%include <tclstrings.swg>
%include <typemaps/misctypes.swg>
%include <typemaps/enumint.swg>
%include <typemaps/swigtypemaps.swg>
/* fix for instances */
%include <tclswigtype.swg>

59
Lib/tcl/tclwstrings.swg
View file

@ -2,35 +2,64 @@
* utility methods for wchar strings
* ------------------------------------------------------------ */
%fragment("SWIG_AsCharPtrAndSize","header") {
%{
#include <wchar.h>
%}
%fragment("SWIG_AsWCharPtrAndSize","header") {
SWIGINTERN int
SWIG_AsWCharPtrAndSize(Tcl_Obj *obj, wchar_t** cptr, size_t* psize, int *alloc)
{
int len = 0;
wchar_t *cstr = Tcl_GetUnicodeFromObj(obj, &len);
if (cstr) {
if (cptr) *cptr = cstr;
Tcl_UniChar *ustr = Tcl_GetUnicodeFromObj(obj, &len);
if (ustr) {
if (cptr) {
Tcl_Encoding encoding = NULL;
char *src = (char *) ustr;
int srcLen = (len)*sizeof(Tcl_UniChar);
int dstLen = sizeof(wchar_t)*(len + 1);
char *dst = %new_array(dstLen, char);
int flags = 0;
Tcl_EncodingState *statePtr = 0;
int srcRead = 0;
int dstWrote = 0;
int dstChars = 0;
Tcl_UtfToExternal(0, encoding, src, srcLen, flags, statePtr, dst,
dstLen, &srcRead, &dstWrote, &dstChars);
if (alloc) *alloc = SWIG_NEWOBJ;
}
if (psize) *psize = len + 1;
if (alloc) *alloc = SWIG_OLDOBJ;
return SWIG_OK;
}
return SWIG_TypeError;
}
}
%fragment("SWIG_FromWCharPtrAndSize","header",
fragment="<limits.h>") {
%fragment("SWIG_FromWCharPtrAndSize","header") {
SWIGINTERNINLINE Tcl_Obj *
SWIG_FromWCharPtrAndSize(const wchar_t* carray, size_t size)
{
return (size < INT_MAX) ? Tcl_NewUnicodeObj(carray, SWIG_numeric_cast(size,int)) : NULL;
Tcl_Obj *res = NULL;
if (size < INT_MAX) {
Tcl_Encoding encoding = NULL;
char *src = (char *) carray;
int srcLen = (size)*sizeof(wchar_t);
int dstLen = (size)*sizeof(Tcl_UniChar);
char *dst = %new_array(dstLen, char);
int flags = 0;
Tcl_EncodingState *statePtr = 0;
int srcRead = 0;
int dstWrote = 0;
int dstChars = 0;
Tcl_ExternalToUtf(0, encoding, src, srcLen, flags, statePtr, dst,
dstLen, &srcRead, &dstWrote, &dstChars);
res = Tcl_NewUnicodeObj((Tcl_UniChar*)dst, size);
%delete_array(dst);
}
return res;
}
}
/* ------------------------------------------------------------
* The plain char * handling
* ------------------------------------------------------------ */
%include <typemaps/strings.swg>
%typemap_string(wchar_t, WChar, SWIG_AsWCharPtrAndSize, SWIG_FromWCharPtrAndSize, wcslen)