/home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c

Bug Summary

File:	jdk/src/java.desktop/share/native/liblcms/cmscgats.c
Warning:	line 456, column 5 Null pointer passed to 1st parameter expecting 'nonnull'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name cmscgats.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mthread-model posix -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base/linux -I /home/daniel/Projects/java/jdk/src/java.base/share/native/libjava -I /home/daniel/Projects/java/jdk/src/java.base/unix/native/libjava -I /home/daniel/Projects/java/jdk/src/hotspot/share/include -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix/include -D LIBC=gnu -D _GNU_SOURCE -D _REENTRANT -D _LARGEFILE64_SOURCE -D LINUX -D DEBUG -D _LITTLE_ENDIAN -D ARCH="amd64" -D amd64 -D _LP64=1 -D CMS_DONT_USE_FAST_FLOOR -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/headers/java.desktop -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/common/awt/debug -I /home/daniel/Projects/java/jdk/src/java.desktop/unix/native/libawt/java2d -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libawt/java2d -D _FORTIFY_SOURCE=2 -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-unused -Wno-format-nonliteral -Wno-type-limits -Wno-misleading-indentation -Wno-undef -Wno-unused-function -Wno-stringop-truncation -std=c99 -fdebug-compilation-dir /home/daniel/Projects/java/jdk/make -ferror-limit 19 -fmessage-length 0 -fvisibility hidden -stack-protector 1 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /home/daniel/Projects/java/scan/2021-12-21-193737-8510-1 -x c /home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c
1/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.  Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/

25// This file is available under and governed by the GNU General Public
26// License version 2 only, as published by the Free Software Foundation.
27// However, the following notice accompanied the original version of this
28// file:
29//
30//---------------------------------------------------------------------------------
31//
32//  Little Color Management System
33//  Copyright (c) 1998-2020 Marti Maria Saguer
34//
35// Permission is hereby granted, free of charge, to any person obtaining
36// a copy of this software and associated documentation files (the "Software"),
37// to deal in the Software without restriction, including without limitation
38// the rights to use, copy, modify, merge, publish, distribute, sublicense,
39// and/or sell copies of the Software, and to permit persons to whom the Software
40// is furnished to do so, subject to the following conditions:
41//
42// The above copyright notice and this permission notice shall be included in
43// all copies or substantial portions of the Software.
44//
45// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
46// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
47// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
48// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
49// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
50// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
51// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
52//
53//---------------------------------------------------------------------------------
54//

56#include "lcms2_internal.h"


59// IT8.7 / CGATS.17-200x handling -----------------------------------------------------------------------------


62#define MAXID128        128     // Max length of identifier
63#define MAXSTR1024      1024     // Max length of string
64#define MAXTABLES255    255     // Max Number of tables in a single stream
65#define MAXINCLUDE20    20     // Max number of nested includes

67#define DEFAULT_DBL_FORMAT"%.10g"  "%.10g" // Double formatting

69#ifdef CMS_IS_WINDOWS_
70#    include <io.h>
71#    define DIR_CHAR'/'    '\\'
72#else
73#    define DIR_CHAR'/'    '/'
74#endif


77// Symbols
78typedef enum {

      SUNDEFINED,
      SINUM,      // Integer
      SDNUM,      // Real
      SIDENT,     // Identifier
      SSTRING,    // string
      SCOMMENT,   // comment
      SEOLN,      // End of line
      SEOF,       // End of stream
      SSYNERROR,  // Syntax error found on stream

      // Keywords

      SBEGIN_DATA,
      SBEGIN_DATA_FORMAT,
      SEND_DATA,
      SEND_DATA_FORMAT,
      SKEYWORD,
      SDATA_FORMAT_ID,
      SINCLUDE

  } SYMBOL;


103// How to write the value
104typedef enum {

      WRITE_UNCOOKED,
      WRITE_STRINGIFY,
      WRITE_HEXADECIMAL,
      WRITE_BINARY,
      WRITE_PAIR

  } WRITEMODE;

114// Linked list of variable names
115typedef 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;


127// Linked list of memory chunks (Memory sink)
128typedef struct _OwnedMem {

      struct _OwnedMem* Next;
      void *            Ptr;          // Point to value

 } OWNEDMEM;

135// Suballocator
136typedef struct _SubAllocator {

       cmsUInt8Number* Block;
       cmsUInt32Number BlockSize;
       cmsUInt32Number Used;

  } SUBALLOCATOR;

144// Table. Each individual table can hold properties and rows & cols
145typedef struct _Table {

      char SheetType[MAXSTR1024];               // The first row of the IT8 (the type)

      int            nSamples, nPatches;    // Cols, Rows
      int            SampleID;              // Pos of ID

      KEYVALUE*      HeaderList;            // The properties

      char**         DataFormat;            // The binary stream descriptor
      char**         Data;                  // The binary stream

  } TABLE;

159// File stream being parsed
160typedef struct _FileContext {
      char           FileName[cmsMAX_PATH256];    // File name if being read from file
      FILE*          Stream;                   // File stream or NULL if holded in memory
  } FILECTX;

165// This struct hold all information about an open IT8 handler.
166typedef struct {


      cmsUInt32Number  TablesCount;                     // How many tables in this stream
      cmsUInt32Number  nTable;                          // The actual table

      TABLE Tab[MAXTABLES255];

      // Memory management
      OWNEDMEM*      MemorySink;            // The storage backend
      SUBALLOCATOR   Allocator;             // String suballocator -- just to keep it fast

      // Parser state machine
      SYMBOL             sy;                // Current symbol
      int                ch;                // Current character

      cmsInt32Number     inum;              // integer value
      cmsFloat64Number   dnum;              // real value

      char           id[MAXID128];             // identifier
      char           str[MAXSTR1024];           // string

      // Allowed keywords & datasets. They have visibility on whole stream
      KEYVALUE*      ValidKeywords;
      KEYVALUE*      ValidSampleID;

      char*          Source;                // Points to loc. being parsed
      cmsInt32Number lineno;                // line counter for error reporting

      FILECTX*       FileStack[MAXINCLUDE20]; // Stack of files being parsed
      cmsInt32Number IncludeSP;             // Include Stack Pointer

      char*          MemoryBlock;           // The stream if holded in memory

      char           DoubleFormatter[MAXID128];// Printf-like 'cmsFloat64Number' formatter

      cmsContext    ContextID;              // The threading context

 } cmsIT8;


207// The stream for save operations
208typedef struct {

      FILE* stream;   // For save-to-file behaviour

      cmsUInt8Number* Base;
      cmsUInt8Number* Ptr;        // For save-to-mem behaviour
      cmsUInt32Number Used;
      cmsUInt32Number Max;

  } SAVESTREAM;


220// ------------------------------------------------------ cmsIT8 parsing routines


223// A keyword
224typedef struct {

      const char *id;
      SYMBOL sy;

 } KEYWORD;

231// The keyword->symbol translation table. Sorting is required.
232static const KEYWORD TabKeys[] = {

      {"$INCLUDE",               SINCLUDE},   // This is an extension!
      {".INCLUDE",               SINCLUDE},   // This is an extension!

      {"BEGIN_DATA",             SBEGIN_DATA },
      {"BEGIN_DATA_FORMAT",      SBEGIN_DATA_FORMAT },
      {"DATA_FORMAT_IDENTIFIER", SDATA_FORMAT_ID},
      {"END_DATA",               SEND_DATA},
      {"END_DATA_FORMAT",        SEND_DATA_FORMAT},
      {"KEYWORD",                SKEYWORD}
      };

245#define NUMKEYS(sizeof(TabKeys)/sizeof(KEYWORD)) (sizeof(TabKeys)/sizeof(KEYWORD))

247// Predefined properties

249// A property
250typedef struct {
      const char *id;    // The identifier
      WRITEMODE as;      // How is supposed to be written
  } PROPERTY;

