PageRenderTime 48ms CodeModel.GetById 17ms RepoModel.GetById 0ms app.codeStats 1ms

/trunk/Lib/modula3/modula3.swg

#
Unknown | 754 lines | 663 code | 91 blank | 0 comment | 0 complexity | 3a505fb5e1e740dc1f0aca35b0f34634 MD5 | raw file
Possible License(s): LGPL-2.1, Cube, GPL-3.0, 0BSD, GPL-2.0 
    

  1. /* -----------------------------------------------------------------------------
    2. 

  2.  * modula3.swg
    3. 

  3.  *
    4. 

  4.  * Modula3 typemaps
    5. 

  5.  * ----------------------------------------------------------------------------- */
    6. 

  6. 

  7. %include <modula3head.swg>
    8. 

  8. 

  9. /* The ctype, m3rawtype and m3wraptype typemaps work together and so there should be one of each. 
    10. 

  10.  * The ctype typemap contains the C type used in the signature of C wrappers for C++ functions. 
    11. 

  11.  * The m3rawtype typemap contains the M3 type used in the raw interface.
    12. 

  12.  * The m3rawintype typemap contains the M3 type used as function argument.
    13. 

  13.  * The m3rawrettype typemap contains the M3 type used as return value.
    14. 

  14.  * The m3wraptype typemap contains the M3 type used in the M3 type wrapper classes and module class. */
    15. 

  15. 

  16. /* Primitive types */
    17. 

  17. %typemap(ctype) bool,               const bool &               "bool"
    18. 

  18. %typemap(ctype) char,               const char &               "char"
    19. 

  19. %typemap(ctype) signed char,        const signed char &        "signed char"
    20. 

  20. %typemap(ctype) unsigned char,      const unsigned char &      "unsigned short"
    21. 

  21. %typemap(ctype) short,              const short &              "short"
    22. 

  22. %typemap(ctype) unsigned short,     const unsigned short &     "unsigned short"
    23. 

  23. %typemap(ctype) int,                const int &                "int"
    24. 

  24. %typemap(ctype) unsigned int,       const unsigned int &       "unsigned int"
    25. 

  25. %typemap(ctype) long,               const long &               "long"
    26. 

  26. %typemap(ctype) unsigned long,      const unsigned long &      "unsigned long"
    27. 

  27. %typemap(ctype) long long,          const long long &          "long long"
    28. 

  28. %typemap(ctype) unsigned long long, const unsigned long long & "unsigned long long"
    29. 

  29. %typemap(ctype) float,              const float &              "float"
    30. 

  30. %typemap(ctype) double,             const double &             "double"
    31. 

  31. %typemap(ctype) char *                                         "char *"
    32. 

  32. %typemap(ctype) void                                           "void"
    33. 

  33. 

  34. %typemap(m3rawtype) bool,               const bool &               "BOOLEAN"
    35. 

  35. %typemap(m3rawtype) char,               const char &               "C.char"
    36. 

  36. %typemap(m3rawtype) signed char,        const signed char &        "C.signed_char"
    37. 

  37. %typemap(m3rawtype) unsigned char,      const unsigned char &      "C.unsigned_char"
    38. 

  38. %typemap(m3rawtype) short,              const short &              "C.short"
    39. 

  39. %typemap(m3rawtype) unsigned short,     const unsigned short &     "C.unsigned_short"
    40. 

  40. %typemap(m3rawtype) int,                const int &                "C.int"
    41. 

  41. %typemap(m3rawtype) unsigned int,       const unsigned int &       "C.unsigned_int"
    42. 

  42. %typemap(m3rawtype) long,               const long &               "C.long"
    43. 

  43. %typemap(m3rawtype) unsigned long,      const unsigned long &      "C.unsigned_long"
    44. 

  44. %typemap(m3rawtype) long long,          const long long &          "C.long_long"
    45. 

  45. %typemap(m3rawtype) unsigned long long, const unsigned long long & "C.unsigned_long_long"
    46. 

  46. %typemap(m3rawtype) float,              const float &              "C.float"
    47. 

  47. %typemap(m3rawtype) double,             const double &             "C.double"
    48. 

  48. %typemap(m3rawtype) long double,        const long double &        "C.long_double"
    49. 

  49. %typemap(m3rawtype) char *                                         "C.char_star"
    50. 

  50. %typemap(m3rawtype) void                                           ""
    51. 

  51. %typemap(m3rawtype) FILE                                           "Cstdio.FILE";
    52. 

  52. %typemap(m3rawtype) FILE *                                         "Cstdio.FILE_star";
    53. 

  53. 

  54. 

  55. %typemap(m3rawintype) bool *,               bool &,               bool               "BOOLEAN"
    56. 

  56. %typemap(m3rawintype) char *,               char &,               char               "C.char"
    57. 

  57. %typemap(m3rawintype) signed char *,        signed char &,        signed char        "C.signed_char"
    58. 

  58. %typemap(m3rawintype) unsigned char *,      unsigned char &,      unsigned char      "C.unsigned_char"
    59. 

  59. %typemap(m3rawintype) short *,              short &,              short              "C.short"
    60. 

  60. %typemap(m3rawintype) unsigned short *,     unsigned short &,     unsigned short     "C.unsigned_short"
    61. 

  61. %typemap(m3rawintype) int *,                int &,                int                "C.int"
    62. 

  62. %typemap(m3rawintype) unsigned int *,       unsigned int &,       unsigned int       "C.unsigned_int"
    63. 

  63. %typemap(m3rawintype) long *,               long &,               long               "C.long"
    64. 

  64. %typemap(m3rawintype) unsigned long *,      unsigned long &,      unsigned long      "C.unsigned_long"
    65. 

  65. %typemap(m3rawintype) long long *,          long long &,          long long          "C.long_long"
    66. 

  66. %typemap(m3rawintype) unsigned long long *, unsigned long long &, unsigned long long "C.unsigned_long_long"
    67. 

  67. %typemap(m3rawintype) float *,              float &,              float              "C.float"
    68. 

  68. %typemap(m3rawintype) double *,             double &,             double             "C.double"
    69. 

  69. %typemap(m3rawintype) long double *,        long double &,        long double        "C.long_double"
    70. 

  70. %typemap(m3rawintype) char *                                                         "C.char_star"
    71. 

  71. %typemap(m3rawintype) void                                                           ""
    72. 

  72. %typemap(m3rawintype) void *                                                         "ADDRESS"
    73. 

  73. %typemap(m3rawintype) FILE                                                           "Cstdio.FILE";
    74. 

  74. %typemap(m3rawintype) FILE *                                                         "Cstdio.FILE_star";
    75. 

  75. 

  76. %typemap(m3rawinmode) char *, void *, FILE *  ""
    77. 

  77. 

  78. 

  79. %typemap(m3rawrettype) bool,               const bool &               "BOOLEAN"
    80. 

  80. %typemap(m3rawrettype) char,               const char &               "C.char"
    81. 

  81. %typemap(m3rawrettype) signed char,        const signed char &        "C.signed_char"
    82. 

  82. %typemap(m3rawrettype) unsigned char,      const unsigned char &      "C.unsigned_char"
    83. 

  83. %typemap(m3rawrettype) short,              const short &              "C.short"
    84. 

  84. %typemap(m3rawrettype) unsigned short,     const unsigned short &     "C.unsigned_short"
    85. 

  85. %typemap(m3rawrettype) int,                const int &                "C.int"
    86. 

  86. %typemap(m3rawrettype) unsigned int,       const unsigned int &       "C.unsigned_int"
    87. 

  87. %typemap(m3rawrettype) long,               const long &               "C.long"
    88. 

  88. %typemap(m3rawrettype) unsigned long,      const unsigned long &      "C.unsigned_long"
    89. 

  89. %typemap(m3rawrettype) long long,          const long long &          "C.long_long"
    90. 

  90. %typemap(m3rawrettype) unsigned long long, const unsigned long long & "C.unsigned_long_long"
    91. 

  91. %typemap(m3rawrettype) float,              const float &              "C.float"
    92. 

  92. %typemap(m3rawrettype) double,             const double &             "C.double"
    93. 

  93. %typemap(m3rawrettype) long double,        const long double &        "C.long_double"
    94. 

  94. %typemap(m3rawrettype) char *                                         "C.char_star"
    95. 

  95. %typemap(m3rawrettype) void                                           ""
    96. 

  96. %typemap(m3rawrettype) void *                                         "ADDRESS"
    97. 

  97. %typemap(m3rawrettype) FILE                                           "Cstdio.FILE";
    98. 

  98. %typemap(m3rawrettype) FILE *                                         "Cstdio.FILE_star";
    99. 

  99. 

  100. 

  101. %typemap("m3rawtype:import")
    102. 

  102.   char,               const char &,
    103. 

  103.   signed char,        const signed char &,
    104. 

  104.   unsigned char,      const unsigned char &,
    105. 

  105.   short,              const short &,
    106. 

  106.   unsigned short,     const unsigned short &,
    107. 

  107.   int,                const int &,
    108. 

  108.   unsigned int,       const unsigned int &,
    109. 

  109.   long,               const long &,
    110. 

  110.   unsigned long,      const unsigned long &,
    111. 

  111.   long long,          const long long &,
    112. 

  112.   unsigned long long, const unsigned long long &,
    113. 

  113.   float,              const float &,
    114. 

  114.   double,             const double &,
    115. 

  115.   long double,        const long double &,
    116. 

  116.   char *
    117. 

  117.     "Ctypes AS C"
    118. 

  118. 

  119. %typemap("m3rawintype:import")
    120. 

  120.   char,               const char &,
    121. 

  121.   signed char,        const signed char &,
    122. 

  122.   unsigned char,      const unsigned char &,
    123. 

  123.   short,              const short &,
    124. 

  124.   unsigned short,     const unsigned short &,
    125. 

  125.   int,                const int &,
    126. 

  126.   unsigned int,       const unsigned int &,
    127. 

  127.   long,               const long &,
    128. 

  128.   unsigned long,      const unsigned long &,
    129. 

  129.   long long,          const long long &,
    130. 

  130.   unsigned long long, const unsigned long long &,
    131. 

  131.   float,              const float &,
    132. 

  132.   double,             const double &,
    133. 

  133.   long double,        const long double &,
    134. 

  134.   char *
    135. 

  135.     "Ctypes AS C"
    136. 

  136. 

  137. %typemap("m3rawrettype:import")
    138. 

  138.   char,               const char &,
    139. 

  139.   signed char,        const signed char &,
    140. 

  140.   unsigned char,      const unsigned char &,
    141. 

  141.   short,              const short &,
    142. 

  142.   unsigned short,     const unsigned short &,
    143. 

  143.   int,                const int &,
    144. 

  144.   unsigned int,       const unsigned int &,
    145. 

  145.   long,               const long &,
    146. 

  146.   unsigned long,      const unsigned long &,
    147. 

  147.   long long,          const long long &,
    148. 

  148.   unsigned long long, const unsigned long long &,
    149. 

  149.   float,              const float &,
    150. 

  150.   double,             const double &,
    151. 

  151.   long double,        const long double &,
    152. 

  152.   char *
    153. 

  153.     "Ctypes AS C"
    154. 

  154. 

  155. %typemap("m3rawtype:import")
    156. 

  156.   FILE,   FILE *
    157. 

  157.     "Cstdio";
    158. 

  158. 

  159. %typemap("m3rawintype:import")
    160. 

  160.   FILE,   FILE *
    161. 

  161.     "Cstdio";
    162. 

  162. 

  163. %typemap("m3rawrettype:import")
    164. 

  164.   FILE,   FILE *
    165. 

  165.     "Cstdio";
    166. 

  166. 

  167. %typemap(m3wraptype) bool,               const bool &               "BOOLEAN"
    168. 

  168. %typemap(m3wraptype) char,               const char &               "CHAR"
    169. 

  169. %typemap(m3wraptype) signed char,        const signed char &        "CHAR"
    170. 

  170. %typemap(m3wraptype) unsigned char,      const unsigned char &      "CHAR"
    171. 

  171. %typemap(m3wraptype) short,              const short &              "Integer16.T"
    172. 

  172. %typemap(m3wraptype) unsigned short,     const unsigned short &     "Cardinal16.T"
    173. 

  173. %typemap(m3wraptype) int,                const int &                "INTEGER"
    174. 

  174. %typemap(m3wraptype) unsigned int,       const unsigned int &       "CARDINAL"
    175. 

  175. %typemap(m3wraptype) long,               const long &               "Integer32.T"
    176. 

  176. %typemap(m3wraptype) unsigned long,      const unsigned long &      "Cardinal32.T"
    177. 

  177. %typemap(m3wraptype) long long,          const long long &          "Integer64.T"
    178. 

  178. %typemap(m3wraptype) unsigned long long, const unsigned long long & "Cardinal64.T"
    179. 

  179. %typemap(m3wraptype) float,              const float &              "REAL"
    180. 

  180. %typemap(m3wraptype) double,             const double &             "LONGREAL"
    181. 

  181. %typemap(m3wraptype) long double,        const long double &        "EXTENDED"
    182. 

  182. %typemap(m3wraptype) char *                                         "TEXT"
    183. 

  183. %typemap(m3wraptype) void                                           ""
    184. 

  184. %typemap(m3wraptype) FILE                                           "Cstdio.FILE";
    185. 

  185. %typemap(m3wraptype) FILE *                                         "Cstdio.FILE_star";
    186. 

  186. 

  187. %typemap(m3wrapintype) bool,               const bool *,               const bool &               "BOOLEAN"
    188. 

  188. %typemap(m3wrapintype) char,               const char *,               const char &               "CHAR"
    189. 

  189. %typemap(m3wrapintype) signed char,        const signed char *,        const signed char &        "CHAR"
    190. 

  190. %typemap(m3wrapintype) unsigned char,      const unsigned char *,      const unsigned char &      "CHAR"
    191. 

  191. %typemap(m3wrapintype) short,              const short *,              const short &              "INTEGER"
    192. 

  192. %typemap(m3wrapintype) unsigned short,     const unsigned short *,     const unsigned short &     "CARDINAL"
    193. 

  193. %typemap(m3wrapintype) int,                const int *,                const int &                "INTEGER"
    194. 

  194. %typemap(m3wrapintype) unsigned int,       const unsigned int *,       const unsigned int &       "CARDINAL"
    195. 

  195. %typemap(m3wrapintype) long,               const long *,               const long &               "INTEGER"
    196. 

  196. %typemap(m3wrapintype) unsigned long,      const unsigned long *,      const unsigned long &      "CARDINAL"
    197. 

  197. %typemap(m3wrapintype) long long,          const long long *,          const long long &          "INTEGER"
    198. 

  198. %typemap(m3wrapintype) unsigned long long, const unsigned long long *, const unsigned long long & "CARDINAL"
    199. 

  199. %typemap(m3wrapintype) float,              const float *,              const float &              "REAL"
    200. 

  200. %typemap(m3wrapintype) double,             const double *,             const double &             "LONGREAL"
    201. 

  201. %typemap(m3wrapintype) long double,        const long double *,        const long double &        "EXTENDED"
    202. 

  202. %typemap(m3wrapintype) const char *, const char []   "TEXT"
    203. 

  203. %typemap(m3wrapintype,numinputs=0) void              ""
    204. 

  204. %typemap(m3wrapintype) FILE            "Cstdio.FILE";
    205. 

  205. %typemap(m3wrapintype) FILE *          "Cstdio.FILE_star";
    206. 

  206. 

  207. 

  208. %typemap(m3wrapouttype) bool,               bool *,               bool &                  "BOOLEAN"
    209. 

  209. %typemap(m3wrapouttype) char,               char *,               char &                  "CHAR"
    210. 

  210. %typemap(m3wrapouttype) signed char,        signed char *,        signed char &           "CHAR"
    211. 

  211. %typemap(m3wrapouttype) unsigned char,      unsigned char *,      unsigned char &         "CHAR"
    212. 

  212. %typemap(m3wrapouttype) short,              short *,              short &                 "INTEGER"
    213. 

  213. %typemap(m3wrapouttype) unsigned short,     unsigned short *,     unsigned short &        "CARDINAL"
    214. 

  214. %typemap(m3wrapouttype) int,                int *,                int &                   "INTEGER"
    215. 

  215. %typemap(m3wrapouttype) unsigned int,       unsigned int *,       unsigned int &          "CARDINAL"
    216. 

  216. %typemap(m3wrapouttype) long,               long *,               long &                  "INTEGER"
    217. 

  217. %typemap(m3wrapouttype) unsigned long,      unsigned long *,      unsigned long &         "CARDINAL"
    218. 

  218. %typemap(m3wrapouttype) long long,          long long *,          long long &             "INTEGER"
    219. 

  219. %typemap(m3wrapouttype) unsigned long long, unsigned long long *, unsigned long long &    "CARDINAL"
    220. 

  220. %typemap(m3wrapouttype) float,              float *,              float &                 "REAL"
    221. 

  221. %typemap(m3wrapouttype) double,             double *,             double &                "LONGREAL"
    222. 

  222. %typemap(m3wrapouttype) long double,        long double *,        long double &           "EXTENDED"
    223. 

  223. %typemap(m3wrapouttype) char *, char []    "TEXT"
    224. 

  224. %typemap(m3wrapouttype,numinputs=0) void   ""
    225. 

  225. 

  226. %typemap(m3wraprettype) bool,               const bool &               "BOOLEAN"
    227. 

  227. %typemap(m3wraprettype) char,               const char &               "CHAR"
    228. 

  228. %typemap(m3wraprettype) signed char,        const signed char &        "CHAR"
    229. 

  229. %typemap(m3wraprettype) unsigned char,      const unsigned char &      "CHAR"
    230. 

  230. %typemap(m3wraprettype) short,              const short &              "INTEGER"
    231. 

  231. %typemap(m3wraprettype) unsigned short,     const unsigned short &     "CARDINAL"
    232. 

  232. %typemap(m3wraprettype) int,                const int &                "INTEGER"
    233. 

  233. %typemap(m3wraprettype) unsigned int,       const unsigned int &       "CARDINAL"
    234. 

  234. %typemap(m3wraprettype) long,               const long &               "INTEGER"
    235. 

  235. %typemap(m3wraprettype) unsigned long,      const unsigned long &      "CARDINAL"
    236. 

  236. %typemap(m3wraprettype) long long,          const long long &          "INTEGER"
    237. 

  237. %typemap(m3wraprettype) unsigned long long, const unsigned long long & "CARDINAL"
    238. 

  238. %typemap(m3wraprettype) float,              const float &              "REAL"
    239. 

  239. %typemap(m3wraprettype) double,             const double &             "LONGREAL"
    240. 

  240. %typemap(m3wraprettype) long double,        const long double &        "EXTENDED"
    241. 

  241. %typemap(m3wraprettype) char *                                         "TEXT"
    242. 

  242. %typemap(m3wraprettype) void                                           ""
    243. 

  243. %typemap(m3wraprettype) FILE            "Cstdio.FILE";
    244. 

  244. %typemap(m3wraprettype) FILE *          "Cstdio.FILE_star";
    245. 

  245. 

  246. 

  247. %typemap(ctype)          char[ANY]               "char *"
    248. 

  248. %typemap(m3rawtype)      char[ANY]               "C.char_star"
    249. 

  249. %typemap(m3rawintype)    char[ANY]               "C.char_star"
    250. 

  250. %typemap(m3rawrettype)   char[ANY]               "C.char_star"
    251. 

  251. %typemap(m3wraptype)     char[ANY]               "TEXT"
    252. 

  252. %typemap(m3wrapintype)   char[ANY]               "TEXT"
    253. 

  253. %typemap(m3wrapouttype)  char[ANY]               "TEXT"
    254. 

  254. %typemap(m3wraprettype)  char[ANY]               "TEXT"
    255. 

  255. 

  256. %typemap(m3wrapinmode)  const char * %{%}
    257. 

  257. %typemap(m3wrapargvar)  const char * %{$1 : C.char_star;%}
    258. 

  258. %typemap(m3wrapinconv)  const char * %{$1 := M3toC.SharedTtoS($1_name);%}
    259. 

  259. %typemap(m3wrapfreearg) const char * %{M3toC.FreeSharedS($1_name,$1);%}
    260. 

  260. %typemap(m3wrapargraw)  const char * %{$1%}
    261. 

  261. %typemap("m3wrapargvar:import")  const char * "Ctypes AS C"
    262. 

  262. %typemap("m3wrapinconv:import")  const char * "M3toC"
    263. 

  263. %typemap("m3wrapfreearg:import") const char * "M3toC"
    264. 

  264. 

  265. %typemap(m3wrapretvar)  char * %{result : C.char_star;%}
    266. 

  266. %typemap(m3wrapretraw)  char * %{result%}
    267. 

  267. %typemap(m3wrapretconv) char * %{M3toC.CopyStoT(result)%}
    268. 

  268. %typemap("m3wrapretvar:import")  char * "Ctypes AS C"
    269. 

  269. %typemap("m3wrapretconv:import") char * "M3toC"
    270. 

  270. 

  271. %typemap(m3wrapinmode)  FILE * %{%}
    272. 

  272. 

  273. 

  274. %typemap("m3wraptype:import")
    275. 

  275.   FILE,   FILE *
    276. 

  276.     "Cstdio";
    277. 

  277. 

  278. %typemap("m3wrapintype:import")
    279. 

  279.   FILE,   FILE *
    280. 

  280.     "Cstdio";
    281. 

  281. 

  282. %typemap("m3wraprettype:import")
    283. 

  283.   FILE,   FILE *
    284. 

  284.     "Cstdio";
    285. 

  285. 

  286. 

  287. /* Composed types */
    288. 

  288. %typemap(ctype)                SWIGTYPE "$1_type"
    289. 

  289. %typemap(m3rawtype)            SWIGTYPE "$1_basetype"
    290. 

  290. %typemap(m3rawrettype)         SWIGTYPE "UNTRACED REF $1_basetype"
    291. 

  291. %typemap(m3wraptype)           SWIGTYPE "$1_basetype"
    292. 

  292. %typemap(m3wrapintype)         SWIGTYPE "$1_basetype"
    293. 

  293. %typemap(m3wrapouttype)        SWIGTYPE "$1_basetype"
    294. 

  294. %typemap(m3wraprettype)        SWIGTYPE "$1_basetype"
    295. 

  295. 

  296. %typemap(ctype)                SWIGTYPE [] "$1_type"
    297. 

  297. %typemap(m3rawtype)      const SWIGTYPE [] "UNTRACED REF ARRAY INTEGER OF $1_basetype"
    298. 

  298. %typemap(m3rawtype)            SWIGTYPE [] "UNTRACED REF ARRAY INTEGER OF $1_basetype"
    299. 

  299. %typemap(m3rawintype)    const SWIGTYPE [] "(*ARRAY OF*) $1_basetype"
    300. 

  300. %typemap(m3rawinmode)    const SWIGTYPE [] "READONLY"
    301. 

  301. %typemap(m3rawintype)          SWIGTYPE [] "(*ARRAY OF*) $1_basetype"
    302. 

  302. %typemap(m3rawinmode)          SWIGTYPE [] "VAR"
    303. 

  303. %typemap(m3rawrettype)   const SWIGTYPE [] "UNTRACED REF ARRAY INTEGER OF $1_basetype"
    304. 

  304. %typemap(m3rawrettype)         SWIGTYPE [] "UNTRACED REF ARRAY INTEGER OF $1_basetype"
    305. 

  305. %typemap(m3wraptype)           SWIGTYPE [] "$1_basetype"
    306. 

  306. %typemap(m3wrapintype)   const SWIGTYPE [] "ARRAY OF $1_basetype"
    307. 

  307. %typemap(m3wrapinmode)   const SWIGTYPE [] "READONLY"
    308. 

  308. %typemap(m3wrapintype)         SWIGTYPE [] "ARRAY OF $1_basetype"
    309. 

  309. %typemap(m3wrapinmode)         SWIGTYPE [] "VAR"
    310. 

  310. %typemap(m3wrapouttype)        SWIGTYPE [] "ARRAY OF $1_basetype"
    311. 

  311. %typemap(m3wraprettype)        SWIGTYPE [] "REF ARRAY OF $1_basetype"
    312. 

  312. 

  313. %typemap(ctype)                SWIGTYPE * "$1_type"
    314. 

  314. %typemap(m3rawtype)      const SWIGTYPE * "UNTRACED REF $1_basetype"
    315. 

  315. %typemap(m3rawtype)            SWIGTYPE * "UNTRACED REF $1_basetype"
    316. 

  316. %typemap(m3rawintype)    const SWIGTYPE * "$1_basetype"
    317. 

  317. %typemap(m3rawinmode)    const SWIGTYPE * "READONLY"
    318. 

  318. %typemap(m3rawintype)          SWIGTYPE * "$1_basetype"
    319. 

  319. %typemap(m3rawinmode)          SWIGTYPE * "VAR"
    320. 

  320. %typemap(m3rawrettype)   const SWIGTYPE * "UNTRACED REF $1_basetype"
    321. 

  321. %typemap(m3rawrettype)         SWIGTYPE * "UNTRACED REF $1_basetype"
    322. 

  322. %typemap(m3wraptype)           SWIGTYPE * "$1_basetype"
    323. 

  323. %typemap(m3wrapintype)   const SWIGTYPE * "$1_basetype"
    324. 

  324. %typemap(m3wrapinmode)   const SWIGTYPE * "READONLY"
    325. 

  325. %typemap(m3wrapintype)         SWIGTYPE * "$1_basetype"
    326. 

  326. %typemap(m3wrapinmode)         SWIGTYPE * "VAR"
    327. 

  327. %typemap(m3wrapouttype)        SWIGTYPE * "$1_basetype"
    328. 

  328. %typemap(m3wraprettype)        SWIGTYPE * "UNTRACED REF $1_basetype"
    329. 

  329. 

  330. %typemap(ctype)                SWIGTYPE & "$1_type"
    331. 

  331. %typemap(m3rawtype)      const SWIGTYPE & "UNTRACED REF $1_basetype"
    332. 

  332. %typemap(m3rawtype)            SWIGTYPE & "UNTRACED REF $1_basetype"
    333. 

  333. %typemap(m3rawintype)    const SWIGTYPE & "$1_basetype"
    334. 

  334. %typemap(m3rawinmode)    const SWIGTYPE & "READONLY"
    335. 

  335. %typemap(m3rawintype)          SWIGTYPE & "$1_basetype"
    336. 

  336. %typemap(m3rawinmode)          SWIGTYPE & "VAR"
    337. 

  337. %typemap(m3rawrettype)   const SWIGTYPE & "UNTRACED REF $1_basetype"
    338. 

  338. %typemap(m3rawrettype)         SWIGTYPE & "UNTRACED REF $1_basetype"
    339. 

  339. %typemap(m3wraptype)           SWIGTYPE & "$1_basetype"
    340. 

  340. %typemap(m3wrapintype)   const SWIGTYPE & "$1_basetype"
    341. 

  341. %typemap(m3wrapinmode)   const SWIGTYPE & "READONLY"
    342. 

  342. %typemap(m3wrapintype)         SWIGTYPE & "$1_basetype"
    343. 

  343. %typemap(m3wrapinmode)         SWIGTYPE & "VAR"
    344. 

  344. %typemap(m3wrapouttype)        SWIGTYPE & "$1_basetype"
    345. 

  345. %typemap(m3wraprettype)        SWIGTYPE & "UNTRACED REF $1_basetype"
    346. 

  346. 

  347. %typemap(ctype)           enum SWIGTYPE "$1_type"
    348. 

  348. %typemap(m3rawtype)       enum SWIGTYPE "C.int"
    349. 

  349. %typemap(m3rawintype)     enum SWIGTYPE "C.int (* $1_type *)"
    350. 

  350. %typemap(m3rawrettype)    enum SWIGTYPE "C.int"
    351. 

  351. %typemap(m3wraptype)      enum SWIGTYPE "$*1_type"
    352. 

  352. %typemap(m3wrapintype)    enum SWIGTYPE "$1_type"
    353. 

  353. %typemap(m3wrapouttype)   enum SWIGTYPE "$1_type"
    354. 

  354. %typemap(m3wraprettype)   enum SWIGTYPE "$*1_type"
    355. 

  355. 

  356. /* pointer to a class member */
    357. 

  357. %typemap(ctype)      SWIGTYPE (CLASS::*) "$1_type"
    358. 

  358. %typemap(m3rawtype)  SWIGTYPE (CLASS::*) "REFANY"
    359. 

  359. %typemap(m3wraptype) SWIGTYPE (CLASS::*) "$1_basetype"
    360. 

  360. 

  361. /* The following are the in, out, freearg, argout typemaps.
    362. 

  362.    These are the PInvoke code generating typemaps for converting from C# to C and visa versa. */
    363. 

  363. 

  364. /* primitive types */
    365. 

  365. %typemap(in) bool
    366. 

  366. %{ $1 = $input ? true : false; %}
    367. 

  367. 

  368. %typemap(in) char, 
    369. 

  369.              signed char, 
    370. 

  370.              unsigned char, 
    371. 

  371.              short, 
    372. 

  372.              unsigned short, 
    373. 

  373.              int, 
    374. 

  374.              unsigned int, 
    375. 

  375.              long, 
    376. 

  376.              unsigned long, 
    377. 

  377.              long long, 
    378. 

  378.              unsigned long long, 
    379. 

  379.              float, 
    380. 

  380.              double, 
    381. 

  381.              enum SWIGTYPE
    382. 

  382. %{ $1 = ($1_ltype)$input; %}
    383. 

  383. 

  384. %typemap(out) bool               %{ $result = $1; %}
    385. 

  385. %typemap(out) char               %{ $result = $1; %}
    386. 

  386. %typemap(out) signed char        %{ $result = $1; %}
    387. 

  387. %typemap(out) unsigned char      %{ $result = $1; %}
    388. 

  388. %typemap(out) short              %{ $result = $1; %}
    389. 

  389. %typemap(out) unsigned short     %{ $result = $1; %}
    390. 

  390. %typemap(out) int                %{ $result = $1; %}
    391. 

  391. %typemap(out) unsigned int       %{ $result = $1; %}
    392. 

  392. %typemap(out) long               %{ $result = $1; %}
    393. 

  393. %typemap(out) unsigned long      %{ $result = $1; %}
    394. 

  394. %typemap(out) long long          %{ $result = $1; %}
    395. 

  395. %typemap(out) unsigned long long %{ $result = $1; %}
    396. 

  396. %typemap(out) float              %{ $result = $1; %}
    397. 

  397. %typemap(out) double             %{ $result = $1; %}
    398. 

  398. %typemap(out) enum SWIGTYPE      %{ $result = $1; %}
    399. 

  399. 

  400. /* char * - treat as String */
    401. 

  401. %typemap(in) char * {
    402. 

  402.   $1 = $input;
    403. 

  403. }
    404. 

  404. //%typemap(freearg) char * { if ($1) JCALL2(ReleaseStringUTFChars, jenv, $input, $1); }
    405. 

  405. //%typemap(out) char * { if($1) $result = JCALL1(NewStringUTF, jenv, $1); }
    406. 

  406. 

  407. %typemap(out) void ""
    408. 

  408. 

  409. /* primitive types by const reference */
    410. 

  410. %typemap(in) const bool & (bool temp)
    411. 

  411. %{ temp = $input ? true : false; 
    412. 

  412.    $1 = &temp; %}
    413. 

  413. 

  414. %typemap(in) const char & (char temp), 
    415. 

  415.              const signed char & (signed char temp), 
    416. 

  416.              const unsigned char & (unsigned char temp), 
    417. 

  417.              const short & (short temp), 
    418. 

  418.              const unsigned short & (unsigned short temp), 
    419. 

  419.              const int & (int temp), 
    420. 

  420.              const unsigned int & (unsigned int temp), 
    421. 

  421.              const long & (long temp), 
    422. 

  422.              const unsigned long & (unsigned long temp), 
    423. 

  423.              const long long & ($*1_ltype temp), 
    424. 

  424.              const unsigned long long & ($*1_ltype temp), 
    425. 

  425.              const float & (float temp), 
    426. 

  426.              const double & (double temp)
    427. 

  427. %{ temp = ($*1_ltype)$input; 
    428. 

  428. $1 = &temp; %}
    429. 

  429. 

  430. %typemap(out) const bool &               %{ $result = *$1; %}
    431. 

  431. %typemap(out) const char &               %{ $result = *$1; %}
    432. 

  432. %typemap(out) const signed char &        %{ $result = *$1; %}
    433. 

  433. %typemap(out) const unsigned char &      %{ $result = *$1; %}
    434. 

  434. %typemap(out) const short &              %{ $result = *$1; %}
    435. 

  435. %typemap(out) const unsigned short &     %{ $result = *$1; %}
    436. 

  436. %typemap(out) const int &                %{ $result = *$1; %}
    437. 

  437. %typemap(out) const unsigned int &       %{ $result = *$1; %}
    438. 

  438. %typemap(out) const long &               %{ $result = *$1; %}
    439. 

  439. %typemap(out) const unsigned long &      %{ $result = *$1; %}
    440. 

  440. %typemap(out) const long long &          %{ $result = *$1; %}
    441. 

  441. %typemap(out) const unsigned long long & %{ $result = *$1; %}
    442. 

  442. %typemap(out) const float &              %{ $result = *$1; %}
    443. 

  443. %typemap(out) const double &             %{ $result = *$1; %}
    444. 

  444. 

  445. /* Default handling. Object passed by value. Convert to a pointer */
    446. 

  446. %typemap(in) SWIGTYPE ($&1_type argp)
    447. 

  447. %{ argp = *($&1_ltype*)&$input; 
    448. 

  448.    if (!argp) {
    449. 

  449. //     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null $1_type");
    450. 

  450.      RETURN $null;
    451. 

  451.    }
    452. 

  452.    $1 = *argp; %}
    453. 

  453. %typemap(out) SWIGTYPE 
    454. 

  454. #ifdef __cplusplus
    455. 

  455. %{*($&1_ltype*)&$result = new $1_ltype((const $1_ltype &)$1); %}
    456. 

  456. #else
    457. 

  457. {
    458. 

  458.   $&1_ltype $1ptr = ($&1_ltype) malloc(sizeof($1_ltype));
    459. 

  459.   memmove($1ptr, &$1, sizeof($1_type));
    460. 

  460.   *($&1_ltype*)&$result = $1ptr;
    461. 

  461. }
    462. 

  462. #endif
    463. 

  463. 

  464. /* Generic pointers and references */
    465. 

  465. %typemap(in) SWIGTYPE *, SWIGTYPE (CLASS::*) %{ $1 = *($&1_ltype)&$input; %}
    466. 

  466. %typemap(in) SWIGTYPE & %{ $1 = *($&1_ltype)&$input;
    467. 

  467.   if(!$1) {
    468. 

  468.     //SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
    469. 

  469.     RETURN $null;
    470. 

  470.   } %}
    471. 

  471. %typemap(out) SWIGTYPE *, SWIGTYPE &, SWIGTYPE (CLASS::*) %{ *($&1_ltype)&$result = $1; %} 
    472. 

  472. 

  473. 

  474. /* Default array handling */
    475. 

  475. %typemap(in) SWIGTYPE [] %{ $1 = *($&1_ltype)&$input; %}
    476. 

  476. %typemap(out) SWIGTYPE [] %{ *($&1_ltype)&$result = $1; %} 
    477. 

  477. 

  478. /* char[ANY] - treat as String */
    479. 

  479. %typemap(in) char[ANY] { 
    480. 

  480.     $1 = $input;
    481. 

  481. }
    482. 

  482. 

  483. %typemap(argout) char[ANY] ""
    484. 

  484. %typemap(freearg) char[ANY] ""//{ if ($1) JCALL2(ReleaseStringUTFChars, jenv, $input, $1); }
    485. 

  485. %typemap(out) char[ANY] { if($1) $result = $1; }
    486. 

  486. 

  487. 

  488. /* Typecheck typemaps - The purpose of these is merely to issue a warning for overloaded C++ functions 
    489. 

  489.  * that cannot be overloaded in C# as more than one C++ type maps to a single C# type */
    490. 

  490. 

  491. %typecheck(SWIG_TYPECHECK_BOOL) /* Java boolean */
    492. 

  492.     bool,
    493. 

  493.     const bool &
    494. 

  494.     ""
    495. 

  495. 

  496. %typecheck(SWIG_TYPECHECK_CHAR) /* Java char */
    497. 

  497.     char, 
    498. 

  498.     const char &
    499. 

  499.     ""
    500. 

  500. 

  501. %typecheck(SWIG_TYPECHECK_INT8) /* Java byte */
    502. 

  502.     signed char,
    503. 

  503.     const signed char &
    504. 

  504.     ""
    505. 

  505. 

  506. %typecheck(SWIG_TYPECHECK_INT16) /* Java short */
    507. 

  507.     unsigned char, 
    508. 

  508.     short, 
    509. 

  509.     const unsigned char &, 
    510. 

  510.     const short &
    511. 

  511.     ""
    512. 

  512. 

  513. %typecheck(SWIG_TYPECHECK_INT32) /* Java int */
    514. 

  514.     unsigned short, 
    515. 

  515.     int, 
    516. 

  516.     long, 
    517. 

  517.     const unsigned short &, 
    518. 

  518.     const int &, 
    519. 

  519.     const long &,
    520. 

  520.     enum SWIGTYPE
    521. 

  521.     ""
    522. 

  522. 

  523. %typecheck(SWIG_TYPECHECK_INT64) /* Java long */
    524. 

  524.     unsigned int, 
    525. 

  525.     unsigned long, 
    526. 

  526.     long long, 
    527. 

  527.     const unsigned int &, 
    528. 

  528.     const unsigned long &, 
    529. 

  529.     const long long &
    530. 

  530.     ""
    531. 

  531. 

  532. %typecheck(SWIG_TYPECHECK_INT128) /* Java BigInteger */
    533. 

  533.     unsigned long long
    534. 

  534.     ""
    535. 

  535. 

  536. %typecheck(SWIG_TYPECHECK_FLOAT) /* Java float */
    537. 

  537.     float,
    538. 

  538.     const float &
    539. 

  539.     ""
    540. 

  540. 

  541. %typecheck(SWIG_TYPECHECK_DOUBLE) /* Java double */
    542. 

  542.     double,
    543. 

  543.     const double &
    544. 

  544.     ""
    545. 

  545. 

  546. %typecheck(SWIG_TYPECHECK_STRING) /* Java String */
    547. 

  547.     char *,
    548. 

  548.     char[ANY]
    549. 

  549.     ""
    550. 

  550. 

  551. %typecheck(SWIG_TYPECHECK_POINTER) /* Default */
    552. 

  552.     SWIGTYPE, 
    553. 

  553.     SWIGTYPE *, 
    554. 

  554.     SWIGTYPE &, 
    555. 

  555.     SWIGTYPE [],
    556. 

  556.     SWIGTYPE (CLASS::*)
    557. 

  557.     ""
    558. 

  558. 

  559. /* Exception handling */
    560. 

  560. 

  561. %typemap(throws) int, 
    562. 

  562.                  long, 
    563. 

  563.                  short, 
    564. 

  564.                  unsigned int, 
    565. 

  565.                  unsigned long, 
    566. 

  566.                  unsigned short {
    567. 

  567.   char error_msg[256];
    568. 

  568.   sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1);
    569. 

  569.   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg);
    570. 

  570.   RETURN $null;
    571. 

  571. }
    572. 

  572. 

  573. %typemap(throws) SWIGTYPE {
    574. 

  574.   (void)$1;
    575. 

  575.   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown");
    576. 

  576.   RETURN $null;
    577. 

  577. }
    578. 

  578. 

  579. %typemap(throws) char * {
    580. 

  580.   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1);
    581. 

  581.   RETURN $null;
    582. 

  582. }
    583. 

  583. 

  584. 

  585. /* Typemaps for code generation in proxy classes and C# type wrapper classes */
    586. 

  586. 

  587. /* The in typemap is used for converting function parameter types from the type 
    588. 

  588.  * used in the proxy, module or type wrapper class to the type used in the PInvoke class. */
    589. 

  589. %typemap(m3in)     bool,               const bool &,
    590. 

  590.                  char,               const char &,
    591. 

  591.                  signed char,        const signed char &,
    592. 

  592.                  unsigned char,      const unsigned char &,
    593. 

  593.                  short,              const short &,
    594. 

  594.                  unsigned short,     const unsigned short &,
    595. 

  595.                  int,                const int &,
    596. 

  596.                  unsigned int,       const unsigned int &,
    597. 

  597.                  long,               const long &,
    598. 

  598.                  unsigned long,      const unsigned long &,
    599. 

  599.                  long long,          const long long &,
    600. 

  600.                  unsigned long long, const unsigned long long &,
    601. 

  601.                  float,              const float &,
    602. 

  602.                  double,             const double &,
    603. 

  603.                  char *,
    604. 

  604.                  char[ANY],
    605. 

  605.                  enum SWIGTYPE 
    606. 

  606.     "$input"
    607. 

  607. %typemap(m3in) SWIGTYPE "$&*1_type.getCPtr($input)"
    608. 

  608. %typemap(m3in) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) "$1_basetype.getCPtr($input)"
    609. 

  609. 

  610. /* The m3out typemap is used for converting function return types from the return type
    611. 

  611.  * used in the PInvoke class to the type returned by the proxy, module or type wrapper class. */
    612. 

  612. %typemap(m3out)   bool,               const bool &,
    613. 

  613.                   char,               const char &,
    614. 

  614.                   signed char,        const signed char &,
    615. 

  615.                   unsigned char,      const unsigned char &,
    616. 

  616.                   short,              const short &,
    617. 

  617.                   unsigned short,     const unsigned short &,
    618. 

  618.                   int,                const int &,
    619. 

  619.                   unsigned int,       const unsigned int &,
    620. 

  620.                   long,               const long &,
    621. 

  621.                   unsigned long,      const unsigned long &,
    622. 

  622.                   long long,          const long long &,
    623. 

  623.                   unsigned long long, const unsigned long long &,
    624. 

  624.                   float,              const float &,
    625. 

  625.                   double,             const double &,
    626. 

  626.                   char *,
    627. 

  627.                   char[ANY],
    628. 

  628.                   enum SWIGTYPE
    629. 

  629. %{$imcall%}
    630. 

  630. 

  631. %typemap(m3out) void %{$imcall%}
    632. 

  632. 

  633. %typemap(m3out) SWIGTYPE %{
    634. 

  634.     RETURN NEW(REF $1_basetype, $imcall);
    635. 

  635. %}
    636. 

  636. %typemap(m3out) SWIGTYPE & %{
    637. 

  637.     RETURN NEW($1_basetype, $imcall, $owner);
    638. 

  638. %}
    639. 

  639. %typemap(m3out) SWIGTYPE *, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
    640. 

  640.     cPtr := $imcall;
    641. 

  641.     RETURN (cPtr = IntPtr.Zero) ? null : NEW($1_basetype, cPtr, $owner);
    642. 

  642. %}
    643. 

  643. 

  644. /* Properties */
    645. 

  645. %typemap(m3varin) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
    646. 

  646. PROCEDURE Set$var (value: $vartype) =
    647. 

  647.   BEGIN
    648. 

  648.     $imcall;
    649. 

  649.   END Set$var;
    650. 

  650. %}
    651. 

  651. 

  652. %typemap(m3varout) bool,               const bool &,
    653. 

  653.                    char,               const char &,
    654. 

  654.                    signed char,        const signed char &,
    655. 

  655.                    unsigned char,      const unsigned char &,
    656. 

  656.                    short,              const short &,
    657. 

  657.                    unsigned short,     const unsigned short &,
    658. 

  658.                    int,                const int &,
    659. 

  659.                    unsigned int,       const unsigned int &,
    660. 

  660.                    long,               const long &,
    661. 

  661.                    unsigned long,      const unsigned long &,
    662. 

  662.                    long long,          const long long &,
    663. 

  663.                    unsigned long long, const unsigned long long &,
    664. 

  664.                    float,              const float &,
    665. 

  665.                    double,             const double &,
    666. 

  666.                    char *,
    667. 

  667.                    char[ANY],
    668. 

  668.                    enum SWIGTYPE %{
    669. 

  669. PROCEDURE Get$var (): $vartype =
    670. 

  670.   BEGIN
    671. 

  671.     RETURN $imcall;
    672. 

  672.   END Get$var;
    673. 

  673. %}
    674. 

  674. 

  675. %typemap(m3varout) void %{
    676. 

  676.     get {
    677. 

  677.       $imcall;
    678. 

  678.     } %}
    679. 

  679. %typemap(m3varout) SWIGTYPE %{
    680. 

  680.     get {
    681. 

  681.       RETURN new $&*1_mangle($imcall, true);
    682. 

  682.     } %}
    683. 

  683. %typemap(m3varout) SWIGTYPE & %{
    684. 

  684.     get {
    685. 

  685.       RETURN new $1_basetype($imcall, $owner);
    686. 

  686.     } %}
    687. 

  687. %typemap(m3varout) SWIGTYPE *, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
    688. 

  688.     get {
    689. 

  689.       IntPtr cPtr = $imcall;
    690. 

  690.       RETURN (cPtr == IntPtr.Zero) ? null : new $1_basetype(cPtr, $owner);
    691. 

  691.     } %}
    692. 

  692. 

  693. /* Typemaps used for the generation of proxy and type wrapper class code */
    694. 

  694. %typemap(m3base)                      SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
    695. 

  695. %typemap(m3classmodifiers)            SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) "public"
    696. 

  696. %typemap(m3code)                      SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
    697. 

  697. %typemap(m3imports)                   SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) "using System;"
    698. 

  698. %typemap(m3interfaces)                SWIGTYPE "IDisposable"
    699. 

  699. %typemap(m3interfaces_derived)                  SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
    700. 

  700. %typemap(m3ptrconstructormodifiers) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) "internal"
    701. 

  701. 

  702. %typemap(m3finalize) SWIGTYPE %{
    703. 

  703.   ~$1_basetype() {
    704. 

  704.     Dispose();
    705. 

  705.   }
    706. 

  706. %}
    707. 

  707. 

  708. %typemap(m3destruct, methodname="Dispose") SWIGTYPE {
    709. 

  709.     if(swigCPtr != IntPtr.Zero && swigCMemOwn) {
    710. 

  710.       $imcall;
    711. 

  711.       swigCMemOwn = false;
    712. 

  712.     }
    713. 

  713.     swigCPtr = IntPtr.Zero;
    714. 

  714.     GC.SuppressFinalize(this);
    715. 

  715.   }
    716. 

  716. 

  717. %typemap(m3destruct_derived, methodname="Dispose") SWIGTYPE {
    718. 

  718.     if(swigCPtr != IntPtr.Zero && swigCMemOwn) {
    719. 

  719.       $imcall;
    720. 

  720.       swigCMemOwn = false;
    721. 

  721.     }
    722. 

  722.     swigCPtr = IntPtr.Zero;
    723. 

  723.     GC.SuppressFinalize(this);
    724. 

  724.     base.Dispose();
    725. 

  725.   }
    726. 

  726. 

  727. %typemap(m3getcptr) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) %{
    728. 

  728.   internal static IntPtr getCPtr($1_basetype obj) {
    729. 

  729.     RETURN (obj == null) ? IntPtr.Zero : obj.swigCPtr;
    730. 

  730.   }
    731. 

  731. %}
    732. 

  732. 

  733. /* M3 specific directives */
    734. 

  734. #define %m3multiretval        %feature("modula3:multiretval")
    735. 

  735. #define %constnumeric(num)    %feature("constnumeric","num")
    736. 

  736. 

  737. %pragma(modula3) moduleimports=%{
    738. 

  738. IMPORT BlaBla;
    739. 

  739. %}
    740. 

  740. 

  741. %pragma(modula3) imclassimports=%{
    742. 

  742. FROM BlaBla IMPORT Bla;
    743. 

  743. %}
    744. 

  744. 

  745. /* Some ANSI C typemaps */
    746. 

  746. 

  747. %apply unsigned long { size_t };
    748. 

  748. 

  749. /* Array reference typemaps */
    750. 

  750. %apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
    751. 

  751. 

  752. /* const pointers */
    753. 

  753. %apply SWIGTYPE * { SWIGTYPE *const }
    754. 

  754. 

  755.