CIccMpeXmlCalculator Class Reference

#include <IccMpeXml.h>

Inheritance diagram for CIccMpeXmlCalculator:

Collaboration diagram for CIccMpeXmlCalculator:

Public Member Functions
	CIccMpeXmlCalculator ()
virtual const char *	GetClassName () const
virtual IIccExtensionMpe *	GetExtension ()
bool	ParseImport (xmlNode *pNode, std::string importPath, std::string &parseStr)
virtual bool	ParseXml (xmlNode *pNode, std::string &parseStr)
virtual bool	ToXml (std::string &xml, std::string blanks="")
virtual	~CIccMpeXmlCalculator ()
Public Member Functions inherited from CIccMpeCalculator
virtual void	Apply (CIccApplyMpe *pApply, icFloatNumber *pDestPixel, const icFloatNumber *pSrcPixel) const
	Name: CIccMpeCalculator::Apply.
virtual bool	Begin (icElemInterp nInterp, CIccTagMultiProcessElement *pMPE)
	Name: CIccMpeCalculator::Begin.
	CIccMpeCalculator (const CIccMpeCalculator &curveSet)
	Name: CIccMpeCalculator::CIccMpeCalculator.
	CIccMpeCalculator (icUInt16Number nInputChannels=0, icUInt16Number nOutputChannels=0)
	Name: CIccMpeCalculator::CIccMpeCalculator.
virtual void	Describe (std::string &sDescription, int nVerboseness)
	Name: CIccMpeCalculator::Describe.
CIccMultiProcessElement *	GetElem (icSigCalcOp op, icUInt16Number index)
	Name: CIccMpeCalculator::GetSubApply.
virtual CIccApplyMpe *	GetNewApply (CIccApplyTagMpe *pApplyTag)
	Name: CIccMpeCalculator::Begin.
virtual icElemTypeSignature	GetType () const
virtual bool	IsLateBinding () const
	Name: CIccMpeCalculator::IsLateBinding.
virtual bool	IsLateBindingReflectance () const
	Name: CIccMpeCalculator::IsLateBindingReflectance.
virtual CIccMpeCalculator *	NewCopy () const
CIccMpeCalculator &	operator= (const CIccMpeCalculator &curveSet)
	Name: &CIccMpeCalculator::operator=.
virtual bool	Read (icUInt32Number size, CIccIO *pIO)
	Name: CIccMpeCalculator::Read.
void	Reset ()
icFuncParseStatus	SetCalcFunc (const char *szFuncDef, std::string &sReport)
	Name: CIccMpeCalculator::SetCalcFunc.
icFuncParseStatus	SetCalcFunc (icCalculatorFuncPtr newFunc)
	Name: CIccMpeCalculator::SetCalcFunc.
void	SetSize (icUInt16Number nInputChannels, icUInt16Number nOutputChannels)
	Name: CIccMpeCalculator::SetSize.
bool	SetSubElem (icUInt32Number idx, CIccMultiProcessElement *pElem)
virtual icValidateStatus	Validate (std::string sigPath, std::string &sReport, const CIccTagMultiProcessElement *pMPE=NULL, const CIccProfile *pProfile=NULL) const
	Name: CIccMpeCalculator::Validate.
virtual bool	Write (CIccIO *pIO)
	Name: CIccMpeCalculator::Write.
virtual	~CIccMpeCalculator ()
	Name: CIccMpeCalculator::~CIccMpeCalculator.
Public Member Functions inherited from CIccMultiProcessElement
	CIccMultiProcessElement ()
virtual icAcsSignature	GetBAcsSig ()
virtual icAcsSignature	GetEAcsSig ()
virtual bool	IsAcs ()
virtual bool	IsSupported ()
virtual icUInt16Number	NumInputChannels () const
virtual icUInt16Number	NumOutputChannels () const
virtual	~CIccMultiProcessElement ()
Public Member Functions inherited from CIccMpeXml
virtual const char *	GetExtClassName ()
virtual	~CIccMpeXml (void)

Protected Member Functions
void	clean ()
bool	Flatten (std::string &flatStr, std::string macroName, const char *szFunc, std::string &parseStr, icUInt32Number nLocalsOffset=0)
bool	ParseChanMap (ChanVarMap &chanMap, const char *szNames, int nChannels)
bool	UpdateLocals (std::string &func, std::string szFunc, std::string &parseStr, int nLocalsOffset)
bool	ValidateMacroCalls (std::string &parseStr) const
bool	ValidMacroCalls (const char *szMacroText, std::string macroStack, std::string &parseStr) const
Protected Member Functions inherited from CIccMpeCalculator
bool	SetElem (icUInt32Number idx, CIccMultiProcessElement *pElem, icUInt32Number &count, CIccMultiProcessElement ***pArray)
	Name: CIccMpeCalculator::GetSubApply.

Static Protected Member Functions
static bool	validName (const char *saName)
static bool	validNameChar (char c, bool bFirst)

