lib/silcutil/silctypes.h

   1 /*
   2
   3   silctypes.h
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 2002 - 2007 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; version 2 of the License.
  12
  13   This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18 */
  19
  20 /****h* silcutil/SILC Types
  21  *
  22  * DESCRIPTION
  23  *
  24  *    This header includes the most basic types used in the SILC source
  25  *    tree, such as arithmetic types and their manipulation macros.  This
  26  *    file is included in the silcincludes.h and is automatically available
  27  *    for application.
  28  *
  29  ***/
  30
  31 #ifndef SILCTYPES_H
  32 #define SILCTYPES_H
  33
  34 /****d* silcutil/SILCTypes/SilcBool
  35  *
  36  * NAME
  37  *
  38  *    typedef unigned char SilcBool;
  39  *
  40  * DESCRIPTION
  41  *
  42  *    Boolean value, and is always 8-bits.  Represents value 0 or 1.
  43  *
  44  ***/
  45 typedef unsigned char SilcBool;
  46
  47 /* The bool macro is deprecated.  Use SilcBool instead. */
  48 #ifdef SILC_MACOSX
  49 #define bool _Bool
  50 #endif
  51 #ifndef __cplusplus
  52 #ifndef bool
  53 #define bool unsigned char
  54 #endif
  55 #endif
  56
  57 /****d* silcutil/SILCTypes/TRUE
  58  *
  59  * NAME
  60  *
  61  *    #define TRUE ...
  62  *
  63  * DESCRIPTION
  64  *
  65  *    Boolean true value indicator.
  66  *
  67  * SOURCE
  68  */
  69 #ifndef TRUE
  70 #define TRUE 1
  71 #endif
  72 /***/
  73
  74 /****d* silcutil/SILCTypes/FALSE
  75  *
  76  * NAME
  77  *
  78  *    #define FALSE ...
  79  *
  80  * DESCRIPTION
  81  *
  82  *    Boolean false value indicator.
  83  *
  84  * SOURCE
  85  */
  86 #ifndef FALSE
  87 #define FALSE 0
  88 #endif
  89 /***/
  90
  91 /* Our offsetof macro */
  92 #define silc_offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
  93
  94 /* silc_likely and silc_unlikely GCC branch prediction macros. Use only if
  95    you have profiled the code first. */
  96 #if __GNUC__ >= 3
  97 #define silc_likely(expr) __builtin_expect(!!(expr), 1)
  98 #define silc_unlikely(expr) __builtin_expect(!!(expr), 0)
  99 #else
 100 #define silc_likely(expr) (expr)
 101 #define silc_unlikely(expr) (expr)
 102 #endif /* __GNUC__ >= 3 */
 103
 104 #if SILC_SIZEOF_SHORT > 2
 105 #error "size of the short must be 2 bytes"
 106 #endif
 107
 108 /****d* silcutil/SILCTypes/SilcUInt8
 109  *
 110  * NAME
 111  *
 112  *    typedef unsigned char SilcUInt8;
 113  *
 114  * DESCRIPTION
 115  *
 116  *    8-bit unsigned integer.
 117  *
 118  * SOURCE
 119  */
 120 typedef unsigned char SilcUInt8;
 121 /***/
 122
 123 /****d* silcutil/SILCTypes/SilcInt8
 124  *
 125  * NAME
 126  *
 127  *    typedef signed char SilcInt8;
 128  *
 129  * DESCRIPTION
 130  *
 131  *    8-bit signed integer.
 132  *
 133  * SOURCE
 134  */
 135 typedef signed char SilcInt8;
 136 /***/
 137
 138 /****d* silcutil/SILCTypes/SilcUInt16
 139  *
 140  * NAME
 141  *
 142  *    typedef unsigned short SilcUInt16;
 143  *
 144  * DESCRIPTION
 145  *
 146  *    16-bit unsigned integer.  Guaranteed to be 16-bits.
 147  *
 148  * SOURCE
 149  */
 150 typedef unsigned short SilcUInt16;
 151 /***/
 152
 153 /****d* silcutil/SILCTypes/SilcInt16
 154  *
 155  * NAME
 156  *
 157  *    typedef signed short SilcInt16;
 158  *
 159  * DESCRIPTION
 160  *
 161  *    16-bit signed integer.  Guaranteed to be 16-bits.
 162  *
 163  * SOURCE
 164  */
 165 typedef signed short SilcInt16;
 166 /***/
 167
 168 /****d* silcutil/SILCTypes/SilcUInt32
 169  *
 170  * NAME
 171  *
 172  *    typedef unsigned long SilcUInt32;
 173  *
 174  * DESCRIPTION
 175  *
 176  *    32-bit unsigned integer.  Guaranteed to be 32-bits.
 177  *
 178  * SOURCE
 179  */
 180 #if SILC_SIZEOF_LONG == 4
 181 typedef unsigned long SilcUInt32;
 182 typedef signed long SilcInt32;
 183 #else
 184 #if SILC_SIZEOF_INT == 4
 185 typedef unsigned int SilcUInt32;
 186 typedef signed int SilcInt32;
 187 #else
 188 #if SILC_SIZEOF_LONG_LONG >= 4
 189 #ifndef WIN32
 190 typedef unsigned long long SilcUInt32;
 191 typedef signed long long SilcInt32;
 192 #endif
 193 #endif
 194 #endif
 195 #endif
 196 /***/
 197
 198 /****d* silcutil/SILCTypes/SilcInt32
 199  *
 200  * NAME
 201  *
 202  *    typedef signed long SilcInt32;
 203  *
 204  * DESCRIPTION
 205  *
 206  *    32-bit signed integer.  Guaranteed to be 32-bits.
 207  *
 208  ***/
 209
 210 /****d* silcutil/SILCTypes/SilcUInt64
 211  *
 212  * NAME
 213  *
 214  *    typedef unsigned long long SilcUInt64;
 215  *
 216  * DESCRIPTION
 217  *
 218  *    64-bit unsigned integer.  Guaranteed to be 64-bits on systems that
 219  *    support it.
 220  *
 221  * SOURCE
 222  */
 223 #if SILC_SIZEOF_LONG >= 8
 224 typedef unsigned long SilcUInt64;
 225 typedef signed long SilcInt64;
 226 #else
 227 #if SILC_SIZEOF_LONG_LONG >= 8
 228 #ifndef WIN32
 229 typedef unsigned long long SilcUInt64;
 230 typedef signed long long SilcInt64;
 231 #else
 232 typedef unsigned __int64 SilcUInt64;
 233 typedef signed __int64 SilcInt64;
 234 #endif
 235 #else
 236 typedef SilcUInt32 SilcUInt64;
 237 typedef SilcInt32 SilcInt64;
 238 #endif
 239 #endif
 240 /***/
 241
 242 /****d* silcutil/SILCTypes/SilcInt64
 243  *
 244  * NAME
 245  *
 246  *    typedef signed long long SilcInt64;
 247  *
 248  * DESCRIPTION
 249  *
 250  *    64-bit signed integer.  Guaranteed to be 64-bits on systems that
 251  *    support it.
 252  *
 253  ***/
 254
 255 #if SILC_SIZEOF_VOID_P < 4
 256 typedef SilcUInt32 * void *;
 257 #endif
 258
 259 /****d* silcutil/SILCTypes/SilcSocket
 260  *
 261  * NAME
 262  *
 263  *    SilcSocket
 264  *
 265  * DESCRIPTION
 266  *
 267  *    Platform specific socket.  On POSIX compliant systems this is simply
 268  *    an integer, representing the socket. On other systems it is platform
 269  *    specific socket context.  Access it only through routines that can
 270  *    handle SilcSocket types, unless you know what you are doing.
 271  *
 272  * SOURCE
 273  */
 274 #if defined(SILC_UNIX)
 275 typedef int SilcSocket;
 276 #elif defined(SILC_WIN32)
 277 typedef SOCKET SilcSocket;
 278 #elif defined(SILC_SYMBIAN)
 279 typedef void * SilcSocket;
 280 #endif
 281 /***/
 282
 283 /* Macros */
 284
 285 #define SILC_GET_WORD(cp) ((SilcUInt32)(SilcUInt8)(cp)[0]) << 24        \
 286                     | ((SilcUInt32)(SilcUInt8)(cp)[1] << 16)            \
 287                     | ((SilcUInt32)(SilcUInt8)(cp)[2] << 8)             \
 288                     | ((SilcUInt32)(SilcUInt8)(cp)[3])
 289
 290 /****d* silcutil/SILCTypes/SILC_GET16_MSB
 291  *
 292  * NAME
 293  *
 294  *    #define SILC_GET16_MSB ...
 295  *
 296  * DESCRIPTION
 297  *
 298  *    Return two 8-bit bytes, most significant bytes first.
 299  *
 300  * SOURCE
 301  */
 302 #define SILC_GET16_MSB(l, cp)                           \
 303 do {                                                    \
 304   (l) = ((SilcUInt32)(SilcUInt8)(cp)[0] << 8)           \
 305     | ((SilcUInt32)(SilcUInt8)(cp)[1]);                 \
 306 } while(0)
 307 /***/
 308
 309 /****d* silcutil/SILCTypes/SILC_GET32_MSB
 310  *
 311  * NAME
 312  *
 313  *    #define SILC_GET32_MSB ...
 314  *
 315  * DESCRIPTION
 316  *
 317  *    Return four 8-bit bytes, most significant bytes first.
 318  *
 319  * SOURCE
 320  */
 321 #define SILC_GET32_MSB(l, cp)                           \
 322 do {                                                    \
 323   (l) = ((SilcUInt32)(SilcUInt8)(cp)[0]) << 24          \
 324     | ((SilcUInt32)(SilcUInt8)(cp)[1] << 16)            \
 325     | ((SilcUInt32)(SilcUInt8)(cp)[2] << 8)             \
 326     | ((SilcUInt32)(SilcUInt8)(cp)[3]);                 \
 327 } while(0)
 328 /***/
 329
 330 /* Same as upper but XOR the result always. Special purpose macro. */
 331 #define SILC_GET32_X_MSB(l, cp)                         \
 332   (l) ^= ((SilcUInt32)(SilcUInt8)(cp)[0]) << 24         \
 333     | ((SilcUInt32)(SilcUInt8)(cp)[1] << 16)            \
 334     | ((SilcUInt32)(SilcUInt8)(cp)[2] << 8)             \
 335     | ((SilcUInt32)(SilcUInt8)(cp)[3]);
 336
 337 /****d* silcutil/SILCTypes/SILC_GET64_MSB
 338  *
 339  * NAME
 340  *
 341  *    #define SILC_GET64_MSB ...
 342  *
 343  * DESCRIPTION
 344  *
 345  *    Return eight 8-bit bytes, most significant bytes first.
 346  *
 347  * SOURCE
 348  */
 349 #define SILC_GET64_MSB(l, cp)                                   \
 350 do {                                                            \
 351   (l) = ((((SilcUInt64)SILC_GET_WORD((cp))) << 32) |            \
 352          ((SilcUInt64)SILC_GET_WORD((cp) + 4)));                \
 353 } while(0)
 354 /***/
 355
 356 /****d* silcutil/SILCTypes/SILC_GET16_LSB
 357  *
 358  * NAME
 359  *
 360  *    #define SILC_GET16_MSB ...
 361  *
 362  * DESCRIPTION
 363  *
 364  *    Return two 8-bit bytes, least significant bytes first.
 365  *
 366  * SOURCE
 367  */
 368 #if defined(SILC_I486) && defined(__GNUC__)
 369 #define SILC_GET16_LSB(l, cp) (l) = (*(SilcUInt16 *)(cp))
 370 #else
 371 #define SILC_GET16_LSB(l, cp)                           \
 372 do {                                                    \
 373   (l) = ((SilcUInt32)(SilcUInt8)(cp)[0])                \
 374     | ((SilcUInt32)(SilcUInt8)(cp)[1] << 8);            \
 375 } while(0)
 376 #endif /* SILC_I486 && __GNUC__ */
 377 /***/
 378
 379 /****d* silcutil/SILCTypes/SILC_GET32_LSB
 380  *
 381  * NAME
 382  *
 383  *    #define SILC_GET32_LSB ...
 384  *
 385  * DESCRIPTION
 386  *
 387  *    Return four 8-bit bytes, least significant bytes first.
 388  *
 389  * SOURCE
 390  */
 391 #if defined(SILC_I486) && defined(__GNUC__)
 392 #define SILC_GET32_LSB(l, cp) (l) = (*(SilcUInt32 *)(cp))
 393 #else
 394 #define SILC_GET32_LSB(l, cp)                           \
 395 do {                                                    \
 396   (l) = ((SilcUInt32)(SilcUInt8)(cp)[0])                \
 397     | ((SilcUInt32)(SilcUInt8)(cp)[1] << 8)             \
 398     | ((SilcUInt32)(SilcUInt8)(cp)[2] << 16)            \
 399     | ((SilcUInt32)(SilcUInt8)(cp)[3] << 24);           \
 400 } while(0)
 401 #endif /* SILC_I486 && __GNUC__ */
 402
 403 /* Same as upper but XOR the result always. Special purpose macro. */
 404 #if defined(SILC_I486) && defined(__GNUC__)
 405 #define SILC_GET32_X_LSB(l, cp) (l) ^= (*(SilcUInt32 *)(cp))
 406 #else
 407 #define SILC_GET32_X_LSB(l, cp)                         \
 408   (l) ^= ((SilcUInt32)(SilcUInt8)(cp)[0])               \
 409     | ((SilcUInt32)(SilcUInt8)(cp)[1] << 8)             \
 410     | ((SilcUInt32)(SilcUInt8)(cp)[2] << 16)            \
 411     | ((SilcUInt32)(SilcUInt8)(cp)[3] << 24)
 412 #endif /* SILC_I486 && __GNUC__ */
 413 /***/
 414
 415 /****d* silcutil/SILCTypes/SILC_PUT16_MSB
 416  *
 417  * NAME
 418  *
 419  *    #define SILC_PUT16_MSB ...
 420  *
 421  * DESCRIPTION
 422  *
 423  *    Put two 8-bit bytes, most significant bytes first.
 424  *
 425  * SOURCE
 426  */
 427 #define SILC_PUT16_MSB(l, cp)                   \
 428 do {                                            \
 429   (cp)[0] = (SilcUInt8)((l) >> 8);              \
 430   (cp)[1] = (SilcUInt8)(l);                     \
 431 } while(0)
 432 /***/
 433
 434 /****d* silcutil/SILCTypes/SILC_PUT32_MSB
 435  *
 436  * NAME
 437  *
 438  *    #define SILC_PUT32_MSB ...
 439  *
 440  * DESCRIPTION
 441  *
 442  *    Put four 8-bit bytes, most significant bytes first.
 443  *
 444  * SOURCE
 445  */
 446 #define SILC_PUT32_MSB(l, cp)                   \
 447 do {                                            \
 448   (cp)[0] = (SilcUInt8)((l) >> 24);             \
 449   (cp)[1] = (SilcUInt8)((l) >> 16);             \
 450   (cp)[2] = (SilcUInt8)((l) >> 8);              \
 451   (cp)[3] = (SilcUInt8)(l);                     \
 452 } while(0)
 453 /***/
 454
 455 /****d* silcutil/SILCTypes/SILC_PUT64_MSB
 456  *
 457  * NAME
 458  *
 459  *    #define SILC_PUT64_MSB ...
 460  *
 461  * DESCRIPTION
 462  *
 463  *    Put eight 8-bit bytes, most significant bytes first.
 464  *
 465  * SOURCE
 466  */
 467 #define SILC_PUT64_MSB(l, cp)                                   \
 468 do {                                                            \
 469   SILC_PUT32_MSB((SilcUInt32)((SilcUInt64)(l) >> 32), (cp));    \
 470   SILC_PUT32_MSB((SilcUInt32)(l), (cp) + 4);                    \
 471 } while(0)
 472 /***/
 473
 474 /****d* silcutil/SILCTypes/SILC_PUT16_LSB
 475  *
 476  * NAME
 477  *
 478  *    #define SILC_PUT16_LSB ...
 479  *
 480  * DESCRIPTION
 481  *
 482  *    Put two 8-bit bytes, least significant bytes first.
 483  *
 484  * SOURCE
 485  */
 486 #if defined(SILC_I486) && defined(__GNUC__)
 487 #define SILC_PUT16_LSB(l, cp) (*(SilcUInt16 *)(cp)) = (l)
 488 #else
 489 #define SILC_PUT16_LSB(l, cp)                   \
 490 do  {                                           \
 491   (cp)[0] = (SilcUInt8)(l);                     \
 492   (cp)[1] = (SilcUInt8)((l) >> 8);              \
 493 } while(0)
 494 #endif /* SILC_I486 && __GNUC__ */
 495 /***/
 496
 497 /****d* silcutil/SILCTypes/SILC_PUT32_LSB
 498  *
 499  * NAME
 500  *
 501  *    #define SILC_PUT32_LSB ...
 502  *
 503  * DESCRIPTION
 504  *
 505  *    Put four 8-bit bytes, least significant bytes first.
 506  *
 507  * SOURCE
 508  */
 509 #if defined(SILC_I486) && defined(__GNUC__)
 510 #define SILC_PUT32_LSB(l, cp) (*(SilcUInt32 *)(cp)) = (l)
 511 #else
 512 #define SILC_PUT32_LSB(l, cp)                   \
 513 do {                                            \
 514   (cp)[0] = (SilcUInt8)(l);                     \
 515   (cp)[1] = (SilcUInt8)((l) >> 8);              \
 516   (cp)[2] = (SilcUInt8)((l) >> 16);             \
 517   (cp)[3] = (SilcUInt8)((l) >> 24);             \
 518 } while(0)
 519 #endif /* SILC_I486 && __GNUC__ */
 520 /***/
 521
 522 /****d* silcutil/SILCTypes/SILC_SWAB_16
 523  *
 524  * NAME
 525  *
 526  *    #define SILC_SWAB_16 ...
 527  *
 528  * DESCRIPTION
 529  *
 530  *    Swabs 16-bit unsigned integer byte order.
 531  *
 532  * SOURCE
 533  */
 534 #define SILC_SWAB_16(l)                                         \
 535   ((SilcUInt16)(((SilcUInt16)(l) & (SilcUInt16)0x00FFU) << 8) | \
 536                (((SilcUInt16)(l) & (SilcUInt16)0xFF00U) >> 8))
 537 /***/
 538
 539 /****d* silcutil/SILCTypes/SILC_SWAB_32
 540  *
 541  * NAME
 542  *
 543  *    #define SILC_SWAB_32 ...
 544  *
 545  * DESCRIPTION
 546  *
 547  *    Swabs 32-bit unsigned integer byte order.
 548  *
 549  * SOURCE
 550  */
 551 #define SILC_SWAB_32(l)                                                 \
 552   ((SilcUInt32)(((SilcUInt32)(l) & (SilcUInt32)0x000000FFUL) << 24) |   \
 553                (((SilcUInt32)(l) & (SilcUInt32)0x0000FF00UL) << 8)  |   \
 554                (((SilcUInt32)(l) & (SilcUInt32)0x00FF0000UL) >> 8)  |   \
 555                (((SilcUInt32)(l) & (SilcUInt32)0xFF000000UL) >> 24))
 556 /***/
 557
 558 /****d* silcutil/SILCTypes/SILC_PTR_TO_32
 559  *
 560  * NAME
 561  *
 562  *    #define SILC_PTR_TO_32 ...
 563  *
 564  * DESCRIPTION
 565  *
 566  *    Type casts a pointer's value into a 32-bit integer.  Use this to
 567  *    avoid compiler warnings when type casting pointers to integers
 568  *    of different size.
 569  *
 570  * SOURCE
 571  */
 572 #if SILC_SIZEOF_VOID_P < 8
 573 #define SILC_PTR_TO_32(_ptr__) ((SilcUInt32)(_ptr__))
 574 #else
 575 #define SILC_PTR_TO_32(_ptr__)                                          \
 576   ((SilcUInt32)((SilcUInt64)(_ptr__) & (SilcUInt32)0xFFFFFFFFUL))
 577 #endif
 578 /***/
 579
 580 /****d* silcutil/SILCTypes/SILC_PTR_TO_64
 581  *
 582  * NAME
 583  *
 584  *    #define SILC_PTR_TO_64 ...
 585  *
 586  * DESCRIPTION
 587  *
 588  *    Type casts a pointer's value into a 64-bit integer.  Use this to
 589  *    avoid compiler warnings when type casting pointers to integers
 590  *    of different size.
 591  *
 592  * SOURCE
 593  */
 594 #if SILC_SIZEOF_VOID_P < 8
 595 #define SILC_PTR_TO_64(_ptr__) ((SilcUInt64)((SilcUInt32)(_ptr__)))
 596 #else
 597 #define SILC_PTR_TO_64(_ptr__) ((SilcUInt64)((SilcUInt64)(_ptr__)))
 598 #endif
 599 /***/
 600
 601 /****d* silcutil/SILCTypes/SILC_32_TO_PTR
 602  *
 603  * NAME
 604  *
 605  *    #define SILC_32_TO_PTR ...
 606  *
 607  * DESCRIPTION
 608  *
 609  *    Type casts a 32-bit integer value into a pointer.  Use this to
 610  *    avoid compiler warnings when type casting integers to pointers of
 611  *    different size.
 612  *
 613  * SOURCE
 614  */
 615 #if SILC_SIZEOF_VOID_P < 8
 616 #define SILC_32_TO_PTR(_ival__) ((void *)((SilcUInt32)(_ival__)))
 617 #else
 618 #define SILC_32_TO_PTR(_ival__) ((void *)((SilcUInt64)(_ival__)))
 619 #endif
 620 /***/
 621
 622 /****d* silcutil/SILCTypes/SILC_64_TO_PTR
 623  *
 624  * NAME
 625  *
 626  *    #define SILC_64_TO_PTR ...
 627  *
 628  * DESCRIPTION
 629  *
 630  *    Type casts a 64-bit integer value into a pointer.  Use this to
 631  *    avoid compiler warnings when type casting integers to pointers of
 632  *    different size.
 633  *
 634  * SOURCE
 635  */
 636 #if SILC_SIZEOF_VOID_P < 8
 637 #define SILC_64_TO_PTR(_ival__)                                         \
 638   ((void *)((SilcUInt32)((SilcUInt64)(_ival__) & (SilcUInt32)0xFFFFFFFFUL)))
 639 #else
 640 #define SILC_64_TO_PTR(_ival__) ((void *)((SilcUInt64)(_ival__)))
 641 #endif
 642 /***/
 643
 644 #endif /* SILCTYPES_H */