/Users/xss/DemoIccMAX-hoyt-master/IccProfLib/IccMpeCalc.cpp

Bug Summary

File:	IccProfLib/IccMpeCalc.cpp
Warning:	line 4886, column 7 Array access results in a null pointer dereference

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 IccMpeCalc.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/IccProfLib -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 IccProfLib2_EXPORTS -I /Users/xss/DemoIccMAX-hoyt-master/build/Cmake/../../IccProfLib -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/IccProfLib -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/IccProfLib/IccMpeCalc.cpp

/Users/xss/DemoIccMAX-hoyt-master/IccProfLib/IccMpeCalc.cpp

→

1/** @file
  File:       IccMpeCalc.cpp

  Contains:   Implementation of Calculator Element

  Version:    V1

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

11/*
* The ICC Software License, Version 0.1
*
*
* Copyright (c) 2003-2006 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////////////////////////////////////////////////////////////////////// 
65// HISTORY:
66//
67// -Initial implementation by Max Derhak 1-30-2006
68//
69//////////////////////////////////////////////////////////////////////

71#ifdef WIN32
72#pragma warning( disable: 4786) //disable warning in <list.h>
73#endif

75#include <stdio.h>
76#include <math.h>
77#include <string.h>
78#include <stdlib.h>
79#include "IccMpeBasic.h"
80#include "IccMpeCalc.h"
81#include "IccIO.h"
82#include <map>
83#include "IccUtil.h"

85//#define ICC_VERBOSE_CALC_APPLY 1


88class CIccConsoleDebugger : public IIccCalcDebugger
89{
90public:

virtual ~CIccConsoleDebugger() {}

virtual void BeginApply()
{
  printf("\nBegin Calc Apply\n");
}

virtual void EndApply()
{
  printf("End Calculator Apply\n\n");
  fflush(stdout__stdoutp);
}

virtual bool BeforeOp(SIccCalcOp *op, SIccOpState &os, SIccCalcOp *ops)
{
  if (op->sig == icSigIfOp || op->sig == icSigSelectOp) {
    printf("Start:");
      std::string opDesc;
    op->Describe(opDesc);
    printf("%9s\t", opDesc.c_str());
    for (int j = 0; j < (int)os.pStack->size(); j++)
      printf(" %.4f", (*os.pStack)[j]);
    printf("\n");
  }
  return false;
}

virtual bool AfterOp(SIccCalcOp *op, SIccOpState &os, SIccCalcOp *ops)
{
  if (op->sig == icSigDataOp) {
    printf("%9s\t", "data");
  }
  else {
    if (op->sig == icSigIfOp || op->sig == icSigSelectOp) {
      printf("End:");
    }
    std::string opDesc;
    op->Describe(opDesc);
    printf("%9s\t", opDesc.c_str());
  }

  for (int j = 0; j < (int)os.pStack->size(); j++)
    printf(" %.4f", (*os.pStack)[j]);
  printf("\n");

  if (op->sig==icSigIfOp || op->sig==icSigSelectOp)
    printf("\n");
  fflush(stdout__stdoutp);

  return false;
}
virtual void Error(const char *szMsg)
{
  printf("%s\n", szMsg);
}
147};

149static CIccConsoleDebugger g_ConsoleDebugger;

151#ifdef ICC_VERBOSE_CALC_APPLY
152static IIccCalcDebugger *g_pDebugger = &g_ConsoleDebugger;
153#else
154static IIccCalcDebugger *g_pDebugger = icCalcDebuggerNone((IIccCalcDebugger*)0);
155#endif

157void IIccCalcDebugger::SetDebugger(IIccCalcDebugger *pDebugger)
158{
if (pDebugger == icCalcDebuggerConsole((IIccCalcDebugger*)-1))
  g_pDebugger = &g_ConsoleDebugger;
else 
  g_pDebugger = pDebugger;
163}

165#define OsPopArg(X){ if (!os.pStack->size()) return false; X = *(os.pStack->
rbegin()); os.pStack->pop_back(); } { \
if (!os.pStack->size()) \
  return false; \
X = *(os.pStack->rbegin()); \
os.pStack->pop_back(); \
170}

172#define OsPopArgs(X, N){ icUInt32Number nv=(N); size_t ss = os.pStack->size(); if
 (nv>ss) return false; icFloatNumber *sv = &(*os.pStack
)[ss-nv]; memcpy((X), sv, nv*sizeof(icFloatNumber)); os.pStack
->resize(ss-nv); } { \
icUInt32Number nv=(N); \
size_t ss = os.pStack->size(); \
if (nv>ss) \
  return false; \
icFloatNumber *sv = &(*os.pStack)[ss-nv]; \
memcpy((X), sv, nv*sizeof(icFloatNumber)); \
os.pStack->resize(ss-nv); \
180}


183#define OsPushArg(X){ icFloatNumber V = (X); os.pStack->push_back(V); } { \
icFloatNumber V = (X); \
os.pStack->push_back(V); \
186}

188#define OsPushArgs(X, N){ size_t ss = os.pStack->size(); icUInt32Number nv=(N); os
.pStack->resize(ss+nv); icFloatNumber *sv = &(*os.pStack
)[ss]; memcpy(sv, (X), nv*sizeof(icFloatNumber)); } { \
size_t ss = os.pStack->size(); \
icUInt32Number nv=(N); \
os.pStack->resize(ss+nv); \
icFloatNumber *sv = &(*os.pStack)[ss]; \
memcpy(sv, (X), nv*sizeof(icFloatNumber)); \
194}

196#define OsShrinkArgs(N){ icUInt32Number nv = (N); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); } { \
icUInt32Number nv = (N); \
size_t ss = os.pStack->size(); \
if (nv>ss) \
  return false; \
os.pStack->resize(ss-nv); \
202}

204#define OsExtendArgs(N){ size_t ss = os.pStack->size(); os.pStack->resize(ss+(
N)); } { \
size_t ss = os.pStack->size(); \
os.pStack->resize(ss+(N)); \
207}


210class CIccOpDefInvalid : public IIccOpDef
211{
212public:
virtual bool IsValid(CIccMpeCalculator *pCalc, SIccCalcOp &op) { return false; }
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  if (g_pDebugger)
  {
    std::string opDesc;
    op->Describe(opDesc);
    std::string line = "Unknown operator: ";
    line += opDesc;
    g_pDebugger->Error(line.c_str());
  }
  return false;
}
226};

228class CIccOpDefData : public IIccOpDef
229{
230public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  icUInt32Number n, j;
  if (!op->extra) {
    for (n=1; n+os.idx<os.nOps; n++)
      if (op[n].sig!=icSigDataOp)
        break;
    op->extra = n;
  }
  else {
    n=(icUInt32Number)op->extra;
  }
  size_t ss = os.pStack->size();
  os.pStack->resize(ss+n);
  icFloatNumber *s = &(*os.pStack)[ss];
  for (j=0; j<n; j++) {
    s[j] = op[j].data.num;
  }
  os.idx += n-1;
  return true;
}
252};

254class CIccOpDefPop : public IIccOpDef
255{
256public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  size_t ss = os.pStack->size();
  if ((size_t)(op->data.select.v1+1)>ss)
    return false;
  os.pStack->resize(ss-(op->data.select.v1+1));
  return true;
}
265};

267class CIccOpDefOutputChan : public IIccOpDef
268{
269public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  OsPopArgs(&os.output[op->data.select.v1], op->data.select.v2+1){ icUInt32Number nv=(op->data.select.v2+1); size_t ss = os
.pStack->size(); if (nv>ss) return false; icFloatNumber
 *sv = &(*os.pStack)[ss-nv]; memcpy((&os.output[op->
data.select.v1]), sv, nv*sizeof(icFloatNumber)); os.pStack->
resize(ss-nv); };
  return true;
}
275};

277class CIccOpDefInputChan : public IIccOpDef
278{
279public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  OsPushArgs(&os.pixel[op->data.select.v1], op->data.select.v2+1){ size_t ss = os.pStack->size(); icUInt32Number nv=(op->
data.select.v2+1); os.pStack->resize(ss+nv); icFloatNumber
 *sv = &(*os.pStack)[ss]; memcpy(sv, (&os.pixel[op->
data.select.v1]), nv*sizeof(icFloatNumber)); };
  return true;
}
285};

287class CIccOpDefTempGetChan : public IIccOpDef
288{
289public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  OsPushArgs(&os.temp[op->data.select.v1], op->data.select.v2+1){ size_t ss = os.pStack->size(); icUInt32Number nv=(op->
data.select.v2+1); os.pStack->resize(ss+nv); icFloatNumber
 *sv = &(*os.pStack)[ss]; memcpy(sv, (&os.temp[op->
data.select.v1]), nv*sizeof(icFloatNumber)); };
  return true;
}
295};

297class CIccOpDefTempPutChan : public IIccOpDef
298{
299public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  OsPopArgs(&os.temp[op->data.select.v1], op->data.select.v2+1){ icUInt32Number nv=(op->data.select.v2+1); size_t ss = os
.pStack->size(); if (nv>ss) return false; icFloatNumber
 *sv = &(*os.pStack)[ss-nv]; memcpy((&os.temp[op->
data.select.v1]), sv, nv*sizeof(icFloatNumber)); os.pStack->
resize(ss-nv); }
  return true;
}
305};

307class CIccOpDefTempSaveChan : public IIccOpDef
308{
309public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  size_t ss = os.pStack->size();
  size_t n=op->data.select.v2+1;

  if (n>ss)
    return false;

  icFloatNumber *s = &(*os.pStack)[ss - n];
  memcpy(&os.temp[op->data.select.v1], s, n*sizeof(icFloatNumber));
  return true;
}
322};

324class CIccOpDefEnvVar : public IIccOpDef
325{
326public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  icSigCmmEnvVar sig = (icSigCmmEnvVar) op->data.size;
  icFloatNumber val=0.0;

  if (sig==icSigTrueVar) {
    OsPushArg((icFloatNumber)1.0){ icFloatNumber V = ((icFloatNumber)1.0); os.pStack->push_back
(V); };
    OsPushArg((icFloatNumber)1.0){ icFloatNumber V = ((icFloatNumber)1.0); os.pStack->push_back
(V); };
  }
  else if (sig==icSigNotDefVar) {
    OsPushArg((icFloatNumber)0.0){ icFloatNumber V = ((icFloatNumber)0.0); os.pStack->push_back
(V); };
    OsPushArg((icFloatNumber)0.0){ icFloatNumber V = ((icFloatNumber)0.0); os.pStack->push_back
(V); };
  }
  else if (os.pApply->GetEnvVar(sig, val)) {
    OsPushArg((icFloatNumber)val){ icFloatNumber V = ((icFloatNumber)val); os.pStack->push_back
(V); };
    OsPushArg((icFloatNumber)1.0){ icFloatNumber V = ((icFloatNumber)1.0); os.pStack->push_back
(V); };
  }
  else {
    OsPushArg((icFloatNumber)0.0){ icFloatNumber V = ((icFloatNumber)0.0); os.pStack->push_back
(V); };
    OsPushArg((icFloatNumber)0.0){ icFloatNumber V = ((icFloatNumber)0.0); os.pStack->push_back
(V); };
  }
  return true;
}
350};

352class CIccOpDefSubElement : public IIccOpDef
353{
354public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  CIccSubCalcApply *pElemApply = os.pApply->GetApply(op->data.select.v1);
  if (!pElemApply)
    return false;

  icUInt16Number nSrc = pElemApply->NumInputChannels();
  icUInt16Number nDst = pElemApply->NumOutputChannels();

  size_t ss = os.pStack->size();
  if (nSrc>ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss - nSrc];

  if (os.pScratch->size()<(size_t)nDst)
    os.pScratch->resize(nDst);

  icFloatNumber *d = &(*os.pScratch)[0];

  pElemApply->Apply(d, s);

  int ns = (int)ss + (int)nDst - (int)nSrc;

  if (ns != ss)
    os.pStack->resize(ns);

  s = &(*os.pStack)[ns - nDst];
  memcpy(s, d, nDst*sizeof(icFloatNumber));
  return true;
}
385};

387class CIccOpDefCopy : public IIccOpDef
388{
389public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  size_t ss = os.pStack->size();
  int j;
  int n=op->data.select.v1+1;
  int t=op->data.select.v2+1;
  if (n>(int)ss)
    return false;

  if (n && t) {
    OsExtendArgs(n*t){ size_t ss = os.pStack->size(); os.pStack->resize(ss+(
n*t)); };

    icFloatNumber *to = &(*os.pStack)[ss];
    icFloatNumber *from = to-n;

    for (j=0; j<t; j++) {
      memcpy(to, from, n*sizeof(icFloatNumber));
      to+=n;
    }
  }
  return true;
}
412};

414class CIccOpDefPositionDup : public IIccOpDef
415{
416public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  size_t ss = os.pStack->size();
  int j, n=op->data.select.v1+1;
  int t=op->data.select.v2+1;
  if (n>(int)ss)
    return false;

  if (n && t) {
    OsExtendArgs(t){ size_t ss = os.pStack->size(); os.pStack->resize(ss+(
t)); };

    icFloatNumber *to = &(*os.pStack)[ss];
    icFloatNumber *from = to-n;

    for (j=0; j<t; j++) {
      to[j] = *from;
    }
  }
  return true;
}
437};

439class CIccOpDefFlip : public IIccOpDef
440{
441public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int n = op->data.select.v1+2;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  icFloatNumber t;
  int j, k;
  for (j=0, k=n-1; j<k; j++, k--) {
    t = s[j];
    s[j] = s[k];
    s[k] = t;
  }
  return true;
}
458};

460class CIccOpDefRotateLeft : public IIccOpDef
461{
462public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int nCopy = op->data.select.v1+1;
  int nPos = op->data.select.v2+1;

  if (nCopy) {
    int next = nPos;
    if (os.pScratch->size()<(size_t)nCopy)
      os.pScratch->resize(nCopy);

    icFloatNumber *copyList = &(*os.pScratch)[0];

    OsPopArgs(copyList, nCopy){ icUInt32Number nv=(nCopy); size_t ss = os.pStack->size()
; if (nv>ss) return false; icFloatNumber *sv = &(*os.pStack
)[ss-nv]; memcpy((copyList), sv, nv*sizeof(icFloatNumber)); os
.pStack->resize(ss-nv); };

    int j;
    for (j=0; j<nCopy; j++) {
      OsPushArg(copyList[(j+next)%nCopy]){ icFloatNumber V = (copyList[(j+next)%nCopy]); os.pStack->
push_back(V); };
    }
  }
  return true;
}
484};

486class CIccOpDefRotateRight : public IIccOpDef
487{
488public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int nCopy = op->data.select.v1+1;
  int nPos = (op->data.select.v2+1)%nCopy;

  if (nCopy) {
    int next = nCopy - nPos;
    if (os.pScratch->size()<(size_t)nCopy)
      os.pScratch->resize(nCopy);

    icFloatNumber *copyList = &(*os.pScratch)[0];

    OsPopArgs(copyList, nCopy){ icUInt32Number nv=(nCopy); size_t ss = os.pStack->size()
; if (nv>ss) return false; icFloatNumber *sv = &(*os.pStack
)[ss-nv]; memcpy((copyList), sv, nv*sizeof(icFloatNumber)); os
.pStack->resize(ss-nv); };

    int j;
    for (j=0; j<nCopy; j++) {
      OsPushArg(copyList[(j+next)%nCopy]){ icFloatNumber V = (copyList[(j+next)%nCopy]); os.pStack->
push_back(V); };
    }
  }
  return true;
}
510};

512class CIccOpDefTranspose : public IIccOpDef
513{
514public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  size_t ss = os.pStack->size();
  int r=op->data.select.v1+1;
  int c=op->data.select.v2+1;
  int nSize = r*c;

  if (nSize>(int)ss)
    return false;

  if (r>1 && c>1) {
    int j, k;

    if (os.pScratch->size()<(size_t)nSize)
      os.pScratch->resize(nSize);

    icFloatNumber *ptrStack = &(*os.pStack)[ss-nSize];
    icFloatNumber *ptrScratch = &(*os.pScratch)[0];
    icFloatNumber *start = ptrStack;
    icFloatNumber *to = ptrScratch;

    for (k=0; k<c; k++) {
      icFloatNumber *from = start;
      for (j=0; j<r; j++) {
        *to++ = *from;
        from += c;
      }
      start++;
    }
    memcpy(ptrStack, ptrScratch, nSize*sizeof(icFloatNumber));
  }
  return true;
}
548};

550class CIccOpDefSolve : public IIccOpDef
551{
552public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  size_t ss = os.pStack->size();
  int r=op->data.select.v1+1;
  int c=op->data.select.v2+1;
  int nMSize = r*c;
  int nSize = nMSize + c;

  if (nSize>(int)ss)
    return false;

  if (r>1 && c>1) {

    if (os.pScratch->size()<(size_t)c)
      os.pScratch->resize(c);
    
    icFloatNumber *ptrStack = &(*os.pStack)[ss-nSize];
    icFloatNumber *x = &(*os.pScratch)[0];
    icFloatNumber *mtx = ptrStack;
    icFloatNumber *y = &ptrStack[nMSize];

    bool bResult = false;

    if (g_pIccMatrixSolver) {
      bResult = g_pIccMatrixSolver->Solve(x, mtx, y, r, c);
    }
    if (bResult) {
      memcpy(ptrStack, x, c*sizeof(icFloatNumber));
      ptrStack[c] = 1.0;
    }
    else {
      memset(ptrStack, 0, c*sizeof(icFloatNumber));
      ptrStack[c] = 0.0;
    }
    os.pStack->resize(ss-nSize+r+1);
  }
  return true;
}
591};

593class CIccOpDefPi : public IIccOpDef
594{
595public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  OsPushArg((icFloatNumber)icPiNum){ icFloatNumber V = ((icFloatNumber)3.14159265358979323846); os
.pStack->push_back(V); };
  return true;
}
601};

603class CIccOpDefPosInfinity : public IIccOpDef
604{
605public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  OsPushArg((icFloatNumber)icPosInfinity){ icFloatNumber V = ((icFloatNumber)(std::numeric_limits<icFloatNumber
>::infinity())); os.pStack->push_back(V); };
  return true;
}
611};

613class CIccOpDefNegInfinity : public IIccOpDef
614{
615public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  OsPushArg((icFloatNumber)icNegInfinity){ icFloatNumber V = ((icFloatNumber)(-std::numeric_limits<
icFloatNumber>::infinity())); os.pStack->push_back(V); };
  return true;
}
621};

623class CIccOpDefNotANumber : public IIccOpDef
624{
625public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  OsPushArg((icFloatNumber)icNotANumber){ icFloatNumber V = ((icFloatNumber)(std::numeric_limits<icFloatNumber
>::quiet_NaN())); os.pStack->push_back(V); };
  return true;
}
631};

633class CIccOpDefSum : public IIccOpDef
634{
635public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+2;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  if (n==2) {
    s[0] += s[1];
    OsShrinkArgs(1){ icUInt32Number nv = (1); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  }
  else {
    for (j=1; j<n; j++) {
      s[0] += s[j];
    }
    OsShrinkArgs(n-1){ icUInt32Number nv = (n-1); size_t ss = os.pStack->size()
; if (nv>ss) return false; os.pStack->resize(ss-nv); };
  }
  return true;
}
655};

657class CIccOpDefProduct : public IIccOpDef
658{
659public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+2;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  if (n==2) {
    s[0] *= s[1];
    OsShrinkArgs(1){ icUInt32Number nv = (1); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  }
  else {
    for (j=1; j<n; j++) {
      s[0] *= s[j];
    }
    OsShrinkArgs(n-1){ icUInt32Number nv = (n-1); size_t ss = os.pStack->size()
; if (nv>ss) return false; os.pStack->resize(ss-nv); };
  }
  return true;
}
679};

681class CIccOpDefMinimum : public IIccOpDef
682{
683public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+2;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  if (n==2) {
    s[0] = icMin(s[0], s[1]);
    OsShrinkArgs(1){ icUInt32Number nv = (1); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  }
  else {
    icFloatNumber mv = s[0];
    for (j=1; j<n; j++) {
      if (s[j]<mv)
        mv = s[j];
    }
    s[0] = mv;
    OsShrinkArgs(n-1){ icUInt32Number nv = (n-1); size_t ss = os.pStack->size()
; if (nv>ss) return false; os.pStack->resize(ss-nv); };
  }
  return true;
}
706};

708class CIccOpDefMaximum : public IIccOpDef
709{
710public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+2;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  if (n==2) {
    s[0] = icMax(s[0], s[1]);
    OsShrinkArgs(1){ icUInt32Number nv = (1); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  }
  else {
    icFloatNumber mv = s[0];
    for (j=1; j<n; j++) {
      if (s[j]>mv)
        mv = s[j];
    }
    s[0] = mv;
    OsShrinkArgs(n-1){ icUInt32Number nv = (n-1); size_t ss = os.pStack->size()
; if (nv>ss) return false; os.pStack->resize(ss-nv); };
  }
  return true;
}
733};

735class CIccOpDefAnd : public IIccOpDef
736{
737public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+2;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];

  for (j=0; j<n; j++) {
    if (s[j]<0.5f)
      break;
  }
  s[0] = j<n ? 0.0f : 1.0f;

  OsShrinkArgs(n-1){ icUInt32Number nv = (n-1); size_t ss = os.pStack->size()
; if (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
755};

757class CIccOpDefOr : public IIccOpDef
758{
759public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j,n = op->data.select.v1+2;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];

  for (j=0; j<n; j++) {
    if (s[j]>=0.5f)
      break;
  }
  s[0] = j<n ? 1.0f : 0.0f;

  OsShrinkArgs(n-1){ icUInt32Number nv = (n-1); size_t ss = os.pStack->size()
; if (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
777};

779class CIccOpDefVectorMinimum : public IIccOpDef
780{
781public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  int tn = n*2;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  for (j=0; j<n; j++) {
    s[j] = icMin(s[j], s[j+n]);
  }
  OsShrinkArgs(n){ icUInt32Number nv = (n); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
796};

798class CIccOpDefVectorMaximum : public IIccOpDef
799{
800public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  int tn = n*2;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  for (j=0; j<n; j++) {
    s[j] = icMax(s[j], s[j+n]);
  }
  OsShrinkArgs(n){ icUInt32Number nv = (n); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
815};

817class CIccOpDefVectorAnd : public IIccOpDef
818{
819public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  int tn = n*2;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  for (j=0; j<n; j++) {
    s[j] = (s[j]>=0.5f && s[j+n]>=0.5) ? 1.0f : 0.0f;
  }
  OsShrinkArgs(n){ icUInt32Number nv = (n); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
834};

836class CIccOpDefVectorOr : public IIccOpDef
837{
838public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  int tn = n*2;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  for (j=0; j<n; j++) {
    s[j] = (s[j]>=0.5f || s[j+n]>=0.5) ? 1.0f : 0.0f;
  }
  OsShrinkArgs(n){ icUInt32Number nv = (n); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
853};

855class CIccOpDefAdd : public IIccOpDef
856{
857public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  int tn = n*2;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  for (j=0; j<n; j++) {
    s[j] += s[j+n];
  }
  OsShrinkArgs(n){ icUInt32Number nv = (n); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
872};

874class CIccOpDefSubtract : public IIccOpDef
875{
876public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  int tn = n*2;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  for (j=0; j<n; j++) {
    s[j] -= s[j+n];
  }
  OsShrinkArgs(n){ icUInt32Number nv = (n); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
891};

893class CIccOpDefMultiply : public IIccOpDef
894{
895public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  int tn = n*2;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  for (j=0; j<n; j++) {
    s[j] *= s[j+n];
  }
  OsShrinkArgs(n){ icUInt32Number nv = (n); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
910};

912class CIccOpDefDivide : public IIccOpDef
913{
914public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  int tn = n*2;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  for (j=0; j<n; j++) {
    s[j] /= s[j+n];
  }
  OsShrinkArgs(n){ icUInt32Number nv = (n); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
929};

931class CIccOpDefModulus : public IIccOpDef
932{
933public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  int tn = n*2;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  for (j=0; j<n; j++) {
    s[j] = s[j] - (icFloatNumber)((int)(s[j] / s[j+n]))*s[j+n];
  }
  OsShrinkArgs(n){ icUInt32Number nv = (n); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
948};

950class CIccOpDefGamma : public IIccOpDef
951{
952public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  int tn = n+1;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  icFloatNumber p = s[n];
  for (j=0; j<n; j++) {
    s[j] = (icFloatNumber)pow(s[j], p);
  }
  OsShrinkArgs(1){ icUInt32Number nv = (1); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
968};

970class CIccOpDefScalarAdd : public IIccOpDef
971{
972public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  int tn = n+1;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  icFloatNumber p = s[n];
  for (j=0; j<n; j++) {
    s[j] = s[j] + p;
  }
  OsShrinkArgs(1){ icUInt32Number nv = (1); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
988};

990class CIccOpDefScalarSubtract : public IIccOpDef
991{
992public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  int tn = n+1;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  icFloatNumber p = s[n];
  for (j=0; j<n; j++) {
    s[j] = s[j] - p;
  }
  OsShrinkArgs(1){ icUInt32Number nv = (1); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
1008};

1010class CIccOpDefScalarMultiply : public IIccOpDef
1011{
1012public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  int tn = n+1;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  icFloatNumber p = s[n];
  for (j=0; j<n; j++) {
    s[j] = s[j] * p;
  }
  OsShrinkArgs(1){ icUInt32Number nv = (1); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
1028};

1030class CIccOpDefScalarDivide : public IIccOpDef
1031{
1032public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  int tn = n+1;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  icFloatNumber p = s[n];
  for (j=0; j<n; j++) {
    s[j] = s[j] / p;
  }
  OsShrinkArgs(1){ icUInt32Number nv = (1); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
1048};

1050class CIccOpDefPow : public IIccOpDef
1051{
1052public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  int tn = n*2;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  for (j=0; j<n; j++) {
    s[j] = (icFloatNumber)pow(s[j], s[j+n]);
  }
  OsShrinkArgs(n){ icUInt32Number nv = (n); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
1067};

1069class CIccOpDefSquare : public IIccOpDef
1070{
1071public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  for (j=0; j<n; j++) {
    a1 = s[j];
    s[j] = a1*a1;
  }
  return true;
}
1086};

1088class CIccOpDefSquareRoot : public IIccOpDef
1089{
1090public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  for (j=0; j<n; j++) {
    a1 = s[j];
    s[j] = (icFloatNumber)sqrt(a1);
  }
  return true;
}
1105};

1107class CIccOpDefCube : public IIccOpDef
1108{
1109public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  for (j=0; j<n; j++) {
    a1 = s[j];
    s[j] = a1*a1*a1;
  }
  return true;
}
1124};

1126class CIccOpDefCubeRoot : public IIccOpDef
1127{
1128public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  for (j=0; j<n; j++) {
    a1 = s[j];
    s[j] = (icFloatNumber)ICC_CBRTF(a1)cbrtf(a1);
  }
  return true;
}
1143};

1145class CIccOpDefSign : public IIccOpDef
1146{
1147public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1 + 1;
  icFloatNumber a1;
  size_t ss = os.pStack->size();
  if (n > (int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss - n];
  for (j = 0; j < n; j++) {
    a1 = s[j];
    s[j] = (icFloatNumber)(a1 < 0 ? -1 : (a1 > 0 ? 1 : 0));
  }
  return true;
}
1162};

1164class CIccOpDefAbsoluteVal : public IIccOpDef
1165{
1166public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  for (j=0; j<n; j++) {
    a1 = s[j];
    s[j] = (a1 < 0 ? -a1 : a1);
  }
  return true;
}
1181};

1183class CIccOpDefTruncate : public IIccOpDef
1184{
1185public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  for (j=0; j<n; j++) {
    //Casting to an int results in truncation
    s[j] = (icFloatNumber)((int)(s[j]));
  }
  return true;
}
1199};

1201class CIccOpDefFloor : public IIccOpDef
1202{
1203public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  for (j=0; j<n; j++) {
    s[j] = (icFloatNumber)floor(s[j]);
  }
  return true;
}
1216};

1218class CIccOpDefCeiling : public IIccOpDef
1219{
1220public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  for (j=0; j<n; j++) {
    s[j] = (icFloatNumber)ceil(s[j]);
  }
  return true;
}
1233};

1235class CIccOpDefRound : public IIccOpDef
1236{
1237public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  for (j=0; j<n; j++) {
    if (s[j]<0.0)
      s[j] = icFloatNumber((int)(s[j]-0.5));
    else
      s[j] = icFloatNumber((int)(s[j]+0.5));
  }
  return true;
}
1253};

1255class CIccOpDefExp : public IIccOpDef
1256{
1257public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  for (j=0; j<n; j++) {
    a1 = s[j];
    s[j] = (icFloatNumber)exp(a1);
  }
  return true;
}
1272};

1274class CIccOpDefLogrithm : public IIccOpDef
1275{
1276public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  for (j=0; j<n; j++) {
    a1 = s[j];
    s[j] = (icFloatNumber)log10(a1);
  }
  return true;
}
1291};

1293class CIccOpDefNaturalLog : public IIccOpDef
1294{
1295public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  for (j=0; j<n; j++) {
    a1 = s[j];
    s[j] = (icFloatNumber)log(a1);
  }
  return true;
}
1310};

1312class CIccOpDefSine : public IIccOpDef
1313{
1314public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  for (j=0; j<n; j++) {
    a1 = s[j];
    s[j] = (icFloatNumber)sin(a1);
  }
  return true;
}
1329};

1331class CIccOpDefCosine : public IIccOpDef
1332{
1333public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  for (j=0; j<n; j++) {
    a1 = s[j];
    s[j] = (icFloatNumber)cos(a1);
  }
  return true;
}
1348};

1350class CIccOpDefTangent : public IIccOpDef
1351{
1352public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  for (j=0; j<n; j++) {
    a1 = s[j];
    s[j] = (icFloatNumber)tan(a1);
  }
  return true;
}
1367};

1369class CIccOpDefArcSine : public IIccOpDef
1370{
1371public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  for (j=0; j<n; j++) {
    a1 = s[j];
    s[j] = (icFloatNumber)asin(a1);
  }
  return true;
}
1386};

1388class CIccOpDefArcCosine : public IIccOpDef
1389{
1390public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  for (j=0; j<n; j++) {
    a1 = s[j];
    s[j] = (icFloatNumber)acos(a1);
  }
  return true;
}
1405};

1407class CIccOpDefArcTangent : public IIccOpDef
1408{
1409public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  for (j=0; j<n; j++) {
    a1 = s[j];
    s[j] = (icFloatNumber)atan(a1);
  }
  return true;
}
1424};

1426class CIccOpDefArcTan2 : public IIccOpDef
1427{
1428public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1, a2;
  int tn = n*2;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  for (j=0; j<n; j++) {
    a1 = s[j];
    a2 = s[j+n];
    s[j] = (icFloatNumber)atan2(a2, a1);
  }
  OsShrinkArgs(n){ icUInt32Number nv = (n); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
1446};

1448class CIccOpDefCartesianToPolar : public IIccOpDef
1449{
1450public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
      int j, n = op->data.select.v1+1;
      icFloatNumber a1, a2;
      int tn = n*2;
      size_t ss = os.pStack->size();
      if (tn>(int)ss)
        return false;
      icFloatNumber *s = &(*os.pStack)[ss-tn];
      for (j=0; j<n; j++) {
        a1 = s[j];
        a2 = s[j+n];
        s[j] = (icFloatNumber)sqrt(a2*a2 + a1*a1);
        icFloatNumber h = (icFloatNumber)atan2(a2, a1) * 180.0f / (icFloatNumber)icPiNum3.14159265358979323846;
        if (h<0.0f)
          h += 360.0f;
        s[j+n] = h;
      }
      return true;
}
1471};

1473class CIccOpDefPolarToCartesian : public IIccOpDef
1474{
1475public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1, a2;
  int tn = n*2;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  for (j=0; j<n; j++) {
    a1 = s[j];
    a2 = s[j+n] * (icFloatNumber)icPiNum3.14159265358979323846 / 180.0f;

    s[j] = a1 * (icFloatNumber)cos(a2);
    s[j+n] = a1 * (icFloatNumber)sin(a2);
  }
  return true;
}
1494};

1496class CIccOpDefLessThan : public IIccOpDef
1497{
1498public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n =op->data.select.v1+1;
  icFloatNumber a1, a2;
  int tn = n*2;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  for (j=0; j<n; j++) {
    a1 = s[j];
    a2 = s[j+n];
    s[j] = (a1 < a2 ? (icFloatNumber)1.0 : (icFloatNumber)0.0);
  }
  OsShrinkArgs(n){ icUInt32Number nv = (n); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
1516};

1518class CIccOpDefRealNumber : public IIccOpDef
1519{
1520public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  icFloatNumber nan = icNotANumber(std::numeric_limits<icFloatNumber>::quiet_NaN());
  for (j=0; j<n; j++) {
    a1 = s[j];
    if (a1==icPosInfinity(std::numeric_limits<icFloatNumber>::infinity()) || a1==icNegInfinity(-std::numeric_limits<icFloatNumber>::infinity()) || !memcmp(&a1,&nan, sizeof(nan)))
      s[j] = 0.0;
    else
      s[j] = 1.0;
  }
  return true;
}
1539};

1541class CIccOpDefLessThanEqual : public IIccOpDef
1542{
1543public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1, a2;
  int tn = n*2;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  for (j=0; j<n; j++) {
    a1 = s[j];
    a2 = s[j+n];
    s[j] = (a1 <= a2 ? (icFloatNumber)1.0 : (icFloatNumber)0.0);
  }
  OsShrinkArgs(n){ icUInt32Number nv = (n); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
1561};

1563class CIccOpDefEqual : public IIccOpDef
1564{
1565public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1, a2;
  int tn = n*2;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber nan = icNotANumber(std::numeric_limits<icFloatNumber>::quiet_NaN());
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  for (j=0; j<n; j++) {
    a1 = s[j];
    a2 = s[j+n];
    s[j] = (a1 == a2 ? 
             (icFloatNumber)1.0 : 
             ((!memcmp(&a1, &nan, sizeof(icFloatNumber)) && !memcmp(&a1, &a2, sizeof(a1))) ? 
               (icFloatNumber)1.0 : 
               (icFloatNumber)0.0));
  }
  OsShrinkArgs(n){ icUInt32Number nv = (n); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
1588};

1590class CIccOpDefNear : public IIccOpDef
1591{
1592public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1, a2;
  int tn = n*2;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  for (j=0; j<n; j++) {
    a1 = s[j];
    a2 = s[j+n];
    s[j] = (fabs(a1-a2)<1.0e-5 ? (icFloatNumber)1.0 : (icFloatNumber)0.0);
  }
  OsShrinkArgs(n){ icUInt32Number nv = (n); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
1610};

1612class CIccOpDefGreaterThanEqual : public IIccOpDef
1613{
1614public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1, a2;
  int tn = n*2;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  for (j=0; j<n; j++) {
    a1 = s[j];
    a2 = s[j+n];
    s[j] = (a1 >= a2 ? (icFloatNumber)1.0 : (icFloatNumber)0.0);
  }
  OsShrinkArgs(n){ icUInt32Number nv = (n); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
1632};

1634class CIccOpDefGreaterThan : public IIccOpDef
1635{
1636public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1, a2;
  int tn = n*2;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  for (j=0; j<n; j++) {
    a1 = s[j];
    a2 = s[j+n];
    s[j] = (a1 > a2 ? (icFloatNumber)1.0 : (icFloatNumber)0.0);
  }
  OsShrinkArgs(n){ icUInt32Number nv = (n); size_t ss = os.pStack->size(); if
 (nv>ss) return false; os.pStack->resize(ss-nv); };
  return true;
}
1654};

1656class CIccOpDefNot : public IIccOpDef
1657{
1658public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  for (j=0; j<n; j++) {
    a1 = s[j];
    s[j] = (a1 >= (icFloatNumber)0.5 ? (icFloatNumber)0.0 : (icFloatNumber)1.0);
  }
  return true;
}
1673};

1675class CIccOpDefNeg : public IIccOpDef
1676{
1677public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  icFloatNumber a1;
  size_t ss = os.pStack->size();
  if (n>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-n];
  for (j=0; j<n; j++) {
    a1 = s[j];
    s[j] = -a1;
  }
  return true;
}
1692};

1694class CIccOpDefToLab : public IIccOpDef
1695{
1696public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  int n2 = n+n;
  int tn = n*3;
  icFloatNumber a1, a2, a3;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber *s = &(*os.pStack)[ss-tn];
  for (j=0; j<n; j++) {
    a1 = icCubeth(s[j]);
    a2 = icCubeth(s[j+n]);
    a3 = icCubeth(s[j+n2]);

    s[j] = (icFloatNumber)(116.0 * a2 - 16.0);
    s[j+n] = (icFloatNumber)(500.0 * (a1 - a2));
    s[j+n2] = (icFloatNumber)(200.0 * (a2 - a3));
  }
  return true;
}
1718};

1720class CIccOpDefFromLab : public IIccOpDef
1721{
1722public:
virtual bool Exec(SIccCalcOp *op, SIccOpState &os)
{
  int j, n = op->data.select.v1+1;
  int n2 = n+n;
  int tn = n*3;
  icFloatNumber a1, a2, a3;
  size_t ss = os.pStack->size();
  if (tn>(int)ss)
    return false;
  icFloatNumber fy, *s = &(*os.pStack)[ss-tn];
  for (j=0; j<n; j++) {
    a1 = s[j];
    a2 = s[j+n];
    a3 = s[j+n2];

    fy = (icFloatNumber)((a1 + 16.0f) / 116.0f);

    s[j] = icICubeth((icFloatNumber)(a2/500.0 + fy));
    s[j+n] = icICubeth(fy);
    s[j+n2] = icICubeth((icFloatNumber)(fy - a3/200.0));
  }
  return true;
}
1746};



1750/**
1751******************************************************************************
1752* Name: SIccCalcOp::Describe
1753* 
1754* Purpose: 
1755* 
1756* Args: 
1757* 
1758* Return: 
1759******************************************************************************/
1760void SIccCalcOp::Describe(std::string &desc)
1761{ 
char buf[300];
if (sig==icSigDataOp) {
  sprintf(buf, "%.8g", data.num);
  desc = buf;
  return;
}

char name[10];
int i;

icGetSig(name, sig, false);
name[5]=0;
for (i=4; i>0; i--)
  if (name[i]==' ')
    name[i] = 0;
if (!name[1])
  name[1] = '?';
desc = &name[1];

switch (sig) {
  case icSigInputChanOp:        
  case icSigOutputChanOp:        
  case icSigTempGetChanOp:  
  case icSigTempPutChanOp:
  case icSigTempSaveChanOp:
    if (!data.select.v2)
      sprintf(buf, "[%d]", data.select.v1);
    else
      sprintf(buf, "[%d,%d]", data.select.v1, data.select.v2+1);
    desc += buf;
    break;

  case icSigEnvVarOp:
    {
      char varName[10];
      icGetSigStr(varName, (icSignature)data.size);
      int l=(int)strlen(varName);
      if (l==9) { //Remove h at end
        varName[8]=0;
      }
      else {
        for (l--; l>0; l--) {
          if (varName[l]!=' ')
            break;
          varName[l]=0;
        }
      }
      sprintf(buf, "(%s)", varName);
      desc += buf;
    }
    break;
  
  case icSigApplyCurvesOp:
  case icSigApplyMatrixOp:
  case icSigApplyCLutOp:
  case icSigApplyTintOp:
  case icSigApplyToJabOp:
  case icSigApplyFromJabOp:
  case icSigApplyCalcOp:
  case icSigApplyElemOp:
    sprintf(buf, "(%d)", data.select.v1);
    desc += buf;
    break;

  case icSigPopOp:
    sprintf(buf, "(%d)", data.select.v1+1);
    desc += buf;
    break;

  case icSigSolveOp:
  case icSigTransposeOp:
    sprintf(buf, "(%d,%d)", data.select.v1+1, data.select.v2+1);
    desc += buf;
    break;

  case icSigRotateLeftOp:       
  case icSigRotateRightOp:
    sprintf(buf, "(%d,%d)", data.select.v1, data.select.v2);
    break;

  case icSigCopyOp:             
  case icSigPositionDupOp:
    if (!data.select.v2) {
      if (data.select.v1) {
        sprintf(buf, "(%d)", data.select.v1+1);
        desc += buf;
      }
    }
    else {
      sprintf(buf, "(%d,%d)", data.select.v1+1, data.select.v2+1);
      desc += buf;
    }
    break;

  case icSigFlipOp:
  case icSigSumOp:
  case icSigProductOp:
  case icSigMinimumOp:
  case icSigMaximumOp:
  case icSigAndOp:
  case icSigOrOp:
    if (data.select.v1) {
      sprintf(buf, "(%d)", data.select.v1+2);
      desc += buf;
    }
    break;

  case icSigGammaOp:
  case icSigScalarAddOp:
  case icSigScalarSubtractOp:
  case icSigScalarMultiplyOp:
  case icSigScalarDivideOp:
  case icSigAddOp:
  case icSigSubtractOp:
  case icSigMultiplyOp:
  case icSigDivideOp:
  case icSigModulusOp:
  case icSigPowOp:
  case icSigArcTan2Op:          
  case icSigLessThanOp:         
  case icSigLessThanEqualOp:    
  case icSigEqualOp:
  case icSigNearOp:
  case icSigGreaterThanEqualOp: 
  case icSigGreaterThanOp:
  case icSigSquareOp:       
  case icSigSquareRootOp:       
  case icSigCubeOp:       
  case icSigCubeRootOp:
  case icSigSignOp:
  case icSigAbsoluteValOp:
  case icSigTruncateOp:
  case icSigFloorOp:
  case icSigCeilingOp:
  case icSigRoundOp:
  case icSigRealNumberOp:
  case icSigNegOp:      
  case icSigExpOp:              
  case icSigLogrithmOp:         
  case icSigNaturalLogOp:       
  case icSigSineOp:             
  case icSigCosineOp:             
  case icSigTangentOp:
  case icSigArcSineOp:          
  case icSigArcCosineOp:        
  case icSigArcTangentOp:      
  case icSigCartesianToPolarOp:
  case icSigPolarToCartesianOp:
  case icSigNotOp:
  case icSigToLabOp:
  case icSigToXYZOp:
  case icSigVectorMinimumOp:
  case icSigVectorMaximumOp:
  case icSigVectorAndOp:
  case icSigVectorOrOp:
    if (data.select.v1) {
      sprintf(buf, "[%d]", data.select.v1+1);
      desc += buf;
    }
    break;
}
1923}