Protected Attributes
TempDeclVarMap	m_declVarMap
ChanVarMap	m_inputMap
TempDeclVarMap	m_macroLocalMap
MacroMap	m_macroMap
MpePtrList	m_mpeList
MpePtrMap	m_mpeMap
int	m_nNextMpe
int	m_nNextVar
ChanVarMap	m_outputMap
std::string	m_sImport
TempVarMap	m_varMap
Protected Attributes inherited from CIccMpeCalculator
bool	m_bNeedTempReset
icCalculatorFuncPtr	m_calcFunc
icUInt32Number	m_nSubElem
icUInt32Number	m_nTempChannels
IIccCmmEnvVarLookup *	m_pCmmEnvVarLookup
CIccMultiProcessElement **	m_SubElem
Protected Attributes inherited from CIccMultiProcessElement
icUInt16Number	m_nInputChannels
icUInt16Number	m_nOutputChannels

Additional Inherited Members
Static Public Member Functions inherited from CIccMultiProcessElement
static CIccMultiProcessElement *	Create (icElemTypeSignature sig)
	Name: CIccMultiProcessElement::Create.
Public Attributes inherited from CIccMultiProcessElement
icUInt32Number	m_nReserved

Detailed Description

Definition at line 301 of file IccMpeXml.h.

Constructor & Destructor Documentation

CIccMpeXmlCalculator()

CIccMpeXmlCalculator::CIccMpeXmlCalculator ( )

inline

Definition at line 304 of file IccMpeXml.h.

{ m_sImport = "*"; }

References m_sImport.

~CIccMpeXmlCalculator()

virtual CIccMpeXmlCalculator::~CIccMpeXmlCalculator ( )

inlinevirtual

Definition at line 305 of file IccMpeXml.h.

{  clean(); }

References clean().

Here is the call graph for this function:

Member Function Documentation

clean()

void CIccMpeXmlCalculator::clean ( )

protected

Definition at line 3000 of file IccMpeXml.cpp.

{
  m_sImport = "*";
  m_declVarMap.clear();
  m_varMap.clear();
  m_macroMap.clear();
 
  MpePtrList::iterator ml;
  for (ml = m_mpeList.begin(); ml != m_mpeList.end(); ml++) {
    if (ml->m_ptr)
      delete ml->m_ptr;
  }
  m_mpeList.clear();
 
  MpePtrMap::iterator mm;
  for (mm = m_mpeMap.begin(); mm != m_mpeMap.end(); mm++) {
    if (mm->second.m_ptr)
      delete mm->second.m_ptr;
  }
  m_mpeMap.clear();
  m_nNextVar = 0;
  m_nNextMpe = 0;
}

Referenced by ~CIccMpeXmlCalculator().

Here is the caller graph for this function:

Flatten()

bool CIccMpeXmlCalculator::Flatten ( std::string & flatStr, std::string macroName, const char * szFunc, std::string & parseStr, icUInt32Number nLocalsOffset = 0 )

protected

Definition at line 2654 of file IccMpeXml.cpp.

