1 /*
   2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   3  *
   4  * This code is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License version 2 only, as
   6  * published by the Free Software Foundation.  Oracle designates this
   7  * particular file as subject to the "Classpath" exception as provided
   8  * by Oracle in the LICENSE file that accompanied this code.
   9  *
  10  * This code is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * version 2 for more details (a copy is included in the LICENSE file that
  14  * accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License version
  17  * 2 along with this work; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  21  * or visit www.oracle.com if you need additional information or have any
  22  * questions.
  23  */
  24 
  25 // This file is available under and governed by the GNU General Public
  26 // License version 2 only, as published by the Free Software Foundation.
  27 // However, the following notice accompanied the original version of this
  28 // file:
  29 //
  30 //---------------------------------------------------------------------------------
  31 //
  32 //  Little Color Management System
  33 //  Copyright (c) 1998-2023 Marti Maria Saguer
  34 //
  35 // Permission is hereby granted, free of charge, to any person obtaining
  36 // a copy of this software and associated documentation files (the "Software"),
  37 // to deal in the Software without restriction, including without limitation
  38 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
  39 // and/or sell copies of the Software, and to permit persons to whom the Software
  40 // is furnished to do so, subject to the following conditions:
  41 //
  42 // The above copyright notice and this permission notice shall be included in
  43 // all copies or substantial portions of the Software.
  44 //
  45 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  46 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  47 // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  48 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  49 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  50 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  51 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  52 //
  53 //---------------------------------------------------------------------------------
  54 //
  55 
  56 #include "lcms2_internal.h"
  57 
  58 // Multilocalized unicode objects. That is an attempt to encapsulate i18n.
  59 
  60 
  61 // Allocates an empty multi localizad unicode object
  62 cmsMLU* CMSEXPORT cmsMLUalloc(cmsContext ContextID, cmsUInt32Number nItems)
  63 {
  64     cmsMLU* mlu;
  65 
  66     // nItems should be positive if given
  67     if (nItems <= 0) nItems = 2;
  68 
  69     // Create the container
  70     mlu = (cmsMLU*) _cmsMallocZero(ContextID, sizeof(cmsMLU));
  71     if (mlu == NULL) return NULL;
  72 
  73     mlu ->ContextID = ContextID;
  74 
  75     // Create entry array
  76     mlu ->Entries = (_cmsMLUentry*) _cmsCalloc(ContextID, nItems, sizeof(_cmsMLUentry));
  77     if (mlu ->Entries == NULL) {
  78         _cmsFree(ContextID, mlu);
  79         return NULL;
  80     }
  81 
  82     // Ok, keep indexes up to date
  83     mlu ->AllocatedEntries    = nItems;
  84     mlu ->UsedEntries         = 0;
  85 
  86     return mlu;
  87 }
  88 
  89 
  90 // Grows a mempool table for a MLU. Each time this function is called, mempool size is multiplied times two.
  91 static
  92 cmsBool GrowMLUpool(cmsMLU* mlu)
  93 {
  94     cmsUInt32Number size;
  95     void *NewPtr;
  96 
  97     // Sanity check
  98     if (mlu == NULL) return FALSE;
  99 
 100     if (mlu ->PoolSize == 0)
 101         size = 256;
 102     else
 103         size = mlu ->PoolSize * 2;
 104 
 105     // Check for overflow
 106     if (size < mlu ->PoolSize) return FALSE;
 107 
 108     // Reallocate the pool
 109     NewPtr = _cmsRealloc(mlu ->ContextID, mlu ->MemPool, size);
 110     if (NewPtr == NULL) return FALSE;
 111 
 112 
 113     mlu ->MemPool  = NewPtr;
 114     mlu ->PoolSize = size;
 115 
 116     return TRUE;
 117 }
 118 
 119 
 120 // Grows a entry table for a MLU. Each time this function is called, table size is multiplied times two.
 121 static
 122 cmsBool GrowMLUtable(cmsMLU* mlu)
 123 {
 124     cmsUInt32Number AllocatedEntries;
 125     _cmsMLUentry *NewPtr;
 126 
 127     // Sanity check
 128     if (mlu == NULL) return FALSE;
 129 
 130     AllocatedEntries = mlu ->AllocatedEntries * 2;
 131 
 132     // Check for overflow
 133     if (AllocatedEntries / 2 != mlu ->AllocatedEntries) return FALSE;
 134 
 135     // Reallocate the memory
 136     NewPtr = (_cmsMLUentry*)_cmsRealloc(mlu ->ContextID, mlu ->Entries, AllocatedEntries*sizeof(_cmsMLUentry));
 137     if (NewPtr == NULL) return FALSE;
 138 
 139     mlu ->Entries          = NewPtr;
 140     mlu ->AllocatedEntries = AllocatedEntries;
 141 
 142     return TRUE;
 143 }
 144 
 145 
 146 // Search for a specific entry in the structure. Language and Country are used.
 147 static
 148 int SearchMLUEntry(cmsMLU* mlu, cmsUInt16Number LanguageCode, cmsUInt16Number CountryCode)
 149 {
 150     cmsUInt32Number i;
 151 
 152     // Sanity check
 153     if (mlu == NULL) return -1;
 154 
 155     // Iterate whole table
 156     for (i=0; i < mlu ->UsedEntries; i++) {
 157 
 158         if (mlu ->Entries[i].Country  == CountryCode &&
 159             mlu ->Entries[i].Language == LanguageCode) return (int) i;
 160     }
 161 
 162     // Not found
 163     return -1;
 164 }
 165 
 166 // Add a block of characters to the intended MLU. Language and country are specified.
 167 // Only one entry for Language/country pair is allowed.
 168 static
 169 cmsBool AddMLUBlock(cmsMLU* mlu, cmsUInt32Number size, const wchar_t *Block,
 170                      cmsUInt16Number LanguageCode, cmsUInt16Number CountryCode)
 171 {
 172     cmsUInt32Number Offset;
 173     cmsUInt8Number* Ptr;
 174 
 175     // Sanity check
 176     if (mlu == NULL) return FALSE;
 177 
 178     // Is there any room available?
 179     if (mlu ->UsedEntries >= mlu ->AllocatedEntries) {
 180         if (!GrowMLUtable(mlu)) return FALSE;
 181     }
 182 
 183     // Only one ASCII string
 184     if (SearchMLUEntry(mlu, LanguageCode, CountryCode) >= 0) return FALSE;  // Only one  is allowed!
 185 
 186     // Check for size
 187     while ((mlu ->PoolSize - mlu ->PoolUsed) < size) {
 188 
 189             if (!GrowMLUpool(mlu)) return FALSE;
 190     }
 191 
 192     Offset = mlu ->PoolUsed;
 193 
 194     Ptr = (cmsUInt8Number*) mlu ->MemPool;
 195     if (Ptr == NULL) return FALSE;
 196 
 197     // Set the entry
 198     memmove(Ptr + Offset, Block, size);
 199     mlu ->PoolUsed += size;
 200 
 201     mlu ->Entries[mlu ->UsedEntries].StrW     = Offset;
 202     mlu ->Entries[mlu ->UsedEntries].Len      = size;
 203     mlu ->Entries[mlu ->UsedEntries].Country  = CountryCode;
 204     mlu ->Entries[mlu ->UsedEntries].Language = LanguageCode;
 205     mlu ->UsedEntries++;
 206 
 207     return TRUE;
 208 }
 209 
 210 // Convert from a 3-char code to a cmsUInt16Number. It is done in this way because some
 211 // compilers don't properly align beginning of strings
 212 static
 213 cmsUInt16Number strTo16(const char str[3])
 214 {
 215     const cmsUInt8Number* ptr8;
 216     cmsUInt16Number n;
 217 
 218     // For non-existent strings
 219     if (str == NULL) return 0;
 220     ptr8 = (const cmsUInt8Number*)str;
 221     n = (cmsUInt16Number)(((cmsUInt16Number)ptr8[0] << 8) | ptr8[1]);
 222 
 223     return n;
 224 }
 225 
 226 static
 227 void strFrom16(char str[3], cmsUInt16Number n)
 228 {
 229     str[0] = (char)(n >> 8);
 230     str[1] = (char)n;
 231     str[2] = (char)0;
 232 
 233 }
 234 
 235 // Add an ASCII entry. Do not add any \0 termination (ICC1v43_2010-12.pdf page 61)
 236 // In the case the user explicitly sets an empty string, we force a \0
 237 cmsBool CMSEXPORT cmsMLUsetASCII(cmsMLU* mlu, const char LanguageCode[3], const char CountryCode[3], const char* ASCIIString)
 238 {
 239     cmsUInt32Number i, len = (cmsUInt32Number) strlen(ASCIIString);
 240     wchar_t* WStr;
 241     cmsBool  rc;
 242     cmsUInt16Number Lang  = strTo16(LanguageCode);
 243     cmsUInt16Number Cntry = strTo16(CountryCode);
 244 
 245     if (mlu == NULL) return FALSE;
 246 
 247     // len == 0 would prevent operation, so we set a empty string pointing to zero
 248     if (len == 0)
 249     {
 250         len = 1;
 251     }
 252 
 253     WStr = (wchar_t*) _cmsCalloc(mlu ->ContextID, len,  sizeof(wchar_t));
 254     if (WStr == NULL) return FALSE;
 255 
 256     for (i=0; i < len; i++)
 257         WStr[i] = (wchar_t) ASCIIString[i];
 258 
 259     rc = AddMLUBlock(mlu, len  * sizeof(wchar_t), WStr, Lang, Cntry);
 260 
 261     _cmsFree(mlu ->ContextID, WStr);
 262     return rc;
 263 
 264 }
 265 
 266 // We don't need any wcs support library
 267 static
 268 cmsUInt32Number mywcslen(const wchar_t *s)
 269 {
 270     const wchar_t *p;
 271 
 272     p = s;
 273     while (*p)
 274         p++;
 275 
 276     return (cmsUInt32Number)(p - s);
 277 }
 278 
 279 // Add a wide entry. Do not add any \0 terminator (ICC1v43_2010-12.pdf page 61)
 280 cmsBool  CMSEXPORT cmsMLUsetWide(cmsMLU* mlu, const char Language[3], const char Country[3], const wchar_t* WideString)
 281 {
 282     cmsUInt16Number Lang  = strTo16(Language);
 283     cmsUInt16Number Cntry = strTo16(Country);
 284     cmsUInt32Number len;
 285 
 286     if (mlu == NULL) return FALSE;
 287     if (WideString == NULL) return FALSE;
 288 
 289     len = (cmsUInt32Number) (mywcslen(WideString)) * sizeof(wchar_t);
 290     if (len == 0)
 291         len = sizeof(wchar_t);
 292 
 293     return AddMLUBlock(mlu, len, WideString, Lang, Cntry);
 294 }
 295 
 296 // Duplicating a MLU is as easy as copying all members
 297 cmsMLU* CMSEXPORT cmsMLUdup(const cmsMLU* mlu)
 298 {
 299     cmsMLU* NewMlu = NULL;
 300 
 301     // Duplicating a NULL obtains a NULL
 302     if (mlu == NULL) return NULL;
 303 
 304     NewMlu = cmsMLUalloc(mlu ->ContextID, mlu ->UsedEntries);
 305     if (NewMlu == NULL) return NULL;
 306 
 307     // Should never happen
 308     if (NewMlu ->AllocatedEntries < mlu ->UsedEntries)
 309         goto Error;
 310 
 311     // Sanitize...
 312     if (NewMlu ->Entries == NULL || mlu ->Entries == NULL)  goto Error;
 313 
 314     memmove(NewMlu ->Entries, mlu ->Entries, mlu ->UsedEntries * sizeof(_cmsMLUentry));
 315     NewMlu ->UsedEntries = mlu ->UsedEntries;
 316 
 317     // The MLU may be empty
 318     if (mlu ->PoolUsed == 0) {
 319         NewMlu ->MemPool = NULL;
 320     }
 321     else {
 322         // It is not empty
 323         NewMlu ->MemPool = _cmsMalloc(mlu ->ContextID, mlu ->PoolUsed);
 324         if (NewMlu ->MemPool == NULL) goto Error;
 325     }
 326 
 327     NewMlu ->PoolSize = mlu ->PoolUsed;
 328 
 329     if (NewMlu ->MemPool == NULL || mlu ->MemPool == NULL) goto Error;
 330 
 331     memmove(NewMlu ->MemPool, mlu->MemPool, mlu ->PoolUsed);
 332     NewMlu ->PoolUsed = mlu ->PoolUsed;
 333 
 334     return NewMlu;
 335 
 336 Error:
 337 
 338     if (NewMlu != NULL) cmsMLUfree(NewMlu);
 339     return NULL;
 340 }
 341 
 342 // Free any used memory
 343 void CMSEXPORT cmsMLUfree(cmsMLU* mlu)
 344 {
 345     if (mlu) {
 346 
 347         if (mlu -> Entries) _cmsFree(mlu ->ContextID, mlu->Entries);
 348         if (mlu -> MemPool) _cmsFree(mlu ->ContextID, mlu->MemPool);
 349 
 350         _cmsFree(mlu ->ContextID, mlu);
 351     }
 352 }
 353 
 354 
 355 // The algorithm first searches for an exact match of country and language, if not found it uses
 356 // the Language. If none is found, first entry is used instead.
 357 static
 358 const wchar_t* _cmsMLUgetWide(const cmsMLU* mlu,
 359                               cmsUInt32Number *len,
 360                               cmsUInt16Number LanguageCode, cmsUInt16Number CountryCode,
 361                               cmsUInt16Number* UsedLanguageCode, cmsUInt16Number* UsedCountryCode)
 362 {
 363     cmsUInt32Number i;
 364     int Best = -1;
 365     _cmsMLUentry* v;
 366 
 367     if (mlu == NULL) return NULL;
 368 
 369     if (mlu -> AllocatedEntries <= 0) return NULL;
 370 
 371     for (i=0; i < mlu ->UsedEntries; i++) {
 372 
 373         v = mlu ->Entries + i;
 374 
 375         if (v -> Language == LanguageCode) {
 376 
 377             if (Best == -1) Best = (int) i;
 378 
 379             if (v -> Country == CountryCode) {
 380 
 381                 if (UsedLanguageCode != NULL) *UsedLanguageCode = v ->Language;
 382                 if (UsedCountryCode  != NULL) *UsedCountryCode = v ->Country;
 383 
 384                 if (len != NULL) *len = v ->Len;
 385 
 386                 return (wchar_t*) ((cmsUInt8Number*) mlu ->MemPool + v -> StrW);        // Found exact match
 387             }
 388         }
 389     }
 390 
 391     // No string found. Return First one
 392     if (Best == -1)
 393         Best = 0;
 394 
 395     v = mlu ->Entries + Best;
 396 
 397     if (UsedLanguageCode != NULL) *UsedLanguageCode = v ->Language;
 398     if (UsedCountryCode  != NULL) *UsedCountryCode = v ->Country;
 399 
 400     if (len != NULL) *len   = v ->Len;
 401 
 402     if (v->StrW + v->Len > mlu->PoolSize) return NULL;
 403 
 404     return(wchar_t*) ((cmsUInt8Number*) mlu ->MemPool + v ->StrW);
 405 }
 406 
 407 
 408 // Obtain an ASCII representation of the wide string. Setting buffer to NULL returns the len
 409 cmsUInt32Number CMSEXPORT cmsMLUgetASCII(const cmsMLU* mlu,
 410                                        const char LanguageCode[3], const char CountryCode[3],
 411                                        char* Buffer, cmsUInt32Number BufferSize)
 412 {
 413     const wchar_t *Wide;
 414     cmsUInt32Number  StrLen = 0;
 415     cmsUInt32Number ASCIIlen, i;
 416 
 417     cmsUInt16Number Lang  = strTo16(LanguageCode);
 418     cmsUInt16Number Cntry = strTo16(CountryCode);
 419 
 420     // Sanitize
 421     if (mlu == NULL) return 0;
 422 
 423     // Get WideChar
 424     Wide = _cmsMLUgetWide(mlu, &StrLen, Lang, Cntry, NULL, NULL);
 425     if (Wide == NULL) return 0;
 426 
 427     ASCIIlen = StrLen / sizeof(wchar_t);
 428 
 429     // Maybe we want only to know the len?
 430     if (Buffer == NULL) return ASCIIlen + 1; // Note the zero at the end
 431 
 432     // No buffer size means no data
 433     if (BufferSize <= 0) return 0;
 434 
 435     // Some clipping may be required
 436     if (BufferSize < ASCIIlen + 1)
 437         ASCIIlen = BufferSize - 1;
 438 
 439     // Precess each character
 440     for (i=0; i < ASCIIlen; i++) {
 441 
 442         if (Wide[i] == 0)
 443             Buffer[i] = 0;
 444         else
 445             Buffer[i] = (char) Wide[i];
 446     }
 447 
 448     // We put a termination "\0"
 449     Buffer[ASCIIlen] = 0;
 450     return ASCIIlen + 1;
 451 }
 452 
 453 // Obtain a wide representation of the MLU, on depending on current locale settings
 454 cmsUInt32Number CMSEXPORT cmsMLUgetWide(const cmsMLU* mlu,
 455                                       const char LanguageCode[3], const char CountryCode[3],
 456                                       wchar_t* Buffer, cmsUInt32Number BufferSize)
 457 {
 458     const wchar_t *Wide;
 459     cmsUInt32Number  StrLen = 0;
 460 
 461     cmsUInt16Number Lang  = strTo16(LanguageCode);
 462     cmsUInt16Number Cntry = strTo16(CountryCode);
 463 
 464     // Sanitize
 465     if (mlu == NULL) return 0;
 466 
 467     Wide = _cmsMLUgetWide(mlu, &StrLen, Lang, Cntry, NULL, NULL);
 468     if (Wide == NULL) return 0;
 469 
 470     // Maybe we want only to know the len?
 471     if (Buffer == NULL) return StrLen + sizeof(wchar_t);
 472 
 473   // No buffer size means no data
 474     if (BufferSize <= 0) return 0;
 475 
 476     // Some clipping may be required
 477     if (BufferSize < StrLen + sizeof(wchar_t))
 478         StrLen = BufferSize - + sizeof(wchar_t);
 479 
 480     memmove(Buffer, Wide, StrLen);
 481     Buffer[StrLen / sizeof(wchar_t)] = 0;
 482 
 483     return StrLen + sizeof(wchar_t);
 484 }
 485 
 486 
 487 // Get also the language and country
 488 CMSAPI cmsBool CMSEXPORT cmsMLUgetTranslation(const cmsMLU* mlu,
 489                                               const char LanguageCode[3], const char CountryCode[3],
 490                                               char ObtainedLanguage[3], char ObtainedCountry[3])
 491 {
 492     const wchar_t *Wide;
 493 
 494     cmsUInt16Number Lang  = strTo16(LanguageCode);
 495     cmsUInt16Number Cntry = strTo16(CountryCode);
 496     cmsUInt16Number ObtLang, ObtCode;
 497 
 498     // Sanitize
 499     if (mlu == NULL) return FALSE;
 500 
 501     Wide = _cmsMLUgetWide(mlu, NULL, Lang, Cntry, &ObtLang, &ObtCode);
 502     if (Wide == NULL) return FALSE;
 503 
 504     // Get used language and code
 505     strFrom16(ObtainedLanguage, ObtLang);
 506     strFrom16(ObtainedCountry, ObtCode);
 507 
 508     return TRUE;
 509 }
 510 
 511 
 512 
 513 // Get the number of translations in the MLU object
 514 cmsUInt32Number CMSEXPORT cmsMLUtranslationsCount(const cmsMLU* mlu)
 515 {
 516     if (mlu == NULL) return 0;
 517     return mlu->UsedEntries;
 518 }
 519 
 520 // Get the language and country codes for a specific MLU index
 521 cmsBool CMSEXPORT cmsMLUtranslationsCodes(const cmsMLU* mlu,
 522                                           cmsUInt32Number idx,
 523                                           char LanguageCode[3],
 524                                           char CountryCode[3])
 525 {
 526     _cmsMLUentry *entry;
 527 
 528     if (mlu == NULL) return FALSE;
 529 
 530     if (idx >= mlu->UsedEntries) return FALSE;
 531 
 532     entry = &mlu->Entries[idx];
 533 
 534     strFrom16(LanguageCode, entry->Language);
 535     strFrom16(CountryCode, entry->Country);
 536 
 537     return TRUE;
 538 }
 539 
 540 
 541 // Named color lists --------------------------------------------------------------------------------------------
 542 
 543 // Grow the list to keep at least NumElements
 544 static
 545 cmsBool  GrowNamedColorList(cmsNAMEDCOLORLIST* v)
 546 {
 547     cmsUInt32Number size;
 548     _cmsNAMEDCOLOR * NewPtr;
 549 
 550     if (v == NULL) return FALSE;
 551 
 552     if (v ->Allocated == 0)
 553         size = 64;   // Initial guess
 554     else
 555         size = v ->Allocated * 2;
 556 
 557     // Keep a maximum color lists can grow, 100K entries seems reasonable
 558     if (size > 1024 * 100) {
 559         _cmsFree(v->ContextID, (void*) v->List);
 560         v->List = NULL;
 561         return FALSE;
 562     }
 563 
 564     NewPtr = (_cmsNAMEDCOLOR*) _cmsRealloc(v ->ContextID, v ->List, size * sizeof(_cmsNAMEDCOLOR));
 565     if (NewPtr == NULL)
 566         return FALSE;
 567 
 568     v ->List      = NewPtr;
 569     v ->Allocated = size;
 570     return TRUE;
 571 }
 572 
 573 // Allocate a list for n elements
 574 cmsNAMEDCOLORLIST* CMSEXPORT cmsAllocNamedColorList(cmsContext ContextID, cmsUInt32Number n, cmsUInt32Number ColorantCount, const char* Prefix, const char* Suffix)
 575 {
 576     cmsNAMEDCOLORLIST* v;
 577 
 578     if (ColorantCount > cmsMAXCHANNELS)
 579         return NULL;
 580 
 581     v = (cmsNAMEDCOLORLIST*)_cmsMallocZero(ContextID, sizeof(cmsNAMEDCOLORLIST));
 582     if (v == NULL) return NULL;
 583 
 584     v ->List      = NULL;
 585     v ->nColors   = 0;
 586     v ->ContextID  = ContextID;
 587 
 588     while (v -> Allocated < n) {
 589         if (!GrowNamedColorList(v)) {
 590             cmsFreeNamedColorList(v);
 591             return NULL;
 592         }
 593     }
 594 
 595     strncpy(v ->Prefix, Prefix, sizeof(v ->Prefix)-1);
 596     strncpy(v ->Suffix, Suffix, sizeof(v ->Suffix)-1);
 597     v->Prefix[32] = v->Suffix[32] = 0;
 598 
 599     v -> ColorantCount = ColorantCount;
 600 
 601     return v;
 602 }
 603 
 604 // Free a list
 605 void CMSEXPORT cmsFreeNamedColorList(cmsNAMEDCOLORLIST* v)
 606 {
 607     if (v == NULL) return;
 608     if (v ->List) _cmsFree(v ->ContextID, v ->List);
 609     _cmsFree(v ->ContextID, v);
 610 }
 611 
 612 cmsNAMEDCOLORLIST* CMSEXPORT cmsDupNamedColorList(const cmsNAMEDCOLORLIST* v)
 613 {
 614     cmsNAMEDCOLORLIST* NewNC;
 615 
 616     if (v == NULL) return NULL;
 617 
 618     NewNC= cmsAllocNamedColorList(v ->ContextID, v -> nColors, v ->ColorantCount, v ->Prefix, v ->Suffix);
 619     if (NewNC == NULL) return NULL;
 620 
 621     // For really large tables we need this
 622     while (NewNC ->Allocated < v ->Allocated){
 623         if (!GrowNamedColorList(NewNC))
 624         {
 625             cmsFreeNamedColorList(NewNC);
 626             return NULL;
 627         }
 628     }
 629 
 630     memmove(NewNC ->Prefix, v ->Prefix, sizeof(v ->Prefix));
 631     memmove(NewNC ->Suffix, v ->Suffix, sizeof(v ->Suffix));
 632     NewNC ->ColorantCount = v ->ColorantCount;
 633     memmove(NewNC->List, v ->List, v->nColors * sizeof(_cmsNAMEDCOLOR));
 634     NewNC ->nColors = v ->nColors;
 635     return NewNC;
 636 }
 637 
 638 
 639 // Append a color to a list. List pointer may change if reallocated
 640 cmsBool  CMSEXPORT cmsAppendNamedColor(cmsNAMEDCOLORLIST* NamedColorList,
 641                                        const char* Name,
 642                                        cmsUInt16Number PCS[3], cmsUInt16Number Colorant[cmsMAXCHANNELS])
 643 {
 644     cmsUInt32Number i;
 645 
 646     if (NamedColorList == NULL) return FALSE;
 647 
 648     if (NamedColorList ->nColors + 1 > NamedColorList ->Allocated) {
 649         if (!GrowNamedColorList(NamedColorList)) return FALSE;
 650     }
 651 
 652     for (i=0; i < NamedColorList ->ColorantCount; i++)
 653         NamedColorList ->List[NamedColorList ->nColors].DeviceColorant[i] = Colorant == NULL ? (cmsUInt16Number)0 : Colorant[i];
 654 
 655     for (i=0; i < 3; i++)
 656         NamedColorList ->List[NamedColorList ->nColors].PCS[i] = PCS == NULL ? (cmsUInt16Number) 0 : PCS[i];
 657 
 658     if (Name != NULL) {
 659 
 660         strncpy(NamedColorList ->List[NamedColorList ->nColors].Name, Name, cmsMAX_PATH-1);
 661         NamedColorList ->List[NamedColorList ->nColors].Name[cmsMAX_PATH-1] = 0;
 662 
 663     }
 664     else
 665         NamedColorList ->List[NamedColorList ->nColors].Name[0] = 0;
 666 
 667 
 668     NamedColorList ->nColors++;
 669     return TRUE;
 670 }
 671 
 672 // Returns number of elements
 673 cmsUInt32Number CMSEXPORT cmsNamedColorCount(const cmsNAMEDCOLORLIST* NamedColorList)
 674 {
 675      if (NamedColorList == NULL) return 0;
 676      return NamedColorList ->nColors;
 677 }
 678 
 679 // Info about a given color
 680 cmsBool  CMSEXPORT cmsNamedColorInfo(const cmsNAMEDCOLORLIST* NamedColorList, cmsUInt32Number nColor,
 681                                      char* Name,
 682                                      char* Prefix,
 683                                      char* Suffix,
 684                                      cmsUInt16Number* PCS,
 685                                      cmsUInt16Number* Colorant)
 686 {
 687     if (NamedColorList == NULL) return FALSE;
 688 
 689     if (nColor >= cmsNamedColorCount(NamedColorList)) return FALSE;
 690 
 691     // strcpy instead of strncpy because many apps are using small buffers
 692     if (Name) strcpy(Name, NamedColorList->List[nColor].Name);
 693     if (Prefix) strcpy(Prefix, NamedColorList->Prefix);
 694     if (Suffix) strcpy(Suffix, NamedColorList->Suffix);
 695     if (PCS)
 696         memmove(PCS, NamedColorList ->List[nColor].PCS, 3*sizeof(cmsUInt16Number));
 697 
 698     if (Colorant)
 699         memmove(Colorant, NamedColorList ->List[nColor].DeviceColorant,
 700                                 sizeof(cmsUInt16Number) * NamedColorList ->ColorantCount);
 701 
 702 
 703     return TRUE;
 704 }
 705 
 706 // Search for a given color name (no prefix or suffix)
 707 cmsInt32Number CMSEXPORT cmsNamedColorIndex(const cmsNAMEDCOLORLIST* NamedColorList, const char* Name)
 708 {
 709     cmsUInt32Number i;
 710     cmsUInt32Number n;
 711 
 712     if (NamedColorList == NULL) return -1;
 713     n = cmsNamedColorCount(NamedColorList);
 714     for (i=0; i < n; i++) {
 715         if (cmsstrcasecmp(Name,  NamedColorList->List[i].Name) == 0)
 716             return (cmsInt32Number) i;
 717     }
 718 
 719     return -1;
 720 }
 721 
 722 // MPE support -----------------------------------------------------------------------------------------------------------------
 723 
 724 static
 725 void FreeNamedColorList(cmsStage* mpe)
 726 {
 727     cmsNAMEDCOLORLIST* List = (cmsNAMEDCOLORLIST*) mpe ->Data;
 728     cmsFreeNamedColorList(List);
 729 }
 730 
 731 static
 732 void* DupNamedColorList(cmsStage* mpe)
 733 {
 734     cmsNAMEDCOLORLIST* List = (cmsNAMEDCOLORLIST*) mpe ->Data;
 735     return cmsDupNamedColorList(List);
 736 }
 737 
 738 static
 739 void EvalNamedColorPCS(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)
 740 {
 741     cmsNAMEDCOLORLIST* NamedColorList = (cmsNAMEDCOLORLIST*) mpe ->Data;
 742     cmsUInt16Number index = (cmsUInt16Number) _cmsQuickSaturateWord(In[0] * 65535.0);
 743 
 744     if (index >= NamedColorList-> nColors) {
 745         cmsSignalError(NamedColorList ->ContextID, cmsERROR_RANGE, "Color %d out of range", index);
 746         Out[0] = Out[1] = Out[2] = 0.0f;
 747     }
 748     else {
 749 
 750             // Named color always uses Lab
 751             Out[0] = (cmsFloat32Number) (NamedColorList->List[index].PCS[0] / 65535.0);
 752             Out[1] = (cmsFloat32Number) (NamedColorList->List[index].PCS[1] / 65535.0);
 753             Out[2] = (cmsFloat32Number) (NamedColorList->List[index].PCS[2] / 65535.0);
 754     }
 755 }
 756 
 757 static
 758 void EvalNamedColor(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)
 759 {
 760     cmsNAMEDCOLORLIST* NamedColorList = (cmsNAMEDCOLORLIST*) mpe ->Data;
 761     cmsUInt16Number index = (cmsUInt16Number) _cmsQuickSaturateWord(In[0] * 65535.0);
 762     cmsUInt32Number j;
 763 
 764     if (index >= NamedColorList-> nColors) {
 765         cmsSignalError(NamedColorList ->ContextID, cmsERROR_RANGE, "Color %d out of range", index);
 766         for (j = 0; j < NamedColorList->ColorantCount; j++)
 767             Out[j] = 0.0f;
 768 
 769     }
 770     else {
 771         for (j=0; j < NamedColorList ->ColorantCount; j++)
 772             Out[j] = (cmsFloat32Number) (NamedColorList->List[index].DeviceColorant[j] / 65535.0);
 773     }
 774 }
 775 
 776 
 777 // Named color lookup element
 778 cmsStage* CMSEXPORT _cmsStageAllocNamedColor(cmsNAMEDCOLORLIST* NamedColorList, cmsBool UsePCS)
 779 {
 780     return _cmsStageAllocPlaceholder(NamedColorList ->ContextID,
 781                                    cmsSigNamedColorElemType,
 782                                    1, UsePCS ? 3 : NamedColorList ->ColorantCount,
 783                                    UsePCS ? EvalNamedColorPCS : EvalNamedColor,
 784                                    DupNamedColorList,
 785                                    FreeNamedColorList,
 786                                    cmsDupNamedColorList(NamedColorList));
 787 
 788 }
 789 
 790 
 791 // Retrieve the named color list from a transform. Should be first element in the LUT
 792 cmsNAMEDCOLORLIST* CMSEXPORT cmsGetNamedColorList(cmsHTRANSFORM xform)
 793 {
 794     _cmsTRANSFORM* v = (_cmsTRANSFORM*) xform;
 795     cmsStage* mpe;
 796 
 797     if (v == NULL) return NULL;
 798     if (v->Lut == NULL) return NULL;
 799 
 800     mpe = v->Lut->Elements;
 801     if (mpe == NULL) return NULL;
 802 
 803     if (mpe ->Type != cmsSigNamedColorElemType) return NULL;
 804     return (cmsNAMEDCOLORLIST*) mpe ->Data;
 805 }
 806 
 807 
 808 // Profile sequence description routines -------------------------------------------------------------------------------------
 809 
 810 cmsSEQ* CMSEXPORT cmsAllocProfileSequenceDescription(cmsContext ContextID, cmsUInt32Number n)
 811 {
 812     cmsSEQ* Seq;
 813     cmsUInt32Number i;
 814 
 815     if (n == 0) return NULL;
 816 
 817     // In a absolutely arbitrary way, I hereby decide to allow a maxim of 255 profiles linked
 818     // in a devicelink. It makes not sense anyway and may be used for exploits, so let's close the door!
 819     if (n > 255) return NULL;
 820 
 821     Seq = (cmsSEQ*) _cmsMallocZero(ContextID, sizeof(cmsSEQ));
 822     if (Seq == NULL) return NULL;
 823 
 824     Seq -> ContextID = ContextID;
 825     Seq -> seq      = (cmsPSEQDESC*) _cmsCalloc(ContextID, n, sizeof(cmsPSEQDESC));
 826     Seq -> n        = n;
 827 
 828     if (Seq -> seq == NULL) {
 829         _cmsFree(ContextID, Seq);
 830         return NULL;
 831     }
 832 
 833     for (i=0; i < n; i++) {
 834         Seq -> seq[i].Manufacturer = NULL;
 835         Seq -> seq[i].Model        = NULL;
 836         Seq -> seq[i].Description  = NULL;
 837     }
 838 
 839     return Seq;
 840 }
 841 
 842 void CMSEXPORT cmsFreeProfileSequenceDescription(cmsSEQ* pseq)
 843 {
 844     cmsUInt32Number i;
 845 
 846     for (i=0; i < pseq ->n; i++) {
 847         if (pseq ->seq[i].Manufacturer != NULL) cmsMLUfree(pseq ->seq[i].Manufacturer);
 848         if (pseq ->seq[i].Model != NULL) cmsMLUfree(pseq ->seq[i].Model);
 849         if (pseq ->seq[i].Description != NULL) cmsMLUfree(pseq ->seq[i].Description);
 850     }
 851 
 852     if (pseq ->seq != NULL) _cmsFree(pseq ->ContextID, pseq ->seq);
 853     _cmsFree(pseq -> ContextID, pseq);
 854 }
 855 
 856 cmsSEQ* CMSEXPORT cmsDupProfileSequenceDescription(const cmsSEQ* pseq)
 857 {
 858     cmsSEQ *NewSeq;
 859     cmsUInt32Number i;
 860 
 861     if (pseq == NULL)
 862         return NULL;
 863 
 864     NewSeq = (cmsSEQ*) _cmsMalloc(pseq -> ContextID, sizeof(cmsSEQ));
 865     if (NewSeq == NULL) return NULL;
 866 
 867 
 868     NewSeq -> seq      = (cmsPSEQDESC*) _cmsCalloc(pseq ->ContextID, pseq ->n, sizeof(cmsPSEQDESC));
 869     if (NewSeq ->seq == NULL) goto Error;
 870 
 871     NewSeq -> ContextID = pseq ->ContextID;
 872     NewSeq -> n        = pseq ->n;
 873 
 874     for (i=0; i < pseq->n; i++) {
 875 
 876         memmove(&NewSeq ->seq[i].attributes, &pseq ->seq[i].attributes, sizeof(cmsUInt64Number));
 877 
 878         NewSeq ->seq[i].deviceMfg   = pseq ->seq[i].deviceMfg;
 879         NewSeq ->seq[i].deviceModel = pseq ->seq[i].deviceModel;
 880         memmove(&NewSeq ->seq[i].ProfileID, &pseq ->seq[i].ProfileID, sizeof(cmsProfileID));
 881         NewSeq ->seq[i].technology  = pseq ->seq[i].technology;
 882 
 883         NewSeq ->seq[i].Manufacturer = cmsMLUdup(pseq ->seq[i].Manufacturer);
 884         NewSeq ->seq[i].Model        = cmsMLUdup(pseq ->seq[i].Model);
 885         NewSeq ->seq[i].Description  = cmsMLUdup(pseq ->seq[i].Description);
 886 
 887     }
 888 
 889     return NewSeq;
 890 
 891 Error:
 892 
 893     cmsFreeProfileSequenceDescription(NewSeq);
 894     return NULL;
 895 }
 896 
 897 // Dictionaries --------------------------------------------------------------------------------------------------------
 898 
 899 // Dictionaries are just very simple linked lists
 900 
 901 
 902 typedef struct _cmsDICT_struct {
 903     cmsDICTentry* head;
 904     cmsContext ContextID;
 905 } _cmsDICT;
 906 
 907 
 908 // Allocate an empty dictionary
 909 cmsHANDLE CMSEXPORT cmsDictAlloc(cmsContext ContextID)
 910 {
 911     _cmsDICT* dict = (_cmsDICT*) _cmsMallocZero(ContextID, sizeof(_cmsDICT));
 912     if (dict == NULL) return NULL;
 913 
 914     dict ->ContextID = ContextID;
 915     return (cmsHANDLE) dict;
 916 
 917 }
 918 
 919 // Dispose resources
 920 void CMSEXPORT cmsDictFree(cmsHANDLE hDict)
 921 {
 922     _cmsDICT* dict = (_cmsDICT*) hDict;
 923     cmsDICTentry *entry, *next;
 924 
 925     _cmsAssert(dict != NULL);
 926 
 927     // Walk the list freeing all nodes
 928     entry = dict ->head;
 929     while (entry != NULL) {
 930 
 931             if (entry ->DisplayName  != NULL) cmsMLUfree(entry ->DisplayName);
 932             if (entry ->DisplayValue != NULL) cmsMLUfree(entry ->DisplayValue);
 933             if (entry ->Name != NULL) _cmsFree(dict ->ContextID, entry -> Name);
 934             if (entry ->Value != NULL) _cmsFree(dict ->ContextID, entry -> Value);
 935 
 936             // Don't fall in the habitual trap...
 937             next = entry ->Next;
 938             _cmsFree(dict ->ContextID, entry);
 939 
 940             entry = next;
 941     }
 942 
 943     _cmsFree(dict ->ContextID, dict);
 944 }
 945 
 946 
 947 // Duplicate a wide char string
 948 static
 949 wchar_t* DupWcs(cmsContext ContextID, const wchar_t* ptr)
 950 {
 951     if (ptr == NULL) return NULL;
 952     return (wchar_t*) _cmsDupMem(ContextID, ptr, (mywcslen(ptr) + 1) * sizeof(wchar_t));
 953 }
 954 
 955 // Add a new entry to the linked list
 956 cmsBool CMSEXPORT cmsDictAddEntry(cmsHANDLE hDict, const wchar_t* Name, const wchar_t* Value, const cmsMLU *DisplayName, const cmsMLU *DisplayValue)
 957 {
 958     _cmsDICT* dict = (_cmsDICT*) hDict;
 959     cmsDICTentry *entry;
 960 
 961     _cmsAssert(dict != NULL);
 962     _cmsAssert(Name != NULL);
 963 
 964     entry = (cmsDICTentry*) _cmsMallocZero(dict ->ContextID, sizeof(cmsDICTentry));
 965     if (entry == NULL) return FALSE;
 966 
 967     entry ->DisplayName  = cmsMLUdup(DisplayName);
 968     entry ->DisplayValue = cmsMLUdup(DisplayValue);
 969     entry ->Name         = DupWcs(dict ->ContextID, Name);
 970     entry ->Value        = DupWcs(dict ->ContextID, Value);
 971 
 972     entry ->Next = dict ->head;
 973     dict ->head = entry;
 974 
 975     return TRUE;
 976 }
 977 
 978 
 979 // Duplicates an existing dictionary
 980 cmsHANDLE CMSEXPORT cmsDictDup(cmsHANDLE hDict)
 981 {
 982     _cmsDICT* old_dict = (_cmsDICT*) hDict;
 983     cmsHANDLE hNew;
 984     cmsDICTentry *entry;
 985 
 986     _cmsAssert(old_dict != NULL);
 987 
 988     hNew  = cmsDictAlloc(old_dict ->ContextID);
 989     if (hNew == NULL) return NULL;
 990 
 991     // Walk the list freeing all nodes
 992     entry = old_dict ->head;
 993     while (entry != NULL) {
 994 
 995         if (!cmsDictAddEntry(hNew, entry ->Name, entry ->Value, entry ->DisplayName, entry ->DisplayValue)) {
 996 
 997             cmsDictFree(hNew);
 998             return NULL;
 999         }
1000 
1001         entry = entry -> Next;
1002     }
1003 
1004     return hNew;
1005 }
1006 
1007 // Get a pointer to the linked list
1008 const cmsDICTentry* CMSEXPORT cmsDictGetEntryList(cmsHANDLE hDict)
1009 {
1010     _cmsDICT* dict = (_cmsDICT*) hDict;
1011 
1012     if (dict == NULL) return NULL;
1013     return dict ->head;
1014 }
1015 
1016 // Helper For external languages
1017 const cmsDICTentry* CMSEXPORT cmsDictNextEntry(const cmsDICTentry* e)
1018 {
1019      if (e == NULL) return NULL;
1020      return e ->Next;
1021 }