jdk-sandbox: comparison jdk/src/share/native/sun/java2d/cmm/lcms/cmscgats.c

equal deleted inserted replaced

-:78d56f33c3a7
+:0f6a4442b29e
 // This file is available under and governed by the GNU General Public
 // License version 2 only, as published by the Free Software Foundation.
 // However, the following notice accompanied the original version of this
 // file:
 //
+//---------------------------------------------------------------------------------
 //
-//  Little cms
+//  Little Color Management System
-//  Copyright (C) 1998-2007 Marti Maria
+//  Copyright (c) 1998-2010 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,
 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
-// IT8.7 / CGATS.17-200x handling
+//---------------------------------------------------------------------------------
+//
-#include "lcms.h"
+#include "lcms2_internal.h"
-LCMSAPI LCMSHANDLE      LCMSEXPORT cmsIT8Alloc(void);
-LCMSAPI void            LCMSEXPORT cmsIT8Free(LCMSHANDLE IT8);
+// IT8.7 / CGATS.17-200x handling -----------------------------------------------------------------------------
-// Tables
+#define MAXID        128     // Max lenght of identifier
-LCMSAPI int             LCMSEXPORT cmsIT8TableCount(LCMSHANDLE IT8);
-LCMSAPI int             LCMSEXPORT cmsIT8SetTable(LCMSHANDLE IT8, int nTable);
-// Persistence
-LCMSAPI LCMSHANDLE      LCMSEXPORT cmsIT8LoadFromFile(const char* cFileName);
-LCMSAPI LCMSHANDLE      LCMSEXPORT cmsIT8LoadFromMem(void *Ptr, size_t len);
-LCMSAPI LCMSBOOL        LCMSEXPORT cmsIT8SaveToFile(LCMSHANDLE IT8, const char* cFileName);
-// Properties
-LCMSAPI const char*     LCMSEXPORT cmsIT8GetSheetType(LCMSHANDLE hIT8);
-LCMSAPI LCMSBOOL        LCMSEXPORT cmsIT8SetSheetType(LCMSHANDLE hIT8, const char* Type);
-LCMSAPI LCMSBOOL        LCMSEXPORT cmsIT8SetComment(LCMSHANDLE hIT8, const char* cComment);
-LCMSAPI LCMSBOOL        LCMSEXPORT cmsIT8SetPropertyStr(LCMSHANDLE hIT8, const char* cProp, const char *Str);
-LCMSAPI LCMSBOOL        LCMSEXPORT cmsIT8SetPropertyDbl(LCMSHANDLE hIT8, const char* cProp, double Val);
-LCMSAPI LCMSBOOL        LCMSEXPORT cmsIT8SetPropertyHex(LCMSHANDLE hIT8, const char* cProp, int Val);
-LCMSAPI LCMSBOOL        LCMSEXPORT cmsIT8SetPropertyMulti(LCMSHANDLE hIT8, const char* cProp, const char* cSubProp, const char *Val);
-LCMSAPI LCMSBOOL        LCMSEXPORT cmsIT8SetPropertyUncooked(LCMSHANDLE hIT8, const char* Key, const char* Buffer);
-LCMSAPI const char*     LCMSEXPORT cmsIT8GetProperty(LCMSHANDLE hIT8, const char* cProp);
-LCMSAPI double          LCMSEXPORT cmsIT8GetPropertyDbl(LCMSHANDLE hIT8, const char* cProp);
-LCMSAPI const char*     LCMSEXPORT cmsIT8GetPropertyMulti(LCMSHANDLE hIT8, const char* cProp, const char *cSubProp);
-LCMSAPI int             LCMSEXPORT cmsIT8EnumProperties(LCMSHANDLE IT8, const char ***PropertyNames);
-LCMSAPI int             LCMSEXPORT cmsIT8EnumPropertyMulti(LCMSHANDLE hIT8, const char* cProp, const char*** SubpropertyNames);
-// Datasets
-LCMSAPI const char*     LCMSEXPORT cmsIT8GetPatchName(LCMSHANDLE hIT8, int nPatch, char* buffer);
-LCMSAPI const char*     LCMSEXPORT cmsIT8GetDataRowCol(LCMSHANDLE IT8, int row, int col);
-LCMSAPI double          LCMSEXPORT cmsIT8GetDataRowColDbl(LCMSHANDLE IT8, int col, int row);
-LCMSAPI LCMSBOOL        LCMSEXPORT cmsIT8SetDataRowCol(LCMSHANDLE hIT8, int row, int col,
-const char* Val);
-LCMSAPI LCMSBOOL        LCMSEXPORT cmsIT8SetDataRowColDbl(LCMSHANDLE hIT8, int row, int col,
-double Val);
-LCMSAPI const char*     LCMSEXPORT cmsIT8GetData(LCMSHANDLE IT8, const char* cPatch, const char* cSample);
-LCMSAPI double          LCMSEXPORT cmsIT8GetDataDbl(LCMSHANDLE IT8, const char* cPatch, const char* cSample);
-LCMSAPI LCMSBOOL        LCMSEXPORT cmsIT8SetData(LCMSHANDLE IT8, const char* cPatch,
-const char* cSample,
-const char *Val);
-LCMSAPI LCMSBOOL        LCMSEXPORT cmsIT8SetDataDbl(LCMSHANDLE hIT8, const char* cPatch,
-const char* cSample,
-double Val);
-LCMSAPI LCMSBOOL        LCMSEXPORT cmsIT8SetDataFormat(LCMSHANDLE IT8, int n, const char *Sample);
-LCMSAPI int             LCMSEXPORT cmsIT8EnumDataFormat(LCMSHANDLE IT8, char ***SampleNames);
-LCMSAPI void            LCMSEXPORT cmsIT8DefineDblFormat(LCMSHANDLE IT8, const char* Formatter);
-LCMSAPI int             LCMSEXPORT cmsIT8SetTableByLabel(LCMSHANDLE hIT8, const char* cSet,
-const char* cField,
-const char* ExpectedType);
-// ------------------------------------------------------------- Implementation
-#define SIZEOFLONGMINUS1    (sizeof(long)-1)
-#define ALIGNLONG(x) (((x)+SIZEOFLONGMINUS1) & ~(SIZEOFLONGMINUS1))
-// #define STRICT_CGATS  1
-#define MAXID       128     // Max lenght of identifier
 #define MAXSTR      1024     // Max lenght of string
-#define MAXTABLES   255     // Max Number of tables in a single stream
+#define MAXTABLES    255     // Max Number of tables in a single stream
-#define MAXINCLUDE   20     // Max number of nested includes
+#define MAXINCLUDE    20     // Max number of nested includes
 #define DEFAULT_DBL_FORMAT  "%.10g" // Double formatting
-#include <ctype.h>
+#ifdef CMS_IS_WINDOWS_
-#include <limits.h>
+#    include <io.h>
+#    define DIR_CHAR    '\\'
-#ifndef NON_WINDOWS
-#include <io.h>
-#define DIR_CHAR    '\\'
 #else
