/*! Updates the Animation.
*/
void Animation::update(Time timeStamp)
{
#ifdef DEBUG_UPDATE_VERBOSE
std::cout << "Processing Animation " << m_name
<< " at time " << timeStamp << std::endl;
#endif
if(m_elapsedTime == -1)
{
m_elapsedTime = 0;
m_startTime = timeStamp;
}
// TODO: add possibility to slow down update ratio!
ActionStoreIter actionIter(m_actions.begin());
ActionStoreIter end (m_actions.end());
for(;actionIter!=end;++actionIter)
{
Action *action = *actionIter;
if(m_curFrame >= action->getStartFrame() &&
m_curFrame <= action->getStartFrame() + action->getNumFrames())
{
#ifdef DEBUG_UPDATE
std::cout << " Updating Action " << m_name
<< " at time " << timeStamp << std::endl;
#endif
action->update(m_curFrame,
action->getNumFrames(),
m_fps,
action->getUserdata());
}
}
if(m_curFrame == m_numFrames)
{
m_isActive = false;
m_elapsedTime = -1;
m_startTime = -1;
m_curFrame = 0;
#ifdef DEBUG_UPDATE
std::cout << "Finished Animation " << m_name
<< " at time " << timeStamp << std::endl;
#endif
}
else
{
m_curFrame++;
m_elapsedTime = timeStamp - m_startTime;
}
}
void dParserCompiler::GenerateParserCode (
const dString& className,
const dString& scannerClassName,
const char* const outputFileName,
const dTree<dTokenInfo, dCRCTYPE>& symbolList,
dTree<dState*, dCRCTYPE>& stateList,
const dString& userCode,
const dString& endUserCode,
int lastTerminalTokenEnum)
{
dString templateHeader ("");
LoadTemplateFile("dParserTemplate _cpp.txt", templateHeader);
int position = templateHeader.Find ("$(userCode)");
templateHeader.Replace(position, 11, userCode);
ReplaceAllMacros (templateHeader, className, "$(className)");
ReplaceAllMacros (templateHeader, scannerClassName, "$(scannerClass)");
char text[256];
sprintf (text, "%d", lastTerminalTokenEnum);
ReplaceMacro (templateHeader, text, "&(lastTerminalToken)");
dTree<dState*, dCRCTYPE> sortedStates;
dTree<dState*, dCRCTYPE>::Iterator stateIter (stateList);
for (stateIter.Begin(); stateIter; stateIter ++) {
dState* const state = stateIter.GetNode()->GetInfo();
sortedStates.Insert(state, state->m_number);
}
dTree<int, dString> actionFilter;
dString emptySematicAction ("");
dString stateActionsStart ("");
dString stateActionsCount ("");
dString nextActionsStateList ("");
dString sematicActions ("");
int entriesCount = 0;
int newLineCount = 0;
int starAndCountIndex = 0;
dTree<dState*, dCRCTYPE>::Iterator sortStateIter (sortedStates);
const char* const caseTabs0 = "\t\t\t\t\t\t";
//const char* const caseTabs1 = "\t\t\t\t\t\t\t";
for (sortStateIter.Begin(); sortStateIter; sortStateIter ++) {
dState* const state = sortStateIter.GetNode()->GetInfo();
int count = 0;
dTree<dActionEntry, int> actionSort;
dTree<dAction, dCRCTYPE>::Iterator actionIter (state->m_actions);
for (actionIter.Begin(); actionIter; actionIter++) {
count ++;
dAction& action = actionIter.GetNode()->GetInfo();
if (action.m_type == dSHIFT) {
dCRCTYPE actionSymbol = actionIter.GetKey();
dAssert (symbolList.Find(actionSymbol));
dActionEntry entry;
entry.m_stateType = char (action.m_type);
entry.m_errorRule = state->m_hasErroItem ? 1 : 0;
entry.m_ruleIndex = 0;
entry.m_ruleSymbols = 0;
entry.m_nextState = short (action.m_nextState);
entry.m_token = short (symbolList.Find(actionSymbol)->GetInfo().m_tokenId);
actionSort.Insert (entry, entry.m_token);
} else if (action.m_type == dREDUCE) {
dCRCTYPE actionSymbol = actionIter.GetKey();
dAssert (symbolList.Find(actionSymbol));
dRuleInfo& reduceRule = action.m_reduceRuleNode->GetInfo();
dAssert (symbolList.Find(reduceRule.m_nameCRC));
dAssert (symbolList.Find(reduceRule.m_nameCRC)->GetInfo().m_tokenId >= 256);
dActionEntry entry;
entry.m_stateType = char (action.m_type);
entry.m_errorRule = 0; //state->m_hasErroItem ? 1 : 0;
entry.m_ruleIndex = short (reduceRule.m_ruleNumber);
entry.m_ruleSymbols = short (reduceRule.GetCount());
entry.m_nextState = short (symbolList.Find(reduceRule.m_nameCRC)->GetInfo().m_tokenId - lastTerminalTokenEnum);
entry.m_token = short (symbolList.Find(actionSymbol)->GetInfo().m_tokenId);
actionSort.Insert (entry, entry.m_token);
if (!reduceRule.m_ruleReduced && (reduceRule.m_semanticActionCode != emptySematicAction)) {
// issue a sematic action code;
reduceRule.m_ruleReduced = true;
char text[128];
dString userSematicAction (reduceRule.m_semanticActionCode);
int symbolsCount = int (entry.m_ruleSymbols);
for (int i = 0; i < symbolsCount; i ++) {
sprintf (text, "%d", symbolsCount - i);
dString macro ("$");
macro += text;
sprintf (text, "%d", symbolsCount - i - 1);
dString macroVariable ("parameter[");
macroVariable += text;
macroVariable += "].m_value";
ReplaceAllMacros (userSematicAction, macroVariable, macro);
}
ReplaceAllMacros (userSematicAction, "entry.m_value", "$$");
sprintf (text, "%d:", reduceRule.m_ruleNumber);
sematicActions += caseTabs0;
sematicActions += "case ";
sematicActions += text;
//sematicActions += "// rule ";
sematicActions += "// ";
sematicActions += reduceRule.m_name;
sematicActions += " : ";
for (dRuleInfo::dListNode* node = reduceRule.GetFirst(); node; node = node->GetNext()) {
sematicActions+= node->GetInfo().m_name;
sematicActions += " ";
}
sematicActions += "\n";
sematicActions += userSematicAction;
sematicActions += "\nbreak;\n\n";
}
} else {
dAssert (action.m_type == dACCEPT);
dActionEntry entry;
entry.m_stateType = char (action.m_type);
entry.m_errorRule = 0; //state->m_hasErroItem ? 1 : 0;
entry.m_ruleIndex = 0;
entry.m_ruleSymbols = 0;
entry.m_nextState = 0;
entry.m_token = DACCEPTING_TOKEN;
actionSort.Insert (entry, entry.m_token);
}
}
int actionIndex = entriesCount;
dString stateActions ("");
dTree<dActionEntry, int>::Iterator iter (actionSort);
for (iter.Begin(); iter; iter ++) {
const dActionEntry& entry = iter.GetNode()->GetInfo();
sprintf (text, "%d, %d, %d, %d, %d, %d, ", entry.m_token, entry.m_errorRule, entry.m_stateType, entry.m_nextState, entry.m_ruleSymbols, entry.m_ruleIndex);
stateActions += text;
entriesCount ++;
}
dTree<int, dString>::dTreeNode* const stateActionNode = actionFilter.Find(stateActions);
if (stateActionNode) {
entriesCount = actionIndex;
actionIndex = stateActionNode->GetInfo();
} else {
actionFilter.Insert(actionIndex, stateActions);
for (iter.Begin(); iter; iter ++) {
if (newLineCount % 4 == 0) {
nextActionsStateList += "\n\t\t\t";
}
newLineCount ++;
const dActionEntry& entry = iter.GetNode()->GetInfo();
sprintf (text, "dActionEntry (%d, %d, %d, %d, %d, %d), ", entry.m_token, entry.m_errorRule, entry.m_stateType, entry.m_nextState, entry.m_ruleSymbols, entry.m_ruleIndex);
nextActionsStateList += text;
}
}
if ((starAndCountIndex % 24) == 0) {
stateActionsStart += "\n\t\t\t";
stateActionsCount += "\n\t\t\t";
}
starAndCountIndex ++;
sprintf (text, "%d, ", actionIndex);
stateActionsStart += text;
sprintf (text, "%d, ", count);
stateActionsCount += text;
}
nextActionsStateList.Replace(nextActionsStateList.Size()-2, 2, "");
stateActionsCount.Replace(stateActionsCount.Size()-2, 2, "");
stateActionsStart.Replace(stateActionsStart.Size()-2, 2, "");
ReplaceMacro (templateHeader, stateActionsCount, "$(actionsCount)");
ReplaceMacro (templateHeader, stateActionsStart, "$(actionsStart)");
ReplaceMacro (templateHeader, nextActionsStateList, "$(actionTable)");
ReplaceMacro (templateHeader, sematicActions, "$(semanticActionsCode)");
dString stateGotoStart ("");
dString stateGotoCount ("");
dString nextGotoStateList ("");
entriesCount = 0;
int newLine = 0;
int gotoStateCount = 0;
for (sortStateIter.Begin(); sortStateIter; sortStateIter ++) {
char text[256];
dState* const state = sortStateIter.GetNode()->GetInfo();
int currentEntryuCount = entriesCount;
int count = 0;
dTree<dState*, dCRCTYPE>::Iterator gotoIter (state->m_goto);
dTree<dTree<dState*, dCRCTYPE>::dTreeNode*, int> sortGotoActions;
for (gotoIter.Begin(); gotoIter; gotoIter++) {
int id = symbolList.Find(gotoIter.GetKey())->GetInfo().m_tokenId;
sortGotoActions.Insert(gotoIter.GetNode(), id);
}
dTree<dTree<dState*, dCRCTYPE>::dTreeNode*, int>::Iterator iter1 (sortGotoActions);
for (iter1.Begin(); iter1; iter1++) {
count ++;
if ((newLine % 5) == 0) {
nextGotoStateList += "\n\t\t\t";
}
newLine ++;
dTree<dState*, dCRCTYPE>::dTreeNode* const node = iter1.GetNode()->GetInfo();
dState* const targetState = node->GetInfo();
dGotoEntry entry;
entry.m_nextState = short (targetState->m_number);
entry.m_token = short(iter1.GetKey());
sprintf (text, "dGotoEntry (%d, %d), ", entry.m_token, entry.m_nextState);
nextGotoStateList += text;
entriesCount ++;
}
if ((gotoStateCount % 24) == 0) {
stateGotoStart += "\n\t\t\t";
stateGotoCount += "\n\t\t\t";
}
gotoStateCount ++;
sprintf (text, "%d, ", currentEntryuCount);
stateGotoStart += text;
sprintf (text, "%d, ", count);
stateGotoCount += text;
}
nextGotoStateList.Replace(nextGotoStateList.Size()-2, 2, "");
stateGotoCount.Replace(stateGotoCount.Size()-2, 2, "");
stateGotoStart.Replace(stateGotoStart.Size()-2, 2, "");
ReplaceMacro (templateHeader, stateGotoCount, "$(gotoCount)");
ReplaceMacro (templateHeader, stateGotoStart, "$(gotoStart)");
ReplaceMacro (templateHeader, nextGotoStateList, "$(gotoTable)");
templateHeader += endUserCode;
SaveFile(outputFileName, ".cpp", templateHeader);
}
