Move core/include/fxcrt to core/fxcrt/include.

third_party/lcms2-2.6/src/cmserr.c

 //---------------------------------------------------------------------------------
 //
 //  Little Color Management System
 //  Copyright (c) 1998-2012 Marti Maria Saguer
 //
 // Permission is hereby granted, free of charge, to any person obtaining
 // a copy of this software and associated documentation files (the "Software"),
 // to deal in the Software without restriction, including without limitation
 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 // and/or sell copies of the Software, and to permit persons to whom the Software
@@ skipping 45 matching lines @@
     fseek(f, p, SEEK_SET); // file position restored
 
     return n;
 }
 
 #if 0
 // Memory handling ------------------------------------------------------------------
 //
 // This is the interface to low-level memory management routines. By default a simple
 // wrapping to malloc/free/realloc is provided, although there is a limit on the max
-// amount of memoy that can be reclaimed. This is mostly as a safety feature to prevent 
+// amount of memoy that can be reclaimed. This is mostly as a safety feature to prevent
 // bogus or evil code to allocate huge blocks that otherwise lcms would never need.
 
 #define MAX_MEMORY_FOR_ALLOC  ((cmsUInt32Number)(1024U*1024U*512U))
 
 // User may override this behaviour by using a memory plug-in, which basically replaces
 // the default memory management functions. In this case, no check is performed and it
 // is up to the plug-in writter to keep in the safe side. There are only three functions
 // required to be implemented: malloc, realloc and free, although the user may want to
 // replace the optional mallocZero, calloc and dup as well.
 
@@ skipping 85 matching lines @@
     mem = _cmsMalloc(ContextID, size);
 
     if (mem != NULL && Org != NULL)
         memmove(mem, Org, size);
 
     return mem;
 }
 
 
 // Pointers to memory manager functions in Context0