-#define DIR_CHAR    '/'
+#    define DIR_CHAR    '/'
 #endif
 // Symbols
 typedef enum {
 SNONE,
 SINUM,      // Integer
 SDNUM,      // Real
 } SYMBOL;
 // How to write the value
 typedef enum {
 WRITE_UNCOOKED,
 WRITE_STRINGIFY,
 WRITE_HEXADECIMAL,
 WRITE_BINARY,
 WRITE_PAIR
 } WRITEMODE;
 // Linked list of variable names
 typedef struct _KeyVal {
 struct _KeyVal*  Next;
 char*            Keyword;       // Name of variable
 struct _KeyVal*  NextSubkey;    // If key is a dictionary, points to the next item
 char*            Subkey;        // If key is a dictionary, points to the subkey name
 char*            Value;         // Points to value
 WRITEMODE        WriteAs;       // How to write the value
-} KEYVALUE, *LPKEYVALUE;
+} KEYVALUE;
 // Linked list of memory chunks (Memory sink)
 typedef struct _OwnedMem {
 struct _OwnedMem* Next;
 void *            Ptr;          // Point to value
-} OWNEDMEM, *LPOWNEDMEM;
+} OWNEDMEM;
 // Suballocator
 typedef struct _SubAllocator {
-LPBYTE Block;
+cmsUInt8Number* Block;
-size_t BlockSize;
+cmsUInt32Number BlockSize;
-size_t Used;
+cmsUInt32Number Used;
-} SUBALLOCATOR, *LPSUBALLOCATOR;
+} SUBALLOCATOR;
 // Table. Each individual table can hold properties and rows & cols
 typedef struct _Table {
 int            nSamples, nPatches;    // Cols, Rows
 int            SampleID;              // Pos of ID
-LPKEYVALUE     HeaderList;            // The properties
+KEYVALUE*      HeaderList;            // The properties
 char**         DataFormat;            // The binary stream descriptor
 char**         Data;                  // The binary stream
-} TABLE, *LPTABLE;
+} TABLE;
 // File stream being parsed
 typedef struct _FileContext {
-char           FileName[MAX_PATH];    // File name if being readed from file
+char           FileName[cmsMAX_PATH];    // File name if being readed from file
-FILE*          Stream;                // File stream or NULL if holded in memory
+FILE*          Stream;                   // File stream or NULL if holded in memory
-} FILECTX, *LPFILECTX;
+} FILECTX;
-// This struct hold all information about an openened
+// This struct hold all information about an open IT8 handler.
-// IT8 handler. Only one dataset is allowed.
 typedef struct {
-char SheetType[MAXSTR];
+char SheetType[MAXSTR];               // The first row of the IT8 (the type)
-int  TablesCount;                     // How many tables in this stream
+cmsUInt32Number  TablesCount;                     // How many tables in this stream
-int  nTable;                          // The actual table
+cmsUInt32Number  nTable;                          // The actual table
 TABLE Tab[MAXTABLES];
 // Memory management
+OWNEDMEM*      MemorySink;            // The storage backend
-LPOWNEDMEM     MemorySink;            // The storage backend
 SUBALLOCATOR   Allocator;             // String suballocator -- just to keep it fast
 // Parser state machine
 SYMBOL         sy;                    // Current symbol
 int            ch;                    // Current character
 int            inum;                  // integer value
-double         dnum;                  // real value
+cmsFloat64Number         dnum;                  // real value
 char           id[MAXID];             // identifier
 char           str[MAXSTR];           // string
 // Allowed keywords & datasets. They have visibility on whole stream
+KEYVALUE*     ValidKeywords;
-LPKEYVALUE     ValidKeywords;
+KEYVALUE*     ValidSampleID;
-LPKEYVALUE     ValidSampleID;
 char*          Source;                // Points to loc. being parsed
 int            lineno;                // line counter for error reporting
-LPFILECTX      FileStack[MAXINCLUDE]; // Stack of files being parsed
+FILECTX*       FileStack[MAXINCLUDE]; // Stack of files being parsed
 int            IncludeSP;             // Include Stack Pointer
 char*          MemoryBlock;           // The stream if holded in memory
-char           DoubleFormatter[MAXID];   // Printf-like 'double' formatter
+char           DoubleFormatter[MAXID];// Printf-like 'cmsFloat64Number' formatter
-} IT8, *LPIT8;
+cmsContext    ContextID;              // The threading context
+} cmsIT8;
+// The stream for save operations
 typedef struct {
 FILE* stream;   // For save-to-file behaviour
-LPBYTE Base;
+cmsUInt8Number* Base;
-LPBYTE Ptr;     // For save-to-mem behaviour
+cmsUInt8Number* Ptr;        // For save-to-mem behaviour
-size_t Used;
+cmsUInt32Number Used;
-size_t Max;
+cmsUInt32Number Max;
-} SAVESTREAM, FAR* LPSAVESTREAM;
+} SAVESTREAM;
-// ------------------------------------------------------ IT8 parsing routines
+// ------------------------------------------------------ cmsIT8 parsing routines
 // A keyword
 typedef struct {
 } KEYWORD;
 // The keyword->symbol translation table. Sorting is required.
 static const KEYWORD TabKeys[] = {
-{"$INCLUDE",            SINCLUDE},
+{"$INCLUDE",               SINCLUDE},   // This is an extension!
-{".INCLUDE",            SINCLUDE},
+{".INCLUDE",               SINCLUDE},   // This is an extension!
-{"BEGIN_DATA",          SBEGIN_DATA },
-{"BEGIN_DATA_FORMAT",   SBEGIN_DATA_FORMAT },
+{"BEGIN_DATA",             SBEGIN_DATA },
+{"BEGIN_DATA_FORMAT",      SBEGIN_DATA_FORMAT },
 {"DATA_FORMAT_IDENTIFIER", SDATA_FORMAT_ID},
-{"END_DATA",            SEND_DATA},
+{"END_DATA",               SEND_DATA},
-{"END_DATA_FORMAT",     SEND_DATA_FORMAT},
+{"END_DATA_FORMAT",        SEND_DATA_FORMAT},
-{"KEYWORD",             SKEYWORD}
+{"KEYWORD",                SKEYWORD}
 };
 #define NUMKEYS (sizeof(TabKeys)/sizeof(KEYWORD))
 // Predefined properties
 // A property
 typedef struct {
-const char *id;
+const char *id;    // The identifier
-WRITEMODE as;
+WRITEMODE as;      // How is supposed to be written
 } PROPERTY;
 static PROPERTY PredefinedProperties[] = {
 {"NUMBER_OF_FIELDS", WRITE_UNCOOKED},    // Required - NUMBER OF FIELDS
 {"SAMPLE_BACKING",   WRITE_STRINGIFY},   // Identifies the backing material used behind the sample during
 // measurement. Allowed values are �black�, �white�, or {"na".
 {"CHISQ_DOF",        WRITE_STRINGIFY},   // Degrees of freedom associated with the Chi squared statistic
-//    new in recent specs:
+// below properties are new in recent specs:
 {"MEASUREMENT_GEOMETRY", WRITE_STRINGIFY}, // The type of measurement, either reflection or transmission, should be indicated
 // along with details of the geometry and the aperture size and shape. For example,
 // for transmission measurements it is important to identify 0/diffuse, diffuse/0,
 // opal or integrating sphere, etc. For reflection it is important to identify 0/45,
 // 45/0, sphere (specular included or excluded), etc.
 "LAB_L",          // L* component of Lab data
 "LAB_A",          // a* component of Lab data
 "LAB_B",          // b* component of Lab data
 "LAB_C",          // C*ab component of Lab data
 "LAB_H",          // hab component of Lab data
-"LAB_DE",         //  CIE dE
+"LAB_DE",         // CIE dE
-"LAB_DE_94",      //  CIE dE using CIE 94
+"LAB_DE_94",      // CIE dE using CIE 94
-"LAB_DE_CMC",     //  dE using CMC
+"LAB_DE_CMC",     // dE using CMC
 "LAB_DE_2000",    // CIE dE using CIE DE 2000
 "MEAN_DE",        // Mean Delta E (LAB_DE) of samples compared to batch average
 // (Used for data files for ANSI IT8.7/1 and IT8.7/2 targets)
 "STDEV_X",        // Standard deviation of X (tristimulus data)
 "STDEV_Y",        // Standard deviation of Y (tristimulus data)
 // recommended as the predictor of the variability of dE
 #define NUMPREDEFINEDSAMPLEID (sizeof(PredefinedSampleID)/sizeof(char *))
 //Forward declaration of some internal functions
-static
+static void* AllocChunk(cmsIT8* it8, cmsUInt32Number size);
-void* AllocChunk(LPIT8 it8, size_t size);
 // Checks if c is a separator
 static
-LCMSBOOL isseparator(int c)
+cmsBool isseparator(int c)
 {
 return (c == ' ') || (c == '\t') || (c == '\r');
 }
 // Checks whatever if c is a valid identifier char
 static
-LCMSBOOL ismiddle(int c)
+cmsBool ismiddle(int c)
 {
 return (!isseparator(c) && (c != '#') && (c !='\"') && (c != '\'') && (c > 32) && (c < 127));
 }
 // Checks whatsever if c is a valid identifier middle char.
 static
-LCMSBOOL isidchar(int c)
+cmsBool isidchar(int c)
 {
 return isalnum(c) || ismiddle(c);
 }
 // Checks whatsever if c is a valid identifier first char.
 static
-LCMSBOOL isfirstidchar(int c)
+cmsBool isfirstidchar(int c)
 {
 return !isdigit(c) && ismiddle(c);
 }
-// checks whether the supplied path looks like an absolute path
+// Guess whether the supplied path looks like an absolute path
-// NOTE: this function doesn't checks if the path exists or even if it's legal
+static
-static
+cmsBool isabsolutepath(const char *path)
-LCMSBOOL isabsolutepath(const char *path)
+{
-{
+char ThreeChars[4];
 if(path == NULL)
 return FALSE;
+if (path[0] == 0)
-if(path[0] == DIR_CHAR)
+return FALSE;
+strncpy(ThreeChars, path, 3);
+ThreeChars[3] = 0;
+if(ThreeChars[0] == DIR_CHAR)
 return TRUE;
-#ifndef NON_WINDOWS
+#ifdef  CMS_IS_WINDOWS_
-if(isalpha(path[0]) && path[1] == ':')
+if (isalpha((int) ThreeChars[0]) && ThreeChars[1] == ':')
 return TRUE;
 #endif
 return FALSE;
 }
 // Makes a file path based on a given reference path
-// NOTE: buffer is assumed to point to at least MAX_PATH bytes
-// NOTE: both relPath and basePath are assumed to be no more than MAX_PATH characters long (including the null terminator!)
 // NOTE: this function doesn't check if the path exists or even if it's legal
 static
-LCMSBOOL _cmsMakePath(const char *relPath, const char *basePath, char *buffer)
+cmsBool BuildAbsolutePath(const char *relPath, const char *basePath, char *buffer, cmsUInt32Number MaxLen)
 {
-if (!isabsolutepath(relPath)) {
+char *tail;
+cmsUInt32Number len;
-char *tail;
+// Already absolute?
-strncpy(buffer, basePath, MAX_PATH-1);
+if (isabsolutepath(relPath)) {
-tail = strrchr(buffer, DIR_CHAR);
-if (tail != NULL) {
+strncpy(buffer, relPath, MaxLen);
+buffer[MaxLen-1] = 0;
-size_t len = tail - buffer;
+return TRUE;
-strncpy(tail + 1, relPath, MAX_PATH - len -1);
+}
-//  TODO: if combined path is longer than MAX_PATH, this should return FALSE!
-return TRUE;
+// No, search for last
-}
+strncpy(buffer, basePath, MaxLen);
-}
+buffer[MaxLen-1] = 0;
-strncpy(buffer, relPath, MAX_PATH - 1);
-buffer[MAX_PATH-1] = 0;
+tail = strrchr(buffer, DIR_CHAR);
+if (tail == NULL) return FALSE;    // Is not absolute and has no separators??
+len = (cmsUInt32Number) (tail - buffer);
+if (len >= MaxLen) return FALSE;
+// No need to assure zero terminator over here
+strncpy(tail + 1, relPath, MaxLen - len);
 return TRUE;
 }
 // Make sure no exploit is being even tried
 static
 const char* NoMeta(const char* str)
 {
 if (strchr(str, '%') != NULL)
 return "**** CORRUPTED FORMAT STRING ***";
 return str;
 }
 // Syntax error
 static
-LCMSBOOL SynError(LPIT8 it8, const char *Txt, ...)
+cmsBool SynError(cmsIT8* it8, const char *Txt, ...)
 {
 char Buffer[256], ErrMsg[1024];
 va_list args;
 va_start(args, Txt);
 vsnprintf(Buffer, 255, Txt, args);
 Buffer[255] = 0;
 va_end(args);
 snprintf(ErrMsg, 1023, "%s: Line %d, %s", it8->FileStack[it8 ->IncludeSP]->FileName, it8->lineno, Buffer);
 ErrMsg[1023] = 0;
 it8->sy = SSYNERROR;
-cmsSignalError(LCMS_ERRC_ABORTED, "%s", ErrMsg);
+cmsSignalError(it8 ->ContextID, cmsERROR_CORRUPTION_DETECTED, "%s", ErrMsg);
 return FALSE;
 }
 // Check if current symbol is same as specified. issue an error else.
 static
-LCMSBOOL Check(LPIT8 it8, SYMBOL sy, const char* Err)
+cmsBool Check(cmsIT8* it8, SYMBOL sy, const char* Err)
 {
 if (it8 -> sy != sy)
 return SynError(it8, NoMeta(Err));
 return TRUE;
 }
 // Read Next character from stream
 static
-void NextCh(LPIT8 it8)
+void NextCh(cmsIT8* it8)
 {
 if (it8 -> FileStack[it8 ->IncludeSP]->Stream) {
 it8 ->ch = fgetc(it8 ->FileStack[it8 ->IncludeSP]->Stream);
 it8 -> ch = ' ';                            // Whitespace to be ignored
 } else
 it8 ->ch = 0;   // EOF
 }
 }
 else {
 it8->ch = *it8->Source;
 if (it8->ch) it8->Source++;
 }
 // Try to see if current identifier is a keyword, if so return the referred symbol
 static
 SYMBOL BinSrchKey(const char *id)
 {
 int l = 1;
 int r = NUMKEYS;
 int x, res;
 while (r >= l)
 {
 x = (l+r)/2;
-res = stricmp(id, TabKeys[x-1].id);
+res = cmsstrcasecmp(id, TabKeys[x-1].id);
 if (res == 0) return TabKeys[x-1].sy;
 if (res < 0) r = x - 1;
 else l = x + 1;
 }
 return SNONE;
 }
 // 10 ^n
 static
-double xpow10(int n)
+cmsFloat64Number xpow10(int n)
 {
-return pow(10, (double) n);
+return pow(10, (cmsFloat64Number) n);
 }
 //  Reads a Real number, tries to follow from integer number
 static
-void ReadReal(LPIT8 it8, int inum)
+void ReadReal(cmsIT8* it8, int inum)
 {
-it8->dnum = (double) inum;
+it8->dnum = (cmsFloat64Number) inum;
 while (isdigit(it8->ch)) {
 it8->dnum = it8->dnum * 10.0 + (it8->ch - '0');
 NextCh(it8);
 }
 if (it8->ch == '.') {        // Decimal point
-double frac = 0.0;      // fraction
+cmsFloat64Number frac = 0.0;      // fraction
-int prec = 0;           // precission
+int prec = 0;           // precision
 NextCh(it8);               // Eats dec. point
 while (isdigit(it8->ch)) {
 frac = frac * 10.0 + (it8->ch - '0');
 prec++;
 NextCh(it8);
 }
 it8->dnum = it8->dnum + (frac / xpow10(prec));
 }
 // Exponent, example 34.00E+20
 if (toupper(it8->ch) == 'E') {
 int e;
 int sgn;
 NextCh(it8); sgn = 1;
 if (it8->ch == '-') {
 sgn = -1; NextCh(it8);
 }
 else
 if (it8->ch == '+') {
 sgn = +1;
 NextCh(it8);
 }
+e = 0;
-e = 0;
+while (isdigit(it8->ch)) {
-while (isdigit(it8->ch)) {
+if ((cmsFloat64Number) e * 10L < INT_MAX)
-if ((double) e * 10L < INT_MAX)
+e = e * 10 + (it8->ch - '0');
-e = e * 10 + (it8->ch - '0');
+NextCh(it8);
-NextCh(it8);
+}
-}
+e = sgn*e;
-e = sgn*e;
+it8 -> dnum = it8 -> dnum * xpow10(e);
+}
-it8 -> dnum = it8 -> dnum * xpow10(e);
-}
 }
 // Reads next symbol
 static