1925typedef std::map<icSigCalcOp, IIccOpDef*> icCalcOpMap;

1927class CIccCalcOpMgr
1928{
CIccCalcOpMgr();
static CIccCalcOpMgr* m_inst;
1931public:
static CIccCalcOpMgr* GetInstance();
static IIccOpDef *getOpDef(icSigCalcOp opSig);

1935protected:
icCalcOpMap m_map;
CIccOpDefInvalid m_invalid;
1938};
1939CIccCalcOpMgr *CIccCalcOpMgr::m_inst = NULL__null;

1941CIccCalcOpMgr::CIccCalcOpMgr()
1942{
m_map[icSigDataOp] = new CIccOpDefData();            
m_map[icSigInputChanOp] = new CIccOpDefInputChan();        
m_map[icSigOutputChanOp] = new CIccOpDefOutputChan(); 
m_map[icSigTempGetChanOp] = new CIccOpDefTempGetChan();
m_map[icSigTempPutChanOp] = new CIccOpDefTempPutChan();
m_map[icSigTempSaveChanOp] = new CIccOpDefTempSaveChan();
m_map[icSigEnvVarOp] = new CIccOpDefEnvVar();
m_map[icSigApplyCurvesOp] = new CIccOpDefSubElement();
m_map[icSigApplyMatrixOp] = new CIccOpDefSubElement();
m_map[icSigApplyCLutOp] = new CIccOpDefSubElement();
m_map[icSigApplyTintOp] = new CIccOpDefSubElement();
m_map[icSigApplyToJabOp] = new CIccOpDefSubElement();
m_map[icSigApplyFromJabOp] = new CIccOpDefSubElement();
m_map[icSigApplyCalcOp] = new CIccOpDefSubElement();
m_map[icSigApplyElemOp] = new CIccOpDefSubElement();
m_map[icSigCopyOp] = new CIccOpDefCopy();             
m_map[icSigRotateLeftOp] = new CIccOpDefRotateLeft();       
m_map[icSigRotateRightOp] = new CIccOpDefRotateRight();
m_map[icSigPositionDupOp] = new CIccOpDefPositionDup();
m_map[icSigFlipOp] = new CIccOpDefFlip();
m_map[icSigPopOp] = new CIccOpDefPop();
m_map[icSigSolveOp] = new CIccOpDefSolve();
m_map[icSigTransposeOp] = new CIccOpDefTranspose();
m_map[icSigPiOp] = new CIccOpDefPi(); 
m_map[icSigPosInfinityOp] = new CIccOpDefPosInfinity();
m_map[icSigNegInfinityOp] = new CIccOpDefNegInfinity();
m_map[icSigNotaNumberOp] = new CIccOpDefNotANumber(); 
m_map[icSigSumOp] = new CIccOpDefSum();
m_map[icSigProductOp] = new CIccOpDefProduct();
m_map[icSigAddOp] = new CIccOpDefAdd();
m_map[icSigSubtractOp] = new CIccOpDefSubtract();         
m_map[icSigMultiplyOp] = new CIccOpDefMultiply();         
m_map[icSigDivideOp] = new CIccOpDefDivide();           
m_map[icSigModulusOp] = new CIccOpDefModulus();           
m_map[icSigPowOp] = new CIccOpDefPow();
m_map[icSigGammaOp] = new CIccOpDefGamma();
m_map[icSigScalarAddOp] = new CIccOpDefScalarAdd();
m_map[icSigScalarSubtractOp] = new CIccOpDefScalarSubtract();
m_map[icSigScalarMultiplyOp] = new CIccOpDefScalarMultiply();
m_map[icSigScalarDivideOp] = new CIccOpDefScalarDivide();
m_map[icSigSquareOp] = new CIccOpDefSquare();       
m_map[icSigSquareRootOp] = new CIccOpDefSquareRoot();       
m_map[icSigCubeOp] = new CIccOpDefCube();       
m_map[icSigCubeRootOp] = new CIccOpDefCubeRoot();       
m_map[icSigSignOp] = new CIccOpDefSign();
m_map[icSigAbsoluteValOp] = new CIccOpDefAbsoluteVal();
m_map[icSigTruncateOp] = new CIccOpDefTruncate();      
m_map[icSigFloorOp] = new CIccOpDefFloor();      
m_map[icSigCeilingOp] = new CIccOpDefCeiling();      
m_map[icSigRoundOp] = new CIccOpDefRound();      
m_map[icSigNegOp] = new CIccOpDefNeg();
m_map[icSigExpOp] = new CIccOpDefExp();              
m_map[icSigLogrithmOp] = new CIccOpDefLogrithm();         
m_map[icSigNaturalLogOp] = new CIccOpDefNaturalLog();       
m_map[icSigSineOp] = new CIccOpDefSine();             
m_map[icSigCosineOp] = new CIccOpDefCosine();             
m_map[icSigTangentOp] = new CIccOpDefTangent();          
m_map[icSigArcSineOp] = new CIccOpDefArcSine();          
m_map[icSigArcCosineOp] = new CIccOpDefArcCosine();        
m_map[icSigArcTangentOp] = new CIccOpDefArcTangent();      
m_map[icSigArcTan2Op] = new CIccOpDefArcTan2();
m_map[icSigCartesianToPolarOp] = new CIccOpDefCartesianToPolar();
m_map[icSigPolarToCartesianOp] = new CIccOpDefPolarToCartesian();
m_map[icSigVectorMinimumOp] = new CIccOpDefVectorMinimum();
m_map[icSigVectorMaximumOp] = new CIccOpDefVectorMaximum();
m_map[icSigVectorAndOp] = new CIccOpDefVectorAnd();
m_map[icSigVectorOrOp] = new CIccOpDefVectorOr();
m_map[icSigMinimumOp] = new CIccOpDefMinimum();          
m_map[icSigMaximumOp] = new CIccOpDefMaximum();          
m_map[icSigRealNumberOp] = new CIccOpDefRealNumber();
m_map[icSigLessThanOp] = new CIccOpDefLessThan();         
m_map[icSigLessThanEqualOp] = new CIccOpDefLessThanEqual();    
m_map[icSigEqualOp] = new CIccOpDefEqual();
m_map[icSigNearOp] = new CIccOpDefNear();
m_map[icSigGreaterThanEqualOp] = new CIccOpDefGreaterThanEqual(); 
m_map[icSigGreaterThanOp] = new CIccOpDefGreaterThan();
m_map[icSigAndOp] = new CIccOpDefAnd();
m_map[icSigOrOp] = new CIccOpDefOr();
m_map[icSigNotOp] = new CIccOpDefNot();
m_map[icSigToLabOp] = new CIccOpDefToLab();
m_map[icSigToXYZOp] = new CIccOpDefFromLab();
2024}