{
  CIccFuncTokenizer parse(szFunc, true);
 
  while (parse.GetNext()) {
    std::string token = parse.GetLast();
    const char *tok = token.c_str();
    if (!strncmp(tok, "call{", 5) ||
        tok[0] == '#') {
      std::string nameiter;
      std::string name;
 
      if (tok[0] == '#')
        nameiter = token.substr(1);
      else
        nameiter = parse.GetReference();
 
      const char *ptr;
      for (ptr = nameiter.c_str(); *ptr && *ptr != '[' && *ptr != '('; ptr++) name += *ptr;
      int iter = 1;
//       if (*ptr) {
//         iter = atoi(ptr + 1);
//         if (iter < 1)
//           iter = 1;
//         else if (iter>1024)
//           iter = 1024;
//       }
 
      MacroMap::iterator m = m_macroMap.find(name.c_str());
      if (m != m_macroMap.end()) {
        icUInt16Number nLocalsSize = 0;
        TempDeclVarMap::iterator locals = m_macroLocalMap.find(macroName);
        if (locals != m_macroLocalMap.end()) {
          nLocalsSize = locals->second.m_size;
        }
        
        int i;
        for (i = 0; i < iter; i++) {
          Flatten(flatStr, name, m->second.c_str(), parseStr, nLocalsOffset+nLocalsSize);
        }
      }
      else {
        parseStr += "Call to undefined macro '" + name + "'\n";
        return false;
      }
    }
    else if (!strncmp(tok, "in{", 3) ||
             !strncmp(tok, "out{", 4)) {
      std::string op = parse.GetName();
      std::string ref = parse.GetReference();
      std::string refroot;
      for (const char *ptr = ref.c_str(); *ptr && *ptr != ',' && *ptr != '(' && *ptr != '['; ptr++) refroot += *ptr;
 
      ChanVarMap *pMap;
      int nChan;
      if (op == "in") {
        pMap = &m_inputMap;
        nChan = m_nInputChannels;
      }
      else {
        pMap = &m_outputMap;
        nChan = m_nOutputChannels;
      }
 
      ChanVarMap::iterator ci = pMap->find(refroot);
      if (ci == pMap->end()) {
        parseStr += "Invalid '" + op + "' operation channel reference '" + refroot + "'\n";
        return false;
      }
      if (refroot != ref) {
        std::string select = ref.substr(refroot.size());
        int offset = 0;
        int size = 1;
 
        if (select[0] == '[' || select[1] == '(') {
          const char *ptr;
          offset = atoi(select.c_str() + 1);
          for (ptr = select.c_str() + 1; *ptr && *ptr != ')' && *ptr != ']'; ptr++);
          select = ptr + 1;
        }
 
        if (select[0]==',')
          size = atoi(select.c_str() + 1);
 
        if (size < 0 || offset<0 || ci->second.first + offset + size > m_nInputChannels) {
          parseStr += "Invalid '" + op + "' operation channel offset or size '" + refroot + "'\n";
          return false;
        }
        char index[80];
        sprintf(index, "(%d,%d)", ci->second.first+offset, size);
        flatStr += op + index + " ";
      }
      else if (ci->second.second>1) {
        char index[80];
        sprintf(index, "(%d,%d)", ci->second.first, ci->second.second);
        flatStr += op + index + " ";
      }
      else {
        char index[80];
        sprintf(index, "(%d)", ci->second.first);
        flatStr += op + index + " ";
      }
    }
    else if (!strncmp(tok, "tget{", 5) ||
             !strncmp(tok, "tput{", 5) ||
             !strncmp(tok, "tsav{", 5)) {
      std::string op = parse.GetName();
      std::string ref = parse.GetReference();
      std::string refroot;
      for (const char *ptr = ref.c_str(); *ptr && *ptr != '[' && *ptr != '('; ptr++) refroot += *ptr;
 
      if (macroName.size() && refroot.size() && refroot[0] == '@') {
        std::string localName = refroot.substr(1);
        TempDeclVarMap::iterator locals = m_macroLocalMap.find(macroName);
        if (locals == m_macroLocalMap.end()) {
          parseStr += "Reference to undeclared local variable '" + localName + "' in macro '" + macroName + "'\n";
          return false;
        }
 
        unsigned long nLocalOffset = 0;
        unsigned long nLocalSize = 0;
        TempVarList::iterator m = locals->second.m_members.begin();
        for (; m != locals->second.m_members.end(); m++) {
          if (localName == m->m_name) {
            nLocalOffset = m->m_pos;
            nLocalSize = m->m_size;
            break;
          }
        }
        if (m == locals->second.m_members.end()) {
          parseStr += "Reference to undeclared local variable '" + localName + "' in macro '" + macroName + "'\n";
          return false;
        }
        int voffset, vsize;
 
        if (ref != refroot) {
          CIccFuncTokenizer p2(ref.c_str());
          p2.GetNext();
          icUInt16Number _voffset = 0, _vsize = 1;
          p2.GetIndex(_voffset, _vsize, 0, 1);
          voffset = _voffset;
          vsize = _vsize + 1;
        }
        else {
          voffset = 0;
          vsize = (int)nLocalSize;
        }
 
        if (voffset + vsize > (int)nLocalSize) {
          parseStr += "Out of bounds indexing of local '" + refroot + "' in macro '" + macroName + "'\n";
          return false;
        }
 
        if (nLocalsOffset + nLocalOffset + voffset + vsize > 65536) {
          parseStr += "Temporary variable addressing out of bounds\n";
          return false;
        }
        char idx[80];
        if (vsize == 1) {
          sprintf(idx, "[%lu]", nLocalsOffset + nLocalOffset + voffset);
        }
        else {
          sprintf(idx, "[%lu,%d]", nLocalsOffset + nLocalOffset + voffset, vsize);
        }
        flatStr += "l";
        flatStr += op.substr(1);
        flatStr += idx;
        flatStr += " ";
      }
      else {
        TempVarMap::iterator var = m_varMap.find(refroot);
        if (var == m_varMap.end()) {
          std::string root;
          for (const char *ptr = refroot.c_str(); *ptr && *ptr != '.'; ptr++) root += *ptr;
 
          TempVarMap::iterator rootVar = m_varMap.find(root);
          if (refroot != root && rootVar == m_varMap.end()) {
            parseStr += "Reference to undeclared variable '" + ref + "'\n";
            return false;
          }
 
          TempDeclVarMap::iterator decl = m_declVarMap.find(root);
          if (decl == m_declVarMap.end()) {
            parseStr += "Reference to undeclared variable '" + ref + "'\n";
            return false;
          }
 
          if (decl->second.m_pos < 0) {
            m_varMap[root] = CIccTempVar(root, m_nNextVar, decl->second.m_size);
            decl->second.m_pos = m_nNextVar;
 
            if (strchr(refroot.c_str(), '.')) {
              TempVarList::iterator m = decl->second.m_members.begin();
              for (; m != decl->second.m_members.end(); m++) {
                std::string vm = root + "." + m->m_name;
                m_varMap[vm] = CIccTempVar(vm, m_nNextVar + m->m_pos, m->m_size);
              }
            }
 
            if (m_nNextVar + decl->second.m_size > 65536) {
              parseStr += "Temporary variable addressing out of bounds\n";
              return false;
            }
            m_nNextVar += decl->second.m_size;
          }
          else {
            m_varMap[root] = CIccTempVar(root, decl->second.m_pos, decl->second.m_size);
 
            if (strchr(refroot.c_str(), '.')) {
              TempVarList::iterator m = decl->second.m_members.begin();
              for (; m != decl->second.m_members.end(); m++) {
                std::string vm = root + "." + m->m_name;
                m_varMap[vm] = CIccTempVar(vm, decl->second.m_pos + m->m_pos, m->m_size);
              }
            }
            if (decl->second.m_pos + decl->second.m_size > 65536) {
              parseStr += "Temporary variable addressing out of bounds\n";
              return false;
            }
          }
 
          var = m_varMap.find(refroot);
          if (var == m_varMap.end()) {
            parseStr += "Reference to undeclared variable '" + refroot + "'\n";
            return false;
          }
        }
        int voffset, vsize;
 
        if (ref != refroot) {
          CIccFuncTokenizer p2(ref.c_str());
          p2.GetNext();
          icUInt16Number _voffset = 0, _vsize = 1;
          p2.GetIndex(_voffset, _vsize, 0, 1);
          voffset = _voffset;
          vsize = _vsize + 1;
        }
        else {
          voffset = 0;
          vsize = var->second.m_size;
        }
 
        if (voffset + vsize > var->second.m_size) {
          parseStr += "Out of bounds indexing of '" + refroot + "'\n";
          return false;
        }
        if (var->second.m_pos + voffset + vsize > 65536) {
          parseStr += "Temporary variable addressing out of bounds\n";
          return false;
        }
        char idx[80];
        if (vsize == 1) {
          sprintf(idx, "[%d]", var->second.m_pos + voffset);
        }
        else {
          sprintf(idx, "[%d,%d]", var->second.m_pos + voffset, vsize);
        }
        flatStr += op + idx + " ";
      }
    }
    else if (!strncmp(tok, "elem{", 5) ||
             !strncmp(tok, "curv{", 5) ||
             !strncmp(tok, "clut{", 5) ||
             !strncmp(tok, "mtx{", 4) ||
             !strncmp(tok, "fJab{", 5) ||
             !strncmp(tok, "tJab{", 5) ||
             !strncmp(tok, "calc{", 5) ||
             !strncmp(tok, "tint{", 5)) {
      std::string op = parse.GetName();
      std::string ref = parse.GetReference();
      MpePtrMap::iterator e = m_mpeMap.find(ref);
      if (e == m_mpeMap.end()) {
        parseStr += "Unknown sub element reference to " + token + "\n";
        return false;
      }
      if (e->second.m_nIndex<0) {
        if (e->second.m_ptr) {
          m_mpeList.push_back(CIccMpePtr(e->second.m_ptr, m_nNextMpe));
          e->second.m_ptr = NULL;
          e->second.m_nIndex = m_nNextMpe;
          m_nNextMpe++;
        }
        else {
          parseStr += "Invalid sub-element reference:  " + token + "\n";
          return false;
        }
      }
      char idx[80];
      sprintf(idx, "(%d)", e->second.m_nIndex);
      flatStr += op + idx + " ";
    }
    else {
      flatStr += tok;
      flatStr += " ";
    }
  }
 
  return true;
}

