Lib/ocaml/cstring.i

   1 /* -----------------------------------------------------------------------------
   2  * See the LICENSE file for information on copyright, usage and redistribution
   3  * of SWIG, and the README file for authors - http://www.swig.org/release.html.
   4  *
   5  * cstring.i
   6  *
   7  * This file provides typemaps and macros for dealing with various forms
   8  * of C character string handling.   The primary use of this module
   9  * is in returning character data that has been allocated or changed in
  10  * some way.
  11  * ----------------------------------------------------------------------------- */
  12
  13 /* %cstring_input_binary(TYPEMAP, SIZE)
  14  *
  15  * Macro makes a function accept binary string data along with
  16  * a size.
  17  */
  18
  19 %define %cstring_input_binary(TYPEMAP, SIZE)
  20 %apply (char *STRING, int LENGTH) { (TYPEMAP, SIZE) };
  21 %enddef
  22
  23 /*
  24  * %cstring_bounded_output(TYPEMAP, MAX)
  25  *
  26  * This macro is used to return a NULL-terminated output string of
  27  * some maximum length.  For example:
  28  *
  29  *     %cstring_bounded_output(char *outx, 512);
  30  *     void foo(char *outx) {
  31  *         sprintf(outx,"blah blah\n");
  32  *     }
  33  *
  34  */
  35
  36 %define %cstring_bounded_output(TYPEMAP,MAX)
  37 %typemap(ignore) TYPEMAP(char temp[MAX+1]) {
  38     $1 = ($1_ltype) temp;
  39 }
  40 %typemap(argout) TYPEMAP {
  41     $1[MAX] = 0;
  42     $result = caml_list_append($result,caml_val_string(str));
  43 }
  44 %enddef
  45
  46 /*
  47  * %cstring_chunk_output(TYPEMAP, SIZE)
  48  *
  49  * This macro is used to return a chunk of binary string data.
  50  * Embedded NULLs are okay.  For example:
  51  *
  52  *     %cstring_chunk_output(char *outx, 512);
  53  *     void foo(char *outx) {
  54  *         memmove(outx, somedata, 512);
  55  *     }
  56  *
  57  */
  58
  59 %define %cstring_chunk_output(TYPEMAP,SIZE)
  60 %typemap(ignore) TYPEMAP(char temp[SIZE]) {
  61     $1 = ($1_ltype) temp;
  62 }
  63 %typemap(argout) TYPEMAP {
  64     $result = caml_list_append($result,caml_val_string_len($1,SIZE));
  65 }
  66 %enddef
  67
  68 /*
  69  * %cstring_bounded_mutable(TYPEMAP, SIZE)
  70  *
  71  * This macro is used to wrap a string that's going to mutate.
  72  *
  73  *     %cstring_bounded_mutable(char *in, 512);
  74  *     void foo(in *x) {
  75  *         while (*x) {
  76  *            *x = toupper(*x);
  77  *            x++;
  78  *         }
  79  *     }
  80  *
  81  */
  82
  83
  84 %define %cstring_bounded_mutable(TYPEMAP,MAX)
  85 %typemap(in) TYPEMAP(char temp[MAX+1]) {
  86     char *t = (char *)caml_ptr_val($input);
  87     strncpy(temp,t,MAX);
  88     $1 = ($1_ltype) temp;
  89 }
  90 %typemap(argout) TYPEMAP {
  91     $result = caml_list_append($result,caml_val_string_len($1,MAX));
  92 }
  93 %enddef
  94
  95 /*
  96  * %cstring_mutable(TYPEMAP [, expansion])
  97  *
  98  * This macro is used to wrap a string that will mutate in place.
  99  * It may change size up to a user-defined expansion.
 100  *
 101  *     %cstring_mutable(char *in);
 102  *     void foo(in *x) {
 103  *         while (*x) {
 104  *            *x = toupper(*x);
 105  *            x++;
 106  *         }
 107  *     }
 108  *
 109  */
 110
 111 %define %cstring_mutable(TYPEMAP,...)
 112 %typemap(in) TYPEMAP {
 113    char *t = String_val($input);
 114    int   n = string_length($input);
 115    $1 = ($1_ltype) t;
 116 #if #__VA_ARGS__ == ""
 117 #ifdef __cplusplus
 118    $1 = ($1_ltype) new char[n+1];
 119 #else
 120    $1 = ($1_ltype) malloc(n+1);
 121 #endif
 122 #else
 123 #ifdef __cplusplus
 124    $1 = ($1_ltype) new char[n+1+__VA_ARGS__];
 125 #else
 126    $1 = ($1_ltype) malloc(n+1+__VA_ARGS__);
 127 #endif
 128 #endif
 129    memmove($1,t,n);
 130    $1[n] = 0;
 131 }
 132
 133 %typemap(argout) TYPEMAP {
 134     $result = caml_list_append($result,caml_val_string($1));
 135 #ifdef __cplusplus
 136    delete[] $1;
 137 #else
 138    free($1);
 139 #endif
 140 }
 141 %enddef
 142
 143 /*
 144  * %cstring_output_maxsize(TYPEMAP, SIZE)
 145  *
 146  * This macro returns data in a string of some user-defined size.
 147  *
 148  *     %cstring_output_maxsize(char *outx, int max) {
 149  *     void foo(char *outx, int max) {
 150  *         sprintf(outx,"blah blah\n");
 151  *     }
 152  */
 153
 154 %define %cstring_output_maxsize(TYPEMAP, SIZE)
 155 %typemap(in) (TYPEMAP, SIZE) {
 156    $2 = caml_val_long($input);
 157 #ifdef __cplusplus
 158    $1 = ($1_ltype) new char[$2+1];
 159 #else
 160    $1 = ($1_ltype) malloc($2+1);
 161 #endif
 162 }
 163 %typemap(argout) (TYPEMAP,SIZE) {
 164     $result = caml_list_append($result,caml_val_string($1));
 165 #ifdef __cplusplus
 166    delete [] $1;
 167 #else
 168    free($1);
 169 #endif
 170 }
 171 %enddef
 172
 173 /*
 174  * %cstring_output_withsize(TYPEMAP, SIZE)
 175  *
 176  * This macro is used to return character data along with a size
 177  * parameter.
 178  *
 179  *     %cstring_output_maxsize(char *outx, int *max) {
 180  *     void foo(char *outx, int *max) {
 181  *         sprintf(outx,"blah blah\n");
 182  *         *max = strlen(outx);
 183  *     }
 184  */
 185
 186 %define %cstring_output_withsize(TYPEMAP, SIZE)
 187 %typemap(in) (TYPEMAP, SIZE) {
 188    int n = caml_val_long($input);
 189 #ifdef __cplusplus
 190    $1 = ($1_ltype) new char[n+1];
 191    $2 = ($2_ltype) new $*1_ltype;
 192 #else
 193    $1 = ($1_ltype) malloc(n+1);
 194    $2 = ($2_ltype) malloc(sizeof($*1_ltype));
 195 #endif
 196    *$2 = n;
 197 }
 198 %typemap(argout) (TYPEMAP,SIZE) {
 199     $result = caml_list_append($result,caml_val_string_len($1,$2));
 200 #ifdef __cplusplus
 201    delete [] $1;
 202    delete $2;
 203 #else
 204    free($1);
 205    free($2);
 206 #endif
 207 }
 208 %enddef
 209
 210 /*
 211  * %cstring_output_allocate(TYPEMAP, RELEASE)
 212  *
 213  * This macro is used to return character data that was
 214  * allocated with new or malloc.
 215  *
 216  *     %cstring_output_allocated(char **outx, free($1));
 217  *     void foo(char **outx) {
 218  *         *outx = (char *) malloc(512);
 219  *         sprintf(outx,"blah blah\n");
 220  *     }
 221  */
 222
 223 %define %cstring_output_allocate(TYPEMAP, RELEASE)
 224 %typemap(ignore) TYPEMAP($*1_ltype temp = 0) {
 225    $1 = &temp;
 226 }
 227
 228 %typemap(argout) TYPEMAP {
 229     if (*$1) {
 230         $result = caml_list_append($result,caml_val_string($1));
 231         RELEASE;
 232     } else {
 233         $result = caml_list_append($result,caml_val_ptr($1));
 234     }
 235 }
 236 %enddef
 237
 238 /*
 239  * %cstring_output_allocate_size(TYPEMAP, SIZE, RELEASE)
 240  *
 241  * This macro is used to return character data that was
 242  * allocated with new or malloc.
 243  *
 244  *     %cstring_output_allocated(char **outx, int *sz, free($1));
 245  *     void foo(char **outx, int *sz) {
 246  *         *outx = (char *) malloc(512);
 247  *         sprintf(outx,"blah blah\n");
 248  *         *sz = strlen(outx);
 249  *     }
 250  */
 251
 252 %define %cstring_output_allocate_size(TYPEMAP, SIZE, RELEASE)
 253 %typemap(ignore) (TYPEMAP, SIZE) ($*1_ltype temp = 0, $*2_ltype tempn) {
 254    $1 = &temp;
 255    $2 = &tempn;
 256 }
 257
 258 %typemap(argout)(TYPEMAP,SIZE) {
 259     if (*$1) {
 260         $result = caml_list_append($result,caml_val_string_len($1,$2));
 261         RELEASE;
 262     } else
 263         $result = caml_list_append($result,caml_val_ptr($1));
 264 }
 265 %enddef
 266
 267
 268
 269
 270
 271