255static PROPERTY PredefinedProperties[] = {

      {"NUMBER_OF_FIELDS", WRITE_UNCOOKED},    // Required - NUMBER OF FIELDS
      {"NUMBER_OF_SETS",   WRITE_UNCOOKED},    // Required - NUMBER OF SETS
      {"ORIGINATOR",       WRITE_STRINGIFY},   // Required - Identifies the specific system, organization or individual that created the data file.
      {"FILE_DESCRIPTOR",  WRITE_STRINGIFY},   // Required - Describes the purpose or contents of the data file.
      {"CREATED",          WRITE_STRINGIFY},   // Required - Indicates date of creation of the data file.
      {"DESCRIPTOR",       WRITE_STRINGIFY},   // Required  - Describes the purpose or contents of the data file.
      {"DIFFUSE_GEOMETRY", WRITE_STRINGIFY},   // The diffuse geometry used. Allowed values are "sphere" or "opal".
      {"MANUFACTURER",     WRITE_STRINGIFY},
      {"MANUFACTURE",      WRITE_STRINGIFY},   // Some broken Fuji targets does store this value
      {"PROD_DATE",        WRITE_STRINGIFY},   // Identifies year and month of production of the target in the form yyyy:mm.
      {"SERIAL",           WRITE_STRINGIFY},   // Uniquely identifies individual physical target.

      {"MATERIAL",         WRITE_STRINGIFY},    // Identifies the material on which the target was produced using a code
                                                // uniquely identifying th e material. This is intend ed to be used for IT8.7
                                                // physical targets only (i.e . IT8.7/1 a nd IT8.7/2).

      {"INSTRUMENTATION",  WRITE_STRINGIFY},    // Used to report the specific instrumentation used (manufacturer and
                                                // model number) to generate the data reported. This data will often
                                                // provide more information about the particular data collected than an
                                                // extensive list of specific details. This is particularly important for
                                                // spectral data or data derived from spectrophotometry.

      {"MEASUREMENT_SOURCE", WRITE_STRINGIFY},  // Illumination used for spectral measurements. This data helps provide
                                                // a guide to the potential for issues of paper fluorescence, etc.

      {"PRINT_CONDITIONS", WRITE_STRINGIFY},     // Used to define the characteristics of the printed sheet being reported.
                                                 // Where standard conditions have been defined (e.g., SWOP at nominal)
                                                 // named conditions may suffice. Otherwise, detailed information is
                                                 // needed.

      {"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
                                                 // 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.

     {"FILTER",            WRITE_STRINGIFY},     // Identifies the use of physical filter(s) during measurement. Typically used to
                                                 // denote the use of filters such as none, D65, Red, Green or Blue.

     {"POLARIZATION",      WRITE_STRINGIFY},     // Identifies the use of a physical polarization filter during measurement. Allowed
                                                 // values are {"yes", "white", "none" or "na".

     {"WEIGHTING_FUNCTION", WRITE_PAIR},         // Indicates such functions as: the CIE standard observer functions used in the
                                                 // calculation of various data parameters (2 degree and 10 degree), CIE standard
                                                 // illuminant functions used in the calculation of various data parameters (e.g., D50,
                                                 // D65, etc.), density status response, etc. If used there shall be at least one
                                                 // name-value pair following the WEIGHTING_FUNCTION tag/keyword. The first attribute
                                                 // in the set shall be {"name" and shall identify the particular parameter used.
                                                 // The second shall be {"value" and shall provide the value associated with that name.
                                                 // For ASCII data, a string containing the Name and Value attribute pairs shall follow
                                                 // the weighting function keyword. A semi-colon separates attribute pairs from each
                                                 // other and within the attribute the name and value are separated by a comma.

     {"COMPUTATIONAL_PARAMETER", WRITE_PAIR},    // Parameter that is used in computing a value from measured data. Name is the name
                                                 // of the calculation, parameter is the name of the parameter used in the calculation
                                                 // and value is the value of the parameter.

     {"TARGET_TYPE",        WRITE_STRINGIFY},    // The type of target being measured, e.g. IT8.7/1, IT8.7/3, user defined, etc.

     {"COLORANT",           WRITE_STRINGIFY},    // Identifies the colorant(s) used in creating the target.

     {"TABLE_DESCRIPTOR",   WRITE_STRINGIFY},    // Describes the purpose or contents of a data table.

     {"TABLE_NAME",         WRITE_STRINGIFY}     // Provides a short name for a data table.
327};

329#define NUMPREDEFINEDPROPS(sizeof(PredefinedProperties)/sizeof(PROPERTY)) (sizeof(PredefinedProperties)/sizeof(PROPERTY))


332// Predefined sample types on dataset
333static const char* PredefinedSampleID[] = {
      "SAMPLE_ID",      // Identifies sample that data represents
      "STRING",         // Identifies label, or other non-machine readable value.
                        // Value must begin and end with a " symbol

      "CMYK_C",         // Cyan component of CMYK data expressed as a percentage
      "CMYK_M",         // Magenta component of CMYK data expressed as a percentage
      "CMYK_Y",         // Yellow component of CMYK data expressed as a percentage
      "CMYK_K",         // Black component of CMYK data expressed as a percentage
      "D_RED",          // Red filter density
      "D_GREEN",        // Green filter density
      "D_BLUE",         // Blue filter density
      "D_VIS",          // Visual filter density
      "D_MAJOR_FILTER", // Major filter d ensity
      "RGB_R",          // Red component of RGB data
      "RGB_G",          // Green component of RGB data
      "RGB_B",          // Blue com ponent of RGB data
      "SPECTRAL_NM",    // Wavelength of measurement expressed in nanometers
      "SPECTRAL_PCT",   // Percentage reflectance/transmittance
      "SPECTRAL_DEC",   // Reflectance/transmittance
      "XYZ_X",          // X component of tristimulus data
      "XYZ_Y",          // Y component of tristimulus data
      "XYZ_Z",          // Z component of tristimulus data
      "XYY_X",          // x component of chromaticity data
      "XYY_Y",          // y component of chromaticity data
      "XYY_CAPY",       // Y component of tristimulus data
      "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_94",      // CIE dE using CIE 94
      "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)
      "STDEV_Z",        // Standard deviation of Z (tristimulus data)
      "STDEV_L",        // Standard deviation of L*
      "STDEV_A",        // Standard deviation of a*
      "STDEV_B",        // Standard deviation of b*
      "STDEV_DE",       // Standard deviation of CIE dE
      "CHI_SQD_PAR"};   // The average of the standard deviations of L*, a* and b*. It is
                        // used to derive an estimate of the chi-squared parameter which is
                        // recommended as the predictor of the variability of dE

381#define NUMPREDEFINEDSAMPLEID(sizeof(PredefinedSampleID)/sizeof(char *)) (sizeof(PredefinedSampleID)/sizeof(char *))

383//Forward declaration of some internal functions
384static void* AllocChunk(cmsIT8* it8, cmsUInt32Number size);

386// Checks whatever c is a separator
387static
388cmsBool isseparator(int c)
389{
  return (c == ' ') || (c == '\t') ;
391}

393// Checks whatever c is a valid identifier char
394static
395cmsBool ismiddle(int c)
396{
 return (!isseparator(c) && (c != '#') && (c !='\"') && (c != '\'') && (c > 32) && (c < 127));
398}

400// Checks whatsever c is a valid identifier middle char.
401static
402cmsBool isidchar(int c)
403{
 return isalnum(c)((*__ctype_b_loc ())[(int) ((c))] & (unsigned short int) _ISalnum
) || ismiddle(c);
405}

407// Checks whatsever c is a valid identifier first char.
408static
409cmsBool isfirstidchar(int c)
410{
   return !isdigit(c)((*__ctype_b_loc ())[(int) ((c))] & (unsigned short int) _ISdigit
) && ismiddle(c);
3
←
Assuming the condition is false→
4
←
Returning zero, which participates in a condition later→
412}

414// Guess whether the supplied path looks like an absolute path
415static
416cmsBool isabsolutepath(const char *path)
417{
  char ThreeChars[4];

  if(path30.1
'path' is not equal to NULL
 == NULL((void*)0))
31
←
Taking false branch→
      return FALSE0;
  if (path[0] == 0)
32
←
Assuming the condition is true→
33
←
Taking true branch→
      return FALSE0;
34
←
Returning zero, which participates in a condition later→

  strncpy(ThreeChars, path, 3);
  ThreeChars[3] = 0;

  if(ThreeChars[0] == DIR_CHAR'/')
      return TRUE1;

431#ifdef  CMS_IS_WINDOWS_
  if (isalpha((int) ThreeChars[0])((*__ctype_b_loc ())[(int) (((int) ThreeChars[0]))] & (unsigned
 short int) _ISalpha) && ThreeChars[1] == ':')
      return TRUE1;
434#endif
  return FALSE0;
436}


439// Makes a file path based on a given reference path
440// NOTE: this function doesn't check if the path exists or even if it's legal
441static
442cmsBool BuildAbsolutePath(const char *relPath, const char *basePath, char *buffer, cmsUInt32Number MaxLen)
443{
  char *tail;
  cmsUInt32Number len;

  // Already absolute?
  if (isabsolutepath(relPath)) {
30
←
Calling 'isabsolutepath'→
35
←
Returning from 'isabsolutepath'→
36
←
Taking false branch→

      strncpy(buffer, relPath, MaxLen);
      buffer[MaxLen-1] = 0;
      return TRUE1;
  }

  // No, search for last
  strncpy(buffer, basePath, MaxLen);
37
←
Null pointer passed to 1st parameter expecting 'nonnull'
  buffer[MaxLen-1] = 0;

  tail = strrchr(buffer, DIR_CHAR'/');
  if (tail == NULL((void*)0)) return FALSE0;    // Is not absolute and has no separators??

  len = (cmsUInt32Number) (tail - buffer);
  if (len >= MaxLen) return FALSE0;

  // No need to assure zero terminator over here
  strncpy(tail + 1, relPath, MaxLen - len);

  return TRUE1;
469}


472// Make sure no exploit is being even tried
473static
474const char* NoMeta(const char* str)
475{
  if (strchr(str, '%') != NULL((void*)0))
      return "**** CORRUPTED FORMAT STRING ***";

  return str;
480}

482// Syntax error
483static
484cmsBool SynError(cmsIT8* it8, const char *Txt, ...)
485{
  char Buffer[256], ErrMsg[1024];
  va_list args;

  va_start(args, Txt)__builtin_va_start(args, Txt);
  vsnprintf(Buffer, 255, Txt, args);
  Buffer[255] = 0;
  va_end(args)__builtin_va_end(args);

  snprintf(ErrMsg, 1023, "%s: Line %d, %s", it8->FileStack[it8 ->IncludeSP]->FileName, it8->lineno, Buffer)__builtin___snprintf_chk (ErrMsg, 1023, 2 - 1, __builtin_object_size
 (ErrMsg, 2 > 1), "%s: Line %d, %s", it8->FileStack[it8
 ->IncludeSP]->FileName, it8->lineno, Buffer);
  ErrMsg[1023] = 0;
  it8->sy = SSYNERROR;
  cmsSignalError(it8 ->ContextID, cmsERROR_CORRUPTION_DETECTED12, "%s", ErrMsg);
  return FALSE0;
499}

501// Check if current symbol is same as specified. issue an error else.
502static
503cmsBool Check(cmsIT8* it8, SYMBOL sy, const char* Err)
504{
      if (it8 -> sy != sy)
21
←
Assuming 'sy' is equal to field 'sy'→
22
←
Taking false branch→
              return SynError(it8, NoMeta(Err));
      return TRUE1;
23
←
Returning the value 1, which participates in a condition later→
508}

510// Read Next character from stream
511static
512void NextCh(cmsIT8* it8)
513{
  if (it8 -> FileStack[it8 ->IncludeSP]->Stream) {

      it8 ->ch = fgetc(it8 ->FileStack[it8 ->IncludeSP]->Stream);

      if (feof(it8 -> FileStack[it8 ->IncludeSP]->Stream))  {

          if (it8 ->IncludeSP > 0) {

              fclose(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++;
  }
533}


536// Try to see if current identifier is a keyword, if so return the referred symbol
537static
538SYMBOL BinSrchKey(const char *id)
539{
  int l = 1;
  int r = NUMKEYS(sizeof(TabKeys)/sizeof(KEYWORD));
  int x, res;

  while (r >= l)
  {
      x = (l+r)/2;
      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 SUNDEFINED;
554}


557// 10 ^n
558static
559cmsFloat64Number xpow10(int n)
560{
  return pow(10, (cmsFloat64Number) n);
562}


565//  Reads a Real number, tries to follow from integer number
566static
567void ReadReal(cmsIT8* it8, cmsInt32Number inum)
568{
  it8->dnum = (cmsFloat64Number)inum;

  while (isdigit(it8->ch)((*__ctype_b_loc ())[(int) ((it8->ch))] & (unsigned short
 int) _ISdigit)) {

      it8->dnum = (cmsFloat64Number)it8->dnum * 10.0 + (cmsFloat64Number)(it8->ch - '0');
      NextCh(it8);
  }

  if (it8->ch == '.') {        // Decimal point

      cmsFloat64Number frac = 0.0;      // fraction
      int prec = 0;                     // precision

      NextCh(it8);               // Eats dec. point

      while (isdigit(it8->ch)((*__ctype_b_loc ())[(int) ((it8->ch))] & (unsigned short
 int) _ISdigit)) {

          frac = frac * 10.0 + (cmsFloat64Number)(it8->ch - '0');
          prec++;
          NextCh(it8);
      }

      it8->dnum = it8->dnum + (frac / xpow10(prec));
  }

  // Exponent, example 34.00E+20
  if (toupper(it8->ch)(__extension__ ({ int __res; if (sizeof (it8->ch) > 1) {
 if (__builtin_constant_p (it8->ch)) { int __c = (it8->
ch); __res = __c < -128 || __c > 255 ? __c : (*__ctype_toupper_loc
 ())[__c]; } else __res = toupper (it8->ch); } else __res =
 (*__ctype_toupper_loc ())[(int) (it8->ch)]; __res; })) == 'E') {

      cmsInt32Number e;
      cmsInt32Number sgn;

      NextCh(it8); sgn = 1;

      if (it8->ch == '-') {

          sgn = -1; NextCh(it8);
      }
      else
          if (it8->ch == '+') {

              sgn = +1;
              NextCh(it8);
          }

      e = 0;
      while (isdigit(it8->ch)((*__ctype_b_loc ())[(int) ((it8->ch))] & (unsigned short
 int) _ISdigit)) {

          cmsInt32Number digit = (it8->ch - '0');

          if ((cmsFloat64Number)e * 10.0 + (cmsFloat64Number)digit < (cmsFloat64Number)+2147483647.0)
              e = e * 10 + digit;

          NextCh(it8);
      }

      e = sgn*e;
      it8->dnum = it8->dnum * xpow10(e);
  }
627}

629// Parses a float number
630// This can not call directly atof because it uses locale dependent
631// parsing, while CCMX files always use . as decimal separator
632static
633cmsFloat64Number ParseFloatNumber(const char *Buffer)
634{
  cmsFloat64Number dnum = 0.0;
  int sign = 1;

  // keep safe
  if (Buffer == NULL((void*)0)) return 0.0;

  if (*Buffer == '-' || *Buffer == '+') {

      sign = (*Buffer == '-') ? -1 : 1;
      Buffer++;
  }


  while (*Buffer && isdigit((int)*Buffer)((*__ctype_b_loc ())[(int) (((int)*Buffer))] & (unsigned short
 int) _ISdigit)) {

      dnum = dnum * 10.0 + (*Buffer - '0');
      if (*Buffer) Buffer++;
  }

  if (*Buffer == '.') {

      cmsFloat64Number frac = 0.0;      // fraction
      int prec = 0;                     // precision

      if (*Buffer) Buffer++;

      while (*Buffer && isdigit((int)*Buffer)((*__ctype_b_loc ())[(int) (((int)*Buffer))] & (unsigned short
 int) _ISdigit)) {

          frac = frac * 10.0 + (*Buffer - '0');
          prec++;
          if (*Buffer) Buffer++;
      }

      dnum = dnum + (frac / xpow10(prec));
  }

  // Exponent, example 34.00E+20
  if (*Buffer && toupper(*Buffer)(__extension__ ({ int __res; if (sizeof (*Buffer) > 1) { if
 (__builtin_constant_p (*Buffer)) { int __c = (*Buffer); __res
 = __c < -128 || __c > 255 ? __c : (*__ctype_toupper_loc
 ())[__c]; } else __res = toupper (*Buffer); } else __res = (
*__ctype_toupper_loc ())[(int) (*Buffer)]; __res; })) == 'E') {

      int e;
      int sgn;

      if (*Buffer) Buffer++;
      sgn = 1;

      if (*Buffer == '-') {

          sgn = -1;
          if (*Buffer) Buffer++;
      }
      else
          if (*Buffer == '+') {

              sgn = +1;
              if (*Buffer) Buffer++;
          }

      e = 0;
      while (*Buffer && isdigit((int)*Buffer)((*__ctype_b_loc ())[(int) (((int)*Buffer))] & (unsigned short
 int) _ISdigit)) {

          cmsInt32Number digit = (*Buffer - '0');

          if ((cmsFloat64Number)e * 10.0 + digit < (cmsFloat64Number)+2147483647.0)
              e = e * 10 + digit;

          if (*Buffer) Buffer++;
      }

      e = sgn*e;
      dnum = dnum * xpow10(e);
  }

  return sign * dnum;
708}


711// Reads next symbol
712static
713void InSymbol(cmsIT8* it8)
714{
  CMSREGISTERregister char *idptr;
  CMSREGISTERregister int k;
  SYMBOL key;
  int sng;

  do {
15
←
Loop condition is false.  Exiting loop→

      while (isseparator(it8->ch))
1
Loop condition is false. Execution continues on line 725→
          NextCh(it8);

      if (isfirstidchar(it8->ch)) {          // Identifier
2
←
Calling 'isfirstidchar'→
5
←
Returning from 'isfirstidchar'→
6
←
Taking false branch→

          k = 0;
          idptr = it8->id;

          do {

              if (++k < MAXID128) *idptr++ = (char) it8->ch;

              NextCh(it8);

          } while (isidchar(it8->ch));

          *idptr = '\0';


          key = BinSrchKey(it8->id);
          if (key == SUNDEFINED) it8->sy = SIDENT;
          else it8->sy = key;

      }
      else                         // Is a number?
          if (isdigit(it8->ch)((*__ctype_b_loc ())[(int) ((it8->ch))] & (unsigned short
 int) _ISdigit) || it8->ch == '.' || it8->ch == '-' || it8->ch == '+')
7
←
Assuming the condition is false→
8
←
Assuming the condition is false→
9
←
Assuming the condition is false→
10
←
Assuming the condition is false→
11
←
Taking false branch→
          {
              int sign = 1;

              if (it8->ch == '-') {
                  sign = -1;
                  NextCh(it8);
              }

              it8->inum = 0;
              it8->sy   = SINUM;

              if (it8->ch == '0') {          // 0xnnnn (Hexa) or 0bnnnn (Binary)

                  NextCh(it8);
                  if (toupper(it8->ch)(__extension__ ({ int __res; if (sizeof (it8->ch) > 1) {
 if (__builtin_constant_p (it8->ch)) { int __c = (it8->
ch); __res = __c < -128 || __c > 255 ? __c : (*__ctype_toupper_loc
 ())[__c]; } else __res = toupper (it8->ch); } else __res =
 (*__ctype_toupper_loc ())[(int) (it8->ch)]; __res; })) == 'X') {

                      int j;

                      NextCh(it8);
                      while (isxdigit(it8->ch)((*__ctype_b_loc ())[(int) ((it8->ch))] & (unsigned short
 int) _ISxdigit))
                      {
                          it8->ch = toupper(it8->ch)(__extension__ ({ int __res; if (sizeof (it8->ch) > 1) {
 if (__builtin_constant_p (it8->ch)) { int __c = (it8->
ch); __res = __c < -128 || __c > 255 ? __c : (*__ctype_toupper_loc
 ())[__c]; } else __res = toupper (it8->ch); } else __res =
 (*__ctype_toupper_loc ())[(int) (it8->ch)]; __res; }));
                          if (it8->ch >= 'A' && it8->ch <= 'F')  j = it8->ch -'A'+10;
                          else j = it8->ch - '0';

                          if ((cmsFloat64Number) it8->inum * 16.0 + (cmsFloat64Number) j > (cmsFloat64Number)+2147483647.0)
                          {
                              SynError(it8, "Invalid hexadecimal number");
                              return;
                          }

                          it8->inum = it8->inum * 16 + j;
                          NextCh(it8);
                      }
                      return;
                  }

                  if (toupper(it8->ch)(__extension__ ({ int __res; if (sizeof (it8->ch) > 1) {
 if (__builtin_constant_p (it8->ch)) { int __c = (it8->
ch); __res = __c < -128 || __c > 255 ? __c : (*__ctype_toupper_loc
 ())[__c]; } else __res = toupper (it8->ch); } else __res =
 (*__ctype_toupper_loc ())[(int) (it8->ch)]; __res; })) == 'B') {  // Binary

                      int j;

                      NextCh(it8);
                      while (it8->ch == '0' || it8->ch == '1')
                      {
                          j = it8->ch - '0';

                          if ((cmsFloat64Number) it8->inum * 2.0 + j > (cmsFloat64Number)+2147483647.0)
                          {
                              SynError(it8, "Invalid binary number");
                              return;
                          }

                          it8->inum = it8->inum * 2 + j;
                          NextCh(it8);
                      }
                      return;
                  }
              }


              while (isdigit(it8->ch)((*__ctype_b_loc ())[(int) ((it8->ch))] & (unsigned short
 int) _ISdigit)) {

                  cmsInt32Number digit = (it8->ch - '0');

                  if ((cmsFloat64Number) it8->inum * 10.0 + (cmsFloat64Number) digit > (cmsFloat64Number) +2147483647.0) {
                      ReadReal(it8, it8->inum);
                      it8->sy = SDNUM;
                      it8->dnum *= sign;
                      return;
                  }

                  it8->inum = it8->inum * 10 + digit;
                  NextCh(it8);
              }

              if (it8->ch == '.') {

                  ReadReal(it8, it8->inum);
                  it8->sy = SDNUM;
                  it8->dnum *= sign;
                  return;
              }

              it8 -> inum *= sign;

              // Special case. Numbers followed by letters are taken as identifiers

              if (isidchar(it8 ->ch)) {

                  if (it8 ->sy == SINUM) {

                      snprintf(it8->id, 127, "%d", it8->inum)__builtin___snprintf_chk (it8->id, 127, 2 - 1, __builtin_object_size
 (it8->id, 2 > 1), "%d", it8->inum);
                  }
                  else {

                      snprintf(it8->id, 127, it8 ->DoubleFormatter, it8->dnum)__builtin___snprintf_chk (it8->id, 127, 2 - 1, __builtin_object_size
 (it8->id, 2 > 1), it8 ->DoubleFormatter, it8->dnum
);
                  }

                  k = (int) strlen(it8 ->id);
                  idptr = it8 ->id + k;
                  do {

                      if (++k < MAXID128) *idptr++ = (char) it8->ch;

                      NextCh(it8);

                  } while (isidchar(it8->ch));

                  *idptr = '\0';
                  it8->sy = SIDENT;
              }
              return;

          }
          else
              switch ((int) it8->ch) {
12
←
Control jumps to 'case 26:'  at line 866→

      // EOF marker -- ignore it
      case '\x1a':
          NextCh(it8);
          break;
13
←
 Execution continues on line 930→

      // Eof stream markers
      case 0:
      case -1:
          it8->sy = SEOF;
          break;


      // Next line
      case '\r':
          NextCh(it8);
          if (it8 ->ch == '\n')
              NextCh(it8);
          it8->sy = SEOLN;
          it8->lineno++;
          break;

      case '\n':
          NextCh(it8);
          it8->sy = SEOLN;
          it8->lineno++;
          break;

      // Comment
      case '#':
          NextCh(it8);
          while (it8->ch && it8->ch != '\n' && it8->ch != '\r')
              NextCh(it8);

          it8->sy = SCOMMENT;
          break;

      // String.
      case '\'':
      case '\"':
          idptr = it8->str;
          sng = it8->ch;
          k = 0;
          NextCh(it8);

          while (k < (MAXSTR1024-1) && it8->ch != sng) {

              if (it8->ch == '\n'|| it8->ch == '\r') k = MAXSTR1024+1;
              else {
                  *idptr++ = (char) it8->ch;
                  NextCh(it8);
                  k++;
              }
          }

          it8->sy = SSTRING;
          *idptr = '\0';
          NextCh(it8);
          break;


      default:
          SynError(it8, "Unrecognized character: 0x%x", it8 ->ch);
          return;
          }

  } while (it8->sy == SCOMMENT);
14
←
Assuming field 'sy' is not equal to SCOMMENT→

  // Handle the include special token

  if (it8 -> sy == SINCLUDE) {
16
←
Assuming field 'sy' is equal to SINCLUDE→
17
←
Taking true branch→

              FILECTX* FileNest;

              if(it8 -> IncludeSP >= (MAXINCLUDE20-1)) {
18
←
Assuming the condition is false→
19
←
Taking false branch→

                  SynError(it8, "Too many recursion levels");
                  return;
              }

              InSymbol(it8);
              if (!Check(it8, SSTRING, "Filename expected")) return;
20
←
Calling 'Check'→
24
←
Returning from 'Check'→
25
←
Taking false branch→

              FileNest = it8 -> FileStack[it8 -> IncludeSP + 1];
              if(FileNest == NULL((void*)0)) {
26
←
Assuming 'FileNest' is equal to NULL→
27
←
Taking true branch→

                  FileNest = it8 ->FileStack[it8 -> IncludeSP + 1] = (FILECTX*)AllocChunk(it8, sizeof(FILECTX));
                  //if(FileNest == NULL)
                  //  TODO: how to manage out-of-memory conditions?
              }

              if (BuildAbsolutePath(it8->str,
29
←
Calling 'BuildAbsolutePath'→
                                    it8->FileStack[it8->IncludeSP]->FileName,
                                    FileNest->FileName, cmsMAX_PATH256-1) == FALSE0) {
28
←
Passing null pointer value via 3rd parameter 'buffer'→
                  SynError(it8, "File path too long");
                  return;
              }

              FileNest->Stream = fopen(FileNest->FileName, "rt");
              if (FileNest->Stream == NULL((void*)0)) {

                      SynError(it8, "File %s not found", FileNest->FileName);
                      return;
              }
              it8->IncludeSP++;

              it8 ->ch = ' ';
              InSymbol(it8);
  }

974}

976// Checks end of line separator
977static
978cmsBool CheckEOLN(cmsIT8* it8)
979{
      if (!Check(it8, SEOLN, "Expected separator")) return FALSE0;
      while (it8 -> sy == SEOLN)
                      InSymbol(it8);
      return TRUE1;

985}

987// Skip a symbol

989static
990void Skip(cmsIT8* it8, SYMBOL sy)
991{
      if (it8->sy == sy && it8->sy != SEOF)
                      InSymbol(it8);
994}


997// Skip multiple EOLN
998static
999void SkipEOLN(cmsIT8* it8)
1000{
  while (it8->sy == SEOLN) {
           InSymbol(it8);
  }
1004}


1007// Returns a string holding current value
1008static
1009cmsBool GetVal(cmsIT8* it8, char* Buffer, cmsUInt32Number max, const char* ErrorTitle)
1010{
  switch (it8->sy) {

  case SEOLN:   // Empty value
                Buffer[0]=0;
                break;
  case SIDENT:  strncpy(Buffer, it8->id, max);
                Buffer[max-1]=0;
                break;
  case SINUM:   snprintf(Buffer, max, "%d", it8 -> inum)__builtin___snprintf_chk (Buffer, max, 2 - 1, __builtin_object_size
 (Buffer, 2 > 1), "%d", it8 -> inum); break;
  case SDNUM:   snprintf(Buffer, max, it8->DoubleFormatter, it8 -> dnum)__builtin___snprintf_chk (Buffer, max, 2 - 1, __builtin_object_size
 (Buffer, 2 > 1), it8->DoubleFormatter, it8 -> dnum); break;
  case SSTRING: strncpy(Buffer, it8->str, max);
                Buffer[max-1] = 0;
                break;


  default:
       return SynError(it8, "%s", ErrorTitle);
  }

  Buffer[max] = 0;
  return TRUE1;
1032}

1034// ---------------------------------------------------------- Table

1036static
1037TABLE* GetTable(cmsIT8* it8)
1038{
 if ((it8 -> nTable >= it8 ->TablesCount)) {

         SynError(it8, "Table %d out of sequence", it8 -> nTable);
         return it8 -> Tab;
 }

 return it8 ->Tab + it8 ->nTable;
1046}

1048// ---------------------------------------------------------- Memory management


1051// Frees an allocator and owned memory
1052void CMSEXPORT cmsIT8Free(cmsHANDLE hIT8)
1053{
 cmsIT8* it8 = (cmsIT8*) hIT8;

  if (it8 == NULL((void*)0))
      return;

  if (it8->MemorySink) {

      OWNEDMEM* p;
      OWNEDMEM* n;

      for (p = it8->MemorySink; p != NULL((void*)0); p = n) {

          n = p->Next;
          if (p->Ptr) _cmsFree(it8 ->ContextID, p->Ptr);
          _cmsFree(it8 ->ContextID, p);
      }
  }

  if (it8->MemoryBlock)
      _cmsFree(it8 ->ContextID, it8->MemoryBlock);

  _cmsFree(it8 ->ContextID, it8);
1076}


1079// Allocates a chunk of data, keep linked list
1080static
1081void* AllocBigBlock(cmsIT8* it8, cmsUInt32Number size)
1082{
  OWNEDMEM* ptr1;
  void* ptr = _cmsMallocZero(it8->ContextID, size);

  if (ptr != NULL((void*)0)) {

      ptr1 = (OWNEDMEM*) _cmsMallocZero(it8 ->ContextID, sizeof(OWNEDMEM));

      if (ptr1 == NULL((void*)0)) {

          _cmsFree(it8 ->ContextID, ptr);
          return NULL((void*)0);
      }

      ptr1-> Ptr        = ptr;
      ptr1-> Next       = it8 -> MemorySink;
      it8 -> MemorySink = ptr1;
  }

  return ptr;
1102}


1105// Suballocator.
1106static
1107void* AllocChunk(cmsIT8* it8, cmsUInt32Number size)
1108{
  cmsUInt32Number Free = it8 ->Allocator.BlockSize - it8 ->Allocator.Used;
  cmsUInt8Number* ptr;

  size = _cmsALIGNMEM(size)(((size)+(sizeof(void *) - 1)) & ~(sizeof(void *) - 1));

  if (size > Free) {

      if (it8 -> Allocator.BlockSize == 0)

              it8 -> Allocator.BlockSize = 20*1024;
      else
              it8 ->Allocator.BlockSize *= 2;

      if (it8 ->Allocator.BlockSize < size)
              it8 ->Allocator.BlockSize = size;

      it8 ->Allocator.Used = 0;
      it8 ->Allocator.Block = (cmsUInt8Number*)  AllocBigBlock(it8, it8 ->Allocator.BlockSize);
  }

  ptr = it8 ->Allocator.Block + it8 ->Allocator.Used;
  it8 ->Allocator.Used += size;

  return (void*) ptr;

1134}


1137// Allocates a string
1138static
1139char *AllocString(cmsIT8* it8, const char* str)
1140{
  cmsUInt32Number Size = (cmsUInt32Number) strlen(str)+1;
  char *ptr;


  ptr = (char *) AllocChunk(it8, Size);
  if (ptr) strncpy (ptr, str, Size-1);

  return ptr;
1149}

1151// Searches through linked list

1153static
1154cmsBool IsAvailableOnList(KEYVALUE* p, const char* Key, const char* Subkey, KEYVALUE** LastPtr)
1155{
  if (LastPtr) *LastPtr = p;

  for (;  p != NULL((void*)0); p = p->Next) {

      if (LastPtr) *LastPtr = p;

      if (*Key != '#') { // Comments are ignored

          if (cmsstrcasecmp(Key, p->Keyword) == 0)
              break;
      }
  }

  if (p == NULL((void*)0))
      return FALSE0;

  if (Subkey == 0)
      return TRUE1;

  for (; p != NULL((void*)0); p = p->NextSubkey) {

      if (p ->Subkey == NULL((void*)0)) continue;

      if (LastPtr) *LastPtr = p;

      if (cmsstrcasecmp(Subkey, p->Subkey) == 0)
          return TRUE1;
  }

  return FALSE0;
1186}



1190// Add a property into a linked list
1191static
1192KEYVALUE* AddToList(cmsIT8* it8, KEYVALUE** Head, const char *Key, const char *Subkey, const char* xValue, WRITEMODE WriteAs)
1193{
  KEYVALUE* p;
  KEYVALUE* last;


  // 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 {

      last = p;

      // Allocate the container
      p = (KEYVALUE*) AllocChunk(it8, sizeof(KEYVALUE));
      if (p == NULL((void*)0))
      {
          SynError(it8, "AddToList: out of memory");
          return NULL((void*)0);
      }

      // Store name and value
      p->Keyword = AllocString(it8, Key);
      p->Subkey = (Subkey == NULL((void*)0)) ? NULL((void*)0) : AllocString(it8, Subkey);

      // Keep the container in our list
      if (*Head == NULL((void*)0)) {
          *Head = p;
      }
      else
      {
          if (Subkey != NULL((void*)0) && last != NULL((void*)0)) {

              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 != NULL((void*)0))
                       last = last->Next;
          }

          if (last != NULL((void*)0)) last->Next = p;
      }

      p->Next    = NULL((void*)0);
      p->NextSubkey = NULL((void*)0);
  }

  p->WriteAs = WriteAs;

  if (xValue != NULL((void*)0)) {

      p->Value   = AllocString(it8, xValue);
  }
  else {
      p->Value   = NULL((void*)0);
  }

  return p;
1257}

1259static
1260KEYVALUE* AddAvailableProperty(cmsIT8* it8, const char* Key, WRITEMODE as)
1261{
  return AddToList(it8, &it8->ValidKeywords, Key, NULL((void*)0), NULL((void*)0), as);
1263}


1266static
1267KEYVALUE* AddAvailableSampleID(cmsIT8* it8, const char* Key)
1268{
  return AddToList(it8, &it8->ValidSampleID, Key, NULL((void*)0), NULL((void*)0), WRITE_UNCOOKED);
1270}


1273static
1274void AllocTable(cmsIT8* it8)
1275{
  TABLE* t;

  t = it8 ->Tab + it8 ->TablesCount;

  t->HeaderList = NULL((void*)0);
  t->DataFormat = NULL((void*)0);
  t->Data       = NULL((void*)0);

  it8 ->TablesCount++;
1285}


1288cmsInt32Number CMSEXPORT cmsIT8SetTable(cmsHANDLE  IT8, cmsUInt32Number nTable)
1289{
   cmsIT8* it8 = (cmsIT8*) IT8;

   if (nTable >= it8 ->TablesCount) {

       if (nTable == it8 ->TablesCount) {

           AllocTable(it8);
       }
       else {
           SynError(it8, "Table %d is out of sequence", nTable);
           return -1;
       }
   }

   it8 ->nTable = nTable;

   return (cmsInt32Number) nTable;
1307}



1311// Init an empty container
1312cmsHANDLE  CMSEXPORT cmsIT8Alloc(cmsContext ContextID)
1313{
  cmsIT8* it8;
  cmsUInt32Number i;

  it8 = (cmsIT8*) _cmsMallocZero(ContextID, sizeof(cmsIT8));
  if (it8 == NULL((void*)0)) return NULL((void*)0);

  AllocTable(it8);

  it8->MemoryBlock = NULL((void*)0);
  it8->MemorySink  = NULL((void*)0);

  it8 ->nTable = 0;

  it8->ContextID = ContextID;
  it8->Allocator.Used = 0;
  it8->Allocator.Block = NULL((void*)0);
  it8->Allocator.BlockSize = 0;

  it8->ValidKeywords = NULL((void*)0);
  it8->ValidSampleID = NULL((void*)0);

  it8 -> sy = SUNDEFINED;
  it8 -> ch = ' ';
  it8 -> Source = NULL((void*)0);
  it8 -> inum = 0;
  it8 -> dnum = 0.0;

  it8->FileStack[0] = (FILECTX*)AllocChunk(it8, sizeof(FILECTX));
  it8->IncludeSP   = 0;
  it8 -> lineno = 1;

  strcpy(it8->DoubleFormatter, DEFAULT_DBL_FORMAT"%.10g");
  cmsIT8SetSheetType((cmsHANDLE) it8, "CGATS.17");

  // Initialize predefined properties & data

  for (i=0; i < NUMPREDEFINEDPROPS(sizeof(PredefinedProperties)/sizeof(PROPERTY)); i++)
          AddAvailableProperty(it8, PredefinedProperties[i].id, PredefinedProperties[i].as);

  for (i=0; i < NUMPREDEFINEDSAMPLEID(sizeof(PredefinedSampleID)/sizeof(char *)); i++)
          AddAvailableSampleID(it8, PredefinedSampleID[i]);


 return (cmsHANDLE) it8;
1358}


1361const char* CMSEXPORT cmsIT8GetSheetType(cmsHANDLE hIT8)
1362{
      return GetTable((cmsIT8*) hIT8)->SheetType;
1364}

1366cmsBool CMSEXPORT cmsIT8SetSheetType(cmsHANDLE hIT8, const char* Type)
1367{
      TABLE* t = GetTable((cmsIT8*) hIT8);

      strncpy(t ->SheetType, Type, MAXSTR1024-1);
      t ->SheetType[MAXSTR1024-1] = 0;
      return TRUE1;
1373}

1375cmsBool CMSEXPORT cmsIT8SetComment(cmsHANDLE hIT8, const char* Val)
1376{
  cmsIT8* it8 = (cmsIT8*) hIT8;

  if (!Val) return FALSE0;
  if (!*Val) return FALSE0;

  return AddToList(it8, &GetTable(it8)->HeaderList, "# ", NULL((void*)0), Val, WRITE_UNCOOKED) != NULL((void*)0);
1383}

1385// Sets a property
1386cmsBool CMSEXPORT cmsIT8SetPropertyStr(cmsHANDLE hIT8, const char* Key, const char *Val)
1387{
  cmsIT8* it8 = (cmsIT8*) hIT8;

  if (!Val) return FALSE0;
  if (!*Val) return FALSE0;

  return AddToList(it8, &GetTable(it8)->HeaderList, Key, NULL((void*)0), Val, WRITE_STRINGIFY) != NULL((void*)0);
1394}

1396cmsBool CMSEXPORT cmsIT8SetPropertyDbl(cmsHANDLE hIT8, const char* cProp, cmsFloat64Number Val)
1397{
  cmsIT8* it8 = (cmsIT8*) hIT8;
  char Buffer[1024];

  snprintf(Buffer, 1023, it8->DoubleFormatter, Val)__builtin___snprintf_chk (Buffer, 1023, 2 - 1, __builtin_object_size
 (Buffer, 2 > 1), it8->DoubleFormatter, Val);

  return AddToList(it8, &GetTable(it8)->HeaderList, cProp, NULL((void*)0), Buffer, WRITE_UNCOOKED) != NULL((void*)0);
1404}

1406cmsBool CMSEXPORT cmsIT8SetPropertyHex(cmsHANDLE hIT8, const char* cProp, cmsUInt32Number Val)
1407{
  cmsIT8* it8 = (cmsIT8*) hIT8;
  char Buffer[1024];

  snprintf(Buffer, 1023, "%u", Val)__builtin___snprintf_chk (Buffer, 1023, 2 - 1, __builtin_object_size
 (Buffer, 2 > 1), "%u", Val);

  return AddToList(it8, &GetTable(it8)->HeaderList, cProp, NULL((void*)0), Buffer, WRITE_HEXADECIMAL) != NULL((void*)0);
1414}

1416cmsBool CMSEXPORT cmsIT8SetPropertyUncooked(cmsHANDLE hIT8, const char* Key, const char* Buffer)
1417{
  cmsIT8* it8 = (cmsIT8*) hIT8;

  return AddToList(it8, &GetTable(it8)->HeaderList, Key, NULL((void*)0), Buffer, WRITE_UNCOOKED) != NULL((void*)0);
1421}

1423cmsBool CMSEXPORT cmsIT8SetPropertyMulti(cmsHANDLE hIT8, const char* Key, const char* SubKey, const char *Buffer)
1424{
  cmsIT8* it8 = (cmsIT8*) hIT8;

  return AddToList(it8, &GetTable(it8)->HeaderList, Key, SubKey, Buffer, WRITE_PAIR) != NULL((void*)0);
1428}

1430// Gets a property
1431const char* CMSEXPORT cmsIT8GetProperty(cmsHANDLE hIT8, const char* Key)
1432{
  cmsIT8* it8 = (cmsIT8*) hIT8;
  KEYVALUE* p;

  if (IsAvailableOnList(GetTable(it8) -> HeaderList, Key, NULL((void*)0), &p))
  {
      return p -> Value;
  }
  return NULL((void*)0);
1441}


1444cmsFloat64Number CMSEXPORT cmsIT8GetPropertyDbl(cmsHANDLE hIT8, const char* cProp)
1445{
  const char *v = cmsIT8GetProperty(hIT8, cProp);

  if (v == NULL((void*)0)) return 0.0;

  return ParseFloatNumber(v);
1451}

1453const char* CMSEXPORT cmsIT8GetPropertyMulti(cmsHANDLE hIT8, const char* Key, const char *SubKey)
1454{
  cmsIT8* it8 = (cmsIT8*) hIT8;
  KEYVALUE* p;

  if (IsAvailableOnList(GetTable(it8) -> HeaderList, Key, SubKey, &p)) {
      return p -> Value;
  }
  return NULL((void*)0);
1462}

1464// ----------------------------------------------------------------- Datasets


1467static
1468void AllocateDataFormat(cmsIT8* it8)
1469{
  TABLE* t = GetTable(it8);

  if (t -> DataFormat) return;    // Already allocated

  t -> nSamples  = (int) cmsIT8GetPropertyDbl(it8, "NUMBER_OF_FIELDS");

  if (t -> nSamples <= 0) {

      SynError(it8, "AllocateDataFormat: Unknown NUMBER_OF_FIELDS");
      t -> nSamples = 10;
      }

  t -> DataFormat = (char**) AllocChunk (it8, ((cmsUInt32Number) t->nSamples + 1) * sizeof(char *));
  if (t->DataFormat == NULL((void*)0)) {

      SynError(it8, "AllocateDataFormat: Unable to allocate dataFormat array");
  }

1488}

1490static
1491const char *GetDataFormat(cmsIT8* it8, int n)
1492{
  TABLE* t = GetTable(it8);

  if (t->DataFormat)
      return t->DataFormat[n];

  return NULL((void*)0);
1499}

1501static
1502cmsBool SetDataFormat(cmsIT8* it8, int n, const char *label)
1503{
  TABLE* t = GetTable(it8);

  if (!t->DataFormat)
      AllocateDataFormat(it8);

  if (n > t -> nSamples) {
      SynError(it8, "More than NUMBER_OF_FIELDS fields.");
      return FALSE0;
  }

  if (t->DataFormat) {
      t->DataFormat[n] = AllocString(it8, label);
  }

  return TRUE1;
1519}


1522cmsBool CMSEXPORT cmsIT8SetDataFormat(cmsHANDLE  h, int n, const char *Sample)
1523{
  cmsIT8* it8 = (cmsIT8*)h;
  return SetDataFormat(it8, n, Sample);
1526}

1528// A safe atoi that returns 0 when NULL input is given
1529static
1530cmsInt32Number satoi(const char* b)
1531{
  if (b == NULL((void*)0)) return 0;
  return atoi(b);
1534}

1536static
1537void AllocateDataSet(cmsIT8* it8)
1538{
  TABLE* t = GetTable(it8);

  if (t -> Data) return;    // Already allocated

  t-> nSamples   = satoi(cmsIT8GetProperty(it8, "NUMBER_OF_FIELDS"));
  t-> nPatches   = satoi(cmsIT8GetProperty(it8, "NUMBER_OF_SETS"));

  if (t -> nSamples < 0 || t->nSamples > 0x7ffe || t->nPatches < 0 || t->nPatches > 0x7ffe)
  {
      SynError(it8, "AllocateDataSet: too much data");
  }
  else {
      // Some dumb analizers warns of possible overflow here, just take a look couple of lines above.
      t->Data = (char**)AllocChunk(it8, ((cmsUInt32Number)t->nSamples + 1) * ((cmsUInt32Number)t->nPatches + 1) * sizeof(char*));
      if (t->Data == NULL((void*)0)) {

          SynError(it8, "AllocateDataSet: Unable to allocate data array");
      }
  }

1559}

1561static
1562char* GetData(cmsIT8* it8, int nSet, int nField)
1563{
  TABLE* t = GetTable(it8);
  int nSamples    = t -> nSamples;
  int nPatches    = t -> nPatches;

  if (nSet >= nPatches || nField >= nSamples)
      return NULL((void*)0);

  if (!t->Data) return NULL((void*)0);
  return t->Data [nSet * nSamples + nField];
1573}

1575static
1576cmsBool SetData(cmsIT8* it8, int nSet, int nField, const char *Val)
1577{
  TABLE* t = GetTable(it8);

  if (!t->Data)
      AllocateDataSet(it8);

  if (!t->Data) return FALSE0;

  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 TRUE1;
1597}


1600// --------------------------------------------------------------- File I/O


1603// Writes a string to file
1604static
1605void WriteStr(SAVESTREAM* f, const char *str)
1606{
  cmsUInt32Number len;

  if (str == NULL((void*)0))
      str = " ";

  // Length to write
  len = (cmsUInt32Number) strlen(str);
  f ->Used += len;


  if (f ->stream) {   // Should I write it to a file?

      if (fwrite(str, 1, len, f->stream) != len) {
          cmsSignalError(0, cmsERROR_WRITE7, "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(0, cmsERROR_WRITE7, "Write to memory overflows in CGATS parser");
               return;
          }

          memmove(f ->Ptr, str, len);
          f->Ptr += len;
      }

  }
1640}


1643// Write formatted

1645static
1646void Writef(SAVESTREAM* f, const char* frm, ...)
1647{
  char Buffer[4096];
  va_list args;

  va_start(args, frm)__builtin_va_start(args, frm);
  vsnprintf(Buffer, 4095, frm, args);
  Buffer[4095] = 0;
  WriteStr(f, Buffer);
  va_end(args)__builtin_va_end(args);

1657}

1659// Writes full header
1660static
1661void WriteHeader(cmsIT8* it8, SAVESTREAM* fp)
1662{
  KEYVALUE* p;
  TABLE* t = GetTable(it8);

  // Writes the type
  WriteStr(fp, t->SheetType);
  WriteStr(fp, "\n");

  for (p = t->HeaderList; (p != NULL((void*)0)); p = p->Next)
  {
      if (*p ->Keyword == '#') {

          char* Pt;

          WriteStr(fp, "#\n# ");
          for (Pt = p ->Value; *Pt; Pt++) {


              Writef(fp, "%c", *Pt);

              if (*Pt == '\n') {
                  WriteStr(fp, "# ");
              }
          }

          WriteStr(fp, "\n#\n");
          continue;
      }


      if (!IsAvailableOnList(it8-> ValidKeywords, p->Keyword, NULL((void*)0), NULL((void*)0))) {

1694#ifdef CMS_STRICT_CGATS
          WriteStr(fp, "KEYWORD\t\"");
          WriteStr(fp, p->Keyword);
          WriteStr(fp, "\"\n");
1698#endif

          AddAvailableProperty(it8, p->Keyword, WRITE_UNCOOKED);
      }

      WriteStr(fp, p->Keyword);
      if (p->Value) {

          switch (p ->WriteAs) {

          case WRITE_UNCOOKED:
                  Writef(fp, "\t%s", p ->Value);
                  break;

          case WRITE_STRINGIFY:
                  Writef(fp, "\t\"%s\"", p->Value );
                  break;

          case WRITE_HEXADECIMAL:
                  Writef(fp, "\t0x%X", satoi(p ->Value));
                  break;

          case WRITE_BINARY:
                  Writef(fp, "\t0x%B", satoi(p ->Value));
                  break;

          case WRITE_PAIR:
                  Writef(fp, "\t\"%s,%s\"", p->Subkey, p->Value);
                  break;

          default: SynError(it8, "Unknown write mode %d", p ->WriteAs);
                   return;
          }
      }

      WriteStr (fp, "\n");
  }

1736}


1739// Writes the data format
1740static
1741void WriteDataFormat(SAVESTREAM* fp, cmsIT8* it8)
1742{
  int i, nSamples;
  TABLE* t = GetTable(it8);

  if (!t -> DataFormat) return;

     WriteStr(fp, "BEGIN_DATA_FORMAT\n");
     WriteStr(fp, " ");
     nSamples = satoi(cmsIT8GetProperty(it8, "NUMBER_OF_FIELDS"));

     for (i = 0; i < nSamples; i++) {

            WriteStr(fp, t->DataFormat[i]);
            WriteStr(fp, ((i == (nSamples-1)) ? "\n" : "\t"));
        }

     WriteStr (fp, "END_DATA_FORMAT\n");
1759}


1762// Writes data array
1763static
1764void WriteData(SAVESTREAM* fp, cmsIT8* it8)
1765{
     int  i, j;
     TABLE* t = GetTable(it8);

     if (!t->Data) return;

     WriteStr (fp, "BEGIN_DATA\n");

     t->nPatches = satoi(cmsIT8GetProperty(it8, "NUMBER_OF_SETS"));

     for (i = 0; i < t-> nPatches; i++) {

            WriteStr(fp, " ");

            for (j = 0; j < t->nSamples; j++) {

                   char *ptr = t->Data[i*t->nSamples+j];

                   if (ptr == NULL((void*)0)) WriteStr(fp, "\"\"");
                   else {
                       // If value contains whitespace, enclose within quote

                       if (strchr(ptr, ' ') != NULL((void*)0)) {

                           WriteStr(fp, "\"");
                           WriteStr(fp, ptr);
                           WriteStr(fp, "\"");
                       }
                       else
                          WriteStr(fp, ptr);
                   }

                   WriteStr(fp, ((j == (t->nSamples-1)) ? "\n" : "\t"));
            }
     }
     WriteStr (fp, "END_DATA\n");
1801}



1805// Saves whole file
1806cmsBool CMSEXPORT cmsIT8SaveToFile(cmsHANDLE hIT8, const char* cFileName)
1807{
  SAVESTREAM sd;
  cmsUInt32Number i;
  cmsIT8* it8 = (cmsIT8*) hIT8;

  memset(&sd, 0, sizeof(sd));

  sd.stream = fopen(cFileName, "wt");
  if (!sd.stream) return FALSE0;

  for (i=0; i < it8 ->TablesCount; i++) {

          cmsIT8SetTable(hIT8, i);
          WriteHeader(it8, &sd);
          WriteDataFormat(&sd, it8);
          WriteData(&sd, it8);
  }

  if (fclose(sd.stream) != 0) return FALSE0;

  return TRUE1;
1828}


1831// Saves to memory
1832cmsBool CMSEXPORT cmsIT8SaveToMem(cmsHANDLE hIT8, void *MemPtr, cmsUInt32Number* BytesNeeded)
1833{
  SAVESTREAM sd;
  cmsUInt32Number i;
  cmsIT8* it8 = (cmsIT8*) hIT8;

  memset(&sd, 0, sizeof(sd));

  sd.stream = NULL((void*)0);
  sd.Base   = (cmsUInt8Number*)  MemPtr;
  sd.Ptr    = sd.Base;

  sd.Used = 0;

  if (sd.Base)
      sd.Max  = *BytesNeeded;     // Write to memory?
  else
      sd.Max  = 0;                // Just counting the needed bytes

  for (i=0; i < it8 ->TablesCount; i++) {

      cmsIT8SetTable(hIT8, i);
      WriteHeader(it8, &sd);
      WriteDataFormat(&sd, it8);
      WriteData(&sd, it8);
  }

  sd.Used++;  // The \0 at the very end

  if (sd.Base)
      *sd.Ptr = 0;

  *BytesNeeded = sd.Used;

  return TRUE1;
1867}


1870// -------------------------------------------------------------- Higher level parsing

1872static
1873cmsBool DataFormatSection(cmsIT8* it8)
1874{
  int iField = 0;
  TABLE* t = GetTable(it8);

  InSymbol(it8);   // Eats "BEGIN_DATA_FORMAT"
  CheckEOLN(it8);

  while (it8->sy != SEND_DATA_FORMAT &&
      it8->sy != SEOLN &&
      it8->sy != SEOF &&
      it8->sy != SSYNERROR)  {

          if (it8->sy != SIDENT) {

              return SynError(it8, "Sample type expected");
          }

          if (!SetDataFormat(it8, iField, it8->id)) return FALSE0;
          iField++;

          InSymbol(it8);
          SkipEOLN(it8);
     }

     SkipEOLN(it8);
     Skip(it8, SEND_DATA_FORMAT);
     SkipEOLN(it8);

     if (iField != t ->nSamples) {
         SynError(it8, "Count mismatch. NUMBER_OF_FIELDS was %d, found %d\n", t ->nSamples, iField);


     }

     return TRUE1;
1909}



1913static
1914cmsBool DataSection (cmsIT8* it8)
1915{
  int  iField = 0;
  int  iSet   = 0;
  char Buffer[256];
  TABLE* t = GetTable(it8);

  InSymbol(it8);   // Eats "BEGIN_DATA"
  CheckEOLN(it8);

  if (!t->Data)
      AllocateDataSet(it8);

  while (it8->sy != SEND_DATA && it8->sy != SEOF)
  {
      if (iField >= t -> nSamples) {
          iField = 0;
          iSet++;

      }

      if (it8->sy != SEND_DATA && it8->sy != SEOF) {

          if (!GetVal(it8, Buffer, 255, "Sample data expected"))
              return FALSE0;

          if (!SetData(it8, iSet, iField, Buffer))
              return FALSE0;

          iField++;

          InSymbol(it8);
          SkipEOLN(it8);
      }
  }

  SkipEOLN(it8);
  Skip(it8, SEND_DATA);
  SkipEOLN(it8);

  // Check for data completion.

  if ((iSet+1) != t -> nPatches)
      return SynError(it8, "Count mismatch. NUMBER_OF_SETS was %d, found %d\n", t ->nPatches, iSet+1);

  return TRUE1;
1960}




1965static
1966cmsBool HeaderSection(cmsIT8* it8)
1967{
  char VarName[MAXID128];
  char Buffer[MAXSTR1024];
  KEYVALUE* Key;

      while (it8->sy != SEOF &&
             it8->sy != SSYNERROR &&
             it8->sy != SBEGIN_DATA_FORMAT &&
             it8->sy != SBEGIN_DATA) {


      switch (it8 -> sy) {

      case SKEYWORD:
              InSymbol(it8);
              if (!GetVal(it8, Buffer, MAXSTR1024-1, "Keyword expected")) return FALSE0;
              if (!AddAvailableProperty(it8, Buffer, WRITE_UNCOOKED)) return FALSE0;
              InSymbol(it8);
              break;


      case SDATA_FORMAT_ID:
              InSymbol(it8);
              if (!GetVal(it8, Buffer, MAXSTR1024-1, "Keyword expected")) return FALSE0;
              if (!AddAvailableSampleID(it8, Buffer)) return FALSE0;
              InSymbol(it8);
              break;


      case SIDENT:
          strncpy(VarName, it8->id, MAXID128 - 1);
          VarName[MAXID128 - 1] = 0;

          if (!IsAvailableOnList(it8->ValidKeywords, VarName, NULL((void*)0), &Key)) {

2002#ifdef CMS_STRICT_CGATS
              return SynError(it8, "Undefined keyword '%s'", VarName);
2004#else
              Key = AddAvailableProperty(it8, VarName, WRITE_UNCOOKED);
              if (Key == NULL((void*)0)) return FALSE0;
2007#endif
          }

          InSymbol(it8);
          if (!GetVal(it8, Buffer, MAXSTR1024 - 1, "Property data expected")) return FALSE0;

          if (Key->WriteAs != WRITE_PAIR) {
              AddToList(it8, &GetTable(it8)->HeaderList, VarName, NULL((void*)0), Buffer,
                  (it8->sy == SSTRING) ? WRITE_STRINGIFY : WRITE_UNCOOKED);
          }
          else {
              const char *Subkey;
              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((void*)0); Subkey = Nextkey)
              {
                  char *Value, *temp;

                  //  identify token pair boundary
                  Nextkey = (char*)strchr(Subkey, ';');
                  if (Nextkey)
                      *Nextkey++ = '\0';

                  // for each pair, split the subkey and the value
                  Value = (char*)strrchr(Subkey, ',');
                  if (Value == NULL((void*)0))
                      return SynError(it8, "Invalid value for property '%s'.", VarName);

                  // gobble the spaces before the coma, and the coma itself
                  temp = Value++;
                  do *temp-- = '\0'; while (temp >= Subkey && *temp == ' ');

                  // gobble any space at the right
                  temp = Value + strlen(Value) - 1;
                  while (*temp == ' ') *temp-- = '\0';

                  // trim the strings from the left
                  Subkey += strspn(Subkey, " ");
                  Value += strspn(Value, " ");

                  if (Subkey[0] == 0 || Value[0] == 0)
                      return SynError(it8, "Invalid value for property '%s'.", VarName);
                  AddToList(it8, &GetTable(it8)->HeaderList, VarName, Subkey, Value, WRITE_PAIR);
              }
          }

          InSymbol(it8);
          break;


      case SEOLN: break;

      default:
              return SynError(it8, "expected keyword or identifier");
      }

  SkipEOLN(it8);
  }

  return TRUE1;

2071}


2074static
2075void ReadType(cmsIT8* it8, char* SheetTypePtr)
2076{
  cmsInt32Number cnt = 0;

  // First line is a very special case.

  while (isseparator(it8->ch))
          NextCh(it8);

  while (it8->ch != '\r' && it8 ->ch != '\n' && it8->ch != '\t' && it8 -> ch != 0) {

      if (cnt++ < MAXSTR1024)
          *SheetTypePtr++= (char) it8 ->ch;
      NextCh(it8);
  }

  *SheetTypePtr = 0;
2092}


2095static
2096cmsBool ParseIT8(cmsIT8* it8, cmsBool nosheet)
2097{
  char* SheetTypePtr = it8 ->Tab[0].SheetType;

  if (nosheet == 0) {
      ReadType(it8, SheetTypePtr);
  }

  InSymbol(it8);

  SkipEOLN(it8);

  while (it8-> sy != SEOF &&
         it8-> sy != SSYNERROR) {

          switch (it8 -> sy) {

          case SBEGIN_DATA_FORMAT:
                  if (!DataFormatSection(it8)) return FALSE0;
                  break;

          case SBEGIN_DATA:

                  if (!DataSection(it8)) return FALSE0;

                  if (it8 -> sy != SEOF) {

                          AllocTable(it8);
                          it8 ->nTable = it8 ->TablesCount - 1;

                          // Read sheet type if present. We only support identifier and string.
                          // <ident> <eoln> is a type string
                          // anything else, is not a type string
                          if (nosheet == 0) {

                              if (it8 ->sy == SIDENT) {

                                  // May be a type sheet or may be a prop value statement. We cannot use insymbol in
                                  // this special case...
                                   while (isseparator(it8->ch))
                                       NextCh(it8);

                                   // If a newline is found, then this is a type string
                                  if (it8 ->ch == '\n' || it8->ch == '\r') {

                                       cmsIT8SetSheetType(it8, it8 ->id);
                                       InSymbol(it8);
                                  }
                                  else
                                  {
                                      // It is not. Just continue
                                      cmsIT8SetSheetType(it8, "");
                                  }
                              }
                              else
                                  // Validate quoted strings
                                  if (it8 ->sy == SSTRING) {
                                      cmsIT8SetSheetType(it8, it8 ->str);
                                      InSymbol(it8);
                                  }
                         }

                  }
                  break;

          case SEOLN:
                  SkipEOLN(it8);
                  break;

          default:
                  if (!HeaderSection(it8)) return FALSE0;
         }

  }

  return (it8 -> sy != SSYNERROR);
2172}



2176// Init useful pointers

2178static
2179void CookPointers(cmsIT8* it8)
2180{
  int idField, i;
  char* Fld;
  cmsUInt32Number j;
  cmsUInt32Number nOldTable = it8 ->nTable;

  for (j=0; j < it8 ->TablesCount; j++) {

  TABLE* t = it8 ->Tab + j;

  t -> SampleID = 0;
  it8 ->nTable = j;

  for (idField = 0; idField < t -> nSamples; idField++)
  {
      if (t ->DataFormat == NULL((void*)0)){
          SynError(it8, "Undefined DATA_FORMAT");
          return;
      }

      Fld = t->DataFormat[idField];
      if (!Fld) continue;


      if (cmsstrcasecmp(Fld, "SAMPLE_ID") == 0) {

          t -> SampleID = idField;
      }

      // "LABEL" is an extension. It keeps references to forward tables

      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) {

                  cmsUInt32Number k;

                  // This is the label, search for a table containing
                  // this property

                  for (k = 0; k < it8->TablesCount; k++) {

                      TABLE* Table = it8->Tab + k;
                      KEYVALUE* p;

                      if (IsAvailableOnList(Table->HeaderList, Label, NULL((void*)0), &p)) {

                          // Available, keep type and table
                          char Buffer[256];

                          char* Type = p->Value;
                          int  nTable = (int)k;

                          snprintf(Buffer, 255, "%s %d %s", Label, nTable, Type)__builtin___snprintf_chk (Buffer, 255, 2 - 1, __builtin_object_size
 (Buffer, 2 > 1), "%s %d %s", Label, nTable, Type);

                          SetData(it8, i, idField, Buffer);
                      }
                  }


              }

          }


      }

  }
  }

  it8 ->nTable = nOldTable;
