int CCLuaEngine::executeNodeEvent(CCNode* pNode, int nAction)
{
int ret = 0;
do
{
int nScriptHandler = pNode->getScriptHandler();
CC_BREAK_IF(0 == nScriptHandler);
cleanStack();
CCLuaValueDict dict;
if (nAction == kCCNodeOnEnter)
{
dict["name"] = CCLuaValue::stringValue("enter");
pushCCLuaValueDict(dict);
ret = executeFunctionByHandler(nScriptHandler, 1);
}
else if (nAction == kCCNodeOnExit)
{
dict["name"] = CCLuaValue::stringValue("exit");
pushCCLuaValueDict(dict);
ret = executeFunctionByHandler(nScriptHandler, 1);
}
} while (0);
return ret;
}
int CCLuaEngine::executeLayerTouchesEvent(CCLayer* pLayer, int eventType, CCSet *pTouches)
{
int ret = 0;
do
{
CCTouchScriptHandlerEntry* pScriptHandlerEntry = pLayer->getScriptTouchHandlerEntry();
CC_BREAK_IF(NULL == pScriptHandlerEntry);
int nScriptHandler = pScriptHandlerEntry->getHandler();
CC_BREAK_IF(0 == nScriptHandler);
cleanStack();
lua_pushinteger(m_state, eventType);
lua_newtable(m_state);
CCDirector* pDirector = CCDirector::sharedDirector();
CCSetIterator it = pTouches->begin();
CCTouch* pTouch;
int n = 1;
while (it != pTouches->end())
{
pTouch = (CCTouch*)*it;
CCPoint pt = pDirector->convertToGL(pTouch->getLocationInView());
lua_pushnumber(m_state, pt.x);
lua_rawseti(m_state, -2, n++);
lua_pushnumber(m_state, pt.y);
lua_rawseti(m_state, -2, n++);
++it;
}
ret = executeFunctionByHandler(nScriptHandler, 2);
} while (0);
return ret;
}
int CCLuaEngine::executeSchedule(CCTimer* pTimer, float dt, CCNode* pNode/* = NULL*/)
{
int ret = 0;
do
{
int nScriptHandler = pTimer->getScriptHandler();
CC_BREAK_IF(0 == nScriptHandler);
cleanStack();
pushFloat(dt);
ret = executeFunctionByHandler(nScriptHandler, 1);
} while (0);
return ret;
}
int CCLuaEngine::executeNotificationEvent(CCNotificationCenter* pNotificationCenter, const char* pszName)
{
int ret = 0;
do
{
int nScriptHandler = pNotificationCenter->getScriptHandler();
CC_BREAK_IF(0 == nScriptHandler);
cleanStack();
pushString(pszName);
ret = executeFunctionByHandler(nScriptHandler, 1);
} while (0);
return ret;
}
int CCLuaEngine::executeMenuItemEvent(CCMenuItem* pMenuItem)
{
int ret = 0;
do
{
int nScriptHandler = pMenuItem->getScriptTapHandler();
CC_BREAK_IF(0 == nScriptHandler);
cleanStack();
pushInt(pMenuItem->getTag());
ret = executeFunctionByHandler(nScriptHandler, 1);
} while (0);
return ret;
}
int CCLuaEngine::executeLayerKeypadEvent(CCLayer* pLayer, int eventType)
{
int ret = 0;
do
{
CCScriptHandlerEntry* pScriptHandlerEntry = pLayer->getScriptKeypadHandlerEntry();
CC_BREAK_IF(NULL == pScriptHandlerEntry);
int nScriptHandler = pScriptHandlerEntry->getHandler();
CC_BREAK_IF(0 == nScriptHandler);
cleanStack();
lua_newtable(m_state);
lua_pushinteger(m_state, eventType);
ret = executeFunctionByHandler(nScriptHandler, 1);
} while (0);
return ret;
}
// functions for excute touch event
int CCLuaEngine::executeLayerTouchEvent(int nScriptHandler, int eventType, CCTouch *pTouch)
{
int ret = 0;
do
{
CC_BREAK_IF(0 == nScriptHandler);
cleanStack();
lua_pushinteger(m_state, eventType);
CCPoint pt = (pTouch != 0) ? CCDirector::sharedDirector()->convertToGL(pTouch->getLocationInView()) : ccp(0,0);
lua_pushnumber(m_state, pt.x);
lua_pushnumber(m_state, pt.y);
ret = executeFunctionByHandler(nScriptHandler, 3);
} while (0);
return ret;
}
// functions for excute touch event
int CCLuaEngine::executeLayerTouchEvent(CCLayer* pLayer, int eventType, CCTouch *pTouch)
{
int ret = 0;
do
{
CCTouchScriptHandlerEntry* pScriptHandlerEntry = pLayer->getScriptTouchHandlerEntry();
CC_BREAK_IF(NULL == pScriptHandlerEntry);
int nScriptHandler = pScriptHandlerEntry->getHandler();
CC_BREAK_IF(0 == nScriptHandler);
cleanStack();
CCPoint pt = CCDirector::sharedDirector()->convertToGL(pTouch->getLocationInView());
lua_pushinteger(m_state, eventType);
lua_pushnumber(m_state, pt.x);
lua_pushnumber(m_state, pt.y);
ret = executeFunctionByHandler(nScriptHandler, 3);
} while (0);
return ret;
}
int CCLuaEngine::executeAccelerometerEvent(CCLayer* pLayer, CCAcceleration* pAccelerationValue)
{
int ret = 0;
do
{
CCScriptHandlerEntry* pScriptHandlerEntry = pLayer->getScriptAccelerateHandlerEntry();
CC_BREAK_IF(NULL == pScriptHandlerEntry);
int nScriptHandler = pScriptHandlerEntry->getHandler();
CC_BREAK_IF(0 == nScriptHandler);
cleanStack();
lua_newtable(m_state);
lua_pushnumber(m_state, pAccelerationValue->x);
lua_pushnumber(m_state, pAccelerationValue->y);
lua_pushnumber(m_state, pAccelerationValue->z);
lua_pushnumber(m_state, pAccelerationValue->timestamp);
ret = executeFunctionByHandler(nScriptHandler, 4);
} while (0);
return ret;
}
int CCLuaEngine::executeCallFuncActionEvent(CCCallFunc* pAction, CCObject* pTarget/* = NULL*/)
{
int ret = 0;
do
{
int nScriptHandler = pAction->getScriptHandler();
CC_BREAK_IF(0 == nScriptHandler);
cleanStack();
if (pTarget != NULL)
{
pushCCObject(pTarget, "CCNode");
}
else
{
pushNil();
}
ret = executeFunctionByHandler(nScriptHandler, 1);
} while (0);
return ret;
}
//print stack. You have to print from the stack. You can not call a print function from dlinklist
void printStack(struct stack *s)
{
// struct data* tDta = NULL;
struct stack *tS = createStack();
while(!isEmptyStack(s))
{
struct data* tDta = top(s);
printData(tDta);
pushStack(tS,createData(tDta->v1,tDta->v2));
popStack(s);
}
while(!isEmptyStack(tS))
{
struct data* tDta = top(tS);
pushStack(s,createData(tDta->v1,tDta->v2));
popStack(tS);
}
cleanStack(tS);
}
TokenBase* calculator::calculate(const TokenQueue_t& rpn, TokenMap scope,
const opMap_t& opMap) {
evaluationData data(rpn, scope, opMap);
// Evaluate the expression in RPN form.
std::stack<TokenBase*> evaluation;
while (!data.rpn.empty()) {
TokenBase* base = data.rpn.front()->clone();
data.rpn.pop();
// Operator:
if (base->type == OP) {
data.op = static_cast<Token<std::string>*>(base)->val;
delete base;
/* * * * * Resolve operands Values and References: * * * * */
if (evaluation.size() < 2) {
cleanStack(evaluation);
throw std::domain_error("Invalid equation.");
}
TokenBase* b_right = evaluation.top(); evaluation.pop();
TokenBase* b_left = evaluation.top(); evaluation.pop();
if (b_right->type == VAR) {
std::string var_name = static_cast<Token<std::string>*>(b_right)->val;
delete b_right;
delete resolve_reference(b_left);
cleanStack(evaluation);
throw std::domain_error("Unable to find the variable '" + var_name + "'.");
} else {
b_right = resolve_reference(b_right, &data.scope);
}
packToken r_left;
packToken m_left;
if (b_left->type & REF) {
RefToken* left = static_cast<RefToken*>(b_left);
r_left = left->key;
m_left = left->source;
b_left = resolve_reference(left, &data.scope);
} else if (b_left->type == VAR) {
r_left = static_cast<Token<std::string>*>(b_left)->val;
}
/* * * * * Resolve Asign Operation * * * * */
if (!data.op.compare("=")) {
delete b_left;
// If the left operand has a variable name:
if (r_left->type == STR) {
if (m_left->type == MAP) {
TokenMap& map = m_left.asMap();
std::string& key = r_left.asString();
map[key] = packToken(b_right->clone());
} else {
TokenMap* map = data.scope.findMap(r_left.asString());
if (!map || *map == TokenMap::default_global()) {
// Assign on the local scope.
// The user should not be able to implicitly overwrite
// variables he did not declare, since it's error prone.
data.scope[r_left.asString()] = packToken(b_right->clone());
} else {
(*map)[r_left.asString()] = packToken(b_right->clone());
}
}
evaluation.push(b_right);
// If the left operand has an index number:
} else if (r_left->type & NUM) {
if (m_left->type == LIST) {
TokenList& list = m_left.asList();
size_t index = r_left.asInt();
list[index] = packToken(b_right->clone());
} else {
delete b_right;
cleanStack(evaluation);
throw std::domain_error("Left operand of assignment is not a list!");
}
evaluation.push(b_right);
} else {
packToken p_right(b_right->clone());
delete b_right;
cleanStack(evaluation);
throw undefined_operation(data.op, r_left, p_right);
}
} else if (b_left->type == FUNC && data.op == "()") {
Function* f_left = static_cast<Function*>(b_left);
if (!data.op.compare("()")) {
// Collect the parameter tuple:
Tuple right;
if (b_right->type == TUPLE) {
right = *static_cast<Tuple*>(b_right);
} else {
right = Tuple(b_right);
}
delete b_right;
packToken _this;
if (m_left->type != NONE) {
_this = m_left;
} else {
_this = data.scope;
}
// Execute the function:
packToken ret;
try {
ret = Function::call(_this, f_left, &right, data.scope);
} catch (...) {
cleanStack(evaluation);
delete f_left;
throw;
}
delete f_left;
evaluation.push(ret->clone());
} else {
packToken p_right(b_right->clone());
packToken p_left(b_left->clone());
delete b_right;
cleanStack(evaluation);
throw undefined_operation(data.op, p_left, p_right);
}
} else {
data.opID = Operation::build_mask(b_left->type, b_right->type);
packToken p_left(b_left);
packToken p_right(b_right);
TokenBase* result = 0;
try {
// Resolve the operation:
result = exec_operation(p_left, p_right, &data, data.op);
if (!result) {
result = exec_operation(p_left, p_right, &data, ANY_OP);
}
} catch (...) {
cleanStack(evaluation);
throw;
}
if (result) {
evaluation.push(result);
} else {
cleanStack(evaluation);
throw undefined_operation(data.op, p_left, p_right);
}
}
} else if (base->type == VAR) { // Variable
packToken* value = NULL;
std::string key = static_cast<Token<std::string>*>(base)->val;
value = data.scope.find(key);
if (value) {
TokenBase* copy = (*value)->clone();
evaluation.push(new RefToken(key, copy));
delete base;
} else {
evaluation.push(base);
}
} else {
evaluation.push(base);
}
}
return evaluation.top();
}
int CCLuaEngine::executeSchedule(int nHandler, float dt, CCNode* pNode/* = NULL*/)
{
cleanStack();
pushFloat(dt);
return executeFunctionByHandler(nHandler, 1);
}