-_cmsMemPluginChunkType _cmsMemPluginChunk = { _cmsMallocDefaultFn, _cmsMallocZeroDefaultFn, _cmsFreeDefaultFn, 
+_cmsMemPluginChunkType _cmsMemPluginChunk = { _cmsMallocDefaultFn, _cmsMallocZeroDefaultFn, _cmsFreeDefaultFn,
                                               _cmsReallocDefaultFn, _cmsCallocDefaultFn,    _cmsDupDefaultFn
                                             };
 
 
 // Reset and duplicate memory manager
 void _cmsAllocMemPluginChunk(struct _cmsContext_struct* ctx, const struct _cmsContext_struct* src)
 {
     _cmsAssert(ctx != NULL);
 
-    if (src != NULL) {    
+    if (src != NULL) {
 
         // Duplicate
-        ctx ->chunks[MemPlugin] = _cmsSubAllocDup(ctx ->MemPool, src ->chunks[MemPlugin], sizeof(_cmsMemPluginChunkType));  
+        ctx ->chunks[MemPlugin] = _cmsSubAllocDup(ctx ->MemPool, src ->chunks[MemPlugin], sizeof(_cmsMemPluginChunkType));
     }
     else {
 
         // To reset it, we use the default allocators, which cannot be overriden
         ctx ->chunks[MemPlugin] = &ctx ->DefaultMemoryManager;
-    } 
+    }
 }
 
 // Auxiliar to fill memory management functions from plugin (or context 0 defaults)
 void _cmsInstallAllocFunctions(cmsPluginMemHandler* Plugin, _cmsMemPluginChunkType* ptr)
 {
     if (Plugin == NULL) {
 
         memcpy(ptr, &_cmsMemPluginChunk, sizeof(_cmsMemPluginChunk));
     }
     else {
 
         ptr ->MallocPtr  = Plugin -> MallocPtr;
         ptr ->FreePtr    = Plugin -> FreePtr;
         ptr ->ReallocPtr = Plugin -> ReallocPtr;
 
         // Make sure we revert to defaults
         ptr ->MallocZeroPtr= _cmsMallocZeroDefaultFn;
         ptr ->CallocPtr    = _cmsCallocDefaultFn;
         ptr ->DupPtr       = _cmsDupDefaultFn;
-      
+
         if (Plugin ->MallocZeroPtr != NULL) ptr ->MallocZeroPtr = Plugin -> MallocZeroPtr;
         if (Plugin ->CallocPtr != NULL)     ptr ->CallocPtr     = Plugin -> CallocPtr;
         if (Plugin ->DupPtr != NULL)        ptr ->DupPtr        = Plugin -> DupPtr;
-        
+
     }
 }
 
 
 // Plug-in replacement entry
 cmsBool  _cmsRegisterMemHandlerPlugin(cmsContext ContextID, cmsPluginBase *Data)
 {
-    cmsPluginMemHandler* Plugin = (cmsPluginMemHandler*) Data;     
+    cmsPluginMemHandler* Plugin = (cmsPluginMemHandler*) Data;
     _cmsMemPluginChunkType* ptr;
 
-    // NULL forces to reset to defaults. In this special case, the defaults are stored in the context structure. 
+    // NULL forces to reset to defaults. In this special case, the defaults are stored in the context structure.
     // Remaining plug-ins does NOT have any copy in the context structure, but this is somehow special as the
-    // context internal data should be malloce'd by using those functions. 
+    // context internal data should be malloce'd by using those functions.
     if (Data == NULL) {
 
        struct _cmsContext_struct* ctx = ( struct _cmsContext_struct*) ContextID;
 
        // Return to the default allocators
         if (ContextID != NULL) {
             ctx->chunks[MemPlugin] = (void*) &ctx->DefaultMemoryManager;
         }
         return TRUE;
     }
 
     // Check for required callbacks
     if (Plugin -> MallocPtr == NULL ||
         Plugin -> FreePtr == NULL ||
         Plugin -> ReallocPtr == NULL) return FALSE;
 
     // Set replacement functions
     ptr = (_cmsMemPluginChunkType*) _cmsContextGetClientChunk(ContextID, MemPlugin);
-    if (ptr == NULL) 
+    if (ptr == NULL)
         return FALSE;
 
     _cmsInstallAllocFunctions(Plugin, ptr);
     return TRUE;
 }
 #else
-#include "core/include/fxcrt/fx_memory.h"
-#include "core/include/fxcrt/fx_system.h"
+#include "core/fxcrt/include/fx_memory.h"
+#include "core/fxcrt/include/fx_system.h"
 
 cmsBool  _cmsRegisterMemHandlerPlugin(cmsContext ContextID, cmsPluginBase* Plugin)
 {
         return TRUE;
 }
 
 // Generic allocate
 void* CMSEXPORT _cmsMalloc(cmsContext ContextID, cmsUInt32Number size)
 {
     return FXMEM_DefaultAlloc(size, 1);
@@ skipping 30 matching lines @@
 }
 
 // Generic block duplication
 void* CMSEXPORT _cmsDupMem(cmsContext ContextID, const void* Org, cmsUInt32Number size)
 {
         void* p = FXMEM_DefaultAlloc(size, 1);
         FXSYS_memmove(p, Org, size);
         return p;
 }
 
-_cmsMemPluginChunkType _cmsMemPluginChunk = {_cmsMalloc, _cmsMallocZero, _cmsFree, 
+_cmsMemPluginChunkType _cmsMemPluginChunk = {_cmsMalloc, _cmsMallocZero, _cmsFree,
                                                  _cmsRealloc, _cmsCalloc,    _cmsDupMem
                                             };
 
 void _cmsAllocMemPluginChunk(struct _cmsContext_struct* ctx, const struct _cmsContext_struct* src)
 {
         _cmsAssert(ctx != NULL);
 
-        if (src != NULL) {    
+        if (src != NULL) {
 
                 // Duplicate
-                ctx ->chunks[MemPlugin] = _cmsSubAllocDup(ctx ->MemPool, src ->chunks[MemPlugin], sizeof(_cmsMemPluginChunkType));  
+                ctx ->chunks[MemPlugin] = _cmsSubAllocDup(ctx ->MemPool, src ->chunks[MemPlugin], sizeof(_cmsMemPluginChunkType));
         }
         else {
 
                 // To reset it, we use the default allocators, which cannot be overriden
                 ctx ->chunks[MemPlugin] = &ctx ->DefaultMemoryManager;
-        } 
+        }
 }
 
 void _cmsInstallAllocFunctions(cmsPluginMemHandler* Plugin, _cmsMemPluginChunkType* ptr)
 {
         if (Plugin == NULL) {
 
                 memcpy(ptr, &_cmsMemPluginChunk, sizeof(_cmsMemPluginChunk));
         }
         else {
 
@@ skipping 117 matching lines @@
     ptr =  sub -> h ->Block + sub -> h ->Used;
     sub -> h -> Used += size;
 
     return (void*) ptr;
 }
 
 // Duplicate in pool
 void* _cmsSubAllocDup(_cmsSubAllocator* s, const void *ptr, cmsUInt32Number size)
 {
     void *NewPtr;
-    
+
     // Dup of null pointer is also NULL
     if (ptr == NULL)
         return NULL;
 
     NewPtr = _cmsSubAlloc(s, size);
 
     if (ptr != NULL && NewPtr != NULL) {
         memcpy(NewPtr, ptr, size);
     }
 
@@ skipping 21 matching lines @@
 // ---------------------------------------------------------------------------------------------------------
 
 // This is our default log error
 static void DefaultLogErrorHandlerFunction(cmsContext ContextID, cmsUInt32Number ErrorCode, const char *Text);
 
 // Context0 storage, which is global
 _cmsLogErrorChunkType _cmsLogErrorChunk = { DefaultLogErrorHandlerFunction };
 
 // Allocates and inits error logger container for a given context. If src is NULL, only initializes the value
 // to the default. Otherwise, it duplicates the value. The interface is standard across all context clients
-void _cmsAllocLogErrorChunk(struct _cmsContext_struct* ctx, 
+void _cmsAllocLogErrorChunk(struct _cmsContext_struct* ctx,
                             const struct _cmsContext_struct* src)
-{    
+{
     static _cmsLogErrorChunkType LogErrorChunk = { DefaultLogErrorHandlerFunction };
     void* from;
-     
+
      if (src != NULL) {
-        from = src ->chunks[Logger];       
+        from = src ->chunks[Logger];
     }
     else {
        from = &LogErrorChunk;
     }
-    
-    ctx ->chunks[Logger] = _cmsSubAllocDup(ctx ->MemPool, from, sizeof(_cmsLogErrorChunkType));   
+
+    ctx ->chunks[Logger] = _cmsSubAllocDup(ctx ->MemPool, from, sizeof(_cmsLogErrorChunkType));
 }
 
 // The default error logger does nothing.
 static
 void DefaultLogErrorHandlerFunction(cmsContext ContextID, cmsUInt32Number ErrorCode, const char *Text)
 {
     // fprintf(stderr, "[lcms]: %s\n", Text);
     // fflush(stderr);
 
      cmsUNUSED_PARAMETER(ContextID);
@@ skipping 11 matching lines @@
         if (Fn == NULL)
             lhg -> LogErrorHandler = DefaultLogErrorHandlerFunction;
         else
             lhg -> LogErrorHandler = Fn;
     }
 }
 
 // Change log error, legacy
 void CMSEXPORT cmsSetLogErrorHandler(cmsLogErrorHandlerFunction Fn)
 {
-    cmsSetLogErrorHandlerTHR(NULL, Fn);    
+    cmsSetLogErrorHandlerTHR(NULL, Fn);
 }
 
 // Log an error
 // ErrorText is a text holding an english description of error.
 void CMSEXPORT cmsSignalError(cmsContext ContextID, cmsUInt32Number ErrorCode, const char *ErrorText, ...)
 {
     va_list args;
     char Buffer[MAX_ERROR_MESSAGE_LEN];
     _cmsLogErrorChunkType* lhg;
 
 
     va_start(args, ErrorText);
     vsnprintf(Buffer, MAX_ERROR_MESSAGE_LEN-1, ErrorText, args);
     va_end(args);
 
     // Check for the context, if specified go there. If not, go for the global
     lhg = (_cmsLogErrorChunkType*) _cmsContextGetClientChunk(ContextID, Logger);
     if (lhg ->LogErrorHandler) {
         lhg ->LogErrorHandler(ContextID, ErrorCode, Buffer);
-    }   
+    }
 }
 
 // Utility function to print signatures
 void _cmsTagSignature2String(char String[5], cmsTagSignature sig)
 {
     cmsUInt32Number be;
 
     // Convert to big endian
     be = _cmsAdjustEndianess32((cmsUInt32Number) sig);
 
     // Move chars
     memmove(String, &be, 4);
 
     // Make sure of terminator
     String[4] = 0;
 }
 
 //--------------------------------------------------------------------------------------------------
 
 
 static
 void* defMtxCreate(cmsContext id)
 {
     _cmsMutex* ptr_mutex = (_cmsMutex*) _cmsMalloc(id, sizeof(_cmsMutex));
     _cmsInitMutexPrimitive(ptr_mutex);
-    return (void*) ptr_mutex;   
+    return (void*) ptr_mutex;
 }
 
 static
 void defMtxDestroy(cmsContext id, void* mtx)
 {
-    _cmsDestroyMutexPrimitive((_cmsMutex *) mtx); 
+    _cmsDestroyMutexPrimitive((_cmsMutex *) mtx);
     _cmsFree(id, mtx);
 }
 
 static
 cmsBool defMtxLock(cmsContext id, void* mtx)
 {
     cmsUNUSED_PARAMETER(id);
-    return _cmsLockPrimitive((_cmsMutex *) mtx) == 0;     
+    return _cmsLockPrimitive((_cmsMutex *) mtx) == 0;
 }
 
 static
 void defMtxUnlock(cmsContext id, void* mtx)
 {
     cmsUNUSED_PARAMETER(id);
-    _cmsUnlockPrimitive((_cmsMutex *) mtx); 
+    _cmsUnlockPrimitive((_cmsMutex *) mtx);
 }
 
 
 
 // Pointers to memory manager functions in Context0
 _cmsMutexPluginChunkType _cmsMutexPluginChunk = { defMtxCreate, defMtxDestroy, defMtxLock, defMtxUnlock };
 
 // Allocate and init mutex container.
-void _cmsAllocMutexPluginChunk(struct _cmsContext_struct* ctx, 
+void _cmsAllocMutexPluginChunk(struct _cmsContext_struct* ctx,
                                         const struct _cmsContext_struct* src)
 {
     static _cmsMutexPluginChunkType MutexChunk = {defMtxCreate, defMtxDestroy, defMtxLock, defMtxUnlock };
     void* from;
-     
+
      if (src != NULL) {
-        from = src ->chunks[MutexPlugin];       
+        from = src ->chunks[MutexPlugin];
     }
     else {
        from = &MutexChunk;
     }
-    
-    ctx ->chunks[MutexPlugin] = _cmsSubAllocDup(ctx ->MemPool, from, sizeof(_cmsMutexPluginChunkType));   
+
+    ctx ->chunks[MutexPlugin] = _cmsSubAllocDup(ctx ->MemPool, from, sizeof(_cmsMutexPluginChunkType));
 }
 
 // Register new ways to transform
 cmsBool  _cmsRegisterMutexPlugin(cmsContext ContextID, cmsPluginBase* Data)
 {
     cmsPluginMutex* Plugin = (cmsPluginMutex*) Data;
     _cmsMutexPluginChunkType* ctx = ( _cmsMutexPluginChunkType*) _cmsContextGetClientChunk(ContextID, MutexPlugin);
 
     if (Data == NULL) {
 
         // No lock routines
-        ctx->CreateMutexPtr = NULL; 
-        ctx->DestroyMutexPtr = NULL; 
+        ctx->CreateMutexPtr = NULL;
+        ctx->DestroyMutexPtr = NULL;
         ctx->LockMutexPtr = NULL;
         ctx ->UnlockMutexPtr = NULL;
         return TRUE;
     }
 
     // Factory callback is required
-    if (Plugin ->CreateMutexPtr == NULL || Plugin ->DestroyMutexPtr == NULL || 
+    if (Plugin ->CreateMutexPtr == NULL || Plugin ->DestroyMutexPtr == NULL ||
         Plugin ->LockMutexPtr == NULL || Plugin ->UnlockMutexPtr == NULL) return FALSE;
 
 
     ctx->CreateMutexPtr  = Plugin->CreateMutexPtr;
     ctx->DestroyMutexPtr = Plugin ->DestroyMutexPtr;
     ctx ->LockMutexPtr   = Plugin ->LockMutexPtr;
     ctx ->UnlockMutexPtr = Plugin ->UnlockMutexPtr;
 
     // All is ok
     return TRUE;
@@ skipping 30 matching lines @@
 
 void CMSEXPORT _cmsUnlockMutex(cmsContext ContextID, void* mtx)
 {
     _cmsMutexPluginChunkType* ptr = (_cmsMutexPluginChunkType*) _cmsContextGetClientChunk(ContextID, MutexPlugin);
 
     if (ptr ->UnlockMutexPtr != NULL) {
 
         ptr ->UnlockMutexPtr(ContextID, mtx);
     }
 }