void Output_Nested::operator()(Media_Block* m)
{
List* q = m->media_queries();
Block* b = m->block();
bool decls = false;
indent();
ctx->source_map.add_mapping(m);
append_to_buffer("@media ");
q->perform(this);
append_to_buffer(" {\n");
Selector* e = m->enclosing_selector();
bool hoisted = false;
if (e && b->has_non_hoistable()) {
hoisted = true;
++indentation;
indent();
e->perform(this);
append_to_buffer(" {\n");
}
++indentation;
decls = true;
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
if (!stm->is_hoistable()) {
if (!stm->block()) indent();
stm->perform(this);
append_to_buffer("\n");
}
}
--indentation;
if (hoisted) {
buffer.erase(buffer.length()-1);
if (ctx) ctx->source_map.remove_line();
append_to_buffer(" }\n");
--indentation;
}
if (decls) ++indentation;
if (hoisted) ++indentation;
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
if (stm->is_hoistable()) {
stm->perform(this);
}
}
if (hoisted) --indentation;
if (decls) --indentation;
buffer.erase(buffer.length()-1);
if (ctx) ctx->source_map.remove_line();
append_to_buffer(" }\n");
}
Statement*
Block::append_return_stmt(CGContext& cg_context)
{
FactMgr* fm = get_fact_mgr_for_func(func);
FactVec pre_facts = fm->global_facts;
cg_context.get_effect_stm().clear();
Statement* sr = Statement::make_random(cg_context, eReturn);
ERROR_GUARD(NULL);
stms.push_back(sr);
fm->makeup_new_var_facts(pre_facts, fm->global_facts);
assert(sr->visit_facts(fm->global_facts, cg_context));
fm->set_fact_in(sr, pre_facts);
fm->set_fact_out(sr, fm->global_facts);
fm->map_accum_effect[sr] = *(cg_context.get_effect_accum());
fm->map_visited[sr] = true;
//sr->post_creation_analysis(pre_facts, cg_context);
fm->map_accum_effect[this] = *(cg_context.get_effect_accum());
fm->map_stm_effect[this].add_effect(fm->map_stm_effect[sr]);
return sr;
}
Results* ParentClause::addParentPairToResult(set<Statement*> containerStmts, NodeType type) {
Results* resultsObj = new Results();
for (set<Statement*>::iterator containerIter = containerStmts.begin(); containerIter != containerStmts.end(); containerIter++) {
Statement* containerStmt = *containerIter;
string containerStmtNo = boost::lexical_cast<string>(containerStmt->getStmtNum());
set<int> children;
if (type == NULL_) {
children = containerStmt->getChildren();
} else {
children = Utils::filterStatements(containerStmt->getChildren(), type);
}
if (!children.empty()) {
resultsObj->setClausePassed(true);
for (set<int>::iterator childrenIter = children.begin(); childrenIter != children.end(); childrenIter++) {
string childStmtNo = boost::lexical_cast<string>(*childrenIter);
resultsObj->addPairResult(containerStmtNo, childStmtNo);
}
}
}
return resultsObj;
}
/**
* Find all content placeholders
*/
vector<ContentPlaceholder*> ContentPlaceholderController::GetAllContentPlaceholders()
{
Statement* stmt = conn->createStatement();
ResultSet* rs = stmt->executeQuery("SELECT * FROM cph");
delete stmt;
vector<ContentPlaceholder*> cphs;
if(rs != NULL)
{
while(rs->next())
{
//Add all content placeholders to a vector
cphs.push_back(GenerateContentPlaceholder(*rs));
}
delete rs;
}
return cphs;
}
/**
* Find all sheets
*/
vector<Sheet*> SheetController::GetAllSheets()
{
Statement* stmt = conn->createStatement();
ResultSet* rs = stmt->executeQuery("SELECT * FROM sheets");
vector<Sheet*> sheets;
if(rs != NULL)
{
while(rs->next())
{
//Add all sheets to a vector
sheets.push_back(GenerateSheet(*rs));
}
}
delete stmt;
delete rs;
return sheets;
}
void SQLiteStore::updateExpiration(const std::string &path, int64_t expires) {
assert(uv_thread_self() == thread_id);
if (!db || !*db) return;
ExpirationBaton *expiration_baton = new ExpirationBaton;
expiration_baton->db = db;
expiration_baton->path = path;
expiration_baton->expires = expires;
uv_worker_send(worker, expiration_baton, [](void *data) {
ExpirationBaton *baton = (ExpirationBaton *)data;
const std::string url = unifyMapboxURLs(baton->path);
Statement stmt = // 1 2
baton->db->prepare("UPDATE `http_cache` SET `expires` = ? WHERE `url` = ?");
stmt.bind<int64_t>(1, baton->expires);
stmt.bind(2, url.c_str());
stmt.run();
}, [](void *data) {
delete (ExpirationBaton *)data;
});
}
SQLRETURN SQLNumParams(SQLHSTMT stmt, SQLSMALLINT* paramCnt)
{
using odbc::Statement;
LOG_MSG("SQLNumParams called");
Statement *statement = reinterpret_cast<Statement*>(stmt);
if (!statement)
return SQL_INVALID_HANDLE;
if (paramCnt)
{
uint16_t paramNum = 0;
statement->GetParametersNumber(paramNum);
*paramCnt = static_cast<SQLSMALLINT>(paramNum);
}
return statement->GetDiagnosticRecords().GetReturnCode();
}
SQLRETURN SQLFreeStmt(SQLHSTMT stmt, SQLUSMALLINT option)
{
using odbc::Statement;
LOG_MSG("SQLFreeStmt called [option=" << option << ']');
Statement *statement = reinterpret_cast<Statement*>(stmt);
if (!statement)
return SQL_INVALID_HANDLE;
if (option == SQL_DROP)
{
delete statement;
return SQL_SUCCESS;
}
statement->FreeResources(option);
return statement->GetDiagnosticRecords().GetReturnCode();
}
/*****************************************************************************
* public method executeStatement
* - create a temporary local Statement
* - look at value of numTokens
* - if numTokens == 3, excute assignment statement
* - else if numtokens == 2, execute print statement
* - else, either execute lock, unlock or end depending on value of token
*
****************************************************************************/
void Program::executeStatement(int& semaphore)
{
Statement tempStatement = statementList.getItemVal(programCounter);
cout << "statement retrieved: " << tempStatement << endl;
if(tempStatement.getNumValues() == 3)
{
stringstream lValSS, rValSS;
char lValChar;
int lValInt, rValInt;
cout << "lValString = " << tempStatement.getLValue() << endl;
lValSS << tempStatement.getLValue(); // get left side of assignment
lValSS >> lValChar; // convert to int for array index
cout << "lValChar = " << lValChar << endl;
lValChar -= 'a';
lValInt = (int)lValChar;
cout << "lValInt = " << lValInt << endl;
rValSS << tempStatement.getRValue(); // get right side of assignment
rValSS >> rValInt; // convert to int for value
variables[lValInt] = rValInt; // assign the new value
cout << "new value = " << rValInt << endl;
}
std::vector<std::pair<bool, Block*>> Cssize::slice_by_bubble(Statement* b)
{
std::vector<std::pair<bool, Block*>> results;
for (size_t i = 0, L = b->block()->length(); i < L; ++i) {
Statement* value = (*b->block())[i];
bool key = value->statement_type() == Statement::BUBBLE;
if (!results.empty() && results.back().first == key)
{
Block* wrapper_block = results.back().second;
*wrapper_block << value;
}
else
{
Block* wrapper_block = SASS_MEMORY_NEW(ctx.mem, Block, value->pstate());
*wrapper_block << value;
results.push_back(std::make_pair(key, wrapper_block));
}
}
return results;
}
bool Writer::BlockTableExists()
{
std::ostringstream oss;
std::string block_table_name = getOptions().getValueOrThrow<std::string>("block_table_name");
char szTable[OWNAME]= "";
oss << "select table_name from user_tables";
log()->get(logDEBUG) << "checking for " << block_table_name << " existence ... " ;
Statement statement = Statement(m_connection->CreateStatement(oss.str().c_str()));
// Because of OCIGDALErrorHandler, this is going to throw if there is a
// problem. When it does, the statement should go out of scope and
// be destroyed without leaking.
statement->Define(szTable);
statement->Execute();
log()->get(logDEBUG) << "checking ... " << szTable ;
bool bDidRead(true);
while (bDidRead)
{
log()->get(logDEBUG) << ", " << szTable;
if (boost::iequals(szTable, block_table_name))
{
log()->get(logDEBUG) << " -- '" << block_table_name << "' found." <<std::endl;
return true;
}
bDidRead = statement->Fetch();
}
log()->get(logDEBUG) << " -- '" << block_table_name << "' not found." << std::endl;
return false;
}
/*!
* \brief データベースバージョン取得
*
* \return データベースバージョン
*/
int32_t SequenceLogServiceDB::getVersion() const
{
SLOG(CLS_NAME, "getVersion");
int32_t version = 0;
Statement* stmt = nullptr;
try
{
const char* sql = "select version from version_info";
stmt = newStatement();
stmt->prepare(sql);
stmt->setIntResult(0, &version);
stmt->bind();
stmt->execute();
stmt->fetch();
}
catch (Exception e)
{
// 初回起動時などテーブルが存在しない場合もあるので、
// 例外が発生しても何もすることはない
SMSG(slog::DEBUG, "%s", e.getMessage());
}
delete stmt;
return version;
}
bool operator == ( const Statement & s1, const Statement & s2 )
{
if( s1.type() == Statement::Word && s2.type() == Statement::Word )
return s1.word() == s2.word();
else
return s1.type() == s2.type();
}
std::vector<statement_output_variable_definition*>* Branch::getExposedVariableDefinitions()
{
std::vector<statement_output_variable_definition*>* vars = new std::vector<
statement_output_variable_definition*>();
for (std::map<std::string, Action*>::iterator iter = actionBranches->begin();
iter != actionBranches->end(); ++iter) {
Statement* nextStatement = iter->second->getNextStatement();
while (nextStatement) {
std::vector<statement_output_variable_definition*>* statementVars =
nextStatement->getExposedVariableDefinitions();
if (NULL != statementVars) {
vars->insert(vars->end(), statementVars->begin(), statementVars->end());
delete statementVars;
}
nextStatement = nextStatement->getNextStatement();
}
}
for (std::map<std::string, Trigger*>::iterator iter = triggerBranches->begin();
iter != triggerBranches->end(); ++iter) {
Statement* nextStatement = iter->second->getNextStatement();
while (nextStatement) {
std::vector<statement_output_variable_definition*>* statementVars =
nextStatement->getExposedVariableDefinitions();
if (NULL != statementVars) {
vars->insert(vars->end(), statementVars->begin(), statementVars->end());
delete statementVars;
}
nextStatement = nextStatement->getNextStatement();
}
}
return vars;
}
SQLRETURN SQLDescribeCol(SQLHSTMT stmt,
SQLUSMALLINT columnNum,
SQLCHAR* columnNameBuf,
SQLSMALLINT columnNameBufLen,
SQLSMALLINT* columnNameLen,
SQLSMALLINT* dataType,
SQLULEN* columnSize,
SQLSMALLINT* decimalDigits,
SQLSMALLINT* nullable)
{
using odbc::Statement;
using odbc::SqlLen;
LOG_MSG("SQLDescribeCol called");
Statement *statement = reinterpret_cast<Statement*>(stmt);
if (!statement)
return SQL_INVALID_HANDLE;
statement->GetColumnAttribute(columnNum, SQL_DESC_NAME,
reinterpret_cast<char*>(columnNameBuf), columnNameBufLen, columnNameLen, 0);
SqlLen dataTypeRes;
SqlLen columnSizeRes;
SqlLen decimalDigitsRes;
SqlLen nullableRes;
statement->GetColumnAttribute(columnNum, SQL_DESC_TYPE, 0, 0, 0, &dataTypeRes);
statement->GetColumnAttribute(columnNum, SQL_DESC_PRECISION, 0, 0, 0, &columnSizeRes);
statement->GetColumnAttribute(columnNum, SQL_DESC_SCALE, 0, 0, 0, &decimalDigitsRes);
statement->GetColumnAttribute(columnNum, SQL_DESC_NULLABLE, 0, 0, 0, &nullableRes);
LOG_MSG("columnNum: " << columnNum);
LOG_MSG("dataTypeRes: " << dataTypeRes);
LOG_MSG("columnSizeRes: " << columnSizeRes);
LOG_MSG("decimalDigitsRes: " << decimalDigitsRes);
LOG_MSG("nullableRes: " << nullableRes);
LOG_MSG("columnNameBuf: " << (columnNameBuf ? reinterpret_cast<const char*>(columnNameBuf) : "<null>"));
LOG_MSG("columnNameLen: " << (columnNameLen ? *columnNameLen : -1));
if (dataType)
*dataType = static_cast<SQLSMALLINT>(dataTypeRes);
if (columnSize)
*columnSize = static_cast<SQLULEN>(columnSizeRes);
if (decimalDigits)
*decimalDigits = static_cast<SQLSMALLINT>(decimalDigitsRes);
if (nullable)
*nullable = static_cast<SQLSMALLINT>(nullableRes);
return statement->GetDiagnosticRecords().GetReturnCode();
}
void Output_Nested::operator()(At_Rule* a)
{
string kwd = a->keyword();
Selector* s = a->selector();
Expression* v = a->value();
Block* b = a->block();
bool decls = false;
// indent();
append_to_buffer(kwd);
if (s) {
append_to_buffer(" ");
s->perform(this);
}
else if (v) {
append_to_buffer(" ");
v->perform(this);
}
if (!b) {
append_to_buffer(";");
return;
}
append_to_buffer(" {\n");
++indentation;
decls = true;
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
if (!stm->is_hoistable()) {
if (!stm->block()) indent();
stm->perform(this);
append_to_buffer("\n");
}
}
--indentation;
if (decls) ++indentation;
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
if (stm->is_hoistable()) {
stm->perform(this);
append_to_buffer("\n");
}
}
if (decls) --indentation;
buffer.erase(buffer.length()-1);
if (ctx) ctx->source_map.remove_line();
if (b->has_hoistable()) {
buffer.erase(buffer.length()-1);
if (ctx) ctx->source_map.remove_line();
}
append_to_buffer(" }\n");
}
void Output::operator()(Keyframe_Rule* r)
{
Block* b = r->block();
Selector* v = r->selector();
if (v) {
v->perform(this);
}
if (!b) {
append_colon_separator();
return;
}
append_scope_opener();
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
if (!stm->is_hoistable()) {
stm->perform(this);
if (i < L - 1) append_special_linefeed();
}
}
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
if (stm->is_hoistable()) {
stm->perform(this);
}
}
append_scope_closer();
}
//through the product info get the best channel to create order
//@return the channel num
int ChargeBusiness::SelectBestChannel(int value, int province, int op, vector<ChannelInfo>& channels){
int ret = 0;
Statement *stmt = NULL;
try{
stmt = conn->createStatement(SQL_SELECT_CHANNEL);
stmt->setInt(1, value); //product value
stmt->setInt(2, province); //provice of product
stmt->setInt(3, op); //operator of product
ResultSet *rs = stmt->executeQuery();
while(rs->next())
{
ChannelInfo channel;
channel.channelId = rs->getInt(1); //channel id
//channel.channelName = rs->getString(2); //channel name
channel.sname = rs->getString(2); //short name
channel.priority = rs->getInt(3); //priority
channel.repeat = rs->getInt(4); //repeat times
channel.discount = rs->getFloat(5); //discount of product
channel.interfaceName = rs->getString(6); //the interface of channel,through it to find the class to handle order
channel.pid = rs->getString(7); //the product id given by channel
channel.private_key = rs->getString(8); //the private key given by channel
channel.query_interval = rs->getInt(9); //query order interval
channels.push_back(channel);
ret++;
}
stmt->closeResultSet(rs);
}catch(std::exception &e){
HandleException(e);
ret = -1;
}
Finish();
if(stmt)
conn->terminateStatement(stmt);
return ret;
}
void StatementListVisitor::Visit(StatementList* list)
{
if (list == NULL) return;
const int32 n = list->Size();
for (int32 i = 0; i < n; i ++) {
Statement* statement = list->StatementAt(i);
GroupStatement group(statement);
if (group.IsOpenGroup()) {
BeginGroup(&group);
fLevel ++;
} else if (statement->IsValueStatement()) {
DoValue(statement);
} else if (statement->IsDefaultStatement()) {
DoDefault(statement);
} else if (statement->IsQueryStatement()) {
DoQuery(statement);
} else if (statement->IsParamStatement()) {
DoParam(statement);
}
StatementList* children = statement->GetChildren();
if (children != NULL) {
Visit(children);
}
// Close statements have been removed
if (group.IsOpenGroup()) {
fLevel --;
EndGroup(&group);
}
}
}
int ChargeBusiness::UpdateOrderStatus(TopupInfo *topupInfo){
int ret = 0;
Statement *stmt = NULL;
try{
int status = 0;
if(topupInfo->status == SUCCESS){
status = 1;
}else if(topupInfo->status == FAILED){
status = 2;
}
string ts;
get_time_now("%Y/%m/%d %H:%M:%S", ts);
int notify = topupInfo->notify;
stmt = conn->createStatement(SQL_UPDATE_STATUS);
stmt->setAutoCommit(false);
string tbOrderNo = topupInfo->qs_info.coopOrderNo;
stmt->setInt(1, status);
stmt->setInt(2, notify);
stmt->setString(3, ts);
stmt->setString(4, tbOrderNo);
stmt->executeUpdate();
}catch(SQLException &sqlExcp){
HandleException(sqlExcp);
ret = -1;
}catch(std::exception &e){
HandleException(e);
ret = -1;
}
Finish();
if(stmt)
conn->terminateStatement(stmt);
return ret;
}
int ChargeBusiness::NotifyOrder(TopupInfo *topupInfo){
int ret = 0;
Statement *stmt = NULL;
try{
string ts;
get_time_now("%Y/%m/%d %H:%M:%S", ts);
int notify = 1;
stmt = conn->createStatement(SQL_UPDATE_NOTIFY);
stmt->setAutoCommit(false);
string sysNo = topupInfo->qs_info.coopOrderNo;
stmt->setInt(1, topupInfo->notify);
stmt->setString(2, ts);
stmt->setString(3, sysNo);
stmt->executeUpdate();
}catch(SQLException &sqlExcp){
HandleException(sqlExcp);
ret = -1;
}catch(std::exception &e){
HandleException(e);
}
if(stmt)
conn->terminateStatement(stmt);
Finish();
return ret;
}
void Output_Compressed::operator()(At_Rule* a)
{
string kwd = a->keyword();
Selector* s = a->selector();
Block* b = a->block();
append_singleline_part_to_buffer(kwd);
if (s) {
append_singleline_part_to_buffer(" ");
s->perform(this);
}
if (!b) {
append_singleline_part_to_buffer(";");
return;
}
append_singleline_part_to_buffer("{");
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
if (!stm->is_hoistable()) {
stm->perform(this);
}
}
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
if (stm->is_hoistable()) {
stm->perform(this);
}
}
append_singleline_part_to_buffer("}");
}
void Output_Compressed::operator()(Ruleset* r)
{
Selector* s = r->selector();
Block* b = r->block();
if (s->has_placeholder()) return;
if (b->has_non_hoistable()) {
s->perform(this);
append_singleline_part_to_buffer("{");
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
if (!stm->is_hoistable()) {
stm->perform(this);
}
}
append_singleline_part_to_buffer("}");
}
if (b->has_hoistable()) {
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
if (stm->is_hoistable()) {
stm->perform(this);
}
}
}
}
void TypeCompiler::chunk(utArray<Statement *> *statements)
{
if (!statements)
{
return;
}
BC::enterLevel(cs);
for (unsigned int i = 0; i < statements->size(); i++)
{
Statement *statement = statements->at(i);
BC::lineNumber = statement->lineNumber;
statement->visitStatement(this);
cs->fs->freereg = cs->fs->nactvar; /* free registers */
}
BC::leaveLevel(cs);
}
/**
* displaying all the rows in the table
*/
void displayAllRows ()
{
string sqlStmt = "SELECT author_id, author_name FROM author_tab \
order by author_id";
stmt = conn->createStatement (sqlStmt);
ResultSet *rset = stmt->executeQuery ();
try{
while (rset->next ())
{
cout << "author_id: " << rset->getInt (1) << " author_name: "
<< rset->getString (2) << endl;
}
}catch(SQLException ex)
{
cout<<"Exception thrown for displayAllRows"<<endl;
cout<<"Error number: "<< ex.getErrorCode() << endl;
cout<<ex.getMessage() << endl;
}
stmt->closeResultSet (rset);
conn->terminateStatement (stmt);
}
pdal::SpatialReference OciReader::fetchSpatialReference(Statement stmt,
BlockPtr block) const
{
// Fetch the WKT for the SRID to set the coordinate system of this stage
int srid = stmt->GetInteger(&(block->pc->pc_geometry.sdo_srid));
if (srid)
{
std::ostringstream oss;
oss << "EPSG:" << srid;
return pdal::SpatialReference(oss.str());
}
return pdal::SpatialReference();
}
void Why3Translator::visitIndentedUnlessBlock(Statement const& _statement)
{
bool isBlock = !!dynamic_cast<Block const*>(&_statement);
if (isBlock)
newLine();
else
indent();
_statement.accept(*this);
if (isBlock)
newLine();
else
unindent();
}
Statement IteratorBase::getNextCloud(BlockPtr block, boost::int32_t& cloud_id)
{
std::ostringstream select_blocks;
BlockPtr cloud_block = m_reader.getBlock();
Statement cloud_statement = m_reader.getInitialQueryStatement();
cloud_id = cloud_statement->GetInteger(&cloud_block->pc->pc_id);
std::string cloud_table = std::string(cloud_statement->GetString(cloud_block->pc->blk_table));
select_blocks
<< "select T.OBJ_ID, T.BLK_ID, T.BLK_EXTENT, T.NUM_POINTS, T.POINTS from "
<< cloud_table << " T WHERE T.OBJ_ID = "
<< cloud_id;
Statement output = Statement(m_reader.getConnection()->CreateStatement(select_blocks.str().c_str()));
output->Execute(0);
m_reader.defineBlock(output, block);
return output;
}
// PRIVATE FUNCTIONS
// Case: Uses(s,v) - stmt wild, var wild
Results UsesClause::evaluateStmtWildVarWild() {
Results res = Results();
// set synonyms
res.setNumOfSyn(2);
res.setFirstClauseSyn(this->getFirstArg());
res.setSecondClauseSyn(this->getSecondArg());
// generate all possible combinations using stmtTable as reference
set<Statement*> allStmts = stmtTable->getAllStmts();
set<Statement*>::iterator stmtIter;
// iterate through stmt table
for(stmtIter=allStmts.begin(); stmtIter!=allStmts.end(); stmtIter++) {
Statement* currentStmt = *stmtIter;
// check if current stmt conforms to specific stmt type, if not, skip to next statement
if(!Utils::isSameType(this->firstArgType, currentStmt->getType())) {
continue;
}
// for each stmt generate result pair for vars that it uses
Statement::UsesSet currentUseSet = currentStmt->getUses();
Statement::UsesSet::iterator useIter;
for(useIter=currentUseSet.begin(); useIter!=currentUseSet.end(); useIter++) {
string stmtNum = lexical_cast<string>(currentStmt->getStmtNum());
string var = *useIter;
res.addPairResult(stmtNum, var);
}
}
// checks if result is empty
if(res.getPairResults().size() != 0) {
res.setClausePassed(true);
}
return res;
}
JsonObject *analyze(ParseTree *tree) {
functions_ = new (pool_) JsonList();
methodmaps_ = new (pool_) JsonList();
enums_ = new (pool_) JsonList();
constants_ = new (pool_) JsonList();
typesets_ = new (pool_) JsonList();
typedefs_ = new (pool_) JsonList();
for (size_t i = 0; i < tree->statements()->length(); i++) {
Statement *stmt = tree->statements()->at(i);
stmt->accept(this);
}
JsonObject *obj = new (pool_) JsonObject();
obj->add(cc_.add("functions"), functions_);
obj->add(cc_.add("methodmaps"), methodmaps_);
obj->add(cc_.add("enums"), enums_);
obj->add(cc_.add("constants"), constants_);
obj->add(cc_.add("typesets"), typesets_);
obj->add(cc_.add("typedefs"), typedefs_);
return obj;
}
