| 1 | // |
| 2 | // Use the macro SWIG_PRESERVE_CARRAY_SIZE if you prefer to preserve |
| 3 | // the size of char arrays, ie |
| 4 | // ------------------------------------------ |
| 5 | // C Side => Python Side |
| 6 | // ------------------------------------------ |
| 7 | // char name[5] = "hola" => 'hola\0' |
| 8 | // |
| 9 | // the default behaviour is |
| 10 | // |
| 11 | // char name[5] = "hola" => 'hola' |
| 12 | // |
| 13 | // |
| 14 | //#define SWIG_PRESERVE_CARRAY_SIZE |
| 15 | |
| 16 | /* ------------------------------------------------------------ |
| 17 | * String typemaps for type Char (char or wchar_t) |
| 18 | * ------------------------------------------------------------ */ |
| 19 | |
| 20 | %define %typemap_pystring(Char, |
| 21 | SWIG_AsCharPtr, |
| 22 | SWIG_AsCharPtrAndSize, |
| 23 | SWIG_FromCharPtr, |
| 24 | SWIG_AsNewCharPtr, |
| 25 | SWIG_AsCharArray, |
| 26 | SWIG_FromCharArray) |
| 27 | /* in */ |
| 28 | |
| 29 | %typemap(in,fragment=#SWIG_AsCharPtr) |
| 30 | Char *, Char const*, Char *const, Char const *const |
| 31 | "if (!SWIG_AsCharPtr($input, (Char**)&$1)) {SWIG_arg_fail($argnum);SWIG_fail;}"; |
| 32 | |
| 33 | %typemap(in,fragment=#SWIG_AsCharPtr) |
| 34 | Char const*&, Char *const&, Char const *const & |
| 35 | { |
| 36 | $*ltype temp; |
| 37 | if (!SWIG_AsCharPtr($input, (Char**)&temp)) {SWIG_arg_fail($argnum);SWIG_fail;} |
| 38 | $1 = &temp; |
| 39 | } |
| 40 | |
| 41 | /* out */ |
| 42 | |
| 43 | %typemap(out,fragment=#SWIG_FromCharPtr) |
| 44 | Char *, Char const*, Char *const, Char const *const |
| 45 | "$result = SWIG_FromCharPtr($1);"; |
| 46 | |
| 47 | %typemap(out,fragment=#SWIG_FromCharPtr) |
| 48 | Char *const &, Char const* &, Char const *const & |
| 49 | "$result = SWIG_FromCharPtr(*$1);"; |
| 50 | |
| 51 | /* varin */ |
| 52 | |
| 53 | %typemap(varin,fragment=#SWIG_AsNewCharPtr) Char * |
| 54 | { |
| 55 | Char *cptr = 0; |
| 56 | if (!SWIG_AsNewCharPtr($input, &cptr)) { |
| 57 | SWIG_append_errmsg("C/C++ variable '$name'"); |
| 58 | return 1; |
| 59 | } |
| 60 | if ($1) SWIG_delete_array($1); |
| 61 | $1 = cptr; |
| 62 | } |
| 63 | |
| 64 | %typemap(varin,fragment=#SWIG_AsNewCharPtr, |
| 65 | warning="451:Setting const Char * variable may leak memory") |
| 66 | const Char * |
| 67 | { |
| 68 | Char *cptr; |
| 69 | if (!SWIG_AsNewCharPtr($input, &cptr)) { |
| 70 | SWIG_append_errmsg("C/C++ variable '$name'"); |
| 71 | return 1; |
| 72 | } |
| 73 | $1 = cptr; |
| 74 | } |
| 75 | |
| 76 | /* varout */ |
| 77 | |
| 78 | %typemap(varout,fragment=#SWIG_FromCharPtr) |
| 79 | Char*, Char const*, Char *const, Char const *const |
| 80 | "$result = SWIG_FromCharPtr($1);"; |
| 81 | |
| 82 | /* constant */ |
| 83 | |
| 84 | %typemap(constcode,fragment=#SWIG_FromCharPtr) |
| 85 | Char *, Char const*, Char * const, Char const* const |
| 86 | "PyDict_SetItemString(d,\"$symname\", SWIG_FromCharPtr($value));"; |
| 87 | |
| 88 | /* directorin */ |
| 89 | |
| 90 | %typemap(directorin,fragment=#SWIG_FromCharPtr) |
| 91 | Char *, Char const*, Char *const, Char const *const, |
| 92 | Char const *&, Char *const &, Char const *const & |
| 93 | "$input = SWIG_FromCharPtr($1_name);"; |
| 94 | |
| 95 | /* directorout */ |
| 96 | |
| 97 | %typemap(directorout,fragment=#SWIG_AsCharPtr) |
| 98 | Char *, Char const*, Char *const, Char const* const |
| 99 | "if (!$input || !SWIG_AsCharPtr($input, (Char**) &$result)) { |
| 100 | Swig::DirectorTypeMismatchException(\"Error converting Python object into Char*\"); |
| 101 | }"; |
| 102 | |
| 103 | %typemap(directorout,fragment=#SWIG_AsCharPtr) |
| 104 | Char const *&, Char *const &, Char const *const & |
| 105 | { |
| 106 | Char* temp; |
| 107 | if (!$input || !SWIG_AsCharPtr($input, &temp)) { |
| 108 | Swig::DirectorTypeMismatchException("Error converting Python object into Char*"); |
| 109 | } |
| 110 | $result = ($1_ltype) &temp; |
| 111 | } |
| 112 | |
| 113 | /* typecheck */ |
| 114 | |
| 115 | %typemap(typecheck,precedence=SWIG_TYPECHECK_STRING, |
| 116 | fragment=#SWIG_AsCharPtr) |
| 117 | Char *, Char const*, Char *const, Char const *const, |
| 118 | Char const*&, Char *const&, Char const *const & |
| 119 | "$1 = SWIG_AsCharPtr($input, (Char **)(0));"; |
| 120 | |
| 121 | /* throws */ |
| 122 | |
| 123 | %typemap(throws,fragment=#SWIG_FromCharPtr) |
| 124 | Char *, Char const*, Char * const, Char const* const |
| 125 | { |
| 126 | PyErr_SetObject(PyExc_RuntimeError, SWIG_FromCharPtr($1)); |
| 127 | SWIG_fail; |
| 128 | } |
| 129 | |
| 130 | |
| 131 | /* ------------------------------------------------------------ |
| 132 | * Unknown size const Character array Char[ANY] handling |
| 133 | * ------------------------------------------------------------ */ |
| 134 | |
| 135 | %apply Char* { Char [] }; |
| 136 | %apply const Char* { const Char [] }; |
| 137 | |
| 138 | %typemap(varin,warning="462:Unable to set variable of type Char []") Char [] |
| 139 | { |
| 140 | PyErr_SetString(PyExc_AttributeError, "C/C++ variable '$name' is read-only"); |
| 141 | return 1; |
| 142 | } |
| 143 | |
| 144 | |
| 145 | /* ------------------------------------------------------------ |
| 146 | * Fix size Character array Char[ANY] handling |
| 147 | * ------------------------------------------------------------ */ |
| 148 | |
| 149 | /* memberin and globalin typemaps */ |
| 150 | |
| 151 | %typemap(memberin) Char [ANY] |
| 152 | { |
| 153 | if ($input) memcpy($1,$input,$1_dim0*sizeof(Char)); |
| 154 | else memset($1,0,$1_dim0*sizeof(Char)); |
| 155 | } |
| 156 | |
| 157 | %typemap(globalin) Char [ANY] |
| 158 | { |
| 159 | if ($input) memcpy($1,$input,$1_dim0*sizeof(Char)); |
| 160 | else memset($1,0,$1_dim0*sizeof(Char)); |
| 161 | } |
| 162 | |
| 163 | /* in */ |
| 164 | |
| 165 | %typemap(in,fragment=#SWIG_AsCharArray) |
| 166 | Char [ANY] (Char temp[$1_dim0]), |
| 167 | const Char [ANY](Char temp[$1_dim0]) |
| 168 | { |
| 169 | if (!SWIG_AsCharArray($input, temp, $1_dim0)) {SWIG_arg_fail($argnum);SWIG_fail;} |
| 170 | $1 = temp; |
| 171 | } |
| 172 | |
| 173 | %typemap(in,fragment=#SWIG_AsCharArray) const Char (&)[ANY] (Char temp[$1_dim0]) |
| 174 | { |
| 175 | if (!SWIG_AsCharArray($input, temp, $1_dim0)) {SWIG_arg_fail($argnum);SWIG_fail;} |
| 176 | $1 = &temp; |
| 177 | } |
| 178 | |
| 179 | %typemap(out,fragment=#SWIG_FromCharArray) |
| 180 | Char [ANY], const Char[ANY] |
| 181 | { |
| 182 | size_t size = $1_dim0; |
| 183 | %#ifndef SWIG_PRESERVE_CARRAY_SIZE |
| 184 | while (size && ($1[size - 1] == '\0')) --size; |
| 185 | %#endif |
| 186 | $result = SWIG_FromCharArray($1, size); |
| 187 | } |
| 188 | |
| 189 | /* varin */ |
| 190 | |
| 191 | %typemap(varin,fragment=#SWIG_AsCharArray) Char [ANY] |
| 192 | { |
| 193 | if (!SWIG_AsCharArray($input, $1, $1_dim0)) { |
| 194 | SWIG_append_errmsg("C/C++ variable '$name'"); |
| 195 | return 1; |
| 196 | } |
| 197 | } |
| 198 | |
| 199 | /* varout */ |
| 200 | |
| 201 | %typemap(varout,fragment=#SWIG_FromCharArray) |
| 202 | Char [ANY], const Char [ANY] |
| 203 | { |
| 204 | size_t size = $1_dim0; |
| 205 | %#ifndef SWIG_PRESERVE_CARRAY_SIZE |
| 206 | while (size && ($1[size - 1] == '\0')) --size; |
| 207 | %#endif |
| 208 | $result = SWIG_FromCharArray($1, size); |
| 209 | } |
| 210 | |
| 211 | /* constants */ |
| 212 | |
| 213 | %typemap(constcode,fragment=#SWIG_FromCharArray) |
| 214 | Char [ANY], const Char [ANY] |
| 215 | { |
| 216 | size_t size = $value_dim0; |
| 217 | %#ifndef SWIG_PRESERVE_CARRAY_SIZE |
| 218 | while (size && ($value[size - 1] == '\0')) --size; |
| 219 | %#endif |
| 220 | PyDict_SetItemString(d,"$symname", SWIG_FromCharArray($value,size)); |
| 221 | } |
| 222 | |
| 223 | /* directorin */ |
| 224 | |
| 225 | %typemap(directorin,fragment=#SWIG_FromCharArray) |
| 226 | Char [ANY], const Char [ANY] |
| 227 | { |
| 228 | size_t size = $1_dim0; |
| 229 | %#ifndef SWIG_PRESERVE_CARRAY_SIZE |
| 230 | while (size && ($1_name[size - 1] == '\0')) --size; |
| 231 | %#endif |
| 232 | $input = SWIG_FromCharArray($1_name, size); |
| 233 | } |
| 234 | |
| 235 | /* directorout */ |
| 236 | |
| 237 | %typemap(directorout,fragment=#SWIG_AsCharArray) |
| 238 | Char [ANY], const Char [ANY] (Char temp[$result_dim0]) |
| 239 | { |
| 240 | if (!$input || !SWIG_AsCharArray($input, temp, $result_dim0)) { |
| 241 | Swig::DirectorTypeMismatchException("Error converting Python object into Char[$result_dim0]"); |
| 242 | } |
| 243 | $result = temp; |
| 244 | } |
| 245 | |
| 246 | /* typecheck */ |
| 247 | |
| 248 | %typemap(typecheck,precedence=SWIG_TYPECHECK_STRING, |
| 249 | fragment=#SWIG_AsCharArray) |
| 250 | Char [ANY], const Char[ANY] |
| 251 | "$1 = SWIG_AsCharArray($input, (Char *)0, $1_dim0);"; |
| 252 | |
| 253 | /* throws */ |
| 254 | |
| 255 | %typemap(throws,fragment=#SWIG_FromCharArray) |
| 256 | Char [ANY], const Char[ANY] |
| 257 | { |
| 258 | size_t size = $1_dim0; |
| 259 | %#ifndef SWIG_PRESERVE_CARRAY_SIZE |
| 260 | while (size && ($1[size - 1] == '\0')) --size; |
| 261 | %#endif |
| 262 | PyErr_SetObject(PyExc_RuntimeError, SWIG_FromCharArray($1, size)); |
| 263 | SWIG_fail; |
| 264 | } |
| 265 | |
| 266 | /* ------------------------------------------------------------------- |
| 267 | * --- Really fix size Char arrays, including '\0'chars at the end --- |
| 268 | * ------------------------------------------------------------------- */ |
| 269 | |
| 270 | %typemap(varout,fragment=#SWIG_FromCharArray) |
| 271 | Char FIXSIZE[ANY], const Char FIXSIZE[ANY] |
| 272 | { |
| 273 | size_t size = $1_dim0; |
| 274 | $result = SWIG_FromCharArray($1, size); |
| 275 | } |
| 276 | |
| 277 | %typemap(out,fragment=#SWIG_FromCharArray) |
| 278 | Char FIXSIZE[ANY], const Char FIXSIZE[ANY] |
| 279 | { |
| 280 | size_t size = $1_dim0; |
| 281 | $result = SWIG_FromCharArray($1, size); |
| 282 | } |
| 283 | |
| 284 | %typemap(constcode,fragment=#SWIG_FromCharArray) |
| 285 | Char FIXSIZE[ANY], const Char FIXSIZE[ANY] |
| 286 | { |
| 287 | size_t size = $value_dim0; |
| 288 | PyDict_SetItemString(d,"$symname", SWIG_FromCharArray($value,size)); |
| 289 | } |
| 290 | |
| 291 | %typemap(directorin,fragment=#SWIG_FromCharArray) |
| 292 | Char FIXSIZE[ANY], const Char FIXSIZE[ANY] |
| 293 | { |
| 294 | size_t size = $1_dim0; |
| 295 | $input = SWIG_FromCharArray($1_name, size); |
| 296 | } |
| 297 | |
| 298 | %typemap(throws,fragment=#SWIG_FromCharArray) |
| 299 | Char FIXSIZE[ANY], const Char FIXSIZE[ANY] |
| 300 | { |
| 301 | size_t size = $1_dim0; |
| 302 | PyErr_SetObject(PyExc_RuntimeError, SWIG_FromCharArray($1, size)); |
| 303 | SWIG_fail; |
| 304 | } |
| 305 | |
| 306 | /* ------------------------------------------------------------ |
| 307 | * --- String & length --- |
| 308 | * ------------------------------------------------------------ */ |
| 309 | |
| 310 | /* Here len doesn't include the '0' terminator */ |
| 311 | %typemap(in, fragment=#SWIG_AsCharPtrAndSize) |
| 312 | (Char *STRING, int LENGTH) (Char *buf, size_t size) |
| 313 | { |
| 314 | SWIG_AsCharPtrAndSize($input, &buf, &size); |
| 315 | if (SWIG_arg_fail($argnum)) SWIG_fail; |
| 316 | $1 = ($1_ltype) buf; |
| 317 | $2 = ($2_ltype) size - 1; |
| 318 | } |
| 319 | |
| 320 | /* Here size includes the '0' terminator */ |
| 321 | %typemap(in,fragment=#SWIG_AsCharPtrAndSize) |
| 322 | (Char *STRING, int SIZE) (Char *buf, size_t size) |
| 323 | { |
| 324 | SWIG_AsCharPtrAndSize($input, &buf, &size); |
| 325 | if (SWIG_arg_fail($argnum)) SWIG_fail; |
| 326 | $1 = ($1_ltype) buf; |
| 327 | $2 = ($2_ltype) size; |
| 328 | } |
| 329 | |
| 330 | %enddef |