2256}

2258// Try to infere if the file is a CGATS/IT8 file at all. Read first line
2259// that should be something like some printable characters plus a \n
2260// returns 0 if this is not like a CGATS, or an integer otherwise. This integer is the number of words in first line?
2261static
2262int IsMyBlock(const cmsUInt8Number* Buffer, cmsUInt32Number n)
2263{
  int words = 1, space = 0, quot = 0;
  cmsUInt32Number i;

  if (n < 10) return 0;   // Too small

  if (n > 132)
      n = 132;

  for (i = 1; i < n; i++) {

      switch(Buffer[i])
      {
      case '\n':
      case '\r':
          return ((quot == 1) || (words > 2)) ? 0 : words;
      case '\t':
      case ' ':
          if(!quot && !space)
              space = 1;
          break;
      case '\"':
          quot = !quot;
          break;
      default:
          if (Buffer[i] < 32) return 0;
          if (Buffer[i] > 127) return 0;
          words += space;
          space = 0;
          break;
      }
  }

  return 0;
2297}


2300static
2301cmsBool IsMyFile(const char* FileName)
2302{
 FILE *fp;
 cmsUInt32Number Size;
 cmsUInt8Number Ptr[133];

 fp = fopen(FileName, "rt");
 if (!fp) {
     cmsSignalError(0, cmsERROR_FILE1, "File '%s' not found", FileName);
     return FALSE0;
 }

 Size = (cmsUInt32Number) fread(Ptr, 1, 132, fp);

 if (fclose(fp) != 0)
     return FALSE0;

 Ptr[Size] = '\0';

 return IsMyBlock(Ptr, Size);
2321}

