Rim/gsc-tool
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 3 Wiki Activity

slash paths and compound stmt

Browse Source
This commit is contained in:
xensik 2023-01-24 12:53:39 +01:00
parent 775702323a
commit e4e884d110
14 changed files with 1374 additions and 1282 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
gen/gsc/parser.ypp
View File

@ -162,7 +162,7 @@ namespace xsk::gsc
%type <stmt_list::ptr> stmt_list
%type <stmt_list::ptr> stmt_or_dev_list
%type <stmt_dev::ptr> stmt_dev
%type <stmt_list::ptr> stmt_block
%type <stmt_comp::ptr> stmt_comp
%type <stmt_expr::ptr> stmt_expr
%type <stmt_call::ptr> stmt_call
%type <stmt_assign::ptr> stmt_assign
@ -310,12 +310,12 @@ decl_usingtree
;
decl_function
: expr_identifier LPAREN expr_parameters RPAREN stmt_block
: expr_identifier LPAREN expr_parameters RPAREN stmt_comp
{ lexer.ban_header(@$); $$ = make_decl_function(@$, std::move($1), std::move($3), std::move($5)); }
;
stmt
: stmt_block { $$.as_list = std::move($1); }
: stmt_comp { $$.as_comp = std::move($1); }
| stmt_call { $$.as_call = std::move($1); }
| stmt_assign { $$.as_assign = std::move($1); }
| stmt_endon { $$.as_endon = std::move($1); }
@ -366,9 +366,9 @@ stmt_dev
| DEVBEGIN DEVEND { $$ = make_stmt_dev(@$, make_stmt_list(@$)); }
;
stmt_block
: LBRACE stmt_or_dev_list RBRACE { $$ = std::move($2); }
| LBRACE RBRACE { $$ = make_stmt_list(@$); }
stmt_comp
: LBRACE stmt_or_dev_list RBRACE { $$ = make_stmt_comp(@$, std::move($2)); }
| LBRACE RBRACE { $$ = make_stmt_comp(@$, make_stmt_list(@$)); }
;
stmt_expr
@ -481,7 +481,7 @@ stmt_foreach
;
stmt_switch
: SWITCH LPAREN expr RPAREN stmt_block
: SWITCH LPAREN expr RPAREN stmt_comp
{ $$ = make_stmt_switch(@$, std::move($3), std::move($5));
parse_switch(*$$);
}
@ -930,14 +930,14 @@ void parser::error(location const& loc, std::string const& msg)
auto parse_switch(stmt_switch& stm) -> void
{
auto body = make_stmt_list(stm.body->loc());
auto body = make_stmt_list(stm.body->block->loc());
auto current_case = stmt{ nullptr };
auto num = stm.body->list.size();
auto num = stm.body->block->list.size();
for (auto i = 0u; i < num; i++)
{
auto& entry = stm.body->list[0];
auto& entry = stm.body->block->list[0];
if (entry == node::stmt_case || entry == node::stmt_default)
{
@ -946,8 +946,8 @@ auto parse_switch(stmt_switch& stm) -> void
body->list.push_back(std::move(current_case));
}
current_case = std::move(stm.body->list[0]);
stm.body->list.erase(stm.body->list.begin());
current_case = std::move(stm.body->block->list[0]);
stm.body->block->list.erase(stm.body->block->list.begin());
}
else
{
@ -956,12 +956,12 @@ auto parse_switch(stmt_switch& stm) -> void
if (current_case == node::stmt_case)
{
current_case.as_case->body->list.push_back(std::move(entry));
stm.body->list.erase(stm.body->list.begin());
stm.body->block->list.erase(stm.body->block->list.begin());
}
else
{
current_case.as_default->body->list.push_back(std::move(entry));
stm.body->list.erase(stm.body->list.begin());
stm.body->block->list.erase(stm.body->block->list.begin());
}
}
else
@ -976,7 +976,7 @@ auto parse_switch(stmt_switch& stm) -> void
body->list.push_back(std::move(current_case));
}
stm.body = std::move(body);
stm.body->block = std::move(body);
}
} // namespace xsk::gsc

4
gen/t6/parser.ypp
View File

@ -967,7 +967,9 @@ expr_identifier
;
expr_path
: IDENTIFIER
: PATH DIV IDENTIFIER
{ $$ = std::make_unique<ast::expr_path>(@$, $1 + "/" + $3); };
| IDENTIFIER
{ $$ = std::make_unique<ast::expr_path>(@$, $1); };
| PATH
{ $$ = std::make_unique<ast::expr_path>(@$, $1); };

36
src/gsc/compiler.cpp
View File

