LCOV - code coverage report
Current view: top level - gdk - gdk_atoms.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 57 62 91.9 %
Date: 2021-09-14 19:48:19 Functions: 7 7 100.0 %

          Line data    Source code
       1             : /*
       2             :  * This Source Code Form is subject to the terms of the Mozilla Public
       3             :  * License, v. 2.0.  If a copy of the MPL was not distributed with this
       4             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       5             :  *
       6             :  * Copyright 1997 - July 2008 CWI, August 2008 - 2021 MonetDB B.V.
       7             :  */
       8             : 
       9             : #ifndef _GDK_ATOMS_H_
      10             : #define _GDK_ATOMS_H_
      11             : 
      12             : /* atomFromStr returns the number of bytes of the input string that
      13             :  * were processed.  atomToStr returns the length of the string
      14             :  * produced.  Both functions return -1 on (any kind of) failure.  If
      15             :  * *dst is not NULL, *len specifies the available space.  If there is
      16             :  * not enough space, or if *dst is NULL, *dst will be freed (if not
      17             :  * NULL) and a new buffer will be allocated and returned in *dst.
      18             :  * *len will be set to reflect the actual size allocated.  If
      19             :  * allocation fails, *dst will be NULL on return and *len is
      20             :  * undefined.  In any case, if the function returns, *buf is either
      21             :  * NULL or a valid pointer and then *len is the size of the area *buf
      22             :  * points to.
      23             :  *
      24             :  * atomCmp returns a value less than zero/equal to zero/greater than
      25             :  * zer if the first argument points to a values which is deemed
      26             :  * smaller/equal to/larger than the value pointed to by the second
      27             :  * argument.
      28             :  *
      29             :  * atomHash calculates a hash function for the value pointed to by the
      30             :  * argument.
      31             :  */
      32             : 
      33             : #define IDLENGTH        64      /* maximum BAT id length */
      34             : 
      35             : typedef struct {
      36             :         /* simple attributes */
      37             :         char name[IDLENGTH];
      38             :         uint8_t storage;        /* stored as another type? */
      39             :         bool linear;            /* atom can be ordered linearly */
      40             :         uint16_t size;          /* fixed size of atom */
      41             : 
      42             :         /* automatically generated fields */
      43             :         const void *atomNull;   /* global nil value */
      44             : 
      45             :         /* generic (fixed + varsized atom) ADT functions */
      46             :         ssize_t (*atomFromStr) (const char *src, size_t *len, void **dst, bool external);
      47             :         ssize_t (*atomToStr) (char **dst, size_t *len, const void *src, bool external);
      48             :         void *(*atomRead) (void *dst, size_t *dstlen, stream *s, size_t cnt);
      49             :         gdk_return (*atomWrite) (const void *src, stream *s, size_t cnt);
      50             :         int (*atomCmp) (const void *v1, const void *v2);
      51             :         BUN (*atomHash) (const void *v);
      52             :         /* optional functions */
      53             :         gdk_return (*atomFix) (const void *atom);
      54             :         gdk_return (*atomUnfix) (const void *atom);
      55             : 
      56             :         /* varsized atom-only ADT functions */
      57             :         var_t (*atomPut) (BAT *, var_t *off, const void *src);
      58             :         void (*atomDel) (Heap *, var_t *atom);
      59             :         size_t (*atomLen) (const void *atom);
      60             :         void (*atomHeap) (Heap *, size_t);
      61             : } atomDesc;
      62             : 
      63             : #define MAXATOMS        128
      64             : 
      65             : gdk_export atomDesc BATatoms[MAXATOMS];
      66             : gdk_export int GDKatomcnt;
      67             : 
      68             : gdk_export int ATOMallocate(const char *nme);
      69             : gdk_export int ATOMindex(const char *nme);
      70             : 
      71             : gdk_export str ATOMname(int id);
      72             : gdk_export size_t ATOMlen(int id, const void *v);
      73             : gdk_export void *ATOMnil(int id)
      74             :         __attribute__((__malloc__));
      75             : gdk_export int ATOMprint(int id, const void *val, stream *fd);
      76             : gdk_export char *ATOMformat(int id, const void *val);
      77             : 
      78             : gdk_export void *ATOMdup(int id, const void *val);
      79             : 
      80             : /*
      81             :  * @- maximum atomic string lengths
      82             :  */
      83             : #define bitStrlen       8
      84             : #define bteStrlen       8
      85             : #define shtStrlen       12
      86             : #define intStrlen       24
      87             : #if SIZEOF_OID == SIZEOF_INT
      88             : #define oidStrlen       24
      89             : #else
      90             : #define oidStrlen       48
      91             : #endif
      92             : #if SIZEOF_PTR == SIZEOF_INT
      93             : #define ptrStrlen       24
      94             : #else
      95             : #define ptrStrlen       48
      96             : #endif
      97             : #define lngStrlen       48
      98             : #ifdef HAVE_HGE
      99             : #define hgeStrlen       96
     100             : #endif
     101             : #define fltStrlen       48
     102             : #define dblStrlen       96
     103             : 
     104             : /*
     105             :  * The system comes with the traditional atomic types: int (4 bytes),
     106             :  * bool(1 byte) and str (variable). In addition, we support the notion
     107             :  * of an OID type, which ensures uniqueness of its members.  This
     108             :  * leads to the following type descriptor table.
     109             :  */
     110             : 
     111             : #ifdef HAVE_HGE
     112             : gdk_export ssize_t hgeFromStr(const char *src, size_t *len, hge **dst, bool external);
     113             : gdk_export ssize_t hgeToStr(str *dst, size_t *len, const hge *src, bool external);
     114             : #endif
     115             : gdk_export ssize_t lngFromStr(const char *src, size_t *len, lng **dst, bool external);
     116             : gdk_export ssize_t lngToStr(str *dst, size_t *len, const lng *src, bool external);
     117             : gdk_export ssize_t intFromStr(const char *src, size_t *len, int **dst, bool external);
     118             : gdk_export ssize_t intToStr(str *dst, size_t *len, const int *src, bool external);
     119             : gdk_export ssize_t batFromStr(const char *src, size_t *len, bat **dst, bool external);
     120             : gdk_export ssize_t batToStr(str *dst, size_t *len, const bat *src, bool external);
     121             : gdk_export ssize_t ptrFromStr(const char *src, size_t *len, ptr **dst, bool external);
     122             : gdk_export ssize_t ptrToStr(str *dst, size_t *len, const ptr *src, bool external);
     123             : gdk_export ssize_t bitFromStr(const char *src, size_t *len, bit **dst, bool external);
     124             : gdk_export ssize_t bitToStr(str *dst, size_t *len, const bit *src, bool external);
     125             : gdk_export ssize_t OIDfromStr(const char *src, size_t *len, oid **dst, bool external);
     126             : gdk_export ssize_t OIDtoStr(str *dst, size_t *len, const oid *src, bool external);
     127             : gdk_export ssize_t shtFromStr(const char *src, size_t *len, sht **dst, bool external);
     128             : gdk_export ssize_t shtToStr(str *dst, size_t *len, const sht *src, bool external);
     129             : gdk_export ssize_t bteFromStr(const char *src, size_t *len, bte **dst, bool external);
     130             : gdk_export ssize_t bteToStr(str *dst, size_t *len, const bte *src, bool external);
     131             : gdk_export ssize_t fltFromStr(const char *src, size_t *len, flt **dst, bool external);
     132             : gdk_export ssize_t fltToStr(str *dst, size_t *len, const flt *src, bool external);
     133             : gdk_export ssize_t dblFromStr(const char *src, size_t *len, dbl **dst, bool external);
     134             : gdk_export ssize_t dblToStr(str *dst, size_t *len, const dbl *src, bool external);
     135             : gdk_export ssize_t GDKstrFromStr(unsigned char *restrict dst, const unsigned char *restrict src, ssize_t len);
     136             : gdk_export ssize_t strFromStr(const char *restrict src, size_t *restrict len, str *restrict dst, bool external);
     137             : gdk_export size_t escapedStrlen(const char *restrict src, const char *sep1, const char *sep2, int quote);
     138             : gdk_export size_t escapedStr(char *restrict dst, const char *restrict src, size_t dstlen, const char *sep1, const char *sep2, int quote);
     139             : /*
     140             :  * @- nil values
     141             :  * All types have a single value designated as a NIL value. It
     142             :  * designates a missing value and it is ignored (forbidden) in several
     143             :  * primitives.  The current policy is to use the smallest value in any
     144             :  * ordered domain.  The routine atomnil returns a pointer to the nil
     145             :  * value representation.
     146             :  */
     147             : #define GDK_bit_max ((bit) 1)
     148             : #define GDK_bit_min ((bit) 0)
     149             : #define GDK_bte_max ((bte) INT8_MAX)
     150             : #define GDK_bte_min ((bte) INT8_MIN+1)
     151             : #define GDK_sht_max ((sht) INT16_MAX)
     152             : #define GDK_sht_min ((sht) INT16_MIN+1)
     153             : #define GDK_int_max ((int) INT32_MAX)
     154             : #define GDK_int_min ((int) INT32_MIN+1)
     155             : #define GDK_lng_max ((lng) INT64_MAX)
     156             : #define GDK_lng_min ((lng) INT64_MIN+1)
     157             : #ifdef HAVE_HGE
     158             : #define GDK_hge_max ((((hge) 1) << 126) - 1 + (((hge) 1) << 126))
     159             : #define GDK_hge_min (-GDK_hge_max)
     160             : #endif
     161             : #define GDK_flt_max ((flt) FLT_MAX)
     162             : #define GDK_flt_min ((flt) -FLT_MAX)
     163             : #define GDK_dbl_max ((dbl) DBL_MAX)
     164             : #define GDK_dbl_min ((dbl) -DBL_MAX)
     165             : #define GDK_oid_max (((oid) 1 << ((8 * SIZEOF_OID) - 1)) - 1)
     166             : #define GDK_oid_min ((oid) 0)
     167             : /* representation of the nil */
     168             : gdk_export const bte bte_nil;
     169             : gdk_export const sht sht_nil;
     170             : gdk_export const int int_nil;
     171             : #ifdef NAN_CANNOT_BE_USED_AS_INITIALIZER
     172             : /* Definition of NAN is seriously broken on Intel compiler (at least
     173             :  * in some versions), so we work around it. */
     174             : union _flt_nil_t {
     175             :         uint32_t l;
     176             :         flt f;
     177             : };
     178             : gdk_export const union _flt_nil_t _flt_nil_;
     179             : #define flt_nil (_flt_nil_.f)
     180             : union _dbl_nil_t {
     181             :         uint64_t l;
     182             :         dbl d;
     183             : };
     184             : gdk_export const union _dbl_nil_t _dbl_nil_;
     185             : #define dbl_nil (_dbl_nil_.d)
     186             : #else
     187             : gdk_export const flt flt_nil;
     188             : gdk_export const dbl dbl_nil;
     189             : #endif
     190             : gdk_export const lng lng_nil;
     191             : #ifdef HAVE_HGE
     192             : gdk_export const hge hge_nil;
     193             : #endif
     194             : gdk_export const oid oid_nil;
     195             : gdk_export const char str_nil[2];
     196             : gdk_export const ptr ptr_nil;
     197             : gdk_export const uuid uuid_nil;
     198             : 
     199             : /* derived NIL values - OIDDEPEND */
     200             : #define bit_nil ((bit) bte_nil)
     201             : #define bat_nil ((bat) int_nil)
     202             : 
     203             : #define void_nil        oid_nil
     204             : 
     205             : #define is_bit_nil(v)   ((v) == GDK_bte_min-1)
     206             : #define is_bte_nil(v)   ((v) == GDK_bte_min-1)
     207             : #define is_sht_nil(v)   ((v) == GDK_sht_min-1)
     208             : #define is_int_nil(v)   ((v) == GDK_int_min-1)
     209             : #define is_lng_nil(v)   ((v) == GDK_lng_min-1)
     210             : #ifdef HAVE_HGE
     211             : #define is_hge_nil(v)   ((v) == GDK_hge_min-1)
     212             : #endif
     213             : #define is_oid_nil(v)   ((v) == ((oid) 1 << ((8 * SIZEOF_OID) - 1)))
     214             : #define is_flt_nil(v)   isnan(v)
     215             : #define is_dbl_nil(v)   isnan(v)
     216             : #define is_bat_nil(v)   (((v) & 0x7FFFFFFF) == 0) /* v == bat_nil || v == 0 */
     217             : 
     218             : #include <math.h>
     219             : 
     220             : #if defined(_MSC_VER) && !defined(__INTEL_COMPILER) && _MSC_VER < 1800
     221             : #include <float.h>
     222             : #define isnan(x)        _isnan(x)
     223             : #define isinf(x)        (_fpclass(x) & (_FPCLASS_NINF | _FPCLASS_PINF))
     224             : #define isfinite(x)     _finite(x)
     225             : #endif
     226             : 
     227             : #ifdef HAVE_HGE
     228             : #define is_uuid_nil(x)  ((x).h == 0)
     229             : #else
     230             : #ifdef HAVE_UUID
     231             : #define is_uuid_nil(x)  uuid_is_null((x).u)
     232             : #else
     233             : #define is_uuid_nil(x)  (memcmp((x).u, uuid_nil.u, UUID_SIZE) == 0)
     234             : #endif
     235             : #endif
     236             : 
     237             : /*
     238             :  * @- Derived types
     239             :  * In all algorithms across GDK, you will find switches on the types
     240             :  * (bte, sht, int, flt, dbl, lng, hge, str). They respectively
     241             :  * represent an octet, a 16-bit int, a 32-bit int, a 32-bit float, a
     242             :  * 64-bit double, a 64-bit int, a 128-bit int, and a pointer-sized location
     243             :  * of a char-buffer (ended by a zero char).
     244             :  *
     245             :  * In contrast, the types (bit, ptr, bat, oid) are derived types. They
     246             :  * do not occur in the switches. The ATOMstorage macro maps them
     247             :  * respectively onto a @code{ bte}, @code{ int} (pointers are 32-bit),
     248             :  * @code{ int}, and @code{ int}. OIDs are 32-bit.
     249             :  *
     250             :  * This approach makes it tractable to switch to 64-bits OIDs, or to a
     251             :  * fully 64-bits OS easily. One only has to map the @code{ oid} and
     252             :  * @code{ ptr} types to @code{ lng} instead of @code{ int}.
     253             :  *
     254             :  * Derived types mimic their fathers in many ways. They inherit the
     255             :  * @code{ size}, @code{ linear}, and @code{ null}
     256             :  * properties of their father.  The same goes for the
     257             :  * ADT functions HASH, CMP, PUT, NULL, DEL, LEN, and HEAP. So, a
     258             :  * derived type differs in only two ways from its father:
     259             :  * @table @code
     260             :  * @item [string representation]
     261             :  * the only two ADT operations specific for a derived type are FROMSTR
     262             :  * and TOSTR.
     263             :  * @item [identity]
     264             :  * (a @code{ bit} is really of a different type than @code{ bte}). The
     265             :  * set of operations on derived type values or BATs of such types may
     266             :  * differ from the sets of operations on the father type.
     267             :  * @end table
     268             :  */
     269             : /* use "do ... while(0)" so that lhs can safely be used in if statements */
     270             : #define ATOMstorage(t)          BATatoms[t].storage
     271             : #define ATOMsize(t)             BATatoms[t].size
     272             : #define ATOMfromstr(t,s,l,src,ext)      BATatoms[t].atomFromStr(src,l,s,ext)
     273             : #define ATOMnilptr(t)           BATatoms[t].atomNull
     274             : #define ATOMcompare(t)          BATatoms[t].atomCmp
     275             : #define ATOMcmp(t,l,r)          ((*ATOMcompare(t))(l, r))
     276             : #define ATOMhash(t,src)         BATatoms[t].atomHash(src)
     277             : #define ATOMdel(t,hp,src)       do if (BATatoms[t].atomDel) BATatoms[t].atomDel(hp,src); while (0)
     278             : #define ATOMvarsized(t)         (BATatoms[t].atomPut != NULL)
     279             : #define ATOMlinear(t)           BATatoms[t].linear
     280             : #define ATOMtype(t)             ((t) == TYPE_void ? TYPE_oid : (t))
     281             : #define ATOMfix(t,v)            (BATatoms[t].atomFix ? BATatoms[t].atomFix(v) : GDK_SUCCEED)
     282             : #define ATOMunfix(t,v)          (BATatoms[t].atomUnfix ? BATatoms[t].atomUnfix(v) : GDK_SUCCEED)
     283             : 
     284             : /* The base type is the storage type if the comparison function, the
     285             :  * hash function, and the nil value are the same as those of the
     286             :  * storage type; otherwise it is the type itself. */
     287             : #define ATOMbasetype(t) ((t) != ATOMstorage(t) &&                       \
     288             :                          ATOMnilptr(t) == ATOMnilptr(ATOMstorage(t)) && \
     289             :                          ATOMcompare(t) == ATOMcompare(ATOMstorage(t)) && \
     290             :                          BATatoms[t].atomHash == BATatoms[ATOMstorage(t)].atomHash ? \
     291             :                          ATOMstorage(t) : (t))
     292             : 
     293             : /*
     294             :  * In case that atoms are added to a bat, their logical reference
     295             :  * count should be incremented (and decremented if deleted). Notice
     296             :  * that BATs with atomic types that have logical references (e.g. BATs
     297             :  * of BATs but also BATs of ODMG odSet) can never be persistent, as
     298             :  * this would make the commit tremendously complicated.
     299             :  */
     300             : 
     301             : static inline gdk_return __attribute__((__warn_unused_result__))
     302    70022541 : ATOMputVAR(BAT *b, var_t *dst, const void *src)
     303             : {
     304    70022541 :         assert(BATatoms[b->ttype].atomPut != NULL);
     305    70022541 :         if ((*BATatoms[b->ttype].atomPut)(b, dst, src) == 0)
     306           0 :                 return GDK_FAIL;
     307             :         return GDK_SUCCEED;
     308             : }
     309             : 
     310             : 
     311             : static inline gdk_return __attribute__((__warn_unused_result__))
     312   414393783 : ATOMputFIX(int type, void *dst, const void *src)
     313             : {
     314             :         gdk_return rc;
     315             : 
     316   414393783 :         assert(BATatoms[type].atomPut == NULL);
     317   414393783 :         rc = ATOMfix(type, src);
     318           0 :         if (rc != GDK_SUCCEED)
     319             :                 return rc;
     320   443000950 :         switch (ATOMsize(type)) {
     321             :         case 0:         /* void */
     322             :                 break;
     323    22590884 :         case 1:
     324    22590884 :                 * (bte *) dst = * (bte *) src;
     325    22590884 :                 break;
     326    13907869 :         case 2:
     327    13907869 :                 * (sht *) dst = * (sht *) src;
     328    13907869 :                 break;
     329   372284350 :         case 4:
     330   372284350 :                 * (int *) dst = * (int *) src;
     331   372284350 :                 break;
     332    17851526 :         case 8:
     333    17851526 :                 * (lng *) dst = * (lng *) src;
     334    17851526 :                 break;
     335    16366321 :         case 16:
     336             : #ifdef HAVE_HGE
     337    16366321 :                 * (hge *) dst = * (hge *) src;
     338             : #else
     339             :                 * (uuid *) dst = * (uuid *) src;
     340             : #endif
     341    16366321 :                 break;
     342           0 :         default:
     343           0 :                 memcpy(dst, src, ATOMsize(type));
     344           0 :                 break;
     345             :         }
     346             :         return GDK_SUCCEED;
     347             : }
     348             : 
     349             : static inline gdk_return __attribute__((__warn_unused_result__))
     350      513618 : ATOMreplaceVAR(BAT *b, var_t *dst, const void *src)
     351             : {
     352      513618 :         var_t loc = *dst;
     353      513618 :         int type = b->ttype;
     354             : 
     355      513618 :         assert(BATatoms[type].atomPut != NULL);
     356      513618 :         if ((*BATatoms[type].atomPut)(b, &loc, src) == 0)
     357             :                 return GDK_FAIL;
     358      514755 :         if (ATOMunfix(type, dst) != GDK_SUCCEED)
     359             :                 return GDK_FAIL;
     360      514976 :         ATOMdel(type, b->tvheap, dst);
     361      514534 :         *dst = loc;
     362      514534 :         return ATOMfix(type, src);
     363             : }
     364             : 
     365             : /* string heaps:
     366             :  * - strings are 8 byte aligned
     367             :  * - start with a 1024 bucket hash table
     368             :  * - heaps < 64KiB are fully duplicate eliminated with this hash tables
     369             :  * - heaps >= 64KiB are opportunistically (imperfect) duplicate
     370             :  *   eliminated as only the last 128KiB chunk is considered and there
     371             :  *   is no linked list
     372             :  * - buckets and next pointers are unsigned short "indices"
     373             :  * - indices should be multiplied by 8 and takes from ELIMBASE to get
     374             :  *   an offset
     375             :  * Note that a 64KiB chunk of the heap contains at most 8K 8-byte
     376             :  * aligned strings. The 1K bucket list means that in worst load, the
     377             :  * list length is 8 (OK).
     378             :  */
     379             : #define GDK_STRHASHTABLE        (1<<10)   /* 1024 */
     380             : #define GDK_STRHASHMASK         (GDK_STRHASHTABLE-1)
     381             : #define GDK_STRHASHSIZE         (GDK_STRHASHTABLE * sizeof(stridx_t))
     382             : #define GDK_ELIMPOWER           16      /* 64KiB is the threshold */
     383             : #define GDK_ELIMDOUBLES(h)      ((h)->free < GDK_ELIMLIMIT)
     384             : #define GDK_ELIMLIMIT           (1<<GDK_ELIMPOWER)        /* equivalently: ELIMBASE == 0 */
     385             : #define GDK_ELIMBASE(x)         (((x) >> GDK_ELIMPOWER) << GDK_ELIMPOWER)
     386             : #define GDK_VAROFFSET           ((var_t) GDK_STRHASHSIZE)
     387             : 
     388             : /*
     389             :  * @- String Comparison, NILs and UTF-8
     390             :  *
     391             :  * Using the char* type for strings is handy as this is the type of
     392             :  * any constant strings in a C/C++ program. Therefore, MonetDB uses
     393             :  * this definition for str.  However, different compilers and
     394             :  * platforms use either signed or unsigned characters for the char
     395             :  * type.  It is required that string ordering in MonetDB is consistent
     396             :  * over platforms though.
     397             :  *
     398             :  * As for the choice how strings should be ordered, our support for
     399             :  * UTF-8 actually imposes that it should follow 'unsigned char'
     400             :  * doctrine (like in the AIX native compiler). In this semantics,
     401             :  * though we have to take corrective action to ensure that str(nil) is
     402             :  * the smallest value of the domain.
     403             :  */
     404             : static inline bool __attribute__((__pure__))
     405             : strEQ(const char *l, const char *r)
     406             : {
     407      187700 :         return strcmp(l, r) == 0;
     408             : }
     409             : 
     410             : static inline bool __attribute__((__pure__))
     411             : strNil(const char *s)
     412             : {
     413  1771316461 :         return s == NULL || (s[0] == '\200' && s[1] == '\0');
     414             : }
     415             : 
     416             : static inline size_t __attribute__((__pure__))
     417   113530114 : strLen(const char *s)
     418             : {
     419   113530114 :         return strNil(s) ? 2 : strlen(s) + 1;
     420             : }
     421             : 
     422             : static inline int __attribute__((__pure__))
     423   327673772 : strCmp(const char *l, const char *r)
     424             : {
     425             :         return strNil(r)
     426   148218138 :                 ? !strNil(l)
     427   655347544 :                 : strNil(l) ? -1 : strcmp(l, r);
     428             : }
     429             : 
     430             : static inline size_t
     431   387088192 : VarHeapVal(const void *b, BUN p, int w)
     432             : {
     433   387088192 :         switch (w) {
     434   126011744 :         case 1:
     435   126011744 :                 return (size_t) ((const uint8_t *) b)[p] + GDK_VAROFFSET;
     436    91820028 :         case 2:
     437    91820028 :                 return (size_t) ((const uint16_t *) b)[p] + GDK_VAROFFSET;
     438             : #if SIZEOF_VAR_T == 8
     439   155357807 :         case 4:
     440   155357807 :                 return (size_t) ((const uint32_t *) b)[p];
     441             : #endif
     442    13898613 :         default:
     443    13898613 :                 return (size_t) ((const var_t *) b)[p];
     444             :         }
     445             : }
     446             : 
     447             : static inline BUN __attribute__((__pure__))
     448   218926021 : strHash(const char *key)
     449             : {
     450             :         BUN y = 0;
     451             : 
     452  4414188523 :         for (BUN i = 0; key[i]; i++) {
     453  4195262502 :                 y += key[i];
     454  4195262502 :                 y += (y << 10);
     455  4195262502 :                 y ^= (y >> 6);
     456             :         }
     457   218926021 :         y += (y << 3);
     458   218926021 :         y ^= (y >> 11);
     459   218926021 :         y += (y << 15);
     460   218926021 :         return y;
     461             : }
     462             : 
     463             : #endif /* _GDK_ATOMS_H_ */

Generated by: LCOV version 1.14