-void InSymbol(LPIT8 it8)
+void InSymbol(cmsIT8* it8)
 {
 register char *idptr;
 register int k;
 SYMBOL key;
 int sng;
 while (isseparator(it8->ch))
 NextCh(it8);
 if (isfirstidchar(it8->ch)) {          // Identifier
 k = 0;
 idptr = it8->id;
 do {
 NextCh(it8);
 } while (isidchar(it8->ch));
 *idptr = '\0';
 it8->sy = SIDENT;
 }
 return;
 }
 case '\x1a':
 NextCh(it8);
 break;
 // Eof stream markers
 case 0:
 case -1:
 it8->sy = SEOF;
 break;
 // Next line
 case '\n':
 NextCh(it8);
 it8->sy = SEOLN;
 it8->lineno++;
 break;
 // Comment
 case '#':
 NextCh(it8);
 while (it8->ch && it8->ch != '\n')
 NextCh(it8);
 it8->sy = SCOMMENT;
 break;
 // String.
 case '\'':
 case '\"':
 idptr = it8->str;
 sng = it8->ch;
 k = 0;
 // Handle the include special token
 if (it8 -> sy == SINCLUDE) {
-LPFILECTX FileNest;
+FILECTX* FileNest;
-if(it8 -> IncludeSP >= (MAXINCLUDE-1))
+if(it8 -> IncludeSP >= (MAXINCLUDE-1)) {
-{
 SynError(it8, "Too many recursion levels");
 return;
 }
 InSymbol(it8);
 if (!Check(it8, SSTRING, "Filename expected")) return;
 FileNest = it8 -> FileStack[it8 -> IncludeSP + 1];
-if(FileNest == NULL)
+if(FileNest == NULL) {
-{
-FileNest = it8 ->FileStack[it8 -> IncludeSP + 1] = (LPFILECTX)AllocChunk(it8, sizeof(FILECTX));
+FileNest = it8 ->FileStack[it8 -> IncludeSP + 1] = (FILECTX*)AllocChunk(it8, sizeof(FILECTX));
 //if(FileNest == NULL)
 //  TODO: how to manage out-of-memory conditions?
 }
-if(_cmsMakePath(it8->str, it8->FileStack[it8->IncludeSP]->FileName, FileNest->FileName) == FALSE)
+if (BuildAbsolutePath(it8->str,
-{
+it8->FileStack[it8->IncludeSP]->FileName,
+FileNest->FileName, cmsMAX_PATH-1) == FALSE) {
 SynError(it8, "File path too long");
 return;
 }
 FileNest->Stream = fopen(FileNest->FileName, "rt");
 }
 // Checks end of line separator
 static
-LCMSBOOL CheckEOLN(LPIT8 it8)
+cmsBool CheckEOLN(cmsIT8* it8)
 {
 if (!Check(it8, SEOLN, "Expected separator")) return FALSE;
 while (it8 -> sy == SEOLN)
 InSymbol(it8);
 return TRUE;
 }
 // Skip a symbol
 static
-void Skip(LPIT8 it8, SYMBOL sy)
+void Skip(cmsIT8* it8, SYMBOL sy)
 {
 if (it8->sy == sy && it8->sy != SEOF)
 InSymbol(it8);
 }
 // Skip multiple EOLN
 static
-void SkipEOLN(LPIT8 it8)
+void SkipEOLN(cmsIT8* it8)
 {
 while (it8->sy == SEOLN) {
 InSymbol(it8);
 }
 }
 // Returns a string holding current value
 static
-LCMSBOOL GetVal(LPIT8 it8, char* Buffer, size_t max, const char* ErrorTitle)
+cmsBool GetVal(cmsIT8* it8, char* Buffer, cmsUInt32Number max, const char* ErrorTitle)
 {
 switch (it8->sy) {
 case SIDENT:  strncpy(Buffer, it8->id, max);
 Buffer[max-1]=0;
 }
 // ---------------------------------------------------------- Table
 static
-LPTABLE GetTable(LPIT8 it8)
+TABLE* GetTable(cmsIT8* it8)
 {
-if ((it8 -> nTable >= it8 ->TablesCount) || (it8 -> nTable < 0)) {
+if ((it8 -> nTable >= it8 ->TablesCount)) {
 SynError(it8, "Table %d out of sequence", it8 -> nTable);
 return it8 -> Tab;
 }
 }
 // ---------------------------------------------------------- Memory management
 // Frees an allocator and owned memory
-void LCMSEXPORT cmsIT8Free(LCMSHANDLE hIT8)
+void CMSEXPORT cmsIT8Free(cmsHANDLE hIT8)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
 if (it8 == NULL)
 return;
 if (it8->MemorySink) {
-LPOWNEDMEM p;
+OWNEDMEM* p;
-LPOWNEDMEM n;
+OWNEDMEM* n;
 for (p = it8->MemorySink; p != NULL; p = n) {
 n = p->Next;
-if (p->Ptr) _cmsFree(p->Ptr);
+if (p->Ptr) _cmsFree(it8 ->ContextID, p->Ptr);
-_cmsFree(p);
+_cmsFree(it8 ->ContextID, p);
 }
 }
 if (it8->MemoryBlock)
-_cmsFree(it8->MemoryBlock);
+_cmsFree(it8 ->ContextID, it8->MemoryBlock);
-_cmsFree(it8);
+_cmsFree(it8 ->ContextID, it8);
 }
 // Allocates a chunk of data, keep linked list
 static
-void* AllocBigBlock(LPIT8 it8, size_t size)
+void* AllocBigBlock(cmsIT8* it8, cmsUInt32Number size)
 {
-LPOWNEDMEM ptr1;
+OWNEDMEM* ptr1;
-void* ptr = _cmsMalloc(size);
+void* ptr = _cmsMallocZero(it8->ContextID, size);
-if (ptr) {
+if (ptr != NULL) {
-ZeroMemory(ptr, size);
+ptr1 = (OWNEDMEM*) _cmsMallocZero(it8 ->ContextID, sizeof(OWNEDMEM));
-ptr1 = (LPOWNEDMEM) _cmsMalloc(sizeof(OWNEDMEM));
+if (ptr1 == NULL) {
-if (ptr1 == NULL) {
+_cmsFree(it8 ->ContextID, ptr);
-_cmsFree(ptr);
+return NULL;
-return NULL;
+}
-}
+ptr1-> Ptr        = ptr;
-ZeroMemory(ptr1, sizeof(OWNEDMEM));
+ptr1-> Next       = it8 -> MemorySink;
+it8 -> MemorySink = ptr1;
-ptr1-> Ptr        = ptr;
+}
-ptr1-> Next       = it8 -> MemorySink;
-it8 -> MemorySink = ptr1;
+return ptr;
-}
-return ptr;
 }
 // Suballocator.
 static
-void* AllocChunk(LPIT8 it8, size_t size)
+void* AllocChunk(cmsIT8* it8, cmsUInt32Number size)
 {
-size_t free = it8 ->Allocator.BlockSize - it8 ->Allocator.Used;
+cmsUInt32Number Free = it8 ->Allocator.BlockSize - it8 ->Allocator.Used;
-LPBYTE ptr;
+cmsUInt8Number* ptr;
-size = ALIGNLONG(size);
+size = _cmsALIGNLONG(size);
-if (size > free) {
+if (size > Free) {
 if (it8 -> Allocator.BlockSize == 0)
 it8 -> Allocator.BlockSize = 20*1024;
 else
 if (it8 ->Allocator.BlockSize < size)
 it8 ->Allocator.BlockSize = size;
 it8 ->Allocator.Used = 0;
-it8 ->Allocator.Block = (LPBYTE) AllocBigBlock(it8, it8 ->Allocator.BlockSize);
+it8 ->Allocator.Block = (cmsUInt8Number*)  AllocBigBlock(it8, it8 ->Allocator.BlockSize);
 }
 ptr = it8 ->Allocator.Block + it8 ->Allocator.Used;
 it8 ->Allocator.Used += size;
 }
 // Allocates a string
 static
-char *AllocString(LPIT8 it8, const char* str)
+char *AllocString(cmsIT8* it8, const char* str)
 {
-size_t Size = strlen(str)+1;
+cmsUInt32Number Size = (cmsUInt32Number) strlen(str)+1;
 char *ptr;
 ptr = (char *) AllocChunk(it8, Size);
 if (ptr) strncpy (ptr, str, Size-1);
 }
 // Searches through linked list
 static
-LCMSBOOL IsAvailableOnList(LPKEYVALUE p, const char* Key, const char* Subkey, LPKEYVALUE* LastPtr)
+cmsBool IsAvailableOnList(KEYVALUE* p, const char* Key, const char* Subkey, KEYVALUE** LastPtr)
 {
 if (LastPtr) *LastPtr = p;
 for (;  p != NULL; p = p->Next) {
 if (LastPtr) *LastPtr = p;
 if (*Key != '#') { // Comments are ignored
-if (stricmp(Key, p->Keyword) == 0)
+if (cmsstrcasecmp(Key, p->Keyword) == 0)
 break;
 }
 }
 if (p == NULL)
 for (; p != NULL; p = p->NextSubkey) {
 if (LastPtr) *LastPtr = p;
-if (stricmp(Subkey, p->Subkey) == 0)
+if (cmsstrcasecmp(Subkey, p->Subkey) == 0)
 return TRUE;
 }
 return FALSE;
 }
 // Add a property into a linked list
 static
-LPKEYVALUE AddToList(LPIT8 it8, LPKEYVALUE* Head, const char *Key, const char *Subkey, const char* xValue, WRITEMODE WriteAs)
+KEYVALUE* AddToList(cmsIT8* it8, KEYVALUE** Head, const char *Key, const char *Subkey, const char* xValue, WRITEMODE WriteAs)
 {
-LPKEYVALUE p;
+KEYVALUE* p;
+KEYVALUE* last;
-// Check if property is already in list (this is an error)
+// Check if property is already in list
 if (IsAvailableOnList(*Head, Key, Subkey, &p)) {
 // This may work for editing properties
 //     return SynError(it8, "duplicate key <%s>", Key);
 }
 else {
-LPKEYVALUE last = p;
+last = p;
-// Allocate the container
-p = (LPKEYVALUE) AllocChunk(it8, sizeof(KEYVALUE));
+// Allocate the container
-if (p == NULL)
+p = (KEYVALUE*) AllocChunk(it8, sizeof(KEYVALUE));
-{
+if (p == NULL)
+{
 SynError(it8, "AddToList: out of memory");
 return NULL;
 }
 // Store name and value
 p->Keyword = AllocString(it8, Key);
 p->Subkey = (Subkey == NULL) ? NULL : AllocString(it8, Subkey);
 // Keep the container in our list
-if (*Head == NULL)
+if (*Head == NULL) {
 *Head = p;
+}
 else
 {
-if(Subkey != 0 && last != 0) {
+if (Subkey != NULL && last != NULL) {
 last->NextSubkey = p;
 // If Subkey is not null, then last is the last property with the same key,
 // but not necessarily is the last property in the list, so we need to move
 // to the actual list end
-while(last->Next != 0)
+while (last->Next != NULL)
 last = last->Next;
 }
-last->Next = p;
-}
+if (last != NULL) last->Next = p;
+}
-p->Next    = NULL;
+p->Next    = NULL;
 p->NextSubkey = NULL;
 }
 p->WriteAs = WriteAs;
 if (xValue != NULL) {
 p->Value   = AllocString(it8, xValue);
 }
 else {
 return p;
 }
 static
-LPKEYVALUE AddAvailableProperty(LPIT8 it8, const char* Key, WRITEMODE as)
+KEYVALUE* AddAvailableProperty(cmsIT8* it8, const char* Key, WRITEMODE as)
 {
 return AddToList(it8, &it8->ValidKeywords, Key, NULL, NULL, as);
 }
 static
-LPKEYVALUE AddAvailableSampleID(LPIT8 it8, const char* Key)
+KEYVALUE* AddAvailableSampleID(cmsIT8* it8, const char* Key)
 {
 return AddToList(it8, &it8->ValidSampleID, Key, NULL, NULL, WRITE_UNCOOKED);
 }
 static
-void AllocTable(LPIT8 it8)
+void AllocTable(cmsIT8* it8)
 {
-LPTABLE t;
+TABLE* t;
 t = it8 ->Tab + it8 ->TablesCount;
 t->HeaderList = NULL;
 t->DataFormat = NULL;
 it8 ->TablesCount++;
 }
-int LCMSEXPORT cmsIT8SetTable(LCMSHANDLE IT8, int nTable)
+cmsInt32Number CMSEXPORT cmsIT8SetTable(cmsHANDLE  IT8, cmsUInt32Number nTable)
 {
-LPIT8 it8 = (LPIT8) IT8;
+cmsIT8* it8 = (cmsIT8*) IT8;
 if (nTable >= it8 ->TablesCount) {
 if (nTable == it8 ->TablesCount) {
 }
 // Init an empty container
-LCMSHANDLE LCMSEXPORT cmsIT8Alloc(void)
+cmsHANDLE  CMSEXPORT cmsIT8Alloc(cmsContext ContextID)
 {
-LPIT8 it8;
+cmsIT8* it8;
 int i;
-it8 = (LPIT8) malloc(sizeof(IT8));
+it8 = (cmsIT8*) _cmsMallocZero(ContextID, sizeof(cmsIT8));
 if (it8 == NULL) return NULL;
-ZeroMemory(it8, sizeof(IT8));
 AllocTable(it8);
 it8->MemoryBlock = NULL;
 it8->MemorySink  = NULL;
 it8 ->nTable = 0;
+it8->ContextID = ContextID;
 it8->Allocator.Used = 0;
 it8->Allocator.Block = NULL;
 it8->Allocator.BlockSize = 0;
 it8->ValidKeywords = NULL;
 it8 -> ch = ' ';
 it8 -> Source = NULL;
 it8 -> inum = 0;
 it8 -> dnum = 0.0;
-it8->FileStack[0] = (LPFILECTX)AllocChunk(it8, sizeof(FILECTX));
+it8->FileStack[0] = (FILECTX*)AllocChunk(it8, sizeof(FILECTX));
 it8->IncludeSP   = 0;
 it8 -> lineno = 1;
 strcpy(it8->DoubleFormatter, DEFAULT_DBL_FORMAT);
 strcpy(it8->SheetType, "CGATS.17");
 for (i=0; i < NUMPREDEFINEDSAMPLEID; i++)
 AddAvailableSampleID(it8, PredefinedSampleID[i]);
-return (LCMSHANDLE) it8;
+return (cmsHANDLE) it8;
 }
-const char* LCMSEXPORT cmsIT8GetSheetType(LCMSHANDLE hIT8)
+const char* CMSEXPORT cmsIT8GetSheetType(cmsHANDLE hIT8)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
 return it8 ->SheetType;
 }
-LCMSBOOL  LCMSEXPORT cmsIT8SetSheetType(LCMSHANDLE hIT8, const char* Type)
+cmsBool CMSEXPORT cmsIT8SetSheetType(cmsHANDLE hIT8, const char* Type)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
 strncpy(it8 ->SheetType, Type, MAXSTR-1);
 it8 ->SheetType[MAXSTR-1] = 0;
 return TRUE;
 }
-LCMSBOOL LCMSEXPORT cmsIT8SetComment(LCMSHANDLE hIT8, const char* Val)
+cmsBool CMSEXPORT cmsIT8SetComment(cmsHANDLE hIT8, const char* Val)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
 if (!Val) return FALSE;
 if (!*Val) return FALSE;
 return AddToList(it8, &GetTable(it8)->HeaderList, "# ", NULL, Val, WRITE_UNCOOKED) != NULL;
 }
 // Sets a property
-LCMSBOOL LCMSEXPORT cmsIT8SetPropertyStr(LCMSHANDLE hIT8, const char* Key, const char *Val)
+cmsBool CMSEXPORT cmsIT8SetPropertyStr(cmsHANDLE hIT8, const char* Key, const char *Val)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
 if (!Val) return FALSE;
 if (!*Val) return FALSE;
 return AddToList(it8, &GetTable(it8)->HeaderList, Key, NULL, Val, WRITE_STRINGIFY) != NULL;
 }
-LCMSBOOL LCMSEXPORT cmsIT8SetPropertyDbl(LCMSHANDLE hIT8, const char* cProp, double Val)
+cmsBool CMSEXPORT cmsIT8SetPropertyDbl(cmsHANDLE hIT8, const char* cProp, cmsFloat64Number Val)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
 char Buffer[1024];
 sprintf(Buffer, it8->DoubleFormatter, Val);
 return AddToList(it8, &GetTable(it8)->HeaderList, cProp, NULL, Buffer, WRITE_UNCOOKED) != NULL;
 }
-LCMSBOOL LCMSEXPORT cmsIT8SetPropertyHex(LCMSHANDLE hIT8, const char* cProp, int Val)
+cmsBool CMSEXPORT cmsIT8SetPropertyHex(cmsHANDLE hIT8, const char* cProp, cmsUInt32Number Val)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
 char Buffer[1024];
 sprintf(Buffer, "%d", Val);
 return AddToList(it8, &GetTable(it8)->HeaderList, cProp, NULL, Buffer, WRITE_HEXADECIMAL) != NULL;
 }
-LCMSBOOL LCMSEXPORT cmsIT8SetPropertyUncooked(LCMSHANDLE hIT8, const char* Key, const char* Buffer)
+cmsBool CMSEXPORT cmsIT8SetPropertyUncooked(cmsHANDLE hIT8, const char* Key, const char* Buffer)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
 return AddToList(it8, &GetTable(it8)->HeaderList, Key, NULL, Buffer, WRITE_UNCOOKED) != NULL;
 }
-LCMSBOOL LCMSEXPORT cmsIT8SetPropertyMulti(LCMSHANDLE hIT8, const char* Key, const char* SubKey, const char *Buffer)
+cmsBool CMSEXPORT cmsIT8SetPropertyMulti(cmsHANDLE hIT8, const char* Key, const char* SubKey, const char *Buffer)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
 return AddToList(it8, &GetTable(it8)->HeaderList, Key, SubKey, Buffer, WRITE_PAIR) != NULL;
 }
 // Gets a property
-const char* LCMSEXPORT cmsIT8GetProperty(LCMSHANDLE hIT8, const char* Key)
+const char* CMSEXPORT cmsIT8GetProperty(cmsHANDLE hIT8, const char* Key)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
-LPKEYVALUE p;
+KEYVALUE* p;
 if (IsAvailableOnList(GetTable(it8) -> HeaderList, Key, NULL, &p))
 {
 return p -> Value;
 }
 return NULL;
 }
