int getReversedPolishExpressionSize(char* expression) {
int count = 0;
for(char* i = expression; *i != '\0'; i++)
if(getCodeName(i) != 6 && getCodeName(i) != 7)
count++;
return count;
}
bool checkForValidMultiCharOperator(char* const position) {
if(getCodeName(position) == 4 && *(position + 1) != '>') {
printf("Invalid operator: -> cannot be found.\n");
return false;
}
if(getCodeName(position) == 5 && *(position + 1) != '-' && *(position + 1) != '>') {
printf("Invalid operator: <-> cannot be found.\n");
return false;
}
return true;
}
llvm::Type *StructAdapter::buildLLVMRawType( RC::Handle<Context> const &context ) const
{
std::vector<llvm::Type *> memberLLVMTypes;
memberLLVMTypes.reserve( m_memberAdapters.size() );
for ( size_t i=0; i<m_memberAdapters.size(); ++i )
memberLLVMTypes.push_back( m_memberAdapters[i]->llvmRawType( context ) );
return llvm::StructType::create( context->getLLVMContext(), memberLLVMTypes, getCodeName(), true );
}
bool checkForValidBrackets(char* const expression) {
int count = 0;
for(char* i = expression; *i; i++) {
if(getCodeName(i) == 6)
count++;
if(getCodeName(i) == 7)
count--;
if(count < 0) {
printf("Invalid brackets: The brackets' orders are invalid.\n");
return false;
}
}
if(count != 0) {
printf("Invalid brackets: The brackets' orders are invalid.\n");
return false;
}
return true;
}
llvm::Constant *ArrayProducerAdapter::llvmDefaultLValue( BasicBlockBuilder &basicBlockBuilder ) const
{
llvm::Constant *defaultValue = llvmDefaultValue( basicBlockBuilder );
return new llvm::GlobalVariable(
*basicBlockBuilder.getModuleBuilder(),
defaultValue->getType(),
true,
llvm::GlobalValue::InternalLinkage,
defaultValue,
"__" + getCodeName() + "__DefaultValue"
);
}
void StructAdapter::llvmDefaultAssign( BasicBlockBuilder &basicBlockBuilder, llvm::Value *dstLValue, llvm::Value *srcRValue ) const
{
if ( !m_isShallow )
{
InternalFunctionBuilder functionBuilder(
basicBlockBuilder.getModuleBuilder(),
0, "__" + getCodeName() + "__DefaultAssign",
"dst", this, USAGE_LVALUE,
"src", this, USAGE_RVALUE,
0
);
basicBlockBuilder->CreateCall2( functionBuilder.getLLVMFunction(), dstLValue, srcRValue );
}
else basicBlockBuilder->CreateStore( basicBlockBuilder->CreateLoad( srcRValue ), dstLValue );
}
char* convertToReversedPolish(char* expression) {
if(!isValidExpression(expression))
return NULL;
stack<char*> operators_stack;
char* converted = new char[getReversedPolishExpressionSize(expression)];
strcpy(converted, "");
for(char* i = expression; *i; i++) {
//ignore multi-chars operators' 2nd char onwards
if(*i == '>' || (*i == '-' && *(i - 1) == '<'))
continue;
int code = getCodeName(i);
if(code == 0) {
strncat(converted, i, 1);
continue;
}
if(code == 6) {
pushCharToStack(i, operators_stack);
continue;
}
if(code == 7) {
while(*operators_stack.top() != '(') {
popStackToResult(converted, operators_stack);
}
//pop the '(' char
operators_stack.pop();
continue;
}
if(operators_stack.empty()) {
pushCharToStack(i, operators_stack);
continue;
}
else if(*operators_stack.top() != '(')
popStackToResult(converted, operators_stack);
pushCharToStack(i, operators_stack);
}
while(!operators_stack.empty())
popStackToResult(converted, operators_stack);
return converted;
}
//=============================================================================
// METHOD: SPELLserverCif::notifyReturn
//=============================================================================
void SPELLserverCif::notifyReturn()
{
DEBUG("[CIF] Procedure return");
m_lnMessage.set( MessageField::FIELD_DATA_TYPE, MessageValue::DATA_TYPE_RETURN );
m_lnMessage.setType(MSG_TYPE_NOTIFY);
completeMessage( &m_lnMessage );
m_lnMessage.set(MessageField::FIELD_MSG_SEQUENCE, ISTR(m_sequenceStack));
m_sequenceStack++;
m_lnMessage.set(MessageField::FIELD_CODE_NAME, getCodeName() );
m_asRun->writeReturn( (m_sequence-1) );
SPELLipcMessage* response = sendGUIRequest(&m_lnMessage, SPELL_CIF_NOTIFICATION_TIMEOUT_SEC);
if (response) delete response;
}
void *ArrayProducerAdapter::llvmResolveExternalFunction( std::string const &functionName ) const
{
if ( functionName == "__"+getCodeName()+"__Retain" )
return (void *)&ArrayProducerAdapter::Retain;
else if ( functionName == "__"+getCodeName()+"__Release" )
return (void *)&ArrayProducerAdapter::Release;
else if ( functionName == "__"+getCodeName()+"__DefaultAssign" )
return (void *)&ArrayProducerAdapter::DefaultAssign;
else if ( functionName == "__"+getCodeName()+"__GetCount" )
return (void *)&ArrayProducerAdapter::GetCount;
else if ( functionName == "__"+getCodeName()+"__Produce0" )
return (void *)&ArrayProducerAdapter::Produce0;
else if ( functionName == "__"+getCodeName()+"__Produce1" )
return (void *)&ArrayProducerAdapter::Produce1;
else if ( functionName == "__"+getCodeName()+"__Produce2" )
return (void *)&ArrayProducerAdapter::Produce2;
else if ( functionName == "__"+getCodeName()+"__Flush" )
return (void *)&ArrayProducerAdapter::Flush;
else return Adapter::llvmResolveExternalFunction( functionName );
}
//=============================================================================
// METHOD: SPELLserverCif::notifyLine
//=============================================================================
void SPELLserverCif::notifyLine()
{
std::string stack = getStack();
if (m_lastStack == stack) return;
m_lastStack = stack;
std::string stage = getStage();
DEBUG("[CIF] Procedure line: " + stack + "(" + stage + ")");
m_lnMessage.set( MessageField::FIELD_DATA_TYPE, MessageValue::DATA_TYPE_LINE );
m_lnMessage.setType(MSG_TYPE_NOTIFY_ASYNC);
completeMessage( &m_lnMessage );
m_lnMessage.set(MessageField::FIELD_MSG_SEQUENCE, ISTR(m_sequenceStack));
m_sequenceStack++;
m_lnMessage.set(MessageField::FIELD_CODE_NAME, getCodeName() );
if (stage.find(":") != std::string::npos)
{
std::vector<std::string> stage_title = tokenize(stage,":");
if (stage_title.size()==2)
{
m_lnMessage.set(MessageField::FIELD_STAGE_ID,stage_title[0]);
m_lnMessage.set(MessageField::FIELD_STAGE_TL,stage_title[1]);
}
else
{
m_lnMessage.set(MessageField::FIELD_STAGE_ID,"(none)");
m_lnMessage.set(MessageField::FIELD_STAGE_TL,"(none)");
}
}
else
{
m_lnMessage.set(MessageField::FIELD_STAGE_ID,stage);
m_lnMessage.set(MessageField::FIELD_STAGE_TL,stage);
}
m_asRun->writeLine( stack, (m_sequence-1) );
sendGUIMessage(&m_lnMessage);
}
//=============================================================================
// METHOD: SPELLserverCif::notifyCall
//=============================================================================
void SPELLserverCif::notifyCall()
{
std::string stack = getStack();
DEBUG("[CIF] Procedure call: " + stack );
m_lnMessage.set( MessageField::FIELD_DATA_TYPE, MessageValue::DATA_TYPE_CALL );
m_lnMessage.setType(MSG_TYPE_NOTIFY);
completeMessage( &m_lnMessage );
m_lnMessage.set(MessageField::FIELD_MSG_SEQUENCE, ISTR(m_sequenceStack));
m_sequenceStack++;
m_lnMessage.set(MessageField::FIELD_CODE_NAME, getCodeName() );
m_asRun->writeCall( stack, (m_sequence-1) );
SPELLipcMessage* response = sendGUIRequest(&m_lnMessage, SPELL_CIF_NOTIFICATION_TIMEOUT_SEC);
if (response) delete response;
}
void dumpBuf (const uint32_t* buf) {
printf("\n##########start to dump buf##########\n");
printf("key: %x code: %s\n", ntohl(buf[0]), getCodeName(getCode(buf)));
int loop_num = 0;
if (getCode(buf) == TURN_START) {
loop_num = COMPANY_NUM;
} else {
// loop_num = 1;
loop_num = COMPANY_NUM;
}
for (int i = 0; i < loop_num; i++) {
printf("id: %d value: %d\n", getID(i, buf), getValue(i, buf));
}
printf("########## end dump ##########\n\n");
}
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();
}
}
}
bool checkForOverlap(char* const position) {
if(*(position + 1) == '\0')
return true;
switch(getCodeName(position)) {
case 1:
if(getCodeName(position + 1) <= 5 && getCodeName(position + 1) > 0) {
printf("Invalid expression: Overlapped.\n");
return false;
}
break;
case 2:
if(getCodeName(position + 1) <= 5 && getCodeName(position + 1) > 0) {
printf("Invalid expression: Overlapped.\n");
return false;
}
break;
case 3:
if(getCodeName(position + 1) <= 5 && getCodeName(position + 1) > 0) {
printf("Invalid expression: Overlapped.\n");
return false;
}
break;
case 4:
if(getCodeName(position + 2) <= 5 && getCodeName(position + 2) > 0) {
printf("Invalid expression: The operator -> has been overlapped.\n");
return false;
}
break;
case 5:
if(getCodeName(position + 3) <= 5 && getCodeName(position + 3) > 0) {
printf("Invalid expression: The operator <-> has been overlapped.\n");
return false;
}
break;
case 6:
return true;
break;
case 7:
return true;
break;
default:
if(getCodeName(position) == getCodeName(position + 1)) {
printf("Invalid expression: The variables must be a single character.\n");
return false;
}
break;
}
return true;
}
void ArrayProducerAdapter::llvmDefaultAssign( BasicBlockBuilder &basicBlockBuilder, llvm::Value *dstLValue, llvm::Value *srcRValue ) const
{
RC::Handle<Context> context = basicBlockBuilder.getContext();
std::vector<llvm::Type *> argTypes;
argTypes.push_back( llvmRType( context ) );
argTypes.push_back( llvmLType( context ) );
llvm::FunctionType *funcType = llvm::FunctionType::get( llvm::Type::getVoidTy( context->getLLVMContext() ), argTypes, false );
llvm::Constant *func = basicBlockBuilder.getModuleBuilder()->getOrInsertFunction( "__"+getCodeName()+"__DefaultAssign", funcType );
basicBlockBuilder->CreateCall2( func, srcRValue, dstLValue );
}
void ArrayProducerAdapter::llvmProduce2(
CG::BasicBlockBuilder &basicBlockBuilder,
llvm::Value *arrayProducerRValue,
llvm::Value *indexRValue,
llvm::Value *countRValue,
llvm::Value *dstLValue
) const
{
RC::Handle<Context> context = basicBlockBuilder.getContext();
std::vector<llvm::Type *> argTypes;
argTypes.push_back( basicBlockBuilder->getInt8PtrTy() );
argTypes.push_back( llvmRType( context ) );
argTypes.push_back( llvmSizeType( context ) );
argTypes.push_back( llvmSizeType( context ) );
argTypes.push_back( m_elementVariableArrayAdapter->llvmLType( context ) );
llvm::FunctionType *funcType = llvm::FunctionType::get( llvm::Type::getVoidTy( context->getLLVMContext() ), argTypes, false );
llvm::Constant *func = basicBlockBuilder.getModuleBuilder()->getOrInsertFunction( "__"+getCodeName()+"__Produce2", funcType );
basicBlockBuilder->CreateCall5( func, llvmAdapterPtr( basicBlockBuilder ), arrayProducerRValue, indexRValue, countRValue, dstLValue );
}
int main(int argc, char const *argv[])
{
int fd; // ファイルディスクリプタ。サーバーとの接続
uint32_t r_buf[DATA_NUM];
const char *host = argv[1]; // 第一引数 ex) localhost
const char *service = argv[2]; // 第二引数 ex) 1111
/* サーバーとの接続 */
fd = get_stream(host, service);
if (fd == -1)
{
printf("get_stream error!!\n");
exit(-1);
}
/* 一回目のデータ取得 */
int len = -1;
len = getData(fd, r_buf);
printf("finish read\n");
printf("len: %d\n", len);
// dumpBuf(r_buf);
/* ゲームに必要なデータの初期化 */
struct Company companies[COMPANY_NUM];
struct Tickets* tickets = InitTickets();
uint32_t key, tmp_key, tmp_code;
int money = 10000;
int state = 0;
key = InitCompanies(r_buf, companies);
PrintCompanies(companies);
/* メインルーチン。ターン数分実行される */
for (int t = 0; t < TURNS; t++) {
printf("\n\n------------------------%d th turn money: %d------------------------\n", t, money);
PrintCompanies(companies);
/* strategy部分 */
if (t == 0) {
InitStrategy(fd, key, tickets, companies);
} else if (t % 2 == 1) {
SecondStrategy(fd, key, tickets, companies);
} else if (t % 2 == 0) {
ThirdBuyStrategy(fd, key, money, tickets, companies);
} else {
printf("bug!!!\n");
}
/* ターン内で投げたリクエストに対する反応を取得する */
state = 0;
// stateでゲームの進行状況を管理
// state 0: 同一ターン内
// state 1: 次のターンに進行
// state 2: ゲーム終了。結果の出力へ
while (state == 0) {
getData(fd, r_buf);
dumpBuf(r_buf);
tmp_code = 0;
tmp_key = 0;
tmp_key = getKey(r_buf);
if (key != tmp_key) {
state = 1;
printf("next turn\n");
}
tmp_code = getCode(r_buf);
if (tmp_code == REQ_ACCEPT) {
int accepted_idx = isContain(MakeTicketFromBuf(r_buf), tickets);
printf("%d th ticket accepted!!\n", accepted_idx);
if (accepted_idx != -1) {
money += ApplyTicket(accepted_idx, tickets, companies);
}
} else if (tmp_code == UNKOWN_CODE || tmp_code == INVALID_KEY ||
tmp_code == TOO_MUCH_REQ || tmp_code == ID_NOT_EXIST ||
tmp_code == TOO_MUCH_BUY || tmp_code == TOO_MUCH_SELL) {
printf("code error type: %s\n", getCodeName(tmp_code));
int rejected_idx = isContain(MakeTicketFromBuf(r_buf), tickets);
printf("rejected ticket: %d\n", rejected_idx);
if (rejected_idx != -1) {
DeleteTicket(rejected_idx, tickets);
}
} else if (tmp_code == TURN_START) {
key = Parse(r_buf, companies);
state = 1;
} else if (tmp_code == GAME_END) {
state = 2;
} else {
printf("something wrong in code\n");
}
}
if (state == 2) {
break;
}
}
printf("\n\n\n");
printf("##################################\n");
printf("##############RESULT##############\n");
printf("##################################\n\n");
printf("your rank: %d\n", getID(0, r_buf));
printf("your budget: %u\n", getValue(0, r_buf));
close(fd);
return 0;
}
const char* MtpDebug::getFormatCodeName(MtpObjectFormat code) {
if (code == 0)
return "NONE";
return getCodeName(code, sFormatCodes);
}
void OpaqueAdapter::llvmCompileToModule( ModuleBuilder &moduleBuilder ) const
{
if ( moduleBuilder.haveCompiledToModule( getCodeName() ) )
return;
RC::Handle<Context> context = moduleBuilder.getContext();
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<OpaqueAdapter> dataAdapter = getManager()->getDataAdapter();
dataAdapter->llvmCompileToModule( moduleBuilder );
static const bool buildFunctions = true;
{
ConstructorBuilder functionBuilder( moduleBuilder, booleanAdapter, this, ConstructorBuilder::HighCost );
if ( buildFunctions )
{
llvm::Value *booleanLValue = functionBuilder[0];
llvm::Value *opaqueRValue = functionBuilder[1];
BasicBlockBuilder basicBlockBuilder( functionBuilder );
basicBlockBuilder->SetInsertPoint( functionBuilder.createBasicBlock( "entry" ) );
llvm::Value *booleanRValue = basicBlockBuilder->CreateIsNotNull( opaqueRValue );
booleanAdapter->llvmAssign( basicBlockBuilder, booleanLValue, booleanRValue );
basicBlockBuilder->CreateRetVoid();
}
}
{
ConstructorBuilder functionBuilder( moduleBuilder, stringAdapter, this, ConstructorBuilder::HighCost );
if ( buildFunctions )
{
llvm::Value *stringLValue = functionBuilder[0];
llvm::Value *opaqueRValue = functionBuilder[1];
BasicBlockBuilder basicBlockBuilder( functionBuilder );
basicBlockBuilder->SetInsertPoint( functionBuilder.createBasicBlock( "entry" ) );
llvm::Value *opaqueLValue = llvmRValueToLValue( basicBlockBuilder, opaqueRValue );
stringAdapter->llvmCallCast( basicBlockBuilder, this, opaqueLValue, stringLValue );
basicBlockBuilder->CreateRetVoid();
}
}
{
MethodBuilder functionBuilder(
moduleBuilder,
sizeAdapter,
this, USAGE_RVALUE,
"dataSize"
);
if ( buildFunctions )
{
BasicBlockBuilder basicBlockBuilder( functionBuilder );
basicBlockBuilder->SetInsertPoint( functionBuilder.createBasicBlock( "entry" ) );
llvm::Value *dataSizeRValue = sizeAdapter->llvmConst( context, getDesc()->getAllocSize() );
basicBlockBuilder->CreateRet( dataSizeRValue );
}
}
{
MethodBuilder functionBuilder(
moduleBuilder,
dataAdapter,
this, USAGE_LVALUE,
"data"
);
if ( buildFunctions )
{
llvm::Value *thisLValue = functionBuilder[0];
BasicBlockBuilder basicBlockBuilder( functionBuilder );
basicBlockBuilder->SetInsertPoint( functionBuilder.createBasicBlock( "entry" ) );
basicBlockBuilder->CreateRet( basicBlockBuilder->CreatePointerCast( thisLValue, dataAdapter->llvmRType( context ) ) );
}
}
}
void StructAdapter::llvmCompileToModule( ModuleBuilder &moduleBuilder ) const
{
if ( moduleBuilder.haveCompiledToModule( getCodeName() ) )
return;
RC::Handle<Context> context = moduleBuilder.getContext();
RC::ConstHandle<StringAdapter> stringAdapter = getManager()->getStringAdapter();
stringAdapter->llvmCompileToModule( moduleBuilder );
RC::ConstHandle<SizeAdapter> sizeAdapter = getManager()->getSizeAdapter();
sizeAdapter->llvmCompileToModule( moduleBuilder );
RC::ConstHandle<OpaqueAdapter> dataAdapter = getManager()->getDataAdapter();
dataAdapter->llvmCompileToModule( moduleBuilder );
for ( MemberAdaptorVector::const_iterator it=m_memberAdapters.begin(); it!=m_memberAdapters.end(); ++it )
(*it)->llvmCompileToModule( moduleBuilder );
static const bool buildFunctions = true;
if ( !m_isShallow )
{
{
InternalFunctionBuilder functionBuilder(
moduleBuilder,
0, "__" + getCodeName() + "__DefaultAssign",
"dst", this, USAGE_LVALUE,
"src", this, USAGE_RVALUE,
0
);
if ( buildFunctions )
{
llvm::Value *dstLValue = functionBuilder[0];
llvm::Value *srcRValue = functionBuilder[1];
BasicBlockBuilder basicBlockBuilder( functionBuilder );
basicBlockBuilder->SetInsertPoint( functionBuilder.createBasicBlock( "entry" ) );
for ( size_t i=0; i<getNumMembers(); ++i )
{
RC::ConstHandle<Adapter> const &memberAdapter = m_memberAdapters[i];
llvm::Value *dstMemberLValue = basicBlockBuilder->CreateConstGEP2_32( dstLValue, 0, i );
llvm::Value *srcMemberLValue = basicBlockBuilder->CreateConstGEP2_32( srcRValue, 0, i );
llvm::Value *srcMemberRValue = memberAdapter->llvmLValueToRValue( basicBlockBuilder, srcMemberLValue );
memberAdapter->llvmAssign( basicBlockBuilder, dstMemberLValue, srcMemberRValue );
}
basicBlockBuilder->CreateRetVoid();
}
}
}
{
ConstructorBuilder functionBuilder( moduleBuilder, stringAdapter, this, ConstructorBuilder::HighCost );
if ( buildFunctions )
{
llvm::Value *stringLValue = functionBuilder[0];
llvm::Value *structRValue = functionBuilder[1];
BasicBlockBuilder basicBlockBuilder( functionBuilder );
basicBlockBuilder->SetInsertPoint( functionBuilder.createBasicBlock( "entry" ) );
llvm::Value *structLValue = llvmRValueToLValue( basicBlockBuilder, structRValue );
stringAdapter->llvmCallCast( basicBlockBuilder, this, structLValue, stringLValue );
basicBlockBuilder->CreateRetVoid();
}
}
if ( getDesc()->isShallow() )
{
{
MethodBuilder functionBuilder(
moduleBuilder,
sizeAdapter,
this, USAGE_RVALUE,
"dataSize"
);
if ( buildFunctions )
{
BasicBlockBuilder basicBlockBuilder( functionBuilder );
basicBlockBuilder->SetInsertPoint( functionBuilder.createBasicBlock( "entry" ) );
llvm::Value *dataSizeRValue = llvm::ConstantInt::get( sizeAdapter->llvmRType( context ), getDesc()->getAllocSize() );
basicBlockBuilder->CreateRet( dataSizeRValue );
}
}
{
MethodBuilder functionBuilder(
moduleBuilder,
dataAdapter,
this, USAGE_LVALUE,
"data"
);
if ( buildFunctions )
{
llvm::Value *thisLValue = functionBuilder[0];
BasicBlockBuilder basicBlockBuilder( functionBuilder );
basicBlockBuilder->SetInsertPoint( functionBuilder.createBasicBlock( "entry" ) );
basicBlockBuilder->CreateRet( basicBlockBuilder->CreatePointerCast( thisLValue, dataAdapter->llvmRType( context ) ) );
}
}
}
}
const char* MtpDebug::getOperationCodeName(MtpOperationCode code) {
return getCodeName(code, sOperationCodes);
}
void ArrayProducerAdapter::llvmRelease( CG::BasicBlockBuilder &basicBlockBuilder, llvm::Value *rValue ) const
{
RC::Handle<Context> context = basicBlockBuilder.getContext();
std::vector<llvm::Type *> argTypes;
argTypes.push_back( llvmRType( context ) );
llvm::FunctionType *funcType = llvm::FunctionType::get( llvm::Type::getVoidTy( context->getLLVMContext() ), argTypes, false );
llvm::Constant *func = basicBlockBuilder.getModuleBuilder()->getOrInsertFunction( "__"+getCodeName()+"__Release", funcType );
basicBlockBuilder->CreateCall( func, rValue );
}
const char* MtpDebug::getDevicePropCodeName(MtpPropertyCode code) {
if (code == 0)
return "NONE";
return getCodeName(code, sDevicePropCodes);
}
llvm::Value *ArrayProducerAdapter::llvmGetCount(
CG::BasicBlockBuilder &basicBlockBuilder,
llvm::Value *arrayProducerRValue
) const
{
RC::Handle<Context> context = basicBlockBuilder.getContext();
std::vector<llvm::Type *> argTypes;
argTypes.push_back( llvmRType( context ) );
llvm::FunctionType *funcType = llvm::FunctionType::get( llvmSizeType( context ), argTypes, false );
llvm::Constant *func = basicBlockBuilder.getModuleBuilder()->getOrInsertFunction( "__"+getCodeName()+"__GetCount", funcType );
return basicBlockBuilder->CreateCall( func, arrayProducerRValue );
}