References CIccFuncTokenizer::GetIndex(), CIccFuncTokenizer::GetLast(), CIccFuncTokenizer::GetName(), CIccFuncTokenizer::GetNext(), and CIccFuncTokenizer::GetReference().

Here is the call graph for this function:

GetClassName()

virtual const char * CIccMpeXmlCalculator::GetClassName ( ) const

inlinevirtual

Reimplemented from CIccMpeCalculator.

Definition at line 307 of file IccMpeXml.h.

{ return "CIccMpeXmlCalculator"; }

GetExtension()

virtual IIccExtensionMpe * CIccMpeXmlCalculator::GetExtension ( )

inlinevirtual

Reimplemented from CIccMultiProcessElement.

Definition at line 309 of file IccMpeXml.h.

{ return this; }

ParseChanMap()

bool CIccMpeXmlCalculator::ParseChanMap ( ChanVarMap & chanMap, const char * szNames, int nChannels )

protected

Definition at line 3024 of file IccMpeXml.cpp.

{
  chanMap.clear();
 
  if (!szNames)
    return false;
 
  int i;
  const char *ptr;
  std::string name;
  IndexSizePair isp;
  int size = 1;
 
  for (i = 0, ptr = szNames; *ptr && i < nChannels; ptr++) {
    bool bFirst = name.empty();
    if (*ptr == ' ') {
      if (!bFirst) {
        isp.first = i;
        isp.second = size;
        chanMap[name] = isp;
        name.clear();
        i += size;
        size = 1;
      }
    }
    else if (*ptr == '[' || *ptr == '(') {
      size = atoi(ptr + 1);
      if (size<0 || i + size>nChannels)
        return 0;
 
      for (; *ptr && *ptr != ']' && *ptr != ')'; ptr++);
      if (!*ptr)
        ptr--;
    }
    else if (validNameChar(*ptr, bFirst)) {
      name += *ptr;
    }
    else {
      return false;
    }
  }
 
  if (!name.empty() && i < nChannels) {
    isp.first = i;
    isp.second = size;
    chanMap[name] = isp;
  }
 
  return true;
}

ParseImport()

bool CIccMpeXmlCalculator::ParseImport	(	xmlNode *	pNode,
		std::string	importPath,
		std::string &	parseStr )

Definition at line 2336 of file IccMpeXml.cpp.

