struct DEBRUIJN * term_to_debruijn (struct TERM * term, struct STACK * stack) { TRACE("term_to_debruijn"); struct DEBRUIJN * debruijn; debruijn = malloc (sizeof (struct DEBRUIJN)); switch (term->type) { case TYPE_TERM_INTEGER : { TRACE("integer") debruijn->type = TYPE_DEBRUIJN_INTEGER; debruijn->integer.value = term->integer.value; break; } case TYPE_TERM_VARIABLE : { TRACE("variable") debruijn->type = TYPE_DEBRUIJN_VARIABLE; int pos = get_stack_position (stack, term->variable.value); debruijn->variable.value = pos; break; } case TYPE_TERM_QUOTE : { TRACE("quote") debruijn->type = TYPE_DEBRUIJN_QUOTE; debruijn->quote.value = term_to_debruijn (term->quote.content, NULL); // TODO: NULL stack ? break; } case TYPE_TERM_ABSTRACTION : { TRACE("abstraction") debruijn->type = TYPE_DEBRUIJN_ABSTRACTION; debruijn->abstraction.body = term_to_debruijn (term->abstraction.body, set_stack (stack, term->abstraction.variable, NULL)); break; } case TYPE_TERM_CLOSURE : { TRACE("closure") debruijn->type = TYPE_DEBRUIJN_CLOSURE; debruijn->closure.body = term_to_debruijn (term->closure.body, set_stack (stack, term->closure.variable, NULL)); debruijn->closure.stack = NULL; // TODO: env to stack :/ break; } case TYPE_TERM_APPLICATION : { TRACE("application") debruijn->type = TYPE_DEBRUIJN_APPLICATION; debruijn->application.left = term_to_debruijn (term->application.left, stack); debruijn->application.right = term_to_debruijn (term->application.right, stack); break; } case TYPE_TERM_LET : { TRACE("let") struct DEBRUIJN * abstraction; abstraction = malloc (sizeof (struct DEBRUIJN)); abstraction->type = TYPE_DEBRUIJN_ABSTRACTION; abstraction->abstraction.body = term_to_debruijn (term->let.body, set_stack (stack, term->let.variable, NULL)); debruijn->type = TYPE_DEBRUIJN_APPLICATION; debruijn->application.left = abstraction; debruijn->application.right = term_to_debruijn (term->let.init, stack); break; } } return debruijn; }
struct TERM * debruijn_to_term (struct DEBRUIJN * debruijn, struct STACK * stack) { switch (debruijn->type) { case TYPE_DEBRUIJN_INTEGER : { TRACE("integer"); return make_term_integer(debruijn->integer.value); break; } case TYPE_DEBRUIJN_VARIABLE : { TRACE("variable"); struct STACK * v = get_stack (stack, debruijn->variable.value); return make_term_variable (v->ident); break; } case TYPE_DEBRUIJN_QUOTE : { TRACE("quote"); return make_term_quote (debruijn_to_term (debruijn->quote.value, make_stack())); break ; } case TYPE_DEBRUIJN_ABSTRACTION : { TRACE("abstraction"); char * var = gen_ident(); struct STACK * s = set_stack(stack, var, NULL); // We just want to get ident return make_term_abstraction (var,debruijn_to_term(debruijn->abstraction.body, s)); break ; } case TYPE_DEBRUIJN_CLOSURE : { TRACE("closure"); char * var = gen_ident(); struct STACK * s = set_stack(stack, var, NULL); // We just want to get ident return make_term_closure (var,debruijn_to_term(debruijn->abstraction.body, s), NULL); // Shouldn't be NULL. Should be stack->env transformation break ; } case TYPE_DEBRUIJN_APPLICATION : { TRACE("application"); return make_term_application(debruijn_to_term(debruijn->application.left, stack), debruijn_to_term(debruijn->application.right, stack)); break; } default:{ fprintf(stderr, "Unknown debruijn term type\n"); exit(1); } } }
static void _WCINTERRUPT _WCFAR __int_ctrl_break_handler( void ) { #if defined( __386__ ) unsigned save_stacklow; void _WCFAR *save_stack; save_stack = set_stack( &(my_stack[(sizeof(my_stack)-sizeof(my_stack[0]))]) ); save_stacklow = _STACKLOW; _STACKLOW = (unsigned)&my_stack; #endif if(( _RWD_child == 0 ) && ( __int23_exit != __null_int23_exit ) && ( __int23_exit != __restore_int23 )) { _enable(); raise( SIGBREAK ); } else { _chain_intr( __old_int_ctrl_break ); } #if defined( __386__ ) set_stack( save_stack ); _STACKLOW = save_stacklow; #endif }
struct DEBRUIJN * eval_debruijn (struct DEBRUIJN * debruijn, struct STACK * stack) { switch (debruijn->type) { case TYPE_DEBRUIJN_INTEGER : { TRACE("integer"); return debruijn; break; } case TYPE_DEBRUIJN_VARIABLE : { TRACE("variable"); return get_stack (stack, debruijn->variable.value)->debruijn; break; } case TYPE_DEBRUIJN_QUOTE : { TRACE("quote"); return debruijn->quote.value; break ; } case TYPE_DEBRUIJN_ABSTRACTION : { TRACE("abstraction"); return make_debruijn_closure (debruijn->abstraction.body, stack); break ; } case TYPE_DEBRUIJN_CLOSURE : { TRACE("closure"); return debruijn; break ; } case TYPE_DEBRUIJN_APPLICATION : { TRACE("application"); struct DEBRUIJN * v = eval_debruijn (debruijn->application.left, stack); switch (v->type) { case TYPE_DEBRUIJN_CLOSURE : { return eval_debruijn (v->closure.body, set_stack (v->closure.stack, gen_ident(), eval_debruijn (debruijn->application.right, stack))); } default : { fprintf(stderr, "Not a debruijn closure\n"); exit(1); }} }} }
void show_server_info_dialog(Gtk::Window& w, Glib::ustring game_v, Glib::ustring host_v, Server data, std::function<void()> cb_launch) { PlayerListModelColumns player_list_columns; RuleListModelColumns rule_list_columns; // Set models auto game = Gtk::manage(new Gtk::Label(game_v)); game->set_halign(Gtk::Align::ALIGN_START); auto host = Gtk::manage(new Gtk::Label(host_v)); host->set_halign(Gtk::Align::ALIGN_START); auto name = Gtk::manage(new Gtk::Label); name->set_halign(Gtk::Align::ALIGN_START); auto terrain = Gtk::manage(new Gtk::Label); terrain->set_halign(Gtk::Align::ALIGN_START); auto ping = Gtk::manage(new Gtk::Label); ping->set_halign(Gtk::Align::ALIGN_START); auto players = Gtk::manage(new Gtk::Label); players->set_halign(Gtk::Align::ALIGN_START); set_label_from_optional(name, data.name); set_label_from_optional(terrain, data.terrain); set_label_from_optional(ping, data.ping); try { players->set_text(Glib::ustring::compose("%1 / %2", data.player_count.value(), data.player_limit.value())); } catch (const std::experimental::bad_optional_access&) {} auto player_list = Gtk::ListStore::create(player_list_columns); for (auto v : data.players) { auto& row = *player_list->append(); row[player_list_columns.name] = v.name; try { row[player_list_columns.ping] = std::stoi(v.info.at("ping")); } catch (...) {} try { row[player_list_columns.score] = std::stoi(v.info.at("score")); } catch (...) {} } auto rule_list = Gtk::ListStore::create(rule_list_columns); for (auto v : data.rules) { auto& row = *rule_list->append(); row[rule_list_columns.key] = v.first; row[rule_list_columns.value] = v.second; } // Create presentation auto server_info_data_grid = Gtk::manage(new Gtk::Grid); server_info_data_grid->set_row_spacing(5); server_info_data_grid->set_column_spacing(5); { auto i = -1; auto name_label = Gtk::manage(new Gtk::Label); name_label->set_markup("<b>Name:</b>"); name_label->set_halign(Gtk::Align::ALIGN_END); server_info_data_grid->attach(*name_label, 0, i++, 1, 1); server_info_data_grid->attach_next_to(*name, *name_label, Gtk::PositionType::POS_RIGHT, 1, 1); auto host_label = Gtk::manage(new Gtk::Label); host_label->set_markup("<b>Host:</b>"); host_label->set_halign(Gtk::Align::ALIGN_END); server_info_data_grid->attach(*host_label, 0, i++, 1, 1); server_info_data_grid->attach_next_to(*host, *host_label, Gtk::PositionType::POS_RIGHT, 1, 1); auto game_label = Gtk::manage(new Gtk::Label); game_label->set_markup("<b>Game:</b>"); game_label->set_halign(Gtk::Align::ALIGN_END); server_info_data_grid->attach(*game_label, 0, i++, 1, 1); server_info_data_grid->attach_next_to(*game, *game_label, Gtk::PositionType::POS_RIGHT, 1, 1); auto terrain_label = Gtk::manage(new Gtk::Label); terrain_label->set_markup("<b>Terrain:</b>"); terrain_label->set_halign(Gtk::Align::ALIGN_END); server_info_data_grid->attach(*terrain_label, 0, i++, 1, 1); server_info_data_grid->attach_next_to(*terrain, *terrain_label, Gtk::PositionType::POS_RIGHT, 1, 1); auto players_label = Gtk::manage(new Gtk::Label); players_label->set_markup("<b>Players:</b>"); players_label->set_halign(Gtk::Align::ALIGN_END); server_info_data_grid->attach(*players_label, 0, i++, 1, 1); server_info_data_grid->attach_next_to(*players, *players_label, Gtk::PositionType::POS_RIGHT, 1, 1); auto ping_label = Gtk::manage(new Gtk::Label); ping_label->set_markup("<b>Ping:</b>"); ping_label->set_halign(Gtk::Align::ALIGN_END); server_info_data_grid->attach(*ping_label, 0, i++, 1, 1); server_info_data_grid->attach_next_to(*ping, *ping_label, Gtk::PositionType::POS_RIGHT, 1, 1); } auto player_list_view = Gtk::manage(new Gtk::TreeView(player_list)); { auto col = Gtk::manage(new Gtk::TreeViewColumn("Name")); col->pack_start(player_list_columns.name); player_list_view->append_column(*col); } { auto col = Gtk::manage(new Gtk::TreeViewColumn("Score")); col->pack_start(player_list_columns.score); player_list_view->append_column(*col); } { auto col = Gtk::manage(new Gtk::TreeViewColumn("Ping")); col->pack_start(player_list_columns.ping); player_list_view->append_column(*col); } auto player_list_sw = Gtk::manage(new Gtk::ScrolledWindow); player_list_sw->set_hexpand(true); player_list_sw->set_vexpand(true); player_list_sw->add(*player_list_view); auto server_info_grid = Gtk::manage(new Gtk::Grid); server_info_grid->set_row_spacing(10); { auto i = -1; server_info_grid->attach(*server_info_data_grid, 0, i++, 1, 1); server_info_grid->attach(*player_list_sw, 0, i++, 1, 1); } // Server rules auto rule_list_view = Gtk::manage(new Gtk::TreeView(rule_list)); { auto col = Gtk::manage(new Gtk::TreeViewColumn("Key")); col->pack_start(rule_list_columns.key); rule_list_view->append_column(*col); } { auto col = Gtk::manage(new Gtk::TreeViewColumn("Value")); col->pack_start(rule_list_columns.value); rule_list_view->append_column(*col); } auto server_rules_sw = Gtk::manage(new Gtk::ScrolledWindow); server_rules_sw->add(*rule_list_view); // The stack auto stack = Gtk::manage(new Gtk::Stack); stack->property_margin().set_value(10); stack->add(*server_info_grid, "info", "Information"); stack->add(*server_rules_sw, "rules", "Rules"); auto stack_switcher = Gtk::manage(new Gtk::StackSwitcher); stack_switcher->set_stack(*stack); stack_switcher->set_halign(Gtk::Align::ALIGN_CENTER); // The dialog Gtk::Dialog dialog_window("Server info", w); auto content = dialog_window.get_content_area(); content->pack_start(*stack_switcher, Gtk::PackOptions::PACK_SHRINK); content->pack_start(*stack); auto connect_button = dialog_window.add_button("Connect", 0); auto close_button = dialog_window.add_button("Close", 0); connect_button->signal_clicked().connect([&dialog_window, cb_launch]() { try { cb_launch(); } catch (const std::bad_function_call&) {} }); dialog_window.show_all(); dialog_window.run(); }
int vm_space_create_stack(vm_space_t *vs, void *_addr, vm_size_t s) { vm_addr_t *addr = _addr; return set_stack(vs, vs->seg_stack, vs->seg_data, addr, s); }
// Push an exception in the canonical position for handlers (stack(0)). void push_ex_oop(Node* ex_oop) { ensure_stack(1); // ensure room to push the exception set_stack(0, ex_oop); set_sp(1); clean_stack(1); }
size_t json_parser_execute (json_parser *parser, const char *data, size_t len, size_t depth) { char c, ch; const char *p = data, *pe; enum state state = parser->state; size_t stack_size = parser->stack_size; unsigned char *stack = parser->stack; for (p=data, pe=data+len; p != pe; p++) { ch = *p; /* skip ws */ switch (state) { case s_start_value: case s_separator_or_end: case s_start_key_string: case s_eof: case s_colon: if (WS(ch)) continue; default: break; } switch (state) { case s_start_value: /* start of a strings */ if (ch == '"') { state = s_string; break; } /* start of a number */ if (ch == 0x2D) { state = s_start_int; CALLBACK2(minus); break; } if (ch == '0') { MARK; state = s_start_frac_or_exp; break; } if (ch >= '1' && ch <= '9') { MARK; state = s_int; break; } /* start of an array */ if (ch == '[') { CHECK_DEPTH; set_stack(stack, stack_size++, ss_array); state = s_start_value; CALLBACK2(array_begin); break; } /* start of an object */ if (ch == '{') { CHECK_DEPTH; set_stack(stack, stack_size++, ss_object); state = s_start_key_string; CALLBACK2(object_begin); break; } goto error; end_of_value: if (stack_size == 1) { state = s_eof; if (WS(ch)) { break; } goto error; } else { state = s_separator_or_end; } if (WS(ch)) { break; } case s_separator_or_end: if (get_stack(stack, stack_size-1) == ss_array && ch == ',') { CALLBACK2(separator); state = s_start_value; break; } if ((get_stack(stack, stack_size-1) == ss_array && ch == ']') || (get_stack(stack, stack_size-1) == ss_object && ch == '}')) { CALLBACK2(end); --stack_size; if (stack_size == 1) { state = s_eof; } break; } if (get_stack(stack, stack_size-1) == ss_object && ch == ',') { CALLBACK2(separator); state = s_start_key_string; break; } if (stack_size == 1 && WS(ch)) { state = s_eof; break; } goto error; case s_string: if (ch == '"') { CALLBACK(string); state = s_separator_or_end; break; } break; case s_start_int: if (ch == '0') { MARK; state = s_start_frac_or_exp; break; } if (ch >= '1' && ch <= '9') { MARK; state = s_int; break; } goto error; case s_int: if (ch >= '0' && ch <= '9') { break; } CALLBACK(int); if (ch == '.') { state = s_frac; break; } if (ch == 'e') { state = s_exp; break; } goto end_of_value; case s_start_frac_or_exp: CALLBACK(int); if (ch == '.') { state = s_frac; break; } if (ch == 'e') { state = s_exp; break; } goto end_of_value; case s_frac: if (! parser->data_mark && ch <= '0' && ch >= '9') { goto error; } if (ch >= '0' && ch <= '9') { if (! parser->data_mark) MARK; break; } CALLBACK(frac); if (ch == 'e') { state = s_start_exp; break; } goto end_of_value; case s_start_exp: if (ch == '-' || ch == '+') { MARK; state = s_exp; break; } goto error; case s_exp: if (! parser->data_mark && ch <= '0' && ch >= '9') { goto error; } if (ch >= '0' && ch <= '9') { break; } CALLBACK(exp); goto end_of_value; case s_start_key_string: if (ch == '"') { state = s_key_string; break; } goto error; case s_key_string: if (! parser->data_mark) { MARK; } if (ch == '"') { CALLBACK(string); state = s_colon; break; } break; case s_colon: if (ch == ':') { CALLBACK2(separator); state = s_start_value; break; } goto error; case s_eof: goto error; default: goto error; } } switch (state) { case s_key_string: case s_string: CALLBACK(string); break; case s_int: case s_start_frac_or_exp: CALLBACK(int); break; case s_frac: CALLBACK(frac); break; case s_exp: CALLBACK(exp); break; } parser->state = state; parser->stack_size = stack_size; return len; error: parser->state = state; return (p - data); }
CodeBlock* GlobalEntry::codeGen(){ CodeBlock* main_block = new CodeBlock(); //--------------Init stack and base pointers-------------- ICode set_stack(ICode::ICodeType::MOVI,new Value(0,Type::TypeTag::UINT),&MemoryMgr::stackPointerRegister()); ICode set_base(ICode::ICodeType::MOVI,new Value(0,Type::TypeTag::UINT),&MemoryMgr::basePointerRegister()); main_block->append(set_stack); main_block->append(set_base); //----------------------Declarations---------------------- //Loops over all declarations SymTab* st = this->symTab(); //Separates FunctionEntries from the other types vector<CodeBlock*> function_blocks; vector<CodeBlock*> other_blocks; for(SymTab::iterator i = st->begin(); i != st->end(); ++i){ CodeBlock* cb = (*i)->codeGen(); if((*i)->kind() == SymTabEntry::Kind::FUNCTION_KIND){ function_blocks.push_back(cb); } else { other_blocks.push_back(cb); } } for(unsigned int x = 0; x < other_blocks.size();++x){ main_block->append(other_blocks[x]); } ICode jmp_start(ICode::ICodeType::JMP,parse_label_); main_block->append(jmp_start); for(unsigned int x = 0; x < function_blocks.size();++x){ main_block->append(function_blocks[x]); } //---------------------Event Matching--------------------- // Reads in character CodeBlock* input_block = new CodeBlock(); ICode read_in(ICode::ICodeType::IN,&in_reg_); //If negative, then reached end of file ICode* check_neg = new ICode(ICode::ICodeType::GT,new Value(0,Type::TypeTag::INT),&in_reg_); ICode end_jmp(ICode::ICodeType::JMPC,check_neg,end_label_); input_block->append(read_in); input_block->append(end_jmp); input_block->setStartLabel(parse_label_); CodeBlock* rule_block; // Named rules for(unsigned int i = 0; i < rule_names_.size(); ++i){ rule_block = new CodeBlock(); // Moves the string constant to the register ICode mov_string(ICode::ICodeType::MOVI,new Value((int)(rule_names_[i].at(0)),Type::TypeTag::INT),&comp_reg_); // Comparison ICode* compare = new ICode(ICode::ICodeType::EQ,&comp_reg_,&in_reg_); //Conditionally jumps ICode jmpc(ICode::ICodeType::JMPC,compare,rule_labels_[i]); rule_block->append(mov_string); rule_block->append(jmpc); rule_block->setEndLabel(rule_return_labels_[i]); input_block->append(rule_block); } // "Any" rules for(unsigned int i = 0; i < any_labels_.size(); ++i){ rule_block = new CodeBlock(); //Jumps to any rule body ICode jmp(ICode::ICodeType::JMP,any_labels_[i]); rule_block->append(jmp); rule_block->setEndLabel(any_return_labels_[i]); input_block->append(rule_block); } input_block->append(jmp_start); main_block->append(input_block); //------------------------Rules------------------------ //Loops over all Rules for(unsigned int x = 0; x < rules_.size();++x){ main_block->append(rules_[x]->codeGen()); } //---------------------End program--------------------- //Do the end jump here CodeBlock* end_block = new CodeBlock(); ICode print_end(ICode::ICodeType::PRTS,new Value("PROGRAM END\\n")); end_block->setStartLabel(end_label_); end_block->append(print_end); main_block->append(end_block); return main_block; }