Lib/octave/octprimtypes.swg

   1 /* ------------------------------------------------------------
   2  * Primitive Types
   3  * ------------------------------------------------------------ */
   4
   5
   6 // boolean
   7
   8 %fragment(SWIG_From_frag(bool),"header") {
   9 SWIGINTERNINLINE octave_value
  10   SWIG_From_dec(bool)(bool value)
  11 {
  12   return octave_value(value);
  13 }
  14 }
  15
  16 %fragment(SWIG_AsVal_frag(bool),"header",
  17           fragment=SWIG_AsVal_frag(long)) {
  18 SWIGINTERN int
  19 SWIG_AsVal_dec(bool)(const octave_value& ov, bool *val)
  20 {
  21   if (!ov.is_bool_type())
  22     return SWIG_ERROR;
  23   if (val)
  24     *val = ov.bool_value();
  25   return SWIG_OK;
  26 }
  27 }
  28
  29 // long
  30
  31 %fragment(SWIG_From_frag(long),"header") {
  32   SWIGINTERNINLINE octave_value SWIG_From_dec(long)  (long value)
  33     {
  34       return octave_value(value);
  35     }
  36 }
  37
  38
  39 %fragment(SWIG_AsVal_frag(long),"header") {
  40   SWIGINTERN int SWIG_AsVal_dec(long)(const octave_value& ov, long* val)
  41     {
  42       if (!ov.is_scalar_type())
  43         return SWIG_TypeError;
  44       if (ov.is_complex_scalar())
  45         return SWIG_TypeError;
  46       if (ov.is_double_type()||ov.is_single_type()) {
  47         double v=ov.double_value();
  48         if (v!=floor(v))
  49           return SWIG_TypeError;
  50       }
  51       if (val)
  52         *val = ov.long_value();
  53       return SWIG_OK;
  54     }
  55 }
  56
  57 // unsigned long
  58
  59 %fragment(SWIG_From_frag(unsigned long),"header") {
  60   SWIGINTERNINLINE octave_value SWIG_From_dec(unsigned long)  (unsigned long value)
  61     {
  62       return octave_value(value);
  63     }
  64 }
  65
  66
  67 %fragment(SWIG_AsVal_frag(unsigned long),"header") {
  68   SWIGINTERN int SWIG_AsVal_dec(unsigned long)(const octave_value& ov, unsigned long* val)
  69     {
  70       if (!ov.is_scalar_type())
  71         return SWIG_TypeError;
  72       if (ov.is_complex_scalar())
  73         return SWIG_TypeError;
  74       if (ov.is_double_type()||ov.is_single_type()) {
  75         double v=ov.double_value();
  76         if (v<0)
  77           return SWIG_OverflowError;
  78         if (v!=floor(v))
  79           return SWIG_TypeError;
  80       }
  81       if (ov.is_int8_type()||ov.is_int16_type()||
  82           ov.is_int32_type()) {
  83         long v=ov.long_value();
  84         if (v<0)
  85           return SWIG_OverflowError;
  86       }
  87       if (ov.is_int64_type()) {
  88         long long v=ov.int64_scalar_value().value();
  89         if (v<0)
  90           return SWIG_OverflowError;
  91       }
  92       if (val)
  93         *val = ov.ulong_value();
  94       return SWIG_OK;
  95     }
  96 }
  97
  98 // long long
  99
 100 %fragment(SWIG_From_frag(long long),"header") {
 101   SWIGINTERNINLINE octave_value SWIG_From_dec(long long)  (long long value)
 102     {
 103       return octave_int64(value);
 104     }
 105 }
 106
 107
 108 %fragment(SWIG_AsVal_frag(long long),"header") {
 109   SWIGINTERN int SWIG_AsVal_dec(long long)(const octave_value& ov, long long* val)
 110     {
 111       if (!ov.is_scalar_type())
 112         return SWIG_TypeError;
 113       if (ov.is_complex_scalar())
 114         return SWIG_TypeError;
 115       if (ov.is_double_type()||ov.is_single_type()) {
 116         double v=ov.double_value();
 117         if (v!=floor(v))
 118           return SWIG_TypeError;
 119       }
 120       if (val) {
 121         if (ov.is_int64_type())
 122           *val = ov.int64_scalar_value().value();
 123         else if (ov.is_uint64_type())
 124           *val = ov.uint64_scalar_value().value();
 125         else
 126           *val = ov.long_value();
 127       }
 128       return SWIG_OK;
 129     }
 130 }
 131
 132 %fragment(SWIG_From_frag(unsigned long long),"header") {
 133   SWIGINTERNINLINE octave_value SWIG_From_dec(unsigned long long)  (unsigned long long value)
 134     {
 135       return octave_uint64(value);
 136     }
 137 }
 138
 139 %fragment(SWIG_AsVal_frag(unsigned long long),"header") {
 140   SWIGINTERN int SWIG_AsVal_dec(unsigned long long)(const octave_value& ov, unsigned long long* val)
 141     {
 142       if (!ov.is_scalar_type())
 143         return SWIG_TypeError;
 144       if (ov.is_complex_scalar())
 145         return SWIG_TypeError;
 146       if (ov.is_double_type()||ov.is_single_type()) {
 147         double v=ov.double_value();
 148         if (v<0)
 149           return SWIG_OverflowError;
 150         if (v!=floor(v))
 151           return SWIG_TypeError;
 152       }
 153       if (ov.is_int8_type()||ov.is_int16_type()||
 154           ov.is_int32_type()) {
 155         long v=ov.long_value();
 156         if (v<0)
 157           return SWIG_OverflowError;
 158       }
 159       if (ov.is_int64_type()) {
 160         long long v=ov.int64_scalar_value().value();
 161         if (v<0)
 162           return SWIG_OverflowError;
 163       }
 164       if (val) {
 165         if (ov.is_int64_type())
 166           *val = ov.int64_scalar_value().value();
 167         else if (ov.is_uint64_type())
 168           *val = ov.uint64_scalar_value().value();
 169         else
 170           *val = ov.long_value();
 171       }
 172       return SWIG_OK;
 173     }
 174 }
 175
 176 // double
 177
 178 %fragment(SWIG_From_frag(double),"header") {
 179   SWIGINTERNINLINE octave_value SWIG_From_dec(double)  (double value)
 180     {
 181       return octave_value(value);
 182     }
 183 }
 184
 185
 186 %fragment(SWIG_AsVal_frag(double),"header") {
 187   SWIGINTERN int SWIG_AsVal_dec(double)(const octave_value& ov, double* val)
 188     {
 189       if (!ov.is_scalar_type())
 190         return SWIG_TypeError;
 191       if (ov.is_complex_scalar())
 192         return SWIG_TypeError;
 193       if (val)
 194         *val = ov.double_value();
 195       return SWIG_OK;
 196     }
 197 }
 198
 199 // const char* (strings)
 200
 201 %fragment("SWIG_AsCharPtrAndSize","header") {
 202 SWIGINTERN int
 203 SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc)
 204 {
 205   if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
 206     ov = ov.cell_value()(0);
 207   if (!ov.is_string())
 208     return SWIG_TypeError;
 209
 210   std::string str=ov.string_value();
 211   size_t len=str.size();
 212   char* cstr=(char*)str.c_str();
 213   if (alloc) {
 214     *cptr = %new_copy_array(cstr, len + 1, char);
 215     *alloc = SWIG_NEWOBJ;
 216   } else if (cptr)
 217     *cptr = cstr;
 218   if (psize)
 219     *psize = len + 1;
 220   return SWIG_OK;
 221 }
 222 }
 223
 224 %fragment("SWIG_FromCharPtrAndSize","header",fragment="SWIG_pchar_descriptor") {
 225 SWIGINTERNINLINE octave_value
 226 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
 227 {
 228   return std::string(carray,carray+size);
 229 }
 230 }
 231
 232