{
  xmlNode *pChild, *pNext;
  xmlAttr *attr;
 
  pChild = icXmlFindNode(pNode->children, "Imports");
  if (pChild) {
    for (pNext = pChild->children; pNext; pNext = pNext->next) {
      if (pNext->type == XML_ELEMENT_NODE) {
        if (!strcmp((icChar*)pNext->name, "Import")) {
          if ((attr = icXmlFindAttr(pNext, "Filename"))) {
            std::string file = icXmlAttrValue(attr);
            xmlDoc *doc = NULL;
            xmlNode *root_element = NULL;
 
            std::string look = "*";
            look += file;
            look += "*";
 
            if (strstr(importPath.c_str(), look.c_str())) {
              //Already imported this file
              continue;
            }
 
            /*parse the file and get the DOM */
            doc = xmlReadFile(file.c_str(), NULL, 0);
 
            if (doc == NULL) {
              parseStr += "Unable to import '";
              parseStr += file;
              parseStr += '\n';
              return false;
            }
 
            /*Get the root element node */
            root_element = xmlDocGetRootElement(doc);
            if (strcmp((icChar*)root_element->name, "IccCalcImport")) {
              parseStr += "Invalid calc element import file '" + file + "'\n";
              return false;
            }
 
            bool rv = ParseImport(root_element, importPath+file+"*", parseStr);
 
            xmlFreeDoc(doc);
          }
          else {
            parseStr += "Missing import file specifier\n";
            return false;
          }
        }
        else {
          parseStr += "Invalid import specifier\n";
          return false;
        }
      }
    }
  }
 
  pChild = icXmlFindNode(pNode->children, "Variables");
  if (pChild) {
    for (pNext = pChild->children; pNext; pNext = pNext->next) {
      if (pNext->type == XML_ELEMENT_NODE) {
        if (!strcmp((icChar*)pNext->name, "Declare")) {
          if ((attr = icXmlFindAttr(pNext, "Name"))) {
            std::string name = icXmlAttrValue(attr);
            if (!validName(name.c_str())) {
              parseStr += "Invalid calc element variable name '" + name + "'\n'";
              return false;
            }
 
            TempDeclVarMap::iterator v = m_declVarMap.find(name);
            if (v != m_declVarMap.end()) {
              parseStr += "Calc element variable '" + name + "' was previously declared\n";
              return false;
            }
            int offset = -1;
            icUInt16Number size = 1;
 
            if ((attr = icXmlFindAttr(pNext, "Position"))) {
              offset = atoi(icXmlAttrValue(attr));
              if (offset && importPath != "*") {
                parseStr += "Position cannot be specified for imported variables";
                return false;
              }
            }
            if ((attr = icXmlFindAttr(pNext, "Size"))) {
              size = (icUInt16Number)atoi(icXmlAttrValue(attr));
            }
            if (size < 1) size = 1;
 
            CIccTempDeclVar var = CIccTempDeclVar(name, offset, size);
            if (pNext->children && pNext->children->content) {
              CIccFuncTokenizer parse((icChar*)pNext->children->content);
              offset = 0;
 
              while (parse.GetNext()) {
                icUInt16Number extra = 0;
                std::string member = parse.GetName();
                if (!validName(member.c_str())) {
                  parseStr += "Invalid member name '" + member + "' for calc element variable '" + name + "'\n";
                  return false;
                }
                size = 0; extra = 0;
                parse.GetIndex(size, extra, 1, 0);
                size++;
                if (size < 1) 
                  size = 1;
 
                var.m_members.push_back(CIccTempVar(member, offset, size));
                offset += size;
              }
              if (var.m_size < offset)
                var.m_size = offset;
            }
            m_declVarMap[name] = var;
          }
          else {
            parseStr += "Missing calc element variable name definition\n";
            return false;
          }
        }
        else {
          parseStr += "Invalid calc element variable declaration\n";
          return false;
        }
      }
    }
  }
 
  pChild = icXmlFindNode(pNode->children, "Macros");
  if (pChild) {
    for (pNext = pChild->children; pNext; pNext = pNext->next) {
      if (pNext->type == XML_ELEMENT_NODE) {
        if (!strcmp((icChar*)pNext->name, "Macro")) {
          if ((attr = icXmlFindAttr(pNext, "Name"))) {
            std::string name = icXmlAttrValue(attr);
            if (!validName(name.c_str())) {
              parseStr += "Invalid Macro name '" + name + "'\n'";
              return false;
            }
            if (!pNext->children || !pNext->children->content || !pNext->children->content[0]) {
              parseStr += "Missing content for macro '" + name + "'\n'";
              return false;
            }
            MacroMap::iterator m = m_macroMap.find(name);
            if (m != m_macroMap.end()) {
              if (!strcmp(m->second.c_str(), (icChar*)pNext->children->content))
                continue;
              parseStr += "Calc Element macro '" + name + "' was previously defined differently\n";
              return false;
            }
            m_macroMap[name] = (icChar*)(pNext->children->content);
 
            if ((attr = icXmlFindAttr(pNext, "Local"))) {
              icUInt16Number offset, size;
              CIccTempDeclVar var = CIccTempDeclVar(name, 0, 0);
              std::string locals = icXmlAttrValue(attr);
              CIccFuncTokenizer parse(locals.c_str());
              offset = 0;
 
              while (parse.GetNext()) {
                icUInt16Number extra = 0;
                std::string member = parse.GetName();
                if (!validName(member.c_str())) {
                  parseStr += "Invalid local name '" + member + "' for calc element macro '" + name + "'\n";
                  return false;
                }
                size = 0; extra = 0;
                parse.GetIndex(size, extra, 1, 0);
                size++;
                if (size < 1)
                  size = 1;
 
                var.m_members.push_back(CIccTempVar(member, offset, size));
                offset += size;
              }
              if (var.m_size < offset)
                var.m_size = offset;
 
              m_macroLocalMap[name] = var;
            }
          }
          else {
            parseStr += "Missing macro name\n";
            return false;
          }
        }
        else {
          parseStr += "Invalid macro declaration\n";
          return false;
        }
      }
    }
  }
 
  pChild = icXmlFindNode(pNode->children, "SubElements");
  if (pChild) {
    for (pNext = pChild->children; pNext; pNext = pNext->next) {
      if (pNext->type == XML_ELEMENT_NODE) {
        std::string name;
 
        if ((attr = icXmlFindAttr(pNext, "Name"))) {
          name = icXmlAttrValue(attr);
          if (!validName(name.c_str())) {
            parseStr += "Invalid SubElement name '" + name + "'\n'";
            return false;
          }
        }
        if (name.empty()) {
          if (importPath != "*") {
            parseStr += "Imported Calc SubElments must be named.";
            return false;
          }
        }
        else {
          MpePtrMap::iterator se = m_mpeMap.find(name);
          if (se != m_mpeMap.end()) {
            parseStr += "Duplicate declaration of SubElement '" + name + "'\n";
            return false;
          }
        }
 
        CIccMultiProcessElement *pMpe = CIccTagXmlMultiProcessElement::CreateElement((const icChar*)pNext->name);
 
        if (!pMpe) {
          parseStr += std::string("Unknown Sub-Element Type (") + (const icChar*)pNext->name + ")\n";
          return false;
        }
 
        if (!strcmp(pMpe->GetClassName(), "CIccMpeXmlCalculator")) {
          CIccMpeXmlCalculator *pSubCalc = (CIccMpeXmlCalculator*)pMpe;
          pSubCalc->m_sImport = importPath;
        }
 
        xmlAttr *attr;
        IIccExtensionMpe *pExt = pMpe->GetExtension();
 
        if (pExt) {
          if (!strcmp(pExt->GetExtClassName(), "CIccMpeXml")) {
            CIccMpeXml* pXmlMpe = (CIccMpeXml*)pExt;
 
            if (pXmlMpe->ParseXml(pNext, parseStr)) {
              if ((attr = icXmlFindAttr(pNode, "Reserved"))) {
                sscanf(icXmlAttrValue(attr), "%u", &pMpe->m_nReserved);
              }
 
              if (name.empty()) {
                m_mpeList.push_back(CIccMpePtr(pMpe, m_nNextMpe));
                m_nNextMpe++;
              }
              else {
                m_mpeMap[name] = CIccMpePtr(pMpe);
              }
            }
            else {
              char str[100];
              sprintf(str, " starting on line %d", pNext->line);
              parseStr += std::string("Unable to parse element of type ") + pMpe->GetClassName() + str + "\n";
              delete pMpe;
              return false;
            }
          }
          else {
            parseStr += std::string("Element ") + pMpe->GetClassName() + "isn't of type CIccMpeXml\n";
            delete pMpe;
            return false;
          }
        }
        else {
          parseStr += std::string("Element ") + pMpe->GetClassName() + "isn't of type CIccMpeXml\n";
          delete pMpe;
          return false;
        }
      }
    }
  }
  return true;
}

