// =================================================================================================

// Copyright 2002-2008 Adobe Systems Incorporated

// All Rights Reserved.

//

// NOTICE:  Adobe permits you to use, modify, and distribute this file in accordance with the terms

// of the Adobe license agreement accompanying it.

//

// Adobe patent application tracking #P435, entitled 'Unique markers to simplify embedding data of

// one format in a file with a different format', inventors: Sean Parent, Greg Gilley.

// =================================================================================================

#include "XMP_Environment.h"  // ! This must be the first include!

#include "XMPCore_Impl.hpp"

#include <stdio.h>

#include "XMPMeta.hpp"

#include "XMPIterator.hpp"

#include "XMPUtils.hpp"

#include "XMP_Version.h"

#include "UnicodeInlines.incl_cpp"

#include "UnicodeConversions.hpp"

#include <algorithm>  // For sort and stable_sort.

#if XMP_DebugBuild

  #include <iostream>

#endif

using namespace std;

#if XMP_WinBuild

#ifdef _MSC_VER

  #pragma warning ( disable : 4533 )  // initialization of '...' is skipped by 'goto ...'

  #pragma warning ( disable : 4702 )  // unreachable code

  #pragma warning ( disable : 4800 )  // forcing value to bool 'true' or 'false' (performance warning)

  #pragma warning ( disable : 4996 )  // '...' was declared deprecated

#endif

#endif

// *** Use the XMP_PropIsXyz (Schema, Simple, Struct, Array, ...) macros

// *** Add debug codegen checks, e.g. that typical masking operations really work

// *** Change all uses of strcmp and strncmp to XMP_LitMatch and XMP_LitNMatch

// =================================================================================================

// Local Types and Constants

// =========================

// =================================================================================================

// Static Variables

// ================

XMP_VarString * xdefaultName = 0;

// These are embedded version strings.

const char * kXMPCore_EmbeddedVersion   = kXMPCore_VersionMessage;

const char * kXMPCore_EmbeddedCopyright = kXMPCoreName " " kXMP_CopyrightStr;

// =================================================================================================

// Local Utilities

// ===============

#define IsHexDigit(ch)    ( (('0' <= (ch)) && ((ch) <= '9')) || (('A' <= (ch)) && ((ch) <= 'F')) )

#define HexDigitValue(ch) ( (((ch) - '0') < 10) ? ((ch) - '0') : ((ch) - 'A' + 10) )

static const char * kTenSpaces = "          ";

#define OutProcPadding(pad) { size_t padLen = (pad);                        \

                for ( ; padLen >= 10; padLen -= 10 ) OutProcNChars ( kTenSpaces, 10 ); \

                for ( ; padLen > 0; padLen -= 1 ) OutProcNChars ( " ", 1 ); }

#define OutProcNewline()  { status = (*outProc) ( refCon, "\n", 1 );  if ( status != 0 ) goto EXIT; }

#define OutProcNChars(p,n)  { status = (*outProc) ( refCon, (p), (n) );  if ( status != 0 ) goto EXIT; }

#define OutProcLiteral(lit) { status = (*outProc) ( refCon, (lit), strlen(lit) );  if ( status != 0 ) goto EXIT; }

#define OutProcString(str)  { status = (*outProc) ( refCon, (str).c_str(), (str).size() );  if ( status != 0 ) goto EXIT; }

#define OutProcULong(num) { snprintf ( buffer, sizeof(buffer), "%lu", (num) ); /* AUDIT: Using sizeof for snprintf length is safe */ \

                status = (*outProc) ( refCon, buffer, strlen(buffer) );  if ( status != 0 ) goto EXIT; }

#ifdef __APPLE__

#define OutProcHexInt(num)  { snprintf ( buffer, sizeof(buffer), "%X", (num) ); /* AUDIT: Using sizeof for snprintf length is safe */ \

                status = (*outProc) ( refCon, buffer, strlen(buffer) );  if ( status != 0 ) goto EXIT; }

#else

#define OutProcHexInt(num)  { snprintf ( buffer, sizeof(buffer), "%lX", (num) ); /* AUDIT: Using sizeof for snprintf length is safe */  \

                status = (*outProc) ( refCon, buffer, strlen(buffer) );  if ( status != 0 ) goto EXIT; }

#endif

#define OutProcHexByte(num) { snprintf ( buffer, sizeof(buffer), "%.2X", (num) ); /* AUDIT: Using sizeof for snprintf length is safe */ \

                status = (*outProc) ( refCon, buffer, strlen(buffer) );  if ( status != 0 ) goto EXIT; }

static const char * kIndent = "   ";

#define OutProcIndent(lev)  { for ( size_t i = 0; i < (lev); ++i ) OutProcNChars ( kIndent, 3 ); }

// -------------------------------------------------------------------------------------------------

// DumpClearString

// ---------------

static XMP_Status

DumpClearString ( const XMP_VarString & value, XMP_TextOutputProc outProc, void * refCon )