2026CIccCalcOpMgr *CIccCalcOpMgr::GetInstance()
2027{
if (!m_inst)
  m_inst = new CIccCalcOpMgr();
return m_inst;
2031}


2034/**
2035******************************************************************************
2036* Name: SIccCalcOp::IsValidOp
2037* 
2038* Purpose: 
2039* 
2040* Args: 
2041* 
2042* Return: 
2043******************************************************************************/
2044bool SIccCalcOp::IsValidOp(icSigCalcOp sig)
2045{
switch (sig) {
  case icSigDataOp:          
  case icSigInputChanOp:        
  case icSigOutputChanOp: 
  case icSigTempGetChanOp:
  case icSigTempPutChanOp:
  case icSigTempSaveChanOp:
  case icSigEnvVarOp:
  case icSigApplyCurvesOp:
  case icSigApplyMatrixOp:
  case icSigApplyCLutOp:
  case icSigApplyTintOp:
  case icSigApplyToJabOp:
  case icSigApplyFromJabOp:
  case icSigApplyCalcOp:
  case icSigApplyElemOp:
  case icSigCopyOp:             
  case icSigRotateLeftOp:       
  case icSigRotateRightOp:
  case icSigPositionDupOp:
  case icSigFlipOp:
  case icSigPopOp:
  case icSigSolveOp:
  case icSigTransposeOp:
  case icSigPiOp: 
  case icSigPosInfinityOp:
  case icSigNegInfinityOp:
  case icSigNotaNumberOp:
  case icSigSumOp:
  case icSigProductOp:
  case icSigAddOp:
  case icSigSubtractOp:         
  case icSigMultiplyOp:         
  case icSigDivideOp:
  case icSigModulusOp:
  case icSigPowOp:
  case icSigGammaOp:
  case icSigScalarAddOp:
  case icSigScalarSubtractOp:
  case icSigScalarMultiplyOp:
  case icSigScalarDivideOp:
  case icSigSquareOp:       
  case icSigSquareRootOp:       
  case icSigCubeOp:       
  case icSigCubeRootOp:
  case icSigSignOp:
  case icSigAbsoluteValOp:
  case icSigTruncateOp:
  case icSigFloorOp:
  case icSigCeilingOp:
  case icSigRoundOp:
  case icSigNegOp:
  case icSigExpOp:              
  case icSigLogrithmOp:         
  case icSigNaturalLogOp:       
  case icSigSineOp:             
  case icSigCosineOp:             
  case icSigTangentOp:          
  case icSigArcSineOp:          
  case icSigArcCosineOp:        
  case icSigArcTangentOp:      
  case icSigArcTan2Op:
  case icSigCartesianToPolarOp:
  case icSigPolarToCartesianOp:
  case icSigVectorMinimumOp:
  case icSigVectorMaximumOp:
  case icSigVectorAndOp:
  case icSigVectorOrOp:
  case icSigMinimumOp:          
  case icSigMaximumOp:          
  case icSigRealNumberOp:
  case icSigLessThanOp:         
  case icSigLessThanEqualOp:    
  case icSigEqualOp:
  case icSigNearOp:
  case icSigGreaterThanEqualOp: 
  case icSigGreaterThanOp:
  case icSigAndOp:
  case icSigOrOp:
  case icSigNotOp:
  case icSigToLabOp:
  case icSigToXYZOp:
  case icSigIfOp:
  case icSigElseOp:
  case icSigSelectOp:
  case icSigCaseOp:
  case icSigDefaultOp:
    return true;

  default:
    return false;
}
2138}

2140IIccOpDef *CIccCalcOpMgr::getOpDef(icSigCalcOp opSig)
2141{
icCalcOpMap::iterator pos;
CIccCalcOpMgr *inst = GetInstance();
pos = inst->m_map.find(opSig);
if (pos==inst->m_map.end())
  return &inst->m_invalid;
return pos->second;
2148}



2152/******************************************************************************
2153* Name: SIccCalcOp::IsValidOp
2154* 
2155* Purpose: 
2156* 
2157* Args: 
2158* 
2159* Return: 
2160******************************************************************************/
2161bool SIccCalcOp::IsValidOp(CIccMpeCalculator *pCalc)
2162{
switch(sig) {
  case icSigApplyCurvesOp:
  case icSigApplyMatrixOp:
  case icSigApplyCLutOp:
  case icSigApplyTintOp:
  case icSigApplyToJabOp:
  case icSigApplyFromJabOp:
  case icSigApplyCalcOp:
  case icSigApplyElemOp:
    {
      CIccMultiProcessElement *pMpe = pCalc->GetElem(sig, data.select.v1);
      return pMpe != NULL__null;
    }

  default:
    return IsValidOp(sig);
}
2180}

2182/**
2183******************************************************************************
2184* Name: SIccCalcOp::ArgsUsed
2185* 
2186* Purpose: 
2187* 
2188* Args: 
2189* 
2190* Return: 
2191******************************************************************************/
2192icUInt16Number SIccCalcOp::ArgsUsed(CIccMpeCalculator *pCalc)
2193{
switch (sig) {
  case icSigDataOp:
  case icSigPiOp:
  case icSigPosInfinityOp:
  case icSigNegInfinityOp:
  case icSigNotaNumberOp:
  case icSigInputChanOp:        
  case icSigTempGetChanOp:
  case icSigEnvVarOp:
    return 0;

  case icSigApplyCurvesOp:
  case icSigApplyMatrixOp:
  case icSigApplyCLutOp:
  case icSigApplyTintOp:
  case icSigApplyToJabOp:
  case icSigApplyFromJabOp:
  case icSigApplyCalcOp:
  case icSigApplyElemOp:
    {
      CIccMultiProcessElement *pMpe = pCalc->GetElem(sig, data.select.v1);
      return (pMpe ? pMpe->NumInputChannels() : 0);
    }

  case icSigOutputChanOp:
  case icSigTempPutChanOp:
  case icSigTempSaveChanOp:
    return data.select.v2+1;

  case icSigCopyOp:
  case icSigRotateLeftOp:       
  case icSigRotateRightOp:
  case icSigPositionDupOp:
  case icSigPopOp:
    return data.select.v1+1;

  case icSigSolveOp:
    return (data.select.v1+1)*(data.select.v2+1) + (data.select.v1+1);

  case icSigTransposeOp:
    return (data.select.v1+1)*(data.select.v2+1);

  case icSigFlipOp:
    return data.select.v1+2;

  case icSigSumOp:              
  case icSigProductOp:         
  case icSigMinimumOp:          
  case icSigMaximumOp:          
  case icSigAndOp:
  case icSigOrOp:
    return data.select.v1+2;

  case icSigGammaOp:
  case icSigScalarAddOp:
  case icSigScalarSubtractOp:
  case icSigScalarMultiplyOp:
  case icSigScalarDivideOp:
    return data.select.v1+2;

  case icSigAddOp:
  case icSigSubtractOp:
  case icSigMultiplyOp:
  case icSigDivideOp:
  case icSigModulusOp:
  case icSigPowOp:
  case icSigArcTan2Op:          
  case icSigLessThanOp:         
  case icSigLessThanEqualOp:    
  case icSigEqualOp:
  case icSigNearOp:
  case icSigGreaterThanEqualOp: 
  case icSigGreaterThanOp:
  case icSigCartesianToPolarOp:
  case icSigPolarToCartesianOp:
  case icSigVectorMinimumOp:
  case icSigVectorMaximumOp:
  case icSigVectorAndOp:
  case icSigVectorOrOp:
    return (data.select.v1+1)*2;

  case icSigSquareOp:       
  case icSigSquareRootOp:       
  case icSigCubeOp:       
  case icSigCubeRootOp:
  case icSigSignOp:
  case icSigAbsoluteValOp:
  case icSigTruncateOp:
  case icSigFloorOp:
  case icSigCeilingOp:
  case icSigRoundOp:
  case icSigRealNumberOp:
  case icSigNegOp:      
  case icSigExpOp:              
  case icSigLogrithmOp:         
  case icSigNaturalLogOp:       
  case icSigSineOp:             
  case icSigCosineOp:             
  case icSigTangentOp:          
  case icSigArcSineOp:          
  case icSigArcCosineOp:        
  case icSigArcTangentOp:      
  case icSigNotOp:
    return data.select.v1+1;
  
  case icSigToLabOp:
  case icSigToXYZOp:
    return (data.select.v1+1)*3;

  case icSigIfOp:
  case icSigSelectOp:
    return 1;

  default:
    return 0;
}
2310}


