LCOV - app.info - objdir/dist/include/skia/SkTypes.h

LCOV - code coverage report
| Current view: | directory - objdir/dist/include/skia - SkTypes.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 1 | 0 | 0.0 %
| Date: | 2012-06-02 | Functions: | 1 | 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                 : static inline void sk_bzero(void* buffer, size_t size) {
          69                 :     memset(buffer, 0, size);
          70                 : }
          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                 : static inline bool SkIsS16(long x) {
         196                 :     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                 : static inline int Sk32ToBool(uint32_t n) {
         253                 :     return (n | (0-n)) >> 31;
         254                 : }
         255                 :
         256                 : template <typename T> inline void SkTSwap(T& a, T& b) {
         257                 :     T c(a);
         258                 :     a = b;
         259                 :     b = c;
         260                 : }
         261                 :
         262                 : 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                 :     int32_t mask = value >> 31;
         269                 :     return (value ^ mask) - mask;
         270                 : #endif
         271                 : }
         272                 :
         273                 : static inline int32_t SkMax32(int32_t a, int32_t b) {
         274                 :     if (a < b)
         275                 :         a = b;
         276                 :     return a;
         277                 : }
         278                 :
         279                 : static inline int32_t SkMin32(int32_t a, int32_t b) {
         280                 :     if (a > b)
         281                 :         a = b;
         282                 :     return a;
         283                 : }
         284                 :
         285                 : static inline int32_t SkSign32(int32_t a) {
         286                 :     return (a >> 31) | ((unsigned) -a >> 31);
         287                 : }
         288                 :
         289                 : 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                 :     int diff = max - value;
         296                 :     // clear diff if it is negative (clear if value > max)
         297                 :     diff &= (diff >> 31);
         298                 :     return value + diff;
         299                 : #endif
         300                 : }
         301                 :
         302                 : /** Returns signed 32 bit value pinned between min and max, inclusively
         303                 : */
         304                 : 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                 :     if (value < min)
         312                 :         value = min;
         313                 :     else if (value > max)
         314                 :         value = max;
         315                 : #endif
         316                 :     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                 : static inline uint32_t SkSetClearMask(uint32_t bits, bool cond,
         326                 :                                       uint32_t mask) {
         327                 :     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                 : template <typename Dst> Dst SkTCast(const void* ptr) {
         343                 :     union {
         344                 :         const void* src;
         345                 :         Dst dst;
         346                 :     } data;
         347                 :     data.src = ptr;
         348                 :     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                 :     explicit SkAutoMalloc(size_t size = 0) {
         416                 :         fPtr = size ? sk_malloc_throw(size) : NULL;
         417                 :         fSize = size;
         418                 :     }
         419                 :
         420                 :     ~SkAutoMalloc() {
         421                 :         sk_free(fPtr);
         422                 :     }
         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                 :     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                 :     SkAutoSMalloc() {
         502                 :         fPtr = fStorage;
         503                 :         fSize = 0;
         504                 :     }
         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                 :     explicit SkAutoSMalloc(size_t size) {
         512                 :         fPtr = fStorage;
         513                 :         fSize = 0;
         514                 :         this->reset(size);
         515                 :     }
         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                 :     ~SkAutoSMalloc() {
         522                 :         if (fPtr != (void*)fStorage) {
         523                 :             sk_free(fPtr);
         524                 :         }
         525                 :     }
         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                 :     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                 :     void* reset(size_t size,
         542                 :                 SkAutoMalloc::OnShrink shrink = SkAutoMalloc::kAlloc_OnShrink) {
         543                 :         if (size == fSize || (SkAutoMalloc::kReuse_OnShrink == shrink &&
         544                 :                               size < fSize)) {
         545                 :             return fPtr;
         546                 :         }
         547                 :
         548                 :         if (fPtr != (void*)fStorage) {
         549                 :             sk_free(fPtr);
         550                 :         }
         551                 :
         552                 :         if (size <= kSize) {
         553                 :             fPtr = fStorage;
         554                 :         } else {
         555                 :             fPtr = sk_malloc_flags(size, SK_MALLOC_THROW | SK_MALLOC_TEMP);
         556                 :         }
         557                 :         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