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;
}