2323// ---------------------------------------------------------- Exported routines


2326cmsHANDLE  CMSEXPORT cmsIT8LoadFromMem(cmsContext ContextID, const void *Ptr, cmsUInt32Number len)
2327{
  cmsHANDLE hIT8;
  cmsIT8*  it8;
  int type;

  _cmsAssert(Ptr != NULL)(((Ptr != ((void*)0))) ? (void) (0) : __assert_fail ("(Ptr != ((void*)0))"
, "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c"
, 2332, __extension__ __PRETTY_FUNCTION__));
  _cmsAssert(len != 0)(((len != 0)) ? (void) (0) : __assert_fail ("(len != 0)", "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c"
, 2333, __extension__ __PRETTY_FUNCTION__));

  type = IsMyBlock((const cmsUInt8Number*)Ptr, len);
  if (type == 0) return NULL((void*)0);

  hIT8 = cmsIT8Alloc(ContextID);
  if (!hIT8) return NULL((void*)0);

  it8 = (cmsIT8*) hIT8;
  it8 ->MemoryBlock = (char*) _cmsMalloc(ContextID, len + 1);
  if (it8->MemoryBlock == NULL((void*)0))
  {
      cmsIT8Free(hIT8);
      return FALSE0;
  }

  strncpy(it8 ->MemoryBlock, (const char*) Ptr, len);
  it8 ->MemoryBlock[len] = 0;

  strncpy(it8->FileStack[0]->FileName, "", cmsMAX_PATH256-1);
  it8-> Source = it8 -> MemoryBlock;

  if (!ParseIT8(it8, type-1)) {

      cmsIT8Free(hIT8);
      return FALSE0;
  }

  CookPointers(it8);
  it8 ->nTable = 0;

  _cmsFree(ContextID, it8->MemoryBlock);
  it8 -> MemoryBlock = NULL((void*)0);

  return hIT8;


2370}


