1# Copyright (c) Lawrence Livermore National Security, LLC and other Conduit 2# Project developers. See top-level LICENSE AND COPYRIGHT files for dates and 3# other details. No copyright assignment is required to contribute to Conduit. 4 5############################################################################### 6# Conduit Data Type IDs 7############################################################################### 8 9################################################ 10# generic types 11################################################ 12set(CONDUIT_EMPTY_ID 0) 13set(CONDUIT_OBJECT_ID 1) 14set(CONDUIT_LIST_ID 2) 15################################################ 16# signed integer types 17################################################ 18set(CONDUIT_INT8_ID 3) 19set(CONDUIT_INT16_ID 4) 20set(CONDUIT_INT32_ID 5) 21set(CONDUIT_INT64_ID 6) 22################################################ 23# unsigned integer types 24################################################ 25set(CONDUIT_UINT8_ID 7) 26set(CONDUIT_UINT16_ID 8) 27set(CONDUIT_UINT32_ID 9) 28set(CONDUIT_UINT64_ID 10) 29################################################ 30# floating point types 31################################################ 32set(CONDUIT_FLOAT32_ID 11) 33set(CONDUIT_FLOAT64_ID 12) 34################################################ 35# string types 36################################################ 37set(CONDUIT_CHAR8_STR_ID 13) 38 39 40#----------------------------------------------------------------------------- 41# Logic to provide bitwidth annotated style standard data types 42#----------------------------------------------------------------------------- 43# Derived from numpy (which provides very comprehensive support 44# for these types) 45#----------------------------------------------------------------------------- 46 47#-------------------------------------------------------------------------- 48# bytes to bits size definitions 49#-------------------------------------------------------------------------- 50# NOTE: we are assuming a char is 8 bits (CHAR_BIT in limits.h will tell us ) 51# In the future we should do a CMake try_compile check to make sure. 52# 53set(CONDUIT_BITSOF_CHAR 8) 54 55math(EXPR CONDUIT_BITSOF_SHORT "${CONDUIT_SIZEOF_SHORT} * ${CONDUIT_BITSOF_CHAR}") 56math(EXPR CONDUIT_BITSOF_INT "${CONDUIT_SIZEOF_INT} * ${CONDUIT_BITSOF_CHAR}") 57math(EXPR CONDUIT_BITSOF_LONG "${CONDUIT_SIZEOF_LONG} * ${CONDUIT_BITSOF_CHAR}") 58 59if(CONDUIT_HAS_LONG_LONG) 60 math(EXPR CONDUIT_BITSOF_LONG_LONG "${CONDUIT_SIZEOF_LONG_LONG} * ${CONDUIT_BITSOF_CHAR}") 61endif() 62 63math(EXPR CONDUIT_BITSOF_FLOAT "${CONDUIT_SIZEOF_FLOAT} * ${CONDUIT_BITSOF_CHAR}") 64math(EXPR CONDUIT_BITSOF_DOUBLE "${CONDUIT_SIZEOF_DOUBLE} * ${CONDUIT_BITSOF_CHAR}") 65 66if(CONDUIT_HAS_LONG_DOUBLE) 67 math(EXPR CONDUIT_BITSOF_LONG_DOUBLE "${CONDUIT_SIZEOF_LONG_DOUBLE} * ${CONDUIT_BITSOF_CHAR}") 68endif() 69 70 71#----------------------------------------------------------------------------- 72# -- long long type mapping -- 73#----------------------------------------------------------------------------- 74macro(bitwidth_map_long_long) 75if(CONDUIT_HAS_LONG_LONG) 76 if(${CONDUIT_BITSOF_LONG_LONG} EQUAL 8) 77 #### 78 # conduit to native 79 #### 80 # make sure we haven't already mapped this type 81 if(NOT CONDUIT_INT8_TYPE) 82 set(CONDUIT_USE_LONG_LONG 1) 83 # 84 set(CONDUIT_INT8_TYPE "conduit_signed_long_long") 85 set(CONDUIT_UINT8_TYPE "conduit_unsigned_long_long") 86 # 87 set(CONDUIT_INT8_NATIVE_TYPE "signed long long") 88 set(CONDUIT_UINT8_NATIVE_TYPE "unsigned long long") 89 # 90 endif() 91 #### 92 # native to conduit 93 #### 94 # check to see if the native type map has been made 95 if(NOT CONDUIT_NATIVE_SIGNED_LONG_LONG_ID) 96 # 97 set(CONDUIT_NATIVE_SIGNED_LONG_LONG_ID ${CONDUIT_INT8_ID}) 98 set(CONDUIT_NATIVE_UNSIGNED_LONG_LONG_ID ${CONDUIT_UINT8_ID}) 99 # 100 set(CONDUIT_NATIVE_SIGNED_LONG_LONG_TYPE "conduit_int8") 101 set(CONDUIT_NATIVE_UNSIGNED_LONG_LONG_TYPE "conduit_uint8") 102 endif() 103 elseif(${CONDUIT_BITSOF_LONG_LONG} EQUAL 16) 104 #### 105 # conduit to native 106 #### 107 # make sure we haven't already mapped this type 108 if(NOT CONDUIT_INT16_TYPE) 109 set(CONDUIT_USE_LONG_LONG 1) 110 # 111 set(CONDUIT_INT16_TYPE "conduit_signed_long_long") 112 set(CONDUIT_UINT16_TYPE "conduit_unsigned_long_long") 113 # 114 set(CONDUIT_INT16_NATIVE_TYPE "signed long long") 115 set(CONDUIT_UINT16_NATIVE_TYPE "unsigned long long") 116 # 117 endif() 118 #### 119 # native to conduit 120 #### 121 # check to see if the native type map has been made 122 if(NOT CONDUIT_NATIVE_SIGNED_LONG_LONG_ID) 123 # 124 set(CONDUIT_NATIVE_SIGNED_LONG_LONG_ID ${CONDUIT_INT16_ID}) 125 set(CONDUIT_NATIVE_UNSIGNED_LONG_LONG_ID ${CONDUIT_UINT16_ID}) 126 # 127 set(CONDUIT_NATIVE_SIGNED_LONG_LONG_ID "conduit_int16") 128 set(CONDUIT_NATIVE_UNSIGNED_LONG_LONG_ID "conduit_uint16") 129 endif() 130 elseif(${CONDUIT_BITSOF_LONG_LONG} EQUAL 32) 131 #### 132 # conduit to native 133 #### 134 # make sure we haven't already mapped this type 135 if(NOT CONDUIT_INT32_TYPE) 136 set(CONDUIT_USE_LONG_LONG 1) 137 # 138 set(CONDUIT_INT32_TYPE "conduit_signed_long_long") 139 set(CONDUIT_UINT32_TYPE "conduit_unsigned_long_long") 140 # 141 set(CONDUIT_INT32_NATIVE_TYPE "signed long long") 142 set(CONDUIT_UINT32_NATIVE_TYPE "unsigned long long") 143 # 144 endif() 145 ################################################ 146 # native to conduit 147 #### 148 # check to see if the native type map has been made 149 if(NOT CONDUIT_NATIVE_SIGNED_LONG_LONG_ID) 150 # 151 set(CONDUIT_NATIVE_SIGNED_LONG_LONG_ID ${CONDUIT_INT32_ID}) 152 set(CONDUIT_NATIVE_UNSIGNED_LONG_LONG_ID ${CONDUIT_UINT32_ID}) 153 # 154 set(CONDUIT_NATIVE_SIGNED_LONG_LONG_TYPE "conduit_int32") 155 set(CONDUIT_NATIVE_UNSIGNED_LONG_LONG_TYPE "conduit_uint32") 156 endif() 157 elseif(${CONDUIT_BITSOF_LONG_LONG} EQUAL 64) 158 #### 159 # conduit to native 160 #### 161 # make sure we haven't already mapped this type 162 if(NOT CONDUIT_INT64_TYPE) 163 set(CONDUIT_USE_LONG_LONG 1) 164 # 165 set(CONDUIT_INT64_TYPE "conduit_signed_long_long") 166 set(CONDUIT_UINT64_TYPE "conduit_unsigned_long_long") 167 # 168 set(CONDUIT_INT64_NATIVE_TYPE "signed long long") 169 set(CONDUIT_UINT64_NATIVE_TYPE "unsigned long long") 170 # 171 endif() 172 #### 173 # native to conduit 174 #### 175 # check to see if the native type map has been made 176 if(NOT CONDUIT_NATIVE_SIGNED_LONG_LONG_TYPE) 177 # 178 set(CONDUIT_NATIVE_SIGNED_LONG_LONG_ID ${CONDUIT_INT64_ID}) 179 set(CONDUIT_NATIVE_UNSIGNED_LONG_LONG_ID ${CONDUIT_UINT64_ID}) 180 # 181 set(CONDUIT_NATIVE_SIGNED_LONG_LONG_TYPE "conduit_int64") 182 set(CONDUIT_NATIVE_UNSIGNED_LONG_LONG_TYPE "conduit_uint64") 183 endif() 184 endif() 185endif() 186endmacro() 187 188#------------------------------------------------------------------------------ 189# -- long type mapping -- 190#------------------------------------------------------------------------------ 191macro(bitwidth_map_long) 192if(${CONDUIT_BITSOF_LONG} EQUAL 8) 193 #### 194 # conduit to native 195 #### 196 # make sure we haven't already mapped this type 197 if(NOT CONDUIT_INT8_TYPE) 198 set(CONDUIT_USE_LONG 1) 199 # 200 set(CONDUIT_INT8_TYPE "conduit_signed_long") 201 set(CONDUIT_UINT8_TYPE "conduit_unsigned_long") 202 # 203 set(CONDUIT_INT8_NATIVE_TYPE "signed long") 204 set(CONDUIT_UINT8_NATIVE_TYPE "unsigned long") 205 endif() 206 #### 207 # native to conduit 208 #### 209 # check to see if the native type map has been made 210 if(NOT CONDUIT_NATIVE_SIGNED_LONG_TYPE) 211 set(CONDUIT_NATIVE_SIGNED_LONG_ID ${CONDUIT_INT8_ID}) 212 set(CONDUIT_NATIVE_UNSIGNED_LONG_ID ${CONDUIT_UINT8_ID}) 213 # 214 set(CONDUIT_NATIVE_SIGNED_LONG_TYPE "conduit_int8") 215 set(CONDUIT_NATIVE_UNSIGNED_LONG_TYPE "conduit_uint8") 216 endif() 217elseif(${CONDUIT_BITSOF_LONG} EQUAL 16) 218 #### 219 # conduit to native 220 #### 221 # make sure we haven't already mapped this type 222 if(NOT CONDUIT_INT16_TYPE) 223 set(CONDUIT_USE_LONG 1) 224 # 225 set(CONDUIT_INT16_TYPE "conduit_signed_long") 226 set(CONDUIT_UINT16_TYPE "conduit_unsigned_long") 227 # 228 set(CONDUIT_INT16_NATIVE_TYPE "signed long") 229 set(CONDUIT_UINT16_NATIVE_TYPE "unsigned long") 230 endif() 231 #### 232 # native to conduit 233 #### 234 # check to see if the native type map has been made 235 if(NOT CONDUIT_NATIVE_SIGNED_LONG_TYPE) 236 # 237 set(CONDUIT_NATIVE_SIGNED_LONG_ID ${CONDUIT_INT16_ID}) 238 set(CONDUIT_NATIVE_UNSIGNED_LONG_ID ${CONDUIT_UINT16_ID}) 239 # 240 set(CONDUIT_NATIVE_SIGNED_LONG_TYPE "conduit_int16") 241 set(CONDUIT_NATIVE_UNSIGNED_LONG_TYPE "conduit_uint16") 242 endif() 243elseif(${CONDUIT_BITSOF_LONG} EQUAL 32) 244 #### 245 # conduit to native 246 #### 247 # make sure we haven't already mapped this type 248 if(NOT CONDUIT_INT32_TYPE) 249 set(CONDUIT_USE_LONG 1) 250 # 251 set(CONDUIT_INT32_TYPE "conduit_signed_long") 252 set(CONDUIT_UINT32_TYPE "conduit_unsigned_long") 253 # 254 set(CONDUIT_INT32_NATIVE_TYPE "signed long") 255 set(CONDUIT_UINT32_NATIVE_TYPE "unsigned long") 256 endif() 257 #### 258 # native to conduit 259 #### 260 # check to see if the native type map has been made 261 if(NOT CONDUIT_NATIVE_SIGNED_LONG_TYPE) 262 # 263 set(CONDUIT_NATIVE_SIGNED_LONG_ID ${CONDUIT_INT32_ID}) 264 set(CONDUIT_NATIVE_UNSIGNED_LONG_ID ${CONDUIT_UINT32_ID}) 265 # 266 set(CONDUIT_NATIVE_SIGNED_LONG_TYPE "conduit_int32") 267 set(CONDUIT_NATIVE_UNSIGNED_LONG_TYPE "conduit_uint32") 268 endif() 269elseif(${CONDUIT_BITSOF_LONG} EQUAL 64) 270 #### 271 # conduit to native 272 #### 273 # make sure we haven't already mapped this type 274 if(NOT CONDUIT_INT64_TYPE) 275 set(CONDUIT_USE_LONG 1) 276 # 277 set(CONDUIT_INT64_TYPE "conduit_signed_long") 278 set(CONDUIT_UINT64_TYPE "conduit_unsigned_long") 279 # 280 set(CONDUIT_INT64_NATIVE_TYPE "signed long") 281 set(CONDUIT_UINT64_NATIVE_TYPE "unsigned long") 282 endif() 283 #### 284 # native to conduit 285 #### 286 # check to see if the native type map has been made 287 if(NOT CONDUIT_NATIVE_SIGNED_LONG_TYPE) 288 # 289 set(CONDUIT_NATIVE_SIGNED_LONG_ID ${CONDUIT_INT64_ID}) 290 set(CONDUIT_NATIVE_UNSIGNED_LONG_ID ${CONDUIT_UINT64_ID}) 291 # 292 set(CONDUIT_NATIVE_SIGNED_LONG_TYPE "conduit_int64") 293 set(CONDUIT_NATIVE_UNSIGNED_LONG_TYPE "conduit_uint64") 294 endif() 295endif() 296endmacro() 297 298#----------------------------------------------------------------------------- 299# -- int size checks -- 300#----------------------------------------------------------------------------- 301macro(bitwidth_map_int) 302if(${CONDUIT_BITSOF_INT} EQUAL 8) 303 #### 304 # conduit to native 305 #### 306 # make sure we haven't already mapped this type 307 if(NOT CONDUIT_INT8_TYPE) 308 set(CONDUIT_USE_INT 1) 309 # 310 set(CONDUIT_INT8_TYPE "conduit_int") 311 set(CONDUIT_UINT8_TYPE "conduit_uint") 312 # 313 set(CONDUIT_INT8_NATIVE_TYPE "signed int") 314 set(CONDUIT_UINT8_NATIVE_TYPE "unsigned int") 315 endif() 316 #### 317 # native to conduit 318 #### 319 # check to see if the native type map has been made 320 if(NOT CONDUIT_NATIVE_SIGNED_INT_TYPE) 321 # 322 set(CONDUIT_NATIVE_SIGNED_INT_ID ${CONDUIT_INT8_ID}) 323 set(CONDUIT_NATIVE_UNSIGNED_INT_ID ${CONDUIT_UINT8_ID}) 324 # 325 set(CONDUIT_NATIVE_SIGNED_INT_TYPE "conduit_int8") 326 set(CONDUIT_NATIVE_UNSIGNED_INT_TYPE "conduit_uint8") 327 endif() 328elseif(${CONDUIT_BITSOF_INT} EQUAL 16) 329 #### 330 # conduit to native 331 #### 332 # make sure we haven't already mapped this type 333 if(NOT CONDUIT_INT16_TYPE) 334 set(CONDUIT_USE_INT 1) 335 # 336 set(CONDUIT_INT16_TYPE "conduit_signed_int") 337 set(CONDUIT_UINT16_TYPE "conduit_unsigned_int") 338 # 339 set(CONDUIT_INT16_NATIVE_TYPE "signed int") 340 set(CONDUIT_UINT16_NATIVE_TYPE "unsigned int") 341 endif() 342 #### 343 # native to conduit 344 #### 345 # check to see if the native type map has been made 346 if(NOT CONDUIT_NATIVE_SIGNED_INT_TYPE) 347 # 348 set(CONDUIT_NATIVE_SIGNED_INT_ID ${CONDUIT_INT16_ID}) 349 set(CONDUIT_NATIVE_UNSIGNED_INT_ID ${CONDUIT_UINT16_ID}) 350 # 351 set(CONDUIT_NATIVE_SIGNED_INT_TYPE "conduit_int16") 352 set(CONDUIT_NATIVE_UNSIGNED_INT_TYPE "conduit_uint16") 353 endif() 354elseif(${CONDUIT_BITSOF_INT} EQUAL 32) 355 #### 356 # conduit to native 357 #### 358 # make sure we haven't already mapped this type 359 if(NOT CONDUIT_INT32_TYPE) 360 set(CONDUIT_USE_INT 1) 361 # 362 set(CONDUIT_INT32_TYPE "conduit_signed_int") 363 set(CONDUIT_UINT32_TYPE "conduit_unsigned_int") 364 # 365 set(CONDUIT_INT32_NATIVE_TYPE "signed int") 366 set(CONDUIT_UINT32_NATIVE_TYPE "unsigned int") 367 endif() 368 #### 369 # native to conduit 370 #### 371 # check to see if the native type map has been made 372 if(NOT CONDUIT_NATIVE_SIGNED_INT_TYPE) 373 # 374 set(CONDUIT_NATIVE_SIGNED_INT_ID ${CONDUIT_INT32_ID}) 375 set(CONDUIT_NATIVE_UNSIGNED_INT_ID ${CONDUIT_UINT32_ID}) 376 # 377 set(CONDUIT_NATIVE_SIGNED_INT_TYPE "conduit_int32") 378 set(CONDUIT_NATIVE_UNSIGNED_INT_TYPE "conduit_uint32") 379 endif() 380elseif(${CONDUIT_BITSOF_INT} EQUAL 64) 381 #### 382 # conduit to native 383 #### 384 # make sure we haven't already mapped this type 385 if(NOT CONDUIT_INT64_TYPE) 386 set(CONDUIT_USE_INT 1) 387 # 388 set(CONDUIT_INT64_TYPE "conduit_int") 389 set(CONDUIT_UINT64_TYPE "conduit_uint") 390 # 391 set(CONDUIT_INT64_NATIVE_TYPE "signed int") 392 set(CONDUIT_UINT64_NATIVE_TYPE "unsigned int") 393 endif() 394 #### 395 # native to conduit 396 #### 397 # check to see if the native type map has been made 398 if(NOT CONDUIT_NATIVE_SIGNED_INT_TYPE) 399 # 400 set(CONDUIT_NATIVE_SIGNED_INT_ID ${CONDUIT_INT64_ID}) 401 set(CONDUIT_NATIVE_UNSIGNED_INT_ID ${CONDUIT_UINT64_ID}) 402 # 403 set(CONDUIT_NATIVE_SIGNED_INT_TYPE "conduit_int64") 404 set(CONDUIT_NATIVE_UNSIGNED_INT_TYPE "conduit_uint64") 405 endif() 406endif() 407endmacro() 408 409 410#----------------------------------------------------------------------------- 411# -- short type mapping -- 412#----------------------------------------------------------------------------- 413macro(bitwidth_map_short) 414if(${CONDUIT_BITSOF_SHORT} EQUAL 8) 415 #### 416 # conduit to native 417 #### 418 # make sure we haven't already mapped this type 419 if(NOT CONDUIT_INT8_TYPE) 420 set(CONDUIT_USE_SHORT 1) 421 # 422 set(CONDUIT_INT8_TYPE "conduit_signed_short") 423 set(CONDUIT_UINT8_TYPE "conduit_unsigned_short") 424 # 425 set(CONDUIT_INT8_NATIVE_TYPE "signed short") 426 set(CONDUIT_UINT8_NATIVE_TYPE "unsigned short") 427 endif() 428 #### 429 # native to conduit 430 #### 431 # check to see if the native type map has been made 432 if(NOT CONDUIT_NATIVE_SIGNED_SHORT_TYPE) 433 # 434 set(CONDUIT_NATIVE_SIGNED_SHORT_ID ${CONDUIT_INT8_ID}) 435 set(CONDUIT_NATIVE_UNSIGNED_SHORT_ID ${CONDUIT_UINT8_ID}) 436 # 437 set(CONDUIT_NATIVE_SIGNED_SHORT_TYPE "conduit_int8") 438 set(CONDUIT_NATIVE_UNSIGNED_SHORT_TYPE "conduit_uint8") 439 endif() 440elseif(${CONDUIT_BITSOF_SHORT} EQUAL 16) 441 #### 442 # conduit to native 443 #### 444 # make sure we haven't already mapped this type 445 if(NOT CONDUIT_INT16_TYPE) 446 set(CONDUIT_USE_SHORT 1) 447 # 448 set(CONDUIT_INT16_TYPE "conduit_signed_short") 449 set(CONDUIT_UINT16_TYPE "conduit_unsigned_short") 450 # 451 set(CONDUIT_INT16_NATIVE_TYPE "signed short") 452 set(CONDUIT_UINT16_NATIVE_TYPE "unsigned short") 453 endif() 454 #### 455 # native to conduit 456 #### 457 # check to see if the native type map has been made 458 if(NOT CONDUIT_NATIVE_SIGNED_SHORT_TYPE) 459 # 460 set(CONDUIT_NATIVE_SIGNED_SHORT_ID ${CONDUIT_INT16_ID}) 461 set(CONDUIT_NATIVE_UNSIGNED_SHORT_ID ${CONDUIT_UINT16_ID}) 462 # 463 set(CONDUIT_NATIVE_SIGNED_SHORT_TYPE "conduit_int16") 464 set(CONDUIT_NATIVE_UNSIGNED_SHORT_TYPE "conduit_uint16") 465 endif() 466elseif(${CONDUIT_BITSOF_SHORT} EQUAL 32) 467 #### 468 # conduit to native 469 #### 470 # make sure we haven't already mapped this type 471 if(NOT CONDUIT_INT32_TYPE) 472 set(CONDUIT_USE_SHORT 1) 473 # 474 set(CONDUIT_INT32_TYPE "conduit_signed_short") 475 set(CONDUIT_UINT32_TYPE "conduit_unsigned_short") 476 # 477 set(CONDUIT_INT32_NATIVE_TYPE "signed short") 478 set(CONDUIT_UINT32_NATIVE_TYPE "unsigned short") 479 endif() 480 #### 481 # native to conduit 482 #### 483 # check to see if the native type map has been made 484 if(NOT CONDUIT_NATIVE_SIGNED_SHORT_TYPE) 485 # 486 set(CONDUIT_NATIVE_SIGNED_SHORT_ID ${CONDUIT_INT32_ID}) 487 set(CONDUIT_NATIVE_UNSIGNED_SHORT_ID ${CONDUIT_UINT32_ID}) 488 # 489 set(CONDUIT_NATIVE_SIGNED_SHORT_TYPE "conduit_int32") 490 set(CONDUIT_NATIVE_UNSIGNED_SHORT_TYPE "conduit_uint32") 491 endif() 492elseif(${CONDUIT_BITSOF_SHORT} EQUAL 64) 493 #### 494 # conduit to native 495 #### 496 # make sure we haven't already mapped this type 497 if(NOT CONDUIT_INT64_TYPE) 498 set(CONDUIT_USE_SHORT 1) 499 # 500 set(CONDUIT_INT64_TYPE "conduit_signed_short") 501 set(CONDUIT_UINT64_TYPE "conduit_unsigned_short") 502 # 503 set(CONDUIT_INT64_NATIVE_TYPE "signed short") 504 set(CONDUIT_UINT64_NATIVE_TYPE "unsigned short") 505 endif() 506 #### 507 # native to conduit 508 #### 509 # check to see if the native type map has been made 510 if(NOT CONDUIT_NATIVE_SIGNED_INT_TYPE) 511 # 512 set(CONDUIT_NATIVE_SIGNED_SHORT_ID ${CONDUIT_INT64_ID}) 513 set(CONDUIT_NATIVE_UNSIGNED_SHORT_ID ${CONDUIT_UINT64_ID}) 514 # 515 set(CONDUIT_NATIVE_SIGNED_SHORT_TYPE "conduit_int64") 516 set(CONDUIT_NATIVE_UNSIGNED_SHORT_TYPE "conduit_uint64") 517 endif() 518endif() 519endmacro() 520 521 522#----------------------------------------------------------------------------- 523# -- char type mapping -- 524#----------------------------------------------------------------------------- 525macro(bitwidth_map_char) 526if(${CONDUIT_BITSOF_CHAR} EQUAL 8) 527 #### 528 # conduit to native 529 #### 530 # make sure we haven't already mapped this type 531 if(NOT CONDUIT_INT8_TYPE) 532 set(CONDUIT_USE_CHAR 1) 533 # 534 set(CONDUIT_INT8_TYPE "conduit_signed_char") 535 set(CONDUIT_UINT8_TYPE "conduit_unsigned_char") 536 # 537 set(CONDUIT_INT8_NATIVE_TYPE "signed char") 538 set(CONDUIT_UINT8_NATIVE_TYPE "unsigned char") 539 endif() 540 #### 541 # native to conduit 542 #### 543 # check to see if the native type map has been made 544 if(NOT CONDUIT_NATIVE_SIGNED_CHAR_TYPE) 545 # 546 set(CONDUIT_NATIVE_SIGNED_CHAR_ID ${CONDUIT_INT8_ID}) 547 set(CONDUIT_NATIVE_UNSIGNED_CHAR_ID ${CONDUIT_UINT8_ID}) 548 # 549 set(CONDUIT_NATIVE_SIGNED_CHAR_TYPE "conduit_int8") 550 set(CONDUIT_NATIVE_UNSIGNED_CHAR_TYPE "conduit_uint8") 551 endif() 552elseif(${CONDUIT_BITSOF_SHORT} EQUAL 16) 553 #### 554 # conduit to native 555 #### 556 # make sure we haven't already mapped this type 557 if(NOT CONDUIT_INT16_TYPE) 558 set(CONDUIT_USE_CHAR 1) 559 # 560 set(CONDUIT_INT16_TYPE "conduit_signed_char") 561 set(CONDUIT_UINT16_TYPE "conduit_unsigned_char") 562 # 563 set(CONDUIT_INT16_NATIVE_TYPE "signed char") 564 set(CONDUIT_UINT16_NATIVE_TYPE "unsigned char") 565 endif() 566 #### 567 # native to conduit 568 #### 569 # check to see if the native type map has been made 570 if(NOT CONDUIT_NATIVE_SIGNED_CHAR_TYPE) 571 # 572 set(CONDUIT_NATIVE_SIGNED_CHAR_ID ${CONDUIT_INT16_ID}) 573 set(CONDUIT_NATIVE_UNSIGNED_CHAR_ID ${CONDUIT_UINT16_ID}) 574 # 575 set(CONDUIT_NATIVE_SIGNED_CHAR_TYPE "conduit_int16") 576 set(CONDUIT_NATIVE_UNSIGNED_CHAR_TYPE "conduit_uint16") 577 endif() 578elseif(${CONDUIT_BITSOF_SHORT} EQUAL 32) 579 #### 580 # conduit to native 581 #### 582 # make sure we haven't already mapped this type 583 if(NOT CONDUIT_INT32_TYPE) 584 set(CONDUIT_USE_CHAR 1) 585 # 586 set(CONDUIT_INT32_TYPE "conduit_signed_char") 587 set(CONDUIT_UINT32_TYPE "conduit_unsigned_char") 588 # 589 set(CONDUIT_INT32_NATIVE_TYPE "signed char") 590 set(CONDUIT_UINT32_NATIVE_TYPE "unsigned char") 591 endif() 592 #### 593 # native to conduit 594 #### 595 # check to see if the native type map has been made 596 if(NOT CONDUIT_NATIVE_SIGNED_CHAR_TYPE) 597 # 598 set(CONDUIT_NATIVE_SIGNED_CHAR_ID ${CONDUIT_INT32_ID}) 599 set(CONDUIT_NATIVE_UNSIGNED_CHAR_ID ${CONDUIT_UINT32_ID}) 600 # 601 set(CONDUIT_NATIVE_SIGNED_CHAR_TYPE "conduit_int32") 602 set(CONDUIT_NATIVE_UNSIGNED_CHAR_TYPE "conduit_uint32") 603 endif() 604elseif(${CONDUIT_BITSOF_SHORT} EQUAL 64) 605 #### 606 # conduit to native 607 #### 608 # make sure we haven't already mapped this type 609 if(NOT CONDUIT_INT64_TYPE) 610 set(CONDUIT_USE_CHAR 1) 611 # 612 set(CONDUIT_INT64_TYPE "conduit_signed_char") 613 set(CONDUIT_UINT64_TYPE "conduit_unsigned_char") 614 # 615 set(CONDUIT_INT64_NATIVE_TYPE "signed_char") 616 set(CONDUIT_UINT64_NATIVE_TYPE "unsigned char") 617 endif() 618 #### 619 # native to conduit 620 #### 621 # check to see if the native type map has been made 622 if(NOT CONDUIT_NATIVE_SIGNED_CHAR_TYPE) 623 # 624 set(CONDUIT_NATIVE_SIGNED_CHAR_ID ${CONDUIT_INT64_ID}) 625 set(CONDUIT_NATIVE_UNSIGNED_CHAR_ID ${CONDUIT_UINT64_ID}) 626 # 627 set(CONDUIT_NATIVE_SIGNED_CHAR_TYPE "conduit_int64") 628 set(CONDUIT_NATIVE_UNSIGNED_CHAR_TYPE "conduit_uint64") 629 endif() 630endif() 631endmacro() 632 633 634#----------------------------------------------------------------------------- 635# -- double type mapping -- 636#----------------------------------------------------------------------------- 637macro(bitwidth_map_double) 638if(${CONDUIT_BITSOF_DOUBLE} EQUAL 32) 639 #### 640 # conduit to native 641 #### 642 # make sure we haven't already mapped this type 643 if(NOT CONDUIT_FLOAT32_TYPE) 644 set(CONDUIT_USE_DOUBLE 1) 645 set(CONDUIT_FLOAT32_TYPE "conduit_double") 646 # 647 set(CONDUIT_FLOAT32_NATIVE_TYPE "double") 648 endif() 649 #### 650 # native to conduit 651 #### 652 # check to see if the native type map has been made 653 if(NOT CONDUIT_NATIVE_DOUBLE_TYPE) 654 set(CONDUIT_NATIVE_DOUBLE_ID ${CONDUIT_FLOAT32_ID}) 655 # 656 set(CONDUIT_NATIVE_DOUBLE_TYPE "conduit_float32") 657 endif() 658elseif(${CONDUIT_BITSOF_DOUBLE} EQUAL 64) 659 #### 660 # conduit to native 661 #### 662 # make sure we haven't already mapped this type 663 if(NOT CONDUIT_FLOAT64_TYPE) 664 set(CONDUIT_USE_DOUBLE 1) 665 set(CONDUIT_FLOAT64_TYPE "conduit_double") 666 # 667 set(CONDUIT_FLOAT64_NATIVE_TYPE "double") 668 endif() 669 #### 670 # native to conduit 671 #### 672 # check to see if the native type map has been made 673 if(NOT CONDUIT_NATIVE_DOUBLE_TYPE) 674 set(CONDUIT_NATIVE_DOUBLE_ID ${CONDUIT_FLOAT64_ID}) 675 # 676 set(CONDUIT_NATIVE_DOUBLE_TYPE "conduit_float64") 677 endif() 678endif() 679endmacro() 680 681#----------------------------------------------------------------------------- 682# -- float type mapping -- 683#----------------------------------------------------------------------------- 684macro(bitwidth_map_float) 685if(${CONDUIT_BITSOF_FLOAT} EQUAL 32) 686 #### 687 # conduit to native 688 #### 689 # make sure we haven't already mapped this type 690 if(NOT CONDUIT_FLOAT32_TYPE) 691 set(CONDUIT_USE_FLOAT 1) 692 set(CONDUIT_FLOAT32_TYPE "conduit_float") 693 # 694 set(CONDUIT_FLOAT32_NATIVE_TYPE "float") 695 endif() 696 #### 697 # native to conduit 698 #### 699 # check to see if the native type map has been made 700 if(NOT CONDUIT_NATIVE_FLOAT_TYPE) 701 set(CONDUIT_NATIVE_FLOAT_ID ${CONDUIT_FLOAT32_ID}) 702 # 703 set(CONDUIT_NATIVE_FLOAT_TYPE "conduit_float32") 704 endif() 705elseif(${CONDUIT_BITSOF_FLOAT} EQUAL 64) 706 #### 707 # conduit to native 708 #### 709 # make sure we haven't already mapped this type 710 if(NOT CONDUIT_FLOAT64_TYPE) 711 set(CONDUIT_USE_FLOAT 1) 712 set(CONDUIT_FLOAT64_TYPE "conduit_float") 713 # 714 set(CONDUIT_FLOAT64_NATIVE_TYPE "float") 715 endif() 716 #### 717 # native to conduit 718 #### 719 # check to see if the native type map has been made 720 if(NOT CONDUIT_NATIVE_FLOAT_TYPE) 721 set(CONDUIT_NATIVE_FLOAT_ID ${CONDUIT_FLOAT64_ID}) 722 # 723 set(CONDUIT_NATIVE_FLOAT_TYPE "conduit_float64") 724 endif() 725endif() 726endmacro() 727 728#----------------------------------------------------------------------------- 729# -- long double type mapping -- 730#----------------------------------------------------------------------------- 731macro(bitwidth_map_long_double) 732if(${CONDUIT_HAS_LONG_DOUBLE}) 733 if(${CONDUIT_BITSOF_LONG_DOUBLE} EQUAL 32) 734 #### 735 # conduit to native 736 #### 737 # make sure we haven't already mapped this type 738 if(NOT CONDUIT_FLOAT32_TYPE) 739 set(CONDUIT_USE_LONG_DOUBLE 1) 740 set(CONDUIT_FLOAT32_TYPE "conduit_long_double") 741 # 742 set(CONDUIT_FLOAT32_NATIVE_TYPE "long double") 743 endif() 744 #### 745 # native to conduit 746 #### 747 # check to see if the native type map has been made 748 if(NOT CONDUIT_NATIVE_FLOAT_TYPE) 749 set(CONDUIT_NATIVE_LONG_DOUBLE_ID ${CONDUIT_FLOAT32_ID}) 750 # 751 set(CONDUIT_NATIVE_LONG_DOUBLE_TYPE "conduit_float32") 752 endif() 753 elseif(${CONDUIT_BITSOF_LONG_DOUBLE} EQUAL 64) 754 #### 755 # conduit to native 756 #### 757 # make sure we haven't already mapped this type 758 if(NOT CONDUIT_FLOAT64_TYPE) 759 set(CONDUIT_USE_LONG_DOUBLE 1) 760 set(CONDUIT_FLOAT64_TYPE "conduit_long_double") 761 # 762 set(CONDUIT_FLOAT64_NATIVE_TYPE "long double") 763 endif() 764 #### 765 # native to conduit 766 #### 767 # check to see if the native type map has been made 768 if(NOT CONDUIT_NATIVE_LONG_DOUBLE_TYPE) 769 set(CONDUIT_NATIVE_LONG_DOUBLE_ID ${CONDUIT_FLOAT64_ID}) 770 # 771 set(CONDUIT_NATIVE_LONG_DOUBLE_TYPE "conduit_float64") 772 endif() 773 endif() 774endif() 775endmacro() 776 777#------------------------------------------------------------------------------ 778# End checks for numarray style bit-width names. 779#------------------------------------------------------------------------------ 780 781#----------------------------------------------------------------------------- 782# Map c native types to conduit bitwidth style types 783#----------------------------------------------------------------------------- 784# We prefer `long` by default. c++11 will map either `long` or `long long` 785# as int64, the choice is platform and/or compiler dependent. 786# We have use try_compile with c++11 to find if we should prefer `long long` 787# over `long`. 788#----------------------------------------------------------------------------- 789 790set(bitwidth_prefer_long_long FALSE) 791if(CONDUIT_USE_CXX11) 792 # note: this call assumes this file included from libs/conduit/CMakeLists.txt 793 try_compile( bitwidth_prefer_long_long # result var 794 ${CMAKE_CURRENT_BINARY_DIR}/cmake # build dir 795 SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_cxx11_check_if_long_long_is_std_int64.cpp 796 OUTPUT_VARIABLE bitwidth_prefer_long_long_out 797 CXX_STANDARD 11 798 CXX_STANDARD_REQUIRED TRUE) 799endif() 800 801 802# map our types using the macros above 803bitwidth_map_int() 804if(bitwidth_prefer_long_long) 805 message(STATUS "Bitwidth Mapping: preferring `long long` over `long` for c++11 compatibility") 806 bitwidth_map_long_long() 807 bitwidth_map_long() 808else() 809 message(STATUS "Bitwidth Mapping: preferring `long` over `long long` for c++11 compatibility") 810 bitwidth_map_long() 811 bitwidth_map_long_long() 812endif() 813 814bitwidth_map_short() 815bitwidth_map_char() 816 817# for fp types, use same mapping order for all platforms 818bitwidth_map_double() 819bitwidth_map_float() 820bitwidth_map_long_double() 821 822#----------------------------------------------------------------------------- 823# Display Mapping Results during CMake Configure 824#----------------------------------------------------------------------------- 825message(STATUS "Bitwidth Mapping Results:") 826#----------------------------------------------------------------------------- 827# -- bitwidth style signed integer types -- 828#----------------------------------------------------------------------------- 829message(STATUS " conduit::int8 native type: ${CONDUIT_INT8_NATIVE_TYPE}") 830message(STATUS " conduit::int16 native type: ${CONDUIT_INT16_NATIVE_TYPE}") 831message(STATUS " conduit::int32 native type: ${CONDUIT_INT32_NATIVE_TYPE}") 832message(STATUS " conduit::int64 native type: ${CONDUIT_INT64_NATIVE_TYPE}") 833 834#----------------------------------------------------------------------------- 835# -- bitwidth style unsigned integer types -- 836#----------------------------------------------------------------------------- 837message(STATUS " conduit::uint8 native type: ${CONDUIT_UINT8_NATIVE_TYPE}") 838message(STATUS " conduit::uint16 native type: ${CONDUIT_UINT16_NATIVE_TYPE}") 839message(STATUS " conduit::uint32 native type: ${CONDUIT_UINT32_NATIVE_TYPE}") 840message(STATUS " conduit::uint64 native type: ${CONDUIT_UINT64_NATIVE_TYPE}") 841 842#----------------------------------------------------------------------------- 843# -- bitwidth style floating point types 844#----------------------------------------------------------------------------- 845message(STATUS " conduit::float32 native type: ${CONDUIT_FLOAT32_NATIVE_TYPE}") 846message(STATUS " conduit::float64 native type: ${CONDUIT_FLOAT64_NATIVE_TYPE}") 847