// Traverse VAR DECL
bool SuperastCPP::TraverseVarDecl(clang::VarDecl* var) {
const std::string varName = var->getName().str();
rapidjson::Value varValue(rapidjson::kObjectType);
addId(varValue);
addPos(varValue, var);
// Variable Declaration if it is not a parameter of a function
if (!clang::dyn_cast<clang::ParmVarDecl>(var)) {
varValue.AddMember("type", "variable-declaration", allocator);
}
varValue.AddMember("name",
rapidjson::Value().SetString(varName.c_str(),
varName.size(),
allocator),
allocator);
// NonLValueExpr to remove LValueExpression for references.
// There are more options
clang::QualType qualType = var->getType().getNonLValueExprType(*context);
const clang::Type* type = qualType.getTypePtr();
bool isConst = var->getType().isConstQualified() | qualType.isConstQualified();
//std::cerr << " type: " << type->getCanonicalTypeInternal().getAsString();
varValue.AddMember("data-type", createTypeValue(type), allocator);
varValue.AddMember("is-reference", var->getType()->isReferenceType(), allocator);
varValue.AddMember("is-const", isConst, allocator);
if (var->hasInit() && !type->isStructureType() &&
!isSTLVectorType(type->getCanonicalTypeInternal())) {
rapidjson::Value exprValue(rapidjson::kObjectType);
TRY_TO(TraverseStmt(var->getInit()));
clang::VarDecl::InitializationStyle initStyle = var->getInitStyle();
switch (initStyle) {
case clang::VarDecl::CInit:
case clang::VarDecl::CallInit:
// We don't distinguis between these two initializations
if (!sonValue.IsNull()) {
varValue.AddMember("init", sonValue, allocator);
}
// Call style initializer (int x(1))
break;
case clang::VarDecl::ListInit:
// C++11 Initializer list. Not supported by us.
break;
}
}
sonValue = varValue;
return true;
}
void Parser::ParseConstDecl()
{
if (MatchSkip(CONST, -1))
{
do
{
string name = currToken->lexeme;
Expect(IDENT, -1);
Expect(EQUAL, -1);
sptr<ExprNode> exprValue(ParseExp()); // TODO get value
currSymTable->Push(sptr<SymVar>(new SymVar(name, exprValue->GetType(), true)));
} while (MatchSkip(SEMICOLON, -1));
}
}
void ArrayProducerAdapter::llvmCompileToModule( ModuleBuilder &moduleBuilder ) const
{
if ( moduleBuilder.haveCompiledToModule( getCodeName() ) )
return;
RC::Handle<Context> context = moduleBuilder.getContext();
m_elementAdapter->llvmCompileToModule( moduleBuilder );
m_elementVariableArrayAdapter->llvmCompileToModule( moduleBuilder );
RC::ConstHandle<BooleanAdapter> booleanAdapter = getManager()->getBooleanAdapter();
booleanAdapter->llvmCompileToModule( moduleBuilder );
RC::ConstHandle<SizeAdapter> sizeAdapter = getManager()->getSizeAdapter();
sizeAdapter->llvmCompileToModule( moduleBuilder );
RC::ConstHandle<StringAdapter> stringAdapter = getManager()->getStringAdapter();
stringAdapter->llvmCompileToModule( moduleBuilder );
RC::ConstHandle<ConstStringAdapter> constStringAdapter = getManager()->getConstStringAdapter();
constStringAdapter->llvmCompileToModule( moduleBuilder );
static const bool buildFunctions = true;
{
ConstructorBuilder functionBuilder( moduleBuilder, stringAdapter, this, ConstructorBuilder::HighCost );
if ( buildFunctions )
{
llvm::Value *stringLValue = functionBuilder[0];
BasicBlockBuilder basicBlockBuilder( functionBuilder );
basicBlockBuilder->SetInsertPoint( functionBuilder.createBasicBlock( "entry" ) );
std::string name = getUserName();
ExprValue exprValue( constStringAdapter, USAGE_RVALUE, context, constStringAdapter->llvmConst( basicBlockBuilder, name.data(), name.length() ) );
llvm::Value *stringRValue = stringAdapter->llvmCast( basicBlockBuilder, exprValue );
stringAdapter->llvmAssign( basicBlockBuilder, stringLValue, stringRValue );
stringAdapter->llvmDispose( basicBlockBuilder, stringRValue );
basicBlockBuilder->CreateRetVoid();
}
}
{
ConstructorBuilder functionBuilder( moduleBuilder, booleanAdapter, this, ConstructorBuilder::HighCost );
if ( buildFunctions )
{
llvm::Value *booleanLValue = functionBuilder[0];
llvm::Value *rValue = functionBuilder[1];
BasicBlockBuilder basicBlockBuilder( functionBuilder );
basicBlockBuilder->SetInsertPoint( functionBuilder.createBasicBlock( "entry" ) );
llvm::Value *arrayProducerRValue = basicBlockBuilder->CreateLoad( rValue );
basicBlockBuilder->CreateStore(
basicBlockBuilder->CreateIsNotNull( arrayProducerRValue ),
booleanLValue
);
basicBlockBuilder->CreateRetVoid();
}
}
{
MethodBuilder functionBuilder( moduleBuilder, sizeAdapter, this, USAGE_RVALUE, "getCount" );
if ( buildFunctions )
{
BasicBlockBuilder basicBlockBuilder( functionBuilder );
llvm::Value *rValue = functionBuilder[0];
llvm::BasicBlock *entryBB = basicBlockBuilder.getFunctionBuilder().createBasicBlock( "entry" );
basicBlockBuilder->SetInsertPoint( entryBB );
basicBlockBuilder->CreateRet(
llvmGetCount( basicBlockBuilder, rValue )
);
}
}
{
MethodBuilder functionBuilder(
moduleBuilder,
m_elementVariableArrayAdapter,
this, USAGE_RVALUE,
"produce"
);
if ( buildFunctions )
{
BasicBlockBuilder basicBlockBuilder( functionBuilder );
llvm::Value *rValue = functionBuilder[0];
llvm::BasicBlock *entryBB = basicBlockBuilder.getFunctionBuilder().createBasicBlock( "entry" );
basicBlockBuilder->SetInsertPoint( entryBB );
llvmProduce0( basicBlockBuilder, rValue, functionBuilder.getScope().llvmGetReturnLValue() );
basicBlockBuilder->CreateRetVoid();
}
}
{
MethodBuilder functionBuilder(
moduleBuilder, m_elementAdapter,
this, USAGE_RVALUE,
"produce",
"index", sizeAdapter, USAGE_RVALUE
);
if ( buildFunctions )
{
BasicBlockBuilder basicBlockBuilder( functionBuilder );
llvm::Value *rValue = functionBuilder[0];
llvm::Value *indexRValue = functionBuilder[1];
llvm::BasicBlock *entryBB = basicBlockBuilder.getFunctionBuilder().createBasicBlock( "entry" );
basicBlockBuilder->SetInsertPoint( entryBB );
CG::FunctionScope &functionScope = functionBuilder.getScope();
functionScope.llvmPrepareReturnLValue( basicBlockBuilder );
llvmProduce1( basicBlockBuilder, rValue, indexRValue, functionScope.llvmGetReturnLValue() );
if ( functionScope.getReturnInfo().usesReturnLValue() )
basicBlockBuilder->CreateRetVoid();
else
basicBlockBuilder->CreateRet( basicBlockBuilder->CreateLoad( functionScope.llvmGetReturnLValue() ) );
}
}
{
MethodBuilder functionBuilder(
moduleBuilder, m_elementVariableArrayAdapter,
this, USAGE_RVALUE,
"produce",
"index", sizeAdapter, USAGE_RVALUE,
"count", sizeAdapter, USAGE_RVALUE
);
if ( buildFunctions )
{
BasicBlockBuilder basicBlockBuilder( functionBuilder );
llvm::Value *rValue = functionBuilder[0];
llvm::Value *indexRValue = functionBuilder[1];
llvm::Value *countRValue = functionBuilder[2];
llvm::BasicBlock *entryBB = basicBlockBuilder.getFunctionBuilder().createBasicBlock( "entry" );
basicBlockBuilder->SetInsertPoint( entryBB );
llvmProduce2( basicBlockBuilder, rValue, indexRValue, countRValue, functionBuilder.getScope().llvmGetReturnLValue() );
basicBlockBuilder->CreateRetVoid();
}
}
{
MethodBuilder functionBuilder( moduleBuilder, 0, this, USAGE_RVALUE, "flush" );
if ( buildFunctions )
{
BasicBlockBuilder basicBlockBuilder( functionBuilder );
llvm::Value *rValue = functionBuilder[0];
llvm::BasicBlock *entryBB = basicBlockBuilder.getFunctionBuilder().createBasicBlock( "entry" );
basicBlockBuilder->SetInsertPoint( entryBB );
llvmFlush( basicBlockBuilder, rValue );
basicBlockBuilder->CreateRetVoid();
}
}
}