2373cmsHANDLE  CMSEXPORT cmsIT8LoadFromFile(cmsContext ContextID, const char* cFileName)
2374{

   cmsHANDLE hIT8;
   cmsIT8*  it8;
   int type;

   _cmsAssert(cFileName != NULL)(((cFileName != ((void*)0))) ? (void) (0) : __assert_fail ("(cFileName != ((void*)0))"
, "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c"
, 2380, __extension__ __PRETTY_FUNCTION__));

   type = IsMyFile(cFileName);
   if (type == 0) return NULL((void*)0);

   hIT8 = cmsIT8Alloc(ContextID);
   it8 = (cmsIT8*) hIT8;
   if (!hIT8) return NULL((void*)0);


   it8 ->FileStack[0]->Stream = fopen(cFileName, "rt");

   if (!it8 ->FileStack[0]->Stream) {
       cmsIT8Free(hIT8);
       return NULL((void*)0);
   }


  strncpy(it8->FileStack[0]->FileName, cFileName, cmsMAX_PATH256-1);
  it8->FileStack[0]->FileName[cmsMAX_PATH256-1] = 0;

  if (!ParseIT8(it8, type-1)) {

          fclose(it8 ->FileStack[0]->Stream);
          cmsIT8Free(hIT8);
          return NULL((void*)0);
  }

  CookPointers(it8);
  it8 ->nTable = 0;

  if (fclose(it8 ->FileStack[0]->Stream)!= 0) {
          cmsIT8Free(hIT8);
          return NULL((void*)0);
  }

  return hIT8;

2418}

