Modules/_ctypes/_ctypes_test.c

   1 /*****************************************************************
   2   This file should be kept compatible with Python 2.3, see PEP 291.
   3  *****************************************************************/
   4
   5
   6 #include <Python.h>
   7
   8 /*
   9   Backwards compatibility:
  10   Python2.2 used LONG_LONG instead of PY_LONG_LONG
  11 */
  12 #if defined(HAVE_LONG_LONG) && !defined(PY_LONG_LONG)
  13 #define PY_LONG_LONG LONG_LONG
  14 #endif
  15
  16 #ifdef MS_WIN32
  17 #include <windows.h>
  18 #endif
  19
  20 #if defined(MS_WIN32) || defined(__CYGWIN__)
  21 #define EXPORT(x) __declspec(dllexport) x
  22 #else
  23 #define EXPORT(x) x
  24 #endif
  25
  26 /* some functions handy for testing */
  27
  28 EXPORT(void)testfunc_array(int values[4])
  29 {
  30         printf("testfunc_array %d %d %d %d\n",
  31                values[0],
  32                values[1],
  33                values[2],
  34                values[3]);
  35 }
  36
  37 EXPORT(long double)testfunc_Ddd(double a, double b)
  38 {
  39         long double result = (long double)(a * b);
  40         printf("testfunc_Ddd(%p, %p)\n", &a, &b);
  41         printf("testfunc_Ddd(%g, %g)\n", a, b);
  42         return result;
  43 }
  44
  45 EXPORT(long double)testfunc_DDD(long double a, long double b)
  46 {
  47         long double result = a * b;
  48         printf("testfunc_DDD(%p, %p)\n", &a, &b);
  49         printf("testfunc_DDD(%Lg, %Lg)\n", a, b);
  50         return result;
  51 }
  52
  53 EXPORT(int)testfunc_iii(int a, int b)
  54 {
  55         int result = a * b;
  56         printf("testfunc_iii(%p, %p)\n", &a, &b);
  57         return result;
  58 }
  59
  60 EXPORT(int)myprintf(char *fmt, ...)
  61 {
  62         int result;
  63         va_list argptr;
  64         va_start(argptr, fmt);
  65         result = vprintf(fmt, argptr);
  66         va_end(argptr);
  67         return result;
  68 }
  69
  70 EXPORT(char *)my_strtok(char *token, const char *delim)
  71 {
  72         return strtok(token, delim);
  73 }
  74
  75 EXPORT(char *)my_strchr(const char *s, int c)
  76 {
  77         return strchr(s, c);
  78 }
  79
  80
  81 EXPORT(double) my_sqrt(double a)
  82 {
  83         return sqrt(a);
  84 }
  85
  86 EXPORT(void) my_qsort(void *base, size_t num, size_t width, int(*compare)(const void*, const void*))
  87 {
  88         qsort(base, num, width, compare);
  89 }
  90
  91 EXPORT(int *) _testfunc_ai8(int a[8])
  92 {
  93         return a;
  94 }
  95
  96 EXPORT(void) _testfunc_v(int a, int b, int *presult)
  97 {
  98         *presult = a + b;
  99 }
 100
 101 EXPORT(int) _testfunc_i_bhilfd(signed char b, short h, int i, long l, float f, double d)
 102 {
 103 /*      printf("_testfunc_i_bhilfd got %d %d %d %ld %f %f\n",
 104                b, h, i, l, f, d);
 105 */
 106         return (int)(b + h + i + l + f + d);
 107 }
 108
 109 EXPORT(float) _testfunc_f_bhilfd(signed char b, short h, int i, long l, float f, double d)
 110 {
 111 /*      printf("_testfunc_f_bhilfd got %d %d %d %ld %f %f\n",
 112                b, h, i, l, f, d);
 113 */
 114         return (float)(b + h + i + l + f + d);
 115 }
 116
 117 EXPORT(double) _testfunc_d_bhilfd(signed char b, short h, int i, long l, float f, double d)
 118 {
 119 /*      printf("_testfunc_d_bhilfd got %d %d %d %ld %f %f\n",
 120                b, h, i, l, f, d);
 121 */
 122         return (double)(b + h + i + l + f + d);
 123 }
 124
 125 EXPORT(long double) _testfunc_D_bhilfD(signed char b, short h, int i, long l, float f, long double d)
 126 {
 127 /*      printf("_testfunc_d_bhilfd got %d %d %d %ld %f %f\n",
 128                b, h, i, l, f, d);
 129 */
 130         return (long double)(b + h + i + l + f + d);
 131 }
 132
 133 EXPORT(char *) _testfunc_p_p(void *s)
 134 {
 135         return (char *)s;
 136 }
 137
 138 EXPORT(void *) _testfunc_c_p_p(int *argcp, char **argv)
 139 {
 140         return argv[(*argcp)-1];
 141 }
 142
 143 EXPORT(void *) get_strchr(void)
 144 {
 145         return (void *)strchr;
 146 }
 147
 148 EXPORT(char *) my_strdup(char *src)
 149 {
 150         char *dst = (char *)malloc(strlen(src)+1);
 151         if (!dst)
 152                 return NULL;
 153         strcpy(dst, src);
 154         return dst;
 155 }
 156
 157 EXPORT(void)my_free(void *ptr)
 158 {
 159         free(ptr);
 160 }
 161
 162 #ifdef HAVE_WCHAR_H
 163 EXPORT(wchar_t *) my_wcsdup(wchar_t *src)
 164 {
 165         size_t len = wcslen(src);
 166         wchar_t *ptr = (wchar_t *)malloc((len + 1) * sizeof(wchar_t));
 167         if (ptr == NULL)
 168                 return NULL;
 169         memcpy(ptr, src, (len+1) * sizeof(wchar_t));
 170         return ptr;
 171 }
 172
 173 EXPORT(size_t) my_wcslen(wchar_t *src)
 174 {
 175         return wcslen(src);
 176 }
 177 #endif
 178
 179 #ifndef MS_WIN32
 180 # ifndef __stdcall
 181 #  define __stdcall /* */
 182 # endif
 183 #endif
 184
 185 typedef struct {
 186         int (*c)(int, int);
 187         int (__stdcall *s)(int, int);
 188 } FUNCS;
 189
 190 EXPORT(int) _testfunc_callfuncp(FUNCS *fp)
 191 {
 192         fp->c(1, 2);
 193         fp->s(3, 4);
 194         return 0;
 195 }
 196
 197 EXPORT(int) _testfunc_deref_pointer(int *pi)
 198 {
 199         return *pi;
 200 }
 201
 202 #ifdef MS_WIN32
 203 EXPORT(int) _testfunc_piunk(IUnknown FAR *piunk)
 204 {
 205         piunk->lpVtbl->AddRef(piunk);
 206         return piunk->lpVtbl->Release(piunk);
 207 }
 208 #endif
 209
 210 EXPORT(int) _testfunc_callback_with_pointer(int (*func)(int *))
 211 {
 212         int table[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 213
 214         return (*func)(table);
 215 }
 216
 217 #ifdef HAVE_LONG_LONG
 218 EXPORT(PY_LONG_LONG) _testfunc_q_bhilfdq(signed char b, short h, int i, long l, float f,
 219                                      double d, PY_LONG_LONG q)
 220 {
 221         return (PY_LONG_LONG)(b + h + i + l + f + d + q);
 222 }
 223
 224 EXPORT(PY_LONG_LONG) _testfunc_q_bhilfd(signed char b, short h, int i, long l, float f, double d)
 225 {
 226         return (PY_LONG_LONG)(b + h + i + l + f + d);
 227 }
 228
 229 EXPORT(int) _testfunc_callback_i_if(int value, int (*func)(int))
 230 {
 231         int sum = 0;
 232         while (value != 0) {
 233                 sum += func(value);
 234                 value /= 2;
 235         }
 236         return sum;
 237 }
 238
 239 EXPORT(PY_LONG_LONG) _testfunc_callback_q_qf(PY_LONG_LONG value,
 240                                              PY_LONG_LONG (*func)(PY_LONG_LONG))
 241 {
 242         PY_LONG_LONG sum = 0;
 243
 244         while (value != 0) {
 245                 sum += func(value);
 246                 value /= 2;
 247         }
 248         return sum;
 249 }
 250
 251 #endif
 252
 253 typedef struct {
 254         char *name;
 255         char *value;
 256 } SPAM;
 257
 258 typedef struct {
 259         char *name;
 260         int num_spams;
 261         SPAM *spams;
 262 } EGG;
 263
 264 SPAM my_spams[2] = {
 265         { "name1", "value1" },
 266         { "name2", "value2" },
 267 };
 268
 269 EGG my_eggs[1] = {
 270         { "first egg", 1, my_spams }
 271 };
 272
 273 EXPORT(int) getSPAMANDEGGS(EGG **eggs)
 274 {
 275         *eggs = my_eggs;
 276         return 1;
 277 }
 278
 279 typedef struct tagpoint {
 280         int x;
 281         int y;
 282 } point;
 283
 284 EXPORT(int) _testfunc_byval(point in, point *pout)
 285 {
 286         if (pout) {
 287                 pout->x = in.x;
 288                 pout->y = in.y;
 289         }
 290         return in.x + in.y;
 291 }
 292
 293 EXPORT (int) an_integer = 42;
 294
 295 EXPORT(int) get_an_integer(void)
 296 {
 297         return an_integer;
 298 }
 299
 300 EXPORT(double)
 301 integrate(double a, double b, double (*f)(double), long nstep)
 302 {
 303         double x, sum=0.0, dx=(b-a)/(double)nstep;
 304         for(x=a+0.5*dx; (b-x)*(x-a)>0.0; x+=dx)
 305                 sum += f(x);
 306         return sum/(double)nstep;
 307 }
 308
 309 typedef struct {
 310         void (*initialize)(void *(*)(int), void(*)(void *));
 311 } xxx_library;
 312
 313 static void _xxx_init(void *(*Xalloc)(int), void (*Xfree)(void *))
 314 {
 315         void *ptr;
 316
 317         printf("_xxx_init got %p %p\n", Xalloc, Xfree);
 318         printf("calling\n");
 319         ptr = Xalloc(32);
 320         Xfree(ptr);
 321         printf("calls done, ptr was %p\n", ptr);
 322 }
 323
 324 xxx_library _xxx_lib = {
 325         _xxx_init
 326 };
 327
 328 EXPORT(xxx_library) *library_get(void)
 329 {
 330         return &_xxx_lib;
 331 }
 332
 333 #ifdef MS_WIN32
 334 /* See Don Box (german), pp 79ff. */
 335 EXPORT(void) GetString(BSTR *pbstr)
 336 {
 337         *pbstr = SysAllocString(L"Goodbye!");
 338 }
 339 #endif
 340
 341 /*
 342  * Some do-nothing functions, for speed tests
 343  */
 344 PyObject *py_func_si(PyObject *self, PyObject *args)
 345 {
 346         char *name;
 347         int i;
 348         if (!PyArg_ParseTuple(args, "si", &name, &i))
 349                 return NULL;
 350         Py_INCREF(Py_None);
 351         return Py_None;
 352 }
 353
 354 EXPORT(void) _py_func_si(char *s, int i)
 355 {
 356 }
 357
 358 PyObject *py_func(PyObject *self, PyObject *args)
 359 {
 360         Py_INCREF(Py_None);
 361         return Py_None;
 362 }
 363
 364 EXPORT(void) _py_func(void)
 365 {
 366 }
 367
 368 EXPORT(PY_LONG_LONG) last_tf_arg_s;
 369 EXPORT(unsigned PY_LONG_LONG) last_tf_arg_u;
 370
 371 struct BITS {
 372         int A: 1, B:2, C:3, D:4, E: 5, F: 6, G: 7, H: 8, I: 9;
 373         short M: 1, N: 2, O: 3, P: 4, Q: 5, R: 6, S: 7;
 374 };
 375
 376 DL_EXPORT(void) set_bitfields(struct BITS *bits, char name, int value)
 377 {
 378         switch (name) {
 379         case 'A': bits->A = value; break;
 380         case 'B': bits->B = value; break;
 381         case 'C': bits->C = value; break;
 382         case 'D': bits->D = value; break;
 383         case 'E': bits->E = value; break;
 384         case 'F': bits->F = value; break;
 385         case 'G': bits->G = value; break;
 386         case 'H': bits->H = value; break;
 387         case 'I': bits->I = value; break;
 388
 389         case 'M': bits->M = value; break;
 390         case 'N': bits->N = value; break;
 391         case 'O': bits->O = value; break;
 392         case 'P': bits->P = value; break;
 393         case 'Q': bits->Q = value; break;
 394         case 'R': bits->R = value; break;
 395         case 'S': bits->S = value; break;
 396         }
 397 }
 398
 399 DL_EXPORT(int) unpack_bitfields(struct BITS *bits, char name)
 400 {
 401         switch (name) {
 402         case 'A': return bits->A;
 403         case 'B': return bits->B;
 404         case 'C': return bits->C;
 405         case 'D': return bits->D;
 406         case 'E': return bits->E;
 407         case 'F': return bits->F;
 408         case 'G': return bits->G;
 409         case 'H': return bits->H;
 410         case 'I': return bits->I;
 411
 412         case 'M': return bits->M;
 413         case 'N': return bits->N;
 414         case 'O': return bits->O;
 415         case 'P': return bits->P;
 416         case 'Q': return bits->Q;
 417         case 'R': return bits->R;
 418         case 'S': return bits->S;
 419         }
 420         return 0;
 421 }
 422
 423 static PyMethodDef module_methods[] = {
 424 /*      {"get_last_tf_arg_s", get_last_tf_arg_s, METH_NOARGS},
 425         {"get_last_tf_arg_u", get_last_tf_arg_u, METH_NOARGS},
 426 */
 427         {"func_si", py_func_si, METH_VARARGS},
 428         {"func", py_func, METH_NOARGS},
 429         { NULL, NULL, 0, NULL},
 430 };
 431
 432 #define S last_tf_arg_s = (PY_LONG_LONG)c
 433 #define U last_tf_arg_u = (unsigned PY_LONG_LONG)c
 434
 435 EXPORT(signed char) tf_b(signed char c) { S; return c/3; }
 436 EXPORT(unsigned char) tf_B(unsigned char c) { U; return c/3; }
 437 EXPORT(short) tf_h(short c) { S; return c/3; }
 438 EXPORT(unsigned short) tf_H(unsigned short c) { U; return c/3; }
 439 EXPORT(int) tf_i(int c) { S; return c/3; }
 440 EXPORT(unsigned int) tf_I(unsigned int c) { U; return c/3; }
 441 EXPORT(long) tf_l(long c) { S; return c/3; }
 442 EXPORT(unsigned long) tf_L(unsigned long c) { U; return c/3; }
 443 EXPORT(PY_LONG_LONG) tf_q(PY_LONG_LONG c) { S; return c/3; }
 444 EXPORT(unsigned PY_LONG_LONG) tf_Q(unsigned PY_LONG_LONG c) { U; return c/3; }
 445 EXPORT(float) tf_f(float c) { S; return c/3; }
 446 EXPORT(double) tf_d(double c) { S; return c/3; }
 447 EXPORT(long double) tf_D(long double c) { S; return c/3; }
 448
 449 #ifdef MS_WIN32
 450 EXPORT(signed char) __stdcall s_tf_b(signed char c) { S; return c/3; }
 451 EXPORT(unsigned char) __stdcall s_tf_B(unsigned char c) { U; return c/3; }
 452 EXPORT(short) __stdcall s_tf_h(short c) { S; return c/3; }
 453 EXPORT(unsigned short) __stdcall s_tf_H(unsigned short c) { U; return c/3; }
 454 EXPORT(int) __stdcall s_tf_i(int c) { S; return c/3; }
 455 EXPORT(unsigned int) __stdcall s_tf_I(unsigned int c) { U; return c/3; }
 456 EXPORT(long) __stdcall s_tf_l(long c) { S; return c/3; }
 457 EXPORT(unsigned long) __stdcall s_tf_L(unsigned long c) { U; return c/3; }
 458 EXPORT(PY_LONG_LONG) __stdcall s_tf_q(PY_LONG_LONG c) { S; return c/3; }
 459 EXPORT(unsigned PY_LONG_LONG) __stdcall s_tf_Q(unsigned PY_LONG_LONG c) { U; return c/3; }
 460 EXPORT(float) __stdcall s_tf_f(float c) { S; return c/3; }
 461 EXPORT(double) __stdcall s_tf_d(double c) { S; return c/3; }
 462 EXPORT(long double) __stdcall s_tf_D(long double c) { S; return c/3; }
 463 #endif
 464 /*******/
 465
 466 EXPORT(signed char) tf_bb(signed char x, signed char c) { S; return c/3; }
 467 EXPORT(unsigned char) tf_bB(signed char x, unsigned char c) { U; return c/3; }
 468 EXPORT(short) tf_bh(signed char x, short c) { S; return c/3; }
 469 EXPORT(unsigned short) tf_bH(signed char x, unsigned short c) { U; return c/3; }
 470 EXPORT(int) tf_bi(signed char x, int c) { S; return c/3; }
 471 EXPORT(unsigned int) tf_bI(signed char x, unsigned int c) { U; return c/3; }
 472 EXPORT(long) tf_bl(signed char x, long c) { S; return c/3; }
 473 EXPORT(unsigned long) tf_bL(signed char x, unsigned long c) { U; return c/3; }
 474 EXPORT(PY_LONG_LONG) tf_bq(signed char x, PY_LONG_LONG c) { S; return c/3; }
 475 EXPORT(unsigned PY_LONG_LONG) tf_bQ(signed char x, unsigned PY_LONG_LONG c) { U; return c/3; }
 476 EXPORT(float) tf_bf(signed char x, float c) { S; return c/3; }
 477 EXPORT(double) tf_bd(signed char x, double c) { S; return c/3; }
 478 EXPORT(long double) tf_bD(signed char x, long double c) { S; return c/3; }
 479 EXPORT(void) tv_i(int c) { S; return; }
 480
 481 #ifdef MS_WIN32
 482 EXPORT(signed char) __stdcall s_tf_bb(signed char x, signed char c) { S; return c/3; }
 483 EXPORT(unsigned char) __stdcall s_tf_bB(signed char x, unsigned char c) { U; return c/3; }
 484 EXPORT(short) __stdcall s_tf_bh(signed char x, short c) { S; return c/3; }
 485 EXPORT(unsigned short) __stdcall s_tf_bH(signed char x, unsigned short c) { U; return c/3; }
 486 EXPORT(int) __stdcall s_tf_bi(signed char x, int c) { S; return c/3; }
 487 EXPORT(unsigned int) __stdcall s_tf_bI(signed char x, unsigned int c) { U; return c/3; }
 488 EXPORT(long) __stdcall s_tf_bl(signed char x, long c) { S; return c/3; }
 489 EXPORT(unsigned long) __stdcall s_tf_bL(signed char x, unsigned long c) { U; return c/3; }
 490 EXPORT(PY_LONG_LONG) __stdcall s_tf_bq(signed char x, PY_LONG_LONG c) { S; return c/3; }
 491 EXPORT(unsigned PY_LONG_LONG) __stdcall s_tf_bQ(signed char x, unsigned PY_LONG_LONG c) { U; return c/3; }
 492 EXPORT(float) __stdcall s_tf_bf(signed char x, float c) { S; return c/3; }
 493 EXPORT(double) __stdcall s_tf_bd(signed char x, double c) { S; return c/3; }
 494 EXPORT(long double) __stdcall s_tf_bD(signed char x, long double c) { S; return c/3; }
 495 EXPORT(void) __stdcall s_tv_i(int c) { S; return; }
 496 #endif
 497
 498 /********/
 499
 500 #ifndef MS_WIN32
 501
 502 typedef struct {
 503         long x;
 504         long y;
 505 } POINT;
 506
 507 typedef struct {
 508         long left;
 509         long top;
 510         long right;
 511         long bottom;
 512 } RECT;
 513
 514 #endif
 515
 516 EXPORT(int) PointInRect(RECT *prc, POINT pt)
 517 {
 518         if (pt.x < prc->left)
 519                 return 0;
 520         if (pt.x > prc->right)
 521                 return 0;
 522         if (pt.y < prc->top)
 523                 return 0;
 524         if (pt.y > prc->bottom)
 525                 return 0;
 526         return 1;
 527 }
 528
 529 typedef struct {
 530         short x;
 531         short y;
 532 } S2H;
 533
 534 EXPORT(S2H) ret_2h_func(S2H inp)
 535 {
 536         inp.x *= 2;
 537         inp.y *= 3;
 538         return inp;
 539 }
 540
 541 typedef struct {
 542         int a, b, c, d, e, f, g, h;
 543 } S8I;
 544
 545 EXPORT(S8I) ret_8i_func(S8I inp)
 546 {
 547         inp.a *= 2;
 548         inp.b *= 3;
 549         inp.c *= 4;
 550         inp.d *= 5;
 551         inp.e *= 6;
 552         inp.f *= 7;
 553         inp.g *= 8;
 554         inp.h *= 9;
 555         return inp;
 556 }
 557
 558 EXPORT(int) GetRectangle(int flag, RECT *prect)
 559 {
 560         if (flag == 0)
 561                 return 0;
 562         prect->left = (int)flag;
 563         prect->top = (int)flag + 1;
 564         prect->right = (int)flag + 2;
 565         prect->bottom = (int)flag + 3;
 566         return 1;
 567 }
 568
 569 EXPORT(void) TwoOutArgs(int a, int *pi, int b, int *pj)
 570 {
 571         *pi += a;
 572         *pj += b;
 573 }
 574
 575 #ifdef MS_WIN32
 576 EXPORT(S2H) __stdcall s_ret_2h_func(S2H inp) { return ret_2h_func(inp); }
 577 EXPORT(S8I) __stdcall s_ret_8i_func(S8I inp) { return ret_8i_func(inp); }
 578 #endif
 579
 580 #ifdef MS_WIN32
 581 /* Should port this */
 582 #include <stdlib.h>
 583 #include <search.h>
 584
 585 EXPORT (HRESULT) KeepObject(IUnknown *punk)
 586 {
 587         static IUnknown *pobj;
 588         if (punk)
 589                 punk->lpVtbl->AddRef(punk);
 590         if (pobj)
 591                 pobj->lpVtbl->Release(pobj);
 592         pobj = punk;
 593         return S_OK;
 594 }
 595
 596 #endif
 597
 598 DL_EXPORT(void)
 599 init_ctypes_test(void)
 600 {
 601         Py_InitModule("_ctypes_test", module_methods);
 602 }