{

  char buffer [20];

  bool prevNormal;

  XMP_Status status = 0;

  XMP_StringPtr spanStart, spanEnd;

  XMP_StringPtr valueEnd = &value[0] + value.size();

  spanStart = &value[0];

  while ( spanStart < valueEnd ) {

    // Output the next span of regular characters.

    for ( spanEnd = spanStart; spanEnd < valueEnd; ++spanEnd ) {

      if ( (unsigned char)(*spanEnd) > 0x7F ) break;

      if ( (*spanEnd < 0x20) && (*spanEnd != kTab) && (*spanEnd != kLF) ) break;

    }

    if ( spanStart != spanEnd ) status = (*outProc) ( refCon,  spanStart, (spanEnd-spanStart) );

    if ( status != 0 ) break;

    spanStart = spanEnd;

    // Output the next span of irregular characters.

    prevNormal = true;

    for ( spanEnd = spanStart; spanEnd < valueEnd; ++spanEnd ) {

      if ( ((0x20 <= *spanEnd) && ((unsigned char)(*spanEnd) <= 0x7F)) || (*spanEnd == kTab) || (*spanEnd == kLF) ) break;

      char space = ' ';

      if ( prevNormal ) space = '<';

      status = (*outProc) ( refCon, &space, 1 );

      if ( status != 0 ) break;

      OutProcHexByte ( *spanEnd );

      prevNormal = false;

    }

    if ( ! prevNormal ) {

      status = (*outProc) ( refCon, ">", 1 );

      if ( status != 0 ) return status;

    }

    spanStart = spanEnd;

  }

EXIT: 

  return status;

}  // DumpClearString

// -------------------------------------------------------------------------------------------------

// DumpStringMap

// -------------

static XMP_Status

DumpStringMap ( const XMP_StringMap & map, XMP_StringPtr label, XMP_TextOutputProc outProc, void * refCon )

{

  XMP_Status      status;

  XMP_cStringMapPos currPos;

  XMP_cStringMapPos endPos = map.end();

  size_t maxLen = 0;

  for ( currPos = map.begin(); currPos != endPos; ++currPos ) {

    size_t currLen = currPos->first.size();

    if ( currLen > maxLen ) maxLen = currLen;

  }

  OutProcNewline();

  OutProcLiteral ( label );

  OutProcNewline();

  for ( currPos = map.begin(); currPos != endPos; ++currPos ) {

    OutProcNChars ( "  ", 2 );

    DumpClearString ( currPos->first, outProc, refCon );

    OutProcPadding ( maxLen - currPos->first.size() );

    OutProcNChars ( " => ", 4 );

    DumpClearString ( currPos->second, outProc, refCon );

    OutProcNewline();

  }

EXIT:

  return status;

}  // DumpStringMap

// -------------------------------------------------------------------------------------------------

// DumpNodeOptions

// ---------------

static XMP_Status

DumpNodeOptions ( XMP_OptionBits   options,

          XMP_TextOutputProc outProc,

          void *       refCon )

{

  XMP_Status  status;

  char    buffer [32];  // Decimal of a 64 bit int is at most about 20 digits.

  static const char * optNames[] = { " schema",   // 0x8000_0000

                     " ?30",

                     " ?29",

                     " -COMMAS-",

                     " ?27",      // 0x0800_0000

                     " ?26",

                     " ?25",

                     " ?24",

                     " ?23",      // 0x0080_0000

                     " isStale",

                     " isDerived",

                     " isStable",

                     " ?19",      // 0x0008_0000

                     " isInternal",

                     " hasAliases",

                     " isAlias",

                     " -AFTER-",    // 0x0000_8000

                     " -BEFORE-",

                     " isCompact",

                     " isLangAlt",

                     " isAlt",    // 0x0000_0800

                     " isOrdered",

                     " isArray",

                     " isStruct",

                     " hasType",    // 0x0000_0080

                     " hasLang",

                     " isQual",

                     " hasQual",

                     " ?3",     // 0x0000_0008

                     " ?2",

                     " URI",

                     " ?0" };

  if ( options == 0 ) {

    OutProcNChars ( "(0x0)", 5 );

  } else {

    OutProcNChars ( "(0x", 3 );

    OutProcHexInt ( options );

    OutProcNChars ( " :", 2 );

    XMP_OptionBits mask = 0x80000000;

    for ( int b = 0; b < 32; ++b ) {

      if ( options & mask ) OutProcLiteral ( optNames[b] );

      mask = mask >> 1;

    }

    OutProcNChars ( ")", 1 );

  }

EXIT:

  return status;

}  // DumpNodeOptions

// -------------------------------------------------------------------------------------------------

// DumpPropertyTree

// ----------------

// *** Extract the validation code into a separate routine to call on exit in debug builds.

static XMP_Status

DumpPropertyTree ( const XMP_Node *   currNode,

           int          indent,

           size_t       itemIndex,

           XMP_TextOutputProc outProc,

           void *       refCon )