-double LCMSEXPORT cmsIT8GetPropertyDbl(LCMSHANDLE hIT8, const char* cProp)
+cmsFloat64Number CMSEXPORT cmsIT8GetPropertyDbl(cmsHANDLE hIT8, const char* cProp)
 {
 const char *v = cmsIT8GetProperty(hIT8, cProp);
 if (v) return atof(v);
 else return 0.0;
 }
-const char* LCMSEXPORT cmsIT8GetPropertyMulti(LCMSHANDLE hIT8, const char* Key, const char *SubKey)
+const char* CMSEXPORT cmsIT8GetPropertyMulti(cmsHANDLE hIT8, const char* Key, const char *SubKey)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
-LPKEYVALUE p;
+KEYVALUE* p;
-if (IsAvailableOnList(GetTable(it8) -> HeaderList, Key, SubKey, &p))
+if (IsAvailableOnList(GetTable(it8) -> HeaderList, Key, SubKey, &p)) {
-{
 return p -> Value;
 }
 return NULL;
 }
 // ----------------------------------------------------------------- Datasets
 static
-void AllocateDataFormat(LPIT8 it8)
+void AllocateDataFormat(cmsIT8* it8)
 {
-LPTABLE t = GetTable(it8);
+TABLE* t = GetTable(it8);
 if (t -> DataFormat) return;    // Already allocated
 t -> nSamples  = (int) cmsIT8GetPropertyDbl(it8, "NUMBER_OF_FIELDS");
 SynError(it8, "AllocateDataFormat: Unknown NUMBER_OF_FIELDS");
 t -> nSamples = 10;
 }
 t -> DataFormat = (char**) AllocChunk (it8, (t->nSamples + 1) * sizeof(char *));