2313/**
2314******************************************************************************
2315* Name: SIccCalcOp::ArgsPushed
2316* 
2317* Purpose: 
2318* 
2319* Args: 
2320* 
2321* Return: 
2322******************************************************************************/
2323icUInt16Number SIccCalcOp::ArgsPushed(CIccMpeCalculator *pCalc)
2324{
switch (sig) {
  case icSigOutputChanOp:
  case icSigTempPutChanOp:

  case icSigPopOp:
  case icSigIfOp:
  case icSigSelectOp:
    /*case icSigElseOp:*/     //This is only valid after an icSigIfOp is parsed
    /*case icSigCaseOp:*/     //This is only valid after an icSigSelectOp is parsed
    /*case icSigDefaultOp:*/  //This is only valid after an icSigSelectOp is parsed
    return 0;

  case icSigDataOp:            
  case icSigPiOp:
  case icSigPosInfinityOp:
  case icSigNegInfinityOp:
  case icSigNotaNumberOp:
    return 1;

  case icSigEnvVarOp:
    return 2;

  case icSigInputChanOp:        
  case icSigTempGetChanOp:
  case icSigTempSaveChanOp:
    return data.select.v2+1;

  case icSigApplyCurvesOp:
  case icSigApplyMatrixOp:
  case icSigApplyCLutOp:
  case icSigApplyTintOp:
  case icSigApplyToJabOp:
  case icSigApplyFromJabOp:
  case icSigApplyCalcOp:
  case icSigApplyElemOp:
    {
      CIccMultiProcessElement *pMpe = pCalc->GetElem(sig, data.select.v1);
      return (pMpe ? pMpe->NumOutputChannels() : 0);
    }

  case icSigCopyOp:             
    return (data.select.v1+1)*(data.select.v2+2);
  case icSigRotateLeftOp:       
  case icSigRotateRightOp:
    return (data.select.v1+1);

  case icSigFlipOp:
    return (data.select.v1+2);

  case icSigPositionDupOp:
    return data.select.v1+2+data.select.v2;

  case icSigSolveOp:
    return (data.select.v2+1) + 1;

  case icSigTransposeOp:
    return (data.select.v1+1)*(data.select.v2+1);

  case icSigSumOp:
  case icSigProductOp:         
  case icSigMinimumOp:          
  case icSigMaximumOp:          
  case icSigAndOp:
  case icSigOrOp:
    return 1;

  case icSigAddOp:              
  case icSigSubtractOp:         
  case icSigMultiplyOp:         
  case icSigDivideOp:
  case icSigModulusOp:
  case icSigPowOp:              
  case icSigGammaOp:
  case icSigScalarAddOp:
  case icSigScalarSubtractOp:
  case icSigScalarMultiplyOp:
  case icSigScalarDivideOp:
  case icSigSquareOp:       
  case icSigSquareRootOp:       
  case icSigCubeOp:       
  case icSigCubeRootOp:
  case icSigSignOp:
  case icSigAbsoluteValOp:
  case icSigTruncateOp:
  case icSigFloorOp:
  case icSigCeilingOp:
  case icSigRoundOp:
  case icSigRealNumberOp:
  case icSigNegOp:
  case icSigExpOp:              
  case icSigLogrithmOp:         
  case icSigNaturalLogOp:       
  case icSigSineOp:             
  case icSigCosineOp:             
  case icSigTangentOp:          
  case icSigArcSineOp:          
  case icSigArcCosineOp:        
  case icSigArcTangentOp:      
  case icSigArcTan2Op:
  case icSigLessThanOp:         
  case icSigLessThanEqualOp:    
  case icSigEqualOp:
  case icSigNearOp:
  case icSigGreaterThanEqualOp: 
  case icSigGreaterThanOp:
  case icSigNotOp:
  case icSigVectorMinimumOp:
  case icSigVectorMaximumOp:
  case icSigVectorAndOp:
  case icSigVectorOrOp:
    return data.select.v1+1;

  case icSigCartesianToPolarOp:
  case icSigPolarToCartesianOp:
    return (data.select.v1+1)*2;

  case icSigToLabOp:
  case icSigToXYZOp:
    return (data.select.v1+1)*3;

  default:
    return 0;
}
2448}

2450CIccFuncTokenizer::CIccFuncTokenizer(const char *szText, bool bAllowNamedReferences)
2451{
m_token = new std::string();
m_text = szText;
m_bUseRefs = bAllowNamedReferences;
2455}

2457CIccFuncTokenizer::~CIccFuncTokenizer()
2458{
delete m_token;
2460}


2463bool CIccFuncTokenizer::GetNext(bool bForceNoRefs)
2464{
m_token->clear();

2467try_again:

while (*m_text && IsWhiteSpace())
  m_text++;

if (!*m_text) {
  return false;
}

if (!m_bUseRefs || bForceNoRefs) {
  if (*m_text == '{') {
    m_text++;
    *m_token = "{";
    return true;
  }

  if (*m_text == '}') {
    m_text++;
    *m_token = "}";
    return true;
  }

  if (*m_text == '[') {
    m_text++;
    *m_token = "[";
    while (*m_text && *m_text != ']') {
      *m_token += *m_text;
      m_text++;
    }
  }

  if (*m_text == '(') {
    m_text++;
    *m_token = "(";
    while (*m_text && *m_text != ')') {
      *m_token += *m_text;
      m_text++;
    }
    if (!*m_text) {
      return false;
    }
  }
}

if (!*m_text) {
  return false;
}

if (IsComment()) {
  SkipComment();
  goto try_again;
}

if (m_bUseRefs && !bForceNoRefs) {
  while (!IsWhiteSpace() && *m_text && !IsComment()) {
    *m_token += *m_text;
    m_text++;
  }
}
else {
  while (!IsWhiteSpace() && *m_text && *m_text != '{' && *m_text != '[' &&
         *m_text != '(' &&  *m_text != '}' && !IsComment()) {
    *m_token += *m_text;
    m_text++;
  }
}
return true;
2534}


2537icSigCalcOp CIccFuncTokenizer::GetSig()
2538{
const unsigned char *szToken = (unsigned char*) m_token->c_str();
int i;

if ((szToken[0]>='0' && szToken[0]<='9') || szToken[0]=='.' || (szToken[0]=='-' && szToken[1]!='I')) {
  return icSigDataOp;
}

if (szToken[0]=='{')
  return icSigBeginBlockOp((icSigCalcOp)0x7b202020);

if (szToken[0]=='}')
  return icSigEndBlockOp((icSigCalcOp)0x7d202020);

if (szToken[0]=='[')
  return icSigBadOp((icSigCalcOp)0); 

icUInt32Number sig = 0;
for (i=0; i<4 && szToken[i]; i++) {
  sig <<= 8;
  sig |= szToken[i];
}

for (;i<4; i++) {
  sig <<= 8;
  sig |= 0x20;
}

return (icSigCalcOp)sig;
2567}

2569std::string CIccFuncTokenizer::GetName() const
2570{
std::string rv;
const char *pos = m_token->c_str();

while (*pos && *pos != '{' && *pos != '[' && *pos != '(') {
  rv += *pos;
  pos++;
}

return rv;
2580}

2582std::string CIccFuncTokenizer::GetReference() const
2583{
const char *pos = strchr(m_token->c_str(), '{');
if (!m_bUseRefs || !pos)
  return "";

std::string rv;
pos++;
while (*pos && *pos != '}') {
  rv += *pos;
  pos++;
}

return rv;
2596}

2598bool CIccFuncTokenizer::GetIndex(icUInt16Number &v1, icUInt16Number &v2, icUInt16Number initV1, icUInt16Number initV2)
2599{
unsigned int iv1, iv2;
const char *pos = GetPos();

if (!GetNext(true))
  return false;
iv1=initV1;
iv2=initV2;
const char *szToken = m_token->c_str();
if (*szToken=='[' || *szToken=='(') {
  if (strchr(szToken, ',')) {
    if (*szToken=='(') 
      sscanf(m_token->c_str(), "(%u,%u)", &iv1, &iv2);
    else 
      sscanf(m_token->c_str(), "[%u,%u]", &iv1, &iv2);
  }
  else {
    if (*szToken=='(')
      sscanf(m_token->c_str(), "(%u)", &iv1);
    else 
      sscanf(m_token->c_str(), "[%u]", &iv1);
  }
}
else {
  SetPos(pos); //Undo get token
}
v1 = (icUInt16Number)iv1 - initV1;
v2 = (icUInt16Number)iv2 - initV2;

return true;
2629}


2632icFloat32Number CIccFuncTokenizer::GetValue()
2633{
const char * ascii = m_token->c_str();
char * p = NULL__null;
double d = strtod( ascii, &p );
return (icFloat32Number)d;
2638}


2641bool CIccFuncTokenizer::GetEnvSig(icSigCmmEnvVar &envSig)
2642{
const char *pos = GetPos();

if (!GetNext())
  return false;
const char *szToken = m_token->c_str();
int l=(int)strlen(szToken);
if ((*szToken=='[' && szToken[l-1]==']') ||
    (*szToken=='(' && szToken[l-1]==')')) {

  int i;

  icUInt32Number sig = 0;
  if (l==10) {
    sscanf(szToken+1, "%x", &sig);

    envSig = (icSigCmmEnvVar)sig;
    return true;
  }

  for (i=1; i<=4 && i<l-1; i++) {
    sig <<= 8;
    sig |= szToken[i];
  }

  for (;i<=4; i++) {
    sig <<= 8;
    sig |= 0x20;
  }

  envSig = (icSigCmmEnvVar)sig;
}
else {
  SetPos(pos); //Undo get token
  envSig = (icSigCmmEnvVar)0;
  return false;
}

return true;
2681}


2684bool CIccFuncTokenizer::IsWhiteSpace()
2685{
if (*m_text==' ' || *m_text=='\n' || *m_text=='\r' || *m_text=='\t')
  return true;
return false;
2689}

2691bool CIccFuncTokenizer::IsComment()
2692{
if (*m_text=='%' || *m_text==';' || *m_text=='/')
  return true;
return false;
2696}

2698void CIccFuncTokenizer::SkipComment()
2699{
while(*m_text && !(*m_text=='\n' || *m_text=='\r')) {
  m_text++;
}
2703}

2705/**
******************************************************************************
* Name: CIccCalculatorFunc::CIccCalculatorFunc
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2715CIccCalculatorFunc::CIccCalculatorFunc(CIccMpeCalculator *pCalc)
2716{
m_pCalc = pCalc;
m_nReserved = 0;

m_nOps = 0;
m_Op = NULL__null;
2722}

2724/**
******************************************************************************
* Name: CIccCalculatorFunc::CIccCalculatorFunc
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2734CIccCalculatorFunc::CIccCalculatorFunc(const CIccCalculatorFunc &func)
2735{
m_pCalc = func.m_pCalc;

m_nReserved= func.m_nReserved;

m_nOps = func.m_nOps;

if (m_nOps) {
  m_Op = (SIccCalcOp*)malloc(m_nOps * sizeof(SIccCalcOp));
  memcpy(m_Op, func.m_Op, m_nOps*sizeof(SIccCalcOp));
}
else
  m_Op = NULL__null;
2748}

2750/**
******************************************************************************
* Name: &CIccCalculatorFunc::operator=
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2760CIccCalculatorFunc &CIccCalculatorFunc::operator=(const CIccCalculatorFunc &func)
2761{
m_pCalc = func.m_pCalc;

m_nReserved= func.m_nReserved;

if (m_Op)
  free(m_Op);

m_nOps = func.m_nOps;

if (m_nOps) {
  m_Op = (SIccCalcOp*)malloc(m_nOps * sizeof(SIccCalcOp));
  memcpy(m_Op, func.m_Op, m_nOps*sizeof(SIccCalcOp));
}
else
  m_Op = NULL__null;

return (*this);
2779}

2781/**
******************************************************************************
* Name: CIccCalculatorFunc::~CIccChannelFunc
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2791CIccCalculatorFunc::~CIccCalculatorFunc()
2792{
if (m_Op) {
  free(m_Op);
}
2796}

2798void CIccCalculatorFunc::InsertBlanks(std::string &sDescription, int nBlanks)
2799{
char blanks[21]="                    ";
int i;

while (nBlanks>0) {
  i =  nBlanks < 20 ? nBlanks : 20;
  blanks[i] = 0;
  sDescription += blanks;
  nBlanks -= i;
}
2809}

2811void CIccCalculatorFunc::DescribeSequence(std::string &sDescription,
                                     icUInt32Number nOps, SIccCalcOp *op, int nBlanks)
2813{
icUInt32Number i;
int pos;
std::string opName;
std::string funcDesc;

InsertBlanks(funcDesc, nBlanks);
funcDesc += "{ ";

pos = nBlanks + 2;

for (i=0; i<nOps;) {
  if (pos >nBlanks + 65) {
    funcDesc += "\n";
    InsertBlanks(funcDesc, nBlanks + 2);
    pos = nBlanks + 2;
  }

  op->Describe(opName);
  funcDesc += opName;
  funcDesc += " ";
  pos += opName.size() + 1;

  if (op->sig == icSigIfOp) {
    SIccCalcOp *ifop = op;

    if  (i+1<nOps && op[1].sig == icSigElseOp) {
      SIccCalcOp *elseop = &op[1];
      icUInt32Number nSubOps = (icUInt32Number)icIntMin(nOps-i, ifop->data.size);
      op++;
      i++;
      funcDesc += "\n";
      DescribeSequence(funcDesc, nSubOps, &op[1], nBlanks+2);
      op += nSubOps;
      i += nSubOps;

      InsertBlanks(funcDesc, nBlanks+2);
      funcDesc += "else\n";
      pos = 0;

      nSubOps = (icUInt32Number)icIntMin(nOps-i, elseop->data.size);
      DescribeSequence(funcDesc, nSubOps, &op[1], nBlanks+2);
      op += nSubOps;
      i += nSubOps;
    }
    else {
      icUInt32Number nSubOps = (icUInt32Number)icIntMin(nOps-i, ifop->data.size);
      funcDesc += "\n";
      DescribeSequence(funcDesc, nSubOps, &op[1], nBlanks+2);
      op += nSubOps;
      i += nSubOps;
    }

    InsertBlanks(funcDesc, nBlanks + 2);
    pos = nBlanks + 2;
  }
  else if (op->sig == icSigSelectOp) {
    op++;
    i++;
    funcDesc += "\n";

    int j, n;

    for (n=0; i+n<nOps; ) {
      if (op[n].sig==icSigCaseOp)
        n++;
      else if (n>1 && op[n].sig==icSigDefaultOp) {
        n++;
        break;
      }
      else
        break;
    }

    int p = n;
    for (j=0; j<n; j++) {
      icUInt32Number nSubOps = (icUInt32Number)icIntMin(nOps-(i+p), op[j].data.size);
      InsertBlanks(funcDesc, nBlanks+2);
      if (op[j].sig==icSigCaseOp)
        funcDesc += "case\n";
      else
        funcDesc += "dflt\n";

      DescribeSequence(funcDesc, nSubOps, &op[p], nBlanks+2);
      p += nSubOps;
    }

    op += p-1;
    i += p-1;

    InsertBlanks(funcDesc, nBlanks + 2);
    pos = nBlanks + 2;
  }
  op++;
  i++;
}
funcDesc += "}\n";

sDescription += funcDesc;
2912}

2914/**
******************************************************************************
* Name: CIccCalculatorFunc::Describe
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
2924void CIccCalculatorFunc::Describe(std::string &sDescription, int nBlanks)
2925{
if (m_nOps) {
  DescribeSequence(sDescription, m_nOps, m_Op, nBlanks);
}
else {
  sDescription += "Undefined Function!\n";
}
2932}

2934static void AppendOpList(CIccCalcOpList &toList, const CIccCalcOpList &fromList)
2935{
CIccCalcOpList::const_iterator o;

for (o=fromList.begin(); o!=fromList.end(); o++) {
  toList.push_back(*o);
}
2941}

2943/**
2944******************************************************************************
2945* Name: CIccCalculatorFunc::ParseFuncDef
2946* 
2947* Purpose: 
2948* 
2949* Args: 
2950* 
2951* Return: 
2952******************************************************************************/
2953const char *CIccCalculatorFunc::ParseFuncDef(const char *szFuncDef, CIccCalcOpList &scanList, std::string &sReport)
2954{
SIccCalcOp op;
op.extra = 0;
op.def=NULL__null;

scanList.clear();

if (!szFuncDef)
  return szFuncDef;

CIccFuncTokenizer scan(szFuncDef);
if (!scan.GetNext())
  return NULL__null;

if (scan.GetSig() != icSigBeginBlockOp((icSigCalcOp)0x7b202020))
  return NULL__null;

while(scan.GetNext()) {
  op.sig = scan.GetSig();

  if (op.sig == icSigEndBlockOp((icSigCalcOp)0x7d202020))
    return scan.GetPos();

  switch(op.sig) {
    case icSigDataOp:
      op.data.num = scan.GetValue();
      scanList.push_back(op);
      break;

    case icSigIfOp:
      {
        CIccCalcOpList trueList, falseList;
        bool bHasElse;

        szFuncDef = ParseFuncDef(scan.GetPos(), trueList, sReport);
        if (!szFuncDef)
          return NULL__null;

        scan.SetPos(szFuncDef);
        bHasElse = false;
        if (scan.GetNext() && scan.GetSig()==icSigElseOp) {
          bHasElse = true;
          szFuncDef = ParseFuncDef(scan.GetPos(), falseList, sReport);

          if (!szFuncDef)
            return NULL__null;
        }

        scan.SetPos(szFuncDef);
        op.data.size = (icUInt32Number)trueList.size();
        scanList.push_back(op);

        if (bHasElse) {
          op.sig = icSigElseOp;
          op.data.size = (icUInt32Number)falseList.size();
          scanList.push_back(op);

          AppendOpList(scanList, trueList);
          AppendOpList(scanList, falseList);
        }
        else {
          AppendOpList(scanList, trueList);
        }
      }
      break;

    case icSigSelectOp:
      {
        op.sig = icSigSelectOp;
        op.data.size = 0;
        scanList.push_back(op);

        int c;
        CIccCalcOpListPtrList selList;
        for (c=0; ; c++) {
          szFuncDef = scan.GetPos();
          scan.GetNext();
          if (scan.GetSig()==icSigCaseOp) {
            CIccCalcOpListPtr pCaseList = new CIccCalcOpList();

            szFuncDef = ParseFuncDef(scan.GetPos(), *pCaseList, sReport);

            if (!szFuncDef) {
              delete pCaseList;
              return NULL__null;
            }

            scan.SetPos(szFuncDef);
            op.sig = icSigCaseOp;
            op.data.size = (icUInt32Number)pCaseList->size();
            scanList.push_back(op);

            selList.push_back(pCaseList);
          }
          else if (c && scan.GetSig()==icSigDefaultOp) {
            CIccCalcOpListPtr pDefaultList = new CIccCalcOpList();

            szFuncDef = ParseFuncDef(scan.GetPos(), *pDefaultList, sReport);

            if (!szFuncDef) {
              delete pDefaultList;
              return NULL__null;
            }

            scan.SetPos(szFuncDef);
            op.sig = icSigDefaultOp;
            op.data.size = (icUInt32Number)pDefaultList->size();
            scanList.push_back(op);

            selList.push_back(pDefaultList);
            break;
          }
          else {
            scan.SetPos(szFuncDef);
            break;
          }
        }
        CIccCalcOpListPtrList::iterator l;
        for (l=selList.begin(); l!=selList.end(); l++) {
          CIccCalcOpListPtr pCaseList = *l;

          AppendOpList(scanList, *pCaseList);
          delete pCaseList;
        }
      }
      break;

    case icSigInputChanOp:
    case icSigOutputChanOp:
    case icSigTempGetChanOp:
    case icSigTempPutChanOp:
    case icSigTempSaveChanOp:
      if (!scan.GetIndex(op.data.select.v1, op.data.select.v2, 0, 1))
        return NULL__null;
      scanList.push_back(op);
      break;

    case icSigEnvVarOp:
      {
        icSigCmmEnvVar envSig;
        if (!scan.GetEnvSig(envSig))
          return NULL__null;
        op.data.size = (icUInt32Number)envSig;
        scanList.push_back(op);
      }
      break;

    case icSigCopyOp:
    case icSigRotateLeftOp:
    case icSigRotateRightOp:
    case icSigPositionDupOp:
    case icSigSolveOp:
    case icSigTransposeOp:
      if (!scan.GetIndex(op.data.select.v1, op.data.select.v2, 1, 1))
        return NULL__null;
      scanList.push_back(op);
      break;

    case icSigPopOp:
      if (!scan.GetIndex(op.data.select.v1, op.data.select.v2, 1))
        return NULL__null;
      op.data.select.v2 = 0;
      scanList.push_back(op);
      break;

    case icSigFlipOp:
    case icSigSumOp:
    case icSigProductOp:
    case icSigMinimumOp:
    case icSigMaximumOp:
    case icSigAndOp:
    case icSigOrOp:
      if (!scan.GetIndex(op.data.select.v1, op.data.select.v2, 2))
        return NULL__null;
      op.data.select.v2 = 0;
      scanList.push_back(op);
      break;

    case icSigApplyCurvesOp:
    case icSigApplyMatrixOp:
    case icSigApplyCLutOp:
    case icSigApplyTintOp:
    case icSigApplyToJabOp:
    case icSigApplyFromJabOp:
    case icSigApplyCalcOp:
    case icSigApplyElemOp:
      if (!scan.GetIndex(op.data.select.v1, op.data.select.v2))
        return NULL__null;
      op.data.select.v2 = 0;
      scanList.push_back(op);
      break;

    case icSigGammaOp:
    case icSigScalarAddOp:
    case icSigScalarSubtractOp:
    case icSigScalarMultiplyOp:
    case icSigScalarDivideOp:
    case icSigAddOp:
    case icSigSubtractOp:
    case icSigMultiplyOp:
    case icSigDivideOp:
    case icSigModulusOp:
    case icSigPowOp:
    case icSigArcTan2Op:          
    case icSigLessThanOp:         
    case icSigLessThanEqualOp:    
    case icSigEqualOp:
    case icSigNearOp:
    case icSigGreaterThanEqualOp: 
    case icSigGreaterThanOp:
    case icSigSquareOp:       
    case icSigSquareRootOp:       
    case icSigCubeOp:       
    case icSigCubeRootOp:
    case icSigSignOp:
    case icSigAbsoluteValOp:
    case icSigTruncateOp:
    case icSigFloorOp:
    case icSigCeilingOp:
    case icSigRoundOp:
    case icSigRealNumberOp:
    case icSigNegOp:      
    case icSigExpOp:              
    case icSigLogrithmOp:         
    case icSigNaturalLogOp:       
    case icSigSineOp:             
    case icSigCosineOp:             
    case icSigTangentOp:          
    case icSigArcSineOp:          
    case icSigArcCosineOp:        
    case icSigArcTangentOp:
    case icSigCartesianToPolarOp:
    case icSigPolarToCartesianOp:
    case icSigNotOp:
    case icSigToLabOp:
    case icSigToXYZOp:
    case icSigVectorMinimumOp:
    case icSigVectorMaximumOp:
    case icSigVectorAndOp:
    case icSigVectorOrOp:
      if (!scan.GetIndex(op.data.select.v1, op.data.select.v2, 1))
        return NULL__null;
      op.data.select.v2 = 0;
      scanList.push_back(op);
      break;

    default:
      if (!SIccCalcOp::IsValidOp(op.sig)) {
        std::string opDesc;

        op.Describe(opDesc);
        sReport += "Invalid Operator \"";
        sReport += opDesc;
        sReport += "\"\r\n";

        if (scanList.rbegin()!=scanList.rend()) {
          sReport += "Last Few operators in reverse:\n";

          CIccCalcOpList::reverse_iterator opi;
          int i;
          for (i=0, opi=scanList.rbegin(); i<10 && opi!=scanList.rend(); i++, opi++) {
            opi->Describe(opDesc);
            sReport += " ";
            sReport += opDesc;
          }
          sReport += "\r\n";
        }
        return NULL__null;
      }
      op.data.select.v1 = 0;
      op.data.select.v2 = 0;
      scanList.push_back(op);
      break;
  }
}
return NULL__null;
3230}