{

  XMP_Status  status;

  char    buffer [32];  // Decimal of a 64 bit int is at most about 20 digits.

  OutProcIndent ( (size_t)indent );

  if ( itemIndex == 0 ) {

    if ( currNode->options & kXMP_PropIsQualifier ) OutProcNChars ( "? ", 2 );

    DumpClearString ( currNode->name, outProc, refCon );

  } else {

    OutProcNChars ( "[", 1 );

    OutProcULong ( static_cast<unsigned long>(itemIndex) );

    OutProcNChars ( "]", 1 );

  }

  if ( ! (currNode->options & kXMP_PropCompositeMask) ) {

    OutProcNChars ( " = \"", 4 );

    DumpClearString ( currNode->value, outProc, refCon );

    OutProcNChars ( "\"", 1 );

  }

  if ( currNode->options != 0 ) {

    OutProcNChars ( "  ", 2 );

    status = DumpNodeOptions ( currNode->options, outProc, refCon );

    if ( status != 0 ) goto EXIT;

  }

  if ( currNode->options & kXMP_PropHasLang ) {

    if ( currNode->qualifiers.empty() || (currNode->qualifiers[0]->name != "xml:lang") ) {

      OutProcLiteral ( "  ** bad lang flag **" );

    }

  }

  // *** Check rdf:type also.

  if ( ! (currNode->options & kXMP_PropCompositeMask) ) {

    if ( ! currNode->children.empty() ) OutProcLiteral ( "  ** bad children **" );

  } else if ( currNode->options & kXMP_PropValueIsArray ) {

    if ( currNode->options & kXMP_PropValueIsStruct ) OutProcLiteral ( "  ** bad comp flags **" );

  } else if ( (currNode->options & kXMP_PropCompositeMask) != kXMP_PropValueIsStruct ) {

    OutProcLiteral ( "  ** bad comp flags **" );

  }

  #if 0 // *** XMP_DebugBuild

    if ( (currNode->_namePtr != currNode->name.c_str()) ||

       (currNode->_valuePtr != currNode->value.c_str()) ) OutProcLiteral ( "  ** bad debug string **" );

  #endif

  OutProcNewline();

  for ( size_t qualNum = 0, qualLim = currNode->qualifiers.size(); qualNum < qualLim; ++qualNum ) {

    const XMP_Node * currQual = currNode->qualifiers[qualNum];

    if ( currQual->parent != currNode ) OutProcLiteral ( "** bad parent link => " );

    if ( currQual->name == kXMP_ArrayItemName ) OutProcLiteral ( "** bad qual name => " );

    if ( ! (currQual->options & kXMP_PropIsQualifier) ) OutProcLiteral ( "** bad qual flag => " );

    if ( currQual->name == "xml:lang" ) {

      if ( (qualNum != 0) || (! (currNode->options & kXMP_PropHasLang)) ) OutProcLiteral ( "** bad lang qual => " );

    }

    status = DumpPropertyTree ( currQual, indent+2, 0, outProc, refCon );

    if ( status != 0 ) goto EXIT;

  }

  for ( size_t childNum = 0, childLim = currNode->children.size(); childNum < childLim; ++childNum ) {

    const XMP_Node * currChild = currNode->children[childNum];

    if ( currChild->parent != currNode ) OutProcLiteral ( "** bad parent link => " );

    if ( currChild->options & kXMP_PropIsQualifier ) OutProcLiteral ( "** bad qual flag => " );

    if ( currNode->options & kXMP_PropValueIsArray ) {

      itemIndex = childNum+1;

      if ( currChild->name != kXMP_ArrayItemName ) OutProcLiteral ( "** bad item name => " );

    } else {

      itemIndex = 0;

      if ( currChild->name == kXMP_ArrayItemName ) OutProcLiteral ( "** bad field name => " );

    }

    status = DumpPropertyTree ( currChild, indent+1, itemIndex, outProc, refCon );

    if ( status != 0 ) goto EXIT;

  }

EXIT:

  return status;

}  // DumpPropertyTree

// -------------------------------------------------------------------------------------------------

// DumpXMLTree

// -----------

#if DumpXMLParseTree

static inline void PutHexByte ( FILE * log, unsigned char ch )

{

  fprintf ( log, "\\x" );

  if ( ch < 0x10 ) {

    fprintf ( log, "%c", kHexDigits[ch] );

  } else {

    fprintf ( log, "%c%c", kHexDigits[ch>>4], kHexDigits[ch&0xF] );

  }

} // PutHexByte

// -------------------------------------------------------------------------------------------------

static void PutClearString ( FILE * log, const std::string & str )

{

  for ( size_t i = 0; i != str.size(); ++i ) {

    unsigned char ch = str[i];

    if ( (0x20 <= ch) && (ch <= 0x7F) ) {

      fprintf ( log, "%c", ch );

    } else {

      PutHexByte ( log, ch );

    }

  }

} // PutClearString

// -------------------------------------------------------------------------------------------------

static void DumpXMLTree ( FILE * log, const XML_Node & node, int indent )