2420int CMSEXPORT cmsIT8EnumDataFormat(cmsHANDLE hIT8, char ***SampleNames)
2421{
  cmsIT8* it8 = (cmsIT8*) hIT8;
  TABLE* t;

  _cmsAssert(hIT8 != NULL)(((hIT8 != ((void*)0))) ? (void) (0) : __assert_fail ("(hIT8 != ((void*)0))"
, "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c"
, 2425, __extension__ __PRETTY_FUNCTION__));

  t = GetTable(it8);

  if (SampleNames)
      *SampleNames = t -> DataFormat;
  return t -> nSamples;
2432}


2435cmsUInt32Number CMSEXPORT cmsIT8EnumProperties(cmsHANDLE hIT8, char ***PropertyNames)
2436{
  cmsIT8* it8 = (cmsIT8*) hIT8;
  KEYVALUE* p;
  cmsUInt32Number n;
  char **Props;
  TABLE* t;

  _cmsAssert(hIT8 != NULL)(((hIT8 != ((void*)0))) ? (void) (0) : __assert_fail ("(hIT8 != ((void*)0))"
, "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c"
, 2443, __extension__ __PRETTY_FUNCTION__));

  t = GetTable(it8);

  // Pass#1 - count properties

  n = 0;
  for (p = t -> HeaderList;  p != NULL((void*)0); p = p->Next) {
      n++;
  }


  Props = (char **) AllocChunk(it8, sizeof(char *) * n);

  // Pass#2 - Fill pointers
  n = 0;
  for (p = t -> HeaderList;  p != NULL((void*)0); p = p->Next) {
      Props[n++] = p -> Keyword;
  }

  *PropertyNames = Props;
  return n;
2465}

