libgfortran/intrinsics/iso_c_generated_procs.c

   1 /* Implementation of the ISO_C_BINDING library helper generated functions.
   2    Copyright (C) 2007 Free Software Foundation, Inc.
   3    Contributed by Christopher Rickett.
   4
   5 This file is part of the GNU Fortran 95 runtime library (libgfortran).
   6
   7 Libgfortran is free software; you can redistribute it and/or
   8 modify it under the terms of the GNU General Public
   9 License as published by the Free Software Foundation; either
  10 version 2 of the License, or (at your option) any later version.
  11
  12 In addition to the permissions in the GNU General Public License, the
  13 Free Software Foundation gives you unlimited permission to link the
  14 compiled version of this file into combinations with other programs,
  15 and to distribute those combinations without any restriction coming
  16 from the use of this file.  (The General Public License restrictions
  17 do apply in other respects; for example, they cover modification of
  18 the file, and distribution when not linked into a combine
  19 executable.)
  20
  21 Libgfortran is distributed in the hope that it will be useful,
  22 but WITHOUT ANY WARRANTY; without even the implied warranty of
  23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24 GNU General Public License for more details.
  25
  26 You should have received a copy of the GNU General Public
  27 License along with libgfortran; see the file COPYING.  If not,
  28 write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  29 Boston, MA 02110-1301, USA.  */
  30
  31
  32 #include "libgfortran.h"
  33 #include "iso_c_binding.h"
  34
  35
  36 /* TODO: This file needs to be finished so that a function is provided
  37    for all possible type/kind combinations!  */
  38
  39 #ifdef HAVE_GFC_INTEGER_1
  40 void ISO_C_BINDING_PREFIX (c_f_pointer_i1) (void *, gfc_array_void *,
  41                                             const array_t *);
  42 #endif
  43
  44 #ifdef HAVE_GFC_INTEGER_2
  45 void ISO_C_BINDING_PREFIX (c_f_pointer_i2) (void *, gfc_array_void *,
  46                                             const array_t *);
  47 #endif
  48
  49 #ifdef HAVE_GFC_INTEGER_4
  50 void ISO_C_BINDING_PREFIX (c_f_pointer_i4) (void *, gfc_array_void *,
  51                                             const array_t *);
  52 #endif
  53
  54 #ifdef HAVE_GFC_INTEGER_8
  55 void ISO_C_BINDING_PREFIX (c_f_pointer_i8) (void *, gfc_array_void *,
  56                                             const array_t *);
  57 #endif
  58
  59 #ifdef HAVE_GFC_INTEGER_16
  60 void ISO_C_BINDING_PREFIX (c_f_pointer_i16) (void *, gfc_array_void *,
  61                                              const array_t *);
  62 #endif
  63
  64 #ifdef HAVE_GFC_REAL_4
  65 void ISO_C_BINDING_PREFIX (c_f_pointer_r4) (void *, gfc_array_void *,
  66                                             const array_t *);
  67 #endif
  68
  69 #ifdef HAVE_GFC_REAL_8
  70 void ISO_C_BINDING_PREFIX (c_f_pointer_r8) (void *, gfc_array_void *,
  71                                             const array_t *);
  72 #endif
  73
  74 #ifdef HAVE_GFC_REAL_10
  75 void ISO_C_BINDING_PREFIX (c_f_pointer_r10) (void *, gfc_array_void *,
  76                                              const array_t *);
  77 #endif
  78
  79 #ifdef HAVE_GFC_REAL_16
  80 void ISO_C_BINDING_PREFIX (c_f_pointer_r16) (void *, gfc_array_void *,
  81                                              const array_t *);
  82 #endif
  83
  84 #ifdef HAVE_GFC_COMPLEX_4
  85 void ISO_C_BINDING_PREFIX (c_f_pointer_c4) (void *, gfc_array_void *,
  86                                             const array_t *);
  87 #endif
  88
  89 #ifdef HAVE_GFC_COMPLEX_8
  90 void ISO_C_BINDING_PREFIX (c_f_pointer_c8) (void *, gfc_array_void *,
  91                                             const array_t *);
  92 #endif
  93
  94 #ifdef HAVE_GFC_COMPLEX_10
  95 void ISO_C_BINDING_PREFIX (c_f_pointer_c10) (void *, gfc_array_void *,
  96                                              const array_t *);
  97 #endif
  98
  99 #ifdef HAVE_GFC_COMPLEX_16
 100 void ISO_C_BINDING_PREFIX (c_f_pointer_c16) (void *, gfc_array_void *,
 101                                              const array_t *);
 102 #endif
 103
 104 #ifdef GFC_DEFAULT_CHAR
 105 void ISO_C_BINDING_PREFIX (c_f_pointer_s0) (void *, gfc_array_void *,
 106                                             const array_t *);
 107 #endif
 108
 109 #ifdef HAVE_GFC_LOGICAL_1
 110 void ISO_C_BINDING_PREFIX (c_f_pointer_l1) (void *, gfc_array_void *,
 111                                             const array_t *);
 112 #endif
 113
 114 #ifdef HAVE_GFC_LOGICAL_2
 115 void ISO_C_BINDING_PREFIX (c_f_pointer_l2) (void *, gfc_array_void *,
 116                                             const array_t *);
 117 #endif
 118
 119 #ifdef HAVE_GFC_LOGICAL_4
 120 void ISO_C_BINDING_PREFIX (c_f_pointer_l4) (void *, gfc_array_void *,
 121                                             const array_t *);
 122 #endif
 123
 124 #ifdef HAVE_GFC_LOGICAL_8
 125 void ISO_C_BINDING_PREFIX (c_f_pointer_l8) (void *, gfc_array_void *,
 126                                             const array_t *);
 127 #endif
 128
 129
 130 #ifdef HAVE_GFC_INTEGER_1
 131 /* Set the given Fortran pointer, 'f_ptr_out', to point to the given C
 132    address, 'c_ptr_in'.  The Fortran pointer is of type integer and
 133    kind=1.  The function c_f_pointer is used to set up the pointer
 134    descriptor.  shape is a one-dimensional array of integers
 135    specifying the upper bounds of the array pointed to by the given C
 136    address, if applicable.  'shape' is an optional parameter in
 137    Fortran, so if the user does not provide it, it will come in here
 138    as NULL.  */
 139
 140 void
 141 ISO_C_BINDING_PREFIX (c_f_pointer_i1) (void *c_ptr_in,
 142                                        gfc_array_void *f_ptr_out,
 143                                        const array_t *shape)
 144 {
 145   /* Here we have an integer(kind=1).  */
 146   ISO_C_BINDING_PREFIX (c_f_pointer) (c_ptr_in, f_ptr_out, shape,
 147                                       (int) GFC_DTYPE_INTEGER,
 148                                       (int) sizeof (GFC_INTEGER_1));
 149 }
 150 #endif
 151
 152
 153 #ifdef HAVE_GFC_INTEGER_2
 154 /* Set the given Fortran pointer, 'f_ptr_out', to point to the given C
 155    address, 'c_ptr_in'.  The Fortran pointer is of type integer and
 156    kind=2.  The function c_f_pointer is used to set up the pointer
 157    descriptor.  shape is a one-dimensional array of integers
 158    specifying the upper bounds of the array pointed to by the given C
 159    address, if applicable.  'shape' is an optional parameter in
 160    Fortran, so if the user does not provide it, it will come in here
 161    as NULL.  */
 162
 163 void
 164 ISO_C_BINDING_PREFIX (c_f_pointer_i2) (void *c_ptr_in,
 165                                        gfc_array_void *f_ptr_out,
 166                                        const array_t *shape)
 167 {
 168   /* Here we have an integer(kind=2).  */
 169   ISO_C_BINDING_PREFIX (c_f_pointer) (c_ptr_in, f_ptr_out, shape,
 170                                       (int) GFC_DTYPE_INTEGER,
 171                                       (int) sizeof (GFC_INTEGER_2));
 172 }
 173 #endif
 174
 175
 176 #ifdef HAVE_GFC_INTEGER_4
 177 /* Set the given Fortran pointer, f_ptr_out, to point to the given C
 178    address, c_ptr_in.  The Fortran pointer is of type integer and
 179    kind=4.  The function c_f_pointer is used to set up the pointer
 180    descriptor.  */
 181
 182 void
 183 ISO_C_BINDING_PREFIX (c_f_pointer_i4) (void *c_ptr_in,
 184                                        gfc_array_void *f_ptr_out,
 185                                        const array_t *shape)
 186 {
 187   /* Here we have an integer(kind=4).  */
 188   ISO_C_BINDING_PREFIX (c_f_pointer) (c_ptr_in, f_ptr_out, shape,
 189                                       (int) GFC_DTYPE_INTEGER,
 190                                       (int) sizeof (GFC_INTEGER_4));
 191 }
 192 #endif
 193
 194
 195 #ifdef HAVE_GFC_INTEGER_8
 196 /* Set the given Fortran pointer, f_ptr_out, to point to the given C
 197    address, c_ptr_in.  The Fortran pointer is of type integer and
 198    kind=8.  The function c_f_pointer is used to set up the pointer
 199    descriptor.  */
 200
 201 void
 202 ISO_C_BINDING_PREFIX (c_f_pointer_i8) (void *c_ptr_in,
 203                                        gfc_array_void *f_ptr_out,
 204                                        const array_t *shape)
 205 {
 206   /* Here we have an integer(kind=8).  */
 207   ISO_C_BINDING_PREFIX (c_f_pointer) (c_ptr_in, f_ptr_out, shape,
 208                                       (int) GFC_DTYPE_INTEGER,
 209                                       (int) sizeof (GFC_INTEGER_8));
 210 }
 211 #endif
 212
 213
 214 #ifdef HAVE_GFC_INTEGER_16
 215 /* Set the given Fortran pointer, 'f_ptr_out', to point to the given C
 216    address, 'c_ptr_in'.  The Fortran pointer is of type integer and
 217    kind=16.  The function c_f_pointer is used to set up the pointer
 218    descriptor.  shape is a one-dimensional array of integers
 219    specifying the upper bounds of the array pointed to by the given C
 220    address, if applicable.  'shape' is an optional parameter in
 221    Fortran, so if the user does not provide it, it will come in here
 222    as NULL.  */
 223
 224 void
 225 ISO_C_BINDING_PREFIX (c_f_pointer_i16) (void *c_ptr_in,
 226                                         gfc_array_void *f_ptr_out,
 227                                         const array_t *shape)
 228 {
 229   /* Here we have an integer(kind=16).  */
 230   ISO_C_BINDING_PREFIX (c_f_pointer) (c_ptr_in, f_ptr_out, shape,
 231                                       (int) GFC_DTYPE_INTEGER,
 232                                       (int) sizeof (GFC_INTEGER_16));
 233 }
 234 #endif
 235
 236
 237 #ifdef HAVE_GFC_REAL_4
 238 /* Set the given Fortran pointer, f_ptr_out, to point to the given C
 239    address, c_ptr_in.  The Fortran pointer is of type real and
 240    kind=4.  The function c_f_pointer is used to set up the pointer
 241    descriptor.  */
 242
 243 void
 244 ISO_C_BINDING_PREFIX (c_f_pointer_r4) (void *c_ptr_in,
 245                                        gfc_array_void *f_ptr_out,
 246                                        const array_t *shape)
 247 {
 248   /* Here we have an real(kind=4).  */
 249   ISO_C_BINDING_PREFIX (c_f_pointer) (c_ptr_in, f_ptr_out, shape,
 250                                       (int) GFC_DTYPE_REAL,
 251                                       (int) sizeof (GFC_REAL_4));
 252 }
 253 #endif
 254
 255
 256 #ifdef HAVE_GFC_REAL_8
 257 /* Set the given Fortran pointer, f_ptr_out, to point to the given C
 258    address, c_ptr_in.  The Fortran pointer is of type real and
 259    kind=8.  The function c_f_pointer is used to set up the pointer
 260    descriptor.  */
 261
 262 void
 263 ISO_C_BINDING_PREFIX (c_f_pointer_r8) (void *c_ptr_in,
 264                                        gfc_array_void *f_ptr_out,
 265                                        const array_t *shape)
 266 {
 267   /* Here we have an real(kind=8).  */
 268   ISO_C_BINDING_PREFIX (c_f_pointer) (c_ptr_in, f_ptr_out, shape,
 269                                       (int) GFC_DTYPE_REAL,
 270                                       (int) sizeof (GFC_REAL_8));
 271 }
 272 #endif
 273
 274
 275 #ifdef HAVE_GFC_REAL_10
 276 /* Set the given Fortran pointer, f_ptr_out, to point to the given C
 277    address, c_ptr_in.  The Fortran pointer is of type real and
 278    kind=10.  The function c_f_pointer is used to set up the pointer
 279    descriptor.  */
 280
 281 void
 282 ISO_C_BINDING_PREFIX (c_f_pointer_r10) (void *c_ptr_in,
 283                                         gfc_array_void *f_ptr_out,
 284                                         const array_t *shape)
 285 {
 286   /* Here we have an real(kind=10).  */
 287   ISO_C_BINDING_PREFIX (c_f_pointer) (c_ptr_in, f_ptr_out, shape,
 288                                       (int) GFC_DTYPE_REAL,
 289                                       (int) sizeof (GFC_REAL_10));
 290 }
 291 #endif
 292
 293
 294 #ifdef HAVE_GFC_REAL_16
 295 /* Set the given Fortran pointer, f_ptr_out, to point to the given C
 296    address, c_ptr_in.  The Fortran pointer is of type real and
 297    kind=16.  The function c_f_pointer is used to set up the pointer
 298    descriptor.  */
 299
 300 void
 301 ISO_C_BINDING_PREFIX (c_f_pointer_r16) (void *c_ptr_in,
 302                                         gfc_array_void *f_ptr_out,
 303                                         const array_t *shape)
 304 {
 305   /* Here we have an real(kind=16).  */
 306   ISO_C_BINDING_PREFIX (c_f_pointer) (c_ptr_in, f_ptr_out, shape,
 307                                       (int) GFC_DTYPE_REAL,
 308                                       (int) sizeof (GFC_REAL_16));
 309 }
 310 #endif
 311
 312
 313 #ifdef HAVE_GFC_COMPLEX_4
 314 /* Set the given Fortran pointer, f_ptr_out, to point to the given C
 315    address, c_ptr_in.  The Fortran pointer is of type complex and
 316    kind=4.  The function c_f_pointer is used to set up the pointer
 317    descriptor.  */
 318
 319 void
 320 ISO_C_BINDING_PREFIX (c_f_pointer_c4) (void *c_ptr_in,
 321                                        gfc_array_void *f_ptr_out,
 322                                        const array_t *shape)
 323 {
 324   /* Here we have an complex(kind=4).  */
 325   ISO_C_BINDING_PREFIX (c_f_pointer) (c_ptr_in, f_ptr_out, shape,
 326                                       (int) GFC_DTYPE_COMPLEX,
 327                                       (int) sizeof (GFC_COMPLEX_4));
 328 }
 329 #endif
 330
 331
 332 #ifdef HAVE_GFC_COMPLEX_8
 333 /* Set the given Fortran pointer, f_ptr_out, to point to the given C
 334    address, c_ptr_in.  The Fortran pointer is of type complex and
 335    kind=8.  The function c_f_pointer is used to set up the pointer
 336    descriptor.  */
 337
 338 void
 339 ISO_C_BINDING_PREFIX (c_f_pointer_c8) (void *c_ptr_in,
 340                                        gfc_array_void *f_ptr_out,
 341                                        const array_t *shape)
 342 {
 343   /* Here we have an complex(kind=8).  */
 344   ISO_C_BINDING_PREFIX (c_f_pointer) (c_ptr_in, f_ptr_out, shape,
 345                                       (int) GFC_DTYPE_COMPLEX,
 346                                       (int) sizeof (GFC_COMPLEX_8));
 347 }
 348 #endif
 349
 350
 351 #ifdef HAVE_GFC_COMPLEX_10
 352 /* Set the given Fortran pointer, f_ptr_out, to point to the given C
 353    address, c_ptr_in.  The Fortran pointer is of type complex and
 354    kind=10.  The function c_f_pointer is used to set up the pointer
 355    descriptor.  */
 356
 357 void
 358 ISO_C_BINDING_PREFIX (c_f_pointer_c10) (void *c_ptr_in,
 359                                         gfc_array_void *f_ptr_out,
 360                                         const array_t *shape)
 361 {
 362   /* Here we have an complex(kind=10).  */
 363   ISO_C_BINDING_PREFIX (c_f_pointer) (c_ptr_in, f_ptr_out, shape,
 364                                       (int) GFC_DTYPE_COMPLEX,
 365                                       (int) sizeof (GFC_COMPLEX_10));
 366 }
 367 #endif
 368
 369
 370 #ifdef HAVE_GFC_COMPLEX_16
 371 /* Set the given Fortran pointer, f_ptr_out, to point to the given C
 372    address, c_ptr_in.  The Fortran pointer is of type complex and
 373    kind=16.  The function c_f_pointer is used to set up the pointer
 374    descriptor.  */
 375
 376 void
 377 ISO_C_BINDING_PREFIX (c_f_pointer_c16) (void *c_ptr_in,
 378                                         gfc_array_void *f_ptr_out,
 379                                         const array_t *shape)
 380 {
 381   /* Here we have an complex(kind=16).  */
 382   ISO_C_BINDING_PREFIX (c_f_pointer) (c_ptr_in, f_ptr_out, shape,
 383                                       (int) GFC_DTYPE_COMPLEX,
 384                                       (int) sizeof (GFC_COMPLEX_16));
 385 }
 386 #endif
 387
 388
 389 #ifdef GFC_DEFAULT_CHAR
 390 /* Set the given Fortran pointer, f_ptr_out, to point to the given C
 391    address, c_ptr_in.  The Fortran pointer is of type character.  */
 392
 393 void
 394 ISO_C_BINDING_PREFIX (c_f_pointer_s0) (void *c_ptr_in,
 395                                        gfc_array_void *f_ptr_out,
 396                                        const array_t *shape)
 397 {
 398   /* Here we have a character string of len=1.  */
 399   ISO_C_BINDING_PREFIX (c_f_pointer) (c_ptr_in, f_ptr_out, shape,
 400                                       (int) GFC_DTYPE_CHARACTER,
 401                                       (int) sizeof (char));
 402 }
 403 #endif
 404
 405
 406 #ifdef HAVE_GFC_LOGICAL_1
 407 /* Set the given Fortran pointer, f_ptr_out, to point to the given C
 408    address, c_ptr_in.  The Fortran pointer is of type logical, kind=1.  */
 409
 410 void
 411 ISO_C_BINDING_PREFIX (c_f_pointer_l1) (void *c_ptr_in,
 412                                        gfc_array_void *f_ptr_out,
 413                                        const array_t *shape)
 414 {
 415   /* Here we have a logical of kind=1.  */
 416   ISO_C_BINDING_PREFIX (c_f_pointer) (c_ptr_in, f_ptr_out, shape,
 417                                       (int) GFC_DTYPE_LOGICAL,
 418                                       (int) sizeof (GFC_LOGICAL_1));
 419 }
 420 #endif
 421
 422
 423 #ifdef HAVE_GFC_LOGICAL_2
 424 /* Set the given Fortran pointer, f_ptr_out, to point to the given C
 425    address, c_ptr_in.  The Fortran pointer is of type logical, kind=2.  */
 426
 427 void
 428 ISO_C_BINDING_PREFIX (c_f_pointer_l2) (void *c_ptr_in,
 429                                        gfc_array_void *f_ptr_out,
 430                                        const array_t *shape)
 431 {
 432   /* Here we have a logical of kind=2.  */
 433   ISO_C_BINDING_PREFIX (c_f_pointer) (c_ptr_in, f_ptr_out, shape,
 434                                       (int) GFC_DTYPE_LOGICAL,
 435                                       (int) sizeof (GFC_LOGICAL_2));
 436 }
 437 #endif
 438
 439
 440 #ifdef HAVE_GFC_LOGICAL_4
 441 /* Set the given Fortran pointer, f_ptr_out, to point to the given C
 442    address, c_ptr_in.  The Fortran pointer is of type logical, kind=4.  */
 443
 444 void
 445 ISO_C_BINDING_PREFIX (c_f_pointer_l4) (void *c_ptr_in,
 446                                        gfc_array_void *f_ptr_out,
 447                                        const array_t *shape)
 448 {
 449   /* Here we have a logical of kind=4.  */
 450   ISO_C_BINDING_PREFIX (c_f_pointer) (c_ptr_in, f_ptr_out, shape,
 451                                       (int) GFC_DTYPE_LOGICAL,
 452                                       (int) sizeof (GFC_LOGICAL_4));
 453 }
 454 #endif
 455
 456
 457 #ifdef HAVE_GFC_LOGICAL_8
 458 /* Set the given Fortran pointer, f_ptr_out, to point to the given C
 459    address, c_ptr_in.  The Fortran pointer is of type logical, kind=8.  */
 460
 461 void
 462 ISO_C_BINDING_PREFIX (c_f_pointer_l8) (void *c_ptr_in,
 463                                        gfc_array_void *f_ptr_out,
 464                                        const array_t *shape)
 465 {
 466   /* Here we have a logical of kind=8.  */
 467   ISO_C_BINDING_PREFIX (c_f_pointer) (c_ptr_in, f_ptr_out, shape,
 468                                       (int) GFC_DTYPE_LOGICAL,
 469                                       (int) sizeof (GFC_LOGICAL_8));
 470 }
 471 #endif