-if (t->DataFormat == NULL)
+if (t->DataFormat == NULL) {
-{
 SynError(it8, "AllocateDataFormat: Unable to allocate dataFormat array");
 }
 }
 static
-const char *GetDataFormat(LPIT8 it8, int n)
+const char *GetDataFormat(cmsIT8* it8, int n)
 {
-LPTABLE t = GetTable(it8);
+TABLE* t = GetTable(it8);
 if (t->DataFormat)
 return t->DataFormat[n];
 return NULL;
 }
 static
-LCMSBOOL SetDataFormat(LPIT8 it8, int n, const char *label)
+cmsBool SetDataFormat(cmsIT8* it8, int n, const char *label)
 {
-LPTABLE t = GetTable(it8);
+TABLE* t = GetTable(it8);
-#ifdef  STRICT_CGATS
-if (!IsAvailableOnList(it8-> ValidSampleID, label, NULL, NULL)) {
-SynError(it8, "Invalid data format '%s'.", label);
-return FALSE;
-}
-#endif
 if (!t->DataFormat)
 AllocateDataFormat(it8);
 if (n > t -> nSamples) {
 SynError(it8, "More than NUMBER_OF_FIELDS fields.");
 return FALSE;
 }
 if (t->DataFormat) {
 t->DataFormat[n] = AllocString(it8, label);
 }
 return TRUE;
 }
-LCMSBOOL LCMSEXPORT cmsIT8SetDataFormat(LCMSHANDLE h, int n, const char *Sample)
+cmsBool CMSEXPORT cmsIT8SetDataFormat(cmsHANDLE  h, int n, const char *Sample)
 {
-LPIT8 it8 = (LPIT8) h;
+cmsIT8* it8 = (cmsIT8*) h;
 return SetDataFormat(it8, n, Sample);
 }
 static