2467cmsUInt32Number CMSEXPORT cmsIT8EnumPropertyMulti(cmsHANDLE hIT8, const char* cProp, const char ***SubpropertyNames)
2468{
  cmsIT8* it8 = (cmsIT8*) hIT8;
  KEYVALUE *p, *tmp;
  cmsUInt32Number n;
  const char **Props;
  TABLE* t;

  _cmsAssert(hIT8 != NULL)(((hIT8 != ((void*)0))) ? (void) (0) : __assert_fail ("(hIT8 != ((void*)0))"
, "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c"
, 2475, __extension__ __PRETTY_FUNCTION__));


  t = GetTable(it8);

  if(!IsAvailableOnList(t->HeaderList, cProp, NULL((void*)0), &p)) {
      *SubpropertyNames = 0;
      return 0;
  }

  // Pass#1 - count properties

  n = 0;
  for (tmp = p;  tmp != NULL((void*)0); tmp = tmp->NextSubkey) {
      if(tmp->Subkey != NULL((void*)0))
          n++;
  }


  Props = (const char **) AllocChunk(it8, sizeof(char *) * n);

  // Pass#2 - Fill pointers
  n = 0;
  for (tmp = p;  tmp != NULL((void*)0); tmp = tmp->NextSubkey) {
      if(tmp->Subkey != NULL((void*)0))
          Props[n++] = p ->Subkey;
  }

  *SubpropertyNames = Props;
  return n;
2505}

2507static
2508int LocatePatch(cmsIT8* it8, const char* cPatch)
2509{
  int i;
  const char *data;
  TABLE* t = GetTable(it8);

  for (i=0; i < t-> nPatches; i++) {

      data = GetData(it8, i, t->SampleID);

      if (data != NULL((void*)0)) {

              if (cmsstrcasecmp(data, cPatch) == 0)
                      return i;
              }
      }

      // SynError(it8, "Couldn't find patch '%s'\n", cPatch);
      return -1;
2527}


2530static
2531int LocateEmptyPatch(cmsIT8* it8)
2532{
  int i;
  const char *data;
  TABLE* t = GetTable(it8);

  for (i=0; i < t-> nPatches; i++) {

      data = GetData(it8, i, t->SampleID);

      if (data == NULL((void*)0))
          return i;

  }

  return -1;
2547}

2549static
2550int LocateSample(cmsIT8* it8, const char* cSample)
2551{
  int i;
  const char *fld;
  TABLE* t = GetTable(it8);

  for (i=0; i < t->nSamples; i++) {

      fld = GetDataFormat(it8, i);
      if (fld != NULL((void*)0)) {
          if (cmsstrcasecmp(fld, cSample) == 0)
              return i;
      }
  }

  return -1;

2567}


2570int CMSEXPORT cmsIT8FindDataFormat(cmsHANDLE hIT8, const char* cSample)
2571{
  cmsIT8* it8 = (cmsIT8*) hIT8;

  _cmsAssert(hIT8 != NULL)(((hIT8 != ((void*)0))) ? (void) (0) : __assert_fail ("(hIT8 != ((void*)0))"
, "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c"
, 2574, __extension__ __PRETTY_FUNCTION__));

  return LocateSample(it8, cSample);
2577}



2581const char* CMSEXPORT cmsIT8GetDataRowCol(cmsHANDLE hIT8, int row, int col)
2582{
  cmsIT8* it8 = (cmsIT8*) hIT8;

  _cmsAssert(hIT8 != NULL)(((hIT8 != ((void*)0))) ? (void) (0) : __assert_fail ("(hIT8 != ((void*)0))"
, "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c"
, 2585, __extension__ __PRETTY_FUNCTION__));

  return GetData(it8, row, col);
2588}


2591cmsFloat64Number CMSEXPORT cmsIT8GetDataRowColDbl(cmsHANDLE hIT8, int row, int col)
2592{
  const char* Buffer;

  Buffer = cmsIT8GetDataRowCol(hIT8, row, col);

  if (Buffer == NULL((void*)0)) return 0.0;

  return ParseFloatNumber(Buffer);
2600}


2603cmsBool CMSEXPORT cmsIT8SetDataRowCol(cmsHANDLE hIT8, int row, int col, const char* Val)
2604{
  cmsIT8* it8 = (cmsIT8*) hIT8;

  _cmsAssert(hIT8 != NULL)(((hIT8 != ((void*)0))) ? (void) (0) : __assert_fail ("(hIT8 != ((void*)0))"
, "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c"
, 2607, __extension__ __PRETTY_FUNCTION__));

  return SetData(it8, row, col, Val);
2610}


2613cmsBool CMSEXPORT cmsIT8SetDataRowColDbl(cmsHANDLE hIT8, int row, int col, cmsFloat64Number Val)
2614{
  cmsIT8* it8 = (cmsIT8*) hIT8;
  char Buff[256];

  _cmsAssert(hIT8 != NULL)(((hIT8 != ((void*)0))) ? (void) (0) : __assert_fail ("(hIT8 != ((void*)0))"
, "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c"
, 2618, __extension__ __PRETTY_FUNCTION__));

  snprintf(Buff, 255, it8->DoubleFormatter, Val)__builtin___snprintf_chk (Buff, 255, 2 - 1, __builtin_object_size
 (Buff, 2 > 1), it8->DoubleFormatter, Val);

  return SetData(it8, row, col, Buff);
2623}



2627const char* CMSEXPORT cmsIT8GetData(cmsHANDLE hIT8, const char* cPatch, const char* cSample)
2628{
  cmsIT8* it8 = (cmsIT8*) hIT8;
  int iField, iSet;

  _cmsAssert(hIT8 != NULL)(((hIT8 != ((void*)0))) ? (void) (0) : __assert_fail ("(hIT8 != ((void*)0))"
, "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c"
, 2632, __extension__ __PRETTY_FUNCTION__));

  iField = LocateSample(it8, cSample);
  if (iField < 0) {
      return NULL((void*)0);
  }

  iSet = LocatePatch(it8, cPatch);
  if (iSet < 0) {
          return NULL((void*)0);
  }

  return GetData(it8, iSet, iField);
2645}


2648cmsFloat64Number CMSEXPORT cmsIT8GetDataDbl(cmsHANDLE  it8, const char* cPatch, const char* cSample)
2649{
  const char* Buffer;

  Buffer = cmsIT8GetData(it8, cPatch, cSample);

  return ParseFloatNumber(Buffer);
2655}



2659cmsBool CMSEXPORT cmsIT8SetData(cmsHANDLE hIT8, const char* cPatch, const char* cSample, const char *Val)
2660{
  cmsIT8* it8 = (cmsIT8*) hIT8;
  int iField, iSet;
  TABLE* t;

  _cmsAssert(hIT8 != NULL)(((hIT8 != ((void*)0))) ? (void) (0) : __assert_fail ("(hIT8 != ((void*)0))"
, "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c"
, 2665, __extension__ __PRETTY_FUNCTION__));

  t = GetTable(it8);

  iField = LocateSample(it8, cSample);

  if (iField < 0)
      return FALSE0;

  if (t-> nPatches == 0) {

      AllocateDataFormat(it8);
      AllocateDataSet(it8);
      CookPointers(it8);
  }

  if (cmsstrcasecmp(cSample, "SAMPLE_ID") == 0) {

      iSet   = LocateEmptyPatch(it8);
      if (iSet < 0) {
          return SynError(it8, "Couldn't add more patches '%s'\n", cPatch);
      }

      iField = t -> SampleID;
  }
  else {
      iSet = LocatePatch(it8, cPatch);
      if (iSet < 0) {
          return FALSE0;
      }
  }

  return SetData(it8, iSet, iField, Val);
2698}


2701cmsBool CMSEXPORT cmsIT8SetDataDbl(cmsHANDLE hIT8, const char* cPatch,
                                 const char* cSample,
                                 cmsFloat64Number Val)
2704{
  cmsIT8* it8 = (cmsIT8*) hIT8;
  char Buff[256];

  _cmsAssert(hIT8 != NULL)(((hIT8 != ((void*)0))) ? (void) (0) : __assert_fail ("(hIT8 != ((void*)0))"
, "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c"
, 2708, __extension__ __PRETTY_FUNCTION__));

  snprintf(Buff, 255, it8->DoubleFormatter, Val)__builtin___snprintf_chk (Buff, 255, 2 - 1, __builtin_object_size
 (Buff, 2 > 1), it8->DoubleFormatter, Val);
  return cmsIT8SetData(hIT8, cPatch, cSample, Buff);
2712}

2714// Buffer should get MAXSTR at least

2716const char* CMSEXPORT cmsIT8GetPatchName(cmsHANDLE hIT8, int nPatch, char* buffer)
2717{
  cmsIT8* it8 = (cmsIT8*) hIT8;
  TABLE* t;
  char* Data;

  _cmsAssert(hIT8 != NULL)(((hIT8 != ((void*)0))) ? (void) (0) : __assert_fail ("(hIT8 != ((void*)0))"
, "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c"
, 2722, __extension__ __PRETTY_FUNCTION__));

  t = GetTable(it8);
  Data = GetData(it8, nPatch, t->SampleID);

  if (!Data) return NULL((void*)0);
  if (!buffer) return Data;

  strncpy(buffer, Data, MAXSTR1024-1);
  buffer[MAXSTR1024-1] = 0;
  return buffer;
2733}

2735int CMSEXPORT cmsIT8GetPatchByName(cmsHANDLE hIT8, const char *cPatch)
2736{
  _cmsAssert(hIT8 != NULL)(((hIT8 != ((void*)0))) ? (void) (0) : __assert_fail ("(hIT8 != ((void*)0))"
, "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c"
, 2737, __extension__ __PRETTY_FUNCTION__));

  return LocatePatch((cmsIT8*)hIT8, cPatch);
2740}

2742cmsUInt32Number CMSEXPORT cmsIT8TableCount(cmsHANDLE hIT8)
2743{
  cmsIT8* it8 = (cmsIT8*) hIT8;

  _cmsAssert(hIT8 != NULL)(((hIT8 != ((void*)0))) ? (void) (0) : __assert_fail ("(hIT8 != ((void*)0))"
, "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c"
, 2746, __extension__ __PRETTY_FUNCTION__));

  return it8 ->TablesCount;
2749}

2751// This handles the "LABEL" extension.
2752// Label, nTable, Type

2754int CMSEXPORT cmsIT8SetTableByLabel(cmsHANDLE hIT8, const char* cSet, const char* cField, const char* ExpectedType)
2755{
  const char* cLabelFld;
  char Type[256], Label[256];
  cmsUInt32Number nTable;

  _cmsAssert(hIT8 != NULL)(((hIT8 != ((void*)0))) ? (void) (0) : __assert_fail ("(hIT8 != ((void*)0))"
, "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c"
, 2760, __extension__ __PRETTY_FUNCTION__));

  if (cField != NULL((void*)0) && *cField == 0)
          cField = "LABEL";

  if (cField == NULL((void*)0))
          cField = "LABEL";

  cLabelFld = cmsIT8GetData(hIT8, cSet, cField);
  if (!cLabelFld) return -1;

  if (sscanf(cLabelFld, "%255s %u %255s", Label, &nTable, Type) != 3)
          return -1;

  if (ExpectedType != NULL((void*)0) && *ExpectedType == 0)
      ExpectedType = NULL((void*)0);

  if (ExpectedType) {

      if (cmsstrcasecmp(Type, ExpectedType) != 0) return -1;
  }

  return cmsIT8SetTable(hIT8, nTable);
2783}


2786cmsBool CMSEXPORT cmsIT8SetIndexColumn(cmsHANDLE hIT8, const char* cSample)
2787{
  cmsIT8* it8 = (cmsIT8*) hIT8;
  int pos;

  _cmsAssert(hIT8 != NULL)(((hIT8 != ((void*)0))) ? (void) (0) : __assert_fail ("(hIT8 != ((void*)0))"
, "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c"
, 2791, __extension__ __PRETTY_FUNCTION__));

  pos = LocateSample(it8, cSample);
  if(pos == -1)
      return FALSE0;

  it8->Tab[it8->nTable].SampleID = pos;
  return TRUE1;
2799}


2802void CMSEXPORT cmsIT8DefineDblFormat(cmsHANDLE hIT8, const char* Formatter)
2803{
  cmsIT8* it8 = (cmsIT8*) hIT8;

  _cmsAssert(hIT8 != NULL)(((hIT8 != ((void*)0))) ? (void) (0) : __assert_fail ("(hIT8 != ((void*)0))"
, "/home/daniel/Projects/java/jdk/src/java.desktop/share/native/liblcms/cmscgats.c"
, 2806, __extension__ __PRETTY_FUNCTION__));

  if (Formatter == NULL((void*)0))
      strcpy(it8->DoubleFormatter, DEFAULT_DBL_FORMAT"%.10g");
  else
      strncpy(it8->DoubleFormatter, Formatter, sizeof(it8->DoubleFormatter));

  it8 ->DoubleFormatter[sizeof(it8 ->DoubleFormatter)-1] = 0;
2814}
