dNewtonLuaCompiler::dUserVariable dNewtonLuaCompiler::EmitFunctionCall(const dUserVariable& functionName, const dUserVariable& argumentsList)
{
dCILInstr::dArgType type(dCILInstr::m_luaType);
dString result(m_currentClosure->NewTemp());
dCILInstrCall* const functionCall = new dCILInstrCall(*m_currentClosure, result, type, functionName.GetString());
dAssert (0);
/*
for (dCILInstr* instruction = argumentsList.m_node->GetInfo(); instruction; instruction = instruction->GetPrevius()) {
dCILSingleArgInstr* const parameter = instruction->GetAsSingleArg();
functionCall->AddArgument(parameter->GetArg0());
}
*/
TRACE_INSTRUCTION(functionCall);
return dUserVariable(functionCall);
}
dNewtonLuaCompiler::dUserVariable dNewtonLuaCompiler::EmitLoadConstant(const dUserVariable& constName)
{
dString localVariableAliasName(m_currentClosure->NewTemp());
dCILInstr::dIntrisicType constType = dCILInstr::m_luaType;
dCILInstr::dIntrisicType variableType = dCILInstr::m_luaType;
int token = constName.GetToken();
switch (token)
{
case _INTEGER:
variableType = dCILInstr::m_int;
constType = dCILInstr::m_constInt;
break;
default:
dAssert(0);
}
dCILInstrMove* const move = new dCILInstrMove(*m_currentClosure, localVariableAliasName, dCILInstr::dArgType(variableType), constName.GetString(), dCILInstr::dArgType (constType));
TRACE_INSTRUCTION(move);
return dUserVariable(move);
}
dNewtonLuaCompiler::dUserVariable dNewtonLuaCompiler::EmitAssigmentStatement(const dUserVariable& nameList, const dUserVariable& expresionList)
{
//dList<dCIL::dListNode*>::dListNode* nameListNode = nameList.m_nodeList.GetFirst();
dList<dString>::dListNode* nameListNode = nameList.m_tokenList.GetFirst();
dList<dCIL::dListNode*>::dListNode* expressionListNode = expresionList.m_nodeList.GetFirst();
dAssert(nameList.m_tokenList.GetCount() >= 1);
dAssert(expresionList.m_nodeList.GetCount() >= 1);
int count = dMin (nameList.m_tokenList.GetCount(), expresionList.m_nodeList.GetCount());
for (int i = 0; i < count; i ++) {
//dCILSingleArgInstr* const dst = nameListNode->GetInfo();
const dString& dstName = nameListNode->GetInfo();
/*
if (dest->GetAsLocal()) {
dCILInstrLocal* const dstIntruction = dest->GetAsLocal();
const dCILInstr::dArg& argName = dstIntruction->GetArg0();
for (dList<dCILInstrLocal*>::dListNode* node = m_currentClosure->m_localVariables.GetFirst(); node; node = node->GetNext()) {
dCILInstrLocal* const intruction = node->GetInfo()->GetAsLocal();
dAssert(intruction);
if (argName.m_label == intruction->GetArg0().m_label) {
destArg = argName;
break;
}
}
}
*/
dCILSingleArgInstr* const src = expressionListNode->GetInfo()->GetInfo()->GetAsSingleArg();
dAssert(src);
//dAssert(dst);
//const dCILInstr::dArg& dstArg = dst->GetArg0();
const dCILInstr::dArg& srcArg = src->GetArg0();
dCILInstrMove* const move = new dCILInstrMove(*m_currentClosure, dstName, srcArg.GetType(), srcArg.m_label, srcArg.GetType());
TRACE_INSTRUCTION(move);
nameListNode = nameListNode->GetNext();
expressionListNode = expressionListNode->GetNext();
}
return dUserVariable();
}
dScriptCompiler::dUserVariable dScriptCompiler::NewVariableToCurrentBlock (const dString& modifiers, const dUserVariable& type, const dString& name)
{
/*
dUserVariable variableName(NewVariableStatement (name, modifiers));
dDAGParameterNode* const variableNameNode = (dDAGParameterNode*)variableName.m_node;
dAssert (variableNameNode->IsType(dDAGParameterNode::GetRttiType()));
dDAGTypeNode* const typeNode = (dDAGTypeNode*)type.m_node;
dAssert (typeNode->GetTypeId() == dDAGTypeNode::GetRttiType());
variableNameNode->SetType(typeNode);
dAssert (m_scopeStack.GetCount());
dDAGScopeBlockNode* const block = GetCurrentScope();
block->AddStatement(variableNameNode);
dUserVariable returnNode (NewExpressionNodeVariable (name, modifiers));
dAssert (returnNode.m_node->GetTypeId() == dDAGExpressionNodeVariable::GetRttiType());
dDAGExpressionNodeVariable* const node = (dDAGExpressionNodeVariable*) returnNode.m_node;
node->SetType((dDAGTypeNode*) typeNode->Clone (m_allNodes));
*/
return dUserVariable();
}
dNewtonLuaCompiler::dUserVariable dNewtonLuaCompiler::EmitLoadVariable(const dUserVariable& varName)
{
/*
// search for the defintions
// note: lua does no requred this
dCILInstrMove* definition = NULL;
for (dList<dCILInstrMove*>::dListNode* node = m_currentClosure->m_argumnets.GetFirst(); node; node = node->GetNext()) {
dCILInstrMove* const intruction = node->GetInfo()->GetAsMove();
if (intruction) {
const dCILInstr::dArg& argName = intruction->GetArg1();
if (argName.m_label == varName.GetString()) {
definition = intruction;
break;
}
}
}
dAssert(definition);
*/
dString outVarName(m_currentClosure->NewTemp());
dCILInstr::dArgType type(dCILInstr::m_luaType);
dCILInstrMove* const move = new dCILInstrMove(*m_currentClosure, outVarName, type, varName.GetString(), type);
TRACE_INSTRUCTION(move);
return dUserVariable(move);
}
bool test6::Parse(xxxx& scanner)
{
static short gotoCount[] = {
2, 1, 0, 0, 0};
static short gotoStart[] = {
0, 2, 3, 3, 3};
static dGotoEntry gotoTable[] = {
dGotoEntry (257, 2), dGotoEntry (258, 1), dGotoEntry (259, 3)};
dList<dStackPair> stack;
const int lastToken = 257;
stack.Append ();
m_grammarError = false;
dToken token = dToken (scanner.NextToken());
for (bool terminate = false; !terminate;) {
const dActionEntry* const action = GetNextAction (stack, token, scanner);
if (!action) {
terminate = true;
fprintf (stderr, "unrecoverable parser error\n");
DTRACE (("unrecoverable parser error\n"));
} else {
switch (action->m_stateType)
{
case dSHIFT:
{
dStackPair& entry = stack.Append()->GetInfo();
entry.m_state = action->m_nextState;
entry.m_scannerLine = scanner.GetLineNumber();
entry.m_scannerIndex = scanner.GetIndex();
entry.m_value = dUserVariable (token, scanner.GetTokenString(), entry.m_scannerLine, entry.m_scannerIndex);
token = dToken (scanner.NextToken());
entry.m_token = token;
if (token == -1) {
token = ACCEPTING_TOKEN;
}
break;
}
case dREDUCE:
{
dStackPair parameter[MAX_USER_PARAM];
int reduceCount = action->m_ruleSymbols;
_ASSERTE (reduceCount < sizeof (parameter) / sizeof (parameter[0]));
for (int i = 0; i < reduceCount; i ++) {
parameter[reduceCount - i - 1] = stack.GetLast()->GetInfo();
stack.Remove (stack.GetLast());
}
const dStackPair& stackTop = stack.GetLast()->GetInfo();
int start = gotoStart[stackTop.m_state];
int count = gotoCount[stackTop.m_state];
const dGotoEntry* const table = &gotoTable[start];
const dGotoEntry* const gotoEntry = FindGoto (table, count, dToken (action->m_nextState + lastToken));
dStackPair& entry = stack.Append()->GetInfo();
entry.m_state = gotoEntry->m_nextState;
entry.m_scannerLine = scanner.GetLineNumber();
entry.m_scannerIndex = scanner.GetIndex();
entry.m_token = dToken (gotoEntry->m_token);
switch (action->m_ruleIndex)
{
//do user semantic Actions
case 3:// rule0 :
{/*xxx1*/}
break;
case 1:// NewtonHeader :
{/*xxx0*/}
break;
case 4:// rule1 :
{/*xxx2*/}
break;
default:;
}
break;
}
case dACCEPT: // 2 = accept
{
// program parsed successfully, exit with successful code
terminate = true;
break;
}
default:
{
_ASSERTE (0);
// syntax error parsing program
//if (!ErrorHandler ("error")) {
//}
terminate = true;
m_grammarError = true;
break;
}
}
}
}
return !m_grammarError;
}
const test6::dActionEntry* test6::GetNextAction (dList<dStackPair>& stack, dToken token, xxxx& scanner) const
{
static short actionsCount[] = {
2, 1, 1, 1, 1};
static short actionsStart[] = {
0, 2, 3, 4, 5};
static dActionEntry actionTable[] = {
dActionEntry (254, 0, 1, 0, 0, 1), dActionEntry (256, 0, 1, 1, 0, 3), dActionEntry (256, 0, 1, 2, 0, 4), dActionEntry (254, 0, 2, 0, 0, 0),
dActionEntry (256, 0, 0, 4, 0, 0), dActionEntry (254, 0, 1, 0, 3, 2)};
bool errorMode = false;
const dStackPair& stackTop = stack.GetLast()->GetInfo();
int state = stackTop.m_state;
int start = actionsStart[state];
int count = actionsCount[state];
const dActionEntry* const table = &actionTable[start];
const dActionEntry* action = FindAction (table, count, token);
while (!action && (stack.GetCount() > 1)) {
errorMode = true;
// we found a syntax error in go into error recovering mode, and find the token mark by a ". error" rule
stack.Remove (stack.GetLast());
const dStackPair& stackTop = stack.GetLast()->GetInfo();
int state = stackTop.m_state;
int start = actionsStart[state];
int count = actionsCount[state];
const dActionEntry* const table = &actionTable[start];
action = FindAction (table, count, ERROR_TOKEN);
if (action && !action->m_errorRule) {
action = NULL;
}
}
if (errorMode && action) {
dStackPair& stackTop = stack.GetLast()->GetInfo();
stackTop.m_token = ERROR_TOKEN;
int state = action->m_nextState;
int start = actionsStart[state];
int count = actionsCount[state];
const dActionEntry* const table = &actionTable[start];
// find the next viable token to continues parsing
while (!FindAction (table, count, token)) {
token = dToken (scanner.NextToken());
if (token == -1) {
// reached end of the file, can not recover from this error;
return NULL;
}
}
action = FindAction (table, count, token);
dStackPair& entry = stack.Append()->GetInfo();
entry.m_state = state;
entry.m_scannerLine = stackTop.m_scannerLine;
entry.m_scannerIndex = stackTop.m_scannerIndex;
entry.m_value = dUserVariable (ERROR_TOKEN, "error", entry.m_scannerLine, entry.m_scannerIndex);
entry.m_token = token;
}
return action;
}
dScriptCompiler::dUserVariable dScriptCompiler::NewExpresionNodeAssigment (const dUserVariable& leftVariable, const dUserVariable& assigmentOperator, const dUserVariable& expression)
{
dUserVariable leftVariableCopy;
/*
dDAGExpressionNodeVariable* const leftNode = (dDAGExpressionNodeVariable*) leftVariable.m_node;
dAssert (leftNode->IsType(dDAGExpressionNodeVariable::GetRttiType()));
dUserVariable tmpOperator;
switch (assigmentOperator.m_token)
{
case _ASS_ADD:
{
tmpOperator.m_token = dToken ('+');
break;
}
case _ASS_SUB:
{
tmpOperator.m_token = dToken ('-');
break;
}
case _ASS_MUL:
{
tmpOperator.m_token = dToken ('*');
break;
}
case _ASS_DIV:
{
tmpOperator.m_token = dToken ('/');
break;
}
case _ASS_MOD:
{
tmpOperator.m_token = dToken ('%');
break;
}
case _ASS_SHL:
{
tmpOperator.m_token = dToken ('<<');
break;
}
case _ASS_SHR:
{
tmpOperator.m_token = dToken ('>>');
break;
}
case _ASS_AND:
{
tmpOperator.m_token = dToken ('&');
break;
}
case _ASS_XOR:
{
tmpOperator.m_token = dToken ('^');
break;
}
case _ASS_OR:
{
tmpOperator.m_token = dToken ('|');
break;
}
default:
dAssert (0);
}
dUserVariable expressionA;
expressionA.m_node = leftNode->Clone (m_allNodes);
return NewExpresionNodeAssigment (leftVariable, NewExpressionNodeBinaryOperator (expressionA, tmpOperator, expression));
*/
return dUserVariable();
}