{

  size_t i;

  #if 0 // *** XMP_DebugBuild

    if ( (node._namePtr != node.name.c_str()) ||

       (node._valuePtr != node.value.c_str()) ) fprintf ( log, "*** bad debug string ***\n" );

  #endif

  for ( i = 0; i != (size_t)indent; ++i ) fprintf ( log, "  " );

  switch ( node.kind ) {

    case kRootNode :

      fprintf ( log, "\nStart of XML tree dump\n\n" );

      if ( (indent != 0) || (! node.attrs.empty()) ||

         (! node.ns.empty()) || (! node.name.empty()) || (!node.value.empty()) ) fprintf ( log, " ** invalid root ** \n" );

      for ( i = 0; i < node.children.size(); ++i ) {

        XMP_Uns8 kind = node.children[i]->kind;

        if ( (kind == kRootNode) || (kind == kAttrNode) ) fprintf ( log, " ** invalid child ** \n" );

        DumpXMLTree ( log, *node.children[i], indent+1 );

      }

      fprintf ( log, "\nEnd of XML tree dump\n" );

      break;

    case kElemNode :

      fprintf ( log, "Elem %s", node.name.c_str() );

      if ( indent == 0 ) fprintf ( log, " ** invalid elem ** " );

      if ( ! node.ns.empty() ) fprintf ( log, " @ %s", node.ns.c_str() );

      fprintf ( log, "\n" );

      for ( i = 0; i < node.attrs.size(); ++i ) {

        XMP_Uns8 kind = node.attrs[i]->kind;

        if ( kind != kAttrNode ) fprintf ( log, " ** invalid attr ** \n" );

        DumpXMLTree ( log, *node.attrs[i], indent+2 );

      }

      for ( i = 0; i < node.children.size(); ++i ) {

        XMP_Uns8 kind = node.children[i]->kind;

        if ( (kind == kRootNode) || (kind == kAttrNode) ) fprintf ( log, " ** invalid child ** \n" );

        DumpXMLTree ( log, *node.children[i], indent+1 );

      }

      break;

    case kAttrNode :

      fprintf ( log, "Attr %s", node.name.c_str() );

      if ( (indent == 0) || node.name.empty() || (! node.attrs.empty()) || (! node.children.empty()) ) fprintf ( log, " ** invalid attr ** " );

      fprintf ( log, " = \"" );

      PutClearString ( log, node.value );

      fprintf ( log, "\"" );

      if ( ! node.ns.empty() ) fprintf ( log, " @ %s", node.ns.c_str() );

      fprintf ( log, "\n" );

      break;

    case kCDataNode :

      if ( (indent == 0) || (! node.ns.empty()) || (! node.name.empty()) ||

         (! node.attrs.empty()) || (! node.children.empty()) ) fprintf ( log, " ** invalid cdata ** \n" );

      fprintf ( log, "\"" );

      PutClearString ( log, node.value );

      fprintf ( log, "\"\n" );

      break;

    case kPINode :

      fprintf ( log, "PI %s", node.name.c_str() );

      if ( (indent == 0) || node.name.empty() || (! node.children.empty()) ) fprintf ( log, " ** invalid pi ** \n" );

      if ( ! node.value.empty() ) {

        fprintf ( log, " <? " );

        PutClearString ( log, node.value );

        fprintf ( log, " ?>" );

      }

      fprintf ( log, "\n" );

      break;

  }

} // DumpXMLTree

#endif  // DumpXMLParseTree

// -------------------------------------------------------------------------------------------------

// CompareNodeNames

// ----------------

//

// Comparison routine for sorting XMP nodes by name. The name "xml:lang" is less than anything else,

// and "rdf:type" is less than anything except "xml:lang". This preserves special rules for qualifiers.

static bool

CompareNodeNames ( XMP_Node * left, XMP_Node * right )

{

  if ( left->name  == "xml:lang" ) return true;

  if ( right->name == "xml:lang" ) return false;

  if ( left->name  == "rdf:type" ) return true;

  if ( right->name == "rdf:type" ) return false;

  return ( left->name < right->name );

}  // CompareNodeNames

// -------------------------------------------------------------------------------------------------

// CompareNodeValues

// -----------------

//

// Comparison routine for sorting XMP nodes by value.

static bool

CompareNodeValues ( XMP_Node * left, XMP_Node * right )

{

  if ( XMP_PropIsSimple ( left->options ) && XMP_PropIsSimple ( right->options ) ) {

    return ( left->value < right->value );

  }

  XMP_OptionBits leftForm  = left->options & kXMP_PropCompositeMask;

  XMP_OptionBits rightForm = right->options & kXMP_PropCompositeMask;

  return ( leftForm < rightForm );

}  // CompareNodeValues

// -------------------------------------------------------------------------------------------------

// CompareNodeLangs

// ----------------

//

// Comparison routine for sorting XMP nodes by xml:lang qualifier. An "x-default" value is less than

// any other language.

static bool

CompareNodeLangs ( XMP_Node * left, XMP_Node * right )