@ -123,7 +123,7 @@ auto compiler::emit_decl_function(decl_function const& func) -> void
auto& scp = scopes_.at(func.body.get());
emit_expr_parameters(*func.params, *scp);
emit_stmt_list(*func.body, *scp, true);
emit_stmt_comp(*func.body, *scp, true);
emit_opcode(opcode::OP_End);
function_->size = index_ - function_->index;
@ -137,6 +137,9 @@ auto compiler::emit_stmt(stmt const& stm, scope& scp, bool last) -> void
case node::stmt_list:
emit_stmt_list(*stm.as_list, scp, last);
break;
case node::stmt_comp:
emit_stmt_comp(*stm.as_comp, scp, last);
break;
case node::stmt_dev:
emit_stmt_dev(*stm.as_dev, scp, last);
break;
@ -228,9 +231,14 @@ auto compiler::emit_stmt_list(stmt_list const& stm, scope& scp, bool last) -> vo
}
}
auto compiler::emit_stmt_comp(stmt_comp const& stm, scope& scp, bool last) -> void
{
emit_stmt_list(*stm.block, scp, last);
}
auto compiler::emit_stmt_dev(stmt_dev const& stm, scope& scp, bool last) -> void
{
emit_stmt_list(*stm.body, scp, last);
emit_stmt_list(*stm.block, scp, last);
}
auto compiler::emit_stmt_expr(stmt_expr const& stm, scope& scp) -> void
@ -754,16 +762,16 @@ auto compiler::emit_stmt_switch(stmt_switch const& stm, scope& scp) -> void
can_break_ = true;
auto data = std::vector<std::string>{};
data.push_back(fmt::format("{}", stm.body->list.size()));
data.push_back(fmt::format("{}", stm.body->block->list.size()));
auto type = switch_type::none;
auto loc_default = std::string{};
auto has_default = false;
scope* default_ctx = nullptr;
for (auto i = 0u; i < stm.body->list.size(); i++)
for (auto i = 0u; i < stm.body->block->list.size(); i++)
{
auto const& entry = stm.body->list[i];
auto const& entry = stm.body->block->list[i];
if (entry == node::stmt_case)
{
@ -860,7 +868,7 @@ auto compiler::emit_stmt_switch(stmt_switch const& stm, scope& scp) -> void
emit_opcode(opcode::OP_endswitch, data);
auto offset = static_cast<u32>(((ctx_->engine() == engine::iw9) ? 8 : 7) * stm.body->list.size());
auto offset = static_cast<u32>(((ctx_->engine() == engine::iw9) ? 8 : 7) * stm.body->block->list.size());
function_->instructions.back()->size += offset;
index_ += offset;
@ -2258,7 +2266,7 @@ auto compiler::process_function(decl_function const& func) -> void
auto& scp_body = ins.first->second;
process_expr_parameters(*func.params, *scp_body);
process_stmt_list(*func.body, *scp_body);
process_stmt_comp(*func.body, *scp_body);
}
auto compiler::process_stmt(stmt const& stm, scope& scp) -> void
@ -2268,6 +2276,9 @@ auto compiler::process_stmt(stmt const& stm, scope& scp) -> void
case node::stmt_list:
process_stmt_list(*stm.as_list, scp);
break;
case node::stmt_comp:
process_stmt_comp(*stm.as_comp, scp);
break;
case node::stmt_dev:
process_stmt_dev(*stm.as_dev, scp);
break;
@ -2336,9 +2347,14 @@ auto compiler::process_stmt_list(stmt_list const& stm, scope& scp) -> void
}
}
auto compiler::process_stmt_comp(stmt_comp const& stm, scope& scp) -> void
{
process_stmt_list(*stm.block, scp);
}
auto compiler::process_stmt_dev(stmt_dev const& stm, scope& scp) -> void
{
process_stmt_list(*stm.body, scp);
process_stmt_list(*stm.block, scp);
}
auto compiler::process_stmt_expr(stmt_expr const& stm, scope& scp) -> void
@ -2607,9 +2623,9 @@ auto compiler::process_stmt_switch(stmt_switch const& stm, scope& scp) -> void
auto old_breaks = break_blks_;
break_blks_.clear();
for (auto i = 0u; i < stm.body->list.size(); i++)
for (auto i = 0u; i < stm.body->block->list.size(); i++)
{
auto& entry = stm.body->list[i];
auto& entry = stm.body->block->list[i];
if (entry == node::stmt_case)
{

2
src/gsc/compiler.hpp
View File

@ -40,6 +40,7 @@ private:
auto emit_decl_function(decl_function const& func) -> void;
auto emit_stmt(stmt const& stm, scope& scp, bool last) -> void;
auto emit_stmt_list(stmt_list const& stm, scope& scp, bool last) -> void;
auto emit_stmt_comp(stmt_comp const& stm, scope& scp, bool last) -> void;
auto emit_stmt_dev(stmt_dev const& stm, scope& scp, bool last) -> void;
auto emit_stmt_expr(stmt_expr const& stm, scope& scp) -> void;
auto emit_stmt_call(stmt_call const& stm, scope& scp) -> void;
@ -119,6 +120,7 @@ private:
auto process_function(decl_function const& func) -> void;
auto process_stmt(stmt const& stm, scope& scp) -> void;
auto process_stmt_list(stmt_list const& stm, scope& scp) -> void;
auto process_stmt_comp(stmt_comp const& stm, scope& scp) -> void;
auto process_stmt_dev(stmt_dev const& stm, scope& scp) -> void;
auto process_stmt_expr(stmt_expr const& stm, scope& scp) -> void;
auto process_stmt_assign(stmt_assign const& stm, scope& scp) -> void;

170
src/gsc/decompiler.cpp
View File

@ -39,7 +39,7 @@ auto decompiler::decompile_function(function const& func) -> void
auto loc = location{ nullptr, static_cast<location::counter_type>(func.index) };
auto name = make_expr_identifier(loc, func.name);
auto prms = make_expr_parameters(loc);
auto body = make_stmt_list(loc);
auto body = make_stmt_comp(loc, make_stmt_list(loc));
func_ = make_decl_function(loc, std::move(name), std::move(prms), std::move(body));
for (auto const& inst : func.instructions)
@ -53,10 +53,10 @@ auto decompiler::decompile_function(function const& func) -> void
}
locs_.last = true;
locs_.end = func_->body->list.back().label();
func_->body->list.pop_back();
locs_.end = func_->body->block->list.back().label();
func_->body->block->list.pop_back();
decompile_statements(*func_->body);
decompile_statements(*func_->body->block);
process_function(*func_);
program_->declarations.push_back(decl{ move(func_) });
@ -72,13 +72,13 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
{
case opcode::OP_End:
{
func_->body->list.push_back(stmt{ make_stmt_return(loc, expr{ make_node(loc) }) });
func_->body->block->list.push_back(stmt{ make_stmt_return(loc, expr{ make_node(loc) }) });
break;
}
case opcode::OP_Return:
{
auto value = expr{ std::move(stack_.top()) }; stack_.pop();
func_->body->list.push_back(stmt{ make_stmt_return(value.loc(), std::move(value)) });
func_->body->block->list.push_back(stmt{ make_stmt_return(value.loc(), std::move(value)) });
break;
}
case opcode::OP_GetZero:
@ -216,13 +216,13 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
}
else
{
func_->body->list.push_back(stmt{ make_asm_create(loc, inst.data[0]) });
func_->body->block->list.push_back(stmt{ make_asm_create(loc, inst.data[0]) });
}
break;
}
case opcode::OP_RemoveLocalVariables:
{
func_->body->list.push_back(stmt{ make_asm_remove(loc, inst.data[0]) });
func_->body->block->list.push_back(stmt{ make_asm_remove(loc, inst.data[0]) });
break;
}
case opcode::OP_EvalLocalVariableCached0:
@ -310,7 +310,7 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
auto lvalue = expr{ make_expr_array(loc, std::move(obj), std::move(key)) };
auto rvalue = expr{ make_expr_undefined(loc) };
auto exp = expr{ make_expr_assign_equal(loc, std::move(lvalue), std::move(rvalue)) };
func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
break;
}
case opcode::OP_AddArray:
@ -932,7 +932,7 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
case opcode::OP_DecTop:
{
auto exp = expr{ std::move(stack_.top()) }; stack_.pop();
func_->body->list.push_back(stmt{ make_stmt_call(exp.loc(), std::move(exp)) });
func_->body->block->list.push_back(stmt{ make_stmt_call(exp.loc(), std::move(exp)) });
break;
}
case opcode::OP_inc:
@ -1062,17 +1062,17 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
case opcode::OP_wait:
{
auto exp = expr{ std::move(stack_.top()) }; stack_.pop();
func_->body->list.push_back(stmt{ make_stmt_wait(exp.loc(), std::move(exp)) });
func_->body->block->list.push_back(stmt{ make_stmt_wait(exp.loc(), std::move(exp)) });
break;
}
case opcode::OP_waittillFrameEnd:
{
func_->body->list.push_back(stmt{ make_stmt_waittillframeend(loc) });
func_->body->block->list.push_back(stmt{ make_stmt_waittillframeend(loc) });
break;
}
case opcode::OP_waitframe:
{
func_->body->list.push_back(stmt{ make_stmt_waitframe(loc) });
func_->body->block->list.push_back(stmt{ make_stmt_waitframe(loc) });
break;
}
case opcode::OP_waittill:
@ -1098,7 +1098,7 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
args->list.push_back(std::move(arg));
}
func_->body->list.push_back(stmt{ make_stmt_waittillmatch(loc, std::move(obj), std::move(event), std::move(args)) });
func_->body->block->list.push_back(stmt{ make_stmt_waittillmatch(loc, std::move(obj), std::move(event), std::move(args)) });
break;
}
case opcode::OP_clearparams:
@ -1121,7 +1121,7 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
in_waittill_ = false;
}
func_->body->list.push_back(stmt{ std::move(arg) });
func_->body->block->list.push_back(stmt{ std::move(arg) });
}
break;
}
@ -1140,14 +1140,14 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
loc = var->loc();
}
func_->body->list.push_back(stmt{ make_stmt_notify(loc, std::move(obj), std::move(event), std::move(args)) });
func_->body->block->list.push_back(stmt{ make_stmt_notify(loc, std::move(obj), std::move(event), std::move(args)) });
break;
}
case opcode::OP_endon:
{
auto obj = expr{ std::move(stack_.top()) }; stack_.pop();
auto event = expr{ std::move(stack_.top()) }; stack_.pop();
func_->body->list.push_back(stmt{ make_stmt_endon(event.loc(), std::move(obj), std::move(event)) });
func_->body->block->list.push_back(stmt{ make_stmt_endon(event.loc(), std::move(obj), std::move(event)) });
break;
}
case opcode::OP_voidCodepos:
@ -1233,7 +1233,7 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
auto field = expr{ make_expr_field(loc, std::move(obj), std::move(name)) };
auto undef = expr{ make_expr_undefined(loc) };
auto exp = expr{ make_expr_assign_equal(loc, std::move(field), std::move(undef)) };
func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
break;
}
case opcode::OP_SafeCreateVariableFieldCached:
@ -1278,7 +1278,7 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
auto field = make_expr_identifier(loc, inst.data[0]);
auto lvalue = expr{ make_expr_field(loc, std::move(obj), std::move(field)) };
auto exp = expr{ make_expr_assign_equal(loc, std::move(lvalue), std::move(rvalue)) };
func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
break;
}
case opcode::OP_SetVariableField:
@ -1288,18 +1288,18 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
if (lvalue == node::expr_increment)
{
func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(lvalue)) });
func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(lvalue)) });
}
else if (lvalue == node::expr_decrement)
{
func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(lvalue)) });
func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(lvalue)) });
}
else
{
auto rvalue = expr{ std::move(stack_.top()) }; stack_.pop();
loc = rvalue.loc();
auto exp = expr{ make_expr_assign_equal(loc, std::move(lvalue), std::move(rvalue)) };
func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
}
break;
}
@ -1311,7 +1311,7 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
auto field = make_expr_identifier(loc, inst.data[0]);
auto lvalue = expr{ make_expr_field(loc, std::move(obj), std::move(field)) };
auto exp = expr{ make_expr_assign_equal(loc, std::move(lvalue), std::move(rvalue)) };
func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
break;
}
case opcode::OP_SetSelfFieldVariableField:
@ -1322,7 +1322,7 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
auto field = make_expr_identifier(loc, inst.data[0]);
auto lvalue = expr{ make_expr_field(loc, std::move(obj), std::move(field)) };
auto exp = expr{ make_expr_assign_equal(loc, std::move(lvalue), std::move(rvalue)) };
func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
break;
}
case opcode::OP_SetLocalVariableFieldCached0:
@ -1331,7 +1331,7 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
auto rvalue = expr{ std::move(stack_.top()) }; stack_.pop();
loc = rvalue.loc();
auto exp = expr{ make_expr_assign_equal(loc, std::move(lvalue), std::move(rvalue)) };
func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
break;
}
case opcode::OP_SetNewLocalVariableFieldCached0:
@ -1340,17 +1340,17 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
auto rvalue = expr{ std::move(stack_.top()) }; stack_.pop();
loc = rvalue.loc();
if (func_->body->list.size() > 0)
if (func_->body->block->list.size() > 0)
{
std::vector<std::string> vars;
while (func_->body->list.back() == node::asm_create)
while (func_->body->block->list.back() == node::asm_create)
{
auto& entry = func_->body->list.back();
auto& entry = func_->body->block->list.back();
if (loc.begin.line < entry.loc().begin.line)
{
vars.push_back(entry.as_asm_create->index);
func_->body->list.pop_back();
func_->body->block->list.pop_back();
continue;
}
break;
@ -1361,7 +1361,7 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
}
auto exp = expr{ make_expr_assign_equal(loc, std::move(lvalue), std::move(rvalue)) };
func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
break;
}
case opcode::OP_SetLocalVariableFieldCached:
@ -1370,17 +1370,17 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
auto rvalue = expr{ std::move(stack_.top()) }; stack_.pop();
loc = rvalue.loc();
auto exp = expr{ make_expr_assign_equal(loc, std::move(lvalue), std::move(rvalue)) };
func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
break;
}
case opcode::OP_ClearLocalVariableFieldCached:
{
func_->body->list.push_back(stmt{ make_asm_clear(loc, inst.data[0]) });
func_->body->block->list.push_back(stmt{ make_asm_clear(loc, inst.data[0]) });
break;
}
case opcode::OP_ClearLocalVariableFieldCached0:
{
func_->body->list.push_back(stmt{ make_asm_clear(loc, "0") });
func_->body->block->list.push_back(stmt{ make_asm_clear(loc, "0") });
break;
}
case opcode::OP_EvalLocalVariableObjectCached:
@ -1403,23 +1403,23 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
case opcode::OP_switch:
{
auto test = expr{ std::move(stack_.top()) }; stack_.pop();
func_->body->list.push_back(stmt{ make_asm_switch(test.loc(), std::move(test), inst.data[0]) });
func_->body->block->list.push_back(stmt{ make_asm_switch(test.loc(), std::move(test), inst.data[0]) });
break;
}
case opcode::OP_endswitch:
{
func_->body->list.push_back(stmt{ make_asm_endswitch(loc, inst.data) });
func_->body->block->list.push_back(stmt{ make_asm_endswitch(loc, inst.data) });
break;
}
case opcode::OP_jump:
{
func_->body->list.push_back(stmt{ make_asm_jmp(loc, inst.data[0]) });
func_->body->block->list.push_back(stmt{ make_asm_jmp(loc, inst.data[0]) });
if (stack_.size() != 0) tern_labels_.push_back(inst.data[0]);
break;
}
case opcode::OP_jumpback:
{
func_->body->list.push_back(stmt{ make_asm_jmp_back(loc, inst.data[0]) });
func_->body->block->list.push_back(stmt{ make_asm_jmp_back(loc, inst.data[0]) });
break;
}
case opcode::OP_JumpOnTrue:
@ -1427,13 +1427,13 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
auto lvalue = expr{ std::move(stack_.top()) }; stack_.pop();
loc = lvalue.loc();
auto test = expr{ make_expr_not(loc, std::move(lvalue)) };
func_->body->list.push_back(stmt{ make_asm_jmp_cond(loc, std::move(test), inst.data[0]) });
func_->body->block->list.push_back(stmt{ make_asm_jmp_cond(loc, std::move(test), inst.data[0]) });
break;
}
case opcode::OP_JumpOnFalse:
{
auto test = expr{ std::move(stack_.top()) }; stack_.pop();
func_->body->list.push_back(stmt{ make_asm_jmp_cond(test.loc(), std::move(test), inst.data[0]) });
func_->body->block->list.push_back(stmt{ make_asm_jmp_cond(test.loc(), std::move(test), inst.data[0]) });
break;
}
case opcode::OP_JumpOnTrueExpr:
@ -1548,9 +1548,9 @@ auto decompiler::decompile_expressions(instruction const& inst) -> void
auto rvalue = expr{ std::move(stack_.top()) }; stack_.pop();
auto lvalue = expr{ std::move(stack_.top()) }; stack_.pop();
func_->body->list.pop_back();
auto stm = std::move(func_->body->list.back());
func_->body->list.pop_back();
func_->body->block->list.pop_back();
auto stm = std::move(func_->body->block->list.back());
func_->body->block->list.pop_back();
if (stm == node::asm_jmp_cond)
{
@ -1870,7 +1870,7 @@ auto decompiler::decompile_if(stmt_list& stm, usize begin, usize end) -> void
decompile_statements(*body);
locs_ = save;
stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_if(loc, std::move(test), stmt{ std::move(body) }) });
stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_if(loc, std::move(test), stmt{ make_stmt_comp(loc, std::move(body)) }) });
}
auto decompiler::decompile_ifelse(stmt_list& stm, usize begin, usize end) -> void
@ -1916,7 +1916,7 @@ auto decompiler::decompile_ifelse(stmt_list& stm, usize begin, usize end) -> voi
decompile_statements(*body_else);
locs_ = save;
stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_ifelse(loc, std::move(test), stmt{ std::move(body_if) }, stmt{ std::move(body_else) }) });
stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_ifelse(loc, std::move(test), stmt{ make_stmt_comp(loc, std::move(body_if)) }, stmt{ make_stmt_comp(loc, std::move(body_else)) }) });
}
auto decompiler::decompile_ifelse_end(stmt_list& stm, usize begin, usize end) -> void
@ -1946,7 +1946,7 @@ auto decompiler::decompile_ifelse_end(stmt_list& stm, usize begin, usize end) ->
if (begin == stm.list.size())
{
stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_if(loc, std::move(test), stmt{ std::move(body_if) }) });
stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_if(loc, std::move(test), stmt{ make_stmt_comp(loc, std::move(body_if)) }) });
}
else
{
@ -1967,7 +1967,7 @@ auto decompiler::decompile_ifelse_end(stmt_list& stm, usize begin, usize end) ->
decompile_statements(*body_else);
locs_ = save;
stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_ifelse(loc, std::move(test), stmt{ std::move(body_if) }, stmt{ std::move(body_else) }) });
stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_ifelse(loc, std::move(test), stmt{ make_stmt_comp(loc, std::move(body_if)) }, stmt{ make_stmt_comp(loc, std::move(body_else)) }) });
}
}
@ -1993,7 +1993,7 @@ auto decompiler::decompile_inf(stmt_list& stm, usize begin, usize end) -> void
decompile_statements(*body);
locs_ = save;
stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_for(loc, stmt{ make_node(loc) }, expr{ make_node(loc) }, stmt{ make_node(loc) }, stmt{ std::move(body) }) });
stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_for(loc, stmt{ make_node(loc) }, expr{ make_node(loc) }, stmt{ make_node(loc) }, stmt{ make_stmt_comp(loc, std::move(body)) }) });
}
auto decompiler::decompile_loop(stmt_list& stm, usize start, usize end) -> void
@ -2086,7 +2086,7 @@ auto decompiler::decompile_while(stmt_list& stm, usize begin, usize end) -> void
decompile_statements(*body);
locs_ = save;
stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_while(loc, std::move(test), stmt{ std::move(body) }) });
stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_while(loc, std::move(test), stmt{ make_stmt_comp(loc, std::move(body)) }) });
}
auto decompiler::decompile_dowhile(stmt_list& stm, usize begin, usize end) -> void
@ -2115,7 +2115,7 @@ auto decompiler::decompile_dowhile(stmt_list& stm, usize begin, usize end) -> vo
decompile_statements(*body);
locs_ = save;
stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_dowhile(loc, std::move(test), stmt{ std::move(body) }) });
stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_dowhile(loc, std::move(test), stmt{ make_stmt_comp(loc, std::move(body)) }) });
}
auto decompiler::decompile_for(stmt_list& stm, usize begin, usize end) -> void
@ -2130,7 +2130,6 @@ auto decompiler::decompile_for(stmt_list& stm, usize begin, usize end) -> void
auto loc = stm.list[begin].loc();
auto init = make_stmt_list(loc);
init->is_expr = true;
while (stm.list[begin] != node::asm_jmp_cond)
{
@ -2144,7 +2143,6 @@ auto decompiler::decompile_for(stmt_list& stm, usize begin, usize end) -> void
end -= 2 + init->list.size();
auto iter = make_stmt_list(loc);
iter->is_expr = true;
iter->list.push_back(std::move(stm.list[end]));
stm.list.erase(stm.list.begin() + end);
stm.list.erase(stm.list.begin() + end);
@ -2159,7 +2157,7 @@ auto decompiler::decompile_for(stmt_list& stm, usize begin, usize end) -> void
decompile_statements(*body);
locs_ = save;
stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_for(loc, stmt { std::move(init) }, std::move(test), stmt {std::move(iter) }, stmt{ std::move(body) }) });
stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_for(loc, stmt { std::move(init) }, std::move(test), stmt { std::move(iter) }, stmt{ make_stmt_comp(loc, std::move(body)) }) });
}
auto decompiler::decompile_foreach(stmt_list& stm, usize begin, usize end) -> void
@ -2244,7 +2242,7 @@ auto decompiler::decompile_foreach(stmt_list& stm, usize begin, usize end) -> vo
decompile_statements(*body);
locs_ = save;
body->list.insert(body->list.begin(), stmt{ std::move(init) });
stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_foreach(loc, std::move(container), std::move(value), std::move(index), std::move(array), std::move(key), stmt{ std::move(body) }, (ctx_->props() & props::foreach) ? use_index : use_key) });
stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_foreach(loc, std::move(container), std::move(value), std::move(index), std::move(array), std::move(key), stmt{ make_stmt_comp(loc, std::move(body)) }, (ctx_->props() & props::foreach) ? use_index : use_key) });
}
auto decompiler::decompile_switch(stmt_list& stm, usize begin, usize end) -> void
@ -2361,7 +2359,7 @@ auto decompiler::decompile_switch(stmt_list& stm, usize begin, usize end) -> voi
body->list.push_back(std::move(temp));
}
stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_switch(loc, std::move(test), std::move(body)) });
stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_switch(loc, std::move(test), make_stmt_comp(loc, std::move(body))) });
}
auto decompiler::find_location_reference(stmt_list const& stm, usize begin, usize end, std::string const& loc) -> bool
@ -2416,7 +2414,7 @@ auto decompiler::process_function(decl_function& func) -> void
scp_body->create_count++;
}
process_stmt_list(*func.body, *scp_body);
process_stmt_comp(*func.body, *scp_body);
}
auto decompiler::process_stmt(stmt& stm, scope& scp) -> void
@ -2426,6 +2424,12 @@ auto decompiler::process_stmt(stmt& stm, scope& scp) -> void
case node::stmt_list:
process_stmt_list(*stm.as_list, scp);
break;
case node::stmt_comp:
process_stmt_comp(*stm.as_comp, scp);
break;
case node::stmt_dev:
process_stmt_dev(*stm.as_dev, scp);
break;
case node::stmt_expr:
process_stmt_expr(*stm.as_expr, scp);
break;
@ -2507,6 +2511,16 @@ auto decompiler::process_stmt_list(stmt_list& stm, scope& scp) -> void
}
}
auto decompiler::process_stmt_comp(stmt_comp& stm, scope& scp) -> void
{
process_stmt_list(*stm.block, scp);
}
auto decompiler::process_stmt_dev(stmt_dev& stm, scope& scp) -> void
{
process_stmt_list(*stm.block, scp);
}
auto decompiler::process_stmt_expr(stmt_expr& stm, scope& scp) -> void
{
switch (stm.value.kind())
@ -2624,9 +2638,9 @@ auto decompiler::process_stmt_if(stmt_if& stm, scope& scp) -> void
process_stmt(stm.body, *scp_then);
if (stm.body.as_list->list.size() == 1 && !stm.body.as_list->list[0].as_node->is_special_stmt())
if (stm.body.as_comp->block->list.size() == 1 && !stm.body.as_comp->block->list[0].as_node->is_special_stmt())
{
stm.body = std::move(stm.body.as_list->list.back());
stm.body = std::move(stm.body.as_comp->block->list.back());
}
}
@ -2668,14 +2682,14 @@ auto decompiler::process_stmt_ifelse(stmt_ifelse& stm, scope& scp) -> void
scp.append(childs);
if (stm.stmt_if.as_list->list.size() == 1 && !stm.stmt_if.as_list->list[0].as_node->is_special_stmt())
if (stm.stmt_if.as_comp->block->list.size() == 1 && !stm.stmt_if.as_comp->block->list[0].as_node->is_special_stmt())
{
stm.stmt_if = std::move(stm.stmt_if.as_list->list.back());
stm.stmt_if = std::move(stm.stmt_if.as_comp->block->list.back());
}
if (stm.stmt_else.as_list->list.size() == 1 && !stm.stmt_else.as_list->list[0].as_node->is_special_stmt_noif())
if (stm.stmt_else.as_comp->block->list.size() == 1 && !stm.stmt_else.as_comp->block->list[0].as_node->is_special_stmt_noif())
{
stm.stmt_else = std::move(stm.stmt_else.as_list->list.back());
stm.stmt_else = std::move(stm.stmt_else.as_comp->block->list.back());
}
}
@ -2692,9 +2706,9 @@ auto decompiler::process_stmt_while(stmt_while& stm, scope& scp) -> void
if (stm.test == node::null)
scp.append_dec(scp_body);
if (stm.body.as_list->list.size() == 1 && !stm.body.as_list->list[0].as_node->is_special_stmt())
if (stm.body.as_comp->block->list.size() == 1 && !stm.body.as_comp->block->list[0].as_node->is_special_stmt())
{
stm.body = std::move(stm.body.as_list->list.back());
stm.body = std::move(stm.body.as_comp->block->list.back());
}
}
@ -2711,9 +2725,9 @@ auto decompiler::process_stmt_dowhile(stmt_dowhile& stm, scope& scp) -> void
if (stm.test == node::null)
scp.append_dec(scp_body);
if (stm.body.as_list->list.size() == 1 && !stm.body.as_list->list[0].as_node->is_special_stmt())
if (stm.body.as_comp->block->list.size() == 1 && !stm.body.as_comp->block->list[0].as_node->is_special_stmt())
{
stm.body = std::move(stm.body.as_list->list.back());
stm.body = std::move(stm.body.as_comp->block->list.back());
}
}
@ -2723,6 +2737,11 @@ auto decompiler::process_stmt_for(stmt_for& stm, scope& scp) -> void
process_stmt(stm.init, scp);
if (stm.init == node::stmt_list && stm.init.as_list->list[0] == node::stmt_assign)
{
stm.init = stmt{ make_stmt_expr(stm.init.loc(), std::move(stm.init.as_list->list[0].as_assign->value)) };
}
scp.transfer_dec(scp_body);
process_expr(stm.test, scp);
@ -2731,12 +2750,17 @@ auto decompiler::process_stmt_for(stmt_for& stm, scope& scp) -> void
process_stmt(stm.iter, scp);
if (stm.iter == node::stmt_list && stm.iter.as_list->list[0] == node::stmt_assign)
{
stm.iter = stmt{ make_stmt_expr(stm.iter.loc(), std::move(stm.iter.as_list->list[0].as_assign->value)) };
}
if (stm.test == node::null)
scp.append_dec(scp_body);
if (stm.body.as_list->list.size() == 1 && !stm.body.as_list->list[0].as_node->is_special_stmt())
if (stm.body.as_comp->block->list.size() == 1 && !stm.body.as_comp->block->list[0].as_node->is_special_stmt())
{
stm.body = std::move(stm.body.as_list->list.back());
stm.body = std::move(stm.body.as_comp->block->list.back());
}
}
@ -2753,18 +2777,18 @@ auto decompiler::process_stmt_foreach(stmt_foreach& stm, scope& scp) -> void
process_expr(stm.index, scp);
}
process_stmt(stm.body.as_list->list[0], scp);
process_stmt(stm.body.as_comp->block->list[0], scp);
stm.body.as_list->list.erase(stm.body.as_list->list.begin());
stm.body.as_comp->block->list.erase(stm.body.as_comp->block->list.begin());
scp.transfer_dec(scp_body);
process_expr(stm.value, *scp_body);
process_stmt(stm.body, *scp_body);
if (stm.body.as_list->list.size() == 1 && !stm.body.as_list->list[0].as_node->is_special_stmt())
if (stm.body.as_comp->block->list.size() == 1 && !stm.body.as_comp->block->list[0].as_node->is_special_stmt())
{
stm.body = std::move(stm.body.as_list->list.back());
stm.body = std::move(stm.body.as_comp->block->list.back());
}
}
@ -2776,11 +2800,10 @@ auto decompiler::process_stmt_switch(stmt_switch& stm, scope& scp) -> void
process_expr(stm.test, scp);
for (auto& entry : stm.body->list)
for (auto& entry : stm.body->block->list)
{
if (entry == node::stmt_case)
{
entry.as_case->body->is_case = true;
auto scp_case = make_scope();
scp.transfer_dec(scp_case);
@ -2796,7 +2819,6 @@ auto decompiler::process_stmt_switch(stmt_switch& stm, scope& scp) -> void
else if (entry == node::stmt_default)
{
has_default = true;
entry.as_default->body->is_case = true;
auto scp_case = make_scope();
scp.transfer_dec(scp_case);

2
src/gsc/decompiler.hpp
View File

@ -52,6 +52,8 @@ private:
auto process_function(decl_function& func) -> void;
auto process_stmt(stmt& stm, scope& scp) -> void;
auto process_stmt_list(stmt_list& stm, scope& scp) -> void;
auto process_stmt_comp(stmt_comp& stm, scope& scp) -> void;
auto process_stmt_dev(stmt_dev& stm, scope& scp) -> void;
auto process_stmt_expr(stmt_expr& stm, scope& scp) -> void;
auto process_stmt_call(stmt_call& stm, scope& scp) -> void;
auto process_stmt_assign(stmt_assign& stm, scope& scp) -> void;

11
src/gsc/misc/ast.cpp
View File

@ -414,7 +414,11 @@ stmt_list::stmt_list(location const& loc) : node{ type::stmt_list, loc }
{
}
stmt_dev::stmt_dev(location const& loc, stmt_list::ptr body) : node{ type::stmt_dev, loc }, body{ std::move(body) }
stmt_comp::stmt_comp(location const& loc, stmt_list::ptr block) : node{ type::stmt_comp, loc }, block{ std::move(block) }
{
}
stmt_dev::stmt_dev(location const& loc, stmt_list::ptr block) : node{ type::stmt_dev, loc }, block{ std::move(block) }
{
}
@ -482,7 +486,7 @@ stmt_foreach::stmt_foreach(location const& loc, expr container, expr value, expr
{
}
stmt_switch::stmt_switch(location const& loc, expr test, stmt_list::ptr body) : node{ type::stmt_switch, loc }, test{ std::move(test) }, body{ std::move(body) }
stmt_switch::stmt_switch(location const& loc, expr test, stmt_comp::ptr body) : node{ type::stmt_switch, loc }, test{ std::move(test) }, body{ std::move(body) }
{
}
@ -526,7 +530,7 @@ stmt_prof_end::stmt_prof_end(location const& loc, expr_arguments::ptr args) : no
{
}
decl_function::decl_function(location const& loc, expr_identifier::ptr name, expr_parameters::ptr params, stmt_list::ptr body) : node{ type::decl_function, loc }, name{ std::move(name) }, params{ std::move(params) }, body{ std::move(body) }
decl_function::decl_function(location const& loc, expr_identifier::ptr name, expr_parameters::ptr params, stmt_comp::ptr body) : node{ type::decl_function, loc }, name{ std::move(name) }, params{ std::move(params) }, body{ std::move(body) }
{
}
@ -954,6 +958,7 @@ stmt::~stmt()
{
case node::null: as_node.~unique_ptr(); return;
case node::stmt_list: as_list.~unique_ptr(); return;
case node::stmt_comp: as_comp.~unique_ptr(); return;
case node::stmt_dev: as_dev.~unique_ptr(); return;
case node::stmt_expr: as_expr.~unique_ptr(); return;
case node::stmt_call: as_call.~unique_ptr(); return;

27
src/gsc/misc/ast.hpp
View File

@ -84,6 +84,7 @@ struct node
expr_assign_bitwise_and,
expr_assign_bitwise_exor,
stmt_list,
stmt_comp,
stmt_dev,
stmt_expr,
stmt_call,
@ -228,6 +229,7 @@ struct expr_assign_bitwise_or;
struct expr_assign_bitwise_and;
struct expr_assign_bitwise_exor;
struct stmt_list;
struct stmt_comp;
struct stmt_dev;
struct stmt_expr;
struct stmt_call;
@ -390,6 +392,7 @@ union stmt
{
std::unique_ptr<node> as_node;
std::unique_ptr<stmt_list> as_list;
std::unique_ptr<stmt_comp> as_comp;
std::unique_ptr<stmt_dev> as_dev;
std::unique_ptr<stmt_expr> as_expr;
std::unique_ptr<stmt_call> as_call;
@ -1058,19 +1061,26 @@ struct stmt_list : public node
using ptr = std::unique_ptr<stmt_list>;
std::vector<stmt> list;
bool is_case = false;
bool is_expr = false;
stmt_list(location const& loc);
};
struct stmt_comp : public node
{
using ptr = std::unique_ptr<stmt_comp>;
stmt_list::ptr block;
stmt_comp(location const& loc, stmt_list::ptr block);
};
struct stmt_dev : public node
{
using ptr = std::unique_ptr<stmt_dev>;
stmt_list::ptr body;
stmt_list::ptr block;
stmt_dev(location const& loc, stmt_list::ptr body);
stmt_dev(location const& loc, stmt_list::ptr block);
};
struct stmt_expr : public node
@ -1239,9 +1249,9 @@ struct stmt_switch : public node
using ptr = std::unique_ptr<stmt_switch>;
expr test;
stmt_list::ptr body;
stmt_comp::ptr body;
stmt_switch(location const& loc, expr test, stmt_list::ptr body);
stmt_switch(location const& loc, expr test, stmt_comp::ptr body);
};
struct stmt_case : public node
@ -1319,9 +1329,9 @@ struct decl_function : public node
expr_identifier::ptr name;
expr_parameters::ptr params;
stmt_list::ptr body;
stmt_comp::ptr body;
decl_function(location const& loc, expr_identifier::ptr name, expr_parameters::ptr params, stmt_list::ptr body);
decl_function(location const& loc, expr_identifier::ptr name, expr_parameters::ptr params, stmt_comp::ptr body);
};
struct decl_usingtree : public node
@ -1562,6 +1572,7 @@ XSK_GSC_MAKE_GENERIC(expr_assign_bitwise_or)
XSK_GSC_MAKE_GENERIC(expr_assign_bitwise_and)
XSK_GSC_MAKE_GENERIC(expr_assign_bitwise_exor)
XSK_GSC_MAKE_GENERIC(stmt_list)
XSK_GSC_MAKE_GENERIC(stmt_comp)
XSK_GSC_MAKE_GENERIC(stmt_dev)
XSK_GSC_MAKE_GENERIC(stmt_expr)
XSK_GSC_MAKE_GENERIC(stmt_call)

535
src/gsc/parser.cpp
View File

File diff suppressed because it is too large Load Diff

86
src/gsc/parser.hpp
View File

@ -585,73 +585,75 @@ namespace xsk { namespace gsc {
// stmt_case
char dummy48[sizeof (stmt_case::ptr)];
// stmt_comp
char dummy49[sizeof (stmt_comp::ptr)];
// stmt_continue
char dummy49[sizeof (stmt_continue::ptr)];
char dummy50[sizeof (stmt_continue::ptr)];
// stmt_default
char dummy50[sizeof (stmt_default::ptr)];
char dummy51[sizeof (stmt_default::ptr)];
// stmt_dev
char dummy51[sizeof (stmt_dev::ptr)];
char dummy52[sizeof (stmt_dev::ptr)];
// stmt_dowhile
char dummy52[sizeof (stmt_dowhile::ptr)];
char dummy53[sizeof (stmt_dowhile::ptr)];
// stmt_endon
char dummy53[sizeof (stmt_endon::ptr)];
char dummy54[sizeof (stmt_endon::ptr)];
// stmt_expr
char dummy54[sizeof (stmt_expr::ptr)];
char dummy55[sizeof (stmt_expr::ptr)];
// stmt_for
char dummy55[sizeof (stmt_for::ptr)];
char dummy56[sizeof (stmt_for::ptr)];
// stmt_foreach
char dummy56[sizeof (stmt_foreach::ptr)];
char dummy57[sizeof (stmt_foreach::ptr)];
// stmt_if
char dummy57[sizeof (stmt_if::ptr)];
char dummy58[sizeof (stmt_if::ptr)];
// stmt_ifelse
char dummy58[sizeof (stmt_ifelse::ptr)];
char dummy59[sizeof (stmt_ifelse::ptr)];
// stmt_list
// stmt_or_dev_list
// stmt_block
char dummy59[sizeof (stmt_list::ptr)];
char dummy60[sizeof (stmt_list::ptr)];
// stmt_notify
char dummy60[sizeof (stmt_notify::ptr)];
char dummy61[sizeof (stmt_notify::ptr)];
// stmt_prof_begin
char dummy61[sizeof (stmt_prof_begin::ptr)];
char dummy62[sizeof (stmt_prof_begin::ptr)];
// stmt_prof_end
char dummy62[sizeof (stmt_prof_end::ptr)];
char dummy63[sizeof (stmt_prof_end::ptr)];
// stmt_return
char dummy63[sizeof (stmt_return::ptr)];
char dummy64[sizeof (stmt_return::ptr)];
// stmt_switch
char dummy64[sizeof (stmt_switch::ptr)];
char dummy65[sizeof (stmt_switch::ptr)];
// stmt_wait
char dummy65[sizeof (stmt_wait::ptr)];
char dummy66[sizeof (stmt_wait::ptr)];
// stmt_waitframe
char dummy66[sizeof (stmt_waitframe::ptr)];
char dummy67[sizeof (stmt_waitframe::ptr)];
// stmt_waittill
char dummy67[sizeof (stmt_waittill::ptr)];
char dummy68[sizeof (stmt_waittill::ptr)];
// stmt_waittillframeend
char dummy68[sizeof (stmt_waittillframeend::ptr)];
char dummy69[sizeof (stmt_waittillframeend::ptr)];
// stmt_waittillmatch
char dummy69[sizeof (stmt_waittillmatch::ptr)];
char dummy70[sizeof (stmt_waittillmatch::ptr)];
// stmt_while
char dummy70[sizeof (stmt_while::ptr)];
char dummy71[sizeof (stmt_while::ptr)];
};
/// The size of the largest semantic type.
@ -962,7 +964,7 @@ namespace xsk { namespace gsc {
S_stmt_list = 125, // stmt_list
S_stmt_or_dev_list = 126, // stmt_or_dev_list
S_stmt_dev = 127, // stmt_dev
S_stmt_block = 128, // stmt_block
S_stmt_comp = 128, // stmt_comp
S_stmt_expr = 129, // stmt_expr
S_stmt_call = 130, // stmt_call
S_stmt_assign = 131, // stmt_assign
@ -1284,6 +1286,10 @@ namespace xsk { namespace gsc {
value.move< stmt_case::ptr > (std::move (that.value));
break;
case symbol_kind::S_stmt_comp: // stmt_comp
value.move< stmt_comp::ptr > (std::move (that.value));
break;
case symbol_kind::S_stmt_continue: // stmt_continue
value.move< stmt_continue::ptr > (std::move (that.value));
break;
@ -1326,7 +1332,6 @@ namespace xsk { namespace gsc {
case symbol_kind::S_stmt_list: // stmt_list
case symbol_kind::S_stmt_or_dev_list: // stmt_or_dev_list
case symbol_kind::S_stmt_block: // stmt_block
value.move< stmt_list::ptr > (std::move (that.value));
break;
@ -2069,6 +2074,20 @@ namespace xsk { namespace gsc {
{}
#endif
#if 201103L <= YY_CPLUSPLUS
basic_symbol (typename Base::kind_type t, stmt_comp::ptr&& v, location_type&& l)
: Base (t)
, value (std::move (v))
, location (std::move (l))
{}
#else
basic_symbol (typename Base::kind_type t, const stmt_comp::ptr& v, const location_type& l)
: Base (t)
, value (v)
, location (l)
{}
#endif
#if 201103L <= YY_CPLUSPLUS
basic_symbol (typename Base::kind_type t, stmt_continue::ptr&& v, location_type&& l)
: Base (t)
@ -2612,6 +2631,10 @@ switch (yykind)
value.template destroy< stmt_case::ptr > ();
break;
case symbol_kind::S_stmt_comp: // stmt_comp
value.template destroy< stmt_comp::ptr > ();
break;
case symbol_kind::S_stmt_continue: // stmt_continue
value.template destroy< stmt_continue::ptr > ();
break;
@ -2654,7 +2677,6 @@ switch (yykind)
case symbol_kind::S_stmt_list: // stmt_list
case symbol_kind::S_stmt_or_dev_list: // stmt_or_dev_list
case symbol_kind::S_stmt_block: // stmt_block
value.template destroy< stmt_list::ptr > ();
break;
@ -5174,6 +5196,10 @@ switch (yykind)
value.copy< stmt_case::ptr > (YY_MOVE (that.value));
break;
case symbol_kind::S_stmt_comp: // stmt_comp
value.copy< stmt_comp::ptr > (YY_MOVE (that.value));
break;
case symbol_kind::S_stmt_continue: // stmt_continue
value.copy< stmt_continue::ptr > (YY_MOVE (that.value));
break;
@ -5216,7 +5242,6 @@ switch (yykind)
case symbol_kind::S_stmt_list: // stmt_list
case symbol_kind::S_stmt_or_dev_list: // stmt_or_dev_list
case symbol_kind::S_stmt_block: // stmt_block
value.copy< stmt_list::ptr > (YY_MOVE (that.value));
break;
@ -5506,6 +5531,10 @@ switch (yykind)
value.move< stmt_case::ptr > (YY_MOVE (s.value));
break;
case symbol_kind::S_stmt_comp: // stmt_comp
value.move< stmt_comp::ptr > (YY_MOVE (s.value));
break;
case symbol_kind::S_stmt_continue: // stmt_continue
value.move< stmt_continue::ptr > (YY_MOVE (s.value));
break;
@ -5548,7 +5577,6 @@ switch (yykind)
case symbol_kind::S_stmt_list: // stmt_list
case symbol_kind::S_stmt_or_dev_list: // stmt_or_dev_list
case symbol_kind::S_stmt_block: // stmt_block
value.move< stmt_list::ptr > (YY_MOVE (s.value));
break;
@ -5663,7 +5691,7 @@ switch (yykind)
#line 13 "parser.ypp"
} } // xsk::gsc
#line 5667 "parser.hpp"
#line 5695 "parser.hpp"

70
src/gsc/source.cpp
View File

@ -345,7 +345,7 @@ auto source::dump_decl_function(decl_function const& dec) -> void
fmt::format_to(std::back_inserter(buf_), "(");
dump_expr_parameters(*dec.params);
fmt::format_to(std::back_inserter(buf_), ")\n");
dump_stmt_list(*dec.body);
dump_stmt_comp(*dec.body);
fmt::format_to(std::back_inserter(buf_), "\n");
}
@ -356,6 +356,9 @@ auto source::dump_stmt(stmt const& stm) -> void
case node::stmt_list:
dump_stmt_list(*stm.as_list);
break;
case node::stmt_comp:
dump_stmt_comp(*stm.as_comp);
break;
case node::stmt_dev:
dump_stmt_dev(*stm.as_dev);
break;
@ -468,22 +471,7 @@ auto source::dump_stmt(stmt const& stm) -> void
auto source::dump_stmt_list(stmt_list const& stm) -> void
{
if (stm.is_expr)
{
if (stm.list.size() > 0)
{
dump_stmt(stm.list[0]);
buf_.pop_back();
}
return;
}
bool last_special = false;
if (!stm.is_case)
fmt::format_to(std::back_inserter(buf_), "{: >{}}\n", "{", indent_ + 1);
auto last_special = false;
indent_ += 4;
for (auto const& entry : stm.list)
@ -511,39 +499,19 @@ auto source::dump_stmt_list(stmt_list const& stm) -> void
}
indent_ -= 4;
}
if (!stm.is_case)
auto source::dump_stmt_comp(stmt_comp const& stm) -> void
{
fmt::format_to(std::back_inserter(buf_), "{: >{}}\n", "{", indent_ + 1);
dump_stmt_list(*stm.block);
fmt::format_to(std::back_inserter(buf_), "\n{: >{}}", "}", indent_ + 1);
}
auto source::dump_stmt_dev(stmt_dev const& stm) -> void
{
bool last_special = false;
fmt::format_to(std::back_inserter(buf_), "/#\n");
for (auto const& entry : stm.body->list)
{
if ((&entry != &stm.body->list.front() && entry.as_node->is_special_stmt()) || last_special)
fmt::format_to(std::back_inserter(buf_), "\n");
if (entry == node::stmt_dev)
dump_stmt(entry);
else
{
fmt::format_to(std::back_inserter(buf_), "{: >{}}", "", indent_);
dump_stmt(entry);
}
if (&entry != &stm.body->list.back())
fmt::format_to(std::back_inserter(buf_), "\n");
if (entry.as_node->is_special_stmt())
last_special = true;
else
last_special = false;
}
dump_stmt_list(*stm.block);
fmt::format_to(std::back_inserter(buf_), "\n#/");
}
@ -661,7 +629,7 @@ auto source::dump_stmt_if(stmt_if const& stm) -> void
dump_expr(stm.test);
fmt::format_to(std::back_inserter(buf_), " )\n");
if (stm.body == node::stmt_list)
if (stm.body == node::stmt_comp)
{
dump_stmt(stm.body);
}
@ -680,7 +648,7 @@ auto source::dump_stmt_ifelse(stmt_ifelse const& stm) -> void
dump_expr(stm.test);
fmt::format_to(std::back_inserter(buf_), " )\n");
if (stm.stmt_if == node::stmt_list)
if (stm.stmt_if == node::stmt_comp)
{
dump_stmt(stm.stmt_if);
}
@ -694,7 +662,7 @@ auto source::dump_stmt_ifelse(stmt_ifelse const& stm) -> void
fmt::format_to(std::back_inserter(buf_), "\n{: >{}}else", "", indent_);
if (stm.stmt_else == node::stmt_list)
if (stm.stmt_else == node::stmt_comp)
{
fmt::format_to(std::back_inserter(buf_), "\n");
dump_stmt(stm.stmt_else);
@ -729,7 +697,7 @@ auto source::dump_stmt_while(stmt_while const& stm) -> void
fmt::format_to(std::back_inserter(buf_), " )\n");
}
if (stm.body == node::stmt_list)
if (stm.body == node::stmt_comp)
{
dump_stmt(stm.body);
}
@ -746,7 +714,7 @@ auto source::dump_stmt_dowhile(stmt_dowhile const& stm) -> void
{
fmt::format_to(std::back_inserter(buf_), "do\n");
if (stm.body == node::stmt_list)
if (stm.body == node::stmt_comp)
{
dump_stmt(stm.body);
}
@ -787,7 +755,7 @@ auto source::dump_stmt_for(stmt_for const& stm) -> void
fmt::format_to(std::back_inserter(buf_), " )\n");
}
if (stm.body == node::stmt_list)
if (stm.body == node::stmt_comp)
{
dump_stmt(stm.body);
}
@ -815,7 +783,7 @@ auto source::dump_stmt_foreach(stmt_foreach const& stm) -> void
dump_expr(stm.container);
fmt::format_to(std::back_inserter(buf_), " )\n");
if (stm.body == node::stmt_list)
if (stm.body == node::stmt_comp)
{
dump_stmt(stm.body);
}
@ -833,7 +801,7 @@ auto source::dump_stmt_switch(stmt_switch const& stm) -> void
fmt::format_to(std::back_inserter(buf_), "switch ( ");
dump_expr(stm.test);
fmt::format_to(std::back_inserter(buf_), " )\n");
dump_stmt_list(*stm.body);
dump_stmt_comp(*stm.body);
}
auto source::dump_stmt_case(stmt_case const& stm) -> void

1
src/gsc/source.hpp
View File

@ -40,6 +40,7 @@ private:
auto dump_decl_function(decl_function const& dec) -> void;
auto dump_stmt(stmt const& stm) -> void;
auto dump_stmt_list(stmt_list const& stm) -> void;
auto dump_stmt_comp(stmt_comp const& stm) -> void;
auto dump_stmt_dev(stmt_dev const& stm) -> void;
auto dump_stmt_expr(stmt_expr const& stm) -> void;
auto dump_stmt_call(stmt_call const& stm) -> void;

1654
src/t6/parser.cpp
View File

File diff suppressed because it is too large Load Diff

2
src/t6/parser.hpp
View File

@ -5568,7 +5568,7 @@ switch (yykind)
/// Constants.
enum
{
yylast_ = 3561, ///< Last index in yytable_.
yylast_ = 3635, ///< Last index in yytable_.
yynnts_ = 101, ///< Number of nonterminal symbols.
yyfinal_ = 27 ///< Termination state number.
};