References CIccTagXmlMultiProcessElement::CreateElement(), CIccMultiProcessElement::GetClassName(), IIccExtensionMpe::GetExtClassName(), CIccMultiProcessElement::GetExtension(), CIccFuncTokenizer::GetIndex(), CIccFuncTokenizer::GetName(), CIccFuncTokenizer::GetNext(), icXmlAttrValue(), icXmlFindAttr(), icXmlFindNode(), CIccTempDeclVar::m_members, CIccMultiProcessElement::m_nReserved, m_sImport, CIccTempDeclVar::m_size, and CIccMpeXml::ParseXml().

Here is the call graph for this function:

ParseXml()

bool CIccMpeXmlCalculator::ParseXml ( xmlNode * pNode, std::string & parseStr )

virtual

Implements CIccMpeXml.

Definition at line 3075 of file IccMpeXml.cpp.

{
  xmlNode *pChild;
  
  SetSize(atoi(icXmlAttrValue(pNode, "InputChannels")),
          atoi(icXmlAttrValue(pNode, "OutputChannels")));
 
  clean();
 
  if (!ParseChanMap(m_inputMap, icXmlAttrValue(pNode, "InputNames"), m_nInputChannels)) {
    parseStr += "Invalid name for InputChannels";
    return false;
  }
 
  if (!ParseChanMap(m_outputMap, icXmlAttrValue(pNode, "OutputNames"), m_nOutputChannels)) {
    parseStr += "Invalid name for InputChannels";
    return false;
  }
 
  if (!ParseImport(pNode, "*", parseStr))
    return false;
 
  if (!ValidateMacroCalls(parseStr)) {
    return false;
  }
 
  pChild = icXmlFindNode(pNode->children, "MainFunction");
  if (pChild && pNode->children && pChild->children->content) {
    char *content = (char*)pChild->children->content;
    std::string flatFunc;
 
    //Move new variables to after allocated variables
    TempDeclVarMap::iterator declVar;
    for (declVar = m_declVarMap.begin(); declVar != m_declVarMap.end(); declVar++) {
      if (declVar->second.m_pos >= 0) {
        int next = declVar->second.m_pos + declVar->second.m_size;
        if (next > m_nNextVar)
          m_nNextVar = next;
      }
    }
 
    if (!Flatten(flatFunc, "", content, parseStr, 0)) {
      return false;
    }
 
    if (m_macroLocalMap.size()) {
      std::string localFunc;
      if (!UpdateLocals(localFunc, flatFunc, parseStr, m_nNextVar)) {
        return false;
      }
      flatFunc = localFunc;
    }
    //copy MPE subelmeents used by Main Function to returned object
    int n;
    MpePtrList::iterator m;
    for (m = m_mpeList.begin(), n = 0; m != m_mpeList.end(); m++, n++) {
      this->SetSubElem(n, m->m_ptr);
      m->m_ptr = NULL;
    }
 
#if 0
    FILE *ff = fopen("flatfunc.txt", "wb");
    fwrite(flatFunc.c_str(), flatFunc.size(), 1, ff);
    fclose(ff);
#endif
 
    icFuncParseStatus stat = SetCalcFunc(flatFunc.c_str(), parseStr);
    if (stat!=icFuncParseNoError) {
      char buf[65];
      int len = icIntMin(64, (int)strlen(flatFunc.c_str()));
      strncpy(buf, flatFunc.c_str(), len);
      buf[len]=0;
 
      switch(stat) {
        case icFuncParseSyntaxError:
          parseStr += "Syntax Error occurred while parsing Main Calculator Function from \"";
          break;
        case icFuncParseInvalidOperation:
          parseStr += "Invalid Operation found while parsing Main Calculator Function from \"";
          break;
        case icFuncParseStackUnderflow:
          parseStr += "Stack underflow detected while parsing Main Calculator Function from \"";
          break;
        case icFuncParseInvalidChannel:
          parseStr += "Invalid Channel detected while parsing Main Calculator Function from \"";
          break;
        default:
          parseStr += "Unable to parse Main Calculator Function from \"";
      }
      parseStr += buf;
      parseStr += "\"\n";
      return false;
    }
  }
  clean();
 
  return true;
}