{

  if ( left->qualifiers.empty()  || (left->qualifiers[0]->name  != "xml:lang") ) return false;

  if ( right->qualifiers.empty() || (right->qualifiers[0]->name != "xml:lang") ) return false;

  if ( left->qualifiers[0]->value  == "x-default" ) return true;

  if ( right->qualifiers[0]->value == "x-default" ) return false;

  return ( left->qualifiers[0]->value < right->qualifiers[0]->value );

}  // CompareNodeLangs

// -------------------------------------------------------------------------------------------------

// SortWithinOffspring

// -------------------

//

// Sort one level down, within the elements of a node vector. This sorts the qualifiers of each

// node. If the node is a struct it sorts the fields by names. If the node is an unordered array it

// sorts the elements by value. If the node is an AltText array it sorts the elements by language.

static void

SortWithinOffspring ( XMP_NodeOffspring & nodeVec )

{

  for ( size_t i = 0, limit = nodeVec.size(); i < limit; ++i ) {

    XMP_Node * currPos = nodeVec[i];

    if ( ! currPos->qualifiers.empty() ) {

      sort ( currPos->qualifiers.begin(), currPos->qualifiers.end(), CompareNodeNames );

      SortWithinOffspring ( currPos->qualifiers );

    }

    if ( ! currPos->children.empty() ) {

      if ( XMP_PropIsStruct ( currPos->options ) || XMP_NodeIsSchema ( currPos->options ) ) {

        sort ( currPos->children.begin(), currPos->children.end(), CompareNodeNames );

      } else if ( XMP_PropIsArray ( currPos->options ) ) {

        if ( XMP_ArrayIsUnordered ( currPos->options ) ) {

          stable_sort ( currPos->children.begin(), currPos->children.end(), CompareNodeValues );

        } else if ( XMP_ArrayIsAltText ( currPos->options ) ) {

          sort ( currPos->children.begin(), currPos->children.end(), CompareNodeLangs );

        }

      }

      SortWithinOffspring ( currPos->children );

    }

  }

}  // SortWithinOffspring

// =================================================================================================

// Constructors

// ============

XMPMeta::XMPMeta() : clientRefs(0), prevTkVer(0), tree(XMP_Node(0,"",0)), xmlParser(0)

{

  // Nothing more to do, clientRefs is incremented in wrapper.

  #if XMP_TraceCTorDTor

    printf ( "Default construct XMPMeta @ %.8X\n", this );

  #endif

}  // XMPMeta

// -------------------------------------------------------------------------------------------------

XMPMeta::~XMPMeta() RELEASE_NO_THROW

{

  #if XMP_TraceCTorDTor

    printf ( "Destruct XMPMeta @ %.8X\n", this );

  #endif

  XMP_Assert ( this->clientRefs <= 0 );

  if ( xmlParser != 0 ) delete ( xmlParser );

  xmlParser = 0;

}  // ~XMPMeta

// =================================================================================================

// Class Static Functions

// ======================

//

//

// =================================================================================================

// -------------------------------------------------------------------------------------------------

// GetVersionInfo

// --------------

/* class-static */ void

XMPMeta::GetVersionInfo ( XMP_VersionInfo * info )

{

  memset ( info, 0, sizeof(*info) );  // AUDIT: Safe, using sizeof the destination.

  XMP_Assert ( sizeof(*info) == sizeof(XMP_VersionInfo) );

  info->major   = XMP_API_VERSION_MAJOR;

  info->minor   = XMP_API_VERSION_MINOR;

  info->micro   = XMP_API_VERSION_MICRO;

  info->isDebug = kXMPCore_DebugFlag;

  info->flags   = 0;  // ! None defined yet.

  info->message = kXMPCore_VersionMessage;

}  // GetVersionInfo

// -------------------------------------------------------------------------------------------------

// Initialize

// ----------

/* class-static */ bool

XMPMeta::Initialize()

