/Users/xss/DemoIccMAX-hoyt-master/IccXML/IccLibXML/IccTagXml.cpp

Bug Summary

File:	IccXML/IccLibXML/IccTagXml.cpp
Warning:	line 4617, column 31 Access to field 'name' results in a dereference of a null pointer (loaded from variable 'firstNode')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-apple-macosx14.0.0 -Wundef-prefix=TARGET_OS_ -Werror=undef-prefix -Wdeprecated-objc-isa-usage -Werror=deprecated-objc-isa-usage -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name IccTagXml.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=osx -analyzer-checker=security.insecureAPI.decodeValueOfObjCType -analyzer-checker=deadcode -analyzer-checker=cplusplus -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 -mframe-pointer=all -ffp-contract=on -fno-rounding-math -funwind-tables=2 -target-sdk-version=14.0 -fcompatibility-qualified-id-block-type-checking -fvisibility-inlines-hidden-static-local-var -target-cpu penryn -tune-cpu generic -debugger-tuning=lldb -target-linker-version 1015.7 -fprofile-instrument=clang -fcoverage-mapping -fcoverage-compilation-dir=/Users/xss/DemoIccMAX-hoyt-master/build/IccXML -resource-dir /usr/local/Cellar/llvm/17.0.3/lib/clang/17 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk -D IccXML2_EXPORTS -I /Users/xss/DemoIccMAX-hoyt-master/build/Cmake/../../IccProfLib -I /Library/Developer/CommandLineTools/SDKs/MacOSX12.sdk/usr/include/libxml2 -I /Developer/Headers/FlatCarbon -F/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk/System/Library/Frameworks -internal-isystem /usr/local/Cellar/llvm/17.0.3/bin/../include/c++/v1 -internal-isystem /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk/usr/local/include -internal-isystem /usr/local/Cellar/llvm/17.0.3/lib/clang/17/include -internal-externc-isystem /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk/usr/include -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/Users/xss/DemoIccMAX-hoyt-master/build/IccXML -ferror-limit 19 -fsanitize=address -fsanitize-system-ignorelist=/usr/local/Cellar/llvm/17.0.3/lib/clang/17/share/asan_ignorelist.txt -fno-sanitize-memory-param-retval -fsanitize-address-use-after-scope -fsanitize-address-globals-dead-stripping -fno-assume-sane-operator-new -stack-protector 1 -fblocks -fencode-extended-block-signature -fregister-global-dtors-with-atexit -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -fmax-type-align=16 -analyzer-output=html -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /var/folders/l9/sd9kj1px4yq2wc5_lkwhlt6w0000gn/T/scan-build-2023-10-28-102616-57860-1 -x c++ /Users/xss/DemoIccMAX-hoyt-master/IccXML/IccLibXML/IccTagXml.cpp
1/** @file
  File:       IccTagXML.cpp

  Contains:   Implementation ICC tag XML format conversions

  Version:    V1

  Copyright:  (c) see ICC Software License
9*/

11/*
* The ICC Software License, Version 0.2
*
*
* Copyright (c) 2003-2012 The International Color Consortium. All rights 
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer. 
*
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in
*    the documentation and/or other materials provided with the
*    distribution.
*
* 3. In the absence of prior written permission, the names "ICC" and "The
*    International Color Consortium" must not be used to imply that the
*    ICC organization endorses or promotes products derived from this
*    software.
*
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED.  IN NO EVENT SHALL THE INTERNATIONAL COLOR CONSORTIUM OR
* ITS CONTRIBUTING MEMBERS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the The International Color Consortium. 
*
*
* Membership in the ICC is encouraged when this software is used for
* commercial purposes. 
*
*  
* For more information on The International Color Consortium, please
* see <http://www.color.org/>.
*  
* 
*/

64#include "IccTagXml.h"
65#include "IccMpeXml.h"
66#include "IccUtil.h"
67#include "IccUtilXml.h"
68#include "IccIoXml.h"
69#include "IccSparseMatrix.h"
70#include "IccProfileXml.h"
71#include "IccStructFactory.h"
72#include "IccArrayFactory.h"
73#include <cstring> /* C strings strcpy, memcpy ... */
74#include <set>
75#include <map>
76#include <sstream>  // Make sure to include this header
77#include <iomanip>  // Include this header for setw and setfill

79typedef  std::map<icUInt32Number, icTagSignature> IccOffsetTagSigMap;