References icFuncParseInvalidChannel, icFuncParseInvalidOperation, icFuncParseNoError, icFuncParseStackUnderflow, icFuncParseSyntaxError, icIntMin(), icXmlAttrValue(), and icXmlFindNode().

Referenced by CIccSampledCalculatorCurveXml::ParseXml().

Here is the call graph for this function:

Here is the caller graph for this function:

ToXml()

bool CIccMpeXmlCalculator::ToXml ( std::string & xml, std::string blanks = "" )

virtual

Implements CIccMpeXml.

Definition at line 2260 of file IccMpeXml.cpp.

{
  char line[256];
  std::string blanks2 = blanks + "  ";
 
  sprintf(line, "<CalculatorElement InputChannels=\"%d\" OutputChannels=\"%d\"", NumInputChannels(), NumOutputChannels());
  xml += blanks + line;
 
  if (m_nReserved) {
    sprintf(line, " Reserved=\"%u\"", m_nReserved);
    xml += line;
  }
  xml += ">\n";
 
  int i;
 
  if (m_SubElem && m_nSubElem) {
    xml += blanks2 + "<SubElements>\n";
    for (i=0; i<(int)m_nSubElem; i++) {
      if (m_SubElem[i]) {
        IIccExtensionMpe *pExt = m_SubElem[i]->GetExtension();
        if (pExt && !strcmp(pExt->GetExtClassName(), "CIccMpeXml")) {
          CIccMpeXml *pMpe = (CIccMpeXml*)pExt;
          pMpe->ToXml(xml, blanks2+"  ");
        }
        else {
          return false;
        }
      }
      else {
        return false;
      }
    }
    xml += blanks2 + "</SubElements>\n";
  }
 
  if (m_calcFunc) {
    std::string desc;
 
    xml += blanks2 + "<MainFunction>\n";
 
    m_calcFunc->Describe(desc, 100, (int)blanks2.size()+2);
    xml += desc;
 
    xml+= blanks2 + "</MainFunction>\n";
  }
 
  xml += blanks + "</CalculatorElement>\n";
  return true;
}

References IIccExtensionMpe::GetExtClassName(), and CIccMpeXml::ToXml().

Referenced by CIccSampledCalculatorCurveXml::ToXml().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateLocals()

bool CIccMpeXmlCalculator::UpdateLocals ( std::string & func, std::string szFunc, std::string & parseStr, int nLocalsOffset )

protected

Definition at line 2954 of file IccMpeXml.cpp.