-void AllocateDataSet(LPIT8 it8)
+void AllocateDataSet(cmsIT8* it8)
 {
-LPTABLE t = GetTable(it8);
+TABLE* t = GetTable(it8);
 if (t -> Data) return;    // Already allocated
 t-> nSamples   = atoi(cmsIT8GetProperty(it8, "NUMBER_OF_FIELDS"));
 t-> nPatches   = atoi(cmsIT8GetProperty(it8, "NUMBER_OF_SETS"));
 t-> Data = (char**)AllocChunk (it8, (t->nSamples + 1) * (t->nPatches + 1) *sizeof (char*));
-if (t->Data == NULL)
+if (t->Data == NULL) {
-{
 SynError(it8, "AllocateDataSet: Unable to allocate data array");
 }
 }
 static
-char* GetData(LPIT8 it8, int nSet, int nField)
+char* GetData(cmsIT8* it8, int nSet, int nField)
 {
-LPTABLE t = GetTable(it8);
+TABLE* t = GetTable(it8);
 int  nSamples   = t -> nSamples;
 int  nPatches   = t -> nPatches;
 if (nSet >= nPatches || nField >= nSamples)
 return NULL;
 if (!t->Data) return NULL;
 return t->Data [nSet * nSamples + nField];
 }
 static
-LCMSBOOL SetData(LPIT8 it8, int nSet, int nField, const char *Val)
+cmsBool SetData(cmsIT8* it8, int nSet, int nField, const char *Val)
 {
-LPTABLE t = GetTable(it8);
+TABLE* t = GetTable(it8);
 if (!t->Data)
 AllocateDataSet(it8);
 if (!t->Data) return FALSE;
 if (nSet > t -> nPatches || nSet < 0) {
 return SynError(it8, "Patch %d out of range, there are %d patches", nSet, t -> nPatches);
 }
 if (nField > t ->nSamples || nField < 0) {
 return SynError(it8, "Sample %d out of range, there are %d samples", nField, t ->nSamples);
 }
 t->Data [nSet * t -> nSamples + nField] = AllocString(it8, Val);
 return TRUE;
 }
 // --------------------------------------------------------------- File I/O
 // Writes a string to file
 static
-void WriteStr(LPSAVESTREAM f, const char *str)
+void WriteStr(SAVESTREAM* f, const char *str)
 {
+cmsUInt32Number len;
-size_t len;
 if (str == NULL)
 str = " ";
 // Lenghth to write
-len = strlen(str);
+len = (cmsUInt32Number) strlen(str);
 f ->Used += len;
 if (f ->stream) {   // Should I write it to a file?
-fwrite(str, 1, len, f->stream);
+if (fwrite(str, 1, len, f->stream) != len) {
+cmsSignalError(0, cmsERROR_WRITE, "Write to file error in CGATS parser");
+return;
+}
 }
 else {  // Or to a memory block?
 if (f ->Base) {   // Am I just counting the bytes?
 if (f ->Used > f ->Max) {
-cmsSignalError(LCMS_ERRC_ABORTED, "Write to memory overflows in CGATS parser");
+cmsSignalError(0, cmsERROR_WRITE, "Write to memory overflows in CGATS parser");
 return;
 }
-CopyMemory(f ->Ptr, str, len);
+memmove(f ->Ptr, str, len);
 f->Ptr += len;
 }
 }
 }
 // Write formatted
 static
-void Writef(LPSAVESTREAM f, const char* frm, ...)
+void Writef(SAVESTREAM* f, const char* frm, ...)
 {
 char Buffer[4096];
 va_list args;
 va_start(args, frm);
 }
 // Writes full header
 static
-void WriteHeader(LPIT8 it8, LPSAVESTREAM fp)
+void WriteHeader(cmsIT8* it8, SAVESTREAM* fp)
 {
-LPKEYVALUE p;
+KEYVALUE* p;
-LPTABLE t = GetTable(it8);
+TABLE* t = GetTable(it8);
 for (p = t->HeaderList; (p != NULL); p = p->Next)
 {
 if (*p ->Keyword == '#') {
 }
 if (!IsAvailableOnList(it8-> ValidKeywords, p->Keyword, NULL, NULL)) {
-#ifdef STRICT_CGATS
+#ifdef CMS_STRICT_CGATS
 WriteStr(fp, "KEYWORD\t\"");
 WriteStr(fp, p->Keyword);
 WriteStr(fp, "\"\n");
 #endif
 AddAvailableProperty(it8, p->Keyword, WRITE_UNCOOKED);
 }
 WriteStr(fp, p->Keyword);
 if (p->Value) {
 }
 // Writes the data format
 static
-void WriteDataFormat(LPSAVESTREAM fp, LPIT8 it8)
+void WriteDataFormat(SAVESTREAM* fp, cmsIT8* it8)
 {
 int i, nSamples;
-LPTABLE t = GetTable(it8);
+TABLE* t = GetTable(it8);
 if (!t -> DataFormat) return;
 WriteStr(fp, "BEGIN_DATA_FORMAT\n");
 WriteStr(fp, " ");
 }
 // Writes data array
 static
-void WriteData(LPSAVESTREAM fp, LPIT8 it8)
+void WriteData(SAVESTREAM* fp, cmsIT8* it8)
 {
 int  i, j;
-LPTABLE t = GetTable(it8);
+TABLE* t = GetTable(it8);
 if (!t->Data) return;
 WriteStr (fp, "BEGIN_DATA\n");
 }
 // Saves whole file
-LCMSBOOL LCMSEXPORT cmsIT8SaveToFile(LCMSHANDLE hIT8, const char* cFileName)
+cmsBool CMSEXPORT cmsIT8SaveToFile(cmsHANDLE hIT8, const char* cFileName)
 {
 SAVESTREAM sd;
-int i;
+cmsUInt32Number i;
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
-ZeroMemory(&sd, sizeof(SAVESTREAM));
+memset(&sd, 0, sizeof(sd));
 sd.stream = fopen(cFileName, "wt");
 if (!sd.stream) return FALSE;
 WriteStr(&sd, it8->SheetType);
 WriteHeader(it8, &sd);
 WriteDataFormat(&sd, it8);
 WriteData(&sd, it8);
 }
-fclose(sd.stream);
+if (fclose(sd.stream) != 0) return FALSE;
 return TRUE;
 }
 // Saves to memory
-LCMSBOOL LCMSEXPORT cmsIT8SaveToMem(LCMSHANDLE hIT8, void *MemPtr, size_t* BytesNeeded)
+cmsBool CMSEXPORT cmsIT8SaveToMem(cmsHANDLE hIT8, void *MemPtr, cmsUInt32Number* BytesNeeded)
 {
 SAVESTREAM sd;
-int i;
+cmsUInt32Number i;
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
-ZeroMemory(&sd, sizeof(SAVESTREAM));
+memset(&sd, 0, sizeof(sd));
 sd.stream = NULL;
-sd.Base   = (LPBYTE) MemPtr;
+sd.Base   = (cmsUInt8Number*)  MemPtr;
 sd.Ptr    = sd.Base;
 sd.Used = 0;
 if (sd.Base)
 // -------------------------------------------------------------- Higer level parsing
 static
-LCMSBOOL DataFormatSection(LPIT8 it8)
+cmsBool DataFormatSection(cmsIT8* it8)
 {
 int iField = 0;
-LPTABLE t = GetTable(it8);
+TABLE* t = GetTable(it8);
 InSymbol(it8);   // Eats "BEGIN_DATA_FORMAT"
 CheckEOLN(it8);
 while (it8->sy != SEND_DATA_FORMAT &&
 }
 static
-LCMSBOOL DataSection (LPIT8 it8)
+cmsBool DataSection (cmsIT8* it8)
 {
 int  iField = 0;
 int  iSet   = 0;
-char Buffer[MAXSTR];
+char Buffer[256];
-LPTABLE t = GetTable(it8);
+TABLE* t = GetTable(it8);
 InSymbol(it8);   // Eats "BEGIN_DATA"
 CheckEOLN(it8);
 if (!t->Data)
 static
-LCMSBOOL HeaderSection(LPIT8 it8)
+cmsBool HeaderSection(cmsIT8* it8)
 {
 char VarName[MAXID];
 char Buffer[MAXSTR];
-LPKEYVALUE Key;
+KEYVALUE* Key;
 while (it8->sy != SEOF &&
 it8->sy != SSYNERROR &&
 it8->sy != SBEGIN_DATA_FORMAT &&
 it8->sy != SBEGIN_DATA) {
 strncpy(VarName, it8->id, MAXID-1);
 VarName[MAXID-1] = 0;
 if (!IsAvailableOnList(it8-> ValidKeywords, VarName, NULL, &Key)) {
-#ifdef STRICT_CGATS
+#ifdef CMS_STRICT_CGATS
 return SynError(it8, "Undefined keyword '%s'", VarName);
 #else
 Key = AddAvailableProperty(it8, VarName, WRITE_UNCOOKED);
 if (Key == NULL) return FALSE;
 #endif
 char *Nextkey;
 if (it8->sy != SSTRING)
 return SynError(it8, "Invalid value '%s' for property '%s'.", Buffer, VarName);
 // chop the string as a list of "subkey, value" pairs, using ';' as a separator
-for(Subkey = Buffer; Subkey != NULL; Subkey = Nextkey)
+for (Subkey = Buffer; Subkey != NULL; Subkey = Nextkey)
 {
 char *Value, *temp;
 //  identify token pair boundary
 Nextkey = (char*) strchr(Subkey, ';');
 }
 static
-LCMSBOOL ParseIT8(LPIT8 it8, LCMSBOOL nosheet)
+cmsBool ParseIT8(cmsIT8* it8, cmsBool nosheet)
 {
 char* SheetTypePtr = it8 ->SheetType;
 if (nosheet == 0) {
 // Init usefull pointers
 static
-void CookPointers(LPIT8 it8)
+void CookPointers(cmsIT8* it8)
 {
 int idField, i;
 char* Fld;
-int j;
+cmsUInt32Number j;
-int nOldTable = it8 ->nTable;
+cmsUInt32Number nOldTable = it8 ->nTable;
 for (j=0; j < it8 ->TablesCount; j++) {
-LPTABLE t = it8 ->Tab + j;
+TABLE* t = it8 ->Tab + j;
 t -> SampleID = 0;
 it8 ->nTable = j;
 for (idField = 0; idField < t -> nSamples; idField++)
 {
-if (t ->DataFormat == NULL) {
+if (t ->DataFormat == NULL){
 SynError(it8, "Undefined DATA_FORMAT");
 return;
 }
 Fld = t->DataFormat[idField];
 if (!Fld) continue;
-if (stricmp(Fld, "SAMPLE_ID") == 0) {
+if (cmsstrcasecmp(Fld, "SAMPLE_ID") == 0) {
 t -> SampleID = idField;
 for (i=0; i < t -> nPatches; i++) {
 }
 // "LABEL" is an extension. It keeps references to forward tables
-if ((stricmp(Fld, "LABEL") == 0) || Fld[0] == '$' ) {
+if ((cmsstrcasecmp(Fld, "LABEL") == 0) || Fld[0] == '$' ) {
 // Search for table references...
 for (i=0; i < t -> nPatches; i++) {
 char *Label = GetData(it8, i, idField);
 if (Label) {
-int k;
+cmsUInt32Number k;
 // This is the label, search for a table containing
 // this property
 for (k=0; k < it8 ->TablesCount; k++) {
-LPTABLE Table = it8 ->Tab + k;
+TABLE* Table = it8 ->Tab + k;
-LPKEYVALUE p;
+KEYVALUE* p;
 if (IsAvailableOnList(Table->HeaderList, Label, NULL, &p)) {
 // Available, keep type and table
 char Buffer[256];
 // Try to infere if the file is a CGATS/IT8 file at all. Read first line
 // that should be something like some printable characters plus a \n
 static
-int IsMyBlock(LPBYTE Buffer, size_t n)
+int IsMyBlock(cmsUInt8Number* Buffer, int n)
 {
 int cols = 1, space = 0, quot = 0;
-size_t i;
+int i;
 if (n < 10) return FALSE;   // Too small
 if (n > 132)
 n = 132;
 }
 static
-int IsMyFile(const char* FileName)
+cmsBool IsMyFile(const char* FileName)
 {
 FILE *fp;
-size_t Size;
+cmsUInt32Number Size;
-BYTE Ptr[133];
+cmsUInt8Number Ptr[133];
 fp = fopen(FileName, "rt");
 if (!fp) {
-cmsSignalError(LCMS_ERRC_ABORTED, "File '%s' not found", FileName);
+cmsSignalError(0, cmsERROR_FILE, "File '%s' not found", FileName);
 return FALSE;
 }
-Size = fread(Ptr, 1, 132, fp);
+Size = (cmsUInt32Number) fread(Ptr, 1, 132, fp);
-fclose(fp);
+if (fclose(fp) != 0)
+return FALSE;
 Ptr[Size] = '\0';
 return IsMyBlock(Ptr, Size);
 }
 // ---------------------------------------------------------- Exported routines
-LCMSHANDLE LCMSEXPORT cmsIT8LoadFromMem(void *Ptr, size_t len)
+cmsHANDLE  CMSEXPORT cmsIT8LoadFromMem(cmsContext ContextID, void *Ptr, cmsUInt32Number len)
 {
-LCMSHANDLE hIT8;
+cmsHANDLE hIT8;
-LPIT8  it8;
+cmsIT8*  it8;
+int type;
-int type = IsMyBlock((LPBYTE) Ptr, len);
+_cmsAssert(Ptr != NULL);
+_cmsAssert(len != 0);
+type = IsMyBlock((cmsUInt8Number*)Ptr, len);
 if (type == 0) return NULL;
-hIT8 = cmsIT8Alloc();
+hIT8 = cmsIT8Alloc(ContextID);
 if (!hIT8) return NULL;
-it8 = (LPIT8) hIT8;
+it8 = (cmsIT8*) hIT8;
-it8 ->MemoryBlock = (char*) _cmsMalloc(len + 1);
+it8 ->MemoryBlock = (char*) _cmsMalloc(ContextID, len + 1);
 strncpy(it8 ->MemoryBlock, (const char*) Ptr, len);
 it8 ->MemoryBlock[len] = 0;
-strncpy(it8->FileStack[0]->FileName, "", MAX_PATH-1);
+strncpy(it8->FileStack[0]->FileName, "", cmsMAX_PATH-1);
 it8-> Source = it8 -> MemoryBlock;
 if (!ParseIT8(it8, type-1)) {
 cmsIT8Free(hIT8);
 }
 CookPointers(it8);
 it8 ->nTable = 0;
-_cmsFree(it8->MemoryBlock);
+_cmsFree(ContextID, it8->MemoryBlock);
 it8 -> MemoryBlock = NULL;
 return hIT8;
 }
-LCMSHANDLE LCMSEXPORT cmsIT8LoadFromFile(const char* cFileName)
+cmsHANDLE  CMSEXPORT cmsIT8LoadFromFile(cmsContext ContextID, const char* cFileName)
 {
-LCMSHANDLE hIT8;
+cmsHANDLE hIT8;
-LPIT8  it8;
+cmsIT8*  it8;
+int type;
-int type = IsMyFile(cFileName);
+_cmsAssert(cFileName != NULL);
+type = IsMyFile(cFileName);
 if (type == 0) return NULL;
-hIT8 = cmsIT8Alloc();
+hIT8 = cmsIT8Alloc(ContextID);
-it8 = (LPIT8) hIT8;
+it8 = (cmsIT8*) hIT8;
 if (!hIT8) return NULL;
 it8 ->FileStack[0]->Stream = fopen(cFileName, "rt");
 cmsIT8Free(hIT8);
 return NULL;
 }
-strncpy(it8->FileStack[0]->FileName, cFileName, MAX_PATH-1);
+strncpy(it8->FileStack[0]->FileName, cFileName, cmsMAX_PATH-1);
-it8->FileStack[0]->FileName[MAX_PATH-1] = 0;
+it8->FileStack[0]->FileName[cmsMAX_PATH-1] = 0;
 if (!ParseIT8(it8, type-1)) {
 fclose(it8 ->FileStack[0]->Stream);
 cmsIT8Free(hIT8);
 }
 CookPointers(it8);
 it8 ->nTable = 0;
-fclose(it8 ->FileStack[0]->Stream);
+if (fclose(it8 ->FileStack[0]->Stream)!= 0) {
+cmsIT8Free(hIT8);
+return NULL;
+}
 return hIT8;
 }
-int LCMSEXPORT cmsIT8EnumDataFormat(LCMSHANDLE hIT8, char ***SampleNames)
+int CMSEXPORT cmsIT8EnumDataFormat(cmsHANDLE hIT8, char ***SampleNames)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
-LPTABLE t = GetTable(it8);
+TABLE* t;
+_cmsAssert(hIT8 != NULL);
+t = GetTable(it8);
+if (SampleNames)
 *SampleNames = t -> DataFormat;
 return t -> nSamples;
 }
-int LCMSEXPORT cmsIT8EnumProperties(LCMSHANDLE hIT8, const char ***PropertyNames)
+cmsUInt32Number CMSEXPORT cmsIT8EnumProperties(cmsHANDLE hIT8, char ***PropertyNames)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
-LPKEYVALUE p;
+KEYVALUE* p;
-int n;
+cmsUInt32Number n;
-const char **Props;
+char **Props;
-LPTABLE t = GetTable(it8);
+TABLE* t;
+_cmsAssert(hIT8 != NULL);
+t = GetTable(it8);
 // Pass#1 - count properties
 n = 0;
 for (p = t -> HeaderList;  p != NULL; p = p->Next) {
 n++;
 }
-Props = (const char **) AllocChunk(it8, sizeof(char *) * n);
+Props = (char **) AllocChunk(it8, sizeof(char *) * n);
 // Pass#2 - Fill pointers
 n = 0;
 for (p = t -> HeaderList;  p != NULL; p = p->Next) {
 Props[n++] = p -> Keyword;
 *PropertyNames = Props;
 return n;
 }
-int LCMSEXPORT cmsIT8EnumPropertyMulti(LCMSHANDLE hIT8, const char* cProp, const char ***SubpropertyNames)
+cmsUInt32Number CMSEXPORT cmsIT8EnumPropertyMulti(cmsHANDLE hIT8, const char* cProp, const char ***SubpropertyNames)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
-LPKEYVALUE p, tmp;
+KEYVALUE *p, *tmp;
-int n;
+cmsUInt32Number n;
 const char **Props;
-LPTABLE t = GetTable(it8);
+TABLE* t;
+_cmsAssert(hIT8 != NULL);
+t = GetTable(it8);
 if(!IsAvailableOnList(t->HeaderList, cProp, NULL, &p)) {
 *SubpropertyNames = 0;
 return 0;
 }
 *SubpropertyNames = Props;
 return n;
 }
 static
-int LocatePatch(LPIT8 it8, const char* cPatch)
+int LocatePatch(cmsIT8* it8, const char* cPatch)
 {
 int i;
 const char *data;
-LPTABLE t = GetTable(it8);
+TABLE* t = GetTable(it8);
 for (i=0; i < t-> nPatches; i++) {
 data = GetData(it8, i, t->SampleID);
 if (data != NULL) {
-if (stricmp(data, cPatch) == 0)
+if (cmsstrcasecmp(data, cPatch) == 0)
 return i;
 }
 }
 // SynError(it8, "Couldn't find patch '%s'\n", cPatch);
 return -1;
 }
 static
-int LocateEmptyPatch(LPIT8 it8)
+int LocateEmptyPatch(cmsIT8* it8)
 {
 int i;
 const char *data;
-LPTABLE t = GetTable(it8);
+TABLE* t = GetTable(it8);
 for (i=0; i < t-> nPatches; i++) {
 data = GetData(it8, i, t->SampleID);
 if (data == NULL)
 return i;
 }
 return -1;
 }
 static
-int LocateSample(LPIT8 it8, const char* cSample)
+int LocateSample(cmsIT8* it8, const char* cSample)
 {
 int i;
 const char *fld;
-LPTABLE t = GetTable(it8);
+TABLE* t = GetTable(it8);
 for (i=0; i < t->nSamples; i++) {
 fld = GetDataFormat(it8, i);
-if (stricmp(fld, cSample) == 0)
+if (cmsstrcasecmp(fld, cSample) == 0)
 return i;
 }
-// SynError(it8, "Couldn't find data field %s\n", cSample);
 return -1;
 }
-int LCMSEXPORT cmsIT8GetDataFormat(LCMSHANDLE hIT8, const char* cSample)
+int CMSEXPORT cmsIT8FindDataFormat(cmsHANDLE hIT8, const char* cSample)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
+_cmsAssert(hIT8 != NULL);
 return LocateSample(it8, cSample);
 }
-const char* LCMSEXPORT cmsIT8GetDataRowCol(LCMSHANDLE hIT8, int row, int col)
+const char* CMSEXPORT cmsIT8GetDataRowCol(cmsHANDLE hIT8, int row, int col)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
+_cmsAssert(hIT8 != NULL);
 return GetData(it8, row, col);
 }
-double LCMSEXPORT cmsIT8GetDataRowColDbl(LCMSHANDLE hIT8, int row, int col)
+cmsFloat64Number CMSEXPORT cmsIT8GetDataRowColDbl(cmsHANDLE hIT8, int row, int col)
 {
 const char* Buffer;
 Buffer = cmsIT8GetDataRowCol(hIT8, row, col);
 return 0;
 }
-LCMSBOOL LCMSEXPORT cmsIT8SetDataRowCol(LCMSHANDLE hIT8, int row, int col, const char* Val)
+cmsBool CMSEXPORT cmsIT8SetDataRowCol(cmsHANDLE hIT8, int row, int col, const char* Val)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
+_cmsAssert(hIT8 != NULL);
 return SetData(it8, row, col, Val);
 }
-LCMSBOOL LCMSEXPORT cmsIT8SetDataRowColDbl(LCMSHANDLE hIT8, int row, int col, double Val)
+cmsBool CMSEXPORT cmsIT8SetDataRowColDbl(cmsHANDLE hIT8, int row, int col, cmsFloat64Number Val)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
 char Buff[256];
+_cmsAssert(hIT8 != NULL);
 sprintf(Buff, it8->DoubleFormatter, Val);
 return SetData(it8, row, col, Buff);
 }
-const char* LCMSEXPORT cmsIT8GetData(LCMSHANDLE hIT8, const char* cPatch, const char* cSample)
+const char* CMSEXPORT cmsIT8GetData(cmsHANDLE hIT8, const char* cPatch, const char* cSample)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
 int iField, iSet;
+_cmsAssert(hIT8 != NULL);
 iField = LocateSample(it8, cSample);
 if (iField < 0) {
 return NULL;
 }
 iSet = LocatePatch(it8, cPatch);
 if (iSet < 0) {
 return NULL;
 }
 return GetData(it8, iSet, iField);
 }
-double LCMSEXPORT cmsIT8GetDataDbl(LCMSHANDLE it8, const char* cPatch, const char* cSample)
+cmsFloat64Number CMSEXPORT cmsIT8GetDataDbl(cmsHANDLE  it8, const char* cPatch, const char* cSample)
 {
 const char* Buffer;
 Buffer = cmsIT8GetData(it8, cPatch, cSample);
 }
 }
-LCMSBOOL LCMSEXPORT cmsIT8SetData(LCMSHANDLE hIT8, const char* cPatch,
+cmsBool CMSEXPORT cmsIT8SetData(cmsHANDLE hIT8, const char* cPatch, const char* cSample, const char *Val)
-const char* cSample,
+{
-const char *Val)
+cmsIT8* it8 = (cmsIT8*) hIT8;
-{
-LPIT8 it8 = (LPIT8) hIT8;
 int iField, iSet;
-LPTABLE t = GetTable(it8);
+TABLE* t;
+_cmsAssert(hIT8 != NULL);
+t = GetTable(it8);
 iField = LocateSample(it8, cSample);
 if (iField < 0)
 return FALSE;
+if (t-> nPatches == 0) {
-if (t-> nPatches == 0) {
+AllocateDataFormat(it8);
+AllocateDataSet(it8);
-AllocateDataFormat(it8);
+CookPointers(it8);
-AllocateDataSet(it8);
+}
-CookPointers(it8);
-}
+if (cmsstrcasecmp(cSample, "SAMPLE_ID") == 0) {
+iSet   = LocateEmptyPatch(it8);
-if (stricmp(cSample, "SAMPLE_ID") == 0)
+if (iSet < 0) {
-{
+return SynError(it8, "Couldn't add more patches '%s'\n", cPatch);
+}
-iSet   = LocateEmptyPatch(it8);
-if (iSet < 0) {
+iField = t -> SampleID;
-return SynError(it8, "Couldn't add more patches '%s'\n", cPatch);
+}
-}
+else {
+iSet = LocatePatch(it8, cPatch);
-iField = t -> SampleID;
+if (iSet < 0) {
-}
+return FALSE;
-else {
+}
-iSet = LocatePatch(it8, cPatch);
+}
-if (iSet < 0) {
-return FALSE;
+return SetData(it8, iSet, iField, Val);
 }
-}
-return SetData(it8, iSet, iField, Val);
+cmsBool CMSEXPORT cmsIT8SetDataDbl(cmsHANDLE hIT8, const char* cPatch,
-}
+const char* cSample,
+cmsFloat64Number Val)
+{
-LCMSBOOL LCMSEXPORT cmsIT8SetDataDbl(LCMSHANDLE hIT8, const char* cPatch,
+cmsIT8* it8 = (cmsIT8*) hIT8;
-const char* cSample,
-double Val)
-{
-LPIT8 it8 = (LPIT8) hIT8;
 char Buff[256];
-snprintf(Buff, 255, it8->DoubleFormatter, Val);
+_cmsAssert(hIT8 != NULL);
-return cmsIT8SetData(hIT8, cPatch, cSample, Buff);
+snprintf(Buff, 255, it8->DoubleFormatter, Val);
+return cmsIT8SetData(hIT8, cPatch, cSample, Buff);
 }
 // Buffer should get MAXSTR at least
-const char* LCMSEXPORT cmsIT8GetPatchName(LCMSHANDLE hIT8, int nPatch, char* buffer)
+const char* CMSEXPORT cmsIT8GetPatchName(cmsHANDLE hIT8, int nPatch, char* buffer)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
-LPTABLE t = GetTable(it8);
+TABLE* t;
-char* Data = GetData(it8, nPatch, t->SampleID);
+char* Data;
-if (!Data) return NULL;
+_cmsAssert(hIT8 != NULL);
-if (!buffer) return Data;
+t = GetTable(it8);
-strncpy(buffer, Data, MAXSTR-1);
+Data = GetData(it8, nPatch, t->SampleID);
-buffer[MAXSTR-1] = 0;
-return buffer;
+if (!Data) return NULL;
-}
+if (!buffer) return Data;
-int LCMSEXPORT cmsIT8GetPatchByName(LCMSHANDLE hIT8, const char *cPatch)
+strncpy(buffer, Data, MAXSTR-1);
-{
+buffer[MAXSTR-1] = 0;
-return LocatePatch((LPIT8)hIT8, cPatch);
+return buffer;
 }
-int LCMSEXPORT cmsIT8TableCount(LCMSHANDLE hIT8)
+int CMSEXPORT cmsIT8GetPatchByName(cmsHANDLE hIT8, const char *cPatch)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+_cmsAssert(hIT8 != NULL);
-return it8 ->TablesCount;
+return LocatePatch((cmsIT8*)hIT8, cPatch);
+}
+cmsUInt32Number CMSEXPORT cmsIT8TableCount(cmsHANDLE hIT8)
+{
+cmsIT8* it8 = (cmsIT8*) hIT8;
+_cmsAssert(hIT8 != NULL);
+return it8 ->TablesCount;
 }
 // This handles the "LABEL" extension.
 // Label, nTable, Type
-int LCMSEXPORT cmsIT8SetTableByLabel(LCMSHANDLE hIT8, const char* cSet, const char* cField, const char* ExpectedType)
+int CMSEXPORT cmsIT8SetTableByLabel(cmsHANDLE hIT8, const char* cSet, const char* cField, const char* ExpectedType)
 {
 const char* cLabelFld;
 char Type[256], Label[256];
 int nTable;
+_cmsAssert(hIT8 != NULL);
 if (cField != NULL && *cField == 0)
 cField = "LABEL";
 if (cField == NULL)
 cField = "LABEL";
 if (ExpectedType != NULL && *ExpectedType == 0)
 ExpectedType = NULL;
 if (ExpectedType) {
-if (stricmp(Type, ExpectedType) != 0) return -1;
+if (cmsstrcasecmp(Type, ExpectedType) != 0) return -1;
 }
 return cmsIT8SetTable(hIT8, nTable);
 }
-LCMSBOOL LCMSEXPORT cmsIT8SetIndexColumn(LCMSHANDLE hIT8, const char* cSample)
+cmsBool CMSEXPORT cmsIT8SetIndexColumn(cmsHANDLE hIT8, const char* cSample)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
+int pos;
-int pos = LocateSample(it8, cSample);
+_cmsAssert(hIT8 != NULL);
+pos = LocateSample(it8, cSample);
 if(pos == -1)
 return FALSE;
 it8->Tab[it8->nTable].SampleID = pos;
 return TRUE;
 }
-void LCMSEXPORT cmsIT8DefineDblFormat(LCMSHANDLE hIT8, const char* Formatter)
+void CMSEXPORT cmsIT8DefineDblFormat(cmsHANDLE hIT8, const char* Formatter)
 {
-LPIT8 it8 = (LPIT8) hIT8;
+cmsIT8* it8 = (cmsIT8*) hIT8;
+_cmsAssert(hIT8 != NULL);
 if (Formatter == NULL)
 strcpy(it8->DoubleFormatter, DEFAULT_DBL_FORMAT);
 else
 strcpy(it8->DoubleFormatter, Formatter);

changeset 6482	0f6a4442b29e
parent 5506	202f599c92aa
child 14300	117dc9b98a7b