dScriptCompiler::dUserVariable dScriptCompiler::EndScopeBlock ()
{
dUserVariable returnNode;
returnNode.m_node = GetCurrentScope();
m_scopeStack.Remove(m_scopeStack.GetLast());
return returnNode;
}
dScriptCompiler::dUserVariable dScriptCompiler::NewExpressionNodeLogiOperator (const dUserVariable& expressionA, const dUserVariable& logicOperator, const dUserVariable& expressionB)
{
dUserVariable returnNode;
dAssert (expressionA.m_node && expressionA.m_node->IsType(dDAGExpressionNode::GetRttiType()));
dAssert (expressionB.m_node && expressionB.m_node->IsType(dDAGExpressionNode::GetRttiType()));
dDAGExpressionNodeLogicOperator::dLogicOperator logOperator = dDAGExpressionNodeLogicOperator::m_and;
switch (int (logicOperator.m_token))
{
case _LOGIC_OR:
logOperator = dDAGExpressionNodeLogicOperator::m_or;
break;
case _LOGIC_AND:
logOperator = dDAGExpressionNodeLogicOperator::m_and;
break;
default:
dAssert (0);
}
dAssert (GetCurrentScope());
dDAGExpressionNodeLogicOperator* const node = new dDAGExpressionNodeLogicOperator (m_allNodes, logOperator, (dDAGExpressionNode*)expressionA.m_node, (dDAGExpressionNode*)expressionB.m_node);
// expressionA.m_node->Release();
// expressionB.m_node->Release();
returnNode.m_node = node;
return returnNode;
}
void DIGenerator::Visit(const Ides::Types::StructType* ty) {
std::vector<llvm::Value*> membersDI;
for (auto i = ty->GetMembers().begin(); i != ty->GetMembers().end(); ++i) {
membersDI.push_back(GetType(i->second));
}
createStructType(llvm::DIDescriptor(GetCurrentScope()),
ty->GetName(),
llvm::DIFile(),
0,
ty->GetSize(),
ty->GetAlignment(),
0,
llvm::DIType(),
getOrCreateArray(membersDI));
}
dScriptCompiler::dUserVariable dScriptCompiler::AddStatementToCurrentBlock(const dUserVariable& statement)
{
dUserVariable returnNode;
dDAGScopeBlockNode* const block = GetCurrentScope();
dDAGFunctionStatement* const statementNode = (dDAGFunctionStatement*)statement.m_node;
if (statementNode) {
if (statementNode->IsType(dDAGExpressionNode::GetRttiType())) {
for (dDAGParameterNode* node = (dDAGParameterNode*) statementNode; node; node = (dDAGParameterNode*) node->m_next) {
block->AddStatement(node);
}
} else {
dAssert (statementNode->IsType(dDAGFunctionStatement::GetRttiType()));
block->AddStatement(statementNode);
}
}
returnNode.m_node = block;
return returnNode;
}
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 returnNode;
}
dScriptCompiler::dUserVariable dScriptCompiler::ConcatenateExpressions(const dUserVariable& expressionA, const dUserVariable& expressionB)
{
dUserVariable returnNode;
dDAGExpressionNode* const nodeA = (dDAGExpressionNode*)expressionA.m_node;
dDAGExpressionNode* const nodeB = (dDAGExpressionNode*)expressionB.m_node;
dAssert (nodeA->IsType(dDAGExpressionNode::GetRttiType()));
dAssert (nodeB->IsType(dDAGExpressionNode::GetRttiType()));
dDAGExpressionNode* nextNode = nodeA;
for (; nextNode->m_next; nextNode = (dDAGExpressionNode*) nextNode->m_next);
nextNode->m_next = nodeB;
dDAGExpressionNodeVariable* const leftVarListA = nodeA->FindLeftVariable();
if (leftVarListA && leftVarListA->m_type) {
dDAGExpressionNodeVariable* const leftVarListB = nodeB->FindLeftVariable();
if (leftVarListB && !leftVarListB->m_type) {
dUserVariable localVariable(NewVariableStatement (leftVarListB->m_name, ""));
dDAGParameterNode* const variableNode = (dDAGParameterNode*)localVariable.m_node;
dAssert (variableNode->IsType(dDAGParameterNode::GetRttiType()));
variableNode->SetType((dDAGTypeNode*) leftVarListA->m_type->Clone(m_allNodes));
leftVarListB->SetType((dDAGTypeNode*) leftVarListA->m_type->Clone(m_allNodes));
if (m_scopeStack.GetCount()) {
dDAGScopeBlockNode* const block = GetCurrentScope();
block->AddStatement(variableNode);
} else {
dAssert (0);
//dDAGClassNode* const curClass = GetCurrentClass();
//curClass->AddVariable(variableNode);
}
}
}
returnNode.m_node = nodeA;
return returnNode;
}
void TypeSpecifierResolutionPass::Visit(ForStatement *forStatement)
{
Symbol *parent = GetCurrentScope();
forStatement->SetParentSymbol(parent);
SemanticAnalysisPass::Visit(forStatement);
}
void TypeSpecifierResolutionPass::Visit(SwitchSection *switchSection)
{
Symbol *parent = GetCurrentScope();
switchSection->SetParentSymbol(parent);
SemanticAnalysisPass::Visit(switchSection);
}
void TypeSpecifierResolutionPass::Visit(CompoundStatement *compoundStatement)
{
Symbol *parent = GetCurrentScope();
compoundStatement->SetParentSymbol(parent);
SemanticAnalysisPass::Visit(compoundStatement);
}