{
  func.clear();
  CIccFuncTokenizer parse(sFunc.c_str(), true);
 
  while (parse.GetNext()) {
    std::string token = parse.GetLast();
    const char *tok = token.c_str();
 
    if (!strncmp(tok, "lget[", 5) ||
        !strncmp(tok, "lput[", 5) ||
        !strncmp(tok, "lsav[", 5)) {
      std::string op = parse.GetName();
      int voffset, vsize;
 
      CIccFuncTokenizer p2(tok+4);
      icUInt16Number _voffset = 0, _vsize = 1;
      p2.GetIndex(_voffset, _vsize, 0, 1);
      voffset = _voffset + nLocalsOffset;
      vsize = _vsize + 1;
 
      if (voffset + vsize > 65535) {
        parseStr += "Local variable out of bounds - too many variables.\n";
        return false;
      }
 
      char idx[80];
      if (vsize == 1) {
        sprintf(idx, "[%d]", voffset);
      }
      else {
        sprintf(idx, "[%d,%d]", voffset, vsize);
      }
      func +="t";
      func += op.substr(1);
      func += idx;
      func += " ";
    }
    else {
      func += tok;
      func += " ";
    }
  }
 
  return true;
}

References CIccFuncTokenizer::GetIndex(), CIccFuncTokenizer::GetLast(), CIccFuncTokenizer::GetName(), and CIccFuncTokenizer::GetNext().

Here is the call graph for this function:

ValidateMacroCalls()

bool CIccMpeXmlCalculator::ValidateMacroCalls ( std::string & parseStr ) const

protected

Definition at line 2642 of file IccMpeXml.cpp.

{
  MacroMap::const_iterator m;
 
  for (m = m_macroMap.begin(); m != m_macroMap.end(); m++) {
    if (!ValidMacroCalls(m->second.c_str(), "*", parseStr)) {
      return false;
    }
  }
  return true;
}

ValidMacroCalls()

bool CIccMpeXmlCalculator::ValidMacroCalls ( const char * szMacroText, std::string macroStack, std::string & parseStr ) const

protected

Definition at line 2615 of file IccMpeXml.cpp.

{
  const char *ptr;
  for (ptr = strstr(szMacroText, "call{"); ptr; ptr = strstr(ptr, "call{")) {
    CIccFuncTokenizer parse(ptr, true);
    parse.GetNext();
 
    std::string name = parse.GetReference();
    MacroMap::const_iterator m = m_macroMap.find(name);
    if (m == m_macroMap.end()) {
      parseStr += "Call to undefined macro '" + name + "'\n";
      return false;
    }
    std::string sm = "*";
    sm += name + "*";
    if (strstr(macroStack.c_str(), sm.c_str())) {
      parseStr += "Macro recursion detected in call to '" + name + "'\n";
      return false;
    }
    if (!ValidMacroCalls(m->second.c_str(), macroStack + name + "*", parseStr)) {
      return false;
    }
    ptr++;
  }
  return true;
}

References CIccFuncTokenizer::GetNext(), and CIccFuncTokenizer::GetReference().

Here is the call graph for this function:

validName()

bool CIccMpeXmlCalculator::validName ( const char * saName )

staticprotected

Definition at line 2321 of file IccMpeXml.cpp.

{
  const char *ptr;
  if (!szName || !*szName) {
    return false;
  }
 
  for (ptr = szName; *ptr; ptr++) {
    if (!validNameChar(*ptr, ptr == szName))
      return false;
  }
 
  return true;
}

References szName.

validNameChar()

bool CIccMpeXmlCalculator::validNameChar ( char c, bool bFirst )

staticprotected

Definition at line 2311 of file IccMpeXml.cpp.

{
  if (bFirst && !((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c == '_')))
    return false;
  else if (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || (c == '_')))
    return false;
 
  return true;
}

Member Data Documentation

m_declVarMap

TempDeclVarMap CIccMpeXmlCalculator::m_declVarMap

protected

Definition at line 331 of file IccMpeXml.h.

m_inputMap

ChanVarMap CIccMpeXmlCalculator::m_inputMap

protected

Definition at line 326 of file IccMpeXml.h.

m_macroLocalMap

TempDeclVarMap CIccMpeXmlCalculator::m_macroLocalMap

protected

Definition at line 340 of file IccMpeXml.h.

m_macroMap

MacroMap CIccMpeXmlCalculator::m_macroMap

protected

Definition at line 339 of file IccMpeXml.h.

m_mpeList

MpePtrList CIccMpeXmlCalculator::m_mpeList

protected

Definition at line 337 of file IccMpeXml.h.

m_mpeMap

MpePtrMap CIccMpeXmlCalculator::m_mpeMap

protected

Definition at line 335 of file IccMpeXml.h.

m_nNextMpe

int CIccMpeXmlCalculator::m_nNextMpe

protected

Definition at line 336 of file IccMpeXml.h.

m_nNextVar

int CIccMpeXmlCalculator::m_nNextVar

protected

Definition at line 332 of file IccMpeXml.h.

m_outputMap

ChanVarMap CIccMpeXmlCalculator::m_outputMap

protected

Definition at line 327 of file IccMpeXml.h.

m_sImport

std::string CIccMpeXmlCalculator::m_sImport

protected

Definition at line 329 of file IccMpeXml.h.

Referenced by CIccMpeXmlCalculator(), and ParseImport().

m_varMap

TempVarMap CIccMpeXmlCalculator::m_varMap

protected

Definition at line 333 of file IccMpeXml.h.

---

The documentation for this class was generated from the following files:

• IccXML/IccLibXML/IccMpeXml.h
• IccXML/IccLibXML/IccMpeXml.cpp