2626 lines
76 KiB
C++
2626 lines
76 KiB
C++
// Copyright 2021 xensik. All rights reserved.
|
|
//
|
|
// Use of this source code is governed by a GNU GPLv3 license
|
|
// that can be found in the LICENSE file.
|
|
|
|
#pragma once
|
|
|
|
namespace xsk::gsc
|
|
{
|
|
|
|
enum class node_t
|
|
{
|
|
null,
|
|
data_true,
|
|
data_false,
|
|
data_integer,
|
|
data_float,
|
|
data_vector,
|
|
data_string,
|
|
data_istring,
|
|
data_file,
|
|
data_name,
|
|
data_animtree,
|
|
data_animation,
|
|
data_level,
|
|
data_anim,
|
|
data_self,
|
|
data_game,
|
|
data_undefined,
|
|
data_empty_array,
|
|
data_thisthread,
|
|
expr_paren,
|
|
expr_size,
|
|
expr_field,
|
|
expr_array,
|
|
expr_add_array,
|
|
expr_function,
|
|
expr_arguments,
|
|
expr_call_pointer,
|
|
expr_call_function,
|
|
expr_call,
|
|
expr_complement,
|
|
expr_not,
|
|
expr_add,
|
|
expr_sub,
|
|
expr_mult,
|
|
expr_div,
|
|
expr_mod,
|
|
expr_shift_left,
|
|
expr_shift_right,
|
|
expr_bitwise_or,
|
|
expr_bitwise_and,
|
|
expr_bitwise_exor,
|
|
expr_equality,
|
|
expr_inequality,
|
|
expr_less_equal,
|
|
expr_greater_equal,
|
|
expr_less,
|
|
expr_greater,
|
|
expr_or,
|
|
expr_and,
|
|
expr_assign_equal,
|
|
expr_assign_add,
|
|
expr_assign_sub,
|
|
expr_assign_mult,
|
|
expr_assign_div,
|
|
expr_assign_mod,
|
|
expr_assign_shift_left,
|
|
expr_assign_shift_right,
|
|
expr_assign_bitwise_or,
|
|
expr_assign_bitwise_and,
|
|
expr_assign_bitwise_exor,
|
|
expr_increment,
|
|
expr_decrement,
|
|
stmt_list,
|
|
stmt_call,
|
|
stmt_assign,
|
|
stmt_endon,
|
|
stmt_notify,
|
|
stmt_wait,
|
|
stmt_waittill,
|
|
stmt_waittillmatch,
|
|
stmt_waittillframeend,
|
|
stmt_waitframe,
|
|
stmt_if,
|
|
stmt_ifelse,
|
|
stmt_while,
|
|
stmt_for,
|
|
stmt_foreach,
|
|
stmt_switch,
|
|
stmt_case,
|
|
stmt_default,
|
|
stmt_break,
|
|
stmt_continue,
|
|
stmt_return,
|
|
stmt_breakpoint,
|
|
stmt_prof_begin,
|
|
stmt_prof_end,
|
|
parameters,
|
|
thread,
|
|
constant,
|
|
usingtree,
|
|
include,
|
|
program,
|
|
// DECOMPILER
|
|
asm_loc,
|
|
asm_jump,
|
|
asm_jump_back,
|
|
asm_jump_cond,
|
|
asm_jump_true_expr,
|
|
asm_jump_false_expr,
|
|
asm_switch,
|
|
asm_endswitch,
|
|
asm_prescriptcall,
|
|
asm_voidcodepos,
|
|
asm_create,
|
|
asm_access,
|
|
asm_remove,
|
|
asm_clear,
|
|
};
|
|
|
|
struct node;
|
|
struct node_true;
|
|
struct node_false;
|
|
struct node_integer;
|
|
struct node_float;
|
|
struct node_vector;
|
|
struct node_string;
|
|
struct node_istring;
|
|
struct node_file;
|
|
struct node_name;
|
|
struct node_animtree;
|
|
struct node_animation;
|
|
struct node_level;
|
|
struct node_anim;
|
|
struct node_self;
|
|
struct node_game;
|
|
struct node_undefined;
|
|
struct node_empty_array;
|
|
struct node_thisthread;
|
|
struct node_expr_paren;
|
|
struct node_expr_size;
|
|
struct node_expr_field;
|
|
struct node_expr_array;
|
|
struct node_expr_add_array;
|
|
struct node_expr_function;
|
|
struct node_expr_arguments;
|
|
struct node_expr_call_pointer;
|
|
struct node_expr_call_function;
|
|
struct node_expr_call;
|
|
struct node_expr_complement;
|
|
struct node_expr_not;
|
|
struct node_expr_binary;
|
|
struct node_expr_add;
|
|
struct node_expr_sub;
|
|
struct node_expr_mult;
|
|
struct node_expr_div;
|
|
struct node_expr_mod;
|
|
struct node_expr_shift_left;
|
|
struct node_expr_shift_right;
|
|
struct node_expr_bitwise_or;
|
|
struct node_expr_bitwise_and;
|
|
struct node_expr_bitwise_exor;
|
|
struct node_expr_equality;
|
|
struct node_expr_inequality;
|
|
struct node_expr_less_equal;
|
|
struct node_expr_greater_equal;
|
|
struct node_expr_less;
|
|
struct node_expr_greater;
|
|
struct node_expr_or;
|
|
struct node_expr_and;
|
|
struct node_expr_assign;
|
|
struct node_expr_assign_equal;
|
|
struct node_expr_assign_add;
|
|
struct node_expr_assign_sub;
|
|
struct node_expr_assign_mult;
|
|
struct node_expr_assign_div;
|
|
struct node_expr_assign_mod;
|
|
struct node_expr_assign_shift_left;
|
|
struct node_expr_assign_shift_right;
|
|
struct node_expr_assign_bitwise_or;
|
|
struct node_expr_assign_bitwise_and;
|
|
struct node_expr_assign_bitwise_exor;
|
|
struct node_expr_increment;
|
|
struct node_expr_decrement;
|
|
struct node_stmt_list;
|
|
struct node_stmt_call;
|
|
struct node_stmt_assign;
|
|
struct node_stmt_endon;
|
|
struct node_stmt_notify;
|
|
struct node_stmt_wait;
|
|
struct node_stmt_waittill;
|
|
struct node_stmt_waittillmatch;
|
|
struct node_stmt_waittillframeend;
|
|
struct node_stmt_waitframe;
|
|
struct node_stmt_if;
|
|
struct node_stmt_ifelse;
|
|
struct node_stmt_while;
|
|
struct node_stmt_for;
|
|
struct node_stmt_foreach;
|
|
struct node_stmt_switch;
|
|
struct node_stmt_case;
|
|
struct node_stmt_default;
|
|
struct node_stmt_break;
|
|
struct node_stmt_continue;
|
|
struct node_stmt_return;
|
|
struct node_stmt_breakpoint;
|
|
struct node_stmt_prof_begin;
|
|
struct node_stmt_prof_end;
|
|
struct node_parameters;
|
|
struct node_thread;
|
|
struct node_constant;
|
|
struct node_usingtree;
|
|
struct node_include;
|
|
struct node_program;
|
|
struct node_asm_loc;
|
|
struct node_asm_jump;
|
|
struct node_asm_jump_back;
|
|
struct node_asm_jump_cond;
|
|
struct node_asm_jump_false_expr;
|
|
struct node_asm_jump_true_expr;
|
|
struct node_asm_switch;
|
|
struct node_asm_endswitch;
|
|
struct node_asm_create;
|
|
struct node_asm_access;
|
|
struct node_asm_remove;
|
|
struct node_asm_clear;
|
|
|
|
using node_ptr = std::unique_ptr<node>;
|
|
using true_ptr = std::unique_ptr<node_true>;
|
|
using false_ptr = std::unique_ptr<node_false>;
|
|
using integer_ptr = std::unique_ptr<node_integer>;
|
|
using float_ptr = std::unique_ptr<node_float>;
|
|
using vector_ptr = std::unique_ptr<node_vector>;
|
|
using string_ptr = std::unique_ptr<node_string>;
|
|
using istring_ptr = std::unique_ptr<node_istring>;
|
|
using file_ptr = std::unique_ptr<node_file>;
|
|
using name_ptr = std::unique_ptr<node_name>;
|
|
using animtree_ptr = std::unique_ptr<node_animtree>;
|
|
using animation_ptr = std::unique_ptr<node_animation>;
|
|
using level_ptr = std::unique_ptr<node_level>;
|
|
using anim_ptr = std::unique_ptr<node_anim>;
|
|
using self_ptr = std::unique_ptr<node_self>;
|
|
using game_ptr = std::unique_ptr<node_game>;
|
|
using undefined_ptr = std::unique_ptr<node_undefined>;
|
|
using empty_array_ptr = std::unique_ptr<node_empty_array>;
|
|
using thisthread_ptr = std::unique_ptr<node_thisthread>;
|
|
using expr_paren_ptr = std::unique_ptr<node_expr_paren>;
|
|
using expr_size_ptr = std::unique_ptr<node_expr_size>;
|
|
using expr_field_ptr = std::unique_ptr<node_expr_field>;
|
|
using expr_array_ptr = std::unique_ptr<node_expr_array>;
|
|
using expr_add_array_ptr = std::unique_ptr<node_expr_add_array>;
|
|
using expr_function_ptr = std::unique_ptr<node_expr_function>;
|
|
using expr_arguments_ptr = std::unique_ptr<node_expr_arguments>;
|
|
using expr_call_pointer_ptr = std::unique_ptr<node_expr_call_pointer>;
|
|
using expr_call_function_ptr = std::unique_ptr<node_expr_call_function>;
|
|
using expr_call_ptr = std::unique_ptr<node_expr_call>;
|
|
using expr_complement_ptr = std::unique_ptr<node_expr_complement>;
|
|
using expr_not_ptr = std::unique_ptr<node_expr_not>;
|
|
using expr_binary_ptr = std::unique_ptr<node_expr_binary>;
|
|
using expr_add_ptr = std::unique_ptr<node_expr_add>;
|
|
using expr_sub_ptr = std::unique_ptr<node_expr_sub>;
|
|
using expr_mult_ptr = std::unique_ptr<node_expr_mult>;
|
|
using expr_div_ptr = std::unique_ptr<node_expr_div>;
|
|
using expr_mod_ptr = std::unique_ptr<node_expr_mod>;
|
|
using expr_shift_left_ptr = std::unique_ptr<node_expr_shift_left>;
|
|
using expr_shift_right_ptr = std::unique_ptr<node_expr_shift_right>;
|
|
using expr_bitwise_or_ptr = std::unique_ptr<node_expr_bitwise_or>;
|
|
using expr_bitwise_and_ptr = std::unique_ptr<node_expr_bitwise_and>;
|
|
using expr_bitwise_exor_ptr = std::unique_ptr<node_expr_bitwise_exor>;
|
|
using expr_equality_ptr = std::unique_ptr<node_expr_equality>;
|
|
using expr_inequality_ptr = std::unique_ptr<node_expr_inequality>;
|
|
using expr_less_equal_ptr = std::unique_ptr<node_expr_less_equal>;
|
|
using expr_greater_equal_ptr = std::unique_ptr<node_expr_greater_equal>;
|
|
using expr_less_ptr = std::unique_ptr<node_expr_less>;
|
|
using expr_greater_ptr = std::unique_ptr<node_expr_greater>;
|
|
using expr_or_ptr = std::unique_ptr<node_expr_or>;
|
|
using expr_and_ptr = std::unique_ptr<node_expr_and>;
|
|
using expr_assign_ptr = std::unique_ptr<node_expr_assign>;
|
|
using expr_assign_equal_ptr = std::unique_ptr<node_expr_assign_equal>;
|
|
using expr_assign_add_ptr = std::unique_ptr<node_expr_assign_add>;
|
|
using expr_assign_sub_ptr = std::unique_ptr<node_expr_assign_sub>;
|
|
using expr_assign_mult_ptr = std::unique_ptr<node_expr_assign_mult>;
|
|
using expr_assign_div_ptr = std::unique_ptr<node_expr_assign_div>;
|
|
using expr_assign_mod_ptr = std::unique_ptr<node_expr_assign_mod>;
|
|
using expr_assign_shift_left_ptr = std::unique_ptr<node_expr_assign_shift_left>;
|
|
using expr_assign_shift_right_ptr = std::unique_ptr<node_expr_assign_shift_right>;
|
|
using expr_assign_bitwise_or_ptr = std::unique_ptr<node_expr_assign_bitwise_or>;
|
|
using expr_assign_bitwise_and_ptr = std::unique_ptr<node_expr_assign_bitwise_and>;
|
|
using expr_assign_bitwise_exor_ptr = std::unique_ptr<node_expr_assign_bitwise_exor>;
|
|
using expr_increment_ptr = std::unique_ptr<node_expr_increment>;
|
|
using expr_decrement_ptr = std::unique_ptr<node_expr_decrement>;
|
|
using stmt_list_ptr = std::unique_ptr<node_stmt_list>;
|
|
using stmt_call_ptr = std::unique_ptr<node_stmt_call>;
|
|
using stmt_assign_ptr = std::unique_ptr<node_stmt_assign>;
|
|
using stmt_endon_ptr = std::unique_ptr<node_stmt_endon>;
|
|
using stmt_notify_ptr = std::unique_ptr<node_stmt_notify>;
|
|
using stmt_wait_ptr = std::unique_ptr<node_stmt_wait>;
|
|
using stmt_waittill_ptr = std::unique_ptr<node_stmt_waittill>;
|
|
using stmt_waittillmatch_ptr = std::unique_ptr<node_stmt_waittillmatch>;
|
|
using stmt_waitframe_ptr = std::unique_ptr<node_stmt_waitframe>;
|
|
using stmt_waittillframeend_ptr = std::unique_ptr<node_stmt_waittillframeend>;
|
|
using stmt_if_ptr = std::unique_ptr<node_stmt_if>;
|
|
using stmt_ifelse_ptr = std::unique_ptr<node_stmt_ifelse>;
|
|
using stmt_while_ptr = std::unique_ptr<node_stmt_while>;
|
|
using stmt_for_ptr = std::unique_ptr<node_stmt_for>;
|
|
using stmt_foreach_ptr = std::unique_ptr<node_stmt_foreach>;
|
|
using stmt_switch_ptr = std::unique_ptr<node_stmt_switch>;
|
|
using stmt_case_ptr = std::unique_ptr<node_stmt_case>;
|
|
using stmt_default_ptr = std::unique_ptr<node_stmt_default>;
|
|
using stmt_break_ptr = std::unique_ptr<node_stmt_break>;
|
|
using stmt_continue_ptr = std::unique_ptr<node_stmt_continue>;
|
|
using stmt_return_ptr = std::unique_ptr<node_stmt_return>;
|
|
using stmt_breakpoint_ptr = std::unique_ptr<node_stmt_breakpoint>;
|
|
using stmt_prof_begin_ptr = std::unique_ptr<node_stmt_prof_begin>;
|
|
using stmt_prof_end_ptr = std::unique_ptr<node_stmt_prof_end>;
|
|
using parameters_ptr = std::unique_ptr<node_parameters>;
|
|
using thread_ptr = std::unique_ptr<node_thread>;
|
|
using constant_ptr = std::unique_ptr<node_constant>;
|
|
using usingtree_ptr = std::unique_ptr<node_usingtree>;
|
|
using include_ptr = std::unique_ptr<node_include>;
|
|
using program_ptr = std::unique_ptr<node_program>;
|
|
using asm_loc_ptr = std::unique_ptr<node_asm_loc>;
|
|
using asm_jump_ptr = std::unique_ptr<node_asm_jump>;
|
|
using asm_jump_back_ptr = std::unique_ptr<node_asm_jump_back>;
|
|
using asm_jump_cond_ptr = std::unique_ptr<node_asm_jump_cond>;
|
|
using asm_jump_false_expr_ptr = std::unique_ptr<node_asm_jump_false_expr>;
|
|
using asm_jump_true_expr_ptr = std::unique_ptr<node_asm_jump_true_expr>;
|
|
using asm_switch_ptr = std::unique_ptr<node_asm_switch>;
|
|
using asm_endswitch_ptr = std::unique_ptr<node_asm_endswitch>;
|
|
using asm_create_ptr = std::unique_ptr<node_asm_create>;
|
|
using asm_access_ptr = std::unique_ptr<node_asm_access>;
|
|
using asm_remove_ptr = std::unique_ptr<node_asm_remove>;
|
|
using asm_clear_ptr = std::unique_ptr<node_asm_clear>;
|
|
|
|
union expr_call_type_ptr
|
|
{
|
|
node_ptr as_node;
|
|
expr_call_pointer_ptr as_pointer;
|
|
expr_call_function_ptr as_func;
|
|
|
|
expr_call_type_ptr() {}
|
|
expr_call_type_ptr(node_ptr val): as_node(std::move(val)) {}
|
|
expr_call_type_ptr(expr_call_type_ptr && val) { new(&as_node) node_ptr(std::move(val.as_node)); }
|
|
~expr_call_type_ptr(){}
|
|
};
|
|
|
|
union expr_ptr
|
|
{
|
|
node_ptr as_node;
|
|
true_ptr as_true;
|
|
false_ptr as_false;
|
|
integer_ptr as_integer;
|
|
float_ptr as_float;
|
|
vector_ptr as_vector;
|
|
string_ptr as_string;
|
|
istring_ptr as_istring;
|
|
file_ptr as_file;
|
|
name_ptr as_name;
|
|
animtree_ptr as_animtree;
|
|
animation_ptr as_animation;
|
|
level_ptr as_level;
|
|
anim_ptr as_anim;
|
|
self_ptr as_self;
|
|
game_ptr as_game;
|
|
undefined_ptr as_undefined;
|
|
empty_array_ptr as_empty_array;
|
|
thisthread_ptr as_thisthread;
|
|
expr_paren_ptr as_paren;
|
|
expr_size_ptr as_size;
|
|
expr_field_ptr as_field;
|
|
expr_array_ptr as_array;
|
|
expr_add_array_ptr as_add_array;
|
|
expr_function_ptr as_function;
|
|
expr_arguments_ptr as_arguments;
|
|
expr_call_pointer_ptr as_call_pointer;
|
|
expr_call_function_ptr as_call_function;
|
|
expr_call_ptr as_call;
|
|
expr_complement_ptr as_complement;
|
|
expr_not_ptr as_not;
|
|
expr_add_ptr as_add;
|
|
expr_sub_ptr as_sub;
|
|
expr_mult_ptr as_mult;
|
|
expr_div_ptr as_div;
|
|
expr_mod_ptr as_mod;
|
|
expr_shift_left_ptr as_shift_left;
|
|
expr_shift_right_ptr as_shift_right;
|
|
expr_bitwise_or_ptr as_bitwise_or;
|
|
expr_bitwise_and_ptr as_bitwise_and;
|
|
expr_bitwise_exor_ptr as_bitwise_exor;
|
|
expr_equality_ptr as_equality;
|
|
expr_inequality_ptr as_inequality;
|
|
expr_less_equal_ptr as_less_equal;
|
|
expr_greater_equal_ptr as_greater_equal;
|
|
expr_less_ptr as_less;
|
|
expr_greater_ptr as_greater;
|
|
expr_or_ptr as_or;
|
|
expr_and_ptr as_and;
|
|
expr_binary_ptr as_binary;
|
|
expr_assign_ptr as_assign;
|
|
expr_assign_equal_ptr as_assign_equal;
|
|
expr_assign_add_ptr as_assign_add;
|
|
expr_assign_sub_ptr as_assign_sub;
|
|
expr_assign_mult_ptr as_assign_mult;
|
|
expr_assign_div_ptr as_assign_div;
|
|
expr_assign_mod_ptr as_assign_mod;
|
|
expr_assign_shift_left_ptr as_assign_shift_left;
|
|
expr_assign_shift_right_ptr as_assign_shift_right;
|
|
expr_assign_bitwise_or_ptr as_assign_bw_or;
|
|
expr_assign_bitwise_and_ptr as_assign_bw_and;
|
|
expr_assign_bitwise_exor_ptr as_assign_bw_xor;
|
|
expr_increment_ptr as_increment;
|
|
expr_decrement_ptr as_decrement;
|
|
asm_create_ptr as_asm_create;
|
|
asm_access_ptr as_asm_access;
|
|
|
|
expr_ptr() {}
|
|
expr_ptr(node_ptr val): as_node(std::move(val)) {}
|
|
expr_ptr (expr_ptr && val)
|
|
{
|
|
new(&as_node) node_ptr(std::move(val.as_node));
|
|
}
|
|
|
|
~expr_ptr(){}
|
|
|
|
expr_ptr& operator=(expr_ptr && val)
|
|
{
|
|
new(&as_node) node_ptr(std::move(val.as_node));
|
|
return *(expr_ptr*)&as_node;
|
|
}
|
|
|
|
bool operator==(const expr_ptr& rhs) const;
|
|
};
|
|
|
|
union stmt_ptr
|
|
{
|
|
node_ptr as_node;
|
|
stmt_list_ptr as_list;
|
|
stmt_call_ptr as_call;
|
|
stmt_assign_ptr as_assign;
|
|
stmt_endon_ptr as_endon;
|
|
stmt_notify_ptr as_notify;
|
|
stmt_wait_ptr as_wait;
|
|
stmt_waittill_ptr as_waittill;
|
|
stmt_waittillmatch_ptr as_waittillmatch;
|
|
stmt_waittillframeend_ptr as_waittillframeend;
|
|
stmt_waitframe_ptr as_waitframe;
|
|
stmt_if_ptr as_if;
|
|
stmt_ifelse_ptr as_ifelse;
|
|
stmt_while_ptr as_while;
|
|
stmt_for_ptr as_for;
|
|
stmt_foreach_ptr as_foreach;
|
|
stmt_switch_ptr as_switch;
|
|
stmt_case_ptr as_case;
|
|
stmt_default_ptr as_default;
|
|
stmt_break_ptr as_break;
|
|
stmt_continue_ptr as_continue;
|
|
stmt_return_ptr as_return;
|
|
stmt_breakpoint_ptr as_breakpoint;
|
|
stmt_prof_begin_ptr as_prof_begin;
|
|
stmt_prof_end_ptr as_prof_end;
|
|
asm_loc_ptr as_loc;
|
|
asm_jump_cond_ptr as_cond;
|
|
asm_jump_ptr as_jump;
|
|
asm_jump_back_ptr as_jump_back;
|
|
asm_switch_ptr as_asm_switch;
|
|
asm_endswitch_ptr as_asm_endswitch;
|
|
asm_create_ptr as_asm_create;
|
|
asm_access_ptr as_asm_access;
|
|
asm_remove_ptr as_asm_remove;
|
|
asm_clear_ptr as_asm_clear;
|
|
|
|
stmt_ptr() {}
|
|
stmt_ptr(node_ptr val): as_node(std::move(val)) {}
|
|
stmt_ptr(const stmt_ptr &) = delete;
|
|
stmt_ptr & operator=(const stmt_ptr &) = delete;
|
|
|
|
stmt_ptr (stmt_ptr && val) { new(&as_node) node_ptr(std::move(val.as_node)); }
|
|
stmt_ptr& operator=(stmt_ptr &&val )
|
|
{
|
|
new(&as_node) node_ptr(std::move(val.as_node));
|
|
return *(stmt_ptr*)&as_node;
|
|
}
|
|
~stmt_ptr(){}
|
|
};
|
|
|
|
union define_ptr
|
|
{
|
|
node_ptr as_node;
|
|
usingtree_ptr as_usingtree;
|
|
constant_ptr as_constant;
|
|
thread_ptr as_thread;
|
|
|
|
define_ptr() {}
|
|
define_ptr(node_ptr val): as_node(std::move(val)) {}
|
|
define_ptr(define_ptr && val) { new(&as_node) node_ptr(std::move(val.as_node)); }
|
|
~define_ptr(){}
|
|
};
|
|
|
|
struct node
|
|
{
|
|
node_t type;
|
|
location loc;
|
|
|
|
node() : type(node_t::null) {}
|
|
node(node_t type) : type(type) {}
|
|
node(node_t type, const location& loc) : type(type), loc(loc) {}
|
|
node(const location& loc) : type(node_t::null), loc(loc) {}
|
|
|
|
virtual ~node() = default;
|
|
virtual auto print() -> std::string { return ""; };
|
|
|
|
protected:
|
|
static std::uint32_t indent_;
|
|
static void reset_indentation() { indent_ = 0; }
|
|
static std::string indented(std::uint32_t indent)
|
|
{
|
|
static char buff[100];
|
|
snprintf(buff, sizeof(buff), "%*s", indent, "");
|
|
return std::string(buff);
|
|
}
|
|
|
|
public:
|
|
static auto is_special_stmt(const gsc::stmt_ptr& stmt) -> bool
|
|
{
|
|
switch(stmt.as_node->type)
|
|
{
|
|
case gsc::node_t::stmt_if:
|
|
case gsc::node_t::stmt_ifelse:
|
|
case gsc::node_t::stmt_while:
|
|
case gsc::node_t::stmt_for:
|
|
case gsc::node_t::stmt_foreach:
|
|
case gsc::node_t::stmt_switch:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static auto is_special_stmt_noif(const stmt_ptr& stmt) -> bool
|
|
{
|
|
switch(stmt.as_node->type)
|
|
{
|
|
case gsc::node_t::stmt_while:
|
|
case gsc::node_t::stmt_for:
|
|
case gsc::node_t::stmt_foreach:
|
|
case gsc::node_t::stmt_switch:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
auto is_binary() -> bool
|
|
{
|
|
switch(type)
|
|
{
|
|
case gsc::node_t::expr_or:
|
|
case gsc::node_t::expr_and:
|
|
case gsc::node_t::expr_bitwise_or:
|
|
case gsc::node_t::expr_bitwise_exor:
|
|
case gsc::node_t::expr_bitwise_and:
|
|
case gsc::node_t::expr_equality:
|
|
case gsc::node_t::expr_inequality:
|
|
case gsc::node_t::expr_less:
|
|
case gsc::node_t::expr_greater:
|
|
case gsc::node_t::expr_less_equal:
|
|
case gsc::node_t::expr_greater_equal:
|
|
case gsc::node_t::expr_shift_left:
|
|
case gsc::node_t::expr_shift_right:
|
|
case gsc::node_t::expr_add:
|
|
case gsc::node_t::expr_sub:
|
|
case gsc::node_t::expr_mult:
|
|
case gsc::node_t::expr_div:
|
|
case gsc::node_t::expr_mod:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
auto precedence() -> std::uint8_t
|
|
{
|
|
switch(type)
|
|
{
|
|
case gsc::node_t::expr_or: return 1;
|
|
case gsc::node_t::expr_and: return 2;
|
|
case gsc::node_t::expr_bitwise_or: return 3;
|
|
case gsc::node_t::expr_bitwise_exor: return 4;
|
|
case gsc::node_t::expr_bitwise_and: return 5;
|
|
case gsc::node_t::expr_equality: return 6;
|
|
case gsc::node_t::expr_inequality: return 6;
|
|
case gsc::node_t::expr_less: return 7;
|
|
case gsc::node_t::expr_greater: return 7;
|
|
case gsc::node_t::expr_less_equal: return 7;
|
|
case gsc::node_t::expr_greater_equal:return 7;
|
|
case gsc::node_t::expr_shift_left: return 8;
|
|
case gsc::node_t::expr_shift_right: return 8;
|
|
case gsc::node_t::expr_add: return 9;
|
|
case gsc::node_t::expr_sub: return 9;
|
|
case gsc::node_t::expr_mult: return 10;
|
|
case gsc::node_t::expr_div: return 10;
|
|
case gsc::node_t::expr_mod: return 10;
|
|
default: return 0;
|
|
}
|
|
}
|
|
};
|
|
|
|
struct node_true : public node
|
|
{
|
|
node_true() : node(node_t::data_true) {}
|
|
node_true(const location& loc) : node(node_t::data_true, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "true";
|
|
}
|
|
|
|
friend bool operator==(const node_true& lhs, const node_true& rhs)
|
|
{
|
|
return true;
|
|
}
|
|
};
|
|
|
|
struct node_false : public node
|
|
{
|
|
node_false() : node(node_t::data_false) {}
|
|
node_false(const location& loc) : node(node_t::data_false, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "false";
|
|
}
|
|
|
|
friend bool operator==(const node_false& lhs, const node_false& rhs)
|
|
{
|
|
return true;
|
|
}
|
|
};
|
|
|
|
struct node_integer : public node
|
|
{
|
|
std::string value;
|
|
|
|
node_integer(const std::string& value)
|
|
: node(node_t::data_integer), value(std::move(value)) {}
|
|
|
|
node_integer(const location& loc, const std::string& value)
|
|
: node(node_t::data_integer, loc), value(std::move(value)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return value;
|
|
}
|
|
|
|
friend bool operator==(const node_integer& lhs, const node_integer& rhs)
|
|
{
|
|
return lhs.value == rhs.value;
|
|
}
|
|
};
|
|
|
|
struct node_float : public node
|
|
{
|
|
std::string value;
|
|
|
|
node_float(const std::string& value)
|
|
: node(node_t::data_float), value(std::move(value)) {}
|
|
|
|
node_float(const location& loc, const std::string& value)
|
|
: node(node_t::data_float, loc), value(std::move(value)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return value;
|
|
}
|
|
|
|
friend bool operator==(const node_float& lhs, const node_float& rhs)
|
|
{
|
|
return lhs.value == rhs.value;
|
|
}
|
|
};
|
|
|
|
struct node_vector : public node
|
|
{
|
|
expr_ptr x;
|
|
expr_ptr y;
|
|
expr_ptr z;
|
|
|
|
node_vector(expr_ptr x, expr_ptr y, expr_ptr z)
|
|
: node(node_t::data_vector), x(std::move(x)), y(std::move(y)), z(std::move(z)) {}
|
|
|
|
node_vector(const location& loc, expr_ptr x, expr_ptr y, expr_ptr z)
|
|
: node(node_t::data_vector, loc), x(std::move(x)), y(std::move(y)), z(std::move(z)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "( "s + x.as_node->print() + ", " + y.as_node->print() + ", "+ z.as_node->print() + " )";
|
|
}
|
|
|
|
friend bool operator==(const node_vector& lhs, const node_vector& rhs)
|
|
{
|
|
return lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z;
|
|
}
|
|
};
|
|
|
|
struct node_string : public node
|
|
{
|
|
std::string value;
|
|
|
|
node_string(const std::string& value)
|
|
: node(node_t::data_string), value(value) {}
|
|
|
|
node_string(const location& loc, const std::string& value)
|
|
: node(node_t::data_string, loc), value(value) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return value;
|
|
}
|
|
|
|
friend bool operator==(const node_string& lhs, const node_string& rhs)
|
|
{
|
|
return lhs.value == rhs.value;
|
|
}
|
|
};
|
|
|
|
struct node_istring : public node
|
|
{
|
|
std::string value;
|
|
|
|
node_istring(const std::string& value)
|
|
: node(node_t::data_istring), value(std::move(value)) {}
|
|
|
|
node_istring(const location& loc, const std::string& value)
|
|
: node(node_t::data_istring, loc), value(std::move(value)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "&"s += value;
|
|
}
|
|
|
|
friend bool operator==(const node_istring& lhs, const node_istring& rhs)
|
|
{
|
|
return lhs.value == rhs.value;
|
|
}
|
|
};
|
|
|
|
struct node_file : public node
|
|
{
|
|
std::string value;
|
|
|
|
node_file() : node(node_t::data_file) {}
|
|
|
|
node_file(const std::string& value)
|
|
: node(node_t::data_file), value(value) {}
|
|
|
|
node_file(const location& loc)
|
|
: node(node_t::data_file, loc) {}
|
|
|
|
node_file(const location& loc, const std::string& value)
|
|
: node(node_t::data_file, loc), value(value) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return value;
|
|
}
|
|
|
|
friend bool operator==(const node_file& lhs, const node_file& rhs)
|
|
{
|
|
return lhs.value == rhs.value;
|
|
}
|
|
};
|
|
|
|
struct node_name : public node
|
|
{
|
|
std::string value;
|
|
|
|
node_name(const std::string& value)
|
|
: node(node_t::data_name), value(value) {}
|
|
|
|
node_name(const location& loc, const std::string& value)
|
|
: node(node_t::data_name, loc), value(value) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return value;
|
|
}
|
|
|
|
friend bool operator==(const node_name& lhs, const node_name& rhs)
|
|
{
|
|
return lhs.value == rhs.value;
|
|
}
|
|
};
|
|
|
|
struct node_animtree : public node
|
|
{
|
|
node_animtree() : node(node_t::data_animtree) {}
|
|
|
|
node_animtree(const location& loc) : node(node_t::data_animtree, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "#animtree";
|
|
}
|
|
|
|
friend bool operator==(const node_animtree& lhs, const node_animtree& rhs)
|
|
{
|
|
return true;
|
|
}
|
|
};
|
|
|
|
struct node_animation : public node
|
|
{
|
|
std::string value;
|
|
|
|
node_animation(const std::string& value)
|
|
: node(node_t::data_animation), value(value) {}
|
|
|
|
node_animation(const location& loc, const std::string& value)
|
|
: node(node_t::data_animation, loc), value(value) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "%"s += value;
|
|
}
|
|
|
|
friend bool operator==(const node_animation& lhs, const node_animation& rhs)
|
|
{
|
|
return lhs.value == rhs.value;
|
|
}
|
|
};
|
|
|
|
struct node_level : public node
|
|
{
|
|
node_level() : node(node_t::data_level) {}
|
|
|
|
node_level(const location& loc) : node(node_t::data_level, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "level";
|
|
}
|
|
|
|
friend bool operator==(const node_level& lhs, const node_level& rhs)
|
|
{
|
|
return true;
|
|
}
|
|
};
|
|
|
|
struct node_anim : public node
|
|
{
|
|
node_anim() : node(node_t::data_anim) {}
|
|
|
|
node_anim(const location& loc) : node(node_t::data_anim, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "anim";
|
|
}
|
|
|
|
friend bool operator==(const node_anim& lhs, const node_anim& rhs)
|
|
{
|
|
return true;
|
|
}
|
|
};
|
|
|
|
struct node_self : public node
|
|
{
|
|
node_self() : node(node_t::data_self) {}
|
|
|
|
node_self(const location& loc) : node(node_t::data_self, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "self";
|
|
}
|
|
|
|
friend bool operator==(const node_self& lhs, const node_self& rhs)
|
|
{
|
|
return true;
|
|
}
|
|
};
|
|
|
|
struct node_game : public node
|
|
{
|
|
node_game() : node(node_t::data_game) {}
|
|
|
|
node_game(const location& loc) : node(node_t::data_game, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "game";
|
|
}
|
|
|
|
friend bool operator==(const node_game& lhs, const node_game& rhs)
|
|
{
|
|
return true;
|
|
}
|
|
};
|
|
|
|
struct node_undefined : public node
|
|
{
|
|
node_undefined() : node(node_t::data_undefined) {}
|
|
|
|
node_undefined(const location& loc) : node(node_t::data_undefined, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "undefined";
|
|
}
|
|
|
|
friend bool operator==(const node_undefined& lhs, const node_undefined& rhs)
|
|
{
|
|
return true;
|
|
}
|
|
};
|
|
|
|
struct node_empty_array : public node
|
|
{
|
|
node_empty_array() : node(node_t::data_empty_array) {}
|
|
|
|
node_empty_array(const location& loc) : node(node_t::data_empty_array, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "[]";
|
|
}
|
|
|
|
friend bool operator==(const node_empty_array& lhs, const node_empty_array& rhs)
|
|
{
|
|
return true;
|
|
}
|
|
};
|
|
|
|
struct node_thisthread : public node
|
|
{
|
|
node_thisthread() : node(node_t::data_thisthread) {}
|
|
|
|
node_thisthread(const location& loc) : node(node_t::data_thisthread, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "thisthread";
|
|
}
|
|
|
|
friend bool operator==(const node_thisthread& lhs, const node_thisthread& rhs)
|
|
{
|
|
return true;
|
|
}
|
|
};
|
|
|
|
struct node_expr_paren : public node
|
|
{
|
|
expr_ptr expr;
|
|
|
|
node_expr_paren(expr_ptr expr)
|
|
: node(node_t::expr_paren), expr(std::move(expr)) {}
|
|
|
|
node_expr_paren(const location& loc, expr_ptr expr)
|
|
: node(node_t::expr_paren, loc), expr(std::move(expr)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "( " + expr.as_node->print() + " )";
|
|
}
|
|
|
|
friend bool operator==(const node_expr_paren& lhs, const node_expr_paren& rhs)
|
|
{
|
|
return lhs.expr == rhs.expr;
|
|
}
|
|
};
|
|
|
|
struct node_expr_size : public node
|
|
{
|
|
expr_ptr obj;
|
|
|
|
node_expr_size(expr_ptr obj)
|
|
: node(node_t::expr_size), obj(std::move(obj)) {}
|
|
|
|
node_expr_size(const location& loc, expr_ptr obj)
|
|
: node(node_t::expr_size, loc), obj(std::move(obj)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return obj.as_node->print() + ".size";
|
|
}
|
|
|
|
friend bool operator==(const node_expr_size& lhs, const node_expr_size& rhs)
|
|
{
|
|
return lhs.obj == rhs.obj;
|
|
}
|
|
};
|
|
|
|
struct node_expr_field : public node
|
|
{
|
|
expr_ptr obj;
|
|
name_ptr field;
|
|
|
|
node_expr_field(expr_ptr obj, name_ptr field)
|
|
: node(node_t::expr_field), obj(std::move(obj)), field(std::move(field)) {}
|
|
|
|
node_expr_field(const location& loc, expr_ptr obj, name_ptr field)
|
|
: node(node_t::expr_field, loc), obj(std::move(obj)), field(std::move(field)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return obj.as_node->print() + "." + field->print();
|
|
}
|
|
|
|
friend bool operator==(const node_expr_field& lhs, const node_expr_field& rhs)
|
|
{
|
|
return lhs.obj == rhs.obj && lhs.field == rhs.field;
|
|
}
|
|
};
|
|
|
|
struct node_expr_array : public node
|
|
{
|
|
expr_ptr obj;
|
|
expr_ptr key;
|
|
|
|
node_expr_array(expr_ptr obj, expr_ptr key)
|
|
: node(node_t::expr_array), obj(std::move(obj)), key(std::move(key)) {}
|
|
|
|
node_expr_array(const location& loc, expr_ptr obj, expr_ptr key)
|
|
: node(node_t::expr_array, loc), obj(std::move(obj)), key(std::move(key)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return obj.as_node->print() + "[" + key.as_node->print() + "]";
|
|
}
|
|
|
|
friend bool operator==(const node_expr_array& lhs, const node_expr_array& rhs)
|
|
{
|
|
return lhs.obj == rhs.obj && lhs.key == rhs.key;
|
|
}
|
|
};
|
|
|
|
struct node_expr_arguments : public node
|
|
{
|
|
std::vector<expr_ptr> list;
|
|
|
|
node_expr_arguments() : node(node_t::expr_arguments) {}
|
|
|
|
node_expr_arguments(const location& loc) : node(node_t::expr_arguments, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
std::string data;
|
|
|
|
for (const auto& arg : list)
|
|
{
|
|
data += " " + arg.as_node->print();
|
|
data += (&arg != &list.back()) ? "," : " ";
|
|
}
|
|
|
|
return data;
|
|
}
|
|
};
|
|
|
|
struct node_expr_add_array : public node
|
|
{
|
|
expr_arguments_ptr args;
|
|
|
|
node_expr_add_array(expr_arguments_ptr args)
|
|
: node(node_t::expr_add_array), args(std::move(args)) {}
|
|
|
|
node_expr_add_array(const location& loc, expr_arguments_ptr args)
|
|
: node(node_t::expr_add_array, loc), args(std::move(args)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "[" + args->print() + "]";
|
|
}
|
|
};
|
|
|
|
struct node_expr_function : public node
|
|
{
|
|
file_ptr file;
|
|
name_ptr name;
|
|
|
|
node_expr_function(file_ptr file, name_ptr name)
|
|
: node(node_t::expr_function), file(std::move(file)), name(std::move(name)) {}
|
|
|
|
node_expr_function(const location& loc, file_ptr file, name_ptr name)
|
|
: node(node_t::expr_function, loc), file(std::move(file)), name(std::move(name)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return file->print() + "::" + name->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_call_pointer : public node
|
|
{
|
|
expr_ptr expr;
|
|
expr_arguments_ptr args;
|
|
bool builtin;
|
|
|
|
node_expr_call_pointer(bool builtin, expr_ptr expr, expr_arguments_ptr args)
|
|
: node(node_t::expr_call_pointer), builtin(builtin), expr(std::move(expr)), args(std::move(args)) {}
|
|
|
|
node_expr_call_pointer(const location& loc, bool builtin, expr_ptr expr, expr_arguments_ptr args)
|
|
: node(node_t::expr_call_pointer, loc), builtin(builtin), expr(std::move(expr)), args(std::move(args)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
if(builtin)
|
|
return "call [[ "s + expr.as_node->print() + " ]](" + args->print() + ")";
|
|
else
|
|
return "[[ "s + expr.as_node->print() + " ]](" + args->print() + ")";
|
|
}
|
|
};
|
|
|
|
struct node_expr_call_function : public node
|
|
{
|
|
file_ptr file;
|
|
name_ptr name;
|
|
expr_arguments_ptr args;
|
|
|
|
node_expr_call_function(file_ptr file, name_ptr name, expr_arguments_ptr args)
|
|
: node(node_t::expr_call_function), file(std::move(file)), name(std::move(name)), args(std::move(args)) {}
|
|
|
|
node_expr_call_function(const location& loc, file_ptr file, name_ptr name, expr_arguments_ptr args)
|
|
: node(node_t::expr_call_function, loc), file(std::move(file)), name(std::move(name)), args(std::move(args)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
if(file->value == "") return name->print() + "(" + args->print() + ")";
|
|
|
|
return file->print() + "::" + name->print() + "(" + args->print() + ")";
|
|
}
|
|
};
|
|
|
|
struct node_expr_call : public node
|
|
{
|
|
expr_ptr obj;
|
|
expr_call_type_ptr func;
|
|
bool thread;
|
|
bool child;
|
|
|
|
node_expr_call(bool thread, bool child, expr_ptr obj, expr_call_type_ptr func)
|
|
: node(node_t::expr_call), thread(thread), child(child), obj(std::move(obj)), func(std::move(func)){}
|
|
|
|
node_expr_call(const location& loc, bool thread, bool child, expr_ptr obj, expr_call_type_ptr func)
|
|
: node(node_t::expr_call, loc), thread(thread), child(child), obj(std::move(obj)), func(std::move(func)){}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
if(thread)
|
|
{
|
|
if(obj.as_node->type == node_t::null) return "thread " + func.as_node->print();
|
|
return obj.as_node->print() + " thread " + func.as_node->print();
|
|
}
|
|
|
|
if(child)
|
|
{
|
|
if(obj.as_node->type == node_t::null) return "childthread " + func.as_node->print();
|
|
return obj.as_node->print() + " childthread " + func.as_node->print();
|
|
}
|
|
|
|
if(obj.as_node->type == node_t::null) return func.as_node->print();
|
|
return obj.as_node->print() + " " + func.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_complement : public node
|
|
{
|
|
expr_ptr rvalue;
|
|
|
|
node_expr_complement(expr_ptr rvalue)
|
|
: node(node_t::expr_complement), rvalue(std::move(rvalue)) {}
|
|
|
|
node_expr_complement(const location& loc, expr_ptr rvalue)
|
|
: node(node_t::expr_complement, loc), rvalue(std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "~" + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_not : public node
|
|
{
|
|
expr_ptr rvalue;
|
|
|
|
node_expr_not(expr_ptr rvalue)
|
|
: node(node_t::expr_not), rvalue(std::move(rvalue)) {}
|
|
|
|
node_expr_not(const location& loc, expr_ptr rvalue)
|
|
: node(node_t::expr_not, loc), rvalue(std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "!" + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_binary : public node
|
|
{
|
|
expr_ptr lvalue;
|
|
expr_ptr rvalue;
|
|
|
|
node_expr_binary(node_t type, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node(type), lvalue(std::move(lvalue)), rvalue(std::move(rvalue)) {}
|
|
|
|
node_expr_binary(node_t type, const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node(type, loc), lvalue(std::move(lvalue)), rvalue(std::move(rvalue)) {}
|
|
};
|
|
|
|
struct node_expr_add : public node_expr_binary
|
|
{
|
|
node_expr_add(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_add, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_add(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_add, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " + " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_sub : public node_expr_binary
|
|
{
|
|
node_expr_sub(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_sub, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_sub(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_sub, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " - " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_mult : public node_expr_binary
|
|
{
|
|
node_expr_mult( expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_mult, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_mult(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_mult, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " * " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_div : public node_expr_binary
|
|
{
|
|
node_expr_div(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_div, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_div(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_div, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " / " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_mod : public node_expr_binary
|
|
{
|
|
node_expr_mod(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_mod, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_mod(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_mod, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " % " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_shift_left : public node_expr_binary
|
|
{
|
|
node_expr_shift_left(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_shift_left, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_shift_left(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_shift_left, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " << " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_shift_right : public node_expr_binary
|
|
{
|
|
node_expr_shift_right(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_shift_right, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_shift_right(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_shift_right, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " >> " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_bitwise_or : public node_expr_binary
|
|
{
|
|
node_expr_bitwise_or(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_bitwise_or, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_bitwise_or(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_bitwise_or, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " | " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_bitwise_and : public node_expr_binary
|
|
{
|
|
node_expr_bitwise_and(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_bitwise_and, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_bitwise_and(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_bitwise_and, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " & " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_bitwise_exor : public node_expr_binary
|
|
{
|
|
node_expr_bitwise_exor(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_bitwise_exor, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_bitwise_exor(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_bitwise_exor, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " ^ " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_equality : public node_expr_binary
|
|
{
|
|
node_expr_equality(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_equality, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_equality(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_equality, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " == " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_inequality : public node_expr_binary
|
|
{
|
|
node_expr_inequality(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_inequality, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_inequality(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_inequality, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " != " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_less_equal : public node_expr_binary
|
|
{
|
|
node_expr_less_equal(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_less_equal, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_less_equal(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_less_equal, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " <= " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_greater_equal : public node_expr_binary
|
|
{
|
|
node_expr_greater_equal(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_greater_equal, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_greater_equal(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_greater_equal, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " >= " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_less : public node_expr_binary
|
|
{
|
|
node_expr_less(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_less, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_less(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_less, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " < " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_greater : public node_expr_binary
|
|
{
|
|
node_expr_greater(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_greater, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_greater(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_greater, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " > " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_or : public node_expr_binary
|
|
{
|
|
node_expr_or(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_or, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_or(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_or, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " || " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_and : public node_expr_binary
|
|
{
|
|
node_expr_and(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_and, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_and(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_binary(node_t::expr_and, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " && " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_assign: public node
|
|
{
|
|
expr_ptr lvalue;
|
|
expr_ptr rvalue;
|
|
|
|
node_expr_assign(node_t type, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node(type), lvalue(std::move(lvalue)), rvalue(std::move(rvalue)) {}
|
|
|
|
node_expr_assign(node_t type, const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node(type, loc), lvalue(std::move(lvalue)), rvalue(std::move(rvalue)) {}
|
|
};
|
|
|
|
struct node_expr_assign_equal : public node_expr_assign
|
|
{
|
|
node_expr_assign_equal(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_equal, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_assign_equal(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_equal, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " = " + rvalue.as_node->print() ;
|
|
};
|
|
};
|
|
|
|
struct node_expr_assign_add : public node_expr_assign
|
|
{
|
|
node_expr_assign_add(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_add, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_assign_add(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_add, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " += " + rvalue.as_node->print() ;
|
|
};
|
|
};
|
|
|
|
struct node_expr_assign_sub : public node_expr_assign
|
|
{
|
|
node_expr_assign_sub(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_sub, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_assign_sub(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_sub, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " -= " + rvalue.as_node->print() ;
|
|
};
|
|
};
|
|
|
|
struct node_expr_assign_mult : public node_expr_assign
|
|
{
|
|
node_expr_assign_mult(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_mult, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_assign_mult(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_mult, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " *= " + rvalue.as_node->print() ;
|
|
};
|
|
};
|
|
|
|
struct node_expr_assign_div : public node_expr_assign
|
|
{
|
|
node_expr_assign_div(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_div, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_assign_div(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_div, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " /= " + rvalue.as_node->print() ;
|
|
};
|
|
};
|
|
|
|
struct node_expr_assign_mod : public node_expr_assign
|
|
{
|
|
node_expr_assign_mod(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_mod, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_assign_mod(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_mod, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " %= " + rvalue.as_node->print() ;
|
|
};
|
|
};
|
|
|
|
struct node_expr_assign_shift_left : public node_expr_assign
|
|
{
|
|
node_expr_assign_shift_left(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_shift_left, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_assign_shift_left(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_shift_left, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " <<= " + rvalue.as_node->print() ;
|
|
};
|
|
};
|
|
|
|
struct node_expr_assign_shift_right : public node_expr_assign
|
|
{
|
|
node_expr_assign_shift_right(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_shift_right, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_assign_shift_right(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_shift_right, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " >>= " + rvalue.as_node->print() ;
|
|
};
|
|
};
|
|
|
|
struct node_expr_assign_bitwise_or : public node_expr_assign
|
|
{
|
|
node_expr_assign_bitwise_or(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_bitwise_or, std::move(lvalue),
|
|
std::move(rvalue)) {}
|
|
|
|
node_expr_assign_bitwise_or(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_bitwise_or, loc, std::move(lvalue),
|
|
std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " |= " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_assign_bitwise_and : public node_expr_assign
|
|
{
|
|
node_expr_assign_bitwise_and(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_bitwise_and, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
node_expr_assign_bitwise_and(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_bitwise_and, loc, std::move(lvalue), std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " &= " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_assign_bitwise_exor : public node_expr_assign
|
|
{
|
|
node_expr_assign_bitwise_exor(expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_bitwise_exor, std::move(lvalue),
|
|
std::move(rvalue)) {}
|
|
|
|
node_expr_assign_bitwise_exor(const location& loc, expr_ptr lvalue, expr_ptr rvalue)
|
|
: node_expr_assign(node_t::expr_assign_bitwise_exor, loc, std::move(lvalue),
|
|
std::move(rvalue)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + " ^= " + rvalue.as_node->print();
|
|
}
|
|
};
|
|
|
|
struct node_expr_increment : public node_expr_assign
|
|
{
|
|
node_expr_increment(expr_ptr lvalue)
|
|
: node_expr_assign(node_t::expr_increment, std::move(lvalue), std::make_unique<node>()) {}
|
|
|
|
node_expr_increment(const location& loc, expr_ptr lvalue)
|
|
: node_expr_assign(node_t::expr_increment, loc, std::move(lvalue), std::make_unique<node>()) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + "++";
|
|
}
|
|
};
|
|
|
|
struct node_expr_decrement : public node_expr_assign
|
|
{
|
|
node_expr_decrement(expr_ptr lvalue)
|
|
: node_expr_assign(node_t::expr_decrement, std::move(lvalue), std::make_unique<node>()) {}
|
|
|
|
node_expr_decrement(const location& loc, expr_ptr lvalue)
|
|
: node_expr_assign(node_t::expr_decrement, loc, std::move(lvalue), std::make_unique<node>()) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return lvalue.as_node->print() + "--";
|
|
}
|
|
};
|
|
|
|
struct node_stmt_list : public node
|
|
{
|
|
std::vector<stmt_ptr> stmts;
|
|
bool is_case = false;
|
|
bool is_expr = false;
|
|
|
|
node_stmt_list() : node(node_t::stmt_list) {}
|
|
|
|
node_stmt_list(const location& loc) : node(node_t::stmt_list, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
if(is_expr)
|
|
{
|
|
if(stmts.size() > 0)
|
|
{
|
|
auto s = stmts[0].as_node->print();
|
|
s.pop_back();
|
|
return s;
|
|
}
|
|
else return "";
|
|
}
|
|
|
|
std::string data;
|
|
bool last_special = false;
|
|
auto block_pad = indented(indent_);
|
|
indent_ += 4;
|
|
|
|
auto stmts_pad = indented(indent_);
|
|
|
|
if(!is_case)
|
|
data += block_pad + "{\n";
|
|
|
|
for (const auto& stmt : stmts)
|
|
{
|
|
if (&stmt != &stmts.front() && is_special_stmt(stmt) || last_special)
|
|
data += "\n";
|
|
|
|
data += stmts_pad + stmt.as_node->print();
|
|
|
|
if (&stmt != &stmts.back())
|
|
data += "\n";
|
|
|
|
if(is_special_stmt(stmt))
|
|
last_special = true;
|
|
else
|
|
last_special = false;
|
|
}
|
|
|
|
indent_ -= 4;
|
|
|
|
if(!is_case)
|
|
data += "\n" + block_pad + "}";
|
|
|
|
return data;
|
|
}
|
|
};
|
|
|
|
struct node_stmt_call : public node
|
|
{
|
|
expr_call_ptr expr;
|
|
|
|
node_stmt_call(expr_call_ptr expr)
|
|
: node(node_t::stmt_call), expr(std::move(expr)) {}
|
|
|
|
node_stmt_call(const location& loc, expr_call_ptr expr)
|
|
: node(node_t::stmt_call, loc), expr(std::move(expr)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return expr->print() + ";";
|
|
};
|
|
};
|
|
|
|
struct node_stmt_assign : public node
|
|
{
|
|
expr_assign_ptr expr;
|
|
|
|
node_stmt_assign(expr_assign_ptr expr)
|
|
: node(node_t::stmt_assign), expr(std::move(expr)) {}
|
|
|
|
node_stmt_assign(const location& loc, expr_assign_ptr expr)
|
|
: node(node_t::stmt_assign, loc), expr(std::move(expr)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return expr->print() + ";";
|
|
};
|
|
};
|
|
|
|
struct node_stmt_endon : public node
|
|
{
|
|
expr_ptr obj;
|
|
expr_ptr expr;
|
|
|
|
node_stmt_endon(expr_ptr obj, expr_ptr expr)
|
|
: node(node_t::stmt_endon), obj(std::move(obj)), expr(std::move(expr)) {}
|
|
|
|
node_stmt_endon(const location& loc, expr_ptr obj, expr_ptr expr)
|
|
: node(node_t::stmt_endon, loc), obj(std::move(obj)), expr(std::move(expr)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return obj.as_node->print() + " endon( " + expr.as_node->print() + " );";
|
|
};
|
|
};
|
|
|
|
struct node_stmt_notify : public node
|
|
{
|
|
expr_ptr obj;
|
|
expr_ptr expr;
|
|
expr_arguments_ptr args;
|
|
|
|
node_stmt_notify(expr_ptr obj, expr_ptr expr, expr_arguments_ptr args)
|
|
: node(node_t::stmt_notify), obj(std::move(obj)), expr(std::move(expr)), args(std::move(args)) {}
|
|
|
|
node_stmt_notify(const location& loc, expr_ptr obj, expr_ptr expr, expr_arguments_ptr args)
|
|
: node(node_t::stmt_notify, loc), obj(std::move(obj)), expr(std::move(expr)), args(std::move(args)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
if (args->list.size() == 0)
|
|
return obj.as_node->print() + " notify( " + expr.as_node->print() + " );";
|
|
else
|
|
return obj.as_node->print() + " notify( " + expr.as_node->print() + ", " + args->print() + " );";
|
|
};
|
|
};
|
|
|
|
struct node_stmt_wait : public node
|
|
{
|
|
expr_ptr expr;
|
|
|
|
node_stmt_wait(expr_ptr expr)
|
|
: node(node_t::stmt_wait), expr(std::move(expr)) {}
|
|
|
|
node_stmt_wait(const location& loc, expr_ptr expr)
|
|
: node(node_t::stmt_wait, loc), expr(std::move(expr)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
if(expr.as_node->type == node_t::data_float || expr.as_node->type == node_t::data_integer)
|
|
return "wait " + expr.as_node->print() + ";";
|
|
else
|
|
return "wait(" + expr.as_node->print() + ");";
|
|
};
|
|
};
|
|
|
|
struct node_stmt_waittill : public node
|
|
{
|
|
expr_ptr obj;
|
|
expr_ptr expr;
|
|
expr_arguments_ptr args;
|
|
|
|
node_stmt_waittill(expr_ptr obj, expr_ptr expr, expr_arguments_ptr args)
|
|
: node(node_t::stmt_waittill), obj(std::move(obj)), expr(std::move(expr)), args(std::move(args)) {}
|
|
|
|
node_stmt_waittill(const location& loc, expr_ptr obj, expr_ptr expr, expr_arguments_ptr args)
|
|
: node(node_t::stmt_waittill, loc), obj(std::move(obj)), expr(std::move(expr)), args(std::move(args)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
if (args->list.size() == 0)
|
|
return obj.as_node->print() + " waittill( " + expr.as_node->print() + " );";
|
|
else
|
|
return obj.as_node->print() + " waittill( " + expr.as_node->print() + ", " + args->print() + " );";
|
|
};
|
|
};
|
|
|
|
struct node_stmt_waittillmatch : public node
|
|
{
|
|
expr_ptr obj;
|
|
expr_ptr expr;
|
|
expr_arguments_ptr args;
|
|
|
|
node_stmt_waittillmatch(expr_ptr obj, expr_ptr expr, expr_arguments_ptr args)
|
|
: node(node_t::stmt_waittillmatch), obj(std::move(obj)), expr(std::move(expr)), args(std::move(args)) {}
|
|
|
|
node_stmt_waittillmatch(const location& loc, expr_ptr obj, expr_ptr expr, expr_arguments_ptr args)
|
|
: node(node_t::stmt_waittillmatch, loc), obj(std::move(obj)), expr(std::move(expr)), args(std::move(args)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
if (args->list.size() == 0)
|
|
return obj.as_node->print() + " waittillmatch( " + expr.as_node->print() + " );";
|
|
else
|
|
return obj.as_node->print() + " waittillmatch( " + expr.as_node->print() + ", " + args->print() + " );";
|
|
};
|
|
};
|
|
|
|
struct node_stmt_waittillframeend : public node
|
|
{
|
|
node_stmt_waittillframeend() : node(node_t::stmt_waittillframeend) {}
|
|
|
|
node_stmt_waittillframeend(const location& loc) : node(node_t::stmt_waittillframeend, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "waittillframeend;";
|
|
};
|
|
};
|
|
|
|
struct node_stmt_waitframe : public node
|
|
{
|
|
node_stmt_waitframe() : node(node_t::stmt_waitframe) {}
|
|
|
|
node_stmt_waitframe(const location& loc) : node(node_t::stmt_waitframe, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "waitframe;";
|
|
};
|
|
};
|
|
|
|
struct node_stmt_if : public node
|
|
{
|
|
expr_ptr expr;
|
|
stmt_ptr stmt;
|
|
context_ptr ctx;
|
|
|
|
node_stmt_if(expr_ptr expr, stmt_ptr stmt)
|
|
: node(node_t::stmt_if), expr(std::move(expr)), stmt(std::move(stmt)) {}
|
|
|
|
node_stmt_if(const location& loc, expr_ptr expr, stmt_ptr stmt)
|
|
: node(node_t::stmt_if, loc), expr(std::move(expr)), stmt(std::move(stmt)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
std::string data = "if ( " + expr.as_node->print() + " )\n";
|
|
|
|
if (stmt.as_node->type == node_t::stmt_list)
|
|
{
|
|
data += stmt.as_list->print();
|
|
}
|
|
else
|
|
{
|
|
indent_ += 4;
|
|
data += indented(indent_) + stmt.as_node->print();
|
|
indent_ -= 4;
|
|
}
|
|
|
|
return data;
|
|
};
|
|
};
|
|
|
|
struct node_stmt_ifelse : public node
|
|
{
|
|
expr_ptr expr;
|
|
stmt_ptr stmt_if;
|
|
stmt_ptr stmt_else;
|
|
context_ptr ctx_if;
|
|
context_ptr ctx_else;
|
|
|
|
node_stmt_ifelse(expr_ptr expr, stmt_ptr stmt_if, stmt_ptr stmt_else)
|
|
: node(node_t::stmt_ifelse), expr(std::move(expr)), stmt_if(std::move(stmt_if)), stmt_else(std::move(stmt_else)) {}
|
|
|
|
node_stmt_ifelse(const location& loc, expr_ptr expr, stmt_ptr stmt_if, stmt_ptr stmt_else)
|
|
: node(node_t::stmt_ifelse, loc), expr(std::move(expr)), stmt_if(std::move(stmt_if)), stmt_else(std::move(stmt_else)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
std::string pad = indented(indent_);
|
|
std::string data = "if ( " + expr.as_node->print() + " )\n";
|
|
|
|
if (stmt_if.as_node->type == node_t::stmt_list)
|
|
{
|
|
data += stmt_if.as_node->print();
|
|
}
|
|
else
|
|
{
|
|
indent_ += 4;
|
|
data += indented(indent_) + stmt_if.as_node->print();
|
|
indent_ -= 4;
|
|
}
|
|
|
|
data += "\n" + pad + "else";
|
|
|
|
if (stmt_else.as_node->type == node_t::stmt_list)
|
|
{
|
|
data += "\n" + stmt_else.as_list->print();
|
|
}
|
|
else
|
|
{
|
|
if(stmt_else.as_node->type == node_t::stmt_if || stmt_else.as_node->type == node_t::stmt_ifelse)
|
|
{
|
|
data += " " + stmt_else.as_node->print();
|
|
}
|
|
else
|
|
{
|
|
indent_ += 4;
|
|
data += "\n" + indented(indent_) + stmt_else.as_node->print();
|
|
indent_ -= 4;
|
|
}
|
|
}
|
|
|
|
return data;
|
|
};
|
|
};
|
|
|
|
struct node_stmt_while : public node
|
|
{
|
|
expr_ptr expr;
|
|
stmt_ptr stmt;
|
|
context_ptr ctx;
|
|
|
|
node_stmt_while(expr_ptr expr, stmt_ptr stmt)
|
|
: node(node_t::stmt_while), expr(std::move(expr)), stmt(std::move(stmt)) {}
|
|
|
|
node_stmt_while(const location& loc, expr_ptr expr, stmt_ptr stmt)
|
|
: node(node_t::stmt_while, loc), expr(std::move(expr)), stmt(std::move(stmt)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
std::string data;
|
|
|
|
if (expr.as_node->type == node_t::null)
|
|
{
|
|
data += "while ( true )\n";
|
|
}
|
|
else
|
|
{
|
|
data += "while ( " + expr.as_node->print() + " )\n";
|
|
}
|
|
|
|
std::string pad = indented(indent_);
|
|
|
|
if (stmt.as_node->type == node_t::stmt_list)
|
|
{
|
|
data += stmt.as_node->print();
|
|
}
|
|
else
|
|
{
|
|
indent_ += 4;
|
|
data += indented(indent_) + stmt.as_node->print();
|
|
indent_ -= 4;
|
|
}
|
|
|
|
return data;
|
|
};
|
|
};
|
|
|
|
struct node_stmt_for : public node
|
|
{
|
|
stmt_ptr pre_expr;
|
|
expr_ptr expr;
|
|
stmt_ptr post_expr;
|
|
stmt_ptr stmt;
|
|
context_ptr ctx;
|
|
context_ptr ctx_post;
|
|
std::vector<std::string> vars;
|
|
|
|
node_stmt_for(stmt_ptr pre_expr, expr_ptr expr, stmt_ptr post_expr, stmt_ptr stmt)
|
|
: node(node_t::stmt_for), pre_expr(std::move(pre_expr)), expr(std::move(expr)),
|
|
post_expr(std::move(post_expr)), stmt(std::move(stmt)) {}
|
|
|
|
node_stmt_for(const location& loc, stmt_ptr pre_expr, expr_ptr expr, stmt_ptr post_expr, stmt_ptr stmt)
|
|
: node(node_t::stmt_for, loc), pre_expr(std::move(pre_expr)), expr(std::move(expr)),
|
|
post_expr(std::move(post_expr)), stmt(std::move(stmt)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
std::string data;
|
|
|
|
if (expr.as_node->type == node_t::null)
|
|
{
|
|
data += "for (;;)\n";
|
|
}
|
|
else
|
|
{
|
|
data += "for ( " + pre_expr.as_node->print() + "; " + expr.as_node->print() + "; " + post_expr.as_node->print() + " )";
|
|
data += "\n";
|
|
}
|
|
|
|
if (stmt.as_node->type == node_t::stmt_list)
|
|
{
|
|
data += stmt.as_node->print();
|
|
}
|
|
else
|
|
{
|
|
indent_ += 4;
|
|
data += indented(indent_) + stmt.as_node->print();
|
|
indent_ -= 4;
|
|
}
|
|
|
|
return data;
|
|
};
|
|
};
|
|
|
|
struct node_stmt_foreach : public node
|
|
{
|
|
expr_ptr array_expr;
|
|
expr_ptr value_expr;
|
|
expr_ptr key_expr;
|
|
expr_ptr array;
|
|
stmt_ptr pre_expr;
|
|
expr_ptr cond_expr;
|
|
stmt_ptr post_expr;
|
|
stmt_ptr stmt0;
|
|
stmt_ptr stmt;
|
|
context_ptr ctx;
|
|
context_ptr ctx_post;
|
|
bool use_key;
|
|
std::vector<std::string> vars;
|
|
|
|
node_stmt_foreach(const location& loc, stmt_ptr stmt, bool use_key)
|
|
: node(node_t::stmt_foreach, loc), stmt(std::move(stmt)), use_key(use_key) {}
|
|
|
|
node_stmt_foreach(expr_ptr element, expr_ptr container, stmt_ptr stmt)
|
|
: node(node_t::stmt_foreach), value_expr(std::move(element)), array_expr(std::move(container)),
|
|
stmt(std::move(stmt)), use_key(false) {}
|
|
|
|
node_stmt_foreach(expr_ptr key, expr_ptr element, expr_ptr container, stmt_ptr stmt)
|
|
: node(node_t::stmt_foreach), key_expr(std::move(key)), value_expr(std::move(element)), array_expr(std::move(container)),
|
|
stmt(std::move(stmt)), use_key(true) {}
|
|
|
|
node_stmt_foreach(const location& loc, expr_ptr element, expr_ptr container, stmt_ptr stmt)
|
|
: node(node_t::stmt_foreach, loc), value_expr(std::move(element)), array_expr(std::move(container)),
|
|
stmt(std::move(stmt)), use_key(false) {}
|
|
|
|
node_stmt_foreach(const location& loc, expr_ptr key, expr_ptr element, expr_ptr container, stmt_ptr stmt)
|
|
: node(node_t::stmt_foreach, loc), key_expr(std::move(key)), value_expr(std::move(element)), array_expr(std::move(container)),
|
|
stmt(std::move(stmt)), use_key(true) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
std::string data;
|
|
|
|
data += "foreach ( ";
|
|
|
|
if(use_key) data += key_expr.as_node->print() + ", ";
|
|
|
|
data += value_expr.as_node->print() + " in " + array_expr.as_node->print() + " )\n";
|
|
|
|
if (stmt.as_node->type == node_t::stmt_list)
|
|
{
|
|
data += stmt.as_node->print();
|
|
}
|
|
else
|
|
{
|
|
indent_ += 4;
|
|
data += indented(indent_) + stmt.as_node->print();
|
|
indent_ -= 4;
|
|
}
|
|
|
|
return data;
|
|
};
|
|
};
|
|
|
|
struct node_stmt_switch : public node
|
|
{
|
|
expr_ptr expr;
|
|
stmt_list_ptr stmt;
|
|
context_ptr ctx;
|
|
|
|
node_stmt_switch(expr_ptr expr, stmt_list_ptr stmt)
|
|
: node(node_t::stmt_switch), expr(std::move(expr)), stmt(std::move(stmt)) {}
|
|
|
|
node_stmt_switch(const location& loc, expr_ptr expr, stmt_list_ptr stmt)
|
|
: node(node_t::stmt_switch, loc), expr(std::move(expr)), stmt(std::move(stmt)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
std::string data;
|
|
|
|
data += "switch ( " + expr.as_node->print() + " )\n";
|
|
data += stmt->print();
|
|
|
|
return data;
|
|
};
|
|
};
|
|
|
|
struct node_stmt_case : public node
|
|
{
|
|
expr_ptr value;
|
|
stmt_list_ptr stmt;
|
|
context_ptr ctx;
|
|
|
|
node_stmt_case(expr_ptr value)
|
|
: node(node_t::stmt_case), value(std::move(value)) {}
|
|
|
|
node_stmt_case(const location& loc, expr_ptr value)
|
|
: node(node_t::stmt_case, loc), value(std::move(value)) {}
|
|
|
|
node_stmt_case(const location& loc, expr_ptr value, stmt_list_ptr stmt)
|
|
: node(node_t::stmt_case, loc), value(std::move(value)), stmt(std::move(stmt)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
if(stmt->stmts.size() == 0)
|
|
return "case " + value.as_node->print() + ":";
|
|
else
|
|
return "case " + value.as_node->print() + ":\n" + stmt->print();
|
|
};
|
|
};
|
|
|
|
struct node_stmt_default : public node
|
|
{
|
|
stmt_list_ptr stmt;
|
|
context_ptr ctx;
|
|
|
|
node_stmt_default()
|
|
: node(node_t::stmt_default) {}
|
|
|
|
node_stmt_default(const location& loc)
|
|
: node(node_t::stmt_default, loc) {}
|
|
|
|
node_stmt_default(const location& loc, stmt_list_ptr stmt)
|
|
: node(node_t::stmt_default, loc), stmt(std::move(stmt)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
if(stmt->stmts.size() == 0)
|
|
return "default:";
|
|
else
|
|
return "default:\n" + stmt->print();
|
|
};
|
|
};
|
|
|
|
struct node_stmt_break : public node
|
|
{
|
|
node_stmt_break()
|
|
: node(node_t::stmt_break) {}
|
|
|
|
node_stmt_break(const location& loc)
|
|
: node(node_t::stmt_break, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "break;";
|
|
};
|
|
};
|
|
|
|
struct node_stmt_continue : public node
|
|
{
|
|
node_stmt_continue()
|
|
: node(node_t::stmt_continue) {}
|
|
|
|
node_stmt_continue(const location& loc)
|
|
: node(node_t::stmt_continue, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "continue;";
|
|
};
|
|
};
|
|
|
|
struct node_stmt_return : public node
|
|
{
|
|
expr_ptr expr;
|
|
|
|
node_stmt_return(expr_ptr expr)
|
|
: node(node_t::stmt_return), expr(std::move(expr)) {}
|
|
|
|
node_stmt_return(const location& loc, expr_ptr expr)
|
|
: node(node_t::stmt_return, loc), expr(std::move(expr)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
if(expr.as_node->type == node_t::null) return "return;";
|
|
|
|
return "return " + expr.as_node->print() + ";";
|
|
};
|
|
};
|
|
|
|
struct node_stmt_breakpoint : public node
|
|
{
|
|
node_stmt_breakpoint()
|
|
: node(node_t::stmt_breakpoint) {}
|
|
|
|
node_stmt_breakpoint(const location& loc)
|
|
: node(node_t::stmt_breakpoint, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "breakpoint;";
|
|
};
|
|
};
|
|
|
|
struct node_stmt_prof_begin : public node
|
|
{
|
|
expr_arguments_ptr args;
|
|
|
|
node_stmt_prof_begin(expr_arguments_ptr args)
|
|
: node(node_t::stmt_prof_begin), args(std::move(args)) {}
|
|
|
|
node_stmt_prof_begin(const location& loc, expr_arguments_ptr args)
|
|
: node(node_t::stmt_prof_begin, loc), args(std::move(args)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "prof_begin(" + args->print() + ");";
|
|
};
|
|
};
|
|
|
|
struct node_stmt_prof_end : public node
|
|
{
|
|
expr_arguments_ptr args;
|
|
|
|
node_stmt_prof_end(expr_arguments_ptr args)
|
|
: node(node_t::stmt_prof_end), args(std::move(args)) {}
|
|
|
|
node_stmt_prof_end(const location& loc, expr_arguments_ptr args)
|
|
: node(node_t::stmt_prof_end, loc), args(std::move(args)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "prof_end(" + args->print() + ");";
|
|
};
|
|
};
|
|
|
|
struct node_parameters : public node
|
|
{
|
|
std::vector<name_ptr> list;
|
|
|
|
node_parameters()
|
|
: node(node_t::parameters) {}
|
|
|
|
node_parameters(const location& loc)
|
|
: node(node_t::parameters, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
std::string data;
|
|
|
|
for (const auto& param : list)
|
|
{
|
|
data += " " + param->print();
|
|
data += (¶m != &list.back()) ? "," : " ";
|
|
}
|
|
|
|
return data;
|
|
}
|
|
};
|
|
|
|
struct node_thread : public node
|
|
{
|
|
name_ptr name;
|
|
parameters_ptr params;
|
|
stmt_list_ptr block;
|
|
|
|
node_thread(name_ptr name, parameters_ptr params, stmt_list_ptr block)
|
|
: node(node_t::thread), name(std::move(name)), params(std::move(params)),
|
|
block(std::move(block)) {}
|
|
|
|
node_thread(const location& loc, name_ptr name, parameters_ptr params, stmt_list_ptr block)
|
|
: node(node_t::thread, loc), name(std::move(name)), params(std::move(params)),
|
|
block(std::move(block)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return name->print() + "(" + params->print() + ")" + "\n" + block->print() + "\n";
|
|
}
|
|
};
|
|
|
|
struct node_constant : public node
|
|
{
|
|
name_ptr name;
|
|
expr_ptr value;
|
|
|
|
node_constant(name_ptr name, expr_ptr value)
|
|
: node(node_t::constant), name(std::move(name)), value(std::move(value)) {}
|
|
|
|
node_constant(const location& loc, name_ptr name, expr_ptr value)
|
|
: node(node_t::constant, loc), name(std::move(name)), value(std::move(value)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return name->print() + " = "s + value.as_node->print() + ";\n";
|
|
}
|
|
};
|
|
|
|
struct node_usingtree : public node
|
|
{
|
|
string_ptr animtree;
|
|
|
|
node_usingtree(string_ptr animtree)
|
|
: node(node_t::usingtree), animtree(std::move(animtree)) {}
|
|
|
|
node_usingtree(const location& loc, string_ptr animtree)
|
|
: node(node_t::usingtree, loc), animtree(std::move(animtree)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "#using_animtree"s + "(" + animtree->print() + ");\n";
|
|
}
|
|
};
|
|
|
|
struct node_include : public node
|
|
{
|
|
file_ptr file;
|
|
|
|
node_include(file_ptr file)
|
|
: node(node_t::include), file(std::move(file)) {}
|
|
|
|
node_include(const location& loc, file_ptr file)
|
|
: node(node_t::include, loc), file(std::move(file)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "#include"s + " " + file->print() + ";\n";
|
|
}
|
|
};
|
|
|
|
struct node_program : public node
|
|
{
|
|
std::vector<include_ptr> includes;
|
|
std::vector<define_ptr> definitions;
|
|
|
|
node_program() : node(node_t::program) {}
|
|
|
|
node_program(const location& loc) : node(node_t::program, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
std::string data;
|
|
|
|
for (const auto& include : includes)
|
|
{
|
|
data += include->print();
|
|
}
|
|
|
|
for (const auto& def : definitions)
|
|
{
|
|
if(def.as_node->type == node_t::thread)
|
|
{
|
|
data += "\n";
|
|
}
|
|
|
|
data += def.as_node->print();
|
|
}
|
|
|
|
return data;
|
|
}
|
|
};
|
|
|
|
struct node_asm_loc : public node
|
|
{
|
|
std::string value;
|
|
|
|
node_asm_loc(std::string value)
|
|
: node(node_t::asm_loc), value(std::move(value)) {}
|
|
|
|
node_asm_loc(const location& loc, std::string value)
|
|
: node(node_t::asm_loc, loc), value(std::move(value)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return value + ":";
|
|
}
|
|
};
|
|
|
|
struct node_asm_jump : public node
|
|
{
|
|
std::string value;
|
|
|
|
node_asm_jump(std::string value)
|
|
: node(node_t::asm_jump), value(std::move(value)) {}
|
|
|
|
node_asm_jump(const location& loc, std::string value)
|
|
: node(node_t::asm_jump, loc), value(std::move(value)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "jump " + value;
|
|
}
|
|
};
|
|
|
|
struct node_asm_jump_back : public node
|
|
{
|
|
std::string value;
|
|
|
|
node_asm_jump_back(std::string value)
|
|
: node(node_t::asm_jump_back), value(std::move(value)) {}
|
|
|
|
node_asm_jump_back(const location& loc, std::string value)
|
|
: node(node_t::asm_jump_back, loc), value(std::move(value)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "jump_back " + value;
|
|
}
|
|
};
|
|
|
|
struct node_asm_jump_cond : public node
|
|
{
|
|
std::string value;
|
|
expr_ptr expr;
|
|
|
|
node_asm_jump_cond(expr_ptr expr, std::string value)
|
|
: node(node_t::asm_jump_cond), expr(std::move(expr)), value(std::move(value)) {}
|
|
|
|
node_asm_jump_cond(const location& loc, expr_ptr expr, std::string value)
|
|
: node(node_t::asm_jump_cond, loc), expr(std::move(expr)), value(std::move(value)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "jump_cond( " + expr.as_node->print() + " ) " + value;
|
|
}
|
|
};
|
|
|
|
struct node_asm_jump_true_expr : public node
|
|
{
|
|
expr_ptr expr;
|
|
std::string value;
|
|
|
|
node_asm_jump_true_expr(expr_ptr expr, std::string value)
|
|
: node(node_t::asm_jump_true_expr), expr(std::move(expr)), value(std::move(value)) {}
|
|
|
|
node_asm_jump_true_expr(const location& loc, expr_ptr expr, std::string value)
|
|
: node(node_t::asm_jump_true_expr, loc), expr(std::move(expr)), value(std::move(value)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "expr_true " + value;
|
|
}
|
|
};
|
|
|
|
struct node_asm_jump_false_expr : public node
|
|
{
|
|
expr_ptr expr;
|
|
std::string value;
|
|
|
|
node_asm_jump_false_expr(expr_ptr expr, std::string value)
|
|
: node(node_t::asm_jump_false_expr), expr(std::move(expr)), value(std::move(value)) {}
|
|
|
|
node_asm_jump_false_expr(const location& loc, expr_ptr expr, std::string value)
|
|
: node(node_t::asm_jump_false_expr, loc), expr(std::move(expr)), value(std::move(value)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "expr_false " + value;
|
|
}
|
|
};
|
|
|
|
struct node_asm_switch : public node
|
|
{
|
|
expr_ptr expr;
|
|
std::string value;
|
|
|
|
node_asm_switch(expr_ptr expr, std::string value)
|
|
: node(node_t::asm_switch), expr(std::move(expr)), value(std::move(value)) {}
|
|
|
|
node_asm_switch(const location& loc, expr_ptr expr, std::string value)
|
|
: node(node_t::asm_switch, loc), expr(std::move(expr)), value(std::move(value)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "switch( " + expr.as_node->print() + " ) " + value;
|
|
}
|
|
};
|
|
|
|
struct node_asm_endswitch : public node
|
|
{
|
|
std::vector<std::string> data;
|
|
std::string count;
|
|
|
|
node_asm_endswitch(std::vector<std::string> data, std::string count)
|
|
: node(node_t::asm_endswitch), data(std::move(data)), count(std::move(count)) {}
|
|
|
|
node_asm_endswitch(const location& loc, std::vector<std::string> data, std::string count)
|
|
: node(node_t::asm_endswitch, loc), data(std::move(data)), count(std::move(count)) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
std::string p;
|
|
for(auto& d : data)
|
|
{
|
|
p+= " " + d;
|
|
}
|
|
return "endswitch( " + count + " ) " + p;
|
|
}
|
|
};
|
|
|
|
struct node_asm_prescriptcall : public node
|
|
{
|
|
node_asm_prescriptcall()
|
|
: node(node_t::asm_prescriptcall) {}
|
|
|
|
node_asm_prescriptcall(const location& loc)
|
|
: node(node_t::asm_prescriptcall, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "prescriptcall";
|
|
}
|
|
};
|
|
|
|
struct node_asm_voidcodepos : public node
|
|
{
|
|
node_asm_voidcodepos()
|
|
: node(node_t::asm_voidcodepos) {}
|
|
|
|
node_asm_voidcodepos(const location& loc)
|
|
: node(node_t::asm_voidcodepos, loc) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "voidcodepos";
|
|
}
|
|
};
|
|
|
|
struct node_asm_create : public node
|
|
{
|
|
std::string index;
|
|
std::vector<std::string> vars;
|
|
|
|
node_asm_create(const std::string& index)
|
|
: node(node_t::asm_create), index(index) {}
|
|
|
|
node_asm_create(const location& loc, const std::string& index)
|
|
: node(node_t::asm_create, loc), index(index) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "var_create_" + index;
|
|
}
|
|
};
|
|
|
|
struct node_asm_access : public node
|
|
{
|
|
std::string index;
|
|
|
|
node_asm_access(const std::string& index)
|
|
: node(node_t::asm_access), index(index) {}
|
|
|
|
node_asm_access(const location& loc, const std::string& index)
|
|
: node(node_t::asm_access, loc), index(index) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "var_access_" + index;
|
|
}
|
|
};
|
|
|
|
struct node_asm_remove : public node
|
|
{
|
|
std::string index;
|
|
|
|
node_asm_remove(const std::string& index)
|
|
: node(node_t::asm_remove), index(index) {}
|
|
|
|
node_asm_remove(const location& loc, const std::string& index)
|
|
: node(node_t::asm_remove, loc), index(index) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "var_remove_" + index;
|
|
}
|
|
};
|
|
|
|
struct node_asm_clear : public node
|
|
{
|
|
std::string index;
|
|
|
|
node_asm_clear(const std::string& index)
|
|
: node(node_t::asm_clear), index(index) {}
|
|
|
|
node_asm_clear(const location& loc, const std::string& index)
|
|
: node(node_t::asm_clear, loc), index(index) {}
|
|
|
|
auto print() -> std::string override
|
|
{
|
|
return "var_clear_" + index;
|
|
}
|
|
};
|
|
|
|
} // namespace xsk::gsc
|