3233/**
******************************************************************************
* Name: CIccCalculatorFunc::SetFunction
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3243icFuncParseStatus CIccCalculatorFunc::SetFunction(const char *szFuncDef, std::string &sReport)
3244{
CIccCalcOpList opList;

if (ParseFuncDef(szFuncDef, opList, sReport)) {
  return SetFunction(opList, sReport);
}
return icFuncParseSyntaxError;
3251}

3253/**
3254******************************************************************************
3255* Name: CIccCalculatorFunc::SetFunction
3256* 
3257* Purpose: 
3258* 
3259* Args: 
3260* 
3261* Return: 
3262******************************************************************************/
3263icFuncParseStatus CIccCalculatorFunc::SetFunction(CIccCalcOpList &opList, std::string &sReport)
3264{
if (m_Op) {
  free(m_Op);
}

m_nOps = (icUInt32Number)opList.size();

if (m_nOps) {
  CIccCalcOpList::iterator i;
  int j;

  m_Op = (SIccCalcOp*)calloc(m_nOps , sizeof(SIccCalcOp));

  for (i=opList.begin(), j=0; i!= opList.end(); i++, j++) {
    m_Op[j] = *i;
  }
}
else {
  return icFuncParseEmptyFunction;
}

if (!HasValidOperations(sReport))
  return icFuncParseInvalidOperation;

return DoesStackUnderflowOverflow(sReport);
3289}

3291/**
******************************************************************************
* Name: CIccCalculatorFunc::Read
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3301bool CIccCalculatorFunc::Read(icUInt32Number size, CIccIO *pIO)
3302{
icUInt32Number headerSize = sizeof(icUInt32Number);

headerSize += sizeof(icChannelFuncSignature) + sizeof(icUInt32Number);

if (headerSize > size)
  return false;

if (!pIO) {
  return false;
}

icChannelFuncSignature sig;

if (!pIO->Read32(&sig))
  return false;

if (sig!= GetType())
  return false;

if (!pIO->Read32(&m_nReserved))
  return false;

if (!pIO->Read32(&m_nOps))
  return false;

if ((icUInt64Number)m_nOps * sizeof(icUInt32Number) * 2 > (icUInt64Number)size - headerSize)
  return false;

if (m_Op) {
  free(m_Op);
}

if (m_nOps) {
  m_Op = (SIccCalcOp*)calloc(m_nOps, sizeof(SIccCalcOp));

  if (!m_Op) {
    m_nOps = 0;
    return false;
  }

  icUInt32Number i;
  for (i=0; i<m_nOps; i++) {
    if (!pIO->Read32(&m_Op[i].sig))
      return false;
    if (!pIO->Read32(&m_Op[i].data.num))
      return false;
  }
}

return true;
3353}

3355/**
******************************************************************************
* Name: CIccCalculatorFunc::Write
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3365bool CIccCalculatorFunc::Write(CIccIO *pIO)
3366{
if (!pIO)
  return false;

icChannelFuncSignature sig;
sig = GetType();
if (!pIO->Write32(&sig))
  return false;

if (!pIO->Write32(&m_nReserved))
  return false;

if (!pIO->Write32(&m_nOps))
  return false;

icUInt32Number i;
for (i=0; i<m_nOps; i++)  {
  if (!pIO->Write32(&m_Op[i].sig))
    return false;
  if (!pIO->Write32(&m_Op[i].data.num))
    return false;
}

return true;
3390}


3393/**
******************************************************************************
* Name: CIccCalculatorFunc::SetOpDefs
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3403bool CIccCalculatorFunc::SetOpDefs()
3404{
if (!m_Op)
  return false;

icUInt32Number i;
for (i=0; i<m_nOps; i++) {
  m_Op[i].def = CIccCalcOpMgr::getOpDef(m_Op[i].sig);
  if (!m_Op[i].def)
    return false;
}
return true;
3415}


3418/**
******************************************************************************
* Name: CIccCalculatorFunc::Begin
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3428bool CIccCalculatorFunc::Begin(const CIccMpeCalculator *pChannelCalc, CIccTagMultiProcessElement *pMPE)
3429{
if (!pChannelCalc)
  return false;
std::string sReport;

if (!InitSelectOps())
  return false;

if (!HasValidOperations(sReport))
  return false;

if (!SetOpDefs())
  return false;

if (DoesOverflowInput(pChannelCalc->NumInputChannels()))
  return false;

if (DoesOverflowOutput(pChannelCalc->NumOutputChannels()))
  return false;

if (DoesStackUnderflowOverflow(sReport)!=icFuncParseNoError)
  return false;

return true;
3453}

3455/**
******************************************************************************
* Name: CIccCalculatorFunc::InitSelectOps
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3465bool CIccCalculatorFunc::InitSelectOps()
3466{
icUInt32Number i;

for (i=0; i<m_nOps; i++) {
  if (m_Op[i].sig==icSigSelectOp) {
    if (!InitSelectOp(&m_Op[i], m_nOps-i))
      return false;
  }
}

return true;
3477}

3479/**
******************************************************************************
* Name: CIccCalculatorFunc::InitSelectOp
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3489bool CIccCalculatorFunc::InitSelectOp(SIccCalcOp *ops, icUInt32Number nOps)
3490{

if (ops->sig != icSigSelectOp)
  return false;

if (ops->extra)
  return true;


icUInt32Number i, n, pos;
for (n=0; n<nOps && ops[n+1].sig==icSigCaseOp; n++);
ops->extra=n;
if (ops[n+1].sig==icSigDefaultOp) {
  n++;
}
pos = n;
for (i=1; i<=n && pos<nOps; i++) {
  ops[i].extra = pos;
  pos += ops[i].data.size;
}

if (i<=n)
  return false;

return true;
3515}

3517/**
3518******************************************************************************
3519* Name: CIccCalculatorFunc::ApplySequence
3520* 
3521* Purpose: 
3522* 
3523* Args: 
3524* 
3525* Return: 
3526******************************************************************************/
3527bool CIccCalculatorFunc::ApplySequence(CIccApplyMpeCalculator *pApply, icUInt32Number nOps, SIccCalcOp *ops) const
3528{
SIccCalcOp *op;
SIccOpState os;

os.pApply = pApply;
os.pStack = pApply->GetStack();
os.pScratch = pApply->GetScratch();
os.temp = pApply->GetTemp();
os.pixel = pApply->GetInput();
os.output = pApply->GetOutput();
os.nOps = nOps;

for (os.idx=0; os.idx<os.nOps; os.idx++) {
  op = &ops[os.idx];

  if (g_pDebugger)
    g_pDebugger->BeforeOp(op, os, ops);

  if (op->sig==icSigIfOp) {
    icFloatNumber a1;
    OsPopArg(a1){ if (!os.pStack->size()) return false; a1 = *(os.pStack->
rbegin()); os.pStack->pop_back(); };

    if (os.idx+1<nOps && ops[os.idx+1].sig==icSigElseOp) {
      os.idx++;
      if (a1>=0.5) {
        if (os.idx+1 + op->data.size >= nOps)
          return false;

        if (!ApplySequence(pApply, op->data.size, &ops[os.idx+1]))
          return false;
      }
      else {
        if (os.idx+1 + op->data.size + ops[os.idx].data.size > nOps)
          return false;

        if (!ApplySequence(pApply, ops[os.idx].data.size, &ops[os.idx+1 + op->data.size]))
          return false;
      }
      os.idx += op->data.size + ops[os.idx].data.size;
    }
    else {
      if (a1>=0.5) {
        if (os.idx+op->data.size >= nOps)
          return false;

        if (!ApplySequence(pApply, op->data.size, &ops[os.idx+1]))
          return false;
      }
      os.idx+= op->data.size;
    }
  }
  else if (op->sig==icSigSelectOp) {
    icFloatNumber a1;
    OsPopArg(a1){ if (!os.pStack->size()) return false; a1 = *(os.pStack->
rbegin()); os.pStack->pop_back(); };
    icInt32Number nSel = (a1 >= 0.0) ? (icInt32Number)(a1+0.5f) : (icInt32Number)(a1-0.5f);

    if (!op->extra) {
      return false;
    }
    
    icUInt32Number nDefOff = (icUInt32Number)(os.idx+1 + op->extra);
    if (nDefOff >= nOps)
      return false;

    if (nSel<0 || (icUInt32Number)nSel>=op->extra) {

      if (ops[nDefOff].sig==icSigDefaultOp) {
        if (os.idx+1 + ops[nDefOff].extra >= nOps)
          return false;

        if (!ApplySequence(pApply, ops[nDefOff].data.size, &ops[os.idx+1 + ops[nDefOff].extra]))
          break;
      }
    }
    else {
      icUInt32Number nOff = os.idx+1 + nSel;

      if (nOff >= nOps) 
        return false;

      if (!ApplySequence(pApply, ops[nOff].data.size, &ops[os.idx+1 + ops[nOff].extra]))
        break;
    }

    if (ops[nDefOff].sig==icSigDefaultOp) {
      if (os.idx+1 + ops[nDefOff].extra + ops[nDefOff].data.size >nOps)
        return false;

      os.idx = (icUInt32Number)(os.idx + ops[nDefOff].extra + ops[nDefOff].data.size);
    }
    else if (op->extra) {
      unsigned long nOff = os.idx + op->extra;

      if (os.idx+1 + ops[nOff].extra + ops[nOff].data.size > nOps)
        return false;

      os.idx = (icUInt32Number)(os.idx + ops[nOff].extra + ops[nOff].data.size);
    }
    else 
      return false;
  }
  else {
    if (!op->def->Exec(op, os))
      return false;
  }

  if (g_pDebugger) {
    g_pDebugger->AfterOp(op, os, ops);
  }
}
return true;
3639}

3641/**
******************************************************************************
* Name: CIccCalculatorFunc::Apply
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3651bool CIccCalculatorFunc::Apply(CIccApplyMpeCalculator *pApply) const
3652{
CIccFloatVector *pStack = pApply->GetStack();

pStack->clear();

if (!ApplySequence(pApply, m_nOps, m_Op)) {
  icFloatNumber *pOut = pApply->GetOutput();
  icUInt32Number i;
  for (i=0; i<m_pCalc->NumOutputChannels(); i++)
    pOut[i] = -1;
  return false;
}

return true;
3666}

3668/**
******************************************************************************
* Name: CIccCalculatorFunc::Validate
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
3678icValidateStatus CIccCalculatorFunc::Validate(std::string sigPath, std::string &sReport,
                                         const CIccMpeCalculator* pChannelCalc/*=NULL*/) const
3680{
CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);

icValidateStatus rv = icValidateOK;
if (m_nReserved) {
  sReport += icMsgValidateWarning;
  sReport += sSigPathName;
  sReport += " function has non zero reserved data.\r\n";
  rv = icValidateWarning;
}

if (GetMaxTemp()>65535) {
  sReport += icMsgValidateCriticalError;
  sReport += sSigPathName;
  sReport += " accesses illegal temporary channels.\r\n";
  return icValidateCriticalError;
}

if (!HasValidOperations(sReport)) {
  sReport += icMsgValidateCriticalError;
  sReport += sSigPathName;
  sReport += " function has invalid operations.\r\n";
  return icValidateCriticalError;
}

if (DoesOverflowInput(pChannelCalc->NumInputChannels())) {
  sReport += icMsgValidateCriticalError;
  sReport += sSigPathName;
  sReport += " accesses illegal input channels.\r\n";
  return icValidateCriticalError;
}

if (DoesOverflowOutput(pChannelCalc->NumOutputChannels())) {
  sReport += icMsgValidateCriticalError;
  sReport += sSigPathName;
  sReport += " accesses illegal output channels.\r\n";
  return icValidateCriticalError;
}

icFuncParseStatus parseStat = DoesStackUnderflowOverflow(sReport);
if (parseStat!=icFuncParseNoError) {
  sReport += icMsgValidateCriticalError;
  sReport += sSigPathName;
  if (parseStat==icFuncParseStackUnderflow)
    sReport += " causes an evaluation stack underflow.\r\n";
  else
    sReport += " causes an evaluation stack overflow.\r\n";
  return icValidateCriticalError;
}

return rv;
3732}