81#ifdef USEREFICCMAXNAMESPACE
82namespace refIccMAX {
83#endif


86bool CIccTagXmlUnknown::ToXml(std::string &xml, std::string blanks/* = ""*/) 
87{
xml += blanks + "<UnknownData>\n";
icXmlDumpHexData(xml, blanks+" ", m_pData, m_nSize);
xml += blanks + "</UnknownData>\n";

return true;
93}


96bool CIccTagXmlUnknown::ParseXml(xmlNode *pNode, std::string &parseStr)
97{
const char *tagType = icXmlAttrValue(pNode->parent, "type");
if (tagType) {
  m_nType = (icTagTypeSignature)icGetSigVal(tagType);
}

pNode = icXmlFindNode(pNode, "UnknownData");

if (pNode && pNode->children && pNode->children->content) {
  m_nSize = icXmlGetHexDataSize((const icChar*)pNode->children->content);

  if (m_pData) {
    delete [] m_pData;
    m_pData = NULL__null;
  }
  if (m_nSize) {
    m_pData = new icUInt8Number[m_nSize];

    if (icXmlGetHexData(m_pData, (const icChar*)pNode->children->content, m_nSize)!=m_nSize)
      return false;
  }
  return true;
}
return false;
121}


124static bool icXmlDumpTextData(std::string &xml, std::string blanks, const char *szText, bool bConvert=true)
125{
if (strstr(szText, "]]>")) {
  xml += blanks + "<HexTextData>";
  icXmlDumpHexData(xml, blanks+" ", (void*)szText, (icUInt32Number)strlen(szText));
  xml += blanks + "</HexTextData>\n";
}
else {
  std::string buf;

  xml += blanks + "<TextData>";
  xml += "<![CDATA[";
  if (bConvert)
    xml += icAnsiToUtf8(buf, szText);
  else
    xml += szText;
  xml += "]]></TextData>\n"; 
}

return true;
144}

146bool CIccTagXmlText::ToXml(std::string &xml, std::string blanks/* = ""*/)
147{
return icXmlDumpTextData(xml, blanks, m_szText);
149}

151bool CIccTagXmlUtf8Text::ToXml(std::string &xml, std::string blanks/* = ""*/)
152{
return icXmlDumpTextData(xml, blanks, (icChar*)m_szText, false);
154}

156bool CIccTagXmlZipUtf8Text::ToXml(std::string &xml, std::string blanks/* = ""*/)
157{
xml += blanks + "<HexCompressedData>\n";
icXmlDumpHexData(xml, blanks+" ", m_pZipBuf, m_nBufSize);
xml += blanks + "</HexCompressedData>\n";

return true;
163}

165bool CIccTagXmlZipXml::ToXml(std::string &xml, std::string blanks/* = ""*/)
166{
xml += blanks + "<HexCompressedData>\n";
icXmlDumpHexData(xml, blanks+" ", m_pZipBuf, m_nBufSize);
xml += blanks + "</HexCompressedData>\n";

return true;
172}

174bool CIccTagXmlUtf16Text::ToXml(std::string &xml, std::string blanks/* = ""*/)
175{
std::string buf;
return icXmlDumpTextData(xml, blanks, GetText(buf), false);
178}

180static std::string icXmlParseTextString(xmlNode *pNode, std::string &parseStr, bool bConvert = true)
181{
std::string str;

while (pNode) {
  if (pNode->type==XML_ELEMENT_NODE) {
    if (!icXmlStrCmp(pNode->name, "HexTextData")strcmp((const char *)(pNode->name), (const char*)("HexTextData"
)) && pNode->children && pNode->children->content) {
      CIccUInt8Array buf;
      if (!buf.SetSize(icXmlGetHexDataSize((const icChar*)pNode->children->content) ||
        icXmlGetHexData(buf.GetBuf(), (const icChar*)pNode->children->content, buf.GetSize())!=buf.GetSize()))
        return str;

      str += (char*)buf.GetBuf();
    }      
    else if (!icXmlStrCmp(pNode->name, "TextData")strcmp((const char *)(pNode->name), (const char*)("TextData"
)) ) {
      std::string buf;
      const icChar *filename = icXmlAttrValue(pNode, "File");

      // file exists
      if (filename[0]) {        
        CIccIO *file = IccOpenFileIO(filename, "rb");        
        if (!file){          
          parseStr += "Error! - File '";
          parseStr += filename;
          parseStr +="' not found.\n";
          delete file;
          return str;
        }

        icUInt32Number fileLength = file->GetLength();  
        char *ansiStr = (char *)malloc(fileLength+1);

        if (!ansiStr) {
          perror("Memory Error");
          parseStr += "'";
          parseStr += filename;
          parseStr += "' may not be a valid text file.\n";
          delete file;
          return str;
        }
        // read the contents of the file
        if (file->ReadLine(ansiStr, fileLength)!=fileLength) {
          parseStr += "Error while reading file '";
          parseStr += filename;
          parseStr += "'. Size read is not equal to file length. File may not be a valid text file.\n";
          free(ansiStr);
          delete file;             
          return str;
        }   
        // convert utf8 (xml format) to ansi (icc format)
        if (bConvert)
          icUtf8ToAnsi(buf, ansiStr);
        else
          buf = ansiStr;
        free(ansiStr);
        delete file;
      }
      // file does not exist
      else if (pNode->children && pNode->children->content){
        if (bConvert)
          icUtf8ToAnsi(buf, (const icChar*)pNode->children->content);      
        else
          buf = (const icChar*)pNode->children->content;
      }      
      str += buf;      
    } 
  }
  pNode = pNode->next; 
}

return str;
251}

253bool CIccTagXmlText::ParseXml(xmlNode *pNode, std::string &parseStr)
254{
std::string str = icXmlParseTextString(pNode, parseStr);

if (!str.empty()){    
  SetText(str.c_str());
  return true;
}
return false;
262}

264bool CIccTagXmlUtf8Text::ParseXml(xmlNode *pNode, std::string &parseStr)
265{
std::string str = icXmlParseTextString(pNode, parseStr, false);

if (!str.empty()){    
  SetText(str.c_str());
  return true;
}
return false;
273}

275bool CIccTagXmlZipUtf8Text::ParseXml(xmlNode *pNode, std::string &parseStr)
276{
while (pNode) {
  if (pNode->type==XML_ELEMENT_NODE) {
    if (!icXmlStrCmp(pNode->name, "HexCompressedData")strcmp((const char *)(pNode->name), (const char*)("HexCompressedData"
)) && pNode->children && pNode->children->content) {
      CIccUInt8Array buf;
      if (!buf.SetSize(icXmlGetHexDataSize((const icChar*)pNode->children->content) ||
          icXmlGetHexData(buf.GetBuf(), (const icChar*)pNode->children->content, buf.GetSize())!=buf.GetSize()))
        return false;

      AllocBuffer(buf.GetSize());
      if (m_nBufSize && m_pZipBuf) {
        memcpy(m_pZipBuf, buf.GetBuf(), m_nBufSize);
      }
      return true;
    }      
  }
  pNode = pNode->next; 
}

std::string str = icXmlParseTextString(pNode, parseStr, false);

return SetText(str.c_str());
298}

300bool CIccTagXmlZipXml::ParseXml(xmlNode *pNode, std::string &parseStr)
301{
while (pNode) {
  if (pNode->type==XML_ELEMENT_NODE) {
    if (!icXmlStrCmp(pNode->name, "HexCompressedData")strcmp((const char *)(pNode->name), (const char*)("HexCompressedData"
)) && pNode->children && pNode->children->content) {
      CIccUInt8Array buf;
      if (!buf.SetSize(icXmlGetHexDataSize((const icChar*)pNode->children->content) ||
        icXmlGetHexData(buf.GetBuf(), (const icChar*)pNode->children->content, buf.GetSize())!=buf.GetSize()))
        return false;

      AllocBuffer(buf.GetSize());
      if (m_nBufSize && m_pZipBuf) {
        memcpy(m_pZipBuf, buf.GetBuf(), m_nBufSize);
      }
      return true;
    }      
  }
  pNode = pNode->next; 
}

std::string str = icXmlParseTextString(pNode, parseStr, false);

return SetText(str.c_str());
323}

325bool CIccTagXmlUtf16Text::ParseXml(xmlNode *pNode, std::string &parseStr)
326{
std::string str = icXmlParseTextString(pNode, parseStr, false);

if (!str.empty()){    
  SetText(str.c_str());
  return true;
}
return false;
334}

336bool CIccTagXmlTextDescription::ToXml(std::string &xml, std::string blanks/* = ""*/)
337{
  std::string fix;
  std::string buf;
  char data[256];  // Adjust the size as needed
  std::string datastr;

  icXmlDumpTextData(xml, blanks, m_szText);

  // Added support for <![CData[Insert Text here]]> for Unicode
  if (m_uzUnicodeText[0]) {
      if (m_nUnicodeLanguageCode == 0)
          buf = "<Unicode>";
      else {
          icGetSigStr(data, m_nUnicodeLanguageCode);
          icFixXml(fix, data);
          buf = "<Unicode LanguageCode=\"" + fix + "\">";
      }
      xml += blanks + buf;

      icUtf16ToUtf8(datastr, m_uzUnicodeText);
      icFixXml(fix, datastr.c_str());
      buf = "<![CDATA[" + fix + "]]></Unicode>\n";
      xml += buf;
  }

  if (m_nScriptSize) {
      buf = "<MacScript ScriptCode=\"" + std::to_string(m_nScriptCode) + "\">";
      xml += blanks + buf;

      std::stringstream ss;
      for (int i = 0; i < m_nScriptSize; i++) {
          ss << std::hex << std::uppercase << std::setw(2) << std::setfill('0')
             << static_cast<int>(static_cast<unsigned char>(m_szScriptText[i]));
      }
      buf = ss.str();

      xml += buf;
      xml += "</MacScript>\n";
  }

  return true;
378}


381bool CIccTagXmlTextDescription::ParseXml(xmlNode *pNode, std::string &parseStr)
382{
pNode = icXmlFindNode(pNode, "TextData");

// support for reading desc, dmmd, and dmnd tags from file.
// if (!pNode || !pNode->children)
if (!pNode)
  return false;

// search for "file" attribute in <TextDescription/> tag
const icChar *filename = icXmlAttrValue(pNode, "File");

// file exists
if (filename[0]) {
  CIccIO *file = IccOpenFileIO(filename, "rb");

  if (!file){
    parseStr += "Error! - File '";
    parseStr += filename;
    parseStr +="' not found.\n";
    delete file;
    return false;
  }

  icUInt32Number fileLength = file->GetLength();  
  char *buf = (char *)malloc(fileLength);

  if (!buf) {
    perror("Memory Error");
    parseStr += "'";
    parseStr += filename;
    parseStr += "' may not be a valid text file.\n";
    delete file;
    return false;
  }

  if (file->ReadLine(buf, fileLength)!=fileLength) {
    parseStr += "Error while reading file '";
    parseStr += filename;
    parseStr += "'. Size read is not equal to file length. File may not be a valid text file.\n";
    free(buf);
    delete file;             
    return false;
  }   

  // set ANSII string
  std::string ansiStr;    
  icUtf8ToAnsi(ansiStr, buf);

  icUInt32Number nStrSize = (icUInt32Number)ansiStr.size();
  GetBuffer(nStrSize);
  if (nStrSize) {
    memcpy(m_szText, ansiStr.c_str(), nStrSize);  
    m_nASCIISize = nStrSize + 1;
  }
  else 
    m_szText[0] = '\0';

  // set Unicode String
  CIccUTF16String wstr(buf);

  nStrSize = (icUInt32Number)wstr.Size();
  m_uzUnicodeText = GetUnicodeBuffer(nStrSize);

  if (nStrSize) {
    // assign each entry in wstr to m_uzUnicodeText
    for (int i=0; i < (int) nStrSize; i++) {
      m_uzUnicodeText[i] = wstr[i];
    }  

    // include the null termintor in the string size.
    m_nUnicodeSize = nStrSize + 1;
  }
  else
    m_uzUnicodeText[0] = 0;

  // Set ScriptCode
  m_nScriptCode=0;
  m_nScriptSize = (icUInt8Number) fileLength + 1;  
  memcpy(m_szScriptText, buf, 67);

  delete file;
}

// file does not exist
else {
  std::string str = icXmlParseTextString(pNode, parseStr);
  icUInt32Number nSize = (icUInt32Number)str.size();
  icChar *pBuf = GetBuffer(nSize);

  if (nSize) {
    memcpy(m_szText, str.c_str(), nSize);

    // include the null termintor in the string size.
    m_nASCIISize = nSize + 1;
  }
  else 
    m_szText[0] = '\0';

  Release();

  // support for automatically generating unicode and scriptcode tags if these do not 
  // exist in the XML file.
  bool unicodeExists = false;
  bool scriptcodeExists = false;
  for (;pNode; pNode = pNode->next) {
    if (pNode->type==XML_ELEMENT_NODE) {
      if (!icXmlStrCmp(pNode->name, "Unicode")strcmp((const char *)(pNode->name), (const char*)("Unicode"
))) {
        const icChar *pRegion = icXmlAttrValue(pNode, "LanguageCode");

        // *pRegion may not have value.
        if (pRegion && /* *pRegion && */pNode->children && pNode->children->content) {
          CIccUTF16String wstr((const char*)pNode->children->content);

          nSize = (icUInt32Number)wstr.Size();

          // set size of m_uzUnicodeText
          m_uzUnicodeText = GetUnicodeBuffer(nSize);
          if (nSize) {

            // assign each entry in wstr to m_uzUnicodeText
            for (int i=0; i < (int) nSize; i++) {
              m_uzUnicodeText[i] = wstr[i];
            }  

            // include the null termintor in the string size.
            m_nUnicodeSize = nSize + 1;

            unicodeExists = true;
          }
          else
            m_uzUnicodeText[0] = 0;
        }
      }
      else if (!icXmlStrCmp(pNode->name, "MacScript")strcmp((const char *)(pNode->name), (const char*)("MacScript"
))) {
        const icChar *pScript = icXmlAttrValue(pNode, "ScriptCode");

        if (pScript && *pScript) {
          icUInt32Number nCode=0;

          sscanf(pScript, "%x", &nCode);
          m_nScriptCode = (icUInt16Number)nCode;
          if (pNode->children && pNode->children->content) {
            // set m_nScriptSize as receiver the return value of icXmlGetHexData
            // no need to add 1 since the return value is already exact.
            m_nScriptSize = (icUInt8Number) icXmlGetHexData(m_szScriptText, (const char*)pNode->children->content, sizeof(m_szScriptText));
            scriptcodeExists = true;
          }
          else
            m_szScriptText[0] = 0;
        }
      }
    }
  }
535#if 0
  // automatically generate unicode tag in the profile if it does not exist
  if (!unicodeExists){    

    m_uzUnicodeText = GetUnicodeBuffer(nSize);

    if (nSize) {
      // assign each entry in wstr to m_uzUnicodeText
      for (int i=0; i < (int) nSize; i++) {
        m_uzUnicodeText[i] = str[i];
      }  

      // include the null termintor in the string size.
      m_nUnicodeSize = nSize + 1;
    }
    else
      m_uzUnicodeText[0] = 0;
  }

  // automatically generate scriptcode tag in the profile if it does not exist
  if (!scriptcodeExists){
    m_nScriptCode=0;
    m_nScriptSize = (icUInt8Number)m_nASCIISize;
    memcpy(m_szScriptText, m_szText, 67);

  }
561#endif
}

return true;
565}


568bool CIccTagXmlSignature::ToXml(std::string &xml, std::string blanks/* = ""*/)
569{
char fix[40];
char line[256];
char buf[40];

sprintf(line, "<Signature>%s</Signature>\n", icFixXml(fix, icGetSigStr(buf, m_nSig)));

xml += blanks + line;
return true;
578}


581bool CIccTagXmlSignature::ParseXml(xmlNode *pNode, std::string &parseStr)
582{
if ((pNode = icXmlFindNode(pNode, "Signature"))) {
  this->SetValue(icGetSigVal(pNode->children ? (const icChar*)pNode->children->content : ""));

  return true;
}
return false;
589}


592bool CIccTagXmlSpectralDataInfo::ToXml(std::string &xml, std::string blanks/* = ""*/)
593{
char fix[40];
char line[256];
char buf[40];

sprintf(line, "<SpectralSpace>%s</SpectralSpace>\n", icFixXml(fix, icGetColorSigStr(buf, m_nSig)));
xml += blanks + line;

xml += blanks + "<SpectralRange>\n";
sprintf(line, "  <Wavelengths start=\"%f\" end=\"%f\" steps=\"%d\"/>\n", icF16toF(m_spectralRange.start), icF16toF(m_spectralRange.end), m_spectralRange.steps);
xml += blanks + line;
xml += blanks + "</SpectralRange>\n";

if (m_biSpectralRange.steps) {
  xml +=blanks +  "<BiSpectralRange>\n";
  sprintf(line, "  <Wavelengths start=\"%f\" end=\"%f\" steps=\"%d\"/>\n", icF16toF(m_biSpectralRange.start), icF16toF(m_biSpectralRange.end), m_biSpectralRange.steps);
  xml += blanks + line;
  xml += blanks + "</BiSpectralRange>\n";
}

return true;
614}


617bool CIccTagXmlSpectralDataInfo::ParseXml(xmlNode *pNode, std::string &parseStr)
618{
xmlNode *pChild;

if (!(pChild = icXmlFindNode(pNode, "SpectralSpace"))) {
  parseStr += "No SpectralSpace section found\n";
  return false;
}
m_nSig = icGetSigVal(pChild->children ? (const icChar*)pChild->children->content : "");

if (!(pChild = icXmlFindNode(pNode, "SpectralRange"))) {
  parseStr += "No SpectralRange section found\n";
  return false;
}

if (!(pChild = icXmlFindNode(pChild->children, "Wavelengths"))) {
  parseStr += "SpectralRange missing Wavelengths\n";
  return false;
}

m_spectralRange.start = icFtoF16((icUInt16Number)atof(icXmlAttrValue(pChild, "start")));
m_spectralRange.end = icFtoF16((icUInt16Number)atof(icXmlAttrValue(pChild, "end")));
m_spectralRange.steps = (icUInt16Number)atoi(icXmlAttrValue(pChild, "steps"));

pChild = icXmlFindNode(pNode, "BiSpectralRange");

if (pChild) {
  if ((pChild = icXmlFindNode(pChild->children, "Wavelengths"))) {
    m_biSpectralRange.start = icFtoF16((icUInt16Number)atof(icXmlAttrValue(pChild, "start")));
    m_biSpectralRange.end = icFtoF16((icUInt16Number)atof(icXmlAttrValue(pChild, "end")));
    m_biSpectralRange.steps = (icUInt16Number)atoi(icXmlAttrValue(pChild, "steps"));
  }
}

return true;
652}


655bool CIccTagXmlNamedColor2::ToXml(std::string &xml, std::string blanks/* = ""*/)
656{
char fix[256];
char line[256];
char buf[256];
int i, j;
std::string str;

sprintf(line, "<NamedColors VendorFlag=\"%08x\" CountOfDeviceCoords=\"%d\" DeviceEncoding=\"int16\"", m_nVendorFlags, m_nDeviceCoords);
xml += blanks + line;

sprintf(line, " Prefix=\"%s\"", icFixXml(fix, icAnsiToUtf8(str, m_szPrefix)));
xml += line;

sprintf(line, " Suffix=\"%s\">\n", icFixXml(fix, icAnsiToUtf8(str, m_szSufix)));
xml += line;

for (i=0; i<(int)m_nSize; i++) {
  SIccNamedColorEntry *pEntry= GetEntry(i);

  const char *szNodeName = "";

  if (pEntry) {
    if (m_csPCS==icSigLabData) {
      icFloatNumber lab[3];

      Lab2ToLab4(lab, pEntry->pcsCoords);
      icLabFromPcs(lab);
      szNodeName = "LabNamedColor";
      sprintf(line, "  <%s Name=\"%s\" L=\"%.8f\" a=\"%.8f\" b=\"%.8f\"", szNodeName,
        icFixXml(fix, icAnsiToUtf8(str, pEntry->rootName)), lab[0], lab[1], lab[2]);
      xml += blanks + line;
    }
    else {
      icFloatNumber xyz[3];

      memcpy(xyz, pEntry->pcsCoords, 3*sizeof(icFloatNumber));
      icXyzFromPcs(xyz);
      szNodeName = "XYZNamedColor";
      sprintf(line, "  <%s Name=\"%s\" X=\"%.8f\" Y=\"%.8f\" Z=\"%.8f\"", szNodeName,
        icFixXml(fix, icAnsiToUtf8(str, pEntry->rootName)), xyz[0], xyz[1], xyz[2]);
      xml += blanks + line;
    }

    if (!m_nDeviceCoords) {
      xml += "/>\n";
    }
    else {
      xml += ">";
      for (j=0; j<(int)m_nDeviceCoords; j++) {
        if (j)
          xml+=" ";
        sprintf(buf, "%d", (int)(pEntry->deviceCoords[j] * 65535.0 + 0.5));
        xml += buf;
      }
      xml += "\n";

      xml += blanks + " </" + szNodeName + ">\n";
    }
  }
}
xml += blanks + " </NamedColors>\n";
return true;
718}


721bool CIccTagXmlNamedColor2::ParseXml(xmlNode *pNode, std::string &parseStr)
722{
pNode = icXmlFindNode(pNode, "NamedColors");

if (pNode) {
  const icChar *szVendorFlags = icXmlAttrValue(pNode, "VendorFlag");
  const icChar *szDeviceCoords = icXmlAttrValue(pNode, "CountOfDeviceCoords");
  const icChar *szDeviceEncoding = icXmlAttrValue(pNode, "DeviceEncoding");
  const icChar *szPrefix = icXmlAttrValue(pNode, "Prefix");
  const icChar *szSufix = icXmlAttrValue(pNode, "Suffix");

  if (szVendorFlags && *szVendorFlags &&
    szDeviceCoords && *szDeviceCoords &&
    szDeviceEncoding && *szDeviceEncoding &&
    szPrefix && szSufix) {
      std::string str;

      sscanf(szVendorFlags, "%x", &m_nVendorFlags);

      strncpy(m_szPrefix, icUtf8ToAnsi(str, szPrefix), sizeof(m_szPrefix));
      m_szPrefix[sizeof(m_szPrefix)-1] = '\0';

      strncpy(m_szSufix, icUtf8ToAnsi(str, szSufix), sizeof(m_szSufix));
      m_szSufix[sizeof(m_szSufix)-1] = '\0';

      m_nDeviceCoords = atoi(szDeviceCoords);
      icUInt32Number n = icXmlNodeCount3(pNode->children, "NamedColor", "LabNamedColor", "XYZNamedColor");
      SetSize(n, m_nDeviceCoords);

      icUInt32Number i;

      SIccNamedColorEntry *pNamedColor = m_NamedColor;

      for (i=0, pNode=pNode->children; pNode; pNode=pNode->next) {
        const icChar *szName = NULL__null;
        if (pNode->type == XML_ELEMENT_NODE &&
          !icXmlStrCmp(pNode->name, "NamedColor")strcmp((const char *)(pNode->name), (const char*)("NamedColor"
)) &&
          i<n) {
            szName = icXmlAttrValue(pNode, "Name");
            xmlAttr *L = icXmlFindAttr(pNode, "L");
            xmlAttr *a = icXmlFindAttr(pNode, "a");
            xmlAttr *b = icXmlFindAttr(pNode, "b");

            if (L && a && b) {
              pNamedColor->pcsCoords[0] = (icFloatNumber)atof(icXmlAttrValue(L));
              pNamedColor->pcsCoords[1] = (icFloatNumber)atof(icXmlAttrValue(a));
              pNamedColor->pcsCoords[2] = (icFloatNumber)atof(icXmlAttrValue(b));

              icLabToPcs(pNamedColor->pcsCoords);
              Lab4ToLab2(pNamedColor->pcsCoords, pNamedColor->pcsCoords);
            }
            else {
              xmlAttr *x = icXmlFindAttr(pNode, "X");
              xmlAttr *y = icXmlFindAttr(pNode, "Y");
              xmlAttr *z = icXmlFindAttr(pNode, "Z");

              if (x && y && z) {
                pNamedColor->pcsCoords[0] = (icFloatNumber)atof(icXmlAttrValue(x));
                pNamedColor->pcsCoords[1] = (icFloatNumber)atof(icXmlAttrValue(y));
                pNamedColor->pcsCoords[2] = (icFloatNumber)atof(icXmlAttrValue(z));

                icXyzToPcs(pNamedColor->pcsCoords);
              }
              else
                return false;
            }
        }
        else if (pNode->type == XML_ELEMENT_NODE &&
          !icXmlStrCmp(pNode->name, "LabNamedColor")strcmp((const char *)(pNode->name), (const char*)("LabNamedColor"
)) &&
          i < n) {
          szName = icXmlAttrValue(pNode, "Name");
          xmlAttr *L = icXmlFindAttr(pNode, "L");
          xmlAttr *a = icXmlFindAttr(pNode, "a");
          xmlAttr *b = icXmlFindAttr(pNode, "b");

          if (L && a && b) {
            pNamedColor->pcsCoords[0] = (icFloatNumber)atof(icXmlAttrValue(L));
            pNamedColor->pcsCoords[1] = (icFloatNumber)atof(icXmlAttrValue(a));
            pNamedColor->pcsCoords[2] = (icFloatNumber)atof(icXmlAttrValue(b));

            icLabToPcs(pNamedColor->pcsCoords);
            Lab4ToLab2(pNamedColor->pcsCoords, pNamedColor->pcsCoords);
          }
          else {
            return false;
          }
        }
        else if (pNode->type == XML_ELEMENT_NODE &&
          !icXmlStrCmp(pNode->name, "XYZNamedColor")strcmp((const char *)(pNode->name), (const char*)("XYZNamedColor"
)) &&
          i < n) {
          szName = icXmlAttrValue(pNode, "Name");
          xmlAttr *x = icXmlFindAttr(pNode, "X");
          xmlAttr *y = icXmlFindAttr(pNode, "Y");
          xmlAttr *z = icXmlFindAttr(pNode, "Z");

          if (x && y && z) {
            pNamedColor->pcsCoords[0] = (icFloatNumber)atof(icXmlAttrValue(x));
            pNamedColor->pcsCoords[1] = (icFloatNumber)atof(icXmlAttrValue(y));
            pNamedColor->pcsCoords[2] = (icFloatNumber)atof(icXmlAttrValue(z));

            icXyzToPcs(pNamedColor->pcsCoords);
          }
          else
            return false;
        }

        if (szName) {
          strncpy(pNamedColor->rootName, icUtf8ToAnsi(str, szName), sizeof(pNamedColor->rootName));
          pNamedColor->rootName[sizeof(pNamedColor->rootName) - 1] = 0;

          if (m_nDeviceCoords && pNode->children) {
            if (!strcmp(szDeviceEncoding, "int8")) {
              CIccUInt8Array coords;

              coords.ParseArray(pNode->children);
              icUInt8Number *pBuf = coords.GetBuf();

              icUInt32Number j;
              for (j = 0; j < m_nDeviceCoords && j < coords.GetSize(); j++) {
                pNamedColor->deviceCoords[j] = (icFloatNumber)pBuf[i] / 255.0f;
              }
            }
            else if (!strcmp(szDeviceEncoding, "int16")) {
              CIccUInt16Array coords;

              coords.ParseArray(pNode->children);
              icUInt16Number *pBuf = coords.GetBuf();

              icUInt32Number j;
              for (j = 0; j < m_nDeviceCoords && j < coords.GetSize(); j++) {
                pNamedColor->deviceCoords[j] = (icFloatNumber)pBuf[i] / 65535.0f;
              }
            }
            else if (!strcmp(szDeviceEncoding, "float")) {
              CIccFloatArray coords;

              coords.ParseArray(pNode->children);
              icFloatNumber *pBuf = coords.GetBuf();

              icUInt32Number j;
              for (j = 0; j < m_nDeviceCoords && j < coords.GetSize(); j++) {
                pNamedColor->deviceCoords[j] = (icFloatNumber)pBuf[i];
              }
            }
            else
              return false;
          }

          i++;
          pNamedColor = (SIccNamedColorEntry*)((icChar*)pNamedColor + m_nColorEntrySize);
        }
      }
      return i==n;
  }
}
return false;
877}


880bool CIccTagXmlXYZ::ToXml(std::string &xml, std::string blanks/* = ""*/)
881{
char buf[256];
int i;

for (i=0; i<(int)m_nSize; i++) {
  sprintf(buf, "<XYZNumber X=\"%.8f\" Y=\"%.8f\" Z=\"%.8f\"/>\n", (float)icFtoD(m_XYZ[i].X),
    (float)icFtoD(m_XYZ[i].Y),
    (float)icFtoD(m_XYZ[i].Z));
  xml += blanks + buf;
}
return true;
892}


895bool CIccTagXmlXYZ::ParseXml(xmlNode *pNode, std::string &parseStr)
896{
icUInt32Number n = icXmlNodeCount(pNode, "XYZNumber");

if (n) {
  icUInt32Number i;
  SetSize(n);

  for (i=0; pNode; pNode=pNode->next) {
    if (pNode->type == XML_ELEMENT_NODE &&
      !icXmlStrCmp(pNode->name, "XYZNumber")strcmp((const char *)(pNode->name), (const char*)("XYZNumber"
)) &&
      i<n) {
        xmlAttr *x = icXmlFindAttr(pNode, "X");
        xmlAttr *y = icXmlFindAttr(pNode, "Y");
        xmlAttr *z = icXmlFindAttr(pNode, "Z");

        if (x && y && z) {
          m_XYZ[i].X = icDtoF((icFloatNumber)atof(icXmlAttrValue(x)));
          m_XYZ[i].Y = icDtoF((icFloatNumber)atof(icXmlAttrValue(y)));
          m_XYZ[i].Z = icDtoF((icFloatNumber)atof(icXmlAttrValue(z)));
          i++;
        }
        else
          return false;
    }
  }
  return i==n;
}
return false;
924}


927bool CIccTagXmlChromaticity::ToXml(std::string &xml, std::string blanks/* = ""*/)
928{
char buf[256];
int i;

CIccInfo info;
sprintf(buf, "<Colorant>%s</Colorant>\n",info.GetColorantEncoding((icColorantEncoding)m_nColorantType));
xml += blanks + buf;    

for (i=0; i<(int)m_nChannels; i++) {
  sprintf(buf, "  <Channel x=\"%.8f\" y=\"%.8f\"/>\n", (float)icUFtoD(m_xy[i].x),
    (float)icUFtoD(m_xy[i].y));
  xml += blanks + buf;
}

return true;
943}


946bool CIccTagXmlChromaticity::ParseXml(xmlNode *pNode, std::string &parseStr)
947{

pNode = icXmlFindNode(pNode, "Colorant");

if (pNode)    
  m_nColorantType = icGetColorantValue(pNode->children ? (const icChar*)pNode->children->content : ""); 


icUInt16Number n = (icUInt16Number)icXmlNodeCount(pNode, "Channel");  

if (n) {
  icUInt32Number i;
  SetSize(n);

  for (i=0; pNode; pNode=pNode->next) {
    if (pNode->type == XML_ELEMENT_NODE &&
      !icXmlStrCmp(pNode->name, "Channel")strcmp((const char *)(pNode->name), (const char*)("Channel"
)) &&
      i<n) {
        xmlAttr *x = icXmlFindAttr(pNode, "x");
        xmlAttr *y = icXmlFindAttr(pNode, "y");

        if (x && y) {
          m_xy[i].x = icDtoUF((icFloatNumber)atof(icXmlAttrValue(x)));
          m_xy[i].y = icDtoUF((icFloatNumber)atof(icXmlAttrValue(y)));
          i++;
        }
        else
          return false;
    }
  }
  return i==n;
}
return false;
980}


983bool CIccTagXmlSparseMatrixArray::ToXml(std::string &xml, std::string blanks/* = ""*/)
984{
char buf[256];
int i, j, n;

sprintf(buf, "<SparseMatrixArray outputChannels=\"%d\" matrixType=\"%d\">\n", m_nChannelsPerMatrix, m_nMatrixType);
xml += blanks + buf;    

CIccSparseMatrix mtx;
icUInt32Number bytesPerMatrix = GetBytesPerMatrix();

for (i=0; i<(int)m_nSize; i++) {
  mtx.Reset(m_RawData+i*bytesPerMatrix, bytesPerMatrix, icSparseMatrixFloatNum((icSparseMatrixType)0x0000), true);
  sprintf(buf, " <SparseMatrix rows=\"%d\" cols=\"%d\">\n", mtx.Rows(), mtx.Cols());
  xml += blanks + buf;

  for (j=0; j<(int)mtx.Rows(); j++) {
    xml += blanks + "  <SparseRow>\n";
    
    n=mtx.GetNumRowColumns(j);

    xml += blanks + "   <ColIndices>\n";
    CIccUInt16Array::DumpArray(xml, blanks+"    ", mtx.GetColumnsForRow(j), n, icConvert16Bit, 8);
    xml += blanks + "   </ColIndices>\n";

    xml += blanks + "   <ColData>\n";
    CIccFloatArray::DumpArray(xml, blanks+"    ", (icFloatNumber*)(mtx.GetData()->getPtr(mtx.GetRowOffset(j))), n, icConvertFloat, 8);
    xml += blanks + "   </ColData>\n";

    xml += blanks + "  </SparseRow>\n";
  }
  xml += blanks + " </SparseMatrix>\n";
}

xml += blanks + "</SparseMatrixArray>\n";

return true;
1020}


1023bool CIccTagXmlSparseMatrixArray::ParseXml(xmlNode *pNode, std::string &parseStr)
1024{
pNode = icXmlFindNode(pNode, "SparseMatrixArray");

if (pNode) {
  xmlAttr *outputChan = icXmlFindAttr(pNode, "outputChannels");
  xmlAttr *matrixType = icXmlFindAttr(pNode, "matrixType");

  if (outputChan && matrixType) {
    icUInt32Number nChannelsPerMatrix = atoi(icXmlAttrValue(outputChan));
    icSparseMatrixType nMatrixType = (icSparseMatrixType)atoi(icXmlAttrValue(matrixType));

    xmlNode *pChild;

    int n=0;
    for (pChild = pNode->children; pChild; pChild=pChild->next) {
      if (pChild->type == XML_ELEMENT_NODE &&
          (!icXmlStrCmp(pChild->name, "SparseMatrix")strcmp((const char *)(pChild->name), (const char*)("SparseMatrix"
)) || !icXmlStrCmp(pChild->name, "FullMatrix")strcmp((const char *)(pChild->name), (const char*)("FullMatrix"
))))
        n++;

    }
    Reset(n, (icUInt16Number)nChannelsPerMatrix);
    m_nMatrixType = (icSparseMatrixType)nMatrixType;

    icUInt32Number bytesPerMatrix = GetBytesPerMatrix();
    CIccSparseMatrix mtx;
    int i=0;
    for (pChild = pNode->children; pChild; pChild=pChild->next) {
      if (pChild->type == XML_ELEMENT_NODE) {
        if (!icXmlStrCmp(pChild->name, "SparseMatrix")strcmp((const char *)(pChild->name), (const char*)("SparseMatrix"
))) {
          mtx.Reset(m_RawData + i*bytesPerMatrix, bytesPerMatrix, icSparseMatrixFloatNum((icSparseMatrixType)0x0000), false);

          xmlAttr *rows = icXmlFindAttr(pChild, "rows");
          xmlAttr *cols = icXmlFindAttr(pChild, "cols");

          if (rows && cols) {
            icUInt16Number nRows, nCols;

            nRows = atoi(icXmlAttrValue(rows));
            nCols = atoi(icXmlAttrValue(cols));

            mtx.Init(nRows, nCols, true);

            icUInt16Number *rowstart = mtx.GetRowStart();
            icUInt32Number nMaxEntries = mtx.GetMaxEntries();
            xmlNode *pRow;
            int iRow=0;
            icUInt32Number pos = 0;
            for (pRow=pChild->children; pRow; pRow=pRow->next) {
              if (pRow->type == XML_ELEMENT_NODE && !icXmlStrCmp(pRow->name, "SparseRow")strcmp((const char *)(pRow->name), (const char*)("SparseRow"
))) {
                xmlNode *pIdx = icXmlFindNode(pRow->children, "ColIndices");
                xmlNode *pData = icXmlFindNode(pRow->children, "ColData");

                if (pIdx && pData) {
                  CIccUInt16Array idx;
                  CIccFloatArray data;

                  if (!idx.ParseTextArray(pIdx) || !data.ParseTextArray(pData)) {
                    parseStr += "Unable to parse SparseRow index or data values\n";
                    return false;
                  }
                  if (idx.GetSize() != data.GetSize()) {
                    parseStr += "Mismatch between SparseRow index and data lengths\n";
                    return false;
                  }
                  if (pos+idx.GetSize() > nMaxEntries) {
                    parseStr += "Exceeded maximum number of sparse matrix entries\n";
                    return false;
                  }
                  rowstart[iRow] = (icUInt16Number)pos;
                  memcpy(mtx.GetColumnsForRow(iRow), idx.GetBuf(), idx.GetSize()*sizeof(icUInt16Number));
                  memcpy(mtx.GetData()->getPtr(pos), data.GetBuf(), data.GetSize()*sizeof(icFloatNumber));
                  pos += idx.GetSize();
                }
                iRow++;
              }
            }
            while(iRow<nRows) {
              rowstart[iRow] = (icUInt16Number)pos;
              iRow++;
            }
            rowstart[iRow] = (icUInt16Number)pos;
          }
          else {
            parseStr += "Cannot find SparseMatrix rows and cols\n";
            return false;
          }

          i++;
        }
        else if (!icXmlStrCmp(pChild->name, "FullMatrix")strcmp((const char *)(pChild->name), (const char*)("FullMatrix"
))) {
          mtx.Reset(m_RawData + i*bytesPerMatrix, bytesPerMatrix, icSparseMatrixFloatNum((icSparseMatrixType)0x0000), false);

          xmlAttr *rows = icXmlFindAttr(pChild, "rows");
          xmlAttr *cols = icXmlFindAttr(pChild, "cols");

          if (rows && cols) {
            icUInt16Number nRows, nCols;

            nRows = atoi(icXmlAttrValue(rows));
            nCols = atoi(icXmlAttrValue(cols));

            mtx.Init(nRows, nCols, true);

            CIccFloatArray data;
            data.ParseTextArray(pChild);
            if (data.GetSize()==nRows*nCols) {
              if (!mtx.FillFromFullMatrix(data.GetBuf()))
                parseStr += "Exceeded maximum number of sparse matrix entries\n";
            }
            else {
              parseStr += "Invalid FullMatrix data dimensions\n";
              return false;
            }
          }
          else {
            parseStr += "Cannot find FullMatrix rows and cols\n";
            return false;
          }
          i++;
        }
      }
    }
    return true;
  }
  else {
    parseStr += "Cannot find outputChannels and matrixType members\n";
  }
}
else {
  parseStr += "Cannot find SparseMatrixArray node\n";
}

return false;
1157}


1160template <class T, icTagTypeSignature Tsig>
1161const icChar* CIccTagXmlFixedNum<T, Tsig>::GetClassName() const
1162{
if (Tsig==icSigS15Fixed16ArrayType)
  return "CIccTagXmlS15Fixed16";
else 
  return "CIccTagXmlU16Fixed16";
1167}

1169// for multi-platform support
1170// added "this->" modifier to data members.
1171template <class T, icTagTypeSignature Tsig>
1172bool CIccTagXmlFixedNum<T, Tsig>::ToXml(std::string &xml, std::string blanks/* = ""*/)
1173{
char buf[256];
int i;

if (Tsig==icSigS15Fixed16ArrayType) {
  int n = 8;
  xml += blanks + "<Array>\n";
  for (i=0; i<(int)this->m_nSize; i++) {
    if (!(i%n)) {
      if (i)
        xml += "\n";
      xml += blanks + blanks;
    }
    else {
      xml += " ";
    }
    sprintf(buf, "%.8f", (float)icFtoD(this->m_Num[i]));
    xml += buf;
  }

  if ((i%n)!=1) {
    xml += "\n";
  }
}
else {
  for (i=0; i<(int)this->m_nSize; i++) {

    if (!(i%8)) {
      if (i)
        xml += "\n";
      xml += blanks + blanks;
    }
    else {
      xml += " ";
    }
    sprintf(buf, "%.8f", (float)icUFtoD(this->m_Num[i]));
    xml += buf;
  }

  if ((i%8)!=1) {
    xml += "\n";
  }
}
xml += blanks + "</Array>\n";
return true;
1218}

1220// for multi-platform support
1221// added "this->" modifier to data members.
1222template <class T, icTagTypeSignature Tsig>
1223bool CIccTagXmlFixedNum<T, Tsig>::ParseXml(xmlNode *pNode, std::string &parseStr)
1224{
pNode = icXmlFindNode(pNode, "Array");
pNode = pNode->children;  

CIccFloatArray a;

if (!a.ParseArray(pNode) || !a.GetSize()) {   
  return false;
}

icUInt32Number i, n = a.GetSize();
icFloatNumber *buf = a.GetBuf();

this->SetSize(n);

for (i=0; i<n; i++) {
  if (Tsig==icSigS15Fixed16ArrayType) {
    this->m_Num[i] = icDtoF(buf[i]);
  }
  else {
    this->m_Num[i] = icDtoUF(buf[i]);
  }
}
return true;
1248}


1251//Make sure typedef classes get built
1252template class CIccTagXmlFixedNum<icS15Fixed16Number, icSigS15Fixed16ArrayType>;
1253template class CIccTagXmlFixedNum<icU16Fixed16Number, icSigU16Fixed16ArrayType>;


1256template <class T, class A, icTagTypeSignature Tsig>
1257const icChar *CIccTagXmlNum<T, A, Tsig>::GetClassName() const
1258{
if (sizeof(T)==sizeof(icUInt8Number))
  return "CIccTagXmlUInt8";
else if (sizeof(T)==sizeof(icUInt16Number))
  return "CIccTagXmlUInt16";
else if (sizeof(T)==sizeof(icUInt32Number))
  return "CIccTagXmlUInt32";
else if (sizeof(T)==sizeof(icUInt64Number))
  return "CIccTagXmlUInt64";
else
  return "CIccTagXmlNum<>";
1269}

1271// for multi-platform support
1272// added "this->" modifier to data members.  
1273template <class T, class A, icTagTypeSignature Tsig>
1274bool CIccTagXmlNum<T, A, Tsig>::ToXml(std::string &xml, std::string blanks/* = ""*/)
1275{
char buf[512];
int i;

xml += blanks + "<Array>\n";
for (i=0; i<(int)this->m_nSize; i++) {
  if (!(i%16)) {
    if (i)
      xml += "\n";
    xml += blanks + blanks;
  }
  else {
    xml += " ";
  }
  if (sizeof(T)==16)
    sprintf(buf, "%llu", (icUInt64Number)this->m_Num[i]);
  else
    sprintf(buf, "%u", (icUInt32Number)this->m_Num[i]);
  xml += buf;
}

if ((i%16)!=1) {
  xml += "\n";
}

xml += blanks + "</Array>\n";
return true;
return true;
1303}

1305// for multi-platform support
1306// added "this->" modifier to data members.
1307template <class T, class A, icTagTypeSignature Tsig>
1308bool CIccTagXmlNum<T, A, Tsig>::ParseXml(xmlNode *pNode, std::string &parseStr)
1309{
xmlNode *pDataNode = icXmlFindNode(pNode, "Data");
if (!pDataNode) {
  pDataNode = icXmlFindNode(pNode, "Array");
}
if (!pDataNode) {
  return false;
}

pNode = pDataNode->children;  

A a;

if (!a.ParseArray(pNode) || !a.GetSize()) {   
  return false;
}

icUInt32Number i, n = a.GetSize();
T *buf = a.GetBuf();

this->SetSize(n);

for (i=0; i<n; i++) {
  this->m_Num[i] = buf[i];
}

return true;
1336}

1338//Make sure typedef classes get built
1339template class CIccTagXmlNum<icUInt8Number, CIccUInt8Array, icSigUInt8ArrayType>;
1340template class CIccTagXmlNum<icUInt16Number, CIccUInt16Array, icSigUInt16ArrayType>;
1341template class CIccTagXmlNum<icUInt32Number, CIccUInt32Array, icSigUInt32ArrayType>;
1342template class CIccTagXmlNum<icUInt64Number, CIccUInt64Array, icSigUInt64ArrayType>;


1345template <class T, class A, icTagTypeSignature Tsig>
1346const icChar *CIccTagXmlFloatNum<T, A, Tsig>::GetClassName() const
1347{
if (Tsig==icSigFloat16ArrayType)
  return "CIccTagXmlFloat32";
else if (Tsig==icSigFloat32ArrayType)
  return "CIccTagXmlFloat32";
else if (Tsig==icSigFloat64ArrayType)
  return "CIccTagXmlFloat64";
else
  return "CIccTagXmlFloatNum<>";
1356}

1358// for multi-platform support
1359// added "this->" modifier to data members.  
1360template <class T, class A, icTagTypeSignature Tsig>
1361bool CIccTagXmlFloatNum<T, A, Tsig>::ToXml(std::string &xml, std::string blanks/* = ""*/)
1362{
char buf[512];

if (this->m_nSize==1) {
1366#ifdef _WIN32
  if (sizeof(T)==sizeof(icFloat32Number))
    sprintf(buf, "<Data>%.8f</Data>\n", this->m_Num[0]);
  else if (sizeof(T)==sizeof(icFloat64Number))
    sprintf(buf, "<Data>%.16lf</Data>\n", this->m_Num[0]);
  else
1372#endif
    sprintf(buf, "<Data>%.8f</Data>", this->m_Num[0]);
  xml += blanks;
  xml += buf;
}
else {
  int i;
  int n = 8;
  xml += blanks + "<Data>\n";
  for (i=0; i<(int)this->m_nSize; i++) {
    if (!(i%n)) {
      if (i)
        xml += "\n";
      xml += blanks + blanks;
    }
    else {
      xml += " ";
    }
1390#ifdef _WIN32
    if (sizeof(T)==sizeof(icFloat32Number))
      sprintf(buf, "%.8f", this->m_Num[i]);

    else if (sizeof(T)==sizeof(icFloat32Number))
      sprintf(buf, "%.16lf", this->m_Num[i]);
    else
1397#endif
      sprintf(buf, "%.8f", this->m_Num[i]);
    xml += buf;
  }

  if ((i%n)!=1) {
    xml += "\n";
    xml += blanks + "</Data>\n";
  }
  else {
    xml += " </Data>\n";
  }
}
return true;
1411}

1413// for multi-platform support
1414// added "this->" modifier to data members.
1415template <class T, class A, icTagTypeSignature Tsig>
1416bool CIccTagXmlFloatNum<T, A, Tsig>::ParseXml(xmlNode *pNode, std::string &parseStr)
1417{
pNode = icXmlFindNode(pNode, "Data");

const char *filename = icXmlAttrValue(pNode, "Filename", "");
if (!filename[0]) {
  filename = icXmlAttrValue(pNode, "File", "");
}

A a;

if (filename[0]) {
  CIccIO *file = IccOpenFileIO(filename, "rb");
  if (!file){
    parseStr += "Error! - File '";
    parseStr += filename;
    parseStr +="' not found.\n";
    delete file;
    return false;
  }

  icUInt32Number len = file->GetLength();

  if (!stricmpstrcasecmp(icXmlAttrValue(pNode, "Format", "text"), "text")) {
    char *fbuf = (char*)malloc(len+1);
    fbuf[len]=0;
    if (!fbuf) {
      parseStr += "Memory error!\n";
      delete file;
      return false;
    }

    if (file->Read8(fbuf, len)!=len) {
      parseStr += "Read error of (";
      parseStr += filename;
      parseStr += ")!\n";
      free(fbuf);
      delete file;
      return false;
    }
    delete file;

    if (!a.ParseTextArray(fbuf) || !a.GetSize()) {
      parseStr += "Parse error of (";
      parseStr += filename;
      parseStr += ")!\n";
      free(fbuf);
      return false;
    }
    free(fbuf);
  }
  else if (Tsig==icSigFloat16ArrayType && sizeof(T)==sizeof(icFloat16Number)) {
    icUInt32Number n = len/sizeof(icFloat16Number);
    this->SetSize(n);
    if (file->Read16(&this->m_Num[0], n)!=n) {
      delete file;
      return false;
    }
    delete file;
    return true;
  }
  else if (Tsig==icSigFloat16ArrayType && sizeof(T)==sizeof(icFloat32Number)) {
    icUInt32Number n = len/sizeof(icFloat32Number);
    this->SetSize(n);
    if (file->ReadFloat16Float(&this->m_Num[0], n)!=n) {
      delete file;
      return false;
    }
    delete file;
    return true;
  }
  else if (Tsig==icSigFloat32ArrayType && sizeof(T)==sizeof(icFloat32Number)) {
    icUInt32Number n = len/sizeof(icFloat32Number);
    this->SetSize(n);
    if (file->ReadFloat32Float(&this->m_Num[0], n)!=n) {
      delete file;
      return false;
    }
    delete file;
    return true;
  }
  else if (Tsig==icSigFloat64ArrayType && sizeof(T)==sizeof(icFloat64Number)) {
    icUInt32Number n = len/sizeof(icFloat64Number);
    this->SetSize(n);
    if (file->Read64(&this->m_Num[0], n)!=n) {
      delete file;
      return false;
    }
    delete file;
    return true;

  }
  else {
    delete file;
    parseStr += "Unsupported file parsing type!\n";
    return false;
  }
}
else {
  pNode = pNode->children;  

  if (!a.ParseArray(pNode) || !a.GetSize()) {   
    return false;
  }
}

icUInt32Number i, n = a.GetSize();
T *buf = a.GetBuf();

this->SetSize(n);

for (i=0; i<n; i++) {
  this->m_Num[i] = buf[i];
}
return true;
1531}


1534//Make sure typedef classes get built
1535template class CIccTagXmlFloatNum<icFloat32Number, CIccFloat32Array, icSigFloat16ArrayType>;
1536template class CIccTagXmlFloatNum<icFloat32Number, CIccFloat32Array, icSigFloat32ArrayType>;
1537template class CIccTagXmlFloatNum<icFloat64Number, CIccFloat64Array, icSigFloat64ArrayType>;


1540bool CIccTagXmlMeasurement::ToXml(std::string &xml, std::string blanks/* = ""*/)
1541{
char buf[256];

CIccInfo info;  

sprintf(buf,"<StandardObserver>%s</StandardObserver>\n",icGetStandardObserverName(m_Data.stdObserver));
xml += blanks + buf;

sprintf(buf, "<MeasurementBacking X=\"%.8f\" Y=\"%.8f\" Z=\"%.8f\"/>\n", icFtoD(m_Data.backing.X), 
  icFtoD(m_Data.backing.Y), icFtoD(m_Data.backing.Z));
xml += blanks + buf;

sprintf(buf,"<Geometry>%s</Geometry>\n",info.GetMeasurementGeometryName(m_Data.geometry));
xml += blanks + buf;  

sprintf(buf,"<Flare>%s</Flare>\n",info.GetMeasurementFlareName(m_Data.flare));
xml += blanks + buf;

sprintf(buf,"<StandardIlluminant>%s</StandardIlluminant>\n",info.GetIlluminantName(m_Data.illuminant));
xml += blanks + buf;  
return true;
1562}


1565bool CIccTagXmlMeasurement::ParseXml(xmlNode *pNode, std::string &parseStr)
1566{
memset(&m_Data, 0, sizeof(m_Data));

pNode = icXmlFindNode(pNode, "StandardObserver");
if (pNode) {
  m_Data.stdObserver = icGetNamedStandardObserverValue(pNode->children ? (icChar*)pNode->children->content: "");   
}


pNode = icXmlFindNode(pNode, "MeasurementBacking");
if (pNode){
  xmlAttr *attr;

  attr = icXmlFindAttr(pNode, "X");
  if (attr) {
    m_Data.backing.X = icDtoF((icFloatNumber)atof(icXmlAttrValue(attr)));
  }

  attr = icXmlFindAttr(pNode, "Y");
  if (attr) {
    m_Data.backing.Y = icDtoF((icFloatNumber)atof(icXmlAttrValue(attr)));
  }

  attr = icXmlFindAttr(pNode, "Z");
  if (attr) {
    m_Data.backing.Z = icDtoF((icFloatNumber)atof(icXmlAttrValue(attr)));
  }
}

pNode = icXmlFindNode(pNode, "Geometry");
if (pNode){
  m_Data.geometry = icGeNamedtMeasurementGeometryValue(pNode->children ? (icChar*)pNode->children->content : "");     
}

pNode = icXmlFindNode(pNode, "Flare");
if (pNode){
  m_Data.flare = icGetNamedMeasurementFlareValue(pNode->children ? (icChar*)pNode->children->content : ""); 
}

pNode = icXmlFindNode(pNode, "StandardIlluminant");
if (pNode){
  m_Data.illuminant = icGetIlluminantValue(pNode->children ? (icChar*)pNode->children->content : "");
}

return true; 
1611}

1613bool CIccTagXmlMultiLocalizedUnicode::ToXml(std::string &xml, std::string blanks/* = ""*/)
1614{
std::string xmlbuf;
char data[256];
std::string bufstr;
CIccMultiLocalizedUnicode::iterator i;

if (!m_Strings)
  return false;

for (i=m_Strings->begin(); i!=m_Strings->end(); i++) {
  xml += blanks + "<LocalizedText LanguageCountry=\"";
  xml += icFixXml(xmlbuf, icGetSigStr(data, (i->m_nLanguageCode<<16) + i->m_nCountryCode));
  xml += "\"><![CDATA[";
  xml += icFixXml(xmlbuf, icUtf16ToUtf8(bufstr, i->GetBuf(), i->GetLength()));
  xml += "]]></LocalizedText>\n";
}
return true;
1631}


1634bool CIccTagXmlMultiLocalizedUnicode::ParseXml(xmlNode *pNode, std::string &parseStr)
1635{
xmlAttr *langCode;
int n = 0;

for (pNode = icXmlFindNode(pNode, "LocalizedText"); pNode; pNode = icXmlFindNode(pNode->next, "LocalizedText")) {    
  if ((langCode = icXmlFindAttr(pNode, "LanguageCountry"))) {
    xmlNode *pText;

    for (pText = pNode->children; pText; pText = pText->next) {
      if (pText->type == XML_TEXT_NODE || pText->type == XML_CDATA_SECTION_NODE)
        break;
    }

    if (pText) {
      icUInt32Number lc = icGetSigVal(icXmlAttrValue(langCode));
      CIccUTF16String str((const char*)pText->content);

      SetText(str.c_str(), (icLanguageCode)(lc>>16), (icCountryCode)(lc & 0xffff));
      n++;
    }
    else {
      SetText("");
      n++;
    }
  }
}  
return n>0;  //We succeed if we parsed at least one string
1662}


1665bool CIccTagXmlTagData::ToXml(std::string &xml, std::string blanks/* = ""*/)
1666{
icUInt8Number *ptr = m_pData;  
char buf[60];
std::string szFlag("ASCII");

if (m_nDataFlag == 1)
  szFlag = "binary";
sprintf (buf, "<Data Flag=\"%s\">\n", szFlag.c_str());
xml += blanks + buf;
icXmlDumpHexData(xml, blanks+" ", m_pData, m_nSize);
xml += blanks + "</Data>\n";

return true;
1679}


1682bool CIccTagXmlTagData::ParseXml(xmlNode *pNode, std::string &parseStr)
1683{
pNode = icXmlFindNode(pNode, "Data");
if (pNode && pNode->children && pNode->children->content) {
  const icChar *szFlag = icXmlAttrValue(pNode, "Flag");    
  m_nDataFlag = icAsciiData;
  if (!strcmp(szFlag,"binary"))
    m_nDataFlag = icBinaryData;

  icUInt32Number nSize = icXmlGetHexDataSize((const char *)pNode->children->content);
  SetSize(nSize, false);
  if (nSize) {
    icXmlGetHexData(m_pData, (const char*)pNode->children->content, nSize);
  }

  return true;
}
return false;
1700}


1703bool CIccTagXmlDateTime::ToXml(std::string &xml, std::string blanks/* = ""*/)
1704{
char buf[256];
sprintf(buf, "<DateTime>%d-%02d-%02dT%02d:%02d:%02d</DateTime>\n",
  m_DateTime.year, m_DateTime.month, m_DateTime.day, m_DateTime.hours, m_DateTime.minutes, m_DateTime.seconds);
xml += blanks + buf;
return true;
1710}


1713bool CIccTagXmlDateTime::ParseXml(xmlNode *pNode, std::string &parseStr)
1714{
memset(&m_DateTime, 0, sizeof(m_DateTime));

pNode = icXmlFindNode(pNode, "DateTime");
if (pNode) {      
  m_DateTime = icGetDateTimeValue(pNode->children ? (const char*)pNode->children->content : "");  
  return true;
}
return false;
1723}


1726bool CIccTagXmlColorantOrder::ToXml(std::string &xml, std::string blanks/* = ""*/)
1727{
char buf[40];
int i;

xml += blanks + "<ColorantOrder>\n"; //+ blanks + "  ";
for (i=0; i<(int)m_nCount; i++) {
  sprintf(buf, "  <n>%d</n>\n", m_pData[i]);
  xml += blanks + buf;
}

xml += blanks + "</ColorantOrder>\n";

return true;
1740}

1742bool CIccTagXmlColorantOrder::ParseXml(xmlNode *pNode, std::string &parseStr)
1743{  
pNode = icXmlFindNode(pNode, "ColorantOrder");

if (pNode) {
  int n = icXmlNodeCount(pNode->children, "n");

  if (n) {
    SetSize(n);

    if (m_pData) {
      if (CIccUInt8Array::ParseArray(m_pData, n, pNode->children))
        return true;
    }
  }
}  
return false;
1759}


1762bool CIccTagXmlColorantTable::ToXml(std::string &xml, std::string blanks/* = ""*/)
1763{
char buf[256];
char fix[256];
int i;
std::string str;

xml += blanks + "<ColorantTable>\n";
for (i=0; i<(int)m_nCount; i++) {
  icFloatNumber lab[3];
  lab[0] = icU16toF(m_pData[i].data[0]);
  lab[1] = icU16toF(m_pData[i].data[1]);
  lab[2] = icU16toF(m_pData[i].data[2]);
  icLabFromPcs(lab);
  sprintf(buf, "  <Colorant Name=\"%s\" Channel1=\"%.8f\" Channel2=\"%.8f\" Channel3=\"%f\"/>\n",
    icFixXml(fix, icAnsiToUtf8(str, m_pData[i].name)), lab[0], lab[1], lab[2]);
  xml += blanks + buf;
}
//xml += "\n";
xml += blanks + "</ColorantTable>\n";

return true;
1784}


1787bool CIccTagXmlColorantTable::ParseXml(xmlNode *pNode, std::string &parseStr)
1788{
pNode = icXmlFindNode(pNode, "ColorantTable");

if (pNode && pNode->children) {
  pNode = pNode->children;

  icUInt16Number n = (icUInt16Number)icXmlNodeCount(pNode, "Colorant");

  if (n) {
    icUInt32Number i;
    SetSize(n);

    for (i=0; pNode; pNode=pNode->next) {
      if (pNode->type == XML_ELEMENT_NODE &&
        !icXmlStrCmp(pNode->name, "Colorant")strcmp((const char *)(pNode->name), (const char*)("Colorant"
)) && 
        i<n) {
          std::string str;
          const icChar *name = icXmlAttrValue(pNode, "Name");
          xmlAttr *L = icXmlFindAttr(pNode, "Channel1");
          xmlAttr *a = icXmlFindAttr(pNode, "Channel2");
          xmlAttr *b = icXmlFindAttr(pNode, "Channel3");

          if (name && L && a && b) {
            strncpy(m_pData[i].name, icUtf8ToAnsi(str, name), sizeof(m_pData[i].name));
            m_pData[i].name[sizeof(m_pData[i].name)-1]=0;

            icFloatNumber lab[3];

            lab[0] = (icFloatNumber)atof(icXmlAttrValue(L));
            lab[1] = (icFloatNumber)atof(icXmlAttrValue(a));
            lab[2] = (icFloatNumber)atof(icXmlAttrValue(b));

            icLabToPcs(lab);
            m_pData[i].data[0] = icFtoU16(lab[0]);
            m_pData[i].data[1] = icFtoU16(lab[1]);
            m_pData[i].data[2] = icFtoU16(lab[2]);

            i++;
          }
          else
            return false;
      }
    }
    return i==n;
  }
  return false;
}
return false;
1836}


1839bool CIccTagXmlViewingConditions::ToXml(std::string &xml, std::string blanks/* = ""*/)
1840{
char buf[256];

sprintf(buf, "<IlluminantXYZ X=\"%.8f\" Y=\"%.8f\" Z=\"%.8f\"/>\n",
  icFtoD(m_XYZIllum.X), icFtoD(m_XYZIllum.Y), icFtoD(m_XYZIllum.Z));
xml += blanks + buf;

sprintf(buf, "<SurroundXYZ X=\"%.8f\" Y=\"%.8f\" Z=\"%.8f\"/>\n",
  icFtoD(m_XYZSurround.X), icFtoD(m_XYZSurround.Y), icFtoD(m_XYZSurround.Z));
xml += blanks + buf;

CIccInfo info;
sprintf(buf, "<IllumType>%s</IllumType>\n", info.GetIlluminantName(m_illumType));
xml += blanks + buf;

return true;
1856}

1858bool CIccTagXmlViewingConditions::ParseXml(xmlNode *pNode, std::string &parseStr)
1859{
xmlAttr *attr;
xmlNode *pChild;

memset(&m_XYZIllum, 0, sizeof(m_XYZIllum));
memset(&m_XYZSurround, 0, sizeof(m_XYZSurround));
m_illumType = (icIlluminant)0;

pChild = icXmlFindNode(pNode, "IlluminantXYZ");
if (pChild) {

  attr = icXmlFindAttr(pChild, "X");
  if (attr) {
    m_XYZIllum.X = icDtoF((icFloatNumber)atof(icXmlAttrValue(attr)));
  }

  attr = icXmlFindAttr(pChild, "Y");
  if (attr) {
    m_XYZIllum.Y = icDtoF((icFloatNumber)atof(icXmlAttrValue(attr)));
  }

  attr = icXmlFindAttr(pChild, "Z");
  if (attr) {
    m_XYZIllum.Z = icDtoF((icFloatNumber)atof(icXmlAttrValue(attr)));
  }
}

pChild = icXmlFindNode(pNode, "SurroundXYZ");
if (pChild) {
  attr = icXmlFindAttr(pChild, "X");
  if (attr) {
    m_XYZSurround.X = icDtoF((icFloatNumber)atof(icXmlAttrValue(attr)));
  }

  attr = icXmlFindAttr(pChild, "Y");
  if (attr) {
    m_XYZSurround.Y = icDtoF((icFloatNumber)atof(icXmlAttrValue(attr)));
  }

  attr = icXmlFindAttr(pChild, "Z");
  if (attr) {
    m_XYZSurround.Z = icDtoF((icFloatNumber)atof(icXmlAttrValue(attr)));
  }
}

pChild = icXmlFindNode(pNode, "IllumType");
if (pChild && pChild->children && pChild->children->content) {
  m_illumType = icGetIlluminantValue((icChar*)pChild->children->content);
}

return true;
1910}

1912bool CIccTagXmlSpectralViewingConditions::ToXml(std::string &xml, std::string blanks/* = ""*/)
1913{
char buf[256];
int i, j;
icFloatNumber *ptr;
CIccInfo info;

sprintf(buf, "<StdObserver>%s</StdObserver>\n", info.GetStandardObserverName(m_stdObserver));
xml += blanks + buf;

sprintf(buf, "<IlluminantXYZ X=\"%.8f\" Y=\"%.8f\" Z=\"%.8f\"/>\n",
  m_illuminantXYZ.X, m_illuminantXYZ.Y, m_illuminantXYZ.Z);
xml += blanks + buf;

if (m_observer) {
  sprintf(buf, "<ObserverFuncs start=\"%.8f\" end=\"%.8f\" steps=\"%d\"",
          icF16toF(m_observerRange.start), icF16toF(m_observerRange.end), m_observerRange.steps);
  xml += blanks + buf;

  if (m_reserved2) {
    sprintf(buf, " Reserved=\"%d\"", m_reserved2);
    xml += buf;
  }
  xml += ">\n";
  
  ptr = &m_observer[0];

  for (j=0; j<3; j++) {
    xml += blanks;
    for (i=0; i<m_observerRange.steps; i++) {
      if (i && !(i%8)) {
        xml += "\n";
        xml += blanks;
      }
      sprintf(buf, " %.8f", *ptr);
      ptr++;
      xml += buf;
    }
    xml += "\n";
  }
  xml += blanks + "</ObserverFuncs>\n";
}

sprintf(buf, "<StdIlluminant>%s</StdIlluminant>\n", info.GetIlluminantName(m_stdIlluminant));
xml += blanks + buf;

sprintf(buf, "<ColorTemperature>%.8f</ColorTemperature>\n", m_colorTemperature);
xml += blanks + buf;

if (m_illuminant) {
  sprintf(buf, "<IlluminantSPD start=\"%.8f.\" end=\"%.8f\" steps=\"%d\"", 
          icF16toF(m_illuminantRange.start), icF16toF(m_illuminantRange.end), m_illuminantRange.steps);
  xml += blanks + buf;

  if (m_reserved3) {
    sprintf(buf, " Reserved=\"%d\"", m_reserved3);
    xml += buf;
  }
  xml += ">\n";

  ptr = &m_illuminant[0];

  xml += blanks;
  for (i=0; i<m_illuminantRange.steps; i++) {
    if (i && !(i%8)) {
      xml += "\n";
      xml += blanks;
    }
    sprintf(buf, " %.8f", *ptr);
    ptr++;
    xml += buf;
  }
  xml += "\n";

  xml += blanks + "</IlluminantSPD>\n";
}

sprintf(buf, "<SurroundXYZ X=\"%.8f\" Y=\"%.8f\" Z=\"%.8f\"/>\n",
  m_surroundXYZ.X, m_surroundXYZ.Y, m_surroundXYZ.Z);
xml += blanks + buf;


return true;
1995}

1997bool CIccTagXmlSpectralViewingConditions::ParseXml(xmlNode *pNode, std::string &parseStr)
1998{
xmlNode *pChild;
xmlAttr *attr;

memset(&m_illuminantXYZ, 0, sizeof(m_illuminantXYZ));
memset(&m_surroundXYZ, 0, sizeof(m_surroundXYZ));
m_stdIlluminant = icIlluminantUnknown;
m_stdObserver = icStdObsUnknown;
m_colorTemperature = 0;
m_reserved2 = 0;
m_reserved3 = 0;

pChild = icXmlFindNode(pNode, "StdObserver");
if (pChild && pChild->children && pChild->children->content) {
  m_stdObserver = icGetNamedStandardObserverValue((icChar*)pChild->children->content);
}

pChild = icXmlFindNode(pNode, "IlluminantXYZ");
if (pChild) {

  attr = icXmlFindAttr(pChild, "X");
  if (attr) {
    m_illuminantXYZ.X = (icFloatNumber)atof(icXmlAttrValue(attr));
  }

  attr = icXmlFindAttr(pChild, "Y");
  if (attr) {
    m_illuminantXYZ.Y = (icFloatNumber)atof(icXmlAttrValue(attr));
  }

  attr = icXmlFindAttr(pChild, "Z");
  if (attr) {
    m_illuminantXYZ.Z = (icFloatNumber)atof(icXmlAttrValue(attr));
  }
}

pChild = icXmlFindNode(pNode, "ObserverFuncs");
if (pChild) {
  attr = icXmlFindAttr(pChild, "start");
  if (attr) {
    m_observerRange.start =icFtoF16((icFloatNumber)atof(icXmlAttrValue(attr)));
  }
  attr = icXmlFindAttr(pChild, "end");
  if (attr) {
    m_observerRange.end = icFtoF16((icFloatNumber)atoi(icXmlAttrValue(attr)));
  }
  attr = icXmlFindAttr(pChild, "steps");
  if (attr) {
    m_observerRange.steps = (icUInt16Number)atoi(icXmlAttrValue(attr));
  }
  attr = icXmlFindAttr(pChild, "reserved");
  if (attr) {
    m_reserved2 = (icUInt16Number)atoi(icXmlAttrValue(attr));
  }

  if (pChild->children && pChild->children->content) {
    CIccFloatArray vals;
    vals.ParseTextArray((icChar*)pChild->children->content);
    if (vals.GetSize()!=m_observerRange.steps*3)
      return false;
    m_observer = (icFloatNumber*)malloc(m_observerRange.steps*3*sizeof(icFloatNumber));
    if (!m_observer)
      return false;
    icFloatNumber *pBuf = vals.GetBuf();
    memcpy(m_observer, pBuf, m_observerRange.steps*3*sizeof(icFloatNumber));
  }
}

pChild = icXmlFindNode(pNode, "StdIlluminant");
if (pChild && pChild->children && pChild->children->content) {
  m_stdIlluminant = icGetIlluminantValue((icChar*)pChild->children->content);
}

pChild = icXmlFindNode(pNode, "ColorTemperature");
if (pChild && pChild->children && pChild->children->content) {
  m_colorTemperature = (icFloatNumber)atof((icChar*)pChild->children->content);
}

pChild = icXmlFindNode(pNode, "IlluminantSPD");
if (pChild) {
  attr = icXmlFindAttr(pChild, "start");
  if (attr) {
    m_illuminantRange.start = icFtoF16((icFloatNumber)atof(icXmlAttrValue(attr)));
  }
  attr = icXmlFindAttr(pChild, "end");
  if (attr) {
    m_illuminantRange.end = icFtoF16((icFloatNumber)atof(icXmlAttrValue(attr)));
  }
  attr = icXmlFindAttr(pChild, "steps");
  if (attr) {
    m_illuminantRange.steps = (icUInt16Number)atoi(icXmlAttrValue(attr));
  }
  attr = icXmlFindAttr(pChild, "reserved");
  if (attr) {
    m_reserved3 = (icUInt16Number)atoi(icXmlAttrValue(attr));
  }

  if (pChild->children && pChild->children->content && m_illuminantRange.steps) {
    CIccFloatArray vals;
    vals.ParseTextArray((icChar*)pChild->children->content);
    if (vals.GetSize()!=m_illuminantRange.steps)
      return false;
    m_illuminant = (icFloatNumber*)malloc(m_illuminantRange.steps * sizeof(icFloatNumber));
    if (!m_illuminant)
      return false;
    icFloatNumber *pBuf = vals.GetBuf();
    memcpy(m_illuminant, pBuf, m_illuminantRange.steps * sizeof(icFloatNumber));
  }
  else {
    setIlluminant(m_stdIlluminant, m_illuminantRange, NULL__null, m_colorTemperature);
  }
}

pChild = icXmlFindNode(pChild, "SurroundXYZ");
if (pChild) {
  attr = icXmlFindAttr(pChild, "X");
  if (attr) {
    m_surroundXYZ.X = (icFloatNumber)atof(icXmlAttrValue(attr));
  }

  attr = icXmlFindAttr(pChild, "Y");
  if (attr) {
    m_surroundXYZ.Y = (icFloatNumber)atof(icXmlAttrValue(attr));
  }

  attr = icXmlFindAttr(pChild, "Z");
  if (attr) {
    m_surroundXYZ.Z = (icFloatNumber)atof(icXmlAttrValue(attr));
  }
}

return true;
2130}



2134bool icProfDescToXml(std::string &xml, CIccProfileDescStruct &p, std::string blanks = "")
2135{
char fix[256];
char buf[256];
char data[256];

sprintf(buf, "<ProfileDesc>\n");
xml += blanks + buf;

sprintf(buf,   "<DeviceManufacturerSignature>%s</DeviceManufacturerSignature>\n", icFixXml(fix, icGetSigStr(data, p.m_deviceMfg)));
xml += blanks + blanks + buf;

sprintf(buf,  "<DeviceModelSignature>%s</DeviceModelSignature>\n", icFixXml(fix, icGetSigStr(data, p.m_deviceModel)));
xml += blanks + blanks + buf;

std::string szAttributes = icGetDeviceAttrName(p.m_attributes);
//sprintf(buf, "<DeviceAttributes>\"%016lX\" technology=\"%s\">\n", p.m_attributes, icFixXml(fix, icGetSigStr(data, p.m_technology)));
//xml += buf;
xml += blanks + blanks + icGetDeviceAttrName(p.m_attributes);

sprintf(buf, "<Technology>%s</Technology>\n", icFixXml(fix, icGetSigStr(data, p.m_technology)));
xml += blanks + blanks + buf;

CIccTag *pTag = p.m_deviceMfgDesc.GetTag();
CIccTagXml *pExt;

if (pTag) {

  pExt = (CIccTagXml*)(pTag->GetExtension());

  if (!pExt || !pExt->GetExtClassName() || strcmp(pExt->GetExtClassName(), "CIccTagXml"))
    return false;

  xml += blanks + blanks + "<DeviceManufacturer>\n";

  const icChar* tagSig = icGetTagSigTypeName(pTag->GetType());
  sprintf(buf, "<%s>\n", tagSig);
  xml += blanks + blanks + blanks + buf;

  if (!pExt->ToXml(xml, blanks + "        "))
    return false;

  sprintf(buf, "</%s>\n", tagSig);
  xml += blanks + blanks + blanks + buf;

  xml += blanks + blanks +"</DeviceManufacturer>\n";
}

pTag = p.m_deviceModelDesc.GetTag();

if (pTag) {
  pExt = (CIccTagXml*)(pTag->GetExtension());

  if (!pExt || !pExt->GetExtClassName() || strcmp(pExt->GetExtClassName(), "CIccTagXml"))
    return false;

  xml += blanks + blanks + "<DeviceModel>\n";

  const icChar* tagSig = icGetTagSigTypeName(pTag->GetType());
  sprintf(buf, "<%s>\n", tagSig);
  xml += blanks + blanks + blanks + buf;

  if (!pExt->ToXml(xml, blanks + "        "))
    return false;

  sprintf(buf, "</%s>\n", tagSig);
  xml += blanks + blanks + blanks + buf;

  xml += blanks + "  </DeviceModel>\n";
}

xml += blanks + "</ProfileDesc>\n";

return true;
2208}

2210bool icXmlParseProfDesc(xmlNode *pNode, CIccProfileDescStruct &p, std::string &parseStr)
2211{
if (pNode->type==XML_ELEMENT_NODE && !icXmlStrCmp(pNode->name, "ProfileDesc")strcmp((const char *)(pNode->name), (const char*)("ProfileDesc"
))) {
  xmlNode *pDescNode;  

  for (pDescNode = pNode->children; pDescNode; pDescNode=pDescNode->next) {
    if (pDescNode->type == XML_ELEMENT_NODE) {
      if (!icXmlStrCmp(pDescNode->name, "DeviceManufacturerSignature")strcmp((const char *)(pDescNode->name), (const char*)("DeviceManufacturerSignature"
))){
        p.m_deviceMfg = icXmlStrToSig(pDescNode->children ? (const icChar*)pDescNode->children->content: "");
      }
      else if (!icXmlStrCmp(pDescNode->name, "DeviceModelSignature")strcmp((const char *)(pDescNode->name), (const char*)("DeviceModelSignature"
))){
        p.m_deviceModel = icXmlStrToSig(pDescNode->children ? (const icChar*)pDescNode->children->content : "");
      }
      else if (!icXmlStrCmp(pDescNode->name, "DeviceAttributes")strcmp((const char *)(pDescNode->name), (const char*)("DeviceAttributes"
))){
        p.m_attributes = icGetDeviceAttrValue(pDescNode);      
      }
      else if (!icXmlStrCmp(pDescNode->name, "Technology")strcmp((const char *)(pDescNode->name), (const char*)("Technology"
))){
        p.m_technology = (icTechnologySignature)icXmlStrToSig(pDescNode->children ? (const icChar*)pDescNode->children->content : "");
      }
      else if (!icXmlStrCmp(pDescNode->name, "DeviceManufacturer")strcmp((const char *)(pDescNode->name), (const char*)("DeviceManufacturer"
))) {  
        xmlNode *pDevManNode = icXmlFindNode(pDescNode->children, "multiLocalizedUnicodeType");

        if (!pDevManNode){
          pDevManNode = icXmlFindNode(pDescNode->children, "textDescriptionType");
        }      

        if (pDevManNode){
          icTagTypeSignature tagSig = icGetTypeNameTagSig ((icChar*) pDevManNode->name);

          if (!p.m_deviceMfgDesc.SetType(tagSig)){
            return false;         
          }        
          CIccTag *pTag = p.m_deviceMfgDesc.GetTag();

          if (!pTag)
            return false;

          CIccTagXml *pExt = (CIccTagXml*)(pTag->GetExtension());

          if (!pExt || !pExt->GetExtClassName() || strcmp(pExt->GetExtClassName(), "CIccTagXml"))
            return false;

          pExt->ParseXml(pDevManNode->children, parseStr);
        }            
      }
      else if (!icXmlStrCmp(pDescNode->name, "DeviceModel")strcmp((const char *)(pDescNode->name), (const char*)("DeviceModel"
))) {
        xmlNode *pDevModNode = icXmlFindNode(pDescNode->children, "multiLocalizedUnicodeType");

        if (!pDevModNode){
          pDevModNode = icXmlFindNode(pDescNode->children, "textDescriptionType");
        }

        if (pDevModNode){
          icTagTypeSignature tagSig = icGetTypeNameTagSig ((icChar*) pDevModNode->name);

          if (!p.m_deviceModelDesc.SetType(tagSig)) {
            return false;
          }
          CIccTag *pTag = p.m_deviceModelDesc.GetTag();

          if (!pTag)
            return false;

          CIccTagXml *pExt = (CIccTagXml*)(pTag->GetExtension());

          if (!pExt || !pExt->GetExtClassName() || strcmp(pExt->GetExtClassName(), "CIccTagXml"))
            return false;

          pExt->ParseXml(pDevModNode->children, parseStr);
        }
      }
    }
  }
}
else
  return false;

if (!p.m_deviceMfgDesc.GetTag() || !p.m_deviceModelDesc.GetTag())
  return false;

return true;
2291}


2294bool CIccTagXmlProfileSeqDesc::ToXml(std::string &xml, std::string blanks/* = ""*/)
2295{
CIccProfileSeqDesc::iterator i;
if (!m_Descriptions) 
  return false;

xml += blanks + "<ProfileSequence>\n";
for (i=m_Descriptions->begin(); i!=m_Descriptions->end(); i++) {
  if (!icProfDescToXml(xml, *i, blanks + "  "))
    return false;
}
xml += blanks + "</ProfileSequence>\n";
return true;
2307}


2310bool CIccTagXmlProfileSeqDesc::ParseXml(xmlNode *pNode, std::string &parseStr)
2311{
pNode = icXmlFindNode(pNode, "ProfileSequence");

if (!m_Descriptions)
  return false;

m_Descriptions->clear();

if (pNode) {
  for (pNode = pNode->children; pNode; pNode=pNode->next) {
    if (pNode->type==XML_ELEMENT_NODE && !icXmlStrCmp(pNode->name, "ProfileDesc")strcmp((const char *)(pNode->name), (const char*)("ProfileDesc"
))) {
      CIccProfileDescStruct ProfileDescStruct;

      if (!icXmlParseProfDesc(pNode, ProfileDescStruct, parseStr))
        return false;

      m_Descriptions->push_back(ProfileDescStruct);
    }
  }
}
return true;
2332}


2335bool CIccTagXmlResponseCurveSet16::ToXml(std::string &xml, std::string blanks/* = ""*/)
2336{
char line[80]; 
int i;

CIccInfo info;

sprintf(line, "<CountOfChannels>%d</CountOfChannels>\n", m_nChannels);
xml += blanks + line;

CIccResponseCurveStruct *pCurves=GetFirstCurves();
while (pCurves) {
  sprintf(line, "<ResponseCurve MeasUnitSignature=\"%s\">\n", info.GetMeasurementUnit(pCurves->GetMeasurementType()));
  xml += blanks + line;
  for (i=0; i<pCurves->GetNumChannels(); i++) {
    CIccResponse16List *pResponseList = pCurves->GetResponseList(i);
    icXYZNumber *pXYZ = pCurves->GetXYZ(i);
    sprintf(line, "    <ChannelResponses X=\"%.8f\" Y=\"%.8f\" Z=\"%.8f\" >\n", icFtoD(pXYZ->X), icFtoD(pXYZ->Y), icFtoD(pXYZ->Z));
    xml += blanks + line;

    CIccResponse16List::iterator j;    
    for (j=pResponseList->begin(); j!=pResponseList->end(); j++) {
      sprintf(line, "      <Measurement DeviceCode=\"%d\" MeasValue=\"%.8f\"", j->deviceCode, icFtoD(j->measurementValue));
      xml += blanks + line;

      if (j->reserved) {
        sprintf(line, " Reserved=\"%d\"", j->reserved);
        xml += line;
      }
      xml += "/>\n";
    }

    xml += blanks + "    </ChannelResponses>\n";
  }
  xml += blanks + "  </ResponseCurve>\n";
  pCurves = GetNextCurves();
}

return true;
2374}


2377bool CIccTagXmlResponseCurveSet16::ParseXml(xmlNode *pNode, std::string &parseStr)
2378{
pNode = icXmlFindNode(pNode, "CountOfChannels"); 

if(!pNode)
  return false;

int nChannels = atoi((const char*)pNode->children->content);
SetNumChannels(nChannels);

if (!m_ResponseCurves)
  return false;

if (!m_ResponseCurves->empty())
  m_ResponseCurves->clear();

for (pNode = pNode->next; pNode; pNode = pNode->next) {
  if (pNode->type==XML_ELEMENT_NODE && !icXmlStrCmp(pNode->name, "ResponseCurve")strcmp((const char *)(pNode->name), (const char*)("ResponseCurve"
))) {
    const icChar *szMeasurmentType = icXmlAttrValue(pNode, "MeasUnitSignature");

    if (nChannels != icXmlNodeCount(pNode->children, "ChannelResponses"))
      return false;

    CIccResponseCurveStruct curves(icGetMeasurementValue(szMeasurmentType), nChannels);
    xmlNode *pChild, *pMeasurement;
    int i;

    for (i=0, pChild = pNode->children; pChild; pChild = pChild->next) {
      if (pChild->type == XML_ELEMENT_NODE && !icXmlStrCmp(pChild->name, "ChannelResponses")strcmp((const char *)(pChild->name), (const char*)("ChannelResponses"
))) {
        CIccResponse16List *pResponseList = curves.GetResponseList(i);
        icXYZNumber *pXYZ = curves.GetXYZ(i);
        icResponse16Number response;

        const icChar *szX = icXmlAttrValue(pChild, "X");
        const icChar *szY = icXmlAttrValue(pChild, "Y");
        const icChar *szZ = icXmlAttrValue(pChild, "Z");

        if (!szX || !szY || !szZ || !*szX || !*szY || !*szZ)
          return false;

        pXYZ->X = icDtoF((icFloatNumber)atof(szX));
        pXYZ->Y = icDtoF((icFloatNumber)atof(szY));
        pXYZ->Z = icDtoF((icFloatNumber)atof(szZ));

        for (pMeasurement = pChild->children; pMeasurement; pMeasurement = pMeasurement->next) {
          if (pMeasurement->type == XML_ELEMENT_NODE && !icXmlStrCmp(pMeasurement->name, "Measurement")strcmp((const char *)(pMeasurement->name), (const char*)("Measurement"
))) {
            const icChar *szDeviceCode = icXmlAttrValue(pMeasurement, "DeviceCode");
            const icChar *szValue = icXmlAttrValue(pMeasurement, "MeasValue");
            const icChar *szReserved = icXmlAttrValue(pMeasurement, "Reserved");

            if (!szDeviceCode || !szValue || !*szDeviceCode || !*szValue)
              return false;

            response.deviceCode = (icUInt16Number)atoi(szDeviceCode);
            response.measurementValue = icDtoF((icFloatNumber)atof(szValue));

            if (szReserved && *szReserved)
              response.reserved = atoi(szReserved);

            pResponseList->push_back(response);
          }
        }
        i++;
      }
    }
    m_ResponseCurves->push_back(curves);
  }
}

return true;
2447}


2450bool CIccTagXmlCurve::ToXml(std::string &xml, std::string blanks/* = ""*/)
2451{
return ToXml(xml, icConvert16Bit, blanks);
2453}


2456bool CIccTagXmlCurve::ToXml(std::string &xml, icConvertType nType, std::string blanks/*= ""*/)
2457{
char buf[40];
int i;

if (!m_nSize) {
  xml += blanks + "<Curve/>\n";
}
else if (IsIdentity()) {
  xml += blanks + "<Curve IdentitySize=\"";
  sprintf(buf, "%d", m_nSize);
  xml += buf;
  xml += "\"/>\n";
}
else if (nType==icConvert8Bit) {
  xml += blanks + "<Curve>\n" + blanks;  
  for (i=0; i<(int)m_nSize; i++) {  
    if ( i && !(i%16)) {
      xml += "\n";
      xml += blanks;  
    }
    sprintf(buf, " %3u", (int)(m_Curve[i] * 255.0 + 0.5));    
    xml += buf;
  }
  xml += "\n";
  xml += blanks + "</Curve>\n";
}
else if (nType==icConvert16Bit || nType==icConvertVariable) {
  xml += blanks + "<Curve>\n" + blanks;
  for (i=0; i<(int)m_nSize; i++) {
    if (i && !(i%16)) {
      xml += "\n";
      xml += blanks + " ";
    }
    sprintf(buf, " %5u", (int)(m_Curve[i] * 65535.0 + 0.5));
    xml += buf;
  }
  xml += "\n";
  xml += blanks + "</Curve>\n";
}
else if (nType==icConvertFloat) {
  xml += blanks + "<Curve>\n" + blanks + "  ";
  for (i=0; i<(int)m_nSize; i++) {
    if (i && !(i%16)) {
      xml += "\n";
      xml += blanks + " ";
    }
    sprintf(buf, " %13.8f", m_Curve[i]);
    xml += buf;
  }
  xml += "\n";
  xml += blanks + "</Curve>\n";
}
else
  return false;

return true;
2513}


2516bool CIccTagXmlCurve::ParseXml(xmlNode *pNode, std::string &parseStr )
2517{
return ParseXml(pNode, icConvert16Bit, parseStr);
2519}



2523bool CIccTagXmlCurve::ParseXml(xmlNode *pNode, icConvertType nType, std::string &parseStr)
2524{
xmlNode *pCurveNode;
pCurveNode = icXmlFindNode(pNode, "Curve");  

if(pCurveNode){
  const char *filename = icXmlAttrValue(pCurveNode, "File");

  // file exists
  if (filename[0]) {
    CIccIO *file = IccOpenFileIO(filename, "rb");
    if (!file){
      parseStr += "Error! - File '";
      parseStr += filename;
      parseStr +="' not found.\n";
      delete file;
      return false;
    }

    const char *format = icXmlAttrValue(pCurveNode, "Format");

    // format is text
    if (!strcmp(format, "text")) {
      icUInt32Number num = file->GetLength();
      char *buf = (char *) new char[num];

      if (!buf) {          
        perror("Memory Error");
        parseStr += "'";
        parseStr += filename;
        parseStr += "' may not be a valid text file.\n";
        free(buf);
        delete file;
        return false;
      }

      if (file->Read8(buf, num) !=num) {
        perror("Read-File Error");
        parseStr += "'";
        parseStr += filename;
        parseStr += "' may not be a valid text file.\n";
        free(buf);
        delete file;             
        return false;
      }         

      // lut8type
      if (nType == icConvert8Bit) {
        CIccUInt8Array data;

        //if (!data.ParseTextArray(buf)) {
        if (!data.ParseTextArrayNum(buf, num, parseStr)){
          parseStr += "File '";
          parseStr += filename;
          parseStr += "' is not a valid text file.\n";
          SetSize(0);
          free(buf);
          delete file;
          return false;
        }

        else {
          SetSize(data.GetSize());
          icUInt8Number *src = data.GetBuf();
          icFloatNumber *dst = GetData(0);

          icUInt32Number i;
          for (i=0; i<data.GetSize(); i++) {  
            *dst = (icFloatNumber)(*src) / 255.0f;              
            dst++;
            src++;
          }

          //if (i!=256) {
          //printf("Error! - Input/Output table does not have 256 entries.\n");                            
          //SetSize(0);
          //return false;
          //}
          delete file;
          return true;
        }
      } 

      //lut16type
      else if (nType == icConvert16Bit || nType == icConvertVariable) {
        CIccUInt16Array data;

        //if (!data.ParseTextArray(buf)) {
        if (!data.ParseTextArrayNum(buf, num, parseStr)){
          parseStr += "File '";
          parseStr += filename;
          parseStr += "' is not a valid text file.\n";
          SetSize(0);
          free(buf);
          delete file;
          return false;
        }

        else {
          SetSize(data.GetSize());

          icUInt16Number *src = data.GetBuf();
          icFloatNumber *dst = GetData(0);

          icUInt32Number i;
          for (i=0; i<data.GetSize(); i++) {
            *dst = (icFloatNumber)(*src) / 65535.0f; 
            dst++;
            src++;
          }
        }
        delete file;
        return true;
      }

      //float type
      else if (nType == icConvertFloat){
        CIccFloatArray data;

        //if (!data.ParseTextArray(buf)) {
        if (!data.ParseTextArrayNum(buf, num, parseStr)){
          parseStr += "File '";
          parseStr += filename;
          parseStr += "' is not a valid text file.\n";
          SetSize(0);
          free(buf);
          delete file;
          return false;
        }

        else {
          SetSize(data.GetSize());
          icFloatNumber *src = data.GetBuf();
          icFloatNumber *dst = GetData(0);          

          icUInt32Number i;
          for (i=0; i<data.GetSize(); i++) {
            *dst = *src; 
            dst++;
            src++;
          }
        }  
        delete file;
        return true;
      }        
      else {
        delete file;
        return false;
      }
    }
    // format is binary
    else if (!strcmp(format, "binary")) {
      const char *order = icXmlAttrValue(pCurveNode, "Endian");
      bool little_endian = !strcmp(order, "little");    

      if (nType == icConvert8Bit){
        icUInt32Number num = file->GetLength();
        icUInt8Number value;

        SetSize(num);
        icFloatNumber *dst =  GetData(0);
        icUInt32Number i;
        for (i=0; i<num; i++) {
          if (!file->Read8(&value)) { 
            perror("Read-File Error");
            parseStr += "'";
            parseStr += filename;
            parseStr += "' may not be a valid binary file.\n";
            delete file;
            return false;
          } 
          *dst++ = (icFloatNumber)value / 255.0f;
        }         
        delete file;
        return true;
      }        
      else if (nType == icConvert16Bit || nType == icConvertVariable){
        icUInt32Number num = file->GetLength() / sizeof(icUInt16Number);
        icUInt16Number value;
        icUInt8Number *ptr = (icUInt8Number*)&value;

        SetSize(num);
        icFloatNumber *dst = GetData(0);
        icUInt32Number i;
        for (i=0; i<num; i++) {
          if (!file->Read16(&value)) {  //this assumes data is big endian
            perror("Read-File Error");
            parseStr += "'";
            parseStr += filename;
            parseStr += "' may not be a valid binary file.\n";
            delete file;              
            return false;
          }
2716#ifdef ICC_BYTE_ORDER_LITTLE_ENDIAN
          if (little_endian) {
2718#else
          if (!little_endian) {
2720#endif
            icUInt8Number t = ptr[0];
            ptr[0] = ptr[1];
            ptr[1] = t;
          }
          *dst++ = (icFloatNumber)value / 65535.0f;
        }
        delete file;
        return true;
      }
      else if (nType == icConvertFloat) {
        icUInt32Number num = file->GetLength()/sizeof(icFloat32Number);
        icFloat32Number value;
        icUInt8Number *ptr = (icUInt8Number*)&value;

        SetSize(num);
        icFloatNumber *dst = GetData(0);

        icUInt32Number i;
        for (i=0; i<num; i++) {
          if (!file->ReadFloat32Float(&value)) { //assumes data is big endian
            perror("Read-File Error");
            parseStr += "'";
            parseStr += filename;
            parseStr += "' may not be a valid binary file.\n";
            delete file;
            return false;
          }
2748#ifdef ICC_BYTE_ORDER_LITTLE_ENDIAN
          if (little_endian) {
2750#else
          if (!little_endian) {
2752#endif
            icUInt8Number tmp;
            tmp = ptr[0]; ptr[0] = ptr[3]; ptr[3] = tmp;
            tmp = ptr[1]; ptr[1] = ptr[2]; ptr[2] = tmp;
          }
          *dst++ = value;
        }        
        delete file;
        return true;
      }
      else { //not 8bit/16bit/float        
        delete file;
        return false;
      } 
    }       
    else {//not text/binary
      delete file;
      return false;
    }
  }    
  // no file
  else{
    if (nType == icConvert8Bit){
      CIccUInt8Array data;      

      if (!data.ParseArray(pCurveNode->children)) {
        const char *szSize = icXmlAttrValue(pCurveNode, "IdentitySize");

        if (szSize && *szSize) {
          icUInt32Number nSize = (icUInt32Number)atol(szSize);
          SetSize(nSize);

          if (m_nSize == nSize) {
            icUInt32Number j;
            icFloatNumber *dst = GetData(0);
            for (j=0; j<nSize; j++) {
              *dst = (icFloatNumber)(j) / (icFloatNumber)(nSize-1); 
              dst++;
            }
          }
          else
            return false;
        }
        else { //Identity curve with size=0
          SetSize(0);
        }
      }
      else {
        SetSize(data.GetSize());

        icUInt32Number j;
        icUInt8Number *src = data.GetBuf();
        icFloatNumber *dst = GetData(0);
        for (j=0; j<data.GetSize(); j++) {
          *dst = (icFloatNumber)(*src) / 255.0f; 
          dst++;
          src++;
        }          

        //if (j!=256) {
        //printf("Error! - Input/Output table does not have 256 entries.\n");                            
        //SetSize(0);
        //return false;
        //}
      }
      return true;
    }

    else if (nType == icConvert16Bit || nType == icConvertVariable){
      CIccUInt16Array data;

      if (!data.ParseArray(pCurveNode->children)) {
        const char *szSize = icXmlAttrValue(pCurveNode, "IdentitySize");

        if (szSize && *szSize) {
          icUInt32Number nSize = (icUInt32Number)atol(szSize);
          SetSize(nSize);

          if (m_nSize == nSize) {
            icUInt32Number j;
            icFloatNumber *dst = GetData(0);
            for (j=0; j<nSize; j++) {
              *dst = (icFloatNumber)(j) / (icFloatNumber)(nSize-1); 
              dst++;
            }
          }
          else
            return false;
        }
        else { //Identity curve with size=0
          SetSize(0);
        }
      }              
      else {
        SetSize(data.GetSize());

        icUInt32Number j;
        icUInt16Number *src = data.GetBuf();
        icFloatNumber *dst = GetData(0);
        for (j=0; j<data.GetSize(); j++) {
          *dst = (icFloatNumber)(*src) / 65535.0f; 
          dst++;
          src++;
        }
      }              
      return true;
    }      
    else if (nType == icConvertFloat){
      CIccFloatArray data;

      if (!data.ParseArray(pCurveNode->children)) {
        const char *szSize = icXmlAttrValue(pCurveNode, "IdentitySize");

        if (szSize && *szSize) {
          icUInt32Number nSize = (icUInt32Number)atol(szSize);

          SetSize(nSize);

          if (m_nSize == nSize) {
            icUInt32Number j;
            icFloatNumber *dst = GetData(0);
            for (j=0; j<nSize; j++) {
              *dst = (icFloatNumber)(j) / (icFloatNumber)(nSize-1); 
              dst++;
            }
          }
          else
            return false;
        }
        else { //Identity curve with size=0
          SetSize(0);
        }
      }
      else {
        SetSize(data.GetSize());

        icUInt32Number j;
        icFloatNumber *src = data.GetBuf();
        icFloatNumber *dst = GetData(0);
        for (j=0; j<data.GetSize(); j++) {
          *dst = *src; 
          dst++;
          src++;
        }
      }        
      return true;
    }
    // unsupported encoding
    else
      return false;
  }
}
return false;
2905}


2908bool CIccTagXmlParametricCurve::ToXml(std::string &xml, std::string blanks/* = ""*/)
2909{
char buf[80];
int i;

sprintf(buf, "<ParametricCurve FunctionType=\"%d\"", m_nFunctionType);
xml += blanks + buf;

if (m_nReserved2) {
  sprintf(buf, " Reserved=\"%d\"", m_nReserved2);
  xml += buf;
}
xml += ">\n";
xml += blanks + " ";

for (i=0; i<(int)m_nNumParam; i++) {
  sprintf(buf, " %.8f", m_dParam[i]);
  xml += buf;
}
xml += "\n";

sprintf(buf, "</ParametricCurve>\n");
xml += blanks + buf;

return true;
2933}

2935bool CIccTagXmlParametricCurve::ToXml(std::string &xml, icConvertType nType, std::string blanks/* = */)
2936{
return ToXml(xml, blanks);
2938}

2940bool CIccTagXmlParametricCurve::ParseXml(xmlNode *pNode, icConvertType nType, std::string &parseStr)
2941{
return ParseXml (pNode, parseStr);
2943}

2945bool CIccTagXmlParametricCurve::ParseXml(xmlNode *pNode, std::string &parseStr)
2946{
xmlNode *pCurveNode = icXmlFindNode(pNode->children, "ParametricCurve");

for (pCurveNode = pNode; pCurveNode; pCurveNode=pCurveNode->next) {
  if (pCurveNode->type==XML_ELEMENT_NODE) {
    if (!icXmlStrCmp(pCurveNode->name, "ParametricCurve")strcmp((const char *)(pCurveNode->name), (const char*)("ParametricCurve"
))) {

      const char *functionType = icXmlAttrValue(pCurveNode, "FunctionType");

      if (!functionType)
        return false;    

      if (!SetFunctionType(atoi(functionType))){
        return false;
      }
      CIccFloatArray data;

      if (!data.ParseArray(pCurveNode->children)){
        return false;       
      }

      if (data.GetSize()!=GetNumParam()){
        return false;
      }

      icUInt32Number j;
      icFloatNumber *dParams = GetParams();
      icFloatNumber *dataBuf = data.GetBuf();
      for (j=0; j<data.GetSize(); j++) {
        dParams[j] = dataBuf[j];   
      }

      xmlAttr *reserved2 = icXmlFindAttr(pCurveNode, "Reserved");

      if (reserved2) {
        m_nReserved2 = (icUInt16Number)atoi(icXmlAttrValue(reserved2));
      }
      return true;
    }
  }
}
return false;
2988}


2991bool icCurvesToXml(std::string &xml, const char *szName, CIccCurve **pCurves, int numCurve, icConvertType nType, std::string blanks)
2992{
if (pCurves) {
  int i;

  xml += blanks + "<" + szName + ">\n";
  for (i=0; i<numCurve; i++) {
    IIccExtensionTag *pTag = pCurves[i]->GetExtension();
    if (!pTag || strcmp(pTag->GetExtDerivedClassName(), "CIccCurveXml"))
      return false;

    if (!((CIccCurveXml *)pTag)->ToXml(xml, nType, blanks + "  "))
      return false;
  }
  xml += blanks + "</" + szName + ">\n";
}
return true;
3008}


3011bool CIccTagXmlSegmentedCurve::ToXml(std::string &xml, std::string blanks/* = ""*/)
3012{
if (m_pCurve)
  return ((CIccSegmentedCurveXml*)m_pCurve)->ToXml(xml, blanks);

return true;
3017}


3020bool CIccTagXmlSegmentedCurve::ToXml(std::string &xml, icConvertType nType, std::string blanks/* = */)
3021{
return ToXml(xml, blanks);
3023}


3026bool CIccTagXmlSegmentedCurve::ParseXml(xmlNode *pNode, std::string &parseStr )
3027{
xmlNode *pCurveNode = icXmlFindNode(pNode, "SegmentedCurve");
if (pCurveNode) {
  CIccSegmentedCurveXml *pCurve = new CIccSegmentedCurveXml();
  
  if (pCurve) {
    if (pCurve->ParseXml(pCurveNode, parseStr)) {
      SetCurve(pCurve);
      return true;
    }
    else {
      delete pCurve;
      return false;
    }
  }
  parseStr += "Unable to allocate Segmented Curve\n";
  return false;
}
parseStr += "Unable to find Segmented Curve\n";
return false;
3047}


3050bool CIccTagXmlSegmentedCurve::ParseXml(xmlNode *pNode, icConvertType nType, std::string &parseStr)
3051{
return ParseXml(pNode, parseStr);
3053}


3056bool icMatrixToXml(std::string &xml, CIccMatrix *pMatrix, std::string blanks)
3057{
char buf[128];
xml += blanks + "<Matrix\n";

sprintf(buf, "  e1=\"%.8f\" e2=\"%.8f\" e3=\"%.8f\"\n", pMatrix->m_e[0], pMatrix->m_e[1], pMatrix->m_e[2]);
xml += blanks + buf;

sprintf(buf, "  e4=\"%.8f\" e5=\"%.8f\" e6=\"%.8f\"\n", pMatrix->m_e[3], pMatrix->m_e[4], pMatrix->m_e[5]);
xml += blanks + buf;

sprintf(buf, "  e7=\"%.8f\" e8=\"%.8f\" e9=\"%.8f\"", pMatrix->m_e[6], pMatrix->m_e[7], pMatrix->m_e[8]);
xml += blanks + buf;

if (pMatrix->m_bUseConstants) {
  xml += "\n";
  sprintf(buf, "  e10=\"%.8f\" e11=\"%.8f\" e12=\"%.8f\"", pMatrix->m_e[9], pMatrix->m_e[10], pMatrix->m_e[11]);
  xml += blanks + buf;
}
xml += "/>\n";
return true;
3077}

3079// for luts
3080bool icMBBToXml(std::string &xml, CIccMBB *pMBB, icConvertType nType, std::string blanks="", bool bSaveGridPoints=false)
3081{
//blanks += "  ";
char buf[256];

sprintf(buf, "<Channels InputChannels=\"%d\" OutputChannels=\"%d\"/>\n", pMBB->InputChannels(), pMBB->OutputChannels());
xml += blanks + buf;

if (pMBB->IsInputMatrix()) {
  if (pMBB->SwapMBCurves()) {
    if (pMBB->GetMatrix()) {
      // added if-statement 
      if (!icMatrixToXml(xml, pMBB->GetMatrix(), blanks)) {
        return false;
      }
    }

    if (pMBB->GetCurvesB()) {
      // added if-statement 
      if (!icCurvesToXml(xml, "BCurves", pMBB->GetCurvesM(), pMBB->InputChannels(), nType, blanks)) {
        return false;
      }
    }
  }
  else {
    if (pMBB->GetCurvesB()) {
      // added if-statement 
      if (!icCurvesToXml(xml, "BCurves", pMBB->GetCurvesB(), pMBB->InputChannels(), nType, blanks)) {
        return false;
      }
    }

    if (pMBB->GetMatrix()) {
      // added if-statement 
      if (!icMatrixToXml(xml, pMBB->GetMatrix(), blanks)) {
        return false;
      }
    }

    if (pMBB->GetCurvesM()) {
      // added if-statement 
      if (!icCurvesToXml(xml, "MCurves", pMBB->GetCurvesM(), 3, nType, blanks)){
        return false;
      }
    }
  }

  if (pMBB->GetCLUT()) {
    // added if-statement 
    if (!icCLUTToXml(xml, pMBB->GetCLUT(), nType, blanks, bSaveGridPoints)){
      return false;
    }
  }

  if (pMBB->GetCurvesA()) {
    // added if-statement 
    if (!icCurvesToXml(xml, "ACurves", pMBB->GetCurvesA(), pMBB->OutputChannels(), nType, blanks)){
      return false;
    }
  }
}
else {
  if (pMBB->GetCurvesA()) {
    // added if-statement 
    if (!icCurvesToXml(xml, "ACurves", pMBB->GetCurvesA(), pMBB->InputChannels(), nType, blanks)){
      return false;
    }
  }

  if (pMBB->GetCLUT()) {
    // added if-statement 
    if (!icCLUTToXml(xml, pMBB->GetCLUT(), nType, blanks, bSaveGridPoints)){
      return false;
    }
  }

  if (pMBB->GetCurvesM()) {
    // added if-statement 
    if (!icCurvesToXml(xml, "MCurves", pMBB->GetCurvesM(), 3, nType, blanks)){
      return false;
    }
  }

  if (pMBB->GetMatrix()) {
    // added if-statement 
    if (!icMatrixToXml(xml, pMBB->GetMatrix(), blanks)) {
      return false;
    }
  }

  if (pMBB->GetCurvesB()) {
    // added if-statement 
    if (!icCurvesToXml(xml, "BCurves", pMBB->GetCurvesB(), pMBB->OutputChannels(), nType, blanks)){
      return false;
    }
  }
}
return true;
3178}


3181bool icCurvesFromXml(LPIccCurve *pCurve, icUInt32Number nChannels, xmlNode *pNode, icConvertType nType, std::string &parseStr)
3182{
icUInt32Number i;
xmlNode *pCurveNode;

for (i=0, pCurveNode = pNode; i<nChannels && pCurveNode; pCurveNode=pCurveNode->next) {
  if (pCurveNode->type==XML_ELEMENT_NODE) {
    CIccCurve *pCurveTag = NULL__null;
    if (!icXmlStrCmp(pCurveNode->name, "Curve")strcmp((const char *)(pCurveNode->name), (const char*)("Curve"
))) {
      pCurveTag = new CIccTagXmlCurve;
    }
    else if (!icXmlStrCmp(pCurveNode->name, "ParametricCurve")strcmp((const char *)(pCurveNode->name), (const char*)("ParametricCurve"
))) {
      pCurveTag = new CIccTagXmlParametricCurve();
    }

    if (pCurveTag) {
      IIccExtensionTag *pExt = pCurveTag->GetExtension();

      if (pExt) {
        if (!strcmp(pExt->GetExtDerivedClassName(), "CIccCurveXml")) {
          CIccCurveXml *pCurveXml = (CIccCurveXml *)pExt;

          if (pCurveXml->ParseXml(pCurveNode, nType, parseStr)) {
            pCurve[i] = pCurveTag;
            i++;
          }
          // added else statement
          else  {
            char num[40];
            parseStr += "Unable to parse curve at Line";
            sprintf(num, "%d\n", pCurveNode->line);
            parseStr += num;
            return false;
          }
        }
        else if (!strcmp(pExt->GetExtClassName(), "CIccTagXml")) {
          CIccTagXml *pXmlTag = (CIccTagXml *)pExt;

          if (pXmlTag->ParseXml(pCurveNode, parseStr)) {
            pCurve[i] = pCurveTag;
            i++;
          }
          // added else statement
          else {
            char num[40];
            parseStr += "Unable to parse curve tag at Line";
            sprintf(num, "%d\n", pCurveNode->line);
            parseStr += num;
            return false;
          }
        }
      }
    }
  }
}
if (!i != nChannels) {
  parseStr += "Channel number mismatch!\n";
}
return i==nChannels;
3240}

3242bool icMatrixFromXml(CIccMatrix *pMatrix, xmlNode *pNode)
3243{
memset(pMatrix->m_e, 0, sizeof(pMatrix->m_e));
pMatrix->m_bUseConstants = false;

char attrName[15];
int i;

for (i=0; i<9; i++) {
  sprintf(attrName, "e%d", i+1);
  xmlAttr *attr = icXmlFindAttr(pNode, attrName);
  if (attr) {
    pMatrix->m_e[i] = (icFloatNumber)atof(icXmlAttrValue(attr));
  }
}
for (i=9; i<12; i++) {
  sprintf(attrName, "e%d", i+1);
  xmlAttr *attr = icXmlFindAttr(pNode, attrName);
  if (attr) {
    pMatrix->m_e[i] = (icFloatNumber)atof(icXmlAttrValue(attr));
    pMatrix->m_bUseConstants = true;
  }
}
return true;
3266}

3268CIccCLUT *icCLutFromXml(xmlNode *pNode, int nIn, int nOut, icConvertType nType,  std::string &parseStr)
3269{
CIccCLUT *pCLUT = NULL__null;

int nPrecision = 2;
if (nType == icConvert8Bit)
  nPrecision = 1;  

icUInt8Number nInput = (icUInt8Number)nIn;
icUInt16Number nOutput = (icUInt16Number)nOut;

pCLUT = new CIccCLUT(nInput, nOutput, nPrecision);

if (!pCLUT){
  parseStr += "Error in creating CLUT Table. Check values of Precision, InputChannel, or OutputChannels.\n";
  return NULL__null;
}

xmlNode *grid = icXmlFindNode(pNode->children, "GridPoints");
if (grid) {
  CIccUInt8Array points;

  if (points.ParseArray(grid->children)) {
    if (!pCLUT->Init(points.GetBuf())) {
      parseStr += "Error in setting the size of GridPoints. Check values of GridPoints, InputChannel, or OutputChannels.\n";
      delete pCLUT;
      return NULL__null;
    }
  }
  else {
    parseStr += "Error parsing GridPoints.\n";
    delete pCLUT;
    return NULL__null;
  }
}
else {
  icUInt8Number nGridGranularity;

  xmlAttr *gridGranularity = icXmlFindAttr(pNode, "GridGranularity");

  if (gridGranularity) {
    nGridGranularity = (icUInt8Number)atoi(icXmlAttrValue(gridGranularity));
  }
  else {
    delete pCLUT;
    return NULL__null;
  }
  if (!pCLUT->Init(nGridGranularity)) {
    parseStr += "Error in setting the size of GridGranularity. Check values of GridGranularity, InputChannel, or OutputChannels.\n";
    delete pCLUT;
    return NULL__null;
  }
}

xmlNode *table = icXmlFindNode(pNode->children, "TableData");

if (table) {
  if (nType == icConvertVariable) {
    const char *precision = icXmlAttrValue(table, "Precision");
    if (precision && atoi(precision) == 1) {
      nType = icConvert8Bit;
      pCLUT->SetPrecision(1);
    }
    else {
      nType = icConvert16Bit;
      pCLUT->SetPrecision(2);
    }
  }

  const char *filename = icXmlAttrValue(table, "Filename");
  if (!filename || !filename[0]) {
    filename = icXmlAttrValue(table, "File");
  }

  if (filename[0]) {
    CIccIO *file = IccOpenFileIO(filename, "rb");

    if (!file) {
      // added error message
      parseStr += "Error! - File '";
      parseStr += filename;
      parseStr +="' not found.\n";
      delete pCLUT;
      return NULL__null;
    }

    const char *format = icXmlAttrValue(table, "Format");

    if (!strcmp(format, "text")) {
      icUInt32Number num = file->GetLength();
      char *buf = (char *)malloc(num);

      if (!buf) {  
        perror("Memory Error");
        parseStr += "'";
        parseStr += filename;
        parseStr += "' may not be a valid text file.\n";
        delete file;
        delete pCLUT;
        return NULL__null;
      }

      //Allow for different encoding in text file than implied by the table type
      const char *encoding = icXmlAttrValue(table, "FileEncoding");

      if (!strcmp(encoding, "int8"))
        nType = icConvert8Bit;
      else if (!strcmp(encoding, "int16"))
        nType = icConvert16Bit;
      else if (!strcmp(encoding, "float"))
        nType = icConvertFloat;
      else if (encoding[0]) {
        parseStr+= "Unknown encoding \"";
        parseStr+= encoding;
        parseStr+= "\" - using default encoding\n";
      }

      if (file->Read8(buf, num)!=num) { 
        perror("Read-File Error");
        parseStr += "'";
        parseStr += filename;
        parseStr += "' may not be a valid text file.\n";
        free(buf);
        delete file;
        delete pCLUT;
        return NULL__null;
      }

      if (nType == icConvert8Bit) {
        CIccUInt8Array data;

        if (!data.ParseTextArrayNum(buf, num, parseStr)) {
          parseStr += "File '";
          parseStr += filename;
          parseStr += "' is not a valid text file.\n";
          free(buf);
          delete file;
          delete pCLUT;
          return NULL__null;
        }

        if (data.GetSize()!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {     
          parseStr += "Error! - Number of entries in file '";
          parseStr += filename;
          parseStr += "'is not equal to the size of the CLUT Table.\n";  
          parseStr += "    a. Check values of GridGranularity/GridPoints, InputChannel, or OutputChannels.\n";
          parseStr += "    b. File may not be a valid text file.\n";
          free(buf);
          delete file;
          delete pCLUT;
          return NULL__null;
        }
        icUInt8Number *src = data.GetBuf();
        icFloatNumber *dst = pCLUT->GetData(0);

        icUInt32Number i;
        for (i=0; i<data.GetSize(); i++) {
          *dst++ = (icFloatNumber)(*src++) / 255.0f;
        }
      }
      else if (nType == icConvert16Bit) {
        CIccUInt16Array data;

        if (!data.ParseTextArrayNum(buf, num, parseStr)) {
          parseStr += "File '";
          parseStr += filename;
          parseStr += "' is not a valid text file.\n";      
          free(buf);
          delete file;
          delete pCLUT;
          return NULL__null;
        }

        if (data.GetSize()!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
          parseStr += "Error! - Number of entries in file '";
          parseStr += filename;
          parseStr += "'is not equal to the size of the CLUT Table.\n";  
          parseStr += "    a. Check values of GridGranularity/GridPoints, InputChannel, or OutputChannels.\n";
          parseStr += "    b. File may not be a valid text file.\n";
          free(buf);
          delete file;
          delete pCLUT;
          return NULL__null;
        }
        icUInt16Number *src = data.GetBuf();
        icFloatNumber *dst = pCLUT->GetData(0);

        icUInt32Number i;
        for (i=0; i<data.GetSize(); i++) {
          *dst++ = (icFloatNumber)(*src++) / 65535.0f;
        }
      }
      else if (nType == icConvertFloat) {
        CIccFloatArray data;

        if (!data.ParseTextArrayNum(buf, num, parseStr)) {
          parseStr += "File '";
          parseStr += filename;
          parseStr += "' is not a valid text file.\n";
          free(buf);
          delete file;
          delete pCLUT;
          return NULL__null;
        }

        if (data.GetSize()!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
          parseStr += "Error! - Number of entries in file '";
          parseStr += filename;
          parseStr += "'is not equal to the size of the CLUT Table.\n";  
          parseStr += "    a. Check values of GridGranularity/GridPoints, InputChannel, or OutputChannels.\n";
          parseStr += "    b. File may not be a valid text file.\n";
          free(buf);
          delete file;
          delete pCLUT;
          return NULL__null;
        }
        icFloatNumber *src = data.GetBuf();
        icFloatNumber *dst = pCLUT->GetData(0);

        icUInt32Number i;
        for (i=0; i<data.GetSize(); i++) {
          *dst++ = *src++;
        }
      }
      else {
        parseStr += "Error! Unknown text data type.\n";
        free(buf);
        delete file;
        delete pCLUT;
        return NULL__null;
      }
      free(buf);
    }
    else if (!strcmp(format, "binary")) {
      const char *order = icXmlAttrValue(table, "Endian");
      bool little_endian = !strcmp(order, "little");

      if (nType==icConvertVariable) {
        //Allow encoding to be defined
        const char *encoding = icXmlAttrValue(table, "FileEncoding");

        if (!strcmp(encoding, "int8"))
          nType = icConvert8Bit;
        else if (!strcmp(encoding, "int16"))
          nType = icConvert16Bit;
        else if (!strcmp(encoding, "float"))
          nType = icConvertFloat;
        else if (encoding[0]) {
          parseStr+= "Unknown encoding \"";
          parseStr+= encoding;
          parseStr+= "\" - using int16.\n";
          nType = icConvert16Bit;
        }
        else {
          parseStr+= "CLUT TableData Encoding type not specified.\n";
        }
      }

      if (nType == icConvert8Bit){
        icUInt32Number num = file->GetLength();
        icUInt8Number value;      
        // if number of entries in file is not equal to size of CLUT table, flag as error
        if (num!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
          parseStr += "Error! - Number of entries in file '";
          parseStr += filename;
          parseStr += "'is not equal to the size of the CLUT Table.\n";  
          parseStr += "    a. Check values of GridGranularity/GridPoints, InputChannel, or OutputChannels.\n";
          parseStr += "    b. File may not be a valid binary file.\n";
          delete file;
          delete pCLUT;
          return NULL__null;
        }
        icFloatNumber *dst = pCLUT->GetData(0);
        icUInt32Number i;
        for (i=0; i<num; i++) {
          if (!file->Read8(&value)) {
            perror("Read-File Error");
            parseStr += "'";
            parseStr += filename;
            parseStr += "' may not be a valid binary file.\n";
            delete file;
            delete pCLUT;
            return NULL__null;
          }      
          *dst++ = (icFloatNumber)value / 255.0f;
        }
      }
      else if (nType == icConvert16Bit){
        icUInt32Number num = file->GetLength() / sizeof(icUInt16Number);
        icUInt16Number value;
        icUInt8Number *ptr = (icUInt8Number*)&value;

        if (num<pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
          parseStr += "Error! - Number of entries in file '";
          parseStr += filename;
          parseStr += "'is not equal to the size of the CLUT Table.\n";
          parseStr += "    a. Check values of GridGranularity/GridPoints, InputChannel, or OutputChannels.\n";
          parseStr += "    b. File may not be a valid binary file.\n";
          delete file;
          delete pCLUT;
          return NULL__null;
        }
        icFloatNumber *dst = pCLUT->GetData(0);

        icUInt32Number i;
        for (i=0; i<num; i++) {
          if (!file->Read16(&value)) {  //this assumes data is big endian
            perror("Read-File Error");
            parseStr += "'";
            parseStr += filename;
            parseStr += "' may not be a valid binary file.\n";
            delete file;
            delete pCLUT;
            return NULL__null;
          }
3583#ifdef ICC_BYTE_ORDER_LITTLE_ENDIAN
          if (little_endian) {
3585#else
          if (!little_endian) {
3587#endif
            icUInt8Number t = ptr[0];
            ptr[0] = ptr[1];
            ptr[1] = t;
          }
          *dst++ = (icFloatNumber)value / 65535.0f;
        }
      }
      else if (nType == icConvertFloat){
        icUInt32Number num = file->GetLength()/sizeof(icFloat32Number);
        icFloat32Number value;
        icUInt8Number *ptr = (icUInt8Number*)&value;

        if (num<pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
          parseStr += "Error! - Number of entries in file '";
          parseStr += filename;
          parseStr += "'is not equal to the size of the CLUT Table.\n";  
          parseStr += "    a. Check values of GridGranularity/GridPoints, InputChannel, or OutputChannels.\n";
          parseStr += "    b. File may not be a valid binary file.\n";
          delete file;
          delete pCLUT;
          return NULL__null;
        }
        icFloatNumber *dst = pCLUT->GetData(0);

        icUInt32Number i;
        for (i=0; i<num; i++) {
          if (!file->ReadFloat32Float(&value)) {  //this assumes data is big endian
            perror("Read-File Error");
            parseStr += "'";
            parseStr += filename;
            parseStr += "' may not be a valid binary file.\n";
            delete file;
            delete pCLUT;
            return NULL__null;
          }
3623#ifdef ICC_BYTE_ORDER_LITTLE_ENDIAN
          if (little_endian) {
3625#else
          if (!little_endian) {
3627#endif
            icUInt8Number tmp;
            tmp = ptr[0]; ptr[0] = ptr[3]; ptr[3] = tmp;
            tmp = ptr[1]; ptr[1] = ptr[2]; ptr[2] = tmp;
          }
          *dst++ = value;
        }
      }
      else {
        parseStr += "Error! Unknown binary data type.\n";
        delete file;
        delete pCLUT;
        return NULL__null;
      }

    }
    else {
      parseStr += "Error! Unknown Format type.\n";
      delete pCLUT;
      return NULL__null;
    }

    delete file;
  }
  else { // no file
    if (nType == icConvert8Bit) {
      CIccUInt8Array data;

      if (!data.ParseArray(table->children)) {
        parseStr += "Error! - unable to parse data in CLUT.\n";
        delete pCLUT;
        return NULL__null;
      }

      if (data.GetSize()!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
        parseStr += "Error! - Number of entries is not equal to the size of the CLUT Table.\n";  
        delete pCLUT;
        return NULL__null;
      }
      icUInt8Number *src = data.GetBuf();
      icFloatNumber *dst = pCLUT->GetData(0);

      icUInt32Number i;
      for (i=0; i<data.GetSize(); i++) {
        *dst++ = (icFloatNumber)(*src++) / 255.0f;
      }
    }
    else if (nType == icConvert16Bit || nType==icConvertVariable) {
      CIccUInt16Array data;

      if (!data.ParseArray(table->children)) {
        parseStr += "Error! - unable to parse data in CLUT.\n";
        delete pCLUT;
        return NULL__null;
      }

      if (data.GetSize()!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
        parseStr += "Error! - Number of entries is not equal to the size of the CLUT Table.\n";  
        delete pCLUT;
        return NULL__null;
      }
      icUInt16Number *src = data.GetBuf();
      icFloatNumber *dst = pCLUT->GetData(0);

      icUInt32Number i;
      for (i=0; i<data.GetSize(); i++) {
        *dst++ = (icFloatNumber)(*src++) / 65535.0f;
      }    
    }      
    else if (nType == icConvertFloat){
      CIccFloatArray data;

      if (!data.ParseArray(table->children)) {
        parseStr += "Error! - unable to parse data in CLUT.\n";
        delete pCLUT;
        return NULL__null;
      }

      if (data.GetSize()!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
        parseStr += "Error! - Number of entries is not equal to the size of the CLUT Table.\n";  
        delete pCLUT;
        return NULL__null;
      }
      icFloatNumber *src = data.GetBuf();
      icFloatNumber *dst = pCLUT->GetData(0);

      icUInt32Number i;
      for (i=0; i<data.GetSize(); i++) {
        *dst++ = *src++;
      }
    }
    else {
      parseStr += "Error! Unknown table data type.";
      delete pCLUT;
      return NULL__null;
    }
  }
}
else {
  parseStr += "Error! Cannot find table data.";
  delete pCLUT;
  return NULL__null;
}

return pCLUT;
3732}

3734bool icMBBFromXml(CIccMBB *pMBB, xmlNode *pNode, icConvertType nType, std::string &parseStr)
3735{
xmlNode *pChannels = icXmlFindNode(pNode, "Channels");

if (!pChannels)
  return false;

xmlAttr *in = icXmlFindAttr(pChannels, "InputChannels");
xmlAttr *out = icXmlFindAttr(pChannels, "OutputChannels");

if (!in || !out)
  return false;

int nIn = atoi(icXmlAttrValue(in));
int nOut = atoi(icXmlAttrValue(out));

pMBB->Init(nIn, nOut);

for (; pNode; pNode = pNode->next) {
  if (pNode->type == XML_ELEMENT_NODE) {
    if (!icXmlStrCmp(pNode->name, "ACurves")strcmp((const char *)(pNode->name), (const char*)("ACurves"
)) && !pMBB->GetCurvesA()) {
      LPIccCurve *pCurves = pMBB->NewCurvesA();
      if (!icCurvesFromXml(pCurves, !pMBB->IsInputB() ? nIn : nOut, pNode->children, nType, parseStr)) {
        parseStr += "Error! - Failed to parse ACurves.\n";
        return false;
      }
    }
    else if (!icXmlStrCmp(pNode->name, "BCurves")strcmp((const char *)(pNode->name), (const char*)("BCurves"
)) && !pMBB->GetCurvesB()) {
      LPIccCurve *pCurves = pMBB->NewCurvesB();
      if (!icCurvesFromXml(pCurves, pMBB->IsInputB() ? nIn : nOut, pNode->children, nType, parseStr)) {
        parseStr += "Error! - Failed to parse BCurves.\n";
        return false;
      }
    }
    else if (!icXmlStrCmp(pNode->name, "MCurves")strcmp((const char *)(pNode->name), (const char*)("MCurves"
)) && !pMBB->GetCurvesM()) {
      LPIccCurve *pCurves = pMBB->NewCurvesM();
      if (!icCurvesFromXml(pCurves, !pMBB->IsInputMatrix() ? nIn : nOut, pNode->children, nType, parseStr)) {
        parseStr += "Error! - Failed to parse MCurves.\n";
        return false;
      }
    }
    else if (!icXmlStrCmp(pNode->name, "Matrix")strcmp((const char *)(pNode->name), (const char*)("Matrix"
)) && !pMBB->GetMatrix()) {
      CIccMatrix *pMatrix = pMBB->NewMatrix();
      if (!icMatrixFromXml(pMatrix, pNode)) {
        parseStr += "Error! - Failed to parse Matrix.\n";
        return false;
      }
    }
    else if (!icXmlStrCmp(pNode->name, "CLUT")strcmp((const char *)(pNode->name), (const char*)("CLUT")) && !pMBB->GetCLUT()) {
      CIccCLUT *pCLUT = icCLutFromXml(pNode, nIn, nOut, nType, parseStr);
      if (pCLUT) {
        if (!pMBB->SetCLUT(pCLUT)) {
          parseStr += "Error! - Failed to set CLUT to LUT.\n";
          return false;
        }
      }
      else {
        parseStr += "Error! - Failed to parse CLUT.\n";
        return false;
      }
    }
  }
}

return true;
3799}

3801bool CIccTagXmlLutAtoB::ToXml(std::string &xml, std::string blanks/* = ""*/)
3802{
std::string info;

bool rv = icMBBToXml(xml, this, icConvertVariable, blanks, true);

return rv;
3808}


3811bool CIccTagXmlLutAtoB::ParseXml(xmlNode *pNode, std::string &parseStr)
3812{

if (pNode) {
  return icMBBFromXml(this, pNode, icConvertVariable, parseStr);
}

return false;
3819}


3822bool CIccTagXmlLutBtoA::ToXml(std::string &xml, std::string blanks/* = ""*/)
3823{
std::string info;

bool rv = icMBBToXml(xml, this, icConvertVariable, blanks, true);

return rv;
3829}


3832bool CIccTagXmlLutBtoA::ParseXml(xmlNode *pNode, std::string &parseStr)
3833{
if (pNode) {
  return icMBBFromXml(this, pNode, icConvertVariable, parseStr);
}

return false;
3839}


3842bool CIccTagXmlLut8::ToXml(std::string &xml, std::string blanks/* = ""*/)
3843{
std::string info;

bool rv = icMBBToXml(xml, this, icConvert8Bit, blanks, false);

return rv;
3849}


3852bool CIccTagXmlLut8::ParseXml(xmlNode *pNode, std::string &parseStr)
3853{

if (pNode) {
  return icMBBFromXml(this, pNode, icConvert8Bit, parseStr);
}
return false;
3859}


3862bool CIccTagXmlLut16::ToXml(std::string &xml, std::string blanks/* = ""*/)
3863{
std::string info;

bool rv = icMBBToXml(xml, this, icConvert16Bit, blanks, false);

return rv;
3869}


3872bool CIccTagXmlLut16::ParseXml(xmlNode *pNode, std::string &parseStr)
3873{
if (pNode) {
  return icMBBFromXml(this, pNode, icConvert16Bit, parseStr);
}
return false;
3878}


3881bool CIccTagXmlMultiProcessElement::ToXml(std::string &xml, std::string blanks/* = ""*/)
3882{
std::string info;
char line[256];

CIccMultiProcessElementList::iterator i;

sprintf(line, "<MultiProcessElements InputChannels=\"%d\" OutputChannels=\"%d\">\n", NumInputChannels(), NumOutputChannels());
xml += blanks + line;

for (i=m_list->begin(); i!=m_list->end(); i++) {
  if (i->ptr) {
    CIccMultiProcessElement *pMpe = i->ptr;

    IIccExtensionMpe *pMpeExt = pMpe->GetExtension();

    if (pMpeExt) {
      if (!strcmp(pMpeExt->GetExtClassName(), "CIccMpeXml")) {
        CIccMpeXml *pMpeXml = (CIccMpeXml*)pMpeExt;

        pMpeXml->ToXml(xml, blanks + "  ");
      }
      else {
        return false;
      }
    }
    else {
      return false;
    }
  }
}
xml += blanks + "</MultiProcessElements>\n";
return true;
3914}


3917CIccMultiProcessElement *CIccTagXmlMultiProcessElement::CreateElement(const icChar *szElementNodeName)
3918{
if (!strcmp(szElementNodeName, "UnknownElement")) {
  return new CIccMpeXmlUnknown;
}
if (!strcmp(szElementNodeName, "CurveSetElement")) {
  return new CIccMpeXmlCurveSet;
}
if (!strcmp(szElementNodeName, "MatrixElement")) {
  return new CIccMpeXmlMatrix;
}
if (!strcmp(szElementNodeName, "CLutElement")) {
  return new CIccMpeXmlCLUT;
}
if (!strcmp(szElementNodeName, "ExtCLutElement")) {
  return new CIccMpeXmlExtCLUT;
}
if (!strcmp(szElementNodeName, "BAcsElement")) {
  return new CIccMpeXmlBAcs;
}
if (!strcmp(szElementNodeName, "EAcsElement")) {
  return new CIccMpeXmlEAcs;
}
if (!strcmp(szElementNodeName, "CalculatorElement")) {
  return new CIccMpeXmlCalculator;
}
if (!strcmp(szElementNodeName, "JabToXYZElement")) {
  return new CIccMpeXmlJabToXYZ;
}
if (!strcmp(szElementNodeName, "XYZToJabElement")) {
  return new CIccMpeXmlXYZToJab;
}
if (!strcmp(szElementNodeName, "TintArrayElement")) {
  return new CIccMpeXmlTintArray;
}
if (!strcmp(szElementNodeName, "EmissionMatrixElement")) {
  return new CIccMpeXmlEmissionMatrix;
}
if (!strcmp(szElementNodeName, "InvEmissionMatrixElement")) {
  return new CIccMpeXmlInvEmissionMatrix;
}
if (!strcmp(szElementNodeName, "EmissionCLutElement")) {
  return new CIccMpeXmlEmissionCLUT;
}
if (!strcmp(szElementNodeName, "ReflectanceCLutElement")) {
  return new CIccMpeXmlReflectanceCLUT;
}
if (!strcmp(szElementNodeName, "EmissionObserverElement")) {
  return new CIccMpeXmlEmissionObserver;
}
if (!strcmp(szElementNodeName, "ReflectanceObserverElement")) {
  return new CIccMpeXmlReflectanceObserver;
}
return NULL__null;
3971}


3974bool CIccTagXmlMultiProcessElement::ParseElement(xmlNode *pNode, std::string &parseStr)
3975{
xmlAttr *attr;

if (pNode->type != XML_ELEMENT_NODE) {
  return false;
}

CIccMultiProcessElement *pMpe = CreateElement((const icChar*)pNode->name);

if (!pMpe) {
  parseStr += std::string("Unknown Element Type (") + (const icChar*)pNode->name + ")\n";
  return false;
}

CIccMultiProcessElementPtr ptr;

IIccExtensionMpe *pExt = pMpe->GetExtension();

if (pExt) {
  if (!strcmp(pExt->GetExtClassName(), "CIccMpeXml")) {
    CIccMpeXml* pXmlMpe = (CIccMpeXml*)pExt;

    if (pXmlMpe->ParseXml(pNode, parseStr)) {
      if ((attr=icXmlFindAttr(pNode, "Reserved"))) {
        sscanf(icXmlAttrValue(attr), "%u", &pMpe->m_nReserved);
      }

      ptr.ptr = pMpe;
      m_list->push_back(ptr);
    }
    else {
      parseStr += std::string("Unable to parse element of type ") + pMpe->GetClassName() + "\n";
      delete pMpe;
      return false;
    }
  }
  else {
    parseStr += std::string("Element ") + pMpe->GetClassName() + "isn't of type CIccMpeXml\n";
    delete pMpe;
    return false;
  }
}
else {
  parseStr += std::string("Element ") + pMpe->GetClassName() + "isn't of type CIccMpeXml\n";
  delete pMpe;
  return false;
}

return true;
4024}


4027bool CIccTagXmlMultiProcessElement::ParseXml(xmlNode *pNode, std::string &parseStr)
4028{
pNode = icXmlFindNode(pNode, "MultiProcessElements");

if (!pNode) {
  parseStr += "Cannot Find MultiProcessElements\r\n";
  return false;
}

xmlAttr *pInputChannels = icXmlFindAttr(pNode, "InputChannels");
xmlAttr *pOutputChannels = icXmlFindAttr(pNode, "OutputChannels");

if (!pInputChannels || !pOutputChannels) {
  parseStr += "Invalid channels in MultiProcessElements\r\n";
  return false;
}

m_nInputChannels = atoi(icXmlAttrValue(pInputChannels));
m_nOutputChannels = atoi(icXmlAttrValue(pOutputChannels));

if (!m_list) {
  m_list = new CIccMultiProcessElementList();
}
else {
  m_list->clear();
}

xmlNode *elemNode;
for (elemNode = pNode->children; elemNode; elemNode = elemNode->next) {
  if (elemNode->type == XML_ELEMENT_NODE) {
    if (!ParseElement(elemNode, parseStr)) {
      char str[100];
      parseStr += "Unable to parse element (";
      parseStr += (char*)elemNode->name;
      sprintf(str, ") starting on line %d\r\n", elemNode->line);
      parseStr += str;
      return false;
    }
  }
}

return true;
4069}


4072bool CIccTagXmlProfileSequenceId::ToXml(std::string &xml, std::string blanks/* = ""*/)
4073{
std::string info;

xml += blanks + "<ProfileSequenceId>\n";

CIccProfileIdDescList::iterator pid;

for (pid=m_list->begin(); pid!=m_list->end(); pid++) {
  char buf[256];
  char data[256];
  char fix[256];
  std::string bufstr;
  int n;

  for (n=0; n<16; n++) {
    sprintf(buf + n*2, "%02X", pid->m_profileID.ID8[n]);
  }
  buf[n*2]='\0';
  xml += blanks + " <ProfileIdDesc id=\"";
  xml += buf;
  xml += "\">\n";

  if (pid->m_desc.m_Strings) {
    CIccMultiLocalizedUnicode::iterator i;

    for (i=pid->m_desc.m_Strings->begin(); i!=pid->m_desc.m_Strings->end(); i++) {
      sprintf(buf, "<LocalizedText LanguangeCountry=\"%s\"", icFixXml(fix, icGetSigStr(data, (i->m_nLanguageCode<<16) + i->m_nCountryCode)));
      xml += blanks + buf;

      sprintf(buf, ">%s</LocalizedText>\n", icFixXml(fix, icUtf16ToUtf8(bufstr, i->GetBuf(), i->GetLength())));
      xml += buf;
    }
  }
  xml += blanks + " </ProfileIdDesc>\n";
}

xml += blanks + "</ProfileSequenceId>\n";
return true;
4111}


4114bool CIccTagXmlProfileSequenceId::ParseXml(xmlNode *pNode, std::string &parseStr)
4115{
pNode = icXmlFindNode(pNode, "ProfileSequenceId");

if (!pNode)
  return false;

m_list->clear();

for (pNode = icXmlFindNode(pNode->children, "ProfileIdDesc"); pNode; pNode = icXmlFindNode(pNode->next, "ProfileIdDesc")) {
  CIccProfileIdDesc desc;
  const icChar *szDesc = icXmlAttrValue(pNode, "id");

  if (szDesc && *szDesc)
    icXmlGetHexData(&desc.m_profileID, szDesc, sizeof(desc.m_profileID));

  xmlAttr *langCode;

  for (pNode = icXmlFindNode(pNode, "LocalizedText"); pNode; pNode = icXmlFindNode(pNode->next, "LocalizedText")) {
    if ((langCode = icXmlFindAttr(pNode, "languageCountry")) &&
      pNode->children) {
        xmlNode *pText;

        for (pText = pNode->children; pText && pText->type != XML_TEXT_NODE; pText = pText->next);

        if (pText) {
          icUInt32Number lc = icGetSigVal(icXmlAttrValue(langCode));
          CIccUTF16String str((const char*)pText->content);
          desc.m_desc.SetText(str.c_str(), (icLanguageCode)(lc>>16), (icCountryCode)(lc & 0xffff));
        }
        else {
          desc.m_desc.SetText("");
        }
    }
  }
  m_list->push_back(desc);
}

return false;
4153}


4156bool CIccTagXmlDict::ToXml(std::string &xml, std::string blanks/* = ""*/)
4157{
std::string info;

CIccNameValueDict::iterator nvp;

for (nvp=m_Dict->begin(); nvp!=m_Dict->end(); nvp++) {
  CIccDictEntry *nv = nvp->ptr;
  if (!nv)
    continue;

  char buf[256];
  char data[256];
  char fix[256];
  std::string bufstr;

  xml += blanks + " <DictEntry Name=\"";
  xml += icFixXml(fix, icUtf16ToUtf8(bufstr, (icUInt16Number*)nv->GetName().c_str(), (int)nv->GetName().size()));
  xml += "\"";

  if (nv->IsValueSet()) {
    xml += " Value=\"";
    xml += icFixXml(fix, icUtf16ToUtf8(bufstr, (icUInt16Number*)nv->GetValue().c_str(), (int)nv->GetValue().size()));
    xml += "\"";
  }

  if (!nv->GetNameLocalized() && !nv->GetValueLocalized()) {
    xml += "/>\n";
  }
  else {
    xml += "\n";

    if (nv->GetNameLocalized()) {
      CIccMultiLocalizedUnicode::iterator i;

      for (i=nv->GetNameLocalized()->m_Strings->begin(); i!=nv->GetNameLocalized()->m_Strings->end(); i++) {
        sprintf(buf, "  <LocalizedName LanguageCountry=\"%s\"", icFixXml(fix, icGetSigStr(data, (i->m_nLanguageCode<<16) + i->m_nCountryCode)));
        xml += blanks + buf;

        sprintf(buf, "><![CDATA[%s]]></LocalizedName>\n", icFixXml(fix, icUtf16ToUtf8(bufstr, i->GetBuf(), i->GetLength())));
        xml += buf;
      }
    }
    if (nv->GetValueLocalized()) {
      CIccMultiLocalizedUnicode::iterator i;

      for (i=nv->GetValueLocalized()->m_Strings->begin(); i!=nv->GetValueLocalized()->m_Strings->end(); i++) {
        sprintf(buf, "  <LocalizedValue LanguageCountry=\"%s\"", icFixXml(fix, icGetSigStr(data, (i->m_nLanguageCode<<16) + i->m_nCountryCode)));
        xml += blanks + buf;

        sprintf(buf, "><![CDATA[%s]]></LocalizedValue>\n", icFixXml(fix, icUtf16ToUtf8(bufstr, i->GetBuf(), i->GetLength())));
        xml += buf;
      }
    }
    xml += blanks + " </DictEntry>\n";
  }
}
return true;
4214}


4217bool CIccTagXmlDict::ParseXml(xmlNode *pNode, std::string &parseStr)
4218{
m_Dict->clear();

for (pNode = icXmlFindNode(pNode, "DictEntry"); pNode; pNode = icXmlFindNode(pNode->next, "DictEntry")) {
  CIccDictEntryPtr ptr;
  CIccDictEntry *pDesc = new CIccDictEntry();
  xmlAttr *pAttr;
  CIccUTF16String str;

  if (!pDesc)
    return false;
  ptr.ptr = pDesc;

  str = icXmlAttrValue(pNode, "Name", "");
  str.ToWString(pDesc->GetName());

  pAttr = icXmlFindAttr(pNode, "Value");
  if (pAttr) {
    std::wstring wstr;
    str = icXmlAttrValue(pAttr, "");
    str.ToWString(wstr);

    pDesc->SetValue(wstr);
  }

  xmlNode *pChild;

  for (pChild = pNode->children; pChild; pChild = pChild->next) {
    if (pChild->type == XML_ELEMENT_NODE && !icXmlStrCmp(pChild->name, "LocalizedName")strcmp((const char *)(pChild->name), (const char*)("LocalizedName"
))) {
      CIccTagMultiLocalizedUnicode *pTag = pDesc->GetNameLocalized();
      if (!pTag) {
        pTag = new CIccTagMultiLocalizedUnicode();
        pDesc->SetNameLocalized(pTag);
      }

      if ((pAttr = icXmlFindAttr(pChild, "LanguageCountry")) && pChild->children) {
        xmlNode *pText;
        icUInt32Number lc = icGetSigVal(icXmlAttrValue(pAttr));

        for (pText = pChild->children; pText && pText->type != XML_TEXT_NODE && pText->type != XML_CDATA_SECTION_NODE; pText = pText->next);

        if (pText) {
          CIccUTF16String str((const char*)pText->content);

          pTag->SetText(str.c_str(), (icLanguageCode)(lc>>16), (icCountryCode)(lc & 0xffff));
        }
        else {
          pTag->SetText("");
        }
      }
    }
    else if (pChild->type == XML_ELEMENT_NODE && !icXmlStrCmp(pChild->name, "LocalizedValue")strcmp((const char *)(pChild->name), (const char*)("LocalizedValue"
))) {
      CIccTagMultiLocalizedUnicode *pTag = pDesc->GetValueLocalized();
      if (!pTag) {
        pTag = new CIccTagMultiLocalizedUnicode();
        pDesc->SetValueLocalized(pTag);
      }

      if ((pAttr = icXmlFindAttr(pChild, "LanguageCountry")) && pChild->children) {
        xmlNode *pText;
        icUInt32Number lc = icGetSigVal(icXmlAttrValue(pAttr));

        for (pText = pChild->children; pText && pText->type != XML_TEXT_NODE && pText->type != XML_CDATA_SECTION_NODE; pText = pText->next);

        if (pText) {
          CIccUTF16String str((const char*)pText->content);
          pTag->SetText(str.c_str(), (icLanguageCode)(lc>>16), (icCountryCode)(lc & 0xffff));
        }
        else {
          pTag->SetText("");
        }
      }
    }
  }

  m_Dict->push_back(ptr);
}

return true;
4297}


4300bool CIccTagXmlStruct::ToXml(std::string &xml, std::string blanks/* = ""*/)
4301{
std::string info;
char buf[256], fix[256], line[256];
IIccStruct *pStruct = GetStructHandler();

const icChar *structName = ((pStruct != NULL__null) ? pStruct->GetDisplayName() : NULL__null);
blanks += "  ";

 if (structName && strcmp(structName, "privateStruct")) {
   sprintf(line, "<%s> <MemberTags>\n", structName);
 }
 else {
   // print out the struct signature
   sprintf(line, "<privateStruct StructSignature=\"%s\"/> <MemberTags>\n", icFixXml(fix, icGetSigStr(buf, m_sigStructType)));
   structName = "privateStruct";
 }

xml += blanks + line;
TagEntryList::iterator i, j;
std::set<icTagSignature> sigSet;
CIccInfo Fmt;
IccOffsetTagSigMap offsetTags;

for (i=m_ElemEntries->begin(); i!=m_ElemEntries->end(); i++) {
  if (sigSet.find(i->TagInfo.sig)==sigSet.end()) {
    CIccTag *pTag = FindElem(i->TagInfo.sig);

    if (pTag) {
      CIccTagXml *pTagXml = (CIccTagXml*)(pTag->GetExtension());
      if (pTagXml) {
        IccOffsetTagSigMap::iterator prevTag = offsetTags.find(i->TagInfo.offset);
        std::string tagName = ((pStruct!=NULL__null) ? pStruct->GetElemName((icSignature)i->TagInfo.sig) : "");
        if (prevTag == offsetTags.end()) {
          const icChar* tagSig = icGetTagSigTypeName(pTag->GetType());

          if (tagName.size() && strncmp(tagName.c_str(), "PrivateSubTag", 13)) {
            sprintf(line, "  <%s>", icFixXml(fix, tagName.c_str()));
          }
          else {
            sprintf(line, "  <PrivateSubTag TagSignature=\"%s\">", icFixXml(fix, icGetSigStr(buf, i->TagInfo.sig)));
            tagName = "PrivateSubTag";
          }
          xml += blanks + line;

          // PrivateType - a type that does not belong to the list in the icc specs - custom for vendor.
          if (!strcmp("PrivateType", tagSig))
            sprintf(line, " <PrivateType type=\"%s\">\n", icFixXml(fix, icGetSigStr(buf, pTag->GetType())));
          else
            sprintf(line, " <%s>\n", tagSig); //parent node is the tag type

          xml += line;
          j = i;
4353#if 0
          // print out the tag signature (there is at least one)
          sprintf(line, "  <TagSignature>%s</TagSignature>\n", icFixXml(fix, icGetSigStr(buf, i->TagInfo.sig)));
          xml += blanks + line;

          sigSet.insert(i->TagInfo.sig);

          // print out the rest of the tag signatures
          for (j++; j != m_ElemEntries->end(); j++) {
            if (j->pTag == i->pTag || j->TagInfo.offset == i->TagInfo.offset) {
              sprintf(line, "  <TagSignature>%s</TagSignature>\n", icFixXml(fix, icGetSigStr(buf, j->TagInfo.sig)));
              xml += blanks + line;
              sigSet.insert(j->TagInfo.sig);
            }
          }
          // if (pTag->m_nReserved) {
          //   sprintf(line, " Reserved=\"%08x\"", pTag->m_nReserved);
          //   xml += line;
          // }
          // xml += ">\n";
4373#endif
          //convert the rest of the tag to xml
          if (!pTagXml->ToXml(xml, blanks + "    ")) {
            printf("Unable to output sub-tag with type %s\n", icGetSigStr(buf, i->TagInfo.sig));
            return false;
          }
          sprintf(line, "  </%s> </%s>\n", tagSig, tagName.c_str());
          xml += blanks + line;
          offsetTags[i->TagInfo.offset] = i->TagInfo.sig;
        }
        else {
          std::string prevTagName = ((pStruct != NULL__null) ? pStruct->GetElemName(prevTag->second) : "");
          char fix2[200];

          if (tagName.size() && strncmp(tagName.c_str(), "PrivateSubTag", 13))
            sprintf(line, "    <%s SameAs=\"%s\"", icFixXml(fix, tagName.c_str()), icFixXml(fix2, prevTagName.c_str())); //parent node is the tag type
          else
            sprintf(line, "    <PrivateSubTag TagSignature=\"%s\" SameAs=\"%s\"", icFixXml(fix2, icGetSigStr(buf, i->TagInfo.sig)), icFixXml(fix, prevTagName.c_str()));

          xml += line;
          if (prevTagName.size() || !strncmp(prevTagName.c_str(), "PrivateSubTag", 13)) {
            sprintf(line, " SameAsSignature=\"%s\"", icFixXml(fix2, icGetSigStr(buf, prevTag->second)));
            xml += line;
          }

          xml += "/>\n";
        }
      }
      else {
        printf("Non XML tag in list with type %s!\n", icGetSigStr(buf, i->TagInfo.sig));
        return false;
      }
    }
    else {
      printf("Unable to find tag with type %s!\n", icGetSigStr(buf, i->TagInfo.sig));
      return false;
    }
  }
}

xml += blanks + "</MemberTags> </" + structName + ">\n";
return true;
4415}

4417/**
4418******************************************************************************
4419* Name: CIccTagXmlStruct::ParseTag
4420* 
4421* Purpose: This will load from the indicated IO object and associate a tag
4422*  object to a tag directory entry.  Nothing happens if tag directory entry
4423*  is associated with a tag object.
4424* 
4425* Args: 
4426*  pNode - pointer to xmlNode object to parse from
4427* 
4428* Return: 
4429*  true - tag from node successfully parsed,
4430*  false - failure
4431*******************************************************************************
4432*/
4433bool CIccTagXmlStruct::ParseTag(xmlNode *pNode, std::string &parseStr)
4434{
xmlAttr *attr;

if (pNode->type != XML_ELEMENT_NODE) {// || icXmlStrCmp(pNode->name, "Tag")) {
  parseStr += "Invalid Tag Node: ";
  parseStr += (const char *)pNode->name;
  parseStr += "\n";
  return false;
}

CIccTag *pTag = NULL__null;

std::string nodeName = (icChar*)pNode->name;
icSignature sigTag;
if (m_pStruct)
  sigTag = m_pStruct->GetElemSig(nodeName.c_str());
else
  sigTag = 0;

if (sigTag != 0 || nodeName == "PrivateSubTag") { //Parsing of XML tags by name
  if (nodeName == "PrivateSubTag") {
    const char *tagSig = icXmlAttrValue(pNode, "TagSignature", "");
    if (tagSig[0]) {
      sigTag = (icTagSignature)icGetSigVal(tagSig);
    }
    else {
      parseStr += "Invalid TagSignature for PrivateSubTag\n";
      return false;
    }
  }

  const char *sameAs = icXmlAttrValue(pNode, "SameAs", "");

  if (sameAs[0]) {
    icTagSignature sigParentTag = icGetTagNameSig(sameAs);
    if (!strcmp(sameAs, "PrivateSubTag") || sigParentTag == icSigUnknownTag((icTagSignature) 0x3f3f3f3f)) {
      const char *sameAsSig = icXmlAttrValue(pNode, "SameAsSignature", "");
      if (sameAsSig[0]) {
        sigParentTag = (icTagSignature)icGetSigVal(sameAsSig);
      }
      else {
        parseStr += "Invalid SameAsSignature for PrivateSubTag\n";
        return false;
      }
    }
    pTag = this->FindElem(sigParentTag);
    if (pTag) {
      AttachElem(sigTag, pTag);
    }
    else {
      parseStr += "SameAs tag ";
      parseStr += sameAs;
      parseStr += " for ";
      parseStr += nodeName + " does not exist\n";
      return false;
    }

    return true;
  }
  else { //Parse the type node as the first child
    xmlNode *pTypeNode;
    for (pTypeNode = pNode->children; pTypeNode; pTypeNode = pTypeNode->next) {
      if (pTypeNode->type == XML_ELEMENT_NODE) {
        break;
      }
    }

    if (!pTypeNode) {
      parseStr += "No tag type node defined for ";
      parseStr += nodeName;
      parseStr += "\n";
      return false;
    }

    // get the tag type signature
    icTagTypeSignature sigType = icGetTypeNameTagSig((const icChar*)pTypeNode->name);

    if (sigType == icSigUnknownType((icTagTypeSignature) 0x3f3f3f3f)) {
      xmlAttr *attr = icXmlFindAttr(pTypeNode, "type");
      sigType = (icTagTypeSignature)icGetSigVal((icChar*)icXmlAttrValue(attr));
    }

    CIccInfo info;

    // create a tag based on the signature
    pTag = CIccTag::Create(sigType);

    IIccExtensionTag *pExt;

    if (pTag && (pExt = pTag->GetExtension()) && !strcmp(pExt->GetExtClassName(), "CIccTagXml")) {
      CIccTagXml* pXmlTag = (CIccTagXml*)pExt;

      if (pXmlTag->ParseXml(pTypeNode->children, parseStr)) {
        if ((attr = icXmlFindAttr(pTypeNode, "reserved"))) {
          sscanf(icXmlAttrValue(attr), "%u", &pTag->m_nReserved);
        }
        AttachElem(sigTag, pTag);
      }
      else {
        parseStr += "Unable to Parse \"";
        parseStr += (const char*)pTypeNode->name;
        parseStr += "\" (";
        parseStr += nodeName;
        parseStr += ") Tag\n";
        return false;
      }
    }
    else {
      parseStr += "Invalid tag extension for \"";
      parseStr += (const char*)pTypeNode->name;
      parseStr += "\" (";
      parseStr += nodeName;
      parseStr += ") Tag\n";
      return false;
    }
  }
}
else {  //Legacy parsing of XML tags by type
  sigTag = (icTagSignature)0;
  // get the tag type signature
  icTagTypeSignature sigType = icGetTypeNameTagSig(nodeName.c_str());

  if (sigType == icSigUnknownType((icTagTypeSignature) 0x3f3f3f3f)) {
    xmlAttr *attr = icXmlFindAttr(pNode, "type");
    sigType = (icTagTypeSignature)icGetSigVal((icChar*)icXmlAttrValue(attr));
  }

  CIccInfo info;

  // create a tag based on the signature
  pTag = CIccTag::Create(sigType);

  IIccExtensionTag *pExt;

  if (pTag && (pExt = pTag->GetExtension()) && !strcmp(pExt->GetExtClassName(), "CIccTagXml")) {
    CIccTagXml* pXmlTag = (CIccTagXml*)pExt;

    if (pXmlTag->ParseXml(pNode->children, parseStr)) {
      if ((attr = icXmlFindAttr(pNode, "reserved"))) {
        sscanf(icXmlAttrValue(attr), "%u", &pTag->m_nReserved);
      }

      for (xmlNode *tagSigNode = pNode->children; tagSigNode; tagSigNode = tagSigNode->next) {
        if (tagSigNode->type == XML_ELEMENT_NODE && !icXmlStrCmp(tagSigNode->name, "TagSignature")strcmp((const char *)(tagSigNode->name), (const char*)("TagSignature"
))) {
          sigTag = (icTagSignature)icGetSigVal((const icChar*)tagSigNode->children->content);
          AttachElem(sigTag, pTag);
        }
      }
    }
    else {
      parseStr += "Unable to Parse \"";
      parseStr += info.GetTagTypeSigName(sigType);
      parseStr += "\" (";
      parseStr += nodeName;
      parseStr += ") Tag\n";
      return false;
    }
  }
  else {
    parseStr += "Invalid tag extension for \"";
    parseStr += info.GetTagTypeSigName(sigType);
    parseStr += "\" (";
    parseStr += nodeName;
    parseStr += ") Tag\n";
    return false;
  }
}

return true;
4603}


4606bool CIccTagXmlStruct::ParseXml(xmlNode *pNode, std::string &parseStr)
4607{
// parse each tag
xmlNode *tagNode, *firstNode=pNode;
1
'firstNode' initialized here→

for (; pNode; pNode = pNode->next) {
2
←
Assuming pointer value is null→
3
←
Loop condition is false. Execution continues on line 4615→
  if (pNode->type == XML_ELEMENT_NODE)
    break;
}
if (!pNode3.1
'pNode' is null
) {
4
←
Taking true branch→
  parseStr += "Invalid Tag Structure: ";
  parseStr += (const char *)firstNode->name;
5
←
Access to field 'name' results in a dereference of a null pointer (loaded from variable 'firstNode')
  parseStr += "\n";
  return false;
}

std::string nodeName = (icChar*)pNode->name;
icStructSignature sigStruct = CIccStructCreator::GetStructSig(nodeName.c_str());

if (sigStruct) {
  m_sigStructType = sigStruct;
  m_pStruct = CIccStructCreator::CreateStruct(m_sigStructType, this);
  pNode = pNode->children;
}
else {
  tagNode = icXmlFindNode(firstNode, "StructureSignature");
  if (!tagNode) {
    parseStr += "Unable to find StructureSignature\r\n";
    return false;
  }

  if (tagNode->type == XML_ELEMENT_NODE && tagNode->children && tagNode->children->content) {
    m_sigStructType = (icStructSignature)icGetSigVal(tagNode->children ? (const icChar*)tagNode->children->content : "");
    m_pStruct = CIccStructCreator::CreateStruct(m_sigStructType, this);
  }
  else {
    parseStr += "Invalid XNode type for StructureSignature\r\n";
    return false;
  }
}

tagNode = icXmlFindNode(pNode, "MemberTags");
if (!tagNode) {
  parseStr += "Unable to find structure MemberTags\r\n";
  return false;
}

for (tagNode = tagNode->children; tagNode; tagNode = tagNode->next) {
  if (tagNode->type == XML_ELEMENT_NODE) {
    if (!ParseTag(tagNode, parseStr)) {
      parseStr += "Failed to parse tag member (";
      parseStr += (char*)tagNode->name;
      parseStr += ")\r\n";
      return false;
    }
  }
}

return true;
4665}

4667bool CIccTagXmlArray::ToXml(std::string &xml, std::string blanks/* = ""*/)
4668{
std::string info;
char buf[256], fix[256], line[256];

std::string arrayName;
std::string arrayBlanks = "";
bool found = CIccArrayCreator::GetArraySigName(arrayName, m_sigArrayType, false);

if (found) {
  sprintf(line, "<%s> ", arrayName.c_str());
  arrayBlanks = "  ";
}
else {
  // print out the struct signature
  sprintf(line, "<privateArray StructSignature=\"%s\"/> ", icFixXml(fix, icGetSigStr(buf, m_sigArrayType)));
  arrayName = "privateArray";
}

xml += blanks + line + "<ArrayTags>\n";
int i;

for (i=0; i<(int)m_nSize; i++) {
  CIccTag* pTag = m_TagVals[i].ptr;
  if (pTag) {
    CIccTagXml *pTagXml = (CIccTagXml*)(pTag->GetExtension());
    if (pTagXml) {
      const icChar* tagSig = icGetTagSigTypeName(pTag->GetType());

      // PrivateType - a type that does not belong to the list in the icc specs - custom for vendor.
      if ( !strcmp("PrivateType", tagSig) )
        sprintf(line, " <PrivateType type=\"%s\">\n",  icFixXml(fix, icGetSigStr(buf, pTag->GetType())));		
      else
        sprintf(line, " <%s>\n", tagSig); //parent node is the tag type

      xml += blanks + arrayBlanks + line; 				

      //convert the rest of the tag to xml
      if (!pTagXml->ToXml(xml, blanks + arrayBlanks + " ")) {
        printf("Unable to output tag with type %s\n", icGetSigStr(buf, pTag->GetType()));
        return false;
      }
      sprintf(line, " </%s>\n\n",  tagSig);
      xml += blanks + arrayBlanks + line; 	
    }
    else {
      printf("Non XML tag in list with type %s!\n", icGetSigStr(buf, pTag->GetType()));
      return false;
    }
  }
}
xml += blanks + "</ArrayTags> </" + arrayName + ">\n";

return true;
4721}


4724bool CIccTagXmlArray::ParseXml(xmlNode *pNode, std::string &parseStr)
4725{
// parse each tag
xmlNode *tagNode, *indexNode, *firstNode = pNode;;
xmlAttr *attr;

for (; pNode; pNode = pNode->next) {
  if (pNode->type == XML_ELEMENT_NODE)
    break;
}
if (!pNode) {
  parseStr += "Invalid Tag Array: ";
  parseStr += (const char *)firstNode->name;
  parseStr += "\n";
  return false;
}

std::string nodeName = (icChar*)pNode->name;
icArraySignature sigArray = CIccArrayCreator::GetArraySig(nodeName.c_str());

if (sigArray) {
  m_sigArrayType = sigArray;
  m_pArray = CIccArrayCreator::CreateArray(m_sigArrayType, this);
  pNode = pNode->children;
}
else {
  tagNode = icXmlFindNode(firstNode, "ArraySignature");
  if (!tagNode) {
    parseStr += "Unable to find ArraySignature\r\n";
    return false;
  }

  if (tagNode->type == XML_ELEMENT_NODE && tagNode->children && tagNode->children->content) {
    m_sigArrayType = (icArraySignature)icGetSigVal(tagNode->children ? (const icChar*)tagNode->children->content : "");
    m_pArray = CIccArrayCreator::CreateArray(m_sigArrayType, this);
  }
  else {
    parseStr += "Invalid XNode type for ArraySignature\r\n";
    return false;
  }
}

indexNode = icXmlFindNode(pNode, "ArrayTags");
if (!indexNode)
  return false;

int nMaxIndex = 0, n=0;
for (tagNode = indexNode->children; tagNode; tagNode = tagNode->next) {
  if (tagNode->type == XML_ELEMENT_NODE) {
    nMaxIndex++;
  }
}
if (!SetSize(nMaxIndex))
  return false;

n=0; 
for (tagNode = indexNode->children; tagNode; tagNode = tagNode->next) {
  if (tagNode->type == XML_ELEMENT_NODE) {
    CIccTag *pTag = NULL__null;
    icSignature sigTag = (icSignature)0;

    // get the tag signature
    icTagTypeSignature sigType = icGetTypeNameTagSig ((icChar*) tagNode->name);

    if (sigType==icSigUnknownType((icTagTypeSignature) 0x3f3f3f3f)){
      xmlAttr *attr = icXmlFindAttr(pNode, "type");
      sigType = (icTagTypeSignature)icGetSigVal((icChar*) icXmlAttrValue(attr));
    }

    CIccInfo info;

    // create a tag based on the signature
    pTag = CIccTag::Create(sigType);

    IIccExtensionTag *pExt;

    if (pTag && (pExt = pTag->GetExtension()) && !strcmp(pExt->GetExtClassName(), "CIccTagXml")) {
      CIccTagXml* pXmlTag = (CIccTagXml*)pExt;

      if (pXmlTag->ParseXml(tagNode->children, parseStr)) {
        if ((attr=icXmlFindAttr(pNode, "reserved"))) {
          sscanf(icXmlAttrValue(attr), "%u", &pTag->m_nReserved);
        }

        if (!m_TagVals[n].ptr)
          m_TagVals[n].ptr = pTag;
        else {
          parseStr += "Tag Array Index ";
          parseStr += n;
          parseStr += " already filled!\r\n";
          return false;
        }
      }
      else {
        parseStr += "Unable to Parse xml node named  \"";
        parseStr += (icChar*)tagNode->name;
        parseStr += "\"\n\r";
        return false;
      }
    }
    n++;
  }
}

for (n=0; n<(int)m_nSize; n++) {
  if (!m_TagVals[n].ptr) {
    parseStr += "Undefined Array Tag at index ";
    parseStr += n;
    parseStr += "\n";
    return false;
  }
}

return true;
4838}

4840bool CIccTagXmlGamutBoundaryDesc::ToXml(std::string &xml, std::string blanks/* = ""*/)
4841{
std::string info;
char line[256];
int i;

if (m_NumberOfVertices && (m_PCSValues || m_DeviceValues)) {
  xml += blanks + "<Vertices>\n";

  if (m_PCSValues) {
    sprintf(line, " <PCSValues channels=\"%d\">\n", m_nPCSChannels);
    xml += blanks + line;
    CIccFloatArray::DumpArray(xml, blanks+"  ", m_PCSValues, m_NumberOfVertices*m_nPCSChannels, icConvertFloat, 9);
    xml += blanks + " </PCSValues>\n";
  }
  if (m_DeviceValues) {
    sprintf(line, " <DeviceValues channels=\"%d\">\n", m_nDeviceChannels);
    xml += blanks + line;
      CIccFloatArray::DumpArray(xml, blanks+"  ", m_DeviceValues, m_NumberOfVertices*m_nDeviceChannels, icConvertFloat, 8);
    xml += blanks + " </DeviceValues>\n";
  }
  xml += blanks + "</Vertices>\n";
}

if (m_Triangles && m_NumberOfTriangles) {
  xml += blanks + "<Triangles>\n";

  for (i=0; i<m_NumberOfTriangles; i++) {
    sprintf(line, " <T>%u %u %u</T>\n", m_Triangles[i].m_VertexNumbers[0], m_Triangles[i].m_VertexNumbers[1], m_Triangles[i].m_VertexNumbers[2]);
    xml += blanks + line; 
  }

  xml += blanks + "</Triangles>\n";
}

return true;
4876}


4879bool CIccTagXmlGamutBoundaryDesc::ParseXml(xmlNode *pNode, std::string &parseStr)
4880{
// parse each tag
xmlNode *childNode, *subNode;

childNode = icXmlFindNode(pNode, "Vertices");
if (!childNode) {
  parseStr += "Cannot find Vertices\n";
  return false;
}

subNode = icXmlFindNode(childNode->children, "PCSValues");

if (subNode) {
  m_nPCSChannels = atoi(icXmlAttrValue(subNode, "channels", "0"));

  if (!m_nPCSChannels) {
    parseStr += "Bad PCSValues channels\n";
    return false;
  }

  CIccFloatArray vals;
  if (!vals.ParseArray(subNode->children)) {
    parseStr += "Unable to parse GamutBoundaryDesc PCSValues\n";
    return false;
  }

  m_NumberOfVertices = vals.GetSize() / m_nPCSChannels;

  if (m_NumberOfVertices<4) {
    parseStr += "Must have at least 4 PCSValues vertices\n";
    return false;
  }

  m_PCSValues = new icFloatNumber[m_NumberOfVertices * m_nPCSChannels];

  if (!m_PCSValues)
    return false;

  memcpy(m_PCSValues, vals.GetBuf(), m_NumberOfVertices * m_nPCSChannels*sizeof(icFloatNumber));
}
else {
  parseStr += "Cannot find PCSValues\n";
  return false;
}

subNode = icXmlFindNode(childNode->children, "DeviceValues");

if (subNode) {
  m_nDeviceChannels = atoi(icXmlAttrValue(subNode, "channels", "0"));

  if (!m_nDeviceChannels) {
    parseStr += "Bad DeviceValues channels\n";
    return false;
  }

  CIccFloatArray vals;
  if (!vals.ParseArray(subNode->children)) {
    parseStr += "Unable to parse GamutBoundaryDesc DeviceValues\n";
    return false;
  }

  int nVertices = vals.GetSize() / m_nDeviceChannels;

  if (m_NumberOfVertices != nVertices) {
    parseStr += "Number of Device vertices doesn't match PCS verticies\n";
    return false;
  }

  m_DeviceValues = new icFloatNumber[m_NumberOfVertices * m_nDeviceChannels];

  if (!m_DeviceValues)
    return false;

  memcpy(m_DeviceValues, vals.GetBuf(), m_NumberOfVertices * m_nDeviceChannels * sizeof(icFloatNumber));
}
else if (!m_PCSValues)
  m_NumberOfVertices = 0;

childNode = icXmlFindNode(pNode, "Triangles");
if (!childNode) {
  parseStr += "Cannot find Triangles\n";
  return false;
}

int nMaxIndex = 0, n=0;
for (subNode = childNode->children; subNode; subNode = subNode->next) {
  if (subNode->type == XML_ELEMENT_NODE && !strcmp((icChar*)subNode->name, "T")) {
    nMaxIndex++;
  }
}
m_NumberOfTriangles = nMaxIndex;
m_Triangles = new icGamutBoundaryTriangle[m_NumberOfTriangles];

n=0; 
for (subNode = childNode->children; subNode && n<nMaxIndex; subNode = subNode->next) {
  if (subNode->type == XML_ELEMENT_NODE && !strcmp((icChar*)subNode->name, "T")) {
    CIccUInt32Array ids;
    
    if (!ids.ParseArray(subNode->children) || ids.GetSize()!=3) {
      parseStr += "Invalid Triangle entry\n";
      return false;
    }
    icUInt32Number *v = ids.GetBuf();

    m_Triangles[n].m_VertexNumbers[0] = v[0];
    m_Triangles[n].m_VertexNumbers[1] = v[1];
    m_Triangles[n].m_VertexNumbers[2] = v[2];

    n++;
  }
}

return true;
4993}

4995bool CIccTagXmlEmbeddedProfile::ParseXml(xmlNode *pNode, std::string &parseStr)
4996{
// parse each tag
xmlNode *tagNode;

tagNode = icXmlFindNode(pNode, "IccProfile");
if (!tagNode)
  return false;

if (m_pProfile) {
  delete m_pProfile;
}

CIccProfileXml *pProfile = new CIccProfileXml();
m_pProfile = pProfile;

if (!pProfile->ParseXml(tagNode, parseStr)) {
  delete m_pProfile;
  m_pProfile = NULL__null;
  return false;
}
return true;
5017}

5019bool CIccTagXmlEmbeddedProfile::ToXml(std::string &xml, std::string blanks/* = ""*/)
5020{
if (!m_pProfile || strcmp(m_pProfile->GetClassName(), "CIccProfileXml")) {
  return false;
}

CIccProfileXml *pProfile = (CIccProfileXml*)m_pProfile;

return pProfile->ToXmlWithBlanks(xml, blanks);
5028}

5030bool CIccTagXmlEmbeddedHeightImage::ParseXml(xmlNode *pNode, std::string &parseStr)
5031{
// parse tag
xmlNode *tagNode;

tagNode = icXmlFindNode(pNode, "HeightImage");
if (!tagNode)
  return false;

m_nSeamlesIndicator = atoi(icXmlAttrValue(tagNode, "SeamlessIndicator", "0"));
m_nEncodingFormat = (icImageEncodingType)atoi(icXmlAttrValue(tagNode, "EncodingFormat", "0"));
m_fMetersMinPixelValue = (icFloatNumber)atof(icXmlAttrValue(tagNode, "MetersMinPixelValue", "0.0"));
m_fMetersMaxPixelValue = (icFloatNumber)atof(icXmlAttrValue(tagNode, "MetersMaxPixelValue", "0.0"));

xmlNode *pImageNode;
pImageNode = icXmlFindNode(tagNode->children, "Image");

if (pImageNode) {
  const char *filename = icXmlAttrValue(pImageNode, "File");
  if (!filename || !filename[0]) {
    filename = icXmlAttrValue(pImageNode, "Filename");
  }

  // file exists
  if (filename[0]) {
    CIccIO *file = IccOpenFileIO(filename, "rb");
    if (!file) {
      parseStr += "Error! - File '";
      parseStr += filename;
      parseStr += "' not found.\n";
      delete file;
      return false;
    }

    icUInt32Number num = file->GetLength();

    SetSize(num);
    icUInt8Number *dst = GetData(0);
    if (file->Read8(dst, num)!=num) {
      perror("Read-File Error");
      parseStr += "'";
      parseStr += filename;
      parseStr += "' may not be a valid binary file.\n";
      delete file;
      return false;
    }
    delete file;
    return true;
  }
  // no file
  else if (pImageNode->children && pImageNode->children->content){
    unsigned long nSize = icXmlGetHexDataSize((const icChar*)pImageNode->children->content);

    SetSize(nSize);
    if (m_pData) {
      if (icXmlGetHexData(m_pData, (const icChar*)pImageNode->children->content, m_nSize) != m_nSize)
        return false;
    }

    return true;
  }
}
return false;
5093}

5095bool CIccTagXmlEmbeddedHeightImage::ToXml(std::string &xml, std::string blanks/*= ""*/)
5096{
char buf[200];

xml += blanks + "<HeightImage";
sprintf(buf, " SeamlessIndicator=\"%d\"", m_nSeamlesIndicator);
xml += buf;

sprintf(buf, " EncodingFormat=\"%d\"", m_nEncodingFormat);
xml += buf;

sprintf(buf, " MetersMinPixelValue=\"%.12f\"", m_fMetersMinPixelValue);
xml += buf;

sprintf(buf, " MetersMaxPixelValue=\"%.12f\"", m_fMetersMaxPixelValue);
xml += buf;

if (!m_nSize) {
  xml += blanks + "/>\n";
}
else {
  xml += ">\n";
  xml += blanks + " <Image>\n";
  icXmlDumpHexData(xml, blanks + "  ", m_pData, m_nSize);
  xml += blanks + " </Image>\n";
  xml += blanks + "</HeightImage>\n";
}

return true;
5124}

5126bool CIccTagXmlEmbeddedNormalImage::ParseXml(xmlNode *pNode, std::string &parseStr)
5127{
// parse tag
xmlNode *tagNode;

tagNode = icXmlFindNode(pNode, "NormalImage");
if (!tagNode)
  return false;

m_nSeamlesIndicator = atoi(icXmlAttrValue(tagNode, "SeamlessIndicator", "0"));
m_nEncodingFormat = (icImageEncodingType)atoi(icXmlAttrValue(tagNode, "EncodingFormat", "0"));

xmlNode *pImageNode;
pImageNode = icXmlFindNode(tagNode->children, "Image");

if (pImageNode) {
  const char *filename = icXmlAttrValue(pImageNode, "File");
  if (!filename || !filename[0]) {
    filename = icXmlAttrValue(pImageNode, "Filename");
  }

  // file exists
  if (filename[0]) {
    CIccIO *file = IccOpenFileIO(filename, "rb");
    if (!file) {
      parseStr += "Error! - File '";
      parseStr += filename;
      parseStr += "' not found.\n";
      delete file;
      return false;
    }

    icUInt32Number num = file->GetLength();

    SetSize(num);
    icUInt8Number *dst = GetData(0);
    if (file->Read8(dst, num) != num) {
      perror("Read-File Error");
      parseStr += "'";
      parseStr += filename;
      parseStr += "' may not be a valid binary file'.\n";
      delete file;
      return false;
    }
    delete file;
    return true;
  }
  // no file
  else if (pImageNode->children && pImageNode->children->content) {
    unsigned long nSize = icXmlGetHexDataSize((const icChar*)pImageNode->children->content);

    SetSize(nSize);
    if (m_pData) {
      if (icXmlGetHexData(m_pData, (const icChar*)pImageNode->children->content, m_nSize) != m_nSize)
        return false;
    }
    return true;
  }
}
return false;
5186}

5188bool CIccTagXmlEmbeddedNormalImage::ToXml(std::string &xml, std::string blanks/*= ""*/)
5189{
char buf[200];

xml += blanks + "<NormalImage";
sprintf(buf, " SeamlessIndicator=\"%d\"", m_nSeamlesIndicator);
xml += buf;

sprintf(buf, " EncodingFormat=\"%d\"", m_nEncodingFormat);
xml += buf;

if (!m_nSize) {
  xml += blanks + "/>\n";
}
else {
  xml += ">\n";
  xml += blanks + " <Image>\n";
  icXmlDumpHexData(xml, blanks + "  ", m_pData, m_nSize);
  xml += blanks + " </Image>\n";
  xml += blanks + "</NormalImage>\n";
}

return true;
5211}


5214#ifdef USEREFICCMAXNAMESPACE
5215}
5216#endif