{

  // Allocate and initialize static objects.

  ++sXMP_InitCount;

  if ( sXMP_InitCount > 1 ) return true;

  #if TraceXMPCalls

    // xmpOut = fopen ( "xmp.out", "w" ); // Coordinate with client glue in WXMP_Common.hpp

    fprintf ( xmpOut, "XMP initializing\n" ); fflush ( xmpOut );

  #endif

  sExceptionMessage = new XMP_VarString();

  XMP_InitMutex ( &sXMPCoreLock );

    sOutputNS  = new XMP_VarString;

    sOutputStr = new XMP_VarString;

  xdefaultName = new XMP_VarString ( "x-default" );

  sNamespaceURIToPrefixMap  = new XMP_StringMap;

  sNamespacePrefixToURIMap  = new XMP_StringMap;

  sRegisteredAliasMap     = new XMP_AliasMap;

  InitializeUnicodeConversions();

  // Register standard namespaces and aliases.

  RegisterNamespace ( kXMP_NS_XML, "xml" );

  RegisterNamespace ( kXMP_NS_RDF, "rdf" );

  RegisterNamespace ( kXMP_NS_DC, "dc" );

  RegisterNamespace ( kXMP_NS_XMP, "xmp" );

  RegisterNamespace ( kXMP_NS_PDF, "pdf" );

  RegisterNamespace ( kXMP_NS_Photoshop, "photoshop" );

  RegisterNamespace ( kXMP_NS_PSAlbum, "album" );

  RegisterNamespace ( kXMP_NS_EXIF, "exif" );

  RegisterNamespace ( kXMP_NS_EXIF_Aux, "aux" );

  RegisterNamespace ( kXMP_NS_TIFF, "tiff" );

  RegisterNamespace ( kXMP_NS_PNG, "png" );

  RegisterNamespace ( kXMP_NS_JPEG, "jpeg" );

  RegisterNamespace ( kXMP_NS_JP2K, "jp2k" );

  RegisterNamespace ( kXMP_NS_CameraRaw, "crs" );

  RegisterNamespace ( kXMP_NS_ASF, "asf" );

  RegisterNamespace ( kXMP_NS_WAV, "wav" );

  RegisterNamespace ( kXMP_NS_AdobeStockPhoto, "bmsp" );

  RegisterNamespace ( kXMP_NS_CreatorAtom, "creatorAtom" );

  RegisterNamespace ( kXMP_NS_XMP_Rights, "xmpRights" );

  RegisterNamespace ( kXMP_NS_XMP_MM, "xmpMM" );

  RegisterNamespace ( kXMP_NS_XMP_BJ, "xmpBJ" );

  RegisterNamespace ( kXMP_NS_XMP_Note, "xmpNote" );

  RegisterNamespace ( kXMP_NS_DM, "xmpDM" );

  RegisterNamespace ( kXMP_NS_XMP_Text, "xmpT" );

  RegisterNamespace ( kXMP_NS_XMP_PagedFile, "xmpTPg" );

  RegisterNamespace ( kXMP_NS_XMP_Graphics, "xmpG" );

  RegisterNamespace ( kXMP_NS_XMP_Image, "xmpGImg" );

  RegisterNamespace ( kXMP_NS_XMP_Font, "stFnt" );

  RegisterNamespace ( kXMP_NS_XMP_Dimensions, "stDim" );

  RegisterNamespace ( kXMP_NS_XMP_ResourceEvent, "stEvt" );

  RegisterNamespace ( kXMP_NS_XMP_ResourceRef, "stRef" );

  RegisterNamespace ( kXMP_NS_XMP_ST_Version, "stVer" );

  RegisterNamespace ( kXMP_NS_XMP_ST_Job, "stJob" );

  RegisterNamespace ( kXMP_NS_XMP_ManifestItem, "stMfs" );

  RegisterNamespace ( kXMP_NS_XMP_IdentifierQual, "xmpidq" );

  RegisterNamespace ( kXMP_NS_IPTCCore, "Iptc4xmpCore" );

  RegisterNamespace ( kXMP_NS_DICOM, "DICOM" );

  RegisterNamespace ( kXMP_NS_PDFA_Schema, "pdfaSchema" );

  RegisterNamespace ( kXMP_NS_PDFA_Property, "pdfaProperty" );

  RegisterNamespace ( kXMP_NS_PDFA_Type, "pdfaType" );

  RegisterNamespace ( kXMP_NS_PDFA_Field, "pdfaField" );

  RegisterNamespace ( kXMP_NS_PDFA_ID, "pdfaid" );

  RegisterNamespace ( kXMP_NS_PDFA_Extension, "pdfaExtension" );

  RegisterNamespace ( kXMP_NS_PDFX, "pdfx" );

  RegisterNamespace ( kXMP_NS_PDFX_ID, "pdfxid" );

  RegisterNamespace ( "adobe:ns:meta/", "x" );

  RegisterNamespace ( "http://ns.adobe.com/iX/1.0/", "iX" );

// 06-Oct-07, ahu: Do not use aliases. They result in unexpected behaviour.

//  XMPMeta::RegisterStandardAliases ( "" );

  // Initialize the other core classes.

  if ( ! XMPIterator::Initialize() ) XMP_Throw ( "Failure from XMPIterator::Initialize", kXMPErr_InternalFailure );

  if ( ! XMPUtils::Initialize() ) XMP_Throw ( "Failure from XMPUtils::Initialize", kXMPErr_InternalFailure );

  // Do miscelaneous semantic checks of types and arithmetic.

  XMP_Assert ( sizeof(XMP_Int8) == 1 );

  XMP_Assert ( sizeof(XMP_Int16) == 2 );

  XMP_Assert ( sizeof(XMP_Int32) == 4 );

  XMP_Assert ( sizeof(XMP_Int64) == 8 );

  XMP_Assert ( sizeof(XMP_Uns8) == 1 );

  XMP_Assert ( sizeof(XMP_Uns16) == 2 );

  XMP_Assert ( sizeof(XMP_Uns32) == 4 );

  XMP_Assert ( sizeof(XMP_Uns64) == 8 );

  XMP_Assert ( sizeof(XMP_OptionBits) == 4 ); // Check that option masking work on all 32 bits.

  XMP_OptionBits flag = ~0;

  XMP_Assert ( flag == (XMP_OptionBits)(-1L) );

  XMP_Assert ( (flag ^ kXMP_PropHasLang) == 0xFFFFFFBFUL );

  XMP_Assert ( (flag & ~kXMP_PropHasLang) == 0xFFFFFFBFUL );

  XMP_OptionBits opt1 = 0;  // Check the general option bit macros.

  XMP_OptionBits opt2 = flag;

  XMP_SetOption ( opt1, kXMP_PropValueIsArray );

  XMP_ClearOption ( opt2, kXMP_PropValueIsArray );

  XMP_Assert ( opt1 == ~opt2 );

  XMP_Assert ( XMP_TestOption ( opt1, kXMP_PropValueIsArray ) );

  XMP_Assert ( ! XMP_TestOption ( opt2, kXMP_PropValueIsArray ) );

  XMP_Assert ( XMP_PropIsSimple ( ~kXMP_PropCompositeMask ) );  // Check the special option bit macros.

  XMP_Assert ( ! XMP_PropIsSimple ( kXMP_PropValueIsStruct ) );

  XMP_Assert ( ! XMP_PropIsSimple ( kXMP_PropValueIsArray ) );

  XMP_Assert ( XMP_PropIsStruct ( kXMP_PropValueIsStruct ) );

  XMP_Assert ( XMP_PropIsArray  ( kXMP_PropValueIsArray ) );

  XMP_Assert ( ! XMP_PropIsStruct ( ~kXMP_PropValueIsStruct ) );

  XMP_Assert ( ! XMP_PropIsArray  ( ~kXMP_PropValueIsArray ) );

  XMP_Assert ( XMP_ArrayIsUnordered ( ~kXMP_PropArrayIsOrdered ) );

  XMP_Assert ( XMP_ArrayIsOrdered   ( kXMP_PropArrayIsOrdered ) );

  XMP_Assert ( XMP_ArrayIsAlternate ( kXMP_PropArrayIsAlternate ) );

  XMP_Assert ( XMP_ArrayIsAltText   ( kXMP_PropArrayIsAltText ) );

  XMP_Assert ( ! XMP_ArrayIsUnordered ( kXMP_PropArrayIsOrdered ) );

  XMP_Assert ( ! XMP_ArrayIsOrdered   ( ~kXMP_PropArrayIsOrdered ) );

  XMP_Assert ( ! XMP_ArrayIsAlternate ( ~kXMP_PropArrayIsAlternate ) );

  XMP_Assert ( ! XMP_ArrayIsAltText   ( ~kXMP_PropArrayIsAltText ) );

  XMP_Assert ( XMP_PropHasQualifiers ( kXMP_PropHasQualifiers ) );

  XMP_Assert ( XMP_PropIsQualifier   ( kXMP_PropIsQualifier ) );

  XMP_Assert ( XMP_PropHasLang       ( kXMP_PropHasLang ) );

  XMP_Assert ( ! XMP_PropHasQualifiers ( ~kXMP_PropHasQualifiers ) );

  XMP_Assert ( ! XMP_PropIsQualifier   ( ~kXMP_PropIsQualifier ) );

  XMP_Assert ( ! XMP_PropHasLang       ( ~kXMP_PropHasLang ) );

  XMP_Assert ( XMP_NodeIsSchema ( kXMP_SchemaNode ) );

  XMP_Assert ( XMP_PropIsAlias  ( kXMP_PropIsAlias ) );

  XMP_Assert ( ! XMP_NodeIsSchema ( ~kXMP_SchemaNode ) );

  XMP_Assert ( ! XMP_PropIsAlias  ( ~kXMP_PropIsAlias ) );

  #if 0 // Generally off, enable to hand check generated code.

    extern XMP_OptionBits opt3, opt4;

    if ( XMP_TestOption ( opt3, kXMP_PropValueIsArray ) ) opt4 = opt3;

    if ( ! XMP_TestOption ( opt3, kXMP_PropValueIsStruct ) ) opt4 = opt3;

    static bool ok1 = XMP_TestOption ( opt4, kXMP_PropValueIsArray );

    static bool ok2 = ! XMP_TestOption ( opt4, kXMP_PropValueIsStruct );

  #endif

  // Make sure the embedded info strings are referenced and kept.

  if ( (kXMPCore_EmbeddedVersion[0] == 0) || (kXMPCore_EmbeddedCopyright[0] == 0) ) return false;

  return true;

}  // Initialize

// -------------------------------------------------------------------------------------------------

// Terminate

// ---------

#define EliminateGlobal(g) delete ( g ); g = 0

/* class-static */ void

XMPMeta::Terminate() RELEASE_NO_THROW

{

  --sXMP_InitCount;

  if ( sXMP_InitCount > 0 ) return;

  #if TraceXMPCalls

    fprintf ( xmpOut, "XMP terminating\n" ); fflush ( xmpOut );

    // fclose ( xmpOut ); // Coordinate with fopen in XMPMeta::Initialize.

  #endif

  XMPIterator::Terminate();

  XMPUtils::Terminate();

  EliminateGlobal ( sNamespaceURIToPrefixMap );

  EliminateGlobal ( sNamespacePrefixToURIMap );

  EliminateGlobal ( sRegisteredAliasMap );

    EliminateGlobal ( xdefaultName );

    EliminateGlobal ( sOutputNS );

    EliminateGlobal ( sOutputStr );

  EliminateGlobal ( sExceptionMessage );

  XMP_TermMutex ( sXMPCoreLock );

}  // Terminate

// -------------------------------------------------------------------------------------------------

// Unlock

// ------

/* class-static */ void

XMPMeta::Unlock ( XMP_OptionBits options )

{

  UNUSED(options);

    #if TraceXMPLocking

      fprintf ( xmpOut, "  Unlocking XMP toolkit, count = %d\n", sLockCount ); fflush ( xmpOut );

  #endif

    --sLockCount;

    XMP_Assert ( sLockCount == 0 );

  XMP_ExitCriticalRegion ( sXMPCoreLock );

}  // Unlock

// -------------------------------------------------------------------------------------------------

// UnlockObject

// ------------

void

XMPMeta::UnlockObject ( XMP_OptionBits options ) const

{

  UNUSED(options);

  XMPMeta::Unlock ( 0 );

}  // UnlockObject

// -------------------------------------------------------------------------------------------------

// DumpNamespaces

// --------------

//

// Dump the prefix to URI map (easier to read) and verify that both are consistent and legit.

// *** Should put checks in a separate routine for regular calling in debug builds.

/* class-static */ XMP_Status

XMPMeta::DumpNamespaces ( XMP_TextOutputProc outProc,

                          void *             refCon )

{

  XMP_Assert ( outProc != 0 );  // ! Enforced by wrapper.

  XMP_Status status = 0;

  XMP_StringMapPos p2uEnd = sNamespacePrefixToURIMap->end();  // ! Move up to avoid gcc complaints.

  XMP_StringMapPos u2pEnd = sNamespaceURIToPrefixMap->end();

  status = DumpStringMap ( *sNamespacePrefixToURIMap, "Dumping namespace prefix to URI map", outProc, refCon );

  if ( status != 0 ) goto EXIT;

  if ( sNamespacePrefixToURIMap->size() != sNamespaceURIToPrefixMap->size() ) {

    OutProcLiteral ( "** bad namespace map sizes **" );

    XMP_Throw ( "Fatal namespace map problem", kXMPErr_InternalFailure );

  }

  for ( XMP_StringMapPos nsLeft = sNamespacePrefixToURIMap->begin(); nsLeft != p2uEnd; ++nsLeft ) {

    XMP_StringMapPos nsOther = sNamespaceURIToPrefixMap->find ( nsLeft->second );

    if ( (nsOther == u2pEnd) || (nsLeft != sNamespacePrefixToURIMap->find ( nsOther->second )) ) {

      OutProcLiteral ( "  ** bad namespace URI **  " );

      DumpClearString ( nsLeft->second, outProc, refCon );

      goto FAILURE;

    }

    for ( XMP_StringMapPos nsRight = nsLeft; nsRight != p2uEnd; ++nsRight ) {

      if ( nsRight == nsLeft ) continue; // ! Can't start at nsLeft+1, no operator+!

      if ( nsLeft->second == nsRight->second ) {

        OutProcLiteral ( "  ** duplicate namespace URI **  " );

        DumpClearString ( nsLeft->second, outProc, refCon );

        goto FAILURE;

      }

    }

  }

  for ( XMP_StringMapPos nsLeft = sNamespaceURIToPrefixMap->begin(); nsLeft != u2pEnd; ++nsLeft ) {

    XMP_StringMapPos nsOther = sNamespacePrefixToURIMap->find ( nsLeft->second );

    if ( (nsOther == p2uEnd) || (nsLeft != sNamespaceURIToPrefixMap->find ( nsOther->second )) ) {

      OutProcLiteral ( "  ** bad namespace prefix **  " );

      DumpClearString ( nsLeft->second, outProc, refCon );

      goto FAILURE;

    }

    for ( XMP_StringMapPos nsRight = nsLeft; nsRight != u2pEnd; ++nsRight ) {

      if ( nsRight == nsLeft ) continue; // ! Can't start at nsLeft+1, no operator+!

      if ( nsLeft->second == nsRight->second ) {

        OutProcLiteral ( "  ** duplicate namespace prefix **  " );

        DumpClearString ( nsLeft->second, outProc, refCon );

        goto FAILURE;

      }

    }

  }

EXIT:

  return status;

FAILURE:

  OutProcNewline();

  (void) DumpStringMap ( *sNamespaceURIToPrefixMap, "Dumping namespace URI to prefix map", outProc, refCon );

  XMP_Throw ( "Fatal namespace map problem", kXMPErr_InternalFailure );

  return 0;

}  // DumpNamespaces

// -------------------------------------------------------------------------------------------------

// DumpAliases

// -----------

/* class-static */ XMP_Status

XMPMeta::DumpAliases ( XMP_TextOutputProc outProc,

                       void *             refCon )

{