BOOL Parse4CVMKADForChannels( //return false if file could not be parsed
const TCHAR* pszTrgTypeName, //4cwin, 4cosai, ...
const TCHAR* pszAutoDeclIni, //full path and file name of AutoDecl.ini
IO_COMP_TYP** ppIOCmps //return, maqy be NULL if no channel def found
)
{
TCHAR szBuffer[2*MAX_PATH];
IXMLDOMNode* pNode;
IXMLDOMNode* pNode2;
IXMLDOMNodeList*pNList;
IXMLDOMNodeList*pNList2;
*ppIOCmps = NULL;
strcpy(szBuffer, pszAutoDeclIni);
FC_StringCutFilePart(szBuffer);
_tcscat(szBuffer, _T("\\"));
_tcscat(szBuffer, pszTrgTypeName);
_tcscat(szBuffer, _T("_4cvm.kad"));
pNode = XMLLoadFile(szBuffer);
if(!pNode)
return FALSE;
pNode2 = NULL;
pNode->get_firstChild(&pNode2); //assume first child is <TRGTYP EXT="4cwin" USECHANNELNUM="0">
FC_RELEASE_PTR(pNode)
if(!pNode2)
return FALSE;
pNList = NULL;
pNode2->selectNodes(L"IOCOMPONENTS", &pNList);
FC_RELEASE_PTR(pNode2)
if(!pNList)
return FALSE;
long len = 0;
pNList->get_length(&len);
ATLASSERT(len<=1);
if(len>0)
{
pNList->get_item(0, &pNode);
// <CHANNEL>
pNList2 = NULL;
pNode->selectNodes(L"CHANNEL", &pNList2);
*ppIOCmps = ReadIOComponents(pNList2);
FC_RELEASE_PTR(pNList2);
FC_RELEASE_PTR(pNode);
}
FC_RELEASE_PTR(pNList);
return TRUE;
}
/*
Function name : CXML::GetNodesList
Description : retrieves the list of nodes with the given name
Return type : bool
Argument : CString csPathToNode
Argument : bool bCurrentNodeAsBase
*/
bool CXML::GetNodesList(CString csPathToNode,bool bCurrentNodeAsBase)
{
CString csPath;
IXMLDOMNode *pBaseNode = NULL;
if(bCurrentNodeAsBase)
{
if(!m_pICurrentNode) return false;
pBaseNode = m_pICurrentNode;
pBaseNode->AddRef();
csPath.Format("./%s",csPathToNode);
}
else
{
if(!m_pIRootNode) return false;
pBaseNode = m_pIRootNode;
pBaseNode->AddRef();
csPath.Format("/%s",csPathToNode);
}
_bstr_t bstrPath(csPath);
if(m_pNodeList)
{
m_pNodeList->Release();
m_pNodeList = NULL;
}
m_hr = pBaseNode->selectNodes(bstrPath,&m_pNodeList);
pBaseNode->Release();
if(!SUCCEEDED(m_hr) || !m_pNodeList)
return false;
return true;
}
bool CModelToolCharDataTable::LoadProperty(const char * lpszFullPathFileName)
{
CNtlXMLDoc doc;
if(doc.Create() == false)
{
_ASSERT(0);
return false;
}
if(doc.Load( const_cast<char *>(lpszFullPathFileName) ) == false)
{
_ASSERT(0);
return false;
}
char szBuffer[1024];
if( !doc.GetDataWithXPath(const_cast<char *>(XML_PROP_NAME_ATTRIBUTE), szBuffer, sizeof(szBuffer)) )
{
_ASSERT(0);
return false;
}
sMODELTOOL_CHAR_TBLDAT *pModelToolCharData = new sMODELTOOL_CHAR_TBLDAT;
Add(szBuffer, pModelToolCharData);
IXMLDOMNodeList *pAnimDataList = doc.SelectNodeList(XML_PROP_ANIM_DATA_ELEMENT);
IXMLDOMNode* pAnimDataNode = NULL;
IXMLDOMNodeList *pAnimEventList = NULL;
IXMLDOMNode* pAnimEventNode = NULL;
long lAnimDataNodeNum = 0;
long lAnimEventNodeNum = 0;
int nAnimKeyID = 0;
float fDurationTime = 0.f;
BYTE byPushCount = 0;
BYTE byKnockDownCount = 0;
bool bKB2Push = false;
BYTE byHitCount = 0;
float aHitTime[NTL_MAX_SIZE_HIT];
pAnimDataList->get_length(&lAnimDataNodeNum);
for(long m = 0; m < lAnimDataNodeNum ; ++m)
{
pAnimDataList->get_item(m,&pAnimDataNode);
if(!doc.GetTextWithAttributeName(pAnimDataNode, XML_PROP_ANIM_DATA_ELEMENT_KEYID_ATTRIBUTE, szBuffer, sizeof(szBuffer)))
{
_ASSERT(0);
return false;
}
nAnimKeyID = atoi(szBuffer);
if(!doc.GetTextWithAttributeName(pAnimDataNode, XML_PROP_ANIM_DATA_ELEMENT_PLAYTIME_ATTRIBUTE, szBuffer, sizeof(szBuffer)))
{
_ASSERT(0);
return false;
}
fDurationTime = (float)atof(szBuffer);
pAnimDataNode->selectNodes(L"ANIM_EVENT", &pAnimEventList);
pAnimEventList->get_length(&lAnimEventNodeNum);
memset(aHitTime, 0, sizeof(aHitTime));
for(long n = 0; n < lAnimEventNodeNum; ++n)
{
pAnimEventList->get_item(n, &pAnimEventNode);
if(!doc.GetTextWithAttributeName(pAnimEventNode, XML_PROP_ANIM_DATA_ELEMENT_EVENTID_ATTRIBUTE, szBuffer, sizeof(szBuffer)))
{
_ASSERT(0);
return false;
}
int nAnimEventID = EVENT_ANIM_NONE;
int nBehavior = TARGET_BEHAVIOR_NONE;
nAnimEventID = atoi(szBuffer);
if(nAnimEventID == EVENT_ANIM_HIT)
{
if(!doc.GetTextWithAttributeName(pAnimEventNode, XML_PROP_ANIM_DATA_ELEMENT_HITBEHAVIOR_ATTRIBUTE, szBuffer, sizeof(szBuffer)))
{
_ASSERT(0);
return false;
}
nBehavior = atoi(szBuffer);
if(nBehavior == TARGET_BEHAVIOR_PUSH)
{
byPushCount++;
}
else if(nBehavior == TARGET_BEHAVIOR_KNOCK_DOWN)
{
byKnockDownCount++;
if( byKnockDownCount > 1 )
{
_ASSERT(0);
return false;
}
}
// Hit time
if(!doc.GetTextWithAttributeName(pAnimEventNode, XML_PROP_ANIM_DATA_ELEMENT_HITTIME_ATTRIBUTE, szBuffer, sizeof(szBuffer)))
{
_ASSERT(0);
return false;
}
aHitTime[byHitCount] = (float)atof(szBuffer);
byHitCount++;
if(byHitCount > NTL_MAX_SIZE_HIT)
_ASSERT(0);
// KB2PUSH
if(!doc.GetTextWithAttributeName(pAnimEventNode, XML_PROP_ANIM_DATA_ELEMENT_HITKB2PUSH_ATTRIBUTE, szBuffer, sizeof(szBuffer)))
{
_ASSERT(0);
return false;
}
if(atoi(szBuffer) == 0)
{
bKB2Push = false;
}
else
{
bKB2Push = true;
}
}
else if(nAnimEventID == EVENT_ANIM_SKILL_CANCEL)
{
// time
if(!doc.GetTextWithAttributeName(pAnimEventNode, XML_PROP_ANIM_DATA_ELEMENT_HITTIME_ATTRIBUTE, szBuffer, sizeof(szBuffer)))
{
_ASSERT(0);
return false;
}
pModelToolCharData->AddSkillCancelTime(nAnimKeyID, (float)atof(szBuffer));
}
if(pAnimEventNode)
{
pAnimEventNode->Release();
pAnimEventNode = NULL;
}
}
if( nAnimKeyID != -1 )
pModelToolCharData->Add(nAnimKeyID, fDurationTime, byPushCount, byKnockDownCount, byHitCount, aHitTime, bKB2Push);
nAnimKeyID = 0;
fDurationTime = 0;
byPushCount = 0;
byKnockDownCount = 0;
byHitCount = 0;
if(pAnimEventList)
{
pAnimEventList->Release();
pAnimEventList = NULL;
}
if(pAnimDataNode)
{
pAnimDataNode->Release();
pAnimDataNode = NULL;
}
}
//pModelToolCharData->GetChainAttack(PC_CLASS_HUMAN_FIGHTER, ITEM_TYPE_UNKNOWN, 6);
if(pAnimDataList)
{
pAnimDataList->Release();
pAnimDataList = NULL;
}
char *pTokenStart = NULL;
char *pTokenEnd = NULL;
char szToken[64];
if( !doc.GetDataWithXPath("MODEL_SCRIPT/HEADER/ANIM_BBOX", szBuffer, sizeof(szBuffer)) )
{
_ASSERT(0);
return false;
}
CNtlVector vTemp;
pTokenStart = szBuffer;
pTokenEnd = strstr( szBuffer, ";");
strncpy_s(szToken, sizeof(szToken), pTokenStart, pTokenEnd - pTokenStart);
vTemp.x = (float) atof(szToken);
pTokenStart = pTokenEnd + 1;
pTokenEnd = strstr( pTokenStart, ";");
strncpy_s(szToken, sizeof(szToken), pTokenStart, pTokenEnd - pTokenStart);
vTemp.y = (float) atof(szToken);
pTokenStart = pTokenEnd + 1;
strncpy_s(szToken, sizeof(szToken), pTokenStart, strlen(szBuffer));
vTemp.z = (float) atof(szToken);
pModelToolCharData->m_vMin.x = -(vTemp.x / 2.0f);
pModelToolCharData->m_vMin.y = 0.0f;
pModelToolCharData->m_vMin.z = -(vTemp.z / 2.0f);
pModelToolCharData->m_vMax.x = vTemp.x / 2.0f;
pModelToolCharData->m_vMax.y = vTemp.y;
pModelToolCharData->m_vMax.z = vTemp.z / 2.0f;
if( !doc.GetDataWithXPath("MODEL_SCRIPT/BONE_DATA/BASE_SCALE", szBuffer, sizeof(szBuffer)) )
{
_ASSERT(0);
return false;
}
pModelToolCharData->m_fScale = (float) atof(szBuffer);
return true;
}
// эта функция, если значения нет (или тип некорректный) *value НЕ трогает
bool SettingsXML::Load(const wchar_t *regName, wchar_t **value)
{
bool lbRc = false;
HRESULT hr = S_OK;
IXMLDOMNode* pChild = NULL;
IXMLDOMNamedNodeMap* pAttrs = NULL;
IXMLDOMAttribute *pIXMLDOMAttribute = NULL;
IXMLDOMNode *pNode = NULL;
IXMLDOMNodeList* pList = NULL;
BSTR bsType = NULL;
BSTR bsData = NULL;
size_t nLen = 0;
//if (*value) {free(*value); *value = NULL;}
if (mp_Key)
pChild = FindItem(mp_Key, L"value", regName, false);
if (!pChild)
return false;
hr = pChild->get_attributes(&pAttrs);
if (SUCCEEDED(hr) && pAttrs)
{
bsType = GetAttr(pChild, pAttrs, L"type");
}
if (SUCCEEDED(hr) && bsType)
{
if (!lstrcmpi(bsType, L"multi"))
{
// Тут значения хранятся так:
//<value name="CmdLineHistory" type="multi">
// <line data="C:\Far\Far.exe"/>
// <line data="cmd"/>
//</value>
wchar_t *pszData = NULL, *pszCur = NULL;
size_t nMaxLen = 0, nCurLen = 0;
long nCount = 0;
if (pAttrs) { pAttrs->Release(); pAttrs = NULL; }
// Получить все дочерние элементы нужного типа
bsData = ::SysAllocString(L"line");
hr = pChild->selectNodes(bsData, &pList);
::SysFreeString(bsData); bsData = NULL;
if (SUCCEEDED(hr) && pList)
{
hr = pList->get_length(&nCount);
if (SUCCEEDED(hr) && (nCount > 0))
{
HEAPVAL;
nMaxLen = ((MAX_PATH+1) * nCount) + 1;
pszData = (wchar_t*)malloc(nMaxLen * sizeof(wchar_t));
pszCur = pszData;
pszCur[0] = 0; pszCur[1] = 0;
nCurLen = 2; // сразу посчитать DoubleZero
HEAPVAL;
}
}
if (SUCCEEDED(hr) && pList)
{
hr = pList->reset();
while ((hr = pList->nextNode(&pNode)) == S_OK && pNode)
{
bsData = GetAttr(pNode, L"data");
pNode->Release(); pNode = NULL;
if (SUCCEEDED(hr) && bsData)
{
nLen = _tcslen(bsData) + 1;
if ((nCurLen + nLen) > nMaxLen)
{
// Нужно пересоздать!
nMaxLen = nCurLen + nLen + MAX_PATH + 1;
wchar_t *psz = (wchar_t*)malloc(nMaxLen * sizeof(wchar_t));
_ASSERTE(psz);
if (!psz) break; // Не удалось выделить память!
wmemmove(psz, pszData, nCurLen);
pszCur = psz + (pszCur - pszData);
HEAPVAL;
free(pszData);
pszData = psz;
HEAPVAL;
}
lstrcpy(pszCur, bsData);
pszCur += nLen; // указатель - на место для следующей строки
nCurLen += nLen;
*pszCur = 0; // ASCIIZZ
HEAPVAL;
::SysFreeString(bsData); bsData = NULL;
}
}
pList->Release(); pList = NULL;
}
// значит что-то прочитать удалось
if (pszData)
{
if (*value) {free(*value); *value = NULL;}
*value = pszData;
lbRc = true;
}
}
else if (!lstrcmpi(bsType, L"string"))
{
bsData = GetAttr(pChild, pAttrs, L"data");
if (SUCCEEDED(hr) && bsData)
{
nLen = _tcslen(bsData);
if (!*value || (_tcslen(*value) <= nLen))
{
*value = (wchar_t*)realloc(*value, (nLen+2)*sizeof(wchar_t));
}
if (*value)
{
lstrcpy(*value, bsData);
(*value)[nLen] = 0; // уже должен быть после lstrcpy
(*value)[nLen+1] = 0; // ASCIIZZ
lbRc = true;
}
}
}
// Все остальные типы - не интересуют. Нам нужны только строки
}
if (bsType) { ::SysFreeString(bsType); bsType = NULL; }
if (bsData) { ::SysFreeString(bsData); bsData = NULL; }
if (pChild) { pChild->Release(); pChild = NULL; }
if (pAttrs) { pAttrs->Release(); pAttrs = NULL; }
//if (!lbRc)
//{
// _ASSERTE(*value == NULL);
// *value = (wchar_t*)malloc(sizeof(wchar_t)*2);
// (*value)[0] = 0; (*value)[1] = 0; // На случай REG_MULTI_SZ
//}
return lbRc;
}
/**
* GetVersionDependentKADFileName. Gets the version dependent compiler KAD.
* It uses the command line, if there is a target file it's firmware version
* is read and then using the <target type>_Addon.kad the final name of the kad is
* searched. If no target or no speciffic kad is specified in <target type>_Addon.kad
* the default kad <<target type>_4cvm.kad is assumed.
* @param pdm IN diag message sink
* @param pOpt IN the command line arguments
* @param kadFile OUT receives the kad file name and full path
* @param ulTrgVer OUT receive firmware version
* @return void
*/
static void GetVersionDependentKADFileName(
CGT_CDiagMsg* pdm,
const CMDL_OPT_TYP* pOpt,
FC_CString& kadFile,
unsigned long& ulTrgVer
)
{
FC_CString addonKad(MAX_PATH);
FC_CString prjPath(MAX_PATH);
FC_CString binPath(MAX_PATH);
IXMLDOMNode* pNode;
IXMLDOMNodeList*pNList;
long len;
FC_CString jot;
long i;
ulTrgVer = 0;
kadFile.clear();
binPath.load(g_szModuleName).stripFilePart();
prjPath.load(pOpt->sz4CP).stripFilePart();
//if there is a target file or check file given in the command line get the target version
if(!pOpt->szCheckFile.isEmpty())
{
//TODO: Workaround: passing an optional target version number via the command line
//is not possible because we may have very old backends, we pass this info
//inside a file with fixed name, old backend simple don't read it.
//If we make a new major version all backends should add this to there cmd line
//and then we don't need this tmp file any more...
FC_CString sCheckInfo(MAX_PATH);
sCheckInfo.load(prjPath)<<_T("\\gen\\checkinf.tmp");
ulTrgVer = GetPrivateProfileInt(_T("target"), _T("version"), 0, sCheckInfo);
}
else if(pOpt->targets.getUsed()>0)
{
ulTrgVer = GetTargetVersion(pdm, prjPath, pOpt->targets.get(0));
//Note: if more than one target is specified CGlobCtx::loadTargets() will
//later treat this as an "error not supported multiple targets".
//This solution here is only possible if at max one target at a time is built!
}
if(ulTrgVer>0)
{
//Addon KAD = "<installdir>\bin\<trgtyp>_Addon.kad"
addonKad<<binPath<<'\\'<<pOpt->szCurTrgTyp<<_T("_Addon.kad");
if(FC_Exist(addonKad))
{
//open xml file:
pNode = CGT_XMLLoadFile(pdm, NULL, addonKad, NULL);
if(pNode)
{
// read targets
pNList = NULL; len = 0;
pNode->selectNodes(L"FIRMWARE", &pNList);
FC_RELEASE_PTR(pNode);
pNList->get_length(&len);
for(i=0;i<len;i++)
{
pNList->get_item(i, &pNode);
if(CGT_XMLGetStrAttrTrim(pdm, pNode, L"VERSION", &jot, false, false))
{
if(strtoul(jot, NULL, 10)==ulTrgVer)
{
CGT_XMLGetStrAttrTrim(pdm, pNode, L"COMPILERKAD", &kadFile, false, true);
FC_RELEASE_PTR(pNode);
break;
}
}
FC_RELEASE_PTR(pNode);
}
}
}//<targettyp>_addon.kad does not exist, this is for backward compatibillity (4cec!)
}//else: maybe check file or build lib, we have no version info!! use default KAD
if(kadFile.isEmpty())
{//Not found in AddonKAD with version:
//default compiler kad = "<installdir>\bin\<trgtyp>_4cvm.kad"
kadFile<<binPath<<'\\'<<pOpt->szCurTrgTyp<<_T("_4cvm.kad");
}
else
{//Found in AddonKAD with version:
//make an absolute path:
kadFile.prepend(binPath, "\\");
}
}
HRESULT CKADmerge::GetKADFilenames(string * sFilenames[], LONG &lLength, string sLogFile)
{
HRESULT hRes = S_FALSE;
if(sLogFile != "")
{
// open log file
OpenLog(sLogFile, sDescription + " GetKADFileNames");
}
IXMLDOMNode * pXMLRoot = NULL;
hRes = GetRootElement(m_pXMLKad, &pXMLRoot);
if(hRes == S_OK)
{
// find elements
IXMLDOMNodeList * pElemList = NULL;
_bstr_t bPatternString("/KAD4CE/KERNEL/ADDON[@KADFILE]");
hRes = pXMLRoot->selectNodes(bPatternString, &pElemList);
if(SUCCEEDED(hRes))
{
LONG lElements = 0;
pElemList->get_length(&lElements);
(*sFilenames) = new string[lElements];
IXMLDOMNode * pCurrentElem = NULL;
hRes = pElemList->nextNode(&pCurrentElem);
int i = 0;
while(pCurrentElem != NULL)
{
// find 'KADFILE' attribute
IXMLDOMNodeList * pAttrList = NULL;
_bstr_t bPatternString("@KADFILE");
hRes = pCurrentElem->selectNodes(bPatternString, &pAttrList);
if(SUCCEEDED(hRes))
{
LONG lAtributes = 0;
pAttrList->get_length(&lAtributes);
IXMLDOMNode * pCurrentAttr = NULL;
hRes = pAttrList->nextNode(&pCurrentAttr);
if(lAtributes == 1)
{
(*sFilenames)[i++] = GetValue(pCurrentAttr);
}
if(pCurrentAttr)
pCurrentAttr->Release();
}
hRes = pElemList->nextNode(&pCurrentElem);
if(pAttrList)
pAttrList->Release();
}
lLength = i;
hRes = S_OK;
if(pCurrentElem)
pCurrentElem->Release();
}
if(pXMLRoot)
pXMLRoot->Release();
if(pElemList)
pElemList->Release();
}
if(hRes == S_OK)
{
Log("GetKADFilenames:");
for(int i = 0; i < (int)lLength; i++)
{
Log((*sFilenames)[i]);
}
}
// close log file
CloseLog();
return hRes;
}
bool CKADInfo::load(
CGT_CDiagMsg* pdm,
const TCHAR* pszKADFileAndPath,
const TCHAR* pszTargetType,
unsigned long ulTrgVer
)
{
long i, o;
long len;
long len2;
long len3;
IXMLDOMNodeList* pNList;
IXMLDOMNodeList* pNList2;
IXMLDOMNodeList* pNList3;
IXMLDOMNode* pNode;
IXMLDOMNode* pNode2;
int nCurrErrors;
FC_CString jot(MAX_PATH);
bool bTargetTypeFound = false;
nCurrErrors = pdm->getTotalErrors();
//clear possible old content:
clear();
m_szKADFile.load(pszKADFileAndPath);
CG_InitSTEdipos(&m_KADEdp, m_szKADFile, 1);
pNode = CGT_XMLLoadFile(pdm, NULL, m_szKADFile, L"KAD4VM");
if(!pNode)
return false;
// read targets
pNList = NULL;
len = 0;
pNode->selectNodes(L"TRGTYP", &pNList);
assert(pNList);
FC_RELEASE_PTR(pNode);
pNList->get_length(&len);
for(i=0;i<len;i++)
{
pNList->get_item(i, &pNode);
if ( ! isCurrentTrgType(pdm, pszTargetType, pNode))
continue;
bTargetTypeFound = true;
// <IEC_FEATURES> : read IEC features : dadta types , languages
pNList2 = NULL;
pNode->selectNodes(L"IEC_FEATURES", &pNList2);
assert(pNList2);
ReadIecFeatures(pdm,
m_szKADFile,
pNList2,
&m_AllowedIEClanguages,
&m_AllowedIECtypes,
&m_AllowedArrayIndexIECtypes,
&m_lMaxTasks,
&m_bLocalRetain,
&m_CheckAddressSpace
);
FC_RELEASE_PTR(pNList2);
// <TASKIMAGE> : read task image features : segments, size, optimize
pNList2 = NULL;
pNode->selectNodes(L"TASKIMAGE", &pNList2);
assert(pNList2);
ReadTaskImageFeature(pdm,
m_szKADFile,
pNList2,
&m_useTIforSegm,
&m_optimizeTIforSegm,
m_lMaxRegionsWR,
m_lMaxRegionsRD,
ulTrgVer);
FC_RELEASE_PTR(pNList2);
// <IOCOMPONENTS>
pNList2 = NULL;
pNode->selectNodes(L"IOCOMPONENTS", &pNList2);
assert(pNList2);
len2 = 0;
pNList2->get_length(&len2);
for(o=0;o<len2;o++)
{
pNList2->get_item(o, &pNode2);
// <CHANNEL>
pNList3 = NULL;
pNode2->selectNodes(L"CHANNEL", &pNList3);
ReadChannels(pdm, pNList3, &m_channels);
FC_RELEASE_PTR(pNList3);
}
FC_RELEASE_PTR(pNList2);
// <VM_SETTINGS> : read target features
pNList2 = NULL;
pNode->selectNodes(L"VM_SETTINGS", &pNList2);
assert(pNList2);
ReadVmSettings(pdm, pNList2, &m_VmSettings);
FC_RELEASE_PTR(pNList2);
// <CG_OPTIONS> : read target code generator features
pNList2 = NULL;
pNode->selectNodes(L"CG_OPTIONS", &pNList2);
assert(pNList2);
pNList2->get_length(&len3);
if (len3 != 0)
{
// <CG_OPTIONS> is optional
ReadCgOptions(pdm, pNList2, &m_CgOptions);
FC_RELEASE_PTR(pNList2);
}
FC_RELEASE_PTR(pNode);
}
FC_RELEASE_PTR(pNList);
if ( ! bTargetTypeFound)
{
pdm->msg1(CG_E_XML_TARGET_NOT_FOUND_IN_KAD, &m_KADEdp, pszTargetType);
return false;
}
//finally check usage of channels if no error so far:
if(nCurrErrors==pdm->getTotalErrors())
ValidateChannels(pdm, &m_KADEdp, &m_channels, &m_VmSettings);
return nCurrErrors==pdm->getTotalErrors();
}