3734/**
3735******************************************************************************
3736* Name: CIccCalculatorFunc::GetMaxTemp
3737* 
3738* Purpose: 
3739* 
3740* Args: 
3741* 
3742* Return: 
3743******************************************************************************/
3744icUInt32Number CIccCalculatorFunc::GetMaxTemp() const
3745{
icUInt32Number i, nMaxTemp = 0;

for (i=0; i<m_nOps; i++) {
  if (m_Op[i].sig == icSigTempGetChanOp || m_Op[i].sig == icSigTempPutChanOp || m_Op[i].sig == icSigTempSaveChanOp ) {
    icUInt32Number last = (icUInt32Number)(m_Op[i].data.select.v1) + (icUInt32Number)(m_Op[i].data.select.v2);
    if (last>nMaxTemp)
      nMaxTemp = last;
  }
}
return nMaxTemp;
3756}

3758/**
3759******************************************************************************
3760* Name: CIccCalculatorFunc::NeedTempReset
3761* 
3762* Purpose: 
3763* 
3764* Args: 
3765* 
3766* Return: 
3767******************************************************************************/
3768bool CIccCalculatorFunc::NeedTempReset(icUInt8Number *tempUsage, icUInt32Number nMaxTemp)
3769{
return SequenceNeedTempReset(m_Op, m_nOps, tempUsage, nMaxTemp);
3771}

3773/**
3774******************************************************************************
3775* Name: CIccCalculatorFunc::SequenceNeedTempReset
3776* 
3777* Purpose: 
3778* 
3779* Args: 
3780* 
3781* Return: 
3782******************************************************************************/
3783bool CIccCalculatorFunc::SequenceNeedTempReset(SIccCalcOp *op, icUInt32Number nOps, icUInt8Number *tempUsage, icUInt32Number nMaxTemp)
3784{
icUInt32Number i, j;

for (i=0; i<nOps; i++) {
  icSigCalcOp sig = op[i].sig;
  if (sig==icSigTempGetChanOp) {
    icUInt32Number p = op[i].data.select.v1;
    icUInt32Number n = op[i].data.select.v2+1;
    for (j=0; j<n; j++) {
      if (!tempUsage[p+j]) {
        return true;
      }
    }
  }
  else if (sig==icSigTempPutChanOp) {
    icUInt32Number p = op[i].data.select.v1;
    icUInt32Number n = op[i].data.select.v2+1;
    memset(tempUsage+p, 1, n);
  }
  else if (sig==icSigTempSaveChanOp) {
    icUInt32Number p = op[i].data.select.v1;
    icUInt32Number n = op[i].data.select.v2+1;
    memset(tempUsage+p, 1, n);
  }
  else if (sig==icSigIfOp) {
    bool rv = false;
    icUInt8Number *ifTemps = (icUInt8Number *)malloc(nMaxTemp);
    icUInt32Number p;
    if (!ifTemps)
      return true;

    memcpy(ifTemps, tempUsage, nMaxTemp);

    p=i+2;
    rv = rv || SequenceNeedTempReset(&op[p], icIntMin(nOps-p, op[i].data.size), ifTemps, nMaxTemp);

    if (i<nOps && op[i+1].sig==icSigElseOp) {
      icUInt8Number *elseTemps = (icUInt8Number *)malloc(nMaxTemp);
      if (!elseTemps) {
        free(ifTemps);
        return true;
      }

      memcpy(elseTemps, tempUsage, nMaxTemp);

      p=i+2+op[i].data.size;
      rv = rv || SequenceNeedTempReset(&op[p], icIntMin(nOps-p, op[i+1].data.size), elseTemps, nMaxTemp);

      if (!rv) {
        for (j=0; j<nMaxTemp; j++) {
          tempUsage[j] |= (ifTemps[j] && elseTemps[j]);
        }
      }

      free(elseTemps);

      i += 1 + op[i].data.size + op[i+1].data.size;
    }
    else {
      i += op[i].data.size;
    }

    free(ifTemps);

    if (rv)
      return true;
  }
}
return false;
3853}


3856/**
3857******************************************************************************
3858* Name: CIccCalculatorFunc::CheckUnderflow
3859* 
3860* Purpose: 
3861* 
3862* Args: 
3863* 
3864* Return: 
3865******************************************************************************/
3866int CIccCalculatorFunc::CheckUnderflowOverflow(SIccCalcOp *op, icUInt32Number nOps, int nArgs, bool bCheckUnderflow, std::string &sReport) const
3867{
icUInt32Number i, p;
int n, nIfArgs, nElseArgs, nSelArgs, nCaseArgs;

for (i=0; i<nOps; i++) {
  n = op[i].ArgsUsed(m_pCalc);

3874#if 0
  std::string opstr;
  op[i].Describe(opstr);
  printf("%s : %d %d\n", opstr.c_str(), n, nArgs);
3878#endif

  if (n > nArgs) {
    std::string opDesc;
    icUInt32Number j, l;
    icInt32Number f;

    op[i].Describe(opDesc);
    sReport += "Stack underflow at operation \"" + opDesc + "\" in \"";
    f=i-2;
    if (f<0) f=0;
    l=i+2;
    if (l>nOps-1)
      l=nOps-1;
    for (j=(icUInt32Number)f; j<=l; j++) {
      op[j].Describe(opDesc);
      if (j!=f)
        sReport += " ";
      sReport += opDesc;
    }
    sReport += "\"\r\n";
    return -1;
  }

  nArgs -= n;
  nArgs += op[i].ArgsPushed(m_pCalc);

  if (nArgs>icMaxDataStackSize65535)
    return -2;

  if (op[i].sig == icSigIfOp) {
    int incI = 0;
    if (i+1<nOps && op[i+1].sig==icSigElseOp) {
      p = i+2; 
      nIfArgs = CheckUnderflowOverflow(&op[p], icIntMin(nOps-p, op[i].data.size), nArgs, bCheckUnderflow, sReport);
      if (nIfArgs<0)
        return -1;
      incI =op[i].data.size;

      p = i+2+op[i].data.size;
      nElseArgs = CheckUnderflowOverflow(&op[p], icIntMin(nOps-p, op[i+1].data.size), nArgs, bCheckUnderflow, sReport);
      if (nElseArgs<0)
        return -1;
      incI += op[i+1].data.size;

      nArgs = bCheckUnderflow ? icIntMin(nIfArgs, nElseArgs) : icIntMax(nIfArgs, nElseArgs) ;
      i++;
      i+=incI;
    }
    else {
      p = i+1; 
      nIfArgs = CheckUnderflowOverflow(&op[p], icIntMin(nOps-p, op[i].data.size), nArgs, bCheckUnderflow, sReport);
      if (nIfArgs<0)
        return -1;
      nArgs = bCheckUnderflow ? icIntMin(nArgs, nIfArgs) : icIntMax(nArgs, nIfArgs);

      i+= op[i].data.size;
    }
  }
  else if (op[i].sig == icSigSelectOp) {
    icUInt32Number n;
    nSelArgs = nArgs;

    for (n=1; i+n<nOps; ) {
      if (op[i+n].sig==icSigCaseOp)
        n++;
      else if (n>1 && op[i+n].sig==icSigDefaultOp) {
        n++;
        break;
      }
      else
        break;
    }
    n--;

    if (!n)
      return -1;

    icUInt32Number pos = i+1 + n;
    for (p=0; p<n; p++) {
      SIccCalcOp *sop = &op[i+1+p];
      int len = sop->data.size;
      if (pos>=nOps)
        return -1;

      nCaseArgs = CheckUnderflowOverflow(&op[pos], icIntMin(nOps-pos, len), nArgs, bCheckUnderflow, sReport);
      if (nCaseArgs<0)
        return -1;

      if (!p)
        nSelArgs = nCaseArgs;
      else
        nSelArgs = bCheckUnderflow ? icIntMin(nSelArgs, nCaseArgs) : icIntMax(nSelArgs, nCaseArgs);

      pos += sop->data.size;
    }
    nArgs = nSelArgs;

    i = pos - 1;
  }
}

return nArgs;
3981}

3983/**
3984******************************************************************************
3985* Name: CIccCalculatorFunc::DoesStackUnderflowOverflow
3986* 
3987* Purpose: 
3988* 
3989* Args: 
3990* 
3991* Return: 
3992******************************************************************************/
3993icFuncParseStatus CIccCalculatorFunc::DoesStackUnderflowOverflow(std::string &sReport) const
3994{
int rv = CheckUnderflowOverflow(m_Op, m_nOps, 0, true, sReport); 

if (rv==-1)
  return icFuncParseStackUnderflow;
else if (rv<0)
  return icFuncParseStackOverflow;

rv = CheckUnderflowOverflow(m_Op, m_nOps, 0, false, sReport); 

if (rv==-1)
  return icFuncParseStackUnderflow;
else if (rv<0)
  return icFuncParseStackOverflow;

return icFuncParseNoError;
4010}

4012/**
4013******************************************************************************
4014* Name: CIccCalculatorFunc::HasValidOperations
4015* 
4016* Purpose: 
4017* 
4018* Args: 
4019* 
4020* Return: 
4021******************************************************************************/
4022bool CIccCalculatorFunc::HasValidOperations(std::string &sReport) const
4023{
icUInt32Number i;
for (i=0; i<m_nOps; i++) {
  if (!m_Op[i].IsValidOp(m_pCalc)) {
    std::string opDesc;
    m_Op[i].Describe(opDesc);
    sReport += "Invalid Operation (" + opDesc + ")\r\n";
    return false;
  }
  if (m_Op[i].sig==icSigSelectOp && i+1<m_nOps && m_Op[i+1].sig!=icSigCaseOp) {
    sReport += "A case operator does not follow a sel operator\r\n";
    return false;
  }
  if (i) {
    if (m_Op[i].sig==icSigElseOp) {
      if (m_Op[i-1].sig!=icSigIfOp) {
        sReport += "An else operator has no proceeding if operator\r\n";
        return false;
      }
    }
    else if (m_Op[i].sig==icSigCaseOp) {
      if (m_Op[i-1].sig!=icSigSelectOp && m_Op[i-1].sig!=icSigCaseOp) {
        sReport += "A case operator has no proceeding sel or case operator\r\n";
        return false;
      }
    }
    else if (m_Op[i].sig==icSigDefaultOp) {
      if (m_Op[i-1].sig!=icSigCaseOp) {
        sReport += "An dflt operator has no proceeding case operator\r\n";
        return false;
      }
    }
  }
}
return true;
4058}

4060/**
4061******************************************************************************
4062* Name: CIccChannelFunc::DoesOverflowInput
4063* 
4064* Purpose: 
4065* 
4066* Args: 
4067* 
4068* Return: 
4069******************************************************************************/
4070bool CIccCalculatorFunc::DoesOverflowInput(icUInt16Number nInputChannels) const
4071{
icUInt32Number i;
for (i=0; i<m_nOps; i++) {
  if (m_Op[i].sig == icSigInputChanOp) {
    if (m_Op[i].data.select.v1+m_Op[i].data.select.v2 >= nInputChannels)
      return true;
  }
}
return false;
4080}


4083/**
4084******************************************************************************
4085* Name: CIccChannelFunc::DoesOverflowOutput
4086* 
4087* Purpose: 
4088* 
4089* Args: 
4090* 
4091* Return: 
4092******************************************************************************/
4093bool CIccCalculatorFunc::DoesOverflowOutput(icUInt16Number nOutputChannels) const
4094{
icUInt32Number i;
for (i=0; i<m_nOps; i++) {
  if (m_Op[i].sig == icSigOutputChanOp) {
    if (m_Op[i].data.select.v1 + m_Op[i].data.select.v2 >= nOutputChannels)
      return true;
  }
}
return false;
4103}


4106/**
******************************************************************************
* Name: CIccMpeCalculator::CIccMpeCalculator
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
4116CIccMpeCalculator::CIccMpeCalculator(icUInt16Number nInputChannels /*=0*/,
                                   icUInt16Number nOutputChannels /*=0*/)
4118{
m_nReserved = 0;
m_nInputChannels = nInputChannels;
m_nOutputChannels = nOutputChannels;
m_nTempChannels = 0;
m_bNeedTempReset = true;
m_nSubElem = 0;
m_SubElem = NULL__null;
m_calcFunc = NULL__null;
m_pCmmEnvVarLookup = NULL__null;
4128}

4130/**
******************************************************************************
* Name: CIccMpeCalculator::CIccMpeCalculator
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
4140CIccMpeCalculator::CIccMpeCalculator(const CIccMpeCalculator &channelGen)
4141{
m_nReserved = channelGen.m_nReserved;

m_nInputChannels = channelGen.m_nInputChannels;
m_nOutputChannels = channelGen.m_nOutputChannels;
m_nTempChannels = channelGen.m_nTempChannels;

m_pCmmEnvVarLookup = channelGen.m_pCmmEnvVarLookup;

m_nSubElem = channelGen.m_nSubElem;
m_bNeedTempReset = channelGen.m_bNeedTempReset;

m_pCmmEnvVarLookup = channelGen.m_pCmmEnvVarLookup;

icCalculatorFuncPtr ptr = channelGen.m_calcFunc;

if (ptr)
  m_calcFunc = ptr->NewCopy();
else
  m_calcFunc = NULL__null;

if (channelGen.m_nSubElem) {
  icUInt32Number i;

  m_SubElem = (CIccMultiProcessElement**)calloc(m_nSubElem, sizeof(CIccMultiProcessElement*));
  if (m_SubElem) {
    for (i=0; i<m_nSubElem; i++) {
      if (channelGen.m_SubElem[i])
        m_SubElem[i] = channelGen.m_SubElem[i]->NewCopy();
    }
  }
  else {
    m_nSubElem = 0;
    m_SubElem = NULL__null;
  }
}
else {
  m_nSubElem = 0;
  m_SubElem = NULL__null;
}
4181}

4183/**
******************************************************************************
* Name: &CIccMpeCalculator::operator=
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
4193CIccMpeCalculator &CIccMpeCalculator::operator=(const CIccMpeCalculator &channelGen)
4194{
m_nReserved = channelGen.m_nReserved;

SetSize(0,0);

m_nInputChannels= channelGen.m_nInputChannels;
m_nOutputChannels = channelGen.m_nOutputChannels;

m_pCmmEnvVarLookup = channelGen.m_pCmmEnvVarLookup;

icCalculatorFuncPtr ptr = channelGen.m_calcFunc;

if (ptr)
  m_calcFunc = ptr->NewCopy();
else
  m_calcFunc = NULL__null;

if (channelGen.m_nSubElem) {
  icUInt32Number i;

  m_SubElem = (CIccMultiProcessElement**)calloc(m_nSubElem, sizeof(CIccMultiProcessElement*));
  if (m_SubElem) {
    for (i=0; i<m_nSubElem; i++) {
      if (channelGen.m_SubElem[i])
        m_SubElem[i] = channelGen.m_SubElem[i]->NewCopy();
    }
  }
  else {
    m_nSubElem = 0;
    m_SubElem = NULL__null;
  }
}
else {
  m_nSubElem = 0;
  m_SubElem = NULL__null;
}

return *this;
4232}

4234/**
******************************************************************************
* Name: CIccMpeCalculator::~CIccMpeCalculator
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
4244CIccMpeCalculator::~CIccMpeCalculator()
4245{
SetSize(0,0);
4247}

4249/**
******************************************************************************
* Name: CIccMpeCalculator::SetSize
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
4259void CIccMpeCalculator::SetSize(icUInt16Number nInputChannels, icUInt16Number nOutputChannels)
4260{
if (m_calcFunc) {
14
←
Assuming field 'm_calcFunc' is null→
15
←
Taking false branch→
  delete m_calcFunc;
  m_calcFunc = NULL__null;
}
icUInt32Number i;

if (m_SubElem) {
16
←
Assuming field 'm_SubElem' is null→
17
←
Taking false branch→
  for (i=0; i<m_nSubElem; i++) {
    if (m_SubElem[i])
      delete m_SubElem[i];
  }
  free(m_SubElem);
  m_SubElem = NULL__null;
  m_nSubElem = 0;
}

m_nInputChannels = nInputChannels;
m_nOutputChannels = nOutputChannels;
4279}

4281/**
******************************************************************************
* Name: CIccMpeCalculator::SetCalcFunc
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
4291icFuncParseStatus CIccMpeCalculator::SetCalcFunc(icCalculatorFuncPtr newChannelFunc) 
4292{
if (m_calcFunc) {
  delete m_calcFunc;
}
m_calcFunc = newChannelFunc;

return icFuncParseNoError;
4299}

4301/**
4302******************************************************************************
4303* Name: CIccMpeCalculator::SetCalcFunc
4304* 
4305* Purpose: 
4306* 
4307* Args: 
4308* 
4309* Return: 
4310******************************************************************************/
4311icFuncParseStatus CIccMpeCalculator::SetCalcFunc(const char *szFuncDef, std::string &sReport)
4312{

if (m_calcFunc) {
  delete m_calcFunc;
  m_calcFunc = NULL__null;
}

CIccCalculatorFunc *pFunc = new CIccCalculatorFunc(this);
icFuncParseStatus rv = pFunc->SetFunction(szFuncDef, sReport);

if (rv!=icFuncParseNoError) {
  delete pFunc;
  m_calcFunc = NULL__null;

  return rv;
}

m_calcFunc = pFunc;

return rv;
4332}


