static void display_file(char **tab, char *option)
{
int j;
j = 0;
while (tab[j])
{
if ((IS_A_2 && !is_main(tab[j])) || IS_A || IS_F)
{
ft_putstr_name(tab[j++]);
if (IS_P && is_file_or_dir(tab[j - 1]) == 2)
ft_putchar('/');
ft_putchar('\n');
}
else if (!(is_hidden(tab[j])))
{
ft_putstr_name(tab[j++]);
if (IS_P && is_file_or_dir(tab[j - 1]) == 2)
ft_putchar('/');
ft_putchar('\n');
}
else
++j;
}
}
_static char *__setup_dvmstack(struct tls_info *tls, int **last_depth,
int **last_repeat, struct Method ***last_meth)
{
char *last_stack;
if (!tls)
return NULL;
last_stack = tls->dvmstack;
if (!last_stack) {
if (is_main())
last_stack = main_dvmstack;
else
last_stack = (char *)libc.malloc(TLS_DVM_STACK_SZ);
if (!last_stack)
return NULL;
libc.memset(last_stack, 0, TLS_DVM_STACK_SZ);
tls->dvmstack = last_stack;
}
*last_depth = dvmstk_last_depth(last_stack);
*last_repeat = dvmstk_repeat(last_stack);
*last_meth = dvmstk_metharr(last_stack);
return last_stack;
}
int max_group(char **tab, char *option)
{
int max;
t_stat *buf;
int j;
j = 0;
max = 0;
(!(buf = (t_stat*)malloc(sizeof(t_stat)))) ? perror_malloc() : 0;
while (tab[j])
{
if ((IS_A_2 && !is_main(tab[j]))
|| IS_A || IS_F || !(is_hidden(tab[j])))
{
init_buf(tab[j], &buf);
if ((int)ft_strlen(group_name(buf->st_gid)) > max)
max = ft_strlen(group_name(buf->st_gid));
}
++j;
}
ft_tstatdel(&buf);
return (max);
}
void jvmcodegen::gen_function_decl(const ast::node_ptr &node)
{
auto func = ast::to_function_decl(node);
auto curr_scope = m_stack.top();
auto& sym = curr_scope->get(func->name);
if (!sym.is_valid()) {
throw jvmcodegen_error(fmt::sprintf("%s simbolo nao encontrado!", func->name));
}
// empilha o escopo da função
m_stack.push(m_symtable->get_scope(sym.scope_id));
reset_locals();
reset_labels();
m_out << fmt::sprintf(".method public static ");
std::stringstream ss;
if (func->is_main()) {
m_out << fmt::sprintf("main([Ljava/lang/String;)V\n");
} else {
ss << fmt::sprintf("%s(", func->name);
for (size_t i = 0; i < func->arguments.size(); i++) {
auto arg = ast::to_argument(func->arguments[i]);
auto& asym = m_stack.top()->get(arg->name);
ss << fmt::sprintf("%s", jvm_type(asym.c_type()));
if (i != func->arguments.size() - 1)
ss << m_out << fmt::sprintf(",");
}
ss << fmt::sprintf(")%s", jvm_type(sym.type & ~types::function));
// salva a assinatura para realizar chamadas..
sym.signature = ss.str();
m_out << fmt::sprintf(ss.str());
m_out << fmt::sprintf("\n");
}
int locals = compute_locals(node);
if (func->is_main())
locals += 1;
m_out << fmt::sprintf(".limit locals %d\n", locals);
m_out << fmt::sprintf(".limit stack 15\n");
for (const auto& arg : func->arguments) {
gen_node(arg);
}
for (const auto& stmt : func->statements) {
gen_node(stmt);
}
m_stack.pop();
if (!func->is_main()) {
if (sym.c_type() == types::integer) {
m_out << fmt::sprintf("ireturn\n");
} else if (sym.c_type() == types::voidt) {
m_out << fmt::sprintf("return\n");
} else if (sym.c_type() == types::string) {
m_out << fmt::sprintf("areturn\n");
}
} else {
m_out << fmt::sprintf("return\n");
}
m_out << fmt::sprintf(".end method\n\n");
}
void NetQueryDispatcher::dispatch(NetQueryPtr net_query) {
net_query->debug("dispatch");
if (stop_flag_.load(std::memory_order_relaxed)) {
// Set error to avoid warning
// No need to send result somewhere, it probably will be ignored anyway
net_query->set_error(Status::Error(500, "Internal Server Error: closing"));
net_query->clear();
net_query.reset();
// G()->net_query_creator().release(std::move(net_query));
return;
}
if (net_query->is_ready()) {
if (net_query->is_error()) {
auto code = net_query->error().code();
if (code == 303) {
try_fix_migrate(net_query);
} else if (code == NetQuery::Resend) {
net_query->resend();
} else if (code < 0 || code == 500 || code == 420) {
net_query->debug("sent to NetQueryDelayer");
return send_closure(delayer_, &NetQueryDelayer::delay, std::move(net_query));
}
}
}
if (!net_query->is_ready()) {
if (net_query->dispatch_ttl == 0) {
net_query->set_error(Status::Error("DispatchTtlError"));
}
}
auto dest_dc_id = net_query->dc_id();
if (dest_dc_id.is_main()) {
dest_dc_id = DcId::internal(main_dc_id_.load(std::memory_order_relaxed));
}
if (!net_query->is_ready() && wait_dc_init(dest_dc_id, true).is_error()) {
net_query->set_error(Status::Error(PSLICE() << "No such dc " << dest_dc_id));
}
if (net_query->is_ready()) {
auto callback = net_query->move_callback();
if (callback.empty()) {
net_query->debug("sent to td (no callback)");
send_closure(G()->td(), &NetQueryCallback::on_result, std::move(net_query));
} else {
net_query->debug("sent to callback", true);
send_closure(std::move(callback), &NetQueryCallback::on_result, std::move(net_query));
}
return;
}
if (net_query->dispatch_ttl > 0) {
net_query->dispatch_ttl--;
}
size_t dc_pos = static_cast<size_t>(dest_dc_id.get_raw_id() - 1);
CHECK(dc_pos < dcs_.size());
switch (net_query->type()) {
case NetQuery::Type::Common:
net_query->debug(PSTRING() << "sent to main session multi proxy " << dest_dc_id);
send_closure_later(dcs_[dc_pos].main_session_, &SessionMultiProxy::send, std::move(net_query));
break;
case NetQuery::Type::Upload:
net_query->debug(PSTRING() << "sent to upload session multi proxy " << dest_dc_id);
send_closure_later(dcs_[dc_pos].upload_session_, &SessionMultiProxy::send, std::move(net_query));
break;
case NetQuery::Type::Download:
net_query->debug(PSTRING() << "sent to download session multi proxy " << dest_dc_id);
send_closure_later(dcs_[dc_pos].download_session_, &SessionMultiProxy::send, std::move(net_query));
break;
case NetQuery::Type::DownloadSmall:
net_query->debug(PSTRING() << "sent to download small session multi proxy " << dest_dc_id);
send_closure_later(dcs_[dc_pos].download_small_session_, &SessionMultiProxy::send, std::move(net_query));
break;
}
}
