ma_gen.py

00001 # This file contains wrappers that has been automatically
00002 # generated from the maapi.h. Some of these has been moved
00003 # to ma.py, sometimes they have changed into more a more
00004 # Pythonic format.
00005 
00006 # When some function or constant is missing from ma.h,
00007 # it might be here.
00008 
00009 """__NATIVE__
00010 #include <ma.h>
00011 """
00012 
00013 
00014 TRANS_NONE = 0
00015 
00016 TRANS_ROT90 = 5
00017 
00018 TRANS_ROT180 = 3
00019 
00020 TRANS_ROT270 = 6
00021 
00022 TRANS_MIRROR = 2
00023 
00024 TRANS_MIRROR_ROT90 = 7
00025 
00026 TRANS_MIRROR_ROT180 = 1
00027 
00028 TRANS_MIRROR_ROT270 = 4
00029 
00030 HANDLE_SCREEN = 0
00031 
00032 HANDLE_LOCAL = 0
00033 
00034 RES_OUT_OF_MEMORY = 1
00035 
00036 RES_BAD_INPUT = 2
00037 
00038 RES_OK = 1
00039 
00040 MAS_CREATE_IF_NECESSARY = 1
00041 
00042 STERR_GENERIC = 2
00043 
00044 STERR_FULL = 3
00045 
00046 STERR_NONEXISTENT = 5
00047 
00048 CONNERR_GENERIC = 2
00049 
00050 CONNERR_MAX = 3
00051 
00052 CONNERR_DNS = 4
00053 
00054 CONNERR_INTERNAL = 5
00055 
00056 CONNERR_CLOSED = 6
00057 
00058 CONNERR_READONLY = 7
00059 
00060 CONNERR_FORBIDDEN = 8
00061 
00062 CONNERR_UNINITIALIZED = 9
00063 
00064 CONNERR_CONLEN = 10
00065 
00066 CONNERR_URL = 11
00067 
00068 CONNERR_UNAVAILABLE = 12
00069 
00070 CONNERR_CANCELED = 13
00071 
00072 CONNERR_PROTOCOL = 14
00073 
00074 CONNERR_NETWORK = 15
00075 
00076 CONNERR_NOHEADER = 16
00077 
00078 CONNERR_NOTFOUND = 17
00079 
00080 CONNERR_USER = 1000000
00081 
00082 CONNOP_READ = 1
00083 
00084 CONNOP_WRITE = 2
00085 
00086 CONNOP_CONNECT = 5
00087 
00088 CONNOP_FINISH = 11
00089 
00090 CONNOP_ACCEPT = 16
00091 
00092 CONN_MAX = 32
00093 
00094 BTADDR_LEN = 6
00095 
00096 CONN_FAMILY_INET4 = 1
00097 
00098 CONN_FAMILY_BT = 2
00099 
00100 HTTP_GET = 1
00101 
00102 HTTP_POST = 2
00103 
00104 HTTP_HEAD = 3
00105 
00106 MAK_UNKNOWN = 0
00107 
00108 MAK_FIRST = 0
00109 
00110 MAK_BACKSPACE = 8
00111 
00112 MAK_TAB = 9
00113 
00114 MAK_CLEAR = 12
00115 
00116 MAK_RETURN = 13
00117 
00118 MAK_PAUSE = 19
00119 
00120 MAK_ESCAPE = 27
00121 
00122 MAK_SPACE = 32
00123 
00124 MAK_EXCLAIM = 33
00125 
00126 MAK_QUOTEDBL = 34
00127 
00128 MAK_POUND = 35
00129 
00130 MAK_HASH = 35
00131 
00132 MAK_GRID = 35
00133 
00134 MAK_DOLLAR = 36
00135 
00136 MAK_AMPERSAND = 38
00137 
00138 MAK_QUOTE = 39
00139 
00140 MAK_LEFTPAREN = 40
00141 
00142 MAK_RIGHTPAREN = 41
00143 
00144 MAK_ASTERISK = 42
00145 
00146 MAK_STAR = 42
00147 
00148 MAK_PLUS = 43
00149 
00150 MAK_COMMA = 44
00151 
00152 MAK_MINUS = 45
00153 
00154 MAK_PERIOD = 46
00155 
00156 MAK_SLASH = 47
00157 
00158 MAK_0 = 48
00159 
00160 MAK_1 = 49
00161 
00162 MAK_2 = 50
00163 
00164 MAK_3 = 51
00165 
00166 MAK_4 = 52
00167 
00168 MAK_5 = 53
00169 
00170 MAK_6 = 54
00171 
00172 MAK_7 = 55
00173 
00174 MAK_8 = 56
00175 
00176 MAK_9 = 57
00177 
00178 MAK_COLON = 58
00179 
00180 MAK_SEMICOLON = 59
00181 
00182 MAK_LESS = 60
00183 
00184 MAK_EQUALS = 61
00185 
00186 MAK_GREATER = 62
00187 
00188 MAK_QUESTION = 63
00189 
00190 MAK_AT = 64
00191 
00192 MAK_LEFTBRACKET = 91
00193 
00194 MAK_BACKSLASH = 92
00195 
00196 MAK_RIGHTBRACKET = 93
00197 
00198 MAK_CARET = 94
00199 
00200 MAK_UNDERSCORE = 95
00201 
00202 MAK_BACKQUOTE = 96
00203 
00204 MAK_A = 97
00205 
00206 MAK_B = 98
00207 
00208 MAK_C = 99
00209 
00210 MAK_D = 100
00211 
00212 MAK_E = 101
00213 
00214 MAK_F = 102
00215 
00216 MAK_G = 103
00217 
00218 MAK_H = 104
00219 
00220 MAK_I = 105
00221 
00222 MAK_J = 106
00223 
00224 MAK_K = 107
00225 
00226 MAK_L = 108
00227 
00228 MAK_M = 109
00229 
00230 MAK_N = 110
00231 
00232 MAK_O = 111
00233 
00234 MAK_P = 112
00235 
00236 MAK_Q = 113
00237 
00238 MAK_R = 114
00239 
00240 MAK_S = 115
00241 
00242 MAK_T = 116
00243 
00244 MAK_U = 117
00245 
00246 MAK_V = 118
00247 
00248 MAK_W = 119
00249 
00250 MAK_X = 120
00251 
00252 MAK_Y = 121
00253 
00254 MAK_Z = 122
00255 
00256 MAK_DELETE = 127
00257 
00258 MAK_KP0 = 256
00259 
00260 MAK_KP1 = 257
00261 
00262 MAK_KP2 = 258
00263 
00264 MAK_KP3 = 259
00265 
00266 MAK_KP4 = 260
00267 
00268 MAK_KP5 = 261
00269 
00270 MAK_KP6 = 262
00271 
00272 MAK_KP7 = 263
00273 
00274 MAK_KP8 = 264
00275 
00276 MAK_KP9 = 265
00277 
00278 MAK_KP_PERIOD = 266
00279 
00280 MAK_KP_DIVIDE = 267
00281 
00282 MAK_KP_MULTIPLY = 268
00283 
00284 MAK_KP_MINUS = 269
00285 
00286 MAK_KP_PLUS = 270
00287 
00288 MAK_KP_ENTER = 271
00289 
00290 MAK_KP_EQUALS = 272
00291 
00292 MAK_UP = 273
00293 
00294 MAK_DOWN = 274
00295 
00296 MAK_RIGHT = 275
00297 
00298 MAK_LEFT = 276
00299 
00300 MAK_INSERT = 277
00301 
00302 MAK_HOME = 278
00303 
00304 MAK_END = 279
00305 
00306 MAK_PAGEUP = 280
00307 
00308 MAK_PAGEDOWN = 281
00309 
00310 MAK_FIRE = 284
00311 
00312 MAK_SOFTLEFT = 285
00313 
00314 MAK_SOFTRIGHT = 286
00315 
00316 MAK_PEN = 291
00317 
00318 MAK_BACK = 292
00319 
00320 MAK_MENU = 293
00321 
00322 MAK_RSHIFT = 303
00323 
00324 MAK_LSHIFT = 304
00325 
00326 MAK_RCTRL = 305
00327 
00328 MAK_LCTRL = 306
00329 
00330 MAK_RALT = 307
00331 
00332 MAK_LALT = 308
00333 
00334 MAKB_LEFT = 0x00001
00335 
00336 MAKB_UP = 0x00002
00337 
00338 MAKB_RIGHT = 0x00004
00339 
00340 MAKB_DOWN = 0x00008
00341 
00342 MAKB_FIRE = 0x00010
00343 
00344 MAKB_SOFTLEFT = 0x00020
00345 
00346 MAKB_SOFTRIGHT = 0x00040
00347 
00348 MAKB_0 = 0x00080
00349 
00350 MAKB_1 = 0x00100
00351 
00352 MAKB_2 = 0x00200
00353 
00354 MAKB_3 = 0x00400
00355 
00356 MAKB_4 = 0x00800
00357 
00358 MAKB_5 = 0x01000
00359 
00360 MAKB_6 = 0x02000
00361 
00362 MAKB_7 = 0x04000
00363 
00364 MAKB_8 = 0x08000
00365 
00366 MAKB_9 = 0x10000
00367 
00368 MAKB_ASTERISK = 0x20000
00369 
00370 MAKB_STAR = 0x20000
00371 
00372 MAKB_HASH = 0x40000
00373 
00374 MAKB_POUND = 0x40000
00375 
00376 MAKB_GRID = 0x40000
00377 
00378 MAKB_CLEAR = 0x80000
00379 
00380 EVENT_BUFFER_SIZE = 128
00381 
00382 EVENT_CLOSE_TIMEOUT = 2000
00383 
00384 EVENT_TYPE_CLOSE = 1
00385 
00386 EVENT_TYPE_KEY_PRESSED = 2
00387 
00388 EVENT_TYPE_KEY_RELEASED = 3
00389 
00390 EVENT_TYPE_CONN = 4
00391 
00392 EVENT_TYPE_BT = 5
00393 
00394 EVENT_TYPE_POINTER_PRESSED = 8
00395 
00396 EVENT_TYPE_POINTER_RELEASED = 9
00397 
00398 EVENT_TYPE_POINTER_DRAGGED = 10
00399 
00400 EVENT_TYPE_FOCUS_LOST = 13
00401 
00402 EVENT_TYPE_FOCUS_GAINED = 14
00403 
00404 EVENT_TYPE_LOCATION = 16
00405 
00406 EVENT_TYPE_LOCATION_PROVIDER = 17
00407 
00408 EVENT_TYPE_SCREEN_CHANGED = 21
00409 
00410 EVENT_TYPE_CHAR = 22
00411 
00412 EVENT_TYPE_TEXTBOX = 23
00413 
00414 RUNTIME_MORE = 1
00415 
00416 RUNTIME_JAVA = 2
00417 
00418 RUNTIME_SYMBIAN = 3
00419 
00420 RUNTIME_WINCE = 4
00421 
00422 REPORT_PANIC = 1
00423 
00424 REPORT_EXCEPTION = 2
00425 
00426 REPORT_PLATFORM_CODE = 3
00427 
00428 REPORT_USER_PANIC = 4
00429 
00430 REPORT_TIMEOUT = 5
00431 
00432 MA_LOC_NONE = 1
00433 
00434 MA_LOC_INVALID = 2
00435 
00436 MA_LOC_UNQUALIFIED = 3
00437 
00438 MA_LOC_QUALIFIED = 4
00439 
00440 MA_LPS_AVAILABLE = 1
00441 
00442 MA_LPS_TEMPORARILY_UNAVAILABLE = 2
00443 
00444 MA_LPS_OUT_OF_SERVICE = 3
00445 
00446 MA_TB_TYPE_ANY = 0
00447 
00448 MA_TB_TYPE_EMAILADDR = 1
00449 
00450 MA_TB_TYPE_NUMERIC = 2
00451 
00452 MA_TB_TYPE_PHONENUMBER = 3
00453 
00454 MA_TB_TYPE_URL = 4
00455 
00456 MA_TB_TYPE_DECIMAL = 5
00457 
00458 MA_TB_RES_OK = 1
00459 
00460 MA_TB_RES_CANCEL = 2
00461 
00462 MA_TB_FLAG_PASSWORD = 0x1000
00463 
00464 MA_TB_FLAG_UNEDITABLE = 0x2000
00465 
00466 MA_TB_FLAG_SENSITIVE = 0x4000
00467 
00468 MA_TB_FLAG_NON_PREDICTIVE = 0x8000
00469 
00470 MA_TB_FLAG_INITIAL_CAPS_WORD = 0x10000
00471 
00472 MA_TB_FLAG_INITIAL_CAPS_SENTENCE = 0x20000
00473 
00474 IOCTL_UNAVAILABLE = 1
00475 
00476 def maCheckInterfaceVersion(hash):
00477     """__NATIVE__
00478     /* Wrapper generated for: */
00479     /*   int maCheckInterfaceVersion(int hash); */
00480 
00481     PmReturn_t retval = PM_RET_OK;
00482 
00483     int func_retval;
00484     pPmObj_t p_func_retval = C_NULL;
00485 
00486     int hash;
00487     pPmObj_t p_hash = C_NULL;
00488 
00489     /* If wrong number of args, raise TypeError */
00490     if (NATIVE_GET_NUM_ARGS() != 1)
00491     {
00492         PM_RAISE(retval, PM_RET_EX_TYPE);
00493         return retval;
00494     }
00495 
00496     /* Raise TypeError if arg is not correct type */
00497     p_hash = NATIVE_GET_LOCAL(0);
00498     if (OBJ_GET_TYPE(p_hash) != OBJ_TYPE_INT)
00499     {
00500         PM_RAISE(retval, PM_RET_EX_TYPE);
00501         return retval;
00502     }
00503 
00504     hash = ((pPmInt_t)p_hash)->val;
00505 
00506     func_retval = maCheckInterfaceVersion(hash);
00507     retval = int_new(func_retval, &p_func_retval);
00508 
00509     NATIVE_SET_TOS(p_func_retval);
00510 
00511     return retval;
00512     """
00513     pass
00514 
00515 
00516 # No wrapper for
00517 #void ATTRIBUTE(noreturn, maExit(int result));
00518 
00519 # No wrapper for
00520 #void ATTRIBUTE(noreturn, maPanic(int result, const char* message));
00521 
00522 # No wrapper for
00523 #void* memset(void* dst, int val, ulong size);
00524 
00525 # No wrapper for
00526 #void* memcpy(void* dst, const void* src, ulong size);
00527 
00528 def strcmp(str1, str2):
00529     """__NATIVE__
00530     /* Wrapper generated for: */
00531     /*   int strcmp(const char* str1, const char* str2); */
00532 
00533     PmReturn_t retval = PM_RET_OK;
00534 
00535     int func_retval;
00536     pPmObj_t p_func_retval = C_NULL;
00537 
00538     const char* str1;
00539     pPmObj_t p_str1 = C_NULL;
00540 
00541     const char* str2;
00542     pPmObj_t p_str2 = C_NULL;
00543 
00544     /* If wrong number of args, raise TypeError */
00545     if (NATIVE_GET_NUM_ARGS() != 2)
00546     {
00547         PM_RAISE(retval, PM_RET_EX_TYPE);
00548         return retval;
00549     }
00550 
00551     /* Raise TypeError if arg is not correct type */
00552     p_str1 = NATIVE_GET_LOCAL(0);
00553     if (OBJ_GET_TYPE(p_str1) != OBJ_TYPE_STR)
00554     {
00555         PM_RAISE(retval, PM_RET_EX_TYPE);
00556         return retval;
00557     }
00558 
00559     /* Raise TypeError if arg is not correct type */
00560     p_str2 = NATIVE_GET_LOCAL(1);
00561     if (OBJ_GET_TYPE(p_str2) != OBJ_TYPE_STR)
00562     {
00563         PM_RAISE(retval, PM_RET_EX_TYPE);
00564         return retval;
00565     }
00566 
00567     str1 = (char const *)&(((pPmString_t)p_str1)->val);
00568     str2 = (char const *)&(((pPmString_t)p_str2)->val);
00569 
00570     func_retval = strcmp(str1, str2);
00571     retval = int_new(func_retval, &p_func_retval);
00572 
00573     NATIVE_SET_TOS(p_func_retval);
00574 
00575     return retval;
00576     """
00577     pass
00578 
00579 
00580 # No wrapper for
00581 #char* strcpy(char* dst, const char* src);
00582 
00583 def __adddf3(a, b):
00584     """__NATIVE__
00585     /* Wrapper generated for: */
00586     /*   double __adddf3(double a, double b); */
00587 
00588     PmReturn_t retval = PM_RET_OK;
00589 
00590     double func_retval;
00591     pPmObj_t p_func_retval = C_NULL;
00592 
00593     double a;
00594     pPmObj_t p_a = C_NULL;
00595 
00596     double b;
00597     pPmObj_t p_b = C_NULL;
00598 
00599     /* If wrong number of args, raise TypeError */
00600     if (NATIVE_GET_NUM_ARGS() != 2)
00601     {
00602         PM_RAISE(retval, PM_RET_EX_TYPE);
00603         return retval;
00604     }
00605 
00606     /* Raise TypeError if arg is not correct type */
00607     p_a = NATIVE_GET_LOCAL(0);
00608     if (OBJ_GET_TYPE(p_a) != OBJ_TYPE_FLT)
00609     {
00610         PM_RAISE(retval, PM_RET_EX_TYPE);
00611         return retval;
00612     }
00613 
00614     /* Raise TypeError if arg is not correct type */
00615     p_b = NATIVE_GET_LOCAL(1);
00616     if (OBJ_GET_TYPE(p_b) != OBJ_TYPE_FLT)
00617     {
00618         PM_RAISE(retval, PM_RET_EX_TYPE);
00619         return retval;
00620     }
00621 
00622     a = (double)(((pPmFloat_t)p_a)->val);
00623     b = (double)(((pPmFloat_t)p_b)->val);
00624 
00625     func_retval = __adddf3(a, b);
00626     retval = float_new(func_retval, &p_func_retval);
00627 
00628     NATIVE_SET_TOS(p_func_retval);
00629 
00630     return retval;
00631     """
00632     pass
00633 
00634 
00635 def __subdf3(a, b):
00636     """__NATIVE__
00637     /* Wrapper generated for: */
00638     /*   double __subdf3(double a, double b); */
00639 
00640     PmReturn_t retval = PM_RET_OK;
00641 
00642     double func_retval;
00643     pPmObj_t p_func_retval = C_NULL;
00644 
00645     double a;
00646     pPmObj_t p_a = C_NULL;
00647 
00648     double b;
00649     pPmObj_t p_b = C_NULL;
00650 
00651     /* If wrong number of args, raise TypeError */
00652     if (NATIVE_GET_NUM_ARGS() != 2)
00653     {
00654         PM_RAISE(retval, PM_RET_EX_TYPE);
00655         return retval;
00656     }
00657 
00658     /* Raise TypeError if arg is not correct type */
00659     p_a = NATIVE_GET_LOCAL(0);
00660     if (OBJ_GET_TYPE(p_a) != OBJ_TYPE_FLT)
00661     {
00662         PM_RAISE(retval, PM_RET_EX_TYPE);
00663         return retval;
00664     }
00665 
00666     /* Raise TypeError if arg is not correct type */
00667     p_b = NATIVE_GET_LOCAL(1);
00668     if (OBJ_GET_TYPE(p_b) != OBJ_TYPE_FLT)
00669     {
00670         PM_RAISE(retval, PM_RET_EX_TYPE);
00671         return retval;
00672     }
00673 
00674     a = (double)(((pPmFloat_t)p_a)->val);
00675     b = (double)(((pPmFloat_t)p_b)->val);
00676 
00677     func_retval = __subdf3(a, b);
00678     retval = float_new(func_retval, &p_func_retval);
00679 
00680     NATIVE_SET_TOS(p_func_retval);
00681 
00682     return retval;
00683     """
00684     pass
00685 
00686 
00687 def __muldf3(a, b):
00688     """__NATIVE__
00689     /* Wrapper generated for: */
00690     /*   double __muldf3(double a, double b); */
00691 
00692     PmReturn_t retval = PM_RET_OK;
00693 
00694     double func_retval;
00695     pPmObj_t p_func_retval = C_NULL;
00696 
00697     double a;
00698     pPmObj_t p_a = C_NULL;
00699 
00700     double b;
00701     pPmObj_t p_b = C_NULL;
00702 
00703     /* If wrong number of args, raise TypeError */
00704     if (NATIVE_GET_NUM_ARGS() != 2)
00705     {
00706         PM_RAISE(retval, PM_RET_EX_TYPE);
00707         return retval;
00708     }
00709 
00710     /* Raise TypeError if arg is not correct type */
00711     p_a = NATIVE_GET_LOCAL(0);
00712     if (OBJ_GET_TYPE(p_a) != OBJ_TYPE_FLT)
00713     {
00714         PM_RAISE(retval, PM_RET_EX_TYPE);
00715         return retval;
00716     }
00717 
00718     /* Raise TypeError if arg is not correct type */
00719     p_b = NATIVE_GET_LOCAL(1);
00720     if (OBJ_GET_TYPE(p_b) != OBJ_TYPE_FLT)
00721     {
00722         PM_RAISE(retval, PM_RET_EX_TYPE);
00723         return retval;
00724     }
00725 
00726     a = (double)(((pPmFloat_t)p_a)->val);
00727     b = (double)(((pPmFloat_t)p_b)->val);
00728 
00729     func_retval = __muldf3(a, b);
00730     retval = float_new(func_retval, &p_func_retval);
00731 
00732     NATIVE_SET_TOS(p_func_retval);
00733 
00734     return retval;
00735     """
00736     pass
00737 
00738 
00739 def __divdf3(a, b):
00740     """__NATIVE__
00741     /* Wrapper generated for: */
00742     /*   double __divdf3(double a, double b); */
00743 
00744     PmReturn_t retval = PM_RET_OK;
00745 
00746     double func_retval;
00747     pPmObj_t p_func_retval = C_NULL;
00748 
00749     double a;
00750     pPmObj_t p_a = C_NULL;
00751 
00752     double b;
00753     pPmObj_t p_b = C_NULL;
00754 
00755     /* If wrong number of args, raise TypeError */
00756     if (NATIVE_GET_NUM_ARGS() != 2)
00757     {
00758         PM_RAISE(retval, PM_RET_EX_TYPE);
00759         return retval;
00760     }
00761 
00762     /* Raise TypeError if arg is not correct type */
00763     p_a = NATIVE_GET_LOCAL(0);
00764     if (OBJ_GET_TYPE(p_a) != OBJ_TYPE_FLT)
00765     {
00766         PM_RAISE(retval, PM_RET_EX_TYPE);
00767         return retval;
00768     }
00769 
00770     /* Raise TypeError if arg is not correct type */
00771     p_b = NATIVE_GET_LOCAL(1);
00772     if (OBJ_GET_TYPE(p_b) != OBJ_TYPE_FLT)
00773     {
00774         PM_RAISE(retval, PM_RET_EX_TYPE);
00775         return retval;
00776     }
00777 
00778     a = (double)(((pPmFloat_t)p_a)->val);
00779     b = (double)(((pPmFloat_t)p_b)->val);
00780 
00781     func_retval = __divdf3(a, b);
00782     retval = float_new(func_retval, &p_func_retval);
00783 
00784     NATIVE_SET_TOS(p_func_retval);
00785 
00786     return retval;
00787     """
00788     pass
00789 
00790 
00791 def __negdf2(a):
00792     """__NATIVE__
00793     /* Wrapper generated for: */
00794     /*   double __negdf2(double a); */
00795 
00796     PmReturn_t retval = PM_RET_OK;
00797 
00798     double func_retval;
00799     pPmObj_t p_func_retval = C_NULL;
00800 
00801     double a;
00802     pPmObj_t p_a = C_NULL;
00803 
00804     /* If wrong number of args, raise TypeError */
00805     if (NATIVE_GET_NUM_ARGS() != 1)
00806     {
00807         PM_RAISE(retval, PM_RET_EX_TYPE);
00808         return retval;
00809     }
00810 
00811     /* Raise TypeError if arg is not correct type */
00812     p_a = NATIVE_GET_LOCAL(0);
00813     if (OBJ_GET_TYPE(p_a) != OBJ_TYPE_FLT)
00814     {
00815         PM_RAISE(retval, PM_RET_EX_TYPE);
00816         return retval;
00817     }
00818 
00819     a = (double)(((pPmFloat_t)p_a)->val);
00820 
00821     func_retval = __negdf2(a);
00822     retval = float_new(func_retval, &p_func_retval);
00823 
00824     NATIVE_SET_TOS(p_func_retval);
00825 
00826     return retval;
00827     """
00828     pass
00829 
00830 
00831 def __fixdfsi(a):
00832     """__NATIVE__
00833     /* Wrapper generated for: */
00834     /*   int __fixdfsi(double a); */
00835 
00836     PmReturn_t retval = PM_RET_OK;
00837 
00838     int func_retval;
00839     pPmObj_t p_func_retval = C_NULL;
00840 
00841     double a;
00842     pPmObj_t p_a = C_NULL;
00843 
00844     /* If wrong number of args, raise TypeError */
00845     if (NATIVE_GET_NUM_ARGS() != 1)
00846     {
00847         PM_RAISE(retval, PM_RET_EX_TYPE);
00848         return retval;
00849     }
00850 
00851     /* Raise TypeError if arg is not correct type */
00852     p_a = NATIVE_GET_LOCAL(0);
00853     if (OBJ_GET_TYPE(p_a) != OBJ_TYPE_FLT)
00854     {
00855         PM_RAISE(retval, PM_RET_EX_TYPE);
00856         return retval;
00857     }
00858 
00859     a = (double)(((pPmFloat_t)p_a)->val);
00860 
00861     func_retval = __fixdfsi(a);
00862     retval = int_new(func_retval, &p_func_retval);
00863 
00864     NATIVE_SET_TOS(p_func_retval);
00865 
00866     return retval;
00867     """
00868     pass
00869 
00870 
00871 # No wrapper for
00872 #uint __fixunsdfsi(double a);
00873 
00874 def __floatsidf(a):
00875     """__NATIVE__
00876     /* Wrapper generated for: */
00877     /*   double __floatsidf(int a); */
00878 
00879     PmReturn_t retval = PM_RET_OK;
00880 
00881     double func_retval;
00882     pPmObj_t p_func_retval = C_NULL;
00883 
00884     int a;
00885     pPmObj_t p_a = C_NULL;
00886 
00887     /* If wrong number of args, raise TypeError */
00888     if (NATIVE_GET_NUM_ARGS() != 1)
00889     {
00890         PM_RAISE(retval, PM_RET_EX_TYPE);
00891         return retval;
00892     }
00893 
00894     /* Raise TypeError if arg is not correct type */
00895     p_a = NATIVE_GET_LOCAL(0);
00896     if (OBJ_GET_TYPE(p_a) != OBJ_TYPE_INT)
00897     {
00898         PM_RAISE(retval, PM_RET_EX_TYPE);
00899         return retval;
00900     }
00901 
00902     a = ((pPmInt_t)p_a)->val;
00903 
00904     func_retval = __floatsidf(a);
00905     retval = float_new(func_retval, &p_func_retval);
00906 
00907     NATIVE_SET_TOS(p_func_retval);
00908 
00909     return retval;
00910     """
00911     pass
00912 
00913 
00914 # No wrapper for
00915 #double __extendsfdf2(float a);
00916 
00917 def dcmp(a, b):
00918     """__NATIVE__
00919     /* Wrapper generated for: */
00920     /*   int dcmp(double a, double b); */
00921 
00922     PmReturn_t retval = PM_RET_OK;
00923 
00924     int func_retval;
00925     pPmObj_t p_func_retval = C_NULL;
00926 
00927     double a;
00928     pPmObj_t p_a = C_NULL;
00929 
00930     double b;
00931     pPmObj_t p_b = C_NULL;
00932 
00933     /* If wrong number of args, raise TypeError */
00934     if (NATIVE_GET_NUM_ARGS() != 2)
00935     {
00936         PM_RAISE(retval, PM_RET_EX_TYPE);
00937         return retval;
00938     }
00939 
00940     /* Raise TypeError if arg is not correct type */
00941     p_a = NATIVE_GET_LOCAL(0);
00942     if (OBJ_GET_TYPE(p_a) != OBJ_TYPE_FLT)
00943     {
00944         PM_RAISE(retval, PM_RET_EX_TYPE);
00945         return retval;
00946     }
00947 
00948     /* Raise TypeError if arg is not correct type */
00949     p_b = NATIVE_GET_LOCAL(1);
00950     if (OBJ_GET_TYPE(p_b) != OBJ_TYPE_FLT)
00951     {
00952         PM_RAISE(retval, PM_RET_EX_TYPE);
00953         return retval;
00954     }
00955 
00956     a = (double)(((pPmFloat_t)p_a)->val);
00957     b = (double)(((pPmFloat_t)p_b)->val);
00958 
00959     func_retval = dcmp(a, b);
00960     retval = int_new(func_retval, &p_func_retval);
00961 
00962     NATIVE_SET_TOS(p_func_retval);
00963 
00964     return retval;
00965     """
00966     pass
00967 
00968 
00969 # No wrapper for
00970 #float __addsf3(float a, float b);
00971 
00972 # No wrapper for
00973 #float __subsf3(float a, float b);
00974 
00975 # No wrapper for
00976 #float __mulsf3(float a, float b);
00977 
00978 # No wrapper for
00979 #float __divsf3(float a, float b);
00980 
00981 # No wrapper for
00982 #float __negsf2(float a);
00983 
00984 # No wrapper for
00985 #int __fixsfsi(float a);
00986 
00987 # No wrapper for
00988 #uint __fixunssfsi(float a);
00989 
00990 # No wrapper for
00991 #float __floatsisf(int a);
00992 
00993 # No wrapper for
00994 #float __truncdfsf2(double a);
00995 
00996 # No wrapper for
00997 #int fcmp(float a, float b);
00998 
00999 def sin(x):
01000     """__NATIVE__
01001     /* Wrapper generated for: */
01002     /*   double sin(double x); */
01003 
01004     PmReturn_t retval = PM_RET_OK;
01005 
01006     double func_retval;
01007     pPmObj_t p_func_retval = C_NULL;
01008 
01009     double x;
01010     pPmObj_t p_x = C_NULL;
01011 
01012     /* If wrong number of args, raise TypeError */
01013     if (NATIVE_GET_NUM_ARGS() != 1)
01014     {
01015         PM_RAISE(retval, PM_RET_EX_TYPE);
01016         return retval;
01017     }
01018 
01019     /* Raise TypeError if arg is not correct type */
01020     p_x = NATIVE_GET_LOCAL(0);
01021     if (OBJ_GET_TYPE(p_x) != OBJ_TYPE_FLT)
01022     {
01023         PM_RAISE(retval, PM_RET_EX_TYPE);
01024         return retval;
01025     }
01026 
01027     x = (double)(((pPmFloat_t)p_x)->val);
01028 
01029     func_retval = sin(x);
01030     retval = float_new(func_retval, &p_func_retval);
01031 
01032     NATIVE_SET_TOS(p_func_retval);
01033 
01034     return retval;
01035     """
01036     pass
01037 
01038 
01039 def cos(x):
01040     """__NATIVE__
01041     /* Wrapper generated for: */
01042     /*   double cos(double x); */
01043 
01044     PmReturn_t retval = PM_RET_OK;
01045 
01046     double func_retval;
01047     pPmObj_t p_func_retval = C_NULL;
01048 
01049     double x;
01050     pPmObj_t p_x = C_NULL;
01051 
01052     /* If wrong number of args, raise TypeError */
01053     if (NATIVE_GET_NUM_ARGS() != 1)
01054     {
01055         PM_RAISE(retval, PM_RET_EX_TYPE);
01056         return retval;
01057     }
01058 
01059     /* Raise TypeError if arg is not correct type */
01060     p_x = NATIVE_GET_LOCAL(0);
01061     if (OBJ_GET_TYPE(p_x) != OBJ_TYPE_FLT)
01062     {
01063         PM_RAISE(retval, PM_RET_EX_TYPE);
01064         return retval;
01065     }
01066 
01067     x = (double)(((pPmFloat_t)p_x)->val);
01068 
01069     func_retval = cos(x);
01070     retval = float_new(func_retval, &p_func_retval);
01071 
01072     NATIVE_SET_TOS(p_func_retval);
01073 
01074     return retval;
01075     """
01076     pass
01077 
01078 
01079 def tan(x):
01080     """__NATIVE__
01081     /* Wrapper generated for: */
01082     /*   double tan(double x); */
01083 
01084     PmReturn_t retval = PM_RET_OK;
01085 
01086     double func_retval;
01087     pPmObj_t p_func_retval = C_NULL;
01088 
01089     double x;
01090     pPmObj_t p_x = C_NULL;
01091 
01092     /* If wrong number of args, raise TypeError */
01093     if (NATIVE_GET_NUM_ARGS() != 1)
01094     {
01095         PM_RAISE(retval, PM_RET_EX_TYPE);
01096         return retval;
01097     }
01098 
01099     /* Raise TypeError if arg is not correct type */
01100     p_x = NATIVE_GET_LOCAL(0);
01101     if (OBJ_GET_TYPE(p_x) != OBJ_TYPE_FLT)
01102     {
01103         PM_RAISE(retval, PM_RET_EX_TYPE);
01104         return retval;
01105     }
01106 
01107     x = (double)(((pPmFloat_t)p_x)->val);
01108 
01109     func_retval = tan(x);
01110     retval = float_new(func_retval, &p_func_retval);
01111 
01112     NATIVE_SET_TOS(p_func_retval);
01113 
01114     return retval;
01115     """
01116     pass
01117 
01118 
01119 def sqrt(x):
01120     """__NATIVE__
01121     /* Wrapper generated for: */
01122     /*   double sqrt(double x); */
01123 
01124     PmReturn_t retval = PM_RET_OK;
01125 
01126     double func_retval;
01127     pPmObj_t p_func_retval = C_NULL;
01128 
01129     double x;
01130     pPmObj_t p_x = C_NULL;
01131 
01132     /* If wrong number of args, raise TypeError */
01133     if (NATIVE_GET_NUM_ARGS() != 1)
01134     {
01135         PM_RAISE(retval, PM_RET_EX_TYPE);
01136         return retval;
01137     }
01138 
01139     /* Raise TypeError if arg is not correct type */
01140     p_x = NATIVE_GET_LOCAL(0);
01141     if (OBJ_GET_TYPE(p_x) != OBJ_TYPE_FLT)
01142     {
01143         PM_RAISE(retval, PM_RET_EX_TYPE);
01144         return retval;
01145     }
01146 
01147     x = (double)(((pPmFloat_t)p_x)->val);
01148 
01149     func_retval = sqrt(x);
01150     retval = float_new(func_retval, &p_func_retval);
01151 
01152     NATIVE_SET_TOS(p_func_retval);
01153 
01154     return retval;
01155     """
01156     pass
01157 
01158 
01159 def maSetColor(rgb):
01160     """__NATIVE__
01161     /* Wrapper generated for: */
01162     /*   int maSetColor(int rgb); */
01163 
01164     PmReturn_t retval = PM_RET_OK;
01165 
01166     int func_retval;
01167     pPmObj_t p_func_retval = C_NULL;
01168 
01169     int rgb;
01170     pPmObj_t p_rgb = C_NULL;
01171 
01172     /* If wrong number of args, raise TypeError */
01173     if (NATIVE_GET_NUM_ARGS() != 1)
01174     {
01175         PM_RAISE(retval, PM_RET_EX_TYPE);
01176         return retval;
01177     }
01178 
01179     /* Raise TypeError if arg is not correct type */
01180     p_rgb = NATIVE_GET_LOCAL(0);
01181     if (OBJ_GET_TYPE(p_rgb) != OBJ_TYPE_INT)
01182     {
01183         PM_RAISE(retval, PM_RET_EX_TYPE);
01184         return retval;
01185     }
01186 
01187     rgb = ((pPmInt_t)p_rgb)->val;
01188 
01189     func_retval = maSetColor(rgb);
01190     retval = int_new(func_retval, &p_func_retval);
01191 
01192     NATIVE_SET_TOS(p_func_retval);
01193 
01194     return retval;
01195     """
01196     pass
01197 
01198 
01199 def maSetClipRect(left, top, width, height):
01200     """__NATIVE__
01201     /* Wrapper generated for: */
01202     /*   void maSetClipRect(int left, int top, int width, int height); */
01203 
01204     PmReturn_t retval = PM_RET_OK;
01205 
01206     pPmObj_t p_func_retval = C_NULL;
01207 
01208     int left;
01209     pPmObj_t p_left = C_NULL;
01210 
01211     int top;
01212     pPmObj_t p_top = C_NULL;
01213 
01214     int width;
01215     pPmObj_t p_width = C_NULL;
01216 
01217     int height;
01218     pPmObj_t p_height = C_NULL;
01219 
01220     /* If wrong number of args, raise TypeError */
01221     if (NATIVE_GET_NUM_ARGS() != 4)
01222     {
01223         PM_RAISE(retval, PM_RET_EX_TYPE);
01224         return retval;
01225     }
01226 
01227     /* Raise TypeError if arg is not correct type */
01228     p_left = NATIVE_GET_LOCAL(0);
01229     if (OBJ_GET_TYPE(p_left) != OBJ_TYPE_INT)
01230     {
01231         PM_RAISE(retval, PM_RET_EX_TYPE);
01232         return retval;
01233     }
01234 
01235     /* Raise TypeError if arg is not correct type */
01236     p_top = NATIVE_GET_LOCAL(1);
01237     if (OBJ_GET_TYPE(p_top) != OBJ_TYPE_INT)
01238     {
01239         PM_RAISE(retval, PM_RET_EX_TYPE);
01240         return retval;
01241     }
01242 
01243     /* Raise TypeError if arg is not correct type */
01244     p_width = NATIVE_GET_LOCAL(2);
01245     if (OBJ_GET_TYPE(p_width) != OBJ_TYPE_INT)
01246     {
01247         PM_RAISE(retval, PM_RET_EX_TYPE);
01248         return retval;
01249     }
01250 
01251     /* Raise TypeError if arg is not correct type */
01252     p_height = NATIVE_GET_LOCAL(3);
01253     if (OBJ_GET_TYPE(p_height) != OBJ_TYPE_INT)
01254     {
01255         PM_RAISE(retval, PM_RET_EX_TYPE);
01256         return retval;
01257     }
01258 
01259     left = ((pPmInt_t)p_left)->val;
01260     top = ((pPmInt_t)p_top)->val;
01261     width = ((pPmInt_t)p_width)->val;
01262     height = ((pPmInt_t)p_height)->val;
01263 
01264     maSetClipRect(left, top, width, height);
01265 
01266     NATIVE_SET_TOS(PM_NONE);
01267 
01268     return retval;
01269     """
01270     pass
01271 
01272 
01273 # No wrapper for
01274 #void maGetClipRect(MARect* out);
01275 
01276 def maPlot(posX, posY):
01277     """__NATIVE__
01278     /* Wrapper generated for: */
01279     /*   void maPlot(int posX, int posY); */
01280 
01281     PmReturn_t retval = PM_RET_OK;
01282 
01283     pPmObj_t p_func_retval = C_NULL;
01284 
01285     int posX;
01286     pPmObj_t p_posX = C_NULL;
01287 
01288     int posY;
01289     pPmObj_t p_posY = C_NULL;
01290 
01291     /* If wrong number of args, raise TypeError */
01292     if (NATIVE_GET_NUM_ARGS() != 2)
01293     {
01294         PM_RAISE(retval, PM_RET_EX_TYPE);
01295         return retval;
01296     }
01297 
01298     /* Raise TypeError if arg is not correct type */
01299     p_posX = NATIVE_GET_LOCAL(0);
01300     if (OBJ_GET_TYPE(p_posX) != OBJ_TYPE_INT)
01301     {
01302         PM_RAISE(retval, PM_RET_EX_TYPE);
01303         return retval;
01304     }
01305 
01306     /* Raise TypeError if arg is not correct type */
01307     p_posY = NATIVE_GET_LOCAL(1);
01308     if (OBJ_GET_TYPE(p_posY) != OBJ_TYPE_INT)
01309     {
01310         PM_RAISE(retval, PM_RET_EX_TYPE);
01311         return retval;
01312     }
01313 
01314     posX = ((pPmInt_t)p_posX)->val;
01315     posY = ((pPmInt_t)p_posY)->val;
01316 
01317     maPlot(posX, posY);
01318 
01319     NATIVE_SET_TOS(PM_NONE);
01320 
01321     return retval;
01322     """
01323     pass
01324 
01325 
01326 def maLine(startX, startY, endX, endY):
01327     """__NATIVE__
01328     /* Wrapper generated for: */
01329     /*   void maLine(int startX, int startY, int endX, int endY); */
01330 
01331     PmReturn_t retval = PM_RET_OK;
01332 
01333     pPmObj_t p_func_retval = C_NULL;
01334 
01335     int startX;
01336     pPmObj_t p_startX = C_NULL;
01337 
01338     int startY;
01339     pPmObj_t p_startY = C_NULL;
01340 
01341     int endX;
01342     pPmObj_t p_endX = C_NULL;
01343 
01344     int endY;
01345     pPmObj_t p_endY = C_NULL;
01346 
01347     /* If wrong number of args, raise TypeError */
01348     if (NATIVE_GET_NUM_ARGS() != 4)
01349     {
01350         PM_RAISE(retval, PM_RET_EX_TYPE);
01351         return retval;
01352     }
01353 
01354     /* Raise TypeError if arg is not correct type */
01355     p_startX = NATIVE_GET_LOCAL(0);
01356     if (OBJ_GET_TYPE(p_startX) != OBJ_TYPE_INT)
01357     {
01358         PM_RAISE(retval, PM_RET_EX_TYPE);
01359         return retval;
01360     }
01361 
01362     /* Raise TypeError if arg is not correct type */
01363     p_startY = NATIVE_GET_LOCAL(1);
01364     if (OBJ_GET_TYPE(p_startY) != OBJ_TYPE_INT)
01365     {
01366         PM_RAISE(retval, PM_RET_EX_TYPE);
01367         return retval;
01368     }
01369 
01370     /* Raise TypeError if arg is not correct type */
01371     p_endX = NATIVE_GET_LOCAL(2);
01372     if (OBJ_GET_TYPE(p_endX) != OBJ_TYPE_INT)
01373     {
01374         PM_RAISE(retval, PM_RET_EX_TYPE);
01375         return retval;
01376     }
01377 
01378     /* Raise TypeError if arg is not correct type */
01379     p_endY = NATIVE_GET_LOCAL(3);
01380     if (OBJ_GET_TYPE(p_endY) != OBJ_TYPE_INT)
01381     {
01382         PM_RAISE(retval, PM_RET_EX_TYPE);
01383         return retval;
01384     }
01385 
01386     startX = ((pPmInt_t)p_startX)->val;
01387     startY = ((pPmInt_t)p_startY)->val;
01388     endX = ((pPmInt_t)p_endX)->val;
01389     endY = ((pPmInt_t)p_endY)->val;
01390 
01391     maLine(startX, startY, endX, endY);
01392 
01393     NATIVE_SET_TOS(PM_NONE);
01394 
01395     return retval;
01396     """
01397     pass
01398 
01399 
01400 def maFillRect(left, top, width, height):
01401     """__NATIVE__
01402     /* Wrapper generated for: */
01403     /*   void maFillRect(int left, int top, int width, int height); */
01404 
01405     PmReturn_t retval = PM_RET_OK;
01406 
01407     pPmObj_t p_func_retval = C_NULL;
01408 
01409     int left;
01410     pPmObj_t p_left = C_NULL;
01411 
01412     int top;
01413     pPmObj_t p_top = C_NULL;
01414 
01415     int width;
01416     pPmObj_t p_width = C_NULL;
01417 
01418     int height;
01419     pPmObj_t p_height = C_NULL;
01420 
01421     /* If wrong number of args, raise TypeError */
01422     if (NATIVE_GET_NUM_ARGS() != 4)
01423     {
01424         PM_RAISE(retval, PM_RET_EX_TYPE);
01425         return retval;
01426     }
01427 
01428     /* Raise TypeError if arg is not correct type */
01429     p_left = NATIVE_GET_LOCAL(0);
01430     if (OBJ_GET_TYPE(p_left) != OBJ_TYPE_INT)
01431     {
01432         PM_RAISE(retval, PM_RET_EX_TYPE);
01433         return retval;
01434     }
01435 
01436     /* Raise TypeError if arg is not correct type */
01437     p_top = NATIVE_GET_LOCAL(1);
01438     if (OBJ_GET_TYPE(p_top) != OBJ_TYPE_INT)
01439     {
01440         PM_RAISE(retval, PM_RET_EX_TYPE);
01441         return retval;
01442     }
01443 
01444     /* Raise TypeError if arg is not correct type */
01445     p_width = NATIVE_GET_LOCAL(2);
01446     if (OBJ_GET_TYPE(p_width) != OBJ_TYPE_INT)
01447     {
01448         PM_RAISE(retval, PM_RET_EX_TYPE);
01449         return retval;
01450     }
01451 
01452     /* Raise TypeError if arg is not correct type */
01453     p_height = NATIVE_GET_LOCAL(3);
01454     if (OBJ_GET_TYPE(p_height) != OBJ_TYPE_INT)
01455     {
01456         PM_RAISE(retval, PM_RET_EX_TYPE);
01457         return retval;
01458     }
01459 
01460     left = ((pPmInt_t)p_left)->val;
01461     top = ((pPmInt_t)p_top)->val;
01462     width = ((pPmInt_t)p_width)->val;
01463     height = ((pPmInt_t)p_height)->val;
01464 
01465     maFillRect(left, top, width, height);
01466 
01467     NATIVE_SET_TOS(PM_NONE);
01468 
01469     return retval;
01470     """
01471     pass
01472 
01473 
01474 # No wrapper for
01475 #void maFillTriangleStrip(const MAPoint2d* points, int count);
01476 
01477 # No wrapper for
01478 #void maFillTriangleFan(const MAPoint2d* points, int count);
01479 
01480 def maGetTextSize(str):
01481     """__NATIVE__
01482     /* Wrapper generated for: */
01483     /*   MAExtent maGetTextSize(const char* str); */
01484 
01485     PmReturn_t retval = PM_RET_OK;
01486 
01487     int func_retval;
01488     pPmObj_t p_func_retval = C_NULL;
01489 
01490     const char* str;
01491     pPmObj_t p_str = C_NULL;
01492 
01493     /* If wrong number of args, raise TypeError */
01494     if (NATIVE_GET_NUM_ARGS() != 1)
01495     {
01496         PM_RAISE(retval, PM_RET_EX_TYPE);
01497         return retval;
01498     }
01499 
01500     /* Raise TypeError if arg is not correct type */
01501     p_str = NATIVE_GET_LOCAL(0);
01502     if (OBJ_GET_TYPE(p_str) != OBJ_TYPE_STR)
01503     {
01504         PM_RAISE(retval, PM_RET_EX_TYPE);
01505         return retval;
01506     }
01507 
01508     str = (char const *)&(((pPmString_t)p_str)->val);
01509 
01510     func_retval = maGetTextSize(str);
01511     retval = int_new(func_retval, &p_func_retval);
01512 
01513     NATIVE_SET_TOS(p_func_retval);
01514 
01515     return retval;
01516     """
01517     pass
01518 
01519 
01520 # No wrapper for
01521 #MAExtent maGetTextSizeW(const wchar* str);
01522 
01523 def maDrawText(left, top, s):
01524     """__NATIVE__
01525     /* Wrapper generated for: */
01526     /*   void maDrawText(int left, int top, const char* str); */
01527 
01528     PmReturn_t retval = PM_RET_OK;
01529 
01530     pPmObj_t p_func_retval = C_NULL;
01531 
01532     int left;
01533     pPmObj_t p_left = C_NULL;
01534 
01535     int top;
01536     pPmObj_t p_top = C_NULL;
01537 
01538     const char* str;
01539     pPmObj_t p_str = C_NULL;
01540 
01541     /* If wrong number of args, raise TypeError */
01542     if (NATIVE_GET_NUM_ARGS() != 3)
01543     {
01544         PM_RAISE(retval, PM_RET_EX_TYPE);
01545         return retval;
01546     }
01547 
01548     /* Raise TypeError if arg is not correct type */
01549     p_left = NATIVE_GET_LOCAL(0);
01550     if (OBJ_GET_TYPE(p_left) != OBJ_TYPE_INT)
01551     {
01552         PM_RAISE(retval, PM_RET_EX_TYPE);
01553         return retval;
01554     }
01555 
01556     /* Raise TypeError if arg is not correct type */
01557     p_top = NATIVE_GET_LOCAL(1);
01558     if (OBJ_GET_TYPE(p_top) != OBJ_TYPE_INT)
01559     {
01560         PM_RAISE(retval, PM_RET_EX_TYPE);
01561         return retval;
01562     }
01563 
01564     /* Raise TypeError if arg is not correct type */
01565     p_str = NATIVE_GET_LOCAL(2);
01566     if (OBJ_GET_TYPE(p_str) != OBJ_TYPE_STR)
01567     {
01568         PM_RAISE(retval, PM_RET_EX_TYPE);
01569         return retval;
01570     }
01571 
01572     left = ((pPmInt_t)p_left)->val;
01573     top = ((pPmInt_t)p_top)->val;
01574     str = (char const *)&(((pPmString_t)p_str)->val);
01575 
01576     maDrawText(left, top, str);
01577 
01578     NATIVE_SET_TOS(PM_NONE);
01579 
01580     return retval;
01581     """
01582     pass
01583 
01584 
01585 # No wrapper for
01586 #void maDrawTextW(int left, int top, const wchar* str);
01587 
01588 def maUpdateScreen():
01589     """__NATIVE__
01590     /* Wrapper generated for: */
01591     /*   void maUpdateScreen(void); */
01592 
01593     PmReturn_t retval = PM_RET_OK;
01594 
01595     pPmObj_t p_func_retval = C_NULL;
01596 
01597     /* If wrong number of args, raise TypeError */
01598     if (NATIVE_GET_NUM_ARGS() != 0)
01599     {
01600         PM_RAISE(retval, PM_RET_EX_TYPE);
01601         return retval;
01602     }
01603 
01604 
01605     maUpdateScreen();
01606 
01607     NATIVE_SET_TOS(PM_NONE);
01608 
01609     return retval;
01610     """
01611     pass
01612 
01613 
01614 def maResetBacklight():
01615     """__NATIVE__
01616     /* Wrapper generated for: */
01617     /*   void maResetBacklight(void); */
01618 
01619     PmReturn_t retval = PM_RET_OK;
01620 
01621     pPmObj_t p_func_retval = C_NULL;
01622 
01623     /* If wrong number of args, raise TypeError */
01624     if (NATIVE_GET_NUM_ARGS() != 0)
01625     {
01626         PM_RAISE(retval, PM_RET_EX_TYPE);
01627         return retval;
01628     }
01629 
01630 
01631     maResetBacklight();
01632 
01633     NATIVE_SET_TOS(PM_NONE);
01634 
01635     return retval;
01636     """
01637     pass
01638 
01639 
01640 def maGetScrSize():
01641     """__NATIVE__
01642     /* Wrapper generated for: */
01643     /*   MAExtent maGetScrSize(void); */
01644 
01645     PmReturn_t retval = PM_RET_OK;
01646 
01647     int func_retval;
01648     pPmObj_t p_func_retval = C_NULL;
01649 
01650     /* If wrong number of args, raise TypeError */
01651     if (NATIVE_GET_NUM_ARGS() != 0)
01652     {
01653         PM_RAISE(retval, PM_RET_EX_TYPE);
01654         return retval;
01655     }
01656 
01657 
01658     func_retval = maGetScrSize();
01659     retval = int_new(func_retval, &p_func_retval);
01660 
01661     NATIVE_SET_TOS(p_func_retval);
01662 
01663     return retval;
01664     """
01665     pass
01666 
01667 
01668 def maDrawImage(image, left, top):
01669     """__NATIVE__
01670     /* Wrapper generated for: */
01671     /*   void maDrawImage(MAHandle image, int left, int top); */
01672 
01673     PmReturn_t retval = PM_RET_OK;
01674 
01675     pPmObj_t p_func_retval = C_NULL;
01676 
01677     int image;
01678     pPmObj_t p_image = C_NULL;
01679 
01680     int left;
01681     pPmObj_t p_left = C_NULL;
01682 
01683     int top;
01684     pPmObj_t p_top = C_NULL;
01685 
01686     /* If wrong number of args, raise TypeError */
01687     if (NATIVE_GET_NUM_ARGS() != 3)
01688     {
01689         PM_RAISE(retval, PM_RET_EX_TYPE);
01690         return retval;
01691     }
01692 
01693     /* Raise TypeError if arg is not correct type */
01694     p_image = NATIVE_GET_LOCAL(0);
01695     if (OBJ_GET_TYPE(p_image) != OBJ_TYPE_INT)
01696     {
01697         PM_RAISE(retval, PM_RET_EX_TYPE);
01698         return retval;
01699     }
01700 
01701     /* Raise TypeError if arg is not correct type */
01702     p_left = NATIVE_GET_LOCAL(1);
01703     if (OBJ_GET_TYPE(p_left) != OBJ_TYPE_INT)
01704     {
01705         PM_RAISE(retval, PM_RET_EX_TYPE);
01706         return retval;
01707     }
01708 
01709     /* Raise TypeError if arg is not correct type */
01710     p_top = NATIVE_GET_LOCAL(2);
01711     if (OBJ_GET_TYPE(p_top) != OBJ_TYPE_INT)
01712     {
01713         PM_RAISE(retval, PM_RET_EX_TYPE);
01714         return retval;
01715     }
01716 
01717     image = ((pPmInt_t)p_image)->val;
01718     left = ((pPmInt_t)p_left)->val;
01719     top = ((pPmInt_t)p_top)->val;
01720 
01721     maDrawImage(image, left, top);
01722 
01723     NATIVE_SET_TOS(PM_NONE);
01724 
01725     return retval;
01726     """
01727     pass
01728 
01729 
01730 # No wrapper for
01731 #void maDrawRGB(const MAPoint2d* dstPoint, const void* src, const MARect* srcRect, int scanlength);
01732 
01733 # No wrapper for
01734 #void maDrawImageRegion(MAHandle image, const MARect* srcRect, const MAPoint2d* dstPoint, int transformMode);
01735 
01736 def maGetImageSize(image):
01737     """__NATIVE__
01738     /* Wrapper generated for: */
01739     /*   MAExtent maGetImageSize(MAHandle image); */
01740 
01741     PmReturn_t retval = PM_RET_OK;
01742 
01743     int func_retval;
01744     pPmObj_t p_func_retval = C_NULL;
01745 
01746     int image;
01747     pPmObj_t p_image = C_NULL;
01748 
01749     /* If wrong number of args, raise TypeError */
01750     if (NATIVE_GET_NUM_ARGS() != 1)
01751     {
01752         PM_RAISE(retval, PM_RET_EX_TYPE);
01753         return retval;
01754     }
01755 
01756     /* Raise TypeError if arg is not correct type */
01757     p_image = NATIVE_GET_LOCAL(0);
01758     if (OBJ_GET_TYPE(p_image) != OBJ_TYPE_INT)
01759     {
01760         PM_RAISE(retval, PM_RET_EX_TYPE);
01761         return retval;
01762     }
01763 
01764     image = ((pPmInt_t)p_image)->val;
01765 
01766     func_retval = maGetImageSize(image);
01767     retval = int_new(func_retval, &p_func_retval);
01768 
01769     NATIVE_SET_TOS(p_func_retval);
01770 
01771     return retval;
01772     """
01773     pass
01774 
01775 
01776 # No wrapper for
01777 #void maGetImageData(MAHandle image, void* dst, const MARect* srcRect, int scanlength);
01778 
01779 def maSetDrawTarget(image):
01780     """__NATIVE__
01781     /* Wrapper generated for: */
01782     /*   MAHandle maSetDrawTarget(MAHandle image); */
01783 
01784     PmReturn_t retval = PM_RET_OK;
01785 
01786     int func_retval;
01787     pPmObj_t p_func_retval = C_NULL;
01788 
01789     int image;
01790     pPmObj_t p_image = C_NULL;
01791 
01792     /* If wrong number of args, raise TypeError */
01793     if (NATIVE_GET_NUM_ARGS() != 1)
01794     {
01795         PM_RAISE(retval, PM_RET_EX_TYPE);
01796         return retval;
01797     }
01798 
01799     /* Raise TypeError if arg is not correct type */
01800     p_image = NATIVE_GET_LOCAL(0);
01801     if (OBJ_GET_TYPE(p_image) != OBJ_TYPE_INT)
01802     {
01803         PM_RAISE(retval, PM_RET_EX_TYPE);
01804         return retval;
01805     }
01806 
01807     image = ((pPmInt_t)p_image)->val;
01808 
01809     func_retval = maSetDrawTarget(image);
01810     retval = int_new(func_retval, &p_func_retval);
01811 
01812     NATIVE_SET_TOS(p_func_retval);
01813 
01814     return retval;
01815     """
01816     pass
01817 
01818 
01819 def maFindLabel(name):
01820     """__NATIVE__
01821     /* Wrapper generated for: */
01822     /*   int maFindLabel(const char* name); */
01823 
01824     PmReturn_t retval = PM_RET_OK;
01825 
01826     int func_retval;
01827     pPmObj_t p_func_retval = C_NULL;
01828 
01829     const char* name;
01830     pPmObj_t p_name = C_NULL;
01831 
01832     /* If wrong number of args, raise TypeError */
01833     if (NATIVE_GET_NUM_ARGS() != 1)
01834     {
01835         PM_RAISE(retval, PM_RET_EX_TYPE);
01836         return retval;
01837     }
01838 
01839     /* Raise TypeError if arg is not correct type */
01840     p_name = NATIVE_GET_LOCAL(0);
01841     if (OBJ_GET_TYPE(p_name) != OBJ_TYPE_STR)
01842     {
01843         PM_RAISE(retval, PM_RET_EX_TYPE);
01844         return retval;
01845     }
01846 
01847     name = (char const *)&(((pPmString_t)p_name)->val);
01848 
01849     func_retval = maFindLabel(name);
01850     retval = int_new(func_retval, &p_func_retval);
01851 
01852     NATIVE_SET_TOS(p_func_retval);
01853 
01854     return retval;
01855     """
01856     pass
01857 
01858 
01859 def maCreateImageFromData(placeholder, data, offset, size):
01860     """__NATIVE__
01861     /* Wrapper generated for: */
01862     /*   int maCreateImageFromData(MAHandle placeholder, MAHandle data, int offset, int size); */
01863 
01864     PmReturn_t retval = PM_RET_OK;
01865 
01866     int func_retval;
01867     pPmObj_t p_func_retval = C_NULL;
01868 
01869     int placeholder;
01870     pPmObj_t p_placeholder = C_NULL;
01871 
01872     int data;
01873     pPmObj_t p_data = C_NULL;
01874 
01875     int offset;
01876     pPmObj_t p_offset = C_NULL;
01877 
01878     int size;
01879     pPmObj_t p_size = C_NULL;
01880 
01881     /* If wrong number of args, raise TypeError */
01882     if (NATIVE_GET_NUM_ARGS() != 4)
01883     {
01884         PM_RAISE(retval, PM_RET_EX_TYPE);
01885         return retval;
01886     }
01887 
01888     /* Raise TypeError if arg is not correct type */
01889     p_placeholder = NATIVE_GET_LOCAL(0);
01890     if (OBJ_GET_TYPE(p_placeholder) != OBJ_TYPE_INT)
01891     {
01892         PM_RAISE(retval, PM_RET_EX_TYPE);
01893         return retval;
01894     }
01895 
01896     /* Raise TypeError if arg is not correct type */
01897     p_data = NATIVE_GET_LOCAL(1);
01898     if (OBJ_GET_TYPE(p_data) != OBJ_TYPE_INT)
01899     {
01900         PM_RAISE(retval, PM_RET_EX_TYPE);
01901         return retval;
01902     }
01903 
01904     /* Raise TypeError if arg is not correct type */
01905     p_offset = NATIVE_GET_LOCAL(2);
01906     if (OBJ_GET_TYPE(p_offset) != OBJ_TYPE_INT)
01907     {
01908         PM_RAISE(retval, PM_RET_EX_TYPE);
01909         return retval;
01910     }
01911 
01912     /* Raise TypeError if arg is not correct type */
01913     p_size = NATIVE_GET_LOCAL(3);
01914     if (OBJ_GET_TYPE(p_size) != OBJ_TYPE_INT)
01915     {
01916         PM_RAISE(retval, PM_RET_EX_TYPE);
01917         return retval;
01918     }
01919 
01920     placeholder = ((pPmInt_t)p_placeholder)->val;
01921     data = ((pPmInt_t)p_data)->val;
01922     offset = ((pPmInt_t)p_offset)->val;
01923     size = ((pPmInt_t)p_size)->val;
01924 
01925     func_retval = maCreateImageFromData(placeholder, data, offset, size);
01926     retval = int_new(func_retval, &p_func_retval);
01927 
01928     NATIVE_SET_TOS(p_func_retval);
01929 
01930     return retval;
01931     """
01932     pass
01933 
01934 
01935 # No wrapper for
01936 #int maCreateImageRaw(MAHandle placeholder, const void* src, MAExtent size, int alpha);
01937 
01938 def maCreateDrawableImage(placeholder, width, height):
01939     """__NATIVE__
01940     /* Wrapper generated for: */
01941     /*   int maCreateDrawableImage(MAHandle placeholder, int width, int height); */
01942 
01943     PmReturn_t retval = PM_RET_OK;
01944 
01945     int func_retval;
01946     pPmObj_t p_func_retval = C_NULL;
01947 
01948     int placeholder;
01949     pPmObj_t p_placeholder = C_NULL;
01950 
01951     int width;
01952     pPmObj_t p_width = C_NULL;
01953 
01954     int height;
01955     pPmObj_t p_height = C_NULL;
01956 
01957     /* If wrong number of args, raise TypeError */
01958     if (NATIVE_GET_NUM_ARGS() != 3)
01959     {
01960         PM_RAISE(retval, PM_RET_EX_TYPE);
01961         return retval;
01962     }
01963 
01964     /* Raise TypeError if arg is not correct type */
01965     p_placeholder = NATIVE_GET_LOCAL(0);
01966     if (OBJ_GET_TYPE(p_placeholder) != OBJ_TYPE_INT)
01967     {
01968         PM_RAISE(retval, PM_RET_EX_TYPE);
01969         return retval;
01970     }
01971 
01972     /* Raise TypeError if arg is not correct type */
01973     p_width = NATIVE_GET_LOCAL(1);
01974     if (OBJ_GET_TYPE(p_width) != OBJ_TYPE_INT)
01975     {
01976         PM_RAISE(retval, PM_RET_EX_TYPE);
01977         return retval;
01978     }
01979 
01980     /* Raise TypeError if arg is not correct type */
01981     p_height = NATIVE_GET_LOCAL(2);
01982     if (OBJ_GET_TYPE(p_height) != OBJ_TYPE_INT)
01983     {
01984         PM_RAISE(retval, PM_RET_EX_TYPE);
01985         return retval;
01986     }
01987 
01988     placeholder = ((pPmInt_t)p_placeholder)->val;
01989     width = ((pPmInt_t)p_width)->val;
01990     height = ((pPmInt_t)p_height)->val;
01991 
01992     func_retval = maCreateDrawableImage(placeholder, width, height);
01993     retval = int_new(func_retval, &p_func_retval);
01994 
01995     NATIVE_SET_TOS(p_func_retval);
01996 
01997     return retval;
01998     """
01999     pass
02000 
02001 
02002 def maCreateData(placeholder, size):
02003     """__NATIVE__
02004     /* Wrapper generated for: */
02005     /*   int maCreateData(MAHandle placeholder, int size); */
02006 
02007     PmReturn_t retval = PM_RET_OK;
02008 
02009     int func_retval;
02010     pPmObj_t p_func_retval = C_NULL;
02011 
02012     int placeholder;
02013     pPmObj_t p_placeholder = C_NULL;
02014 
02015     int size;
02016     pPmObj_t p_size = C_NULL;
02017 
02018     /* If wrong number of args, raise TypeError */
02019     if (NATIVE_GET_NUM_ARGS() != 2)
02020     {
02021         PM_RAISE(retval, PM_RET_EX_TYPE);
02022         return retval;
02023     }
02024 
02025     /* Raise TypeError if arg is not correct type */
02026     p_placeholder = NATIVE_GET_LOCAL(0);
02027     if (OBJ_GET_TYPE(p_placeholder) != OBJ_TYPE_INT)
02028     {
02029         PM_RAISE(retval, PM_RET_EX_TYPE);
02030         return retval;
02031     }
02032 
02033     /* Raise TypeError if arg is not correct type */
02034     p_size = NATIVE_GET_LOCAL(1);
02035     if (OBJ_GET_TYPE(p_size) != OBJ_TYPE_INT)
02036     {
02037         PM_RAISE(retval, PM_RET_EX_TYPE);
02038         return retval;
02039     }
02040 
02041     placeholder = ((pPmInt_t)p_placeholder)->val;
02042     size = ((pPmInt_t)p_size)->val;
02043 
02044     func_retval = maCreateData(placeholder, size);
02045     retval = int_new(func_retval, &p_func_retval);
02046 
02047     NATIVE_SET_TOS(p_func_retval);
02048 
02049     return retval;
02050     """
02051     pass
02052 
02053 
02054 def maCreatePlaceholder():
02055     """__NATIVE__
02056     /* Wrapper generated for: */
02057     /*   MAHandle maCreatePlaceholder(void); */
02058 
02059     PmReturn_t retval = PM_RET_OK;
02060 
02061     int func_retval;
02062     pPmObj_t p_func_retval = C_NULL;
02063 
02064     /* If wrong number of args, raise TypeError */
02065     if (NATIVE_GET_NUM_ARGS() != 0)
02066     {
02067         PM_RAISE(retval, PM_RET_EX_TYPE);
02068         return retval;
02069     }
02070 
02071 
02072     func_retval = maCreatePlaceholder();
02073     retval = int_new(func_retval, &p_func_retval);
02074 
02075     NATIVE_SET_TOS(p_func_retval);
02076 
02077     return retval;
02078     """
02079     pass
02080 
02081 
02082 def maDestroyObject(handle):
02083     """__NATIVE__
02084     /* Wrapper generated for: */
02085     /*   void maDestroyObject(MAHandle handle); */
02086 
02087     PmReturn_t retval = PM_RET_OK;
02088 
02089     pPmObj_t p_func_retval = C_NULL;
02090 
02091     int handle;
02092     pPmObj_t p_handle = C_NULL;
02093 
02094     /* If wrong number of args, raise TypeError */
02095     if (NATIVE_GET_NUM_ARGS() != 1)
02096     {
02097         PM_RAISE(retval, PM_RET_EX_TYPE);
02098         return retval;
02099     }
02100 
02101     /* Raise TypeError if arg is not correct type */
02102     p_handle = NATIVE_GET_LOCAL(0);
02103     if (OBJ_GET_TYPE(p_handle) != OBJ_TYPE_INT)
02104     {
02105         PM_RAISE(retval, PM_RET_EX_TYPE);
02106         return retval;
02107     }
02108 
02109     handle = ((pPmInt_t)p_handle)->val;
02110 
02111     maDestroyObject(handle);
02112 
02113     NATIVE_SET_TOS(PM_NONE);
02114 
02115     return retval;
02116     """
02117     pass
02118 
02119 
02120 def maGetDataSize(data):
02121     """__NATIVE__
02122     /* Wrapper generated for: */
02123     /*   int maGetDataSize(MAHandle data); */
02124 
02125     PmReturn_t retval = PM_RET_OK;
02126 
02127     int func_retval;
02128     pPmObj_t p_func_retval = C_NULL;
02129 
02130     int data;
02131     pPmObj_t p_data = C_NULL;
02132 
02133     /* If wrong number of args, raise TypeError */
02134     if (NATIVE_GET_NUM_ARGS() != 1)
02135     {
02136         PM_RAISE(retval, PM_RET_EX_TYPE);
02137         return retval;
02138     }
02139 
02140     /* Raise TypeError if arg is not correct type */
02141     p_data = NATIVE_GET_LOCAL(0);
02142     if (OBJ_GET_TYPE(p_data) != OBJ_TYPE_INT)
02143     {
02144         PM_RAISE(retval, PM_RET_EX_TYPE);
02145         return retval;
02146     }
02147 
02148     data = ((pPmInt_t)p_data)->val;
02149 
02150     func_retval = maGetDataSize(data);
02151     retval = int_new(func_retval, &p_func_retval);
02152 
02153     NATIVE_SET_TOS(p_func_retval);
02154 
02155     return retval;
02156     """
02157     pass
02158 
02159 
02160 # No wrapper for
02161 #void maReadData(MAHandle data, void* dst, int offset, int size);
02162 
02163 # No wrapper for
02164 #void maWriteData(MAHandle data, const void* src, int offset, int size);
02165 
02166 # No wrapper for
02167 #void maCopyData(const MACopyData* params);
02168 
02169 def maOpenStore(name, flags):
02170     """__NATIVE__
02171     /* Wrapper generated for: */
02172     /*   MAHandle maOpenStore(const char* name, int flags); */
02173 
02174     PmReturn_t retval = PM_RET_OK;
02175 
02176     int func_retval;
02177     pPmObj_t p_func_retval = C_NULL;
02178 
02179     const char* name;
02180     pPmObj_t p_name = C_NULL;
02181 
02182     int flags;
02183     pPmObj_t p_flags = C_NULL;
02184 
02185     /* If wrong number of args, raise TypeError */
02186     if (NATIVE_GET_NUM_ARGS() != 2)
02187     {
02188         PM_RAISE(retval, PM_RET_EX_TYPE);
02189         return retval;
02190     }
02191 
02192     /* Raise TypeError if arg is not correct type */
02193     p_name = NATIVE_GET_LOCAL(0);
02194     if (OBJ_GET_TYPE(p_name) != OBJ_TYPE_STR)
02195     {
02196         PM_RAISE(retval, PM_RET_EX_TYPE);
02197         return retval;
02198     }
02199 
02200     /* Raise TypeError if arg is not correct type */
02201     p_flags = NATIVE_GET_LOCAL(1);
02202     if (OBJ_GET_TYPE(p_flags) != OBJ_TYPE_INT)
02203     {
02204         PM_RAISE(retval, PM_RET_EX_TYPE);
02205         return retval;
02206     }
02207 
02208     name = (char const *)&(((pPmString_t)p_name)->val);
02209     flags = ((pPmInt_t)p_flags)->val;
02210 
02211     func_retval = maOpenStore(name, flags);
02212     retval = int_new(func_retval, &p_func_retval);
02213 
02214     NATIVE_SET_TOS(p_func_retval);
02215 
02216     return retval;
02217     """
02218     pass
02219 
02220 
02221 def maWriteStore(store, data):
02222     """__NATIVE__
02223     /* Wrapper generated for: */
02224     /*   int maWriteStore(MAHandle store, MAHandle data); */
02225 
02226     PmReturn_t retval = PM_RET_OK;
02227 
02228     int func_retval;
02229     pPmObj_t p_func_retval = C_NULL;
02230 
02231     int store;
02232     pPmObj_t p_store = C_NULL;
02233 
02234     int data;
02235     pPmObj_t p_data = C_NULL;
02236 
02237     /* If wrong number of args, raise TypeError */
02238     if (NATIVE_GET_NUM_ARGS() != 2)
02239     {
02240         PM_RAISE(retval, PM_RET_EX_TYPE);
02241         return retval;
02242     }
02243 
02244     /* Raise TypeError if arg is not correct type */
02245     p_store = NATIVE_GET_LOCAL(0);
02246     if (OBJ_GET_TYPE(p_store) != OBJ_TYPE_INT)
02247     {
02248         PM_RAISE(retval, PM_RET_EX_TYPE);
02249         return retval;
02250     }
02251 
02252     /* Raise TypeError if arg is not correct type */
02253     p_data = NATIVE_GET_LOCAL(1);
02254     if (OBJ_GET_TYPE(p_data) != OBJ_TYPE_INT)
02255     {
02256         PM_RAISE(retval, PM_RET_EX_TYPE);
02257         return retval;
02258     }
02259 
02260     store = ((pPmInt_t)p_store)->val;
02261     data = ((pPmInt_t)p_data)->val;
02262 
02263     func_retval = maWriteStore(store, data);
02264     retval = int_new(func_retval, &p_func_retval);
02265 
02266     NATIVE_SET_TOS(p_func_retval);
02267 
02268     return retval;
02269     """
02270     pass
02271 
02272 
02273 def maReadStore(store, placeholder):
02274     """__NATIVE__
02275     /* Wrapper generated for: */
02276     /*   int maReadStore(MAHandle store, MAHandle placeholder); */
02277 
02278     PmReturn_t retval = PM_RET_OK;
02279 
02280     int func_retval;
02281     pPmObj_t p_func_retval = C_NULL;
02282 
02283     int store;
02284     pPmObj_t p_store = C_NULL;
02285 
02286     int placeholder;
02287     pPmObj_t p_placeholder = C_NULL;
02288 
02289     /* If wrong number of args, raise TypeError */
02290     if (NATIVE_GET_NUM_ARGS() != 2)
02291     {
02292         PM_RAISE(retval, PM_RET_EX_TYPE);
02293         return retval;
02294     }
02295 
02296     /* Raise TypeError if arg is not correct type */
02297     p_store = NATIVE_GET_LOCAL(0);
02298     if (OBJ_GET_TYPE(p_store) != OBJ_TYPE_INT)
02299     {
02300         PM_RAISE(retval, PM_RET_EX_TYPE);
02301         return retval;
02302     }
02303 
02304     /* Raise TypeError if arg is not correct type */
02305     p_placeholder = NATIVE_GET_LOCAL(1);
02306     if (OBJ_GET_TYPE(p_placeholder) != OBJ_TYPE_INT)
02307     {
02308         PM_RAISE(retval, PM_RET_EX_TYPE);
02309         return retval;
02310     }
02311 
02312     store = ((pPmInt_t)p_store)->val;
02313     placeholder = ((pPmInt_t)p_placeholder)->val;
02314 
02315     func_retval = maReadStore(store, placeholder);
02316     retval = int_new(func_retval, &p_func_retval);
02317 
02318     NATIVE_SET_TOS(p_func_retval);
02319 
02320     return retval;
02321     """
02322     pass
02323 
02324 
02325 def maCloseStore(store, _remove):
02326     """__NATIVE__
02327     /* Wrapper generated for: */
02328     /*   void maCloseStore(MAHandle store, int _remove); */
02329 
02330     PmReturn_t retval = PM_RET_OK;
02331 
02332     pPmObj_t p_func_retval = C_NULL;
02333 
02334     int store;
02335     pPmObj_t p_store = C_NULL;
02336 
02337     int _remove;
02338     pPmObj_t p__remove = C_NULL;
02339 
02340     /* If wrong number of args, raise TypeError */
02341     if (NATIVE_GET_NUM_ARGS() != 2)
02342     {
02343         PM_RAISE(retval, PM_RET_EX_TYPE);
02344         return retval;
02345     }
02346 
02347     /* Raise TypeError if arg is not correct type */
02348     p_store = NATIVE_GET_LOCAL(0);
02349     if (OBJ_GET_TYPE(p_store) != OBJ_TYPE_INT)
02350     {
02351         PM_RAISE(retval, PM_RET_EX_TYPE);
02352         return retval;
02353     }
02354 
02355     /* Raise TypeError if arg is not correct type */
02356     p__remove = NATIVE_GET_LOCAL(1);
02357     if (OBJ_GET_TYPE(p__remove) != OBJ_TYPE_INT)
02358     {
02359         PM_RAISE(retval, PM_RET_EX_TYPE);
02360         return retval;
02361     }
02362 
02363     store = ((pPmInt_t)p_store)->val;
02364     _remove = ((pPmInt_t)p__remove)->val;
02365 
02366     maCloseStore(store, _remove);
02367 
02368     NATIVE_SET_TOS(PM_NONE);
02369 
02370     return retval;
02371     """
02372     pass
02373 
02374 
02375 def maConnect(url):
02376     """__NATIVE__
02377     /* Wrapper generated for: */
02378     /*   MAHandle maConnect(const char* url); */
02379 
02380     PmReturn_t retval = PM_RET_OK;
02381 
02382     int func_retval;
02383     pPmObj_t p_func_retval = C_NULL;
02384 
02385     const char* url;
02386     pPmObj_t p_url = C_NULL;
02387 
02388     /* If wrong number of args, raise TypeError */
02389     if (NATIVE_GET_NUM_ARGS() != 1)
02390     {
02391         PM_RAISE(retval, PM_RET_EX_TYPE);
02392         return retval;
02393     }
02394 
02395     /* Raise TypeError if arg is not correct type */
02396     p_url = NATIVE_GET_LOCAL(0);
02397     if (OBJ_GET_TYPE(p_url) != OBJ_TYPE_STR)
02398     {
02399         PM_RAISE(retval, PM_RET_EX_TYPE);
02400         return retval;
02401     }
02402 
02403     url = (char const *)&(((pPmString_t)p_url)->val);
02404 
02405     func_retval = maConnect(url);
02406     retval = int_new(func_retval, &p_func_retval);
02407 
02408     NATIVE_SET_TOS(p_func_retval);
02409 
02410     return retval;
02411     """
02412     pass
02413 
02414 
02415 def maConnClose(conn):
02416     """__NATIVE__
02417     /* Wrapper generated for: */
02418     /*   void maConnClose(MAHandle conn); */
02419 
02420     PmReturn_t retval = PM_RET_OK;
02421 
02422     pPmObj_t p_func_retval = C_NULL;
02423 
02424     int conn;
02425     pPmObj_t p_conn = C_NULL;
02426 
02427     /* If wrong number of args, raise TypeError */
02428     if (NATIVE_GET_NUM_ARGS() != 1)
02429     {
02430         PM_RAISE(retval, PM_RET_EX_TYPE);
02431         return retval;
02432     }
02433 
02434     /* Raise TypeError if arg is not correct type */
02435     p_conn = NATIVE_GET_LOCAL(0);
02436     if (OBJ_GET_TYPE(p_conn) != OBJ_TYPE_INT)
02437     {
02438         PM_RAISE(retval, PM_RET_EX_TYPE);
02439         return retval;
02440     }
02441 
02442     conn = ((pPmInt_t)p_conn)->val;
02443 
02444     maConnClose(conn);
02445 
02446     NATIVE_SET_TOS(PM_NONE);
02447 
02448     return retval;
02449     """
02450     pass
02451 
02452 
02453 # No wrapper for
02454 #void maConnRead(MAHandle conn, void* dst, int size);
02455 
02456 # No wrapper for
02457 #void maConnWrite(MAHandle conn, const void* src, int size);
02458 
02459 def maConnReadToData(conn, data, offset, size):
02460     """__NATIVE__
02461     /* Wrapper generated for: */
02462     /*   void maConnReadToData(MAHandle conn, MAHandle data, int offset, int size); */
02463 
02464     PmReturn_t retval = PM_RET_OK;
02465 
02466     pPmObj_t p_func_retval = C_NULL;
02467 
02468     int conn;
02469     pPmObj_t p_conn = C_NULL;
02470 
02471     int data;
02472     pPmObj_t p_data = C_NULL;
02473 
02474     int offset;
02475     pPmObj_t p_offset = C_NULL;
02476 
02477     int size;
02478     pPmObj_t p_size = C_NULL;
02479 
02480     /* If wrong number of args, raise TypeError */
02481     if (NATIVE_GET_NUM_ARGS() != 4)
02482     {
02483         PM_RAISE(retval, PM_RET_EX_TYPE);
02484         return retval;
02485     }
02486 
02487     /* Raise TypeError if arg is not correct type */
02488     p_conn = NATIVE_GET_LOCAL(0);
02489     if (OBJ_GET_TYPE(p_conn) != OBJ_TYPE_INT)
02490     {
02491         PM_RAISE(retval, PM_RET_EX_TYPE);
02492         return retval;
02493     }
02494 
02495     /* Raise TypeError if arg is not correct type */
02496     p_data = NATIVE_GET_LOCAL(1);
02497     if (OBJ_GET_TYPE(p_data) != OBJ_TYPE_INT)
02498     {
02499         PM_RAISE(retval, PM_RET_EX_TYPE);
02500         return retval;
02501     }
02502 
02503     /* Raise TypeError if arg is not correct type */
02504     p_offset = NATIVE_GET_LOCAL(2);
02505     if (OBJ_GET_TYPE(p_offset) != OBJ_TYPE_INT)
02506     {
02507         PM_RAISE(retval, PM_RET_EX_TYPE);
02508         return retval;
02509     }
02510 
02511     /* Raise TypeError if arg is not correct type */
02512     p_size = NATIVE_GET_LOCAL(3);
02513     if (OBJ_GET_TYPE(p_size) != OBJ_TYPE_INT)
02514     {
02515         PM_RAISE(retval, PM_RET_EX_TYPE);
02516         return retval;
02517     }
02518 
02519     conn = ((pPmInt_t)p_conn)->val;
02520     data = ((pPmInt_t)p_data)->val;
02521     offset = ((pPmInt_t)p_offset)->val;
02522     size = ((pPmInt_t)p_size)->val;
02523 
02524     maConnReadToData(conn, data, offset, size);
02525 
02526     NATIVE_SET_TOS(PM_NONE);
02527 
02528     return retval;
02529     """
02530     pass
02531 
02532 
02533 def maConnWriteFromData(conn, data, offset, size):
02534     """__NATIVE__
02535     /* Wrapper generated for: */
02536     /*   void maConnWriteFromData(MAHandle conn, MAHandle data, int offset, int size); */
02537 
02538     PmReturn_t retval = PM_RET_OK;
02539 
02540     pPmObj_t p_func_retval = C_NULL;
02541 
02542     int conn;
02543     pPmObj_t p_conn = C_NULL;
02544 
02545     int data;
02546     pPmObj_t p_data = C_NULL;
02547 
02548     int offset;
02549     pPmObj_t p_offset = C_NULL;
02550 
02551     int size;
02552     pPmObj_t p_size = C_NULL;
02553 
02554     /* If wrong number of args, raise TypeError */
02555     if (NATIVE_GET_NUM_ARGS() != 4)
02556     {
02557         PM_RAISE(retval, PM_RET_EX_TYPE);
02558         return retval;
02559     }
02560 
02561     /* Raise TypeError if arg is not correct type */
02562     p_conn = NATIVE_GET_LOCAL(0);
02563     if (OBJ_GET_TYPE(p_conn) != OBJ_TYPE_INT)
02564     {
02565         PM_RAISE(retval, PM_RET_EX_TYPE);
02566         return retval;
02567     }
02568 
02569     /* Raise TypeError if arg is not correct type */
02570     p_data = NATIVE_GET_LOCAL(1);
02571     if (OBJ_GET_TYPE(p_data) != OBJ_TYPE_INT)
02572     {
02573         PM_RAISE(retval, PM_RET_EX_TYPE);
02574         return retval;
02575     }
02576 
02577     /* Raise TypeError if arg is not correct type */
02578     p_offset = NATIVE_GET_LOCAL(2);
02579     if (OBJ_GET_TYPE(p_offset) != OBJ_TYPE_INT)
02580     {
02581         PM_RAISE(retval, PM_RET_EX_TYPE);
02582         return retval;
02583     }
02584 
02585     /* Raise TypeError if arg is not correct type */
02586     p_size = NATIVE_GET_LOCAL(3);
02587     if (OBJ_GET_TYPE(p_size) != OBJ_TYPE_INT)
02588     {
02589         PM_RAISE(retval, PM_RET_EX_TYPE);
02590         return retval;
02591     }
02592 
02593     conn = ((pPmInt_t)p_conn)->val;
02594     data = ((pPmInt_t)p_data)->val;
02595     offset = ((pPmInt_t)p_offset)->val;
02596     size = ((pPmInt_t)p_size)->val;
02597 
02598     maConnWriteFromData(conn, data, offset, size);
02599 
02600     NATIVE_SET_TOS(PM_NONE);
02601 
02602     return retval;
02603     """
02604     pass
02605 
02606 
02607 # No wrapper for
02608 #int maConnGetAddr(MAHandle conn, MAConnAddr* addr);
02609 
02610 def maHttpCreate(url, method):
02611     """__NATIVE__
02612     /* Wrapper generated for: */
02613     /*   MAHandle maHttpCreate(const char* url, int method); */
02614 
02615     PmReturn_t retval = PM_RET_OK;
02616 
02617     int func_retval;
02618     pPmObj_t p_func_retval = C_NULL;
02619 
02620     const char* url;
02621     pPmObj_t p_url = C_NULL;
02622 
02623     int method;
02624     pPmObj_t p_method = C_NULL;
02625 
02626     /* If wrong number of args, raise TypeError */
02627     if (NATIVE_GET_NUM_ARGS() != 2)
02628     {
02629         PM_RAISE(retval, PM_RET_EX_TYPE);
02630         return retval;
02631     }
02632 
02633     /* Raise TypeError if arg is not correct type */
02634     p_url = NATIVE_GET_LOCAL(0);
02635     if (OBJ_GET_TYPE(p_url) != OBJ_TYPE_STR)
02636     {
02637         PM_RAISE(retval, PM_RET_EX_TYPE);
02638         return retval;
02639     }
02640 
02641     /* Raise TypeError if arg is not correct type */
02642     p_method = NATIVE_GET_LOCAL(1);
02643     if (OBJ_GET_TYPE(p_method) != OBJ_TYPE_INT)
02644     {
02645         PM_RAISE(retval, PM_RET_EX_TYPE);
02646         return retval;
02647     }
02648 
02649     url = (char const *)&(((pPmString_t)p_url)->val);
02650     method = ((pPmInt_t)p_method)->val;
02651 
02652     func_retval = maHttpCreate(url, method);
02653     retval = int_new(func_retval, &p_func_retval);
02654 
02655     NATIVE_SET_TOS(p_func_retval);
02656 
02657     return retval;
02658     """
02659     pass
02660 
02661 
02662 def maHttpSetRequestHeader(conn, key, value):
02663     """__NATIVE__
02664     /* Wrapper generated for: */
02665     /*   void maHttpSetRequestHeader(MAHandle conn, const char* key, const char* value); */
02666 
02667     PmReturn_t retval = PM_RET_OK;
02668 
02669     pPmObj_t p_func_retval = C_NULL;
02670 
02671     int conn;
02672     pPmObj_t p_conn = C_NULL;
02673 
02674     const char* key;
02675     pPmObj_t p_key = C_NULL;
02676 
02677     const char* value;
02678     pPmObj_t p_value = C_NULL;
02679 
02680     /* If wrong number of args, raise TypeError */
02681     if (NATIVE_GET_NUM_ARGS() != 3)
02682     {
02683         PM_RAISE(retval, PM_RET_EX_TYPE);
02684         return retval;
02685     }
02686 
02687     /* Raise TypeError if arg is not correct type */
02688     p_conn = NATIVE_GET_LOCAL(0);
02689     if (OBJ_GET_TYPE(p_conn) != OBJ_TYPE_INT)
02690     {
02691         PM_RAISE(retval, PM_RET_EX_TYPE);
02692         return retval;
02693     }
02694 
02695     /* Raise TypeError if arg is not correct type */
02696     p_key = NATIVE_GET_LOCAL(1);
02697     if (OBJ_GET_TYPE(p_key) != OBJ_TYPE_STR)
02698     {
02699         PM_RAISE(retval, PM_RET_EX_TYPE);
02700         return retval;
02701     }
02702 
02703     /* Raise TypeError if arg is not correct type */
02704     p_value = NATIVE_GET_LOCAL(2);
02705     if (OBJ_GET_TYPE(p_value) != OBJ_TYPE_STR)
02706     {
02707         PM_RAISE(retval, PM_RET_EX_TYPE);
02708         return retval;
02709     }
02710 
02711     conn = ((pPmInt_t)p_conn)->val;
02712     key = (char const *)&(((pPmString_t)p_key)->val);
02713     value = (char const *)&(((pPmString_t)p_value)->val);
02714 
02715     maHttpSetRequestHeader(conn, key, value);
02716 
02717     NATIVE_SET_TOS(PM_NONE);
02718 
02719     return retval;
02720     """
02721     pass
02722 
02723 
02724 # No wrapper for
02725 #int maHttpGetResponseHeader(MAHandle conn, const char* key, char* buffer, int bufSize);
02726 
02727 def maHttpFinish(conn):
02728     """__NATIVE__
02729     /* Wrapper generated for: */
02730     /*   void maHttpFinish(MAHandle conn); */
02731 
02732     PmReturn_t retval = PM_RET_OK;
02733 
02734     pPmObj_t p_func_retval = C_NULL;
02735 
02736     int conn;
02737     pPmObj_t p_conn = C_NULL;
02738 
02739     /* If wrong number of args, raise TypeError */
02740     if (NATIVE_GET_NUM_ARGS() != 1)
02741     {
02742         PM_RAISE(retval, PM_RET_EX_TYPE);
02743         return retval;
02744     }
02745 
02746     /* Raise TypeError if arg is not correct type */
02747     p_conn = NATIVE_GET_LOCAL(0);
02748     if (OBJ_GET_TYPE(p_conn) != OBJ_TYPE_INT)
02749     {
02750         PM_RAISE(retval, PM_RET_EX_TYPE);
02751         return retval;
02752     }
02753 
02754     conn = ((pPmInt_t)p_conn)->val;
02755 
02756     maHttpFinish(conn);
02757 
02758     NATIVE_SET_TOS(PM_NONE);
02759 
02760     return retval;
02761     """
02762     pass
02763 
02764 
02765 def maLoadResources(data):
02766     """__NATIVE__
02767     /* Wrapper generated for: */
02768     /*   int maLoadResources(MAHandle data); */
02769 
02770     PmReturn_t retval = PM_RET_OK;
02771 
02772     int func_retval;
02773     pPmObj_t p_func_retval = C_NULL;
02774 
02775     int data;
02776     pPmObj_t p_data = C_NULL;
02777 
02778     /* If wrong number of args, raise TypeError */
02779     if (NATIVE_GET_NUM_ARGS() != 1)
02780     {
02781         PM_RAISE(retval, PM_RET_EX_TYPE);
02782         return retval;
02783     }
02784 
02785     /* Raise TypeError if arg is not correct type */
02786     p_data = NATIVE_GET_LOCAL(0);
02787     if (OBJ_GET_TYPE(p_data) != OBJ_TYPE_INT)
02788     {
02789         PM_RAISE(retval, PM_RET_EX_TYPE);
02790         return retval;
02791     }
02792 
02793     data = ((pPmInt_t)p_data)->val;
02794 
02795     func_retval = maLoadResources(data);
02796     retval = int_new(func_retval, &p_func_retval);
02797 
02798     NATIVE_SET_TOS(p_func_retval);
02799 
02800     return retval;
02801     """
02802     pass
02803 
02804 
02805 def maLoadProgram(data, reload):
02806     """__NATIVE__
02807     /* Wrapper generated for: */
02808     /*   void maLoadProgram(MAHandle data, int reload); */
02809 
02810     PmReturn_t retval = PM_RET_OK;
02811 
02812     pPmObj_t p_func_retval = C_NULL;
02813 
02814     int data;
02815     pPmObj_t p_data = C_NULL;
02816 
02817     int reload;
02818     pPmObj_t p_reload = C_NULL;
02819 
02820     /* If wrong number of args, raise TypeError */
02821     if (NATIVE_GET_NUM_ARGS() != 2)
02822     {
02823         PM_RAISE(retval, PM_RET_EX_TYPE);
02824         return retval;
02825     }
02826 
02827     /* Raise TypeError if arg is not correct type */
02828     p_data = NATIVE_GET_LOCAL(0);
02829     if (OBJ_GET_TYPE(p_data) != OBJ_TYPE_INT)
02830     {
02831         PM_RAISE(retval, PM_RET_EX_TYPE);
02832         return retval;
02833     }
02834 
02835     /* Raise TypeError if arg is not correct type */
02836     p_reload = NATIVE_GET_LOCAL(1);
02837     if (OBJ_GET_TYPE(p_reload) != OBJ_TYPE_INT)
02838     {
02839         PM_RAISE(retval, PM_RET_EX_TYPE);
02840         return retval;
02841     }
02842 
02843     data = ((pPmInt_t)p_data)->val;
02844     reload = ((pPmInt_t)p_reload)->val;
02845 
02846     maLoadProgram(data, reload);
02847 
02848     NATIVE_SET_TOS(PM_NONE);
02849 
02850     return retval;
02851     """
02852     pass
02853 
02854 
02855 def maGetKeys():
02856     """__NATIVE__
02857     /* Wrapper generated for: */
02858     /*   int maGetKeys(void); */
02859 
02860     PmReturn_t retval = PM_RET_OK;
02861 
02862     int func_retval;
02863     pPmObj_t p_func_retval = C_NULL;
02864 
02865     /* If wrong number of args, raise TypeError */
02866     if (NATIVE_GET_NUM_ARGS() != 0)
02867     {
02868         PM_RAISE(retval, PM_RET_EX_TYPE);
02869         return retval;
02870     }
02871 
02872 
02873     func_retval = maGetKeys();
02874     retval = int_new(func_retval, &p_func_retval);
02875 
02876     NATIVE_SET_TOS(p_func_retval);
02877 
02878     return retval;
02879     """
02880     pass
02881 
02882 
02883 # No wrapper for
02884 #int maGetEvent(MAEvent* event);
02885 
02886 def maWait(timeout):
02887     """__NATIVE__
02888     /* Wrapper generated for: */
02889     /*   void maWait(int timeout); */
02890 
02891     PmReturn_t retval = PM_RET_OK;
02892 
02893     pPmObj_t p_func_retval = C_NULL;
02894 
02895     int timeout;
02896     pPmObj_t p_timeout = C_NULL;
02897 
02898     /* If wrong number of args, raise TypeError */
02899     if (NATIVE_GET_NUM_ARGS() != 1)
02900     {
02901         PM_RAISE(retval, PM_RET_EX_TYPE);
02902         return retval;
02903     }
02904 
02905     /* Raise TypeError if arg is not correct type */
02906     p_timeout = NATIVE_GET_LOCAL(0);
02907     if (OBJ_GET_TYPE(p_timeout) != OBJ_TYPE_INT)
02908     {
02909         PM_RAISE(retval, PM_RET_EX_TYPE);
02910         return retval;
02911     }
02912 
02913     timeout = ((pPmInt_t)p_timeout)->val;
02914 
02915     maWait(timeout);
02916 
02917     NATIVE_SET_TOS(PM_NONE);
02918 
02919     return retval;
02920     """
02921     pass
02922 
02923 
02924 def maTime():
02925     """__NATIVE__
02926     /* Wrapper generated for: */
02927     /*   int maTime(void); */
02928 
02929     PmReturn_t retval = PM_RET_OK;
02930 
02931     int func_retval;
02932     pPmObj_t p_func_retval = C_NULL;
02933 
02934     /* If wrong number of args, raise TypeError */
02935     if (NATIVE_GET_NUM_ARGS() != 0)
02936     {
02937         PM_RAISE(retval, PM_RET_EX_TYPE);
02938         return retval;
02939     }
02940 
02941 
02942     func_retval = maTime();
02943     retval = int_new(func_retval, &p_func_retval);
02944 
02945     NATIVE_SET_TOS(p_func_retval);
02946 
02947     return retval;
02948     """
02949     pass
02950 
02951 
02952 def maLocalTime():
02953     """__NATIVE__
02954     /* Wrapper generated for: */
02955     /*   int maLocalTime(void); */
02956 
02957     PmReturn_t retval = PM_RET_OK;
02958 
02959     int func_retval;
02960     pPmObj_t p_func_retval = C_NULL;
02961 
02962     /* If wrong number of args, raise TypeError */
02963     if (NATIVE_GET_NUM_ARGS() != 0)
02964     {
02965         PM_RAISE(retval, PM_RET_EX_TYPE);
02966         return retval;
02967     }
02968 
02969 
02970     func_retval = maLocalTime();
02971     retval = int_new(func_retval, &p_func_retval);
02972 
02973     NATIVE_SET_TOS(p_func_retval);
02974 
02975     return retval;
02976     """
02977     pass
02978 
02979 
02980 def maGetMilliSecondCount():
02981     """__NATIVE__
02982     /* Wrapper generated for: */
02983     /*   int maGetMilliSecondCount(void); */
02984 
02985     PmReturn_t retval = PM_RET_OK;
02986 
02987     int func_retval;
02988     pPmObj_t p_func_retval = C_NULL;
02989 
02990     /* If wrong number of args, raise TypeError */
02991     if (NATIVE_GET_NUM_ARGS() != 0)
02992     {
02993         PM_RAISE(retval, PM_RET_EX_TYPE);
02994         return retval;
02995     }
02996 
02997 
02998     func_retval = maGetMilliSecondCount();
02999     retval = int_new(func_retval, &p_func_retval);
03000 
03001     NATIVE_SET_TOS(p_func_retval);
03002 
03003     return retval;
03004     """
03005     pass
03006 
03007 
03008 def maFreeObjectMemory():
03009     """__NATIVE__
03010     /* Wrapper generated for: */
03011     /*   int maFreeObjectMemory(void); */
03012 
03013     PmReturn_t retval = PM_RET_OK;
03014 
03015     int func_retval;
03016     pPmObj_t p_func_retval = C_NULL;
03017 
03018     /* If wrong number of args, raise TypeError */
03019     if (NATIVE_GET_NUM_ARGS() != 0)
03020     {
03021         PM_RAISE(retval, PM_RET_EX_TYPE);
03022         return retval;
03023     }
03024 
03025 
03026     func_retval = maFreeObjectMemory();
03027     retval = int_new(func_retval, &p_func_retval);
03028 
03029     NATIVE_SET_TOS(p_func_retval);
03030 
03031     return retval;
03032     """
03033     pass
03034 
03035 
03036 def maTotalObjectMemory():
03037     """__NATIVE__
03038     /* Wrapper generated for: */
03039     /*   int maTotalObjectMemory(void); */
03040 
03041     PmReturn_t retval = PM_RET_OK;
03042 
03043     int func_retval;
03044     pPmObj_t p_func_retval = C_NULL;
03045 
03046     /* If wrong number of args, raise TypeError */
03047     if (NATIVE_GET_NUM_ARGS() != 0)
03048     {
03049         PM_RAISE(retval, PM_RET_EX_TYPE);
03050         return retval;
03051     }
03052 
03053 
03054     func_retval = maTotalObjectMemory();
03055     retval = int_new(func_retval, &p_func_retval);
03056 
03057     NATIVE_SET_TOS(p_func_retval);
03058 
03059     return retval;
03060     """
03061     pass
03062 
03063 
03064 def maVibrate(ms):
03065     """__NATIVE__
03066     /* Wrapper generated for: */
03067     /*   int maVibrate(int ms); */
03068 
03069     PmReturn_t retval = PM_RET_OK;
03070 
03071     int func_retval;
03072     pPmObj_t p_func_retval = C_NULL;
03073 
03074     int ms;
03075     pPmObj_t p_ms = C_NULL;
03076 
03077     /* If wrong number of args, raise TypeError */
03078     if (NATIVE_GET_NUM_ARGS() != 1)
03079     {
03080         PM_RAISE(retval, PM_RET_EX_TYPE);
03081         return retval;
03082     }
03083 
03084     /* Raise TypeError if arg is not correct type */
03085     p_ms = NATIVE_GET_LOCAL(0);
03086     if (OBJ_GET_TYPE(p_ms) != OBJ_TYPE_INT)
03087     {
03088         PM_RAISE(retval, PM_RET_EX_TYPE);
03089         return retval;
03090     }
03091 
03092     ms = ((pPmInt_t)p_ms)->val;
03093 
03094     func_retval = maVibrate(ms);
03095     retval = int_new(func_retval, &p_func_retval);
03096 
03097     NATIVE_SET_TOS(p_func_retval);
03098 
03099     return retval;
03100     """
03101     pass
03102 
03103 
03104 def maSoundPlay(sound_res, offset, size):
03105     """__NATIVE__
03106     /* Wrapper generated for: */
03107     /*   int maSoundPlay(MAHandle sound_res, int offset, int size); */
03108 
03109     PmReturn_t retval = PM_RET_OK;
03110 
03111     int func_retval;
03112     pPmObj_t p_func_retval = C_NULL;
03113 
03114     int sound_res;
03115     pPmObj_t p_sound_res = C_NULL;
03116 
03117     int offset;
03118     pPmObj_t p_offset = C_NULL;
03119 
03120     int size;
03121     pPmObj_t p_size = C_NULL;
03122 
03123     /* If wrong number of args, raise TypeError */
03124     if (NATIVE_GET_NUM_ARGS() != 3)
03125     {
03126         PM_RAISE(retval, PM_RET_EX_TYPE);
03127         return retval;
03128     }
03129 
03130     /* Raise TypeError if arg is not correct type */
03131     p_sound_res = NATIVE_GET_LOCAL(0);
03132     if (OBJ_GET_TYPE(p_sound_res) != OBJ_TYPE_INT)
03133     {
03134         PM_RAISE(retval, PM_RET_EX_TYPE);
03135         return retval;
03136     }
03137 
03138     /* Raise TypeError if arg is not correct type */
03139     p_offset = NATIVE_GET_LOCAL(1);
03140     if (OBJ_GET_TYPE(p_offset) != OBJ_TYPE_INT)
03141     {
03142         PM_RAISE(retval, PM_RET_EX_TYPE);
03143         return retval;
03144     }
03145 
03146     /* Raise TypeError if arg is not correct type */
03147     p_size = NATIVE_GET_LOCAL(2);
03148     if (OBJ_GET_TYPE(p_size) != OBJ_TYPE_INT)
03149     {
03150         PM_RAISE(retval, PM_RET_EX_TYPE);
03151         return retval;
03152     }
03153 
03154     sound_res = ((pPmInt_t)p_sound_res)->val;
03155     offset = ((pPmInt_t)p_offset)->val;
03156     size = ((pPmInt_t)p_size)->val;
03157 
03158     func_retval = maSoundPlay(sound_res, offset, size);
03159     retval = int_new(func_retval, &p_func_retval);
03160 
03161     NATIVE_SET_TOS(p_func_retval);
03162 
03163     return retval;
03164     """
03165     pass
03166 
03167 
03168 def maSoundStop():
03169     """__NATIVE__
03170     /* Wrapper generated for: */
03171     /*   void maSoundStop(void); */
03172 
03173     PmReturn_t retval = PM_RET_OK;
03174 
03175     pPmObj_t p_func_retval = C_NULL;
03176 
03177     /* If wrong number of args, raise TypeError */
03178     if (NATIVE_GET_NUM_ARGS() != 0)
03179     {
03180         PM_RAISE(retval, PM_RET_EX_TYPE);
03181         return retval;
03182     }
03183 
03184 
03185     maSoundStop();
03186 
03187     NATIVE_SET_TOS(PM_NONE);
03188 
03189     return retval;
03190     """
03191     pass
03192 
03193 
03194 def maSoundIsPlaying():
03195     """__NATIVE__
03196     /* Wrapper generated for: */
03197     /*   int maSoundIsPlaying(void); */
03198 
03199     PmReturn_t retval = PM_RET_OK;
03200 
03201     int func_retval;
03202     pPmObj_t p_func_retval = C_NULL;
03203 
03204     /* If wrong number of args, raise TypeError */
03205     if (NATIVE_GET_NUM_ARGS() != 0)
03206     {
03207         PM_RAISE(retval, PM_RET_EX_TYPE);
03208         return retval;
03209     }
03210 
03211 
03212     func_retval = maSoundIsPlaying();
03213     retval = int_new(func_retval, &p_func_retval);
03214 
03215     NATIVE_SET_TOS(p_func_retval);
03216 
03217     return retval;
03218     """
03219     pass
03220 
03221 
03222 def maSoundGetVolume():
03223     """__NATIVE__
03224     /* Wrapper generated for: */
03225     /*   int maSoundGetVolume(void); */
03226 
03227     PmReturn_t retval = PM_RET_OK;
03228 
03229     int func_retval;
03230     pPmObj_t p_func_retval = C_NULL;
03231 
03232     /* If wrong number of args, raise TypeError */
03233     if (NATIVE_GET_NUM_ARGS() != 0)
03234     {
03235         PM_RAISE(retval, PM_RET_EX_TYPE);
03236         return retval;
03237     }
03238 
03239 
03240     func_retval = maSoundGetVolume();
03241     retval = int_new(func_retval, &p_func_retval);
03242 
03243     NATIVE_SET_TOS(p_func_retval);
03244 
03245     return retval;
03246     """
03247     pass
03248 
03249 
03250 def maSoundSetVolume(vol):
03251     """__NATIVE__
03252     /* Wrapper generated for: */
03253     /*   void maSoundSetVolume(int vol); */
03254 
03255     PmReturn_t retval = PM_RET_OK;
03256 
03257     pPmObj_t p_func_retval = C_NULL;
03258 
03259     int vol;
03260     pPmObj_t p_vol = C_NULL;
03261 
03262     /* If wrong number of args, raise TypeError */
03263     if (NATIVE_GET_NUM_ARGS() != 1)
03264     {
03265         PM_RAISE(retval, PM_RET_EX_TYPE);
03266         return retval;
03267     }
03268 
03269     /* Raise TypeError if arg is not correct type */
03270     p_vol = NATIVE_GET_LOCAL(0);
03271     if (OBJ_GET_TYPE(p_vol) != OBJ_TYPE_INT)
03272     {
03273         PM_RAISE(retval, PM_RET_EX_TYPE);
03274         return retval;
03275     }
03276 
03277     vol = ((pPmInt_t)p_vol)->val;
03278 
03279     maSoundSetVolume(vol);
03280 
03281     NATIVE_SET_TOS(PM_NONE);
03282 
03283     return retval;
03284     """
03285     pass
03286 
03287 
03288 def maInvokeExtension(function, a, b, c):
03289     """__NATIVE__
03290     /* Wrapper generated for: */
03291     /*   int maInvokeExtension(int function, int a, int b, int c); */
03292 
03293     PmReturn_t retval = PM_RET_OK;
03294 
03295     int func_retval;
03296     pPmObj_t p_func_retval = C_NULL;
03297 
03298     int function;
03299     pPmObj_t p_function = C_NULL;
03300 
03301     int a;
03302     pPmObj_t p_a = C_NULL;
03303 
03304     int b;
03305     pPmObj_t p_b = C_NULL;
03306 
03307     int c;
03308     pPmObj_t p_c = C_NULL;
03309 
03310     /* If wrong number of args, raise TypeError */
03311     if (NATIVE_GET_NUM_ARGS() != 4)
03312     {
03313         PM_RAISE(retval, PM_RET_EX_TYPE);
03314         return retval;
03315     }
03316 
03317     /* Raise TypeError if arg is not correct type */
03318     p_function = NATIVE_GET_LOCAL(0);
03319     if (OBJ_GET_TYPE(p_function) != OBJ_TYPE_INT)
03320     {
03321         PM_RAISE(retval, PM_RET_EX_TYPE);
03322         return retval;
03323     }
03324 
03325     /* Raise TypeError if arg is not correct type */
03326     p_a = NATIVE_GET_LOCAL(1);
03327     if (OBJ_GET_TYPE(p_a) != OBJ_TYPE_INT)
03328     {
03329         PM_RAISE(retval, PM_RET_EX_TYPE);
03330         return retval;
03331     }
03332 
03333     /* Raise TypeError if arg is not correct type */
03334     p_b = NATIVE_GET_LOCAL(2);
03335     if (OBJ_GET_TYPE(p_b) != OBJ_TYPE_INT)
03336     {
03337         PM_RAISE(retval, PM_RET_EX_TYPE);
03338         return retval;
03339     }
03340 
03341     /* Raise TypeError if arg is not correct type */
03342     p_c = NATIVE_GET_LOCAL(3);
03343     if (OBJ_GET_TYPE(p_c) != OBJ_TYPE_INT)
03344     {
03345         PM_RAISE(retval, PM_RET_EX_TYPE);
03346         return retval;
03347     }
03348 
03349     function = ((pPmInt_t)p_function)->val;
03350     a = ((pPmInt_t)p_a)->val;
03351     b = ((pPmInt_t)p_b)->val;
03352     c = ((pPmInt_t)p_c)->val;
03353 
03354     func_retval = maInvokeExtension(function, a, b, c);
03355     retval = int_new(func_retval, &p_func_retval);
03356 
03357     NATIVE_SET_TOS(p_func_retval);
03358 
03359     return retval;
03360     """
03361     pass
03362 
03363 
03364 # No wrapper for
03365 #longlong maIOCtl(int function, int a, int b, int c MA_IOCTL_ELLIPSIS);
03366 
03367 # No wrapper for
03368 #(void) maIOCtl(3, (int)start, length, 0);
03369 
03370 # No wrapper for
03371 #(void) maIOCtl(4, (int)start, length, 0);
03372 
03373 # No wrapper for
03374 #(void) maIOCtl(5, enable, 0, 0);

Generated on Mon Oct 18 07:40:46 2010 for Python-on-a-chip by  doxygen 1.5.9