LCOV - code coverage report
Current view: directory - gfx/skia/include/core - SkTypes.h (source / functions) Found Hit Coverage
Test: app.info Lines: 70 0 0.0 %
Date: 2012-06-02 Functions: 53 0 0.0 %

       1                 : 
       2                 : /*
       3                 :  * Copyright 2006 The Android Open Source Project
       4                 :  *
       5                 :  * Use of this source code is governed by a BSD-style license that can be
       6                 :  * found in the LICENSE file.
       7                 :  */
       8                 : 
       9                 : 
      10                 : #ifndef SkTypes_DEFINED
      11                 : #define SkTypes_DEFINED
      12                 : 
      13                 : #include "SkPreConfig.h"
      14                 : #include "SkUserConfig.h"
      15                 : #include "SkPostConfig.h"
      16                 : 
      17                 : #ifndef SK_IGNORE_STDINT_DOT_H
      18                 :     #include <stdint.h>
      19                 : #endif
      20                 : 
      21                 : #include <stdio.h>
      22                 : 
      23                 : /** \file SkTypes.h
      24                 : */
      25                 : 
      26                 : /** See SkGraphics::GetVersion() to retrieve these at runtime
      27                 :  */
      28                 : #define SKIA_VERSION_MAJOR  1
      29                 : #define SKIA_VERSION_MINOR  0
      30                 : #define SKIA_VERSION_PATCH  0
      31                 : 
      32                 : /*
      33                 :     memory wrappers to be implemented by the porting layer (platform)
      34                 : */
      35                 : 
      36                 : /** Called internally if we run out of memory. The platform implementation must
      37                 :     not return, but should either throw an exception or otherwise exit.
      38                 : */
      39                 : SK_API extern void sk_out_of_memory(void);
      40                 : /** Called internally if we hit an unrecoverable error.
      41                 :     The platform implementation must not return, but should either throw
      42                 :     an exception or otherwise exit.
      43                 : */
      44                 : SK_API extern void sk_throw(void);
      45                 : 
      46                 : enum {
      47                 :     SK_MALLOC_TEMP  = 0x01, //!< hint to sk_malloc that the requested memory will be freed in the scope of the stack frame
      48                 :     SK_MALLOC_THROW = 0x02  //!< instructs sk_malloc to call sk_throw if the memory cannot be allocated.
      49                 : };
      50                 : /** Return a block of memory (at least 4-byte aligned) of at least the
      51                 :     specified size. If the requested memory cannot be returned, either
      52                 :     return null (if SK_MALLOC_TEMP bit is clear) or call sk_throw()
      53                 :     (if SK_MALLOC_TEMP bit is set). To free the memory, call sk_free().
      54                 : */
      55                 : SK_API extern void* sk_malloc_flags(size_t size, unsigned flags);
      56                 : /** Same as sk_malloc(), but hard coded to pass SK_MALLOC_THROW as the flag
      57                 : */
      58                 : SK_API extern void* sk_malloc_throw(size_t size);
      59                 : /** Same as standard realloc(), but this one never returns null on failure. It will throw
      60                 :     an exception if it fails.
      61                 : */
      62                 : SK_API extern void* sk_realloc_throw(void* buffer, size_t size);
      63                 : /** Free memory returned by sk_malloc(). It is safe to pass null.
      64                 : */
      65                 : SK_API extern void sk_free(void*);
      66                 : 
      67                 : // bzero is safer than memset, but we can't rely on it, so... sk_bzero()
      68               0 : static inline void sk_bzero(void* buffer, size_t size) {
      69               0 :     memset(buffer, 0, size);
      70               0 : }
      71                 : 
      72                 : ///////////////////////////////////////////////////////////////////////////////
      73                 : 
      74                 : #ifdef SK_OVERRIDE_GLOBAL_NEW
      75                 : #include <new>
      76                 : 
      77                 : inline void* operator new(size_t size) {
      78                 :     return sk_malloc_throw(size);
      79                 : }
      80                 : 
      81                 : inline void operator delete(void* p) {
      82                 :     sk_free(p);
      83                 : }
      84                 : #endif
      85                 : 
      86                 : ///////////////////////////////////////////////////////////////////////////////
      87                 : 
      88                 : #define SK_INIT_TO_AVOID_WARNING    = 0
      89                 : 
      90                 : #ifndef SkDebugf
      91                 :     void SkDebugf(const char format[], ...);
      92                 : #endif
      93                 : 
      94                 : #ifdef SK_DEBUG
      95                 :     #define SkASSERT(cond)              SK_DEBUGBREAK(cond)
      96                 :     #define SkDEBUGFAIL(message)        SkASSERT(false && message)
      97                 :     #define SkDEBUGCODE(code)           code
      98                 :     #define SkDECLAREPARAM(type, var)   , type var
      99                 :     #define SkPARAM(var)                , var
     100                 : //  #define SkDEBUGF(args       )       SkDebugf##args
     101                 :     #define SkDEBUGF(args       )       SkDebugf args
     102                 :     #define SkAssertResult(cond)        SkASSERT(cond)
     103                 : #else
     104                 :     #define SkASSERT(cond)
     105                 :     #define SkDEBUGFAIL(message)
     106                 :     #define SkDEBUGCODE(code)
     107                 :     #define SkDEBUGF(args)
     108                 :     #define SkDECLAREPARAM(type, var)
     109                 :     #define SkPARAM(var)
     110                 : 
     111                 :     // unlike SkASSERT, this guy executes its condition in the non-debug build
     112                 :     #define SkAssertResult(cond)        cond
     113                 : #endif
     114                 : 
     115                 : namespace {
     116                 : 
     117                 : template <bool>
     118                 : struct SkCompileAssert {
     119                 : };
     120                 : 
     121                 : }  // namespace
     122                 : 
     123                 : #define SK_COMPILE_ASSERT(expr, msg) \
     124                 :     typedef SkCompileAssert<(bool(expr))> msg[bool(expr) ? 1 : -1]
     125                 : 
     126                 : ///////////////////////////////////////////////////////////////////////
     127                 : 
     128                 : /**
     129                 :  *  Fast type for signed 8 bits. Use for parameter passing and local variables,
     130                 :  *  not for storage.
     131                 :  */
     132                 : typedef int S8CPU;
     133                 : 
     134                 : /**
     135                 :  *  Fast type for unsigned 8 bits. Use for parameter passing and local
     136                 :  *  variables, not for storage
     137                 :  */
     138                 : typedef unsigned U8CPU;
     139                 : 
     140                 : /**
     141                 :  *  Fast type for signed 16 bits. Use for parameter passing and local variables,
     142                 :  *  not for storage
     143                 :  */
     144                 : typedef int S16CPU;
     145                 : 
     146                 : /**
     147                 :  *  Fast type for unsigned 16 bits. Use for parameter passing and local
     148                 :  *  variables, not for storage
     149                 :  */
     150                 : typedef unsigned U16CPU;
     151                 : 
     152                 : /**
     153                 :  *  Meant to be faster than bool (doesn't promise to be 0 or 1,
     154                 :  *  just 0 or non-zero
     155                 :  */
     156                 : typedef int SkBool;
     157                 : 
     158                 : /**
     159                 :  *  Meant to be a small version of bool, for storage purposes. Will be 0 or 1
     160                 :  */
     161                 : typedef uint8_t SkBool8;
     162                 : 
     163                 : #ifdef SK_DEBUG
     164                 :     SK_API int8_t      SkToS8(long);
     165                 :     SK_API uint8_t     SkToU8(size_t);
     166                 :     SK_API int16_t     SkToS16(long);
     167                 :     SK_API uint16_t    SkToU16(size_t);
     168                 :     SK_API int32_t     SkToS32(long);
     169                 :     SK_API uint32_t    SkToU32(size_t);
     170                 : #else
     171                 :     #define SkToS8(x)   ((int8_t)(x))
     172                 :     #define SkToU8(x)   ((uint8_t)(x))
     173                 :     #define SkToS16(x)  ((int16_t)(x))
     174                 :     #define SkToU16(x)  ((uint16_t)(x))
     175                 :     #define SkToS32(x)  ((int32_t)(x))
     176                 :     #define SkToU32(x)  ((uint32_t)(x))
     177                 : #endif
     178                 : 
     179                 : /** Returns 0 or 1 based on the condition
     180                 : */
     181                 : #define SkToBool(cond)  ((cond) != 0)
     182                 : 
     183                 : #define SK_MaxS16   32767
     184                 : #define SK_MinS16   -32767
     185                 : #define SK_MaxU16   0xFFFF
     186                 : #define SK_MinU16   0
     187                 : #define SK_MaxS32   0x7FFFFFFF
     188                 : #define SK_MinS32   0x80000001
     189                 : #define SK_MaxU32   0xFFFFFFFF
     190                 : #define SK_MinU32   0
     191                 : #define SK_NaN32    0x80000000
     192                 : 
     193                 : /** Returns true if the value can be represented with signed 16bits
     194                 :  */
     195               0 : static inline bool SkIsS16(long x) {
     196               0 :     return (int16_t)x == x;
     197                 : }
     198                 : 
     199                 : /** Returns true if the value can be represented with unsigned 16bits
     200                 :  */
     201                 : static inline bool SkIsU16(long x) {
     202                 :     return (uint16_t)x == x;
     203                 : }
     204                 : 
     205                 : //////////////////////////////////////////////////////////////////////////////
     206                 : #ifndef SK_OFFSETOF
     207                 :     #define SK_OFFSETOF(type, field)    ((char*)&(((type*)1)->field) - (char*)1)
     208                 : #endif
     209                 : 
     210                 : /** Returns the number of entries in an array (not a pointer)
     211                 : */
     212                 : #define SK_ARRAY_COUNT(array)       (sizeof(array) / sizeof(array[0]))
     213                 : 
     214                 : /** Returns x rounded up to a multiple of 2
     215                 : */
     216                 : #define SkAlign2(x)     (((x) + 1) >> 1 << 1)
     217                 : /** Returns x rounded up to a multiple of 4
     218                 : */
     219                 : #define SkAlign4(x)     (((x) + 3) >> 2 << 2)
     220                 : 
     221                 : #define SkIsAlign4(x) (((x) & 3) == 0)
     222                 : 
     223                 : typedef uint32_t SkFourByteTag;
     224                 : #define SkSetFourByteTag(a, b, c, d)    (((a) << 24) | ((b) << 16) | ((c) << 8) | (d))
     225                 : 
     226                 : /** 32 bit integer to hold a unicode value
     227                 : */
     228                 : typedef int32_t SkUnichar;
     229                 : /** 32 bit value to hold a millisecond count
     230                 : */
     231                 : typedef uint32_t SkMSec;
     232                 : /** 1 second measured in milliseconds
     233                 : */
     234                 : #define SK_MSec1 1000
     235                 : /** maximum representable milliseconds
     236                 : */
     237                 : #define SK_MSecMax 0x7FFFFFFF
     238                 : /** Returns a < b for milliseconds, correctly handling wrap-around from 0xFFFFFFFF to 0
     239                 : */
     240                 : #define SkMSec_LT(a, b)     ((int32_t)(a) - (int32_t)(b) < 0)
     241                 : /** Returns a <= b for milliseconds, correctly handling wrap-around from 0xFFFFFFFF to 0
     242                 : */
     243                 : #define SkMSec_LE(a, b)     ((int32_t)(a) - (int32_t)(b) <= 0)
     244                 : 
     245                 : /****************************************************************************
     246                 :     The rest of these only build with C++
     247                 : */
     248                 : #ifdef __cplusplus
     249                 : 
     250                 : /** Faster than SkToBool for integral conditions. Returns 0 or 1
     251                 : */
     252               0 : static inline int Sk32ToBool(uint32_t n) {
     253               0 :     return (n | (0-n)) >> 31;
     254                 : }
     255                 : 
     256               0 : template <typename T> inline void SkTSwap(T& a, T& b) {
     257               0 :     T c(a);
     258               0 :     a = b;
     259               0 :     b = c;
     260               0 : }
     261                 : 
     262               0 : static inline int32_t SkAbs32(int32_t value) {
     263                 : #ifdef SK_CPU_HAS_CONDITIONAL_INSTR
     264                 :     if (value < 0)
     265                 :         value = -value;
     266                 :     return value;
     267                 : #else
     268               0 :     int32_t mask = value >> 31;
     269               0 :     return (value ^ mask) - mask;
     270                 : #endif
     271                 : }
     272                 : 
     273               0 : static inline int32_t SkMax32(int32_t a, int32_t b) {
     274               0 :     if (a < b)
     275               0 :         a = b;
     276               0 :     return a;
     277                 : }
     278                 : 
     279               0 : static inline int32_t SkMin32(int32_t a, int32_t b) {
     280               0 :     if (a > b)
     281               0 :         a = b;
     282               0 :     return a;
     283                 : }
     284                 : 
     285                 : static inline int32_t SkSign32(int32_t a) {
     286                 :     return (a >> 31) | ((unsigned) -a >> 31);
     287                 : }
     288                 : 
     289               0 : static inline int32_t SkFastMin32(int32_t value, int32_t max) {
     290                 : #ifdef SK_CPU_HAS_CONDITIONAL_INSTR
     291                 :     if (value > max)
     292                 :         value = max;
     293                 :     return value;
     294                 : #else
     295               0 :     int diff = max - value;
     296                 :     // clear diff if it is negative (clear if value > max)
     297               0 :     diff &= (diff >> 31);
     298               0 :     return value + diff;
     299                 : #endif
     300                 : }
     301                 : 
     302                 : /** Returns signed 32 bit value pinned between min and max, inclusively
     303                 : */
     304               0 : static inline int32_t SkPin32(int32_t value, int32_t min, int32_t max) {
     305                 : #ifdef SK_CPU_HAS_CONDITIONAL_INSTR
     306                 :     if (value < min)
     307                 :         value = min;
     308                 :     if (value > max)
     309                 :         value = max;
     310                 : #else
     311               0 :     if (value < min)
     312               0 :         value = min;
     313               0 :     else if (value > max)
     314               0 :         value = max;
     315                 : #endif
     316               0 :     return value;
     317                 : }
     318                 : 
     319                 : static inline uint32_t SkSetClearShift(uint32_t bits, bool cond,
     320                 :                                        unsigned shift) {
     321                 :     SkASSERT((int)cond == 0 || (int)cond == 1);
     322                 :     return (bits & ~(1 << shift)) | ((int)cond << shift);
     323                 : }
     324                 : 
     325               0 : static inline uint32_t SkSetClearMask(uint32_t bits, bool cond,
     326                 :                                       uint32_t mask) {
     327               0 :     return cond ? bits | mask : bits & ~mask;
     328                 : }
     329                 : 
     330                 : ///////////////////////////////////////////////////////////////////////////////
     331                 : 
     332                 : /** Use to combine multiple bits in a bitmask in a type safe way.
     333                 :  */
     334                 : template <typename T>
     335                 : T SkTBitOr(T a, T b) {
     336                 :     return (T)(a | b);
     337                 : }
     338                 : 
     339                 : /**
     340                 :  *  Use to cast a pointer to a different type, and maintaining strict-aliasing
     341                 :  */
     342               0 : template <typename Dst> Dst SkTCast(const void* ptr) {
     343                 :     union {
     344                 :         const void* src;
     345                 :         Dst dst;
     346                 :     } data;
     347               0 :     data.src = ptr;
     348               0 :     return data.dst;
     349                 : }
     350                 : 
     351                 : //////////////////////////////////////////////////////////////////////////////
     352                 : 
     353                 : /** \class SkNoncopyable
     354                 : 
     355                 : SkNoncopyable is the base class for objects that may do not want to
     356                 : be copied. It hides its copy-constructor and its assignment-operator.
     357                 : */
     358                 : class SK_API SkNoncopyable {
     359                 : public:
     360               0 :     SkNoncopyable() {}
     361                 : 
     362                 : private:
     363                 :     SkNoncopyable(const SkNoncopyable&);
     364                 :     SkNoncopyable& operator=(const SkNoncopyable&);
     365                 : };
     366                 : 
     367                 : class SkAutoFree : SkNoncopyable {
     368                 : public:
     369                 :     SkAutoFree() : fPtr(NULL) {}
     370                 :     explicit SkAutoFree(void* ptr) : fPtr(ptr) {}
     371                 :     ~SkAutoFree() { sk_free(fPtr); }
     372                 : 
     373                 :     /** Return the currently allocate buffer, or null
     374                 :     */
     375                 :     void* get() const { return fPtr; }
     376                 : 
     377                 :     /** Assign a new ptr allocated with sk_malloc (or null), and return the
     378                 :         previous ptr. Note it is the caller's responsibility to sk_free the
     379                 :         returned ptr.
     380                 :     */
     381                 :     void* set(void* ptr) {
     382                 :         void* prev = fPtr;
     383                 :         fPtr = ptr;
     384                 :         return prev;
     385                 :     }
     386                 : 
     387                 :     /** Transfer ownership of the current ptr to the caller, setting the
     388                 :         internal reference to null. Note the caller is reponsible for calling
     389                 :         sk_free on the returned address.
     390                 :     */
     391                 :     void* detach() { return this->set(NULL); }
     392                 : 
     393                 :     /** Free the current buffer, and set the internal reference to NULL. Same
     394                 :         as calling sk_free(detach())
     395                 :     */
     396                 :     void free() {
     397                 :         sk_free(fPtr);
     398                 :         fPtr = NULL;
     399                 :     }
     400                 : 
     401                 : private:
     402                 :     void* fPtr;
     403                 :     // illegal
     404                 :     SkAutoFree(const SkAutoFree&);
     405                 :     SkAutoFree& operator=(const SkAutoFree&);
     406                 : };
     407                 : 
     408                 : /**
     409                 :  *  Manage an allocated block of heap memory. This object is the sole manager of
     410                 :  *  the lifetime of the block, so the caller must not call sk_free() or delete
     411                 :  *  on the block, unless detach() was called.
     412                 :  */
     413                 : class SkAutoMalloc : public SkNoncopyable {
     414                 : public:
     415               0 :     explicit SkAutoMalloc(size_t size = 0) {
     416               0 :         fPtr = size ? sk_malloc_throw(size) : NULL;
     417               0 :         fSize = size;
     418               0 :     }
     419                 : 
     420               0 :     ~SkAutoMalloc() {
     421               0 :         sk_free(fPtr);
     422               0 :     }
     423                 : 
     424                 :     /**
     425                 :      *  Passed to reset to specify what happens if the requested size is smaller
     426                 :      *  than the current size (and the current block was dynamically allocated).
     427                 :      */
     428                 :     enum OnShrink {
     429                 :         /**
     430                 :          *  If the requested size is smaller than the current size, and the
     431                 :          *  current block is dynamically allocated, free the old block and
     432                 :          *  malloc a new block of the smaller size.
     433                 :          */
     434                 :         kAlloc_OnShrink,
     435                 :         
     436                 :         /**
     437                 :          *  If the requested size is smaller than the current size, and the
     438                 :          *  current block is dynamically allocated, just return the old
     439                 :          *  block.
     440                 :          */
     441                 :         kReuse_OnShrink
     442                 :     };
     443                 : 
     444                 :     /**
     445                 :      *  Reallocates the block to a new size. The ptr may or may not change.
     446                 :      */
     447                 :     void* reset(size_t size, OnShrink shrink = kAlloc_OnShrink) {
     448                 :         if (size == fSize || (kReuse_OnShrink == shrink && size < fSize)) {
     449                 :             return fPtr;
     450                 :         }
     451                 : 
     452                 :         sk_free(fPtr);
     453                 :         fPtr = size ? sk_malloc_throw(size) : NULL;
     454                 :         fSize = size;
     455                 : 
     456                 :         return fPtr;
     457                 :     }
     458                 : 
     459                 :     /**
     460                 :      *  Releases the block back to the heap
     461                 :      */
     462                 :     void free() {
     463                 :         this->reset(0);
     464                 :     }
     465                 : 
     466                 :     /**
     467                 :      *  Return the allocated block.
     468                 :      */
     469               0 :     void* get() { return fPtr; }
     470                 :     const void* get() const { return fPtr; }
     471                 : 
     472                 :    /** Transfer ownership of the current ptr to the caller, setting the
     473                 :        internal reference to null. Note the caller is reponsible for calling
     474                 :        sk_free on the returned address.
     475                 :     */
     476                 :     void* detach() {
     477                 :         void* ptr = fPtr;
     478                 :         fPtr = NULL;
     479                 :         fSize = 0;
     480                 :         return ptr;
     481                 :     }
     482                 : 
     483                 : private:
     484                 :     void*   fPtr;
     485                 :     size_t  fSize;  // can be larger than the requested size (see kReuse)
     486                 : };
     487                 : 
     488                 : /**
     489                 :  *  Manage an allocated block of memory. If the requested size is <= kSize, then
     490                 :  *  the allocation will come from the stack rather than the heap. This object
     491                 :  *  is the sole manager of the lifetime of the block, so the caller must not
     492                 :  *  call sk_free() or delete on the block.
     493                 :  */
     494                 : template <size_t kSize> class SkAutoSMalloc : SkNoncopyable {
     495                 : public:
     496                 :     /**
     497                 :      *  Creates initially empty storage. get() returns a ptr, but it is to
     498                 :      *  a zero-byte allocation. Must call reset(size) to return an allocated
     499                 :      *  block.
     500                 :      */
     501               0 :     SkAutoSMalloc() {
     502               0 :         fPtr = fStorage;
     503               0 :         fSize = 0;
     504               0 :     }
     505                 : 
     506                 :     /**
     507                 :      *  Allocate a block of the specified size. If size <= kSize, then the
     508                 :      *  allocation will come from the stack, otherwise it will be dynamically
     509                 :      *  allocated.
     510                 :      */
     511               0 :     explicit SkAutoSMalloc(size_t size) {
     512               0 :         fPtr = fStorage;
     513               0 :         fSize = 0;
     514               0 :         this->reset(size);
     515               0 :     }
     516                 : 
     517                 :     /**
     518                 :      *  Free the allocated block (if any). If the block was small enought to
     519                 :      *  have been allocated on the stack (size <= kSize) then this does nothing.
     520                 :      */
     521               0 :     ~SkAutoSMalloc() {
     522               0 :         if (fPtr != (void*)fStorage) {
     523               0 :             sk_free(fPtr);
     524                 :         }
     525               0 :     }
     526                 : 
     527                 :     /**
     528                 :      *  Return the allocated block. May return non-null even if the block is
     529                 :      *  of zero size. Since this may be on the stack or dynamically allocated,
     530                 :      *  the caller must not call sk_free() on it, but must rely on SkAutoSMalloc
     531                 :      *  to manage it.
     532                 :      */
     533               0 :     void* get() const { return fPtr; }
     534                 : 
     535                 :     /**
     536                 :      *  Return a new block of the requested size, freeing (as necessary) any
     537                 :      *  previously allocated block. As with the constructor, if size <= kSize
     538                 :      *  then the return block may be allocated locally, rather than from the
     539                 :      *  heap.
     540                 :      */
     541               0 :     void* reset(size_t size,
     542                 :                 SkAutoMalloc::OnShrink shrink = SkAutoMalloc::kAlloc_OnShrink) {
     543               0 :         if (size == fSize || (SkAutoMalloc::kReuse_OnShrink == shrink &&
     544                 :                               size < fSize)) {
     545               0 :             return fPtr;
     546                 :         }
     547                 : 
     548               0 :         if (fPtr != (void*)fStorage) {
     549               0 :             sk_free(fPtr);
     550                 :         }
     551                 : 
     552               0 :         if (size <= kSize) {
     553               0 :             fPtr = fStorage;
     554                 :         } else {
     555               0 :             fPtr = sk_malloc_flags(size, SK_MALLOC_THROW | SK_MALLOC_TEMP);
     556                 :         }
     557               0 :         return fPtr;
     558                 :     }
     559                 : 
     560                 : private:
     561                 :     void*       fPtr;
     562                 :     size_t      fSize;  // can be larger than the requested size (see kReuse)
     563                 :     uint32_t    fStorage[(kSize + 3) >> 2];
     564                 : };
     565                 : 
     566                 : #endif /* C++ */
     567                 : 
     568                 : #endif

Generated by: LCOV version 1.7