4335/**
******************************************************************************
* Name: CIccMpeCalculator::Describe
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
4345void CIccMpeCalculator::Describe(std::string &sDescription)
4346{
if (m_calcFunc) {
  icChar buf[81];

  sprintf(buf, "BEGIN_CALC_ELEMENT %u %u\r\n", m_nInputChannels, m_nOutputChannels); 
  sDescription += buf;

  if (m_nSubElem && m_SubElem) {
    icUInt32Number i;
    for (i=0; i<m_nSubElem; i++) {
      sprintf(buf, "BEGIN_SUBCALCELEM %u\r\n", i);
      sDescription += buf;
      m_SubElem[i]->Describe(sDescription);
      sprintf(buf, "END_SUBCALCELEM %u\r\n\r\n", i);
      sDescription += buf;
    }
  }

  if (m_calcFunc) {
    sDescription += "BEGIN_CALC_FUNCTION\r\n";
    m_calcFunc->Describe(sDescription);
    sDescription += "END_CALC_FUNCTION\r\n";
  }

  sprintf(buf, "END_CALC_ELEMENT\r\n");
  sDescription += buf;

}
4374}

4376typedef std::map<icUInt32Number, CIccCalculatorFunc*> icChannelFuncOffsetMap;
4377typedef std::map<CIccCalculatorFunc*, icPositionNumber> icChannelFuncPtrMap;

4379/**
******************************************************************************
* Name: CIccMpeCalculator::Read
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
4389bool CIccMpeCalculator::Read(icUInt32Number size, CIccIO *pIO)
4390{
icElemTypeSignature sig;

icUInt32Number startPos = pIO->Tell();

icUInt32Number headerSize = sizeof(icTagTypeSignature) + 
  sizeof(icUInt32Number) + 
  sizeof(icUInt16Number) + 
  sizeof(icUInt16Number) +
  sizeof(icUInt16Number) +
  sizeof(icUInt16Number) +
  sizeof(icUInt16Number) +
  sizeof(icUInt16Number);

if (headerSize > size)
1
Assuming 'headerSize' is <= 'size'→
2
←
Taking false branch→
  return false;

if (!pIO2.1
'pIO' is non-null
1
'pIO' is non-null
) {
3
←
Taking false branch→
  return false;
}

icUInt16Number nInputChannels, nOutputChannels;

if (!pIO->Read32(&sig))
4
←
Assuming the condition is false→
5
←
Taking false branch→
  return false;

if (!pIO->Read32(&m_nReserved))
6
←
Value assigned to field 'm_SubElem'→
7
←
Assuming the condition is false→
8
←
Taking false branch→
  return false;

if (!pIO->Read16(&nInputChannels))
9
←
Assuming the condition is false→
10
←
Taking false branch→
  return false;

if (!pIO->Read16(&nOutputChannels))
11
←
Assuming the condition is false→
12
←
Taking false branch→
  return false;

SetSize(nInputChannels, nOutputChannels);
13
←
Calling 'CIccMpeCalculator::SetSize'→
18
←
Returning from 'CIccMpeCalculator::SetSize'→

icUInt32Number nSubElem;

if (!pIO->Read32(&nSubElem))
19
←
Assuming the condition is false→
20
←
Taking false branch→
  return false;

icUInt32Number nPos = nSubElem + 1;

if (headerSize + (icUInt64Number)nPos*sizeof(icPositionNumber) > size) {
21
←
Assuming the condition is false→
22
←
Taking false branch→
  return false;
}

icPositionNumber *pos, *posvals = (icPositionNumber*)malloc(nPos*sizeof(icPositionNumber));
if (!posvals) {
23
←
Assuming 'posvals' is non-null→
24
←
Taking false branch→
  return false;
}

icUInt32Number n = nPos * (sizeof(icPositionNumber)/sizeof(icUInt32Number));
if (pIO->Read32(posvals, n)!=n) {
25
←
Assuming the condition is false→
26
←
Taking false branch→
  free(posvals);
  return false;
}

pos = &posvals[1];
if (nSubElem) {
27
←
Assuming 'nSubElem' is not equal to 0→
28
←
Taking true branch→
  icElemTypeSignature elemSig;

  SetSubElem(nSubElem-1, NULL__null); //Initialize array
29
←
Calling 'CIccMpeCalculator::SetSubElem'→

  for (n=0; n<nSubElem; n++) {
    if (pos->offset + pos->size > size) {
      free(posvals);
      return false;
    }
    pIO->Seek(startPos + pos->offset, icSeekSet);

    if (!pIO->Read32(&elemSig)) {
      free(posvals);
      return false;
    }

    CIccMultiProcessElement *pElem = CIccMultiProcessElement::Create(elemSig);
    if (!pElem) {
      free(posvals);
      return false;
    }

    pIO->Seek(startPos + pos->offset, icSeekSet);
    if (!pElem->Read(pos->size, pIO)) {
      free(posvals);
      return false;
    }
    SetSubElem((icUInt16Number)n, (CIccMpeCalculator*)pElem);
    pos++;
  }
}  

m_calcFunc = new CIccCalculatorFunc(this);
pos = posvals;

if (!m_calcFunc || pos->offset + pos->size > size) {
  free(posvals);
  return false;
}

pIO->Seek(startPos + pos->offset, icSeekSet);

if (!m_calcFunc->Read(pos->size, pIO)) {
  return false;
}
free(posvals);

pIO->Seek(startPos + size, icSeekSet);

return true;
4501}

4503/**
******************************************************************************
* Name: CIccMpeCalculator::Write
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
4513bool CIccMpeCalculator::Write(CIccIO *pIO)
4514{
icElemTypeSignature sig = GetType();

if (!pIO)
  return false;

icUInt32Number elemStart = pIO->Tell();

if (!pIO->Write32(&sig))
  return false;

if (!pIO->Write32(&m_nReserved))
  return false;

if (!pIO->Write16(&m_nInputChannels))
  return false;

if (!pIO->Write16(&m_nOutputChannels))
  return false;

if (!pIO->Write32(&m_nSubElem))
  return false;

icUInt32Number nPos = m_nSubElem + 1;

icPositionNumber *pos, *posvals = (icPositionNumber*)calloc(nPos, sizeof(icPositionNumber));
if (!posvals) {
  return false;
}
icUInt32Number nPositionStart = pIO->Tell();

icUInt32Number n, np = nPos * (sizeof(icPositionNumber)/sizeof(icUInt32Number));
if (pIO->Write32(posvals, np)!=np) {
  free(posvals);
  return false;
}

if (m_calcFunc) {
  posvals[0].offset = pIO->Tell()-elemStart;
  if (!m_calcFunc->Write(pIO)) {
    free(posvals);
    return false;
  }
  posvals[0].size = pIO->Tell()-elemStart - posvals[nPos-1].offset;
  pIO->Align32();
}

pos = &posvals[1];

if (m_nSubElem) {
  for(n=0; n<m_nSubElem; n++) {
    if (m_SubElem[n]) {
      pos->offset = pIO->Tell()-elemStart;
      if (!m_SubElem[n]->Write(pIO)) {
        free(posvals);
        return false;
      }
      pos->size = pIO->Tell()-elemStart - pos->offset;
      pIO->Align32();
    }
    pos++;
  }
}
icUInt32Number endPos = pIO->Tell();

pIO->Seek(nPositionStart, icSeekSet);

if (pIO->Write32(posvals, np)!=np) {
  free(posvals);
  return false;
}
free(posvals);

pIO->Seek(endPos, icSeekSet);

return true;
4590}

4592/**
******************************************************************************
* Name: CIccMpeCalculator::Begin
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
4602bool CIccMpeCalculator::Begin(icElemInterp nInterp, CIccTagMultiProcessElement *pMPE)
4603{
if (!m_calcFunc)
  return false;

m_nTempChannels = m_calcFunc->GetMaxTemp()+1;

m_pCmmEnvVarLookup = pMPE->GetCmmEnvLookup();

if (m_nTempChannels>65536)
  return false;

if (m_nTempChannels) {
  icUInt8Number *tempUsage = (icUInt8Number *)calloc(m_nTempChannels, sizeof(icUInt8Number));
  if (tempUsage) {
    m_bNeedTempReset = m_calcFunc->NeedTempReset(tempUsage, m_nTempChannels);
    free(tempUsage);
  }
  else
    m_bNeedTempReset = true;
}
else {
  m_bNeedTempReset = false;
}

if (!m_calcFunc->Begin(this, pMPE))
  return false;

icUInt32Number n;
for (n=0; n<m_nSubElem; n++) {
  if (m_SubElem[n] && !m_SubElem[n]->Begin(nInterp, pMPE))
    return false;
}

return true;
4637}

4639/**
4640******************************************************************************
4641* Name: CIccMpeCalculator::Begin
4642* 
4643* Purpose: 
4644* 
4645* Args: 
4646* 
4647* Return: 
4648******************************************************************************/
4649CIccApplyMpe *CIccMpeCalculator::GetNewApply(CIccApplyTagMpe *pApplyTag)
4650{
CIccApplyTagMpe *pApplyTagEx = (CIccApplyTagMpe*)pApplyTag;

CIccApplyMpeCalculator *pApply = new CIccApplyMpeCalculator(this);

if (!pApply)
  return NULL__null;

if (m_nTempChannels) {
  pApply->m_temp = (icFloatNumber*)malloc(m_nTempChannels*sizeof(icFloatNumber));
}
pApply->m_stack = new CIccFloatVector;
pApply->m_scratch = new CIccFloatVector;
pApply->m_scratch->resize(50);
pApply->m_pCmmEnvVarLookup = m_pCmmEnvVarLookup;

icUInt32Number i;

pApply->m_nSubElem = m_nSubElem;
if(m_nSubElem) {
  pApply->m_SubElem = (CIccSubCalcApply **)calloc(m_nSubElem, sizeof(CIccSubCalcApply));

  if (m_SubElem) {
    for (i=0; i<m_nSubElem; i++) {
      if (m_SubElem[i]) {
        pApply->m_SubElem[i] = new CIccSubCalcApply(m_SubElem[i]->GetNewApply(pApplyTag));
      }
    }
  }
}
else {
  m_SubElem=NULL__null;
}
return pApply;
4684}


4687/**
******************************************************************************
* Name: CIccMpeCalculator::Apply
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
4697void CIccMpeCalculator::Apply(CIccApplyMpe *pApply, icFloatNumber *pDestPixel, const icFloatNumber *pSrcPixel) const
4698{
CIccApplyMpeCalculator *pApplyCalc = (CIccApplyMpeCalculator*)pApply;
icFloatNumber *pSrcTemp = pApplyCalc->m_temp;
bool rv;

pApplyCalc->m_temp = pSrcTemp;
pApplyCalc->m_input = pSrcPixel;
pApplyCalc->m_output = pDestPixel;

if (m_bNeedTempReset) {
  memset(pSrcTemp, 0, m_nTempChannels*sizeof(icFloatNumber));
}

if (g_pDebugger) {
  g_pDebugger->BeginApply();
  rv = m_calcFunc->Apply(pApplyCalc);
  if (!rv)
    g_pDebugger->Error("Calc Function Apply Terminated with an error!");

  g_pDebugger->EndApply();
}
else {
  rv = m_calcFunc->Apply(pApplyCalc);
}
4722}

4724/**
******************************************************************************
* Name: CIccMpeCalculator::Validate
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
4734icValidateStatus CIccMpeCalculator::Validate(std::string sigPath, std::string &sReport, const CIccTagMultiProcessElement* pMPE/*=NULL*/) const
4735{
std::string mpeSigPath = sigPath + icGetSigPath(GetType());
icValidateStatus rv = CIccMultiProcessElement::Validate(sigPath, sReport, pMPE);

icUInt32Number i;

if (m_SubElem) {
  for (i=0; i<m_nSubElem; i++) {
    if (m_SubElem[i])
      rv = icMaxStatus(rv, m_SubElem[i]->Validate(mpeSigPath, sReport, pMPE));
  }
}

bool empty=false;
if (m_calcFunc) {
  rv = icMaxStatus(rv, m_calcFunc->Validate(mpeSigPath, sReport, this));
}
else
  empty = true;

if (empty) {
  CIccInfo Info;
  std::string sSigPathName = Info.GetSigPathName(sigPath);

  sReport += icMsgValidateCriticalError;
  sReport += sSigPathName;
  sReport += " - Has an Empty Calculator Functions!\r\n";
  rv = icMaxStatus(rv, icValidateCriticalError);
}

return rv;
4766}


4769/**
******************************************************************************
* Name: CIccMpeCalculator::IsLateBinding
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
4779bool CIccMpeCalculator::IsLateBinding() const
4780{
icUInt32Number i;

if (m_SubElem) {
  for (i=0; i<m_nSubElem; i++) {
    if (m_SubElem[i] && m_SubElem[i]->IsLateBinding())
      return true;
  }
}

return false;
4791}

4793/**
******************************************************************************
* Name: CIccMpeCalculator::IsLateBindingReflectance
* 
* Purpose: 
* 
* Args: 
* 
* Return: 
******************************************************************************/
4803bool CIccMpeCalculator::IsLateBindingReflectance() const
4804{
icUInt32Number i;

if (m_SubElem) {
  for (i=0; i<m_nSubElem; i++) {
    if (m_SubElem[i] && m_SubElem[i]->IsLateBindingReflectance())
      return true;
  }
}

return false;
4815}


4818/**
4819******************************************************************************
4820* Name: CIccMpeCalculator::GetSubApply
4821* 
4822* Purpose: 
4823* 
4824* Args: 
4825* 
4826* Return: 
4827******************************************************************************/
4828CIccMultiProcessElement *CIccMpeCalculator::GetElem(icSigCalcOp opsig, icUInt16Number index)
4829{
if (m_SubElem && index<m_nSubElem) {
  CIccMultiProcessElement *pMpe = m_SubElem[index];
  if (opsig==icSigApplyElemOp)
    return pMpe;

  if ((opsig==icSigApplyCurvesOp && pMpe->GetType() != icSigCurveSetElemType) ||
      (opsig==icSigApplyMatrixOp && pMpe->GetType() != icSigMatrixElemType) ||
      (opsig==icSigApplyCLutOp && !(pMpe->GetType() == icSigCLutElemType || pMpe->GetType() == icSigExtCLutElemType)) ||
      (opsig==icSigApplyTintOp && pMpe->GetType() != icSigTintArrayElemType) ||
      (opsig==icSigApplyToJabOp && pMpe->GetType() != icSigXYZToJabElemType) ||
      (opsig==icSigApplyFromJabOp && pMpe->GetType() != icSigJabToXYZElemType) ||
      (opsig==icSigApplyCalcOp && pMpe->GetType() != icSigCalculatorElemType))
    return NULL__null;

  return pMpe;
}

return NULL__null;
4848}


4851/**
4852******************************************************************************
4853* Name: CIccMpeCalculator::GetSubApply
4854* 
4855* Purpose: 
4856* 
4857* Args: 
4858* 
4859* Return: 
4860******************************************************************************/
4861bool CIccMpeCalculator::SetElem(icUInt32Number idx, CIccMultiProcessElement *pElem, icUInt32Number &count, CIccMultiProcessElement ***pArray)
4862{
bool rv = true;

if (idx+1>count) {
31
←
Assuming the condition is false→
32
←
Taking false branch→
  if (*pArray) {
    *pArray = (CIccMultiProcessElement**)icRealloc(*pArray, (idx+1)*sizeof(CIccMultiProcessElement*));

    if (!(*pArray))
      return false;

    icUInt32Number i;
    for (i=count; i<=idx; i++) {
      (*pArray)[i] = NULL__null;
    }
  }
  else {
    *pArray = (CIccMultiProcessElement**)calloc(idx+1, sizeof(CIccMultiProcessElement*));

    if (!(*pArray))
      return false;
  }
  count = idx+1;
}

if ((*pArray)[idx]) {
33
←
Array access results in a null pointer dereference
  delete (*pArray)[idx];
  rv = false;
}

(*pArray)[idx] = pElem;

return rv;
4894}

4896/**
4897******************************************************************************
4898* Name: CIccMpeCalculator::CIccApplyMpeCalculator
4899* 
4900* Purpose: 
4901* 
4902* Args: 
4903* 
4904* Return: 
4905******************************************************************************/
4906CIccApplyMpeCalculator::CIccApplyMpeCalculator(CIccMultiProcessElement *pElem) : CIccApplyMpe(pElem)
4907{
m_temp = NULL__null;

m_input = NULL__null;
m_output = NULL__null;

m_stack = NULL__null;
m_scratch = NULL__null;

m_nSubElem = 0;
m_SubElem = NULL__null;

4919}


4922/**
4923******************************************************************************
4924* Name: CIccMpeCalculator::~CIccApplyMpeCalculator
4925* 
4926* Purpose: 
4927* 
4928* Args: 
4929* 
4930* Return: 
4931******************************************************************************/
4932CIccApplyMpeCalculator::~CIccApplyMpeCalculator()
4933{
if (m_stack) {
  delete m_stack;
}
if (m_scratch) {
  delete m_scratch;
}

if (m_temp) {
  free(m_temp);
}

icUInt32Number i;

if (m_SubElem) {
  for (i=0; i<m_nSubElem; i++) {
    if (m_SubElem[i])
      delete m_SubElem[i];
  }
}
4953}

4955/**
4956******************************************************************************
4957* Name: CIccApplyMpeCalculator::GetSubApply
4958* 
4959* Purpose: 
4960* 
4961* Args: 
4962* 
4963* Return: 
4964******************************************************************************/
4965CIccSubCalcApply *CIccApplyMpeCalculator::GetApply(icUInt16Number index)
4966{
if (m_SubElem && index<m_nSubElem)
  return m_SubElem[index];

return NULL__null;
4971}


4974/**
4975******************************************************************************
4976* Name: CIccApplyMpeCalculator::GetSubApply
4977* 
4978* Purpose: 
4979* 
4980* Args: 
4981* 
4982* Return: 
4983******************************************************************************/
4984bool CIccApplyMpeCalculator::GetEnvVar(icSigCmmEnvVar sigEnv, icFloatNumber &val)
4985{
if (!m_pCmmEnvVarLookup) {
  val = 0;
  return false;
}
return m_pCmmEnvVarLookup->GetEnvVar(sigEnv, val);
4991}




←

/Users/xss/DemoIccMAX-hoyt-master/IccProfLib/IccMpeCalc.h

1/** @file
2File:       IccMpeCalc.h

4Contains:   Header for implementation of Channel Calculator element
          and supporting classes

7Version:    V1

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

12/*
* The ICC Software License, Version 0.1
*
*
* Copyright (c) 2003-2006 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/>.
*  
* 
*/

65////////////////////////////////////////////////////////////////////// 
66// HISTORY:
67//
68// -Jan 30, 2005 
69//  Initial CIccMpeent prototype development
70// -June 16, 2006
71//  CIccCalculatorElement prototype development
72//
73//////////////////////////////////////////////////////////////////////

75#ifndef _ICCELEMCALC_H
76#define _ICCELEMCALC_H

78#include "IccTagMPE.h"
79#include "IccSolve.h"
80#include <vector>

82//CIccFloatTag support
83#ifdef USEREFICCMAXNAMESPACE
84namespace refIccMAX {
85#endif

87//Declare forward references
88class CIccMpeCurveSet;
89class CIccMpeMatrix;
90class CIccMpeCLUT;
91class CIccMpeCalculator;
92class CIccApplyMpeCalculator;
93class IIccOpDef;

95#define icMaxDataStackSize65535 65535



99/************************************************************************
* Channel Function signature
************************************************************************/
102typedef enum {
icSigChannelFunction              = 0x66756e63,  /* 'func' */
104} icChannelFuncSignature;


107/************************************************************************ 
* Calculator operator signatures
************************************************************************/
110typedef enum {
//Floating point constant operation
icSigDataOp                       = 0x64617461,  /* 'data' */
icSigPiOp                         = 0x70692020,  /* 'pi  ' */
icSigPosInfinityOp                = 0x2b494e46,  /* '+INF' */
icSigNegInfinityOp                = 0x2d494e46,  /* '-INF' */
icSigNotaNumberOp                 = 0x4e614e20,  /* 'NaN ' */

//Variable operations
icSigInputChanOp                  = 0x696e2020,  /* 'in  ' */
icSigOutputChanOp                 = 0x6f757420,  /* 'out ' */
icSigTempGetChanOp                = 0x74676574,  /* 'tget' */
icSigTempPutChanOp                = 0x74707574,  /* 'tput' */
icSigTempSaveChanOp               = 0x74736176,  /* 'tsav' */

//Environment variable operation
icSigEnvVarOp                     = 0x656e7620,  /* 'env ' */

//Sub-element operations
icSigApplyCurvesOp                = 0x63757276,  /* 'curv' */
icSigApplyMatrixOp                = 0x6d747820,  /* 'mtx ' */
icSigApplyCLutOp                  = 0x636c7574,  /* 'clut' */
icSigApplyTintOp                  = 0x74696e74,  /* 'tint' */
icSigApplyToJabOp                 = 0x744a6162,  /* 'tJab' */
icSigApplyFromJabOp               = 0x664a6162,  /* 'fJab' */
icSigApplyCalcOp                  = 0x63616c63,  /* 'calc' */
icSigApplyElemOp                  = 0x656c656d,  /* 'elem' */

//Stack operations
icSigCopyOp                       = 0x636f7079,  /* 'copy' */
icSigRotateLeftOp                 = 0x726f746c,  /* 'rotl' */
icSigRotateRightOp                = 0x726f7472,  /* 'rotr' */
icSigPositionDupOp                = 0x706f7364,  /* 'posd' */
icSigFlipOp                       = 0x666c6970,  /* 'flip' */
icSigPopOp                        = 0x706f7020,  /* 'pop ' */

//Variable length operations
icSigSumOp                        = 0x73756d20,  /* 'sum ' */
icSigProductOp                    = 0x70726f64,  /* 'prod' */
icSigMinimumOp                    = 0x6d696e20,  /* 'min ' */
icSigMaximumOp                    = 0x6d617820,  /* 'max ' */
icSigAndOp                        = 0x616e6420,  /* 'and ' */
icSigOrOp                         = 0x6f722020,  /* 'or  ' */

//Vector Function operations
icSigNegOp                        = 0x6e656720,  /* 'neg ' */
icSigAddOp                        = 0x61646420,  /* 'add ' */
icSigSubtractOp                   = 0x73756220,  /* 'sub ' */
icSigMultiplyOp                   = 0x6d756c20,  /* 'mul ' */
icSigDivideOp                     = 0x64697620,  /* 'div ' */
icSigModulusOp                    = 0x6d6f6420,  /* 'mod ' */
icSigPowOp                        = 0x706f7720,  /* 'pow ' */
icSigGammaOp                      = 0x67616d61,  /* 'gama' */
icSigScalarAddOp                  = 0x73616464,  /* 'sadd' */
icSigScalarSubtractOp             = 0x73737562,  /* 'ssub' */
icSigScalarMultiplyOp             = 0x736d756c,  /* 'smul' */
icSigScalarDivideOp               = 0x73646976,  /* 'sdiv' */
icSigSquareOp                     = 0x73712020,  /* 'sq  ' */
icSigSquareRootOp                 = 0x73717274,  /* 'sqrt' */
icSigCubeOp                       = 0x63622020,  /* 'cb  ' */
icSigCubeRootOp                   = 0x63627274,  /* 'cbrt' */
icSigSignOp                       = 0x7369676e,  /* 'sign' */
icSigAbsoluteValOp                = 0x61627320,  /* 'abs ' */
icSigFloorOp                      = 0x666c6f72,  /* 'flor' */
icSigCeilingOp                    = 0x6365696c,  /* 'ceil' */
icSigTruncateOp                   = 0x74726e63,  /* 'trnc' */
icSigRoundOp                      = 0x726f6e64,  /* 'rond' */
icSigExpOp                        = 0x65787020,  /* 'exp ' */
icSigLogrithmOp                   = 0x6c6f6720,  /* 'log ' */
icSigNaturalLogOp                 = 0x6c6e2020,  /* 'ln  ' */
icSigSineOp                       = 0x73696e20,  /* 'sin ' */
icSigCosineOp                     = 0x636f7320,  /* 'cos ' */
icSigTangentOp                    = 0x74616e20,  /* 'tan ' */
icSigArcSineOp                    = 0x6173696e,  /* 'asin' */
icSigArcCosineOp                  = 0x61636f73,  /* 'acos' */
icSigArcTangentOp                 = 0x6174616e,  /* 'atan' */
icSigArcTan2Op                    = 0x61746e32,  /* 'atn2' */
icSigCartesianToPolarOp           = 0x63746f70,  /* 'ctop' */
icSigPolarToCartesianOp           = 0x70746f63,  /* 'ptoc' */
icSigRealNumberOp                 = 0x726e756d,  /* 'rnum' */
icSigLessThanOp                   = 0x6c742020,  /* 'lt  ' */
icSigLessThanEqualOp              = 0x6c652020,  /* 'le  ' */
icSigEqualOp                      = 0x65712020,  /* 'eq  ' */
icSigNearOp                       = 0x6e656172,  /* 'near' */
icSigGreaterThanEqualOp           = 0x67652020,  /* 'ge  ' */
icSigGreaterThanOp                = 0x67742020,  /* 'gt  ' */
icSigNotOp                        = 0x6e6f7420,  /* 'not ' */
icSigToLabOp                      = 0x744c6162,  /* 'tLab' */
icSigToXYZOp                      = 0x7458595a,  /* 'tXYZ' */
icSigVectorMinimumOp              = 0x766d696e,  /* 'vmin' */
icSigVectorMaximumOp              = 0x766d6178,  /* 'vmax' */
icSigVectorAndOp                  = 0x76616e64,  /* 'vand' */
icSigVectorOrOp                   = 0x766f7220,  /* 'vor ' */

//Matrix Operations
icSigSolveOp                      = 0x736f6c76,  /* 'solv' */
icSigTransposeOp                  = 0x7472616e,  /* 'tran' */

//Conditional operation
icSigIfOp                         = 0x69662020,  /* 'if  ' */
icSigElseOp                       = 0x656c7365,  /* 'else' */

//Selection operation
icSigSelectOp                     = 0x73656c20,  /* 'sel ' */
icSigCaseOp                       = 0x63617365,  /* 'case' */
icSigDefaultOp                    = 0x64666c74,  /* 'dflt' */

//Boolean operation
218}icSigCalcOp;



222/**
223****************************************************************************
224* Structure: SIccCalcOp
225* 
226* Purpose: A structure to keep track of channel operations
227*****************************************************************************
228*/
229struct ICCPROFLIB_API SIccCalcOp
230{
231public:
icSigCalcOp sig;
union {
  icFloat32Number num;
  icUInt32Number size;
  struct {
237#ifndef ICC_BYTE_ORDER_LITTLE_ENDIAN
    icUInt16Number v1;
    icUInt16Number v2;
240#else
    icUInt16Number v2;
    icUInt16Number v1;
243#endif
  } select;
}data;
unsigned long extra;
IIccOpDef *def;

void Describe(std::string &desc);

static bool IsValidOp(icSigCalcOp sig);

bool IsValidOp(CIccMpeCalculator *pCalc);
icUInt16Number ArgsUsed(CIccMpeCalculator *pCalc);
icUInt16Number ArgsPushed(CIccMpeCalculator *pCalc);
256};

258typedef std::list<SIccCalcOp> CIccCalcOpList;
259typedef CIccCalcOpList* CIccCalcOpListPtr;
260typedef std::list<CIccCalcOpListPtr> CIccCalcOpListPtrList;

262typedef std::vector<icFloatNumber> CIccFloatVector;

264/**
265****************************************************************************
266* Structure: SIccOpState
267* 
268* Purpose: Keep everything in one place for IIccOpDef Exec
269*****************************************************************************
270*/
271struct SIccOpState
272{
CIccApplyMpeCalculator *pApply;
CIccFloatVector *pStack;
CIccFloatVector *pScratch;
icFloatNumber *temp;
const icFloatNumber *pixel;
icFloatNumber *output;
icUInt32Number idx;
icUInt32Number nOps;
281};

283/**
284****************************************************************************
285* Interface: IIccOpDef
286* 
287* Purpose: A structure to keep track of channel operations
288*****************************************************************************
289*/
290class ICCPROFLIB_API IIccOpDef
291{
292public:
IIccOpDef() {}
virtual ~IIccOpDef() {}

virtual int ArgsPushed(CIccMpeCalculator *pCalc, SIccCalcOp &op) { return op.ArgsPushed(pCalc);}
virtual int ArgsUsed(CIccMpeCalculator *pCalc, SIccCalcOp &op) { return op.ArgsUsed(pCalc);}

virtual void Describe(SIccCalcOp &op, std::string &desc) {op.Describe(desc);}

virtual bool IsValid(CIccMpeCalculator *pCalc, SIccCalcOp &op) { return op.IsValidOp(pCalc); }

virtual bool Exec(SIccCalcOp *op, SIccOpState &s) {return false;}
304};


307typedef enum {
icFuncParseNoError=0,
icFuncParseSyntaxError,
icFuncParseInvalidOperation,
icFuncParseStackUnderflow,
icFuncParseStackOverflow,
icFuncParseInvalidChannel,
icFuncParseEmptyFunction,
315} icFuncParseStatus;

317#define icSigBeginBlockOp((icSigCalcOp)0x7b202020) ((icSigCalcOp)0x7b202020)
318#define icSigEndBlockOp((icSigCalcOp)0x7d202020)  ((icSigCalcOp)0x7d202020)
319#define icSigBadOp((icSigCalcOp)0) ((icSigCalcOp)0)

321class ICCPROFLIB_API CIccFuncTokenizer
322{
323public:
CIccFuncTokenizer(const char *szText, bool bAllowReferences = false);
virtual ~CIccFuncTokenizer();

bool GetNext(bool bForceNoRefs = false);
const char *GetPos() { return m_text; }
void SetPos(const char *szText) { m_text = szText; }

icSigCalcOp GetSig();
bool GetIndex(icUInt16Number &v1, icUInt16Number &v2, icUInt16Number initV1=0, icUInt16Number initV2=0);
icFloat32Number GetValue();
bool GetEnvSig(icSigCmmEnvVar &envSig);

//The following are used by XML variable and macro parsing
std::string GetName() const;
std::string GetReference() const;

std::string &GetLast() { return *m_token; }

342protected:
bool IsWhiteSpace();
bool IsComment();
void SkipComment();

const char *m_text;
std::string *m_token;

bool m_bUseRefs;
351};

353class CIccApplyMpeCalculator;

355/**
356****************************************************************************
357* Class: CIccCalculatorFunc
358* 
359* Purpose: The Calculator function sequence
360*****************************************************************************
361*/
362class ICCPROFLIB_API CIccCalculatorFunc
363{
364public:
CIccCalculatorFunc(CIccMpeCalculator *pCalc);
CIccCalculatorFunc(const CIccCalculatorFunc &ICF);
CIccCalculatorFunc &operator=(const CIccCalculatorFunc &ICF);
virtual CIccCalculatorFunc *NewCopy() const { return new CIccCalculatorFunc(*this);}
virtual ~CIccCalculatorFunc();

virtual icChannelFuncSignature GetType() const { return icSigChannelFunction; }
virtual const icChar *GetClassName() const { return "CIccChannelFunction"; }

virtual void Describe(std::string &sDescription, int nBlanks=0);

virtual bool Read(icUInt32Number size, CIccIO *pIO);
virtual bool Write(CIccIO *pIO);

virtual bool Begin(const CIccMpeCalculator *pChannelMux, CIccTagMultiProcessElement *pMPE);
virtual bool Apply(CIccApplyMpeCalculator *pApply) const;
virtual icValidateStatus Validate(std::string sigPath, std::string &sReport,
                                  const CIccMpeCalculator* pChannelCalc=NULL__null) const;

icFuncParseStatus SetFunction(const char *szFuncDef, std::string &sReport);
icFuncParseStatus SetFunction(CIccCalcOpList &opList, std::string &sReport);

icUInt32Number GetMaxTemp() const;
int CheckUnderflowOverflow(SIccCalcOp *op, icUInt32Number nOps, int nArgs, bool bCheckUnderflow, std::string &sReport) const;
icFuncParseStatus DoesStackUnderflowOverflow(std::string &sReport) const;
bool HasValidOperations(std::string &sReport) const;
bool DoesOverflowInput(icUInt16Number nInputChannels) const;
bool DoesOverflowOutput(icUInt16Number nOutputChannels) const;
bool NeedTempReset(icUInt8Number *tempUsage, icUInt32Number nMaxTemp);
bool SetOpDefs();

396protected:

bool InitSelectOps();
bool InitSelectOp(SIccCalcOp *ops, icUInt32Number nOps);

bool SequenceNeedTempReset(SIccCalcOp *op, icUInt32Number nOps, icUInt8Number *tempUsage, icUInt32Number nMaxTemp);

void InsertBlanks(std::string &sDescription, int nBlanks);
void DescribeSequence(std::string &sDescription,
                      icUInt32Number nOps, SIccCalcOp *op, int nBlanks);
bool ApplySequence(CIccApplyMpeCalculator *pApply, icUInt32Number nOps, SIccCalcOp *op) const;

const char *ParseFuncDef(const char *szFuncDef, CIccCalcOpList &m_list, std::string &sReport);

CIccMpeCalculator *m_pCalc;

icUInt32Number m_nReserved;

icUInt32Number m_nOps;
SIccCalcOp *m_Op;

417};

419typedef CIccCalculatorFunc* icCalculatorFuncPtr;

421class ICCPROFLIB_API CIccSubCalcApply
422{
423public:
CIccSubCalcApply(CIccApplyMpe *pApplyMpe) { m_pApply = pApplyMpe; }
~CIccSubCalcApply() { if (m_pApply) delete m_pApply; }

icUInt16Number NumInputChannels() { return m_pApply->GetElem()->NumInputChannels(); }
icUInt16Number NumOutputChannels() { return m_pApply->GetElem()->NumOutputChannels(); }

void Apply(icFloatNumber *pDestPixel, const icFloatNumber *pSrcPixel) { if (m_pApply) m_pApply->Apply(pDestPixel, pSrcPixel); }

432protected:
CIccApplyMpe *m_pApply;
434};


437/**
438****************************************************************************
439* Class: CIccMpeCalculator
440* 
441* Purpose: The Calculator process element
442*****************************************************************************
443*/
444class ICCPROFLIB_API CIccMpeCalculator : public CIccMultiProcessElement
445{
446public:
CIccMpeCalculator(icUInt16Number nInputChannels=0, icUInt16Number nOutputChannels=0);
CIccMpeCalculator(const CIccMpeCalculator &curveSet);
CIccMpeCalculator &operator=(const CIccMpeCalculator &curveSet);
virtual CIccMpeCalculator *NewCopy() const { return new CIccMpeCalculator(*this);}
virtual ~CIccMpeCalculator();

void Reset() { SetSize(0,0); }
void SetSize(icUInt16Number nInputChannels, icUInt16Number nOutputChannels);

icFuncParseStatus SetCalcFunc(icCalculatorFuncPtr newFunc);
icFuncParseStatus SetCalcFunc(const char *szFuncDef, std::string &sReport);

bool SetSubElem(icUInt32Number idx, CIccMultiProcessElement *pElem) { return SetElem(idx, pElem, m_nSubElem, &m_SubElem); }
30
←
Calling 'CIccMpeCalculator::SetElem'→

virtual icElemTypeSignature GetType() const { return icSigCalculatorElemType; }
virtual const icChar *GetClassName() const { return "CIccMpeCalculator"; }

virtual void Describe(std::string &sDescription);

virtual bool Read(icUInt32Number size, CIccIO *pIO);
virtual bool Write(CIccIO *pIO);

virtual bool Begin(icElemInterp nInterp, CIccTagMultiProcessElement *pMPE);
virtual CIccApplyMpe *GetNewApply(CIccApplyTagMpe *pApplyTag);
virtual void Apply(CIccApplyMpe *pApply, icFloatNumber *pDestPixel, const icFloatNumber *pSrcPixel) const;
virtual icValidateStatus Validate(std::string sigPath, std::string &sReport, const CIccTagMultiProcessElement* pMPE=NULL__null) const;

CIccMultiProcessElement *GetElem(icSigCalcOp op, icUInt16Number index);

virtual bool IsLateBinding() const;
virtual bool IsLateBindingReflectance() const;

479protected:

bool SetElem(icUInt32Number idx, CIccMultiProcessElement *pElem, icUInt32Number &count, CIccMultiProcessElement ***pArray);

icUInt32Number m_nTempChannels;
bool m_bNeedTempReset;

icUInt32Number m_nSubElem;
CIccMultiProcessElement **m_SubElem;

icCalculatorFuncPtr m_calcFunc;

IIccCmmEnvVarLookup *m_pCmmEnvVarLookup;
492};


495/**
496****************************************************************************
497* Class: CIccApplyMpeCalculator
498* 
499* Purpose: The Calculator process element apply data
500*****************************************************************************
501*/
502class CIccApplyMpeCalculator : public CIccApplyMpe
503{
friend class CIccMpeCalculator;
505public:
virtual ~CIccApplyMpeCalculator();

virtual icElemTypeSignature GetType() const { return icSigCalculatorElemType; }
virtual const icChar *GetClassName() const { return "CIccApplyMpeCalculator"; }

const icFloatNumber *GetInput() { return m_input; }
icFloatNumber *GetOutput() { return m_output; }
icFloatNumber *GetTemp() { return m_temp; }

CIccFloatVector *GetStack() { return m_stack; }

CIccFloatVector *GetScratch() { return m_scratch; }

CIccSubCalcApply* GetApply(icUInt16Number index);

bool GetEnvVar(icSigCmmEnvVar sigEnv, icFloatNumber &val);

523protected:
CIccApplyMpeCalculator(CIccMultiProcessElement *pElem);

CIccFloatVector *m_stack;
CIccFloatVector *m_scratch;

//Use member storage for calls between Apply and ApplySequence
const icFloatNumber *m_input;
icFloatNumber *m_output;
icFloatNumber *m_temp;

//Apply storage for sub-elements
icUInt32Number m_nSubElem;
CIccSubCalcApply **m_SubElem;

IIccCmmEnvVarLookup *m_pCmmEnvVarLookup;
539};

541class IIccCalcDebugger
542{
543public:
static void SetDebugger(IIccCalcDebugger *pDebugger);

virtual ~IIccCalcDebugger() {}

virtual void BeginApply() = 0;
virtual void EndApply() = 0;

virtual bool BeforeOp(SIccCalcOp *op, SIccOpState &os, SIccCalcOp *ops)=0;
virtual bool AfterOp(SIccCalcOp *op, SIccOpState &os, SIccCalcOp *ops)=0;

virtual void Error(const char *msg) = 0;
555};

557#define icCalcDebuggerNone((IIccCalcDebugger*)0)    ((IIccCalcDebugger*)0) 
558#define icCalcDebuggerConsole((IIccCalcDebugger*)-1) ((IIccCalcDebugger*)-1) 

560//CIccMPElements support  
561#ifdef USEREFICCMAXNAMESPACE
562}
563#endif

565#endif //_ICCELEMCALC_H