1052 lines
34 KiB
Plaintext
1052 lines
34 KiB
Plaintext
import tree:*
|
|
import vector:*
|
|
import vector_literals:*
|
|
import set:*
|
|
import stack:*
|
|
import map:*
|
|
import util:*
|
|
import string:*
|
|
import mem:*
|
|
import io:*
|
|
import type:*
|
|
|
|
|
|
adt ast_node {
|
|
translation_unit: translation_unit,
|
|
import: import,
|
|
identifier: identifier,
|
|
type_def: type_def,
|
|
adt_def: adt_def,
|
|
function: function,
|
|
function_template: function_template,
|
|
code_block: code_block,
|
|
statement: statement,
|
|
if_statement: if_statement,
|
|
match_statement: match_statement,
|
|
case_statement: case_statement,
|
|
while_loop: while_loop,
|
|
for_loop: for_loop,
|
|
return_statement: return_statement,
|
|
branching_statement: branching_statement,
|
|
defer_statement: defer_statement,
|
|
assignment_statement: assignment_statement,
|
|
declaration_statement: declaration_statement,
|
|
if_comp: if_comp,
|
|
simple_passthrough: simple_passthrough,
|
|
function_call: function_call,
|
|
value: value
|
|
}
|
|
/*
|
|
total:
|
|
ASTType type;
|
|
Type* valueType;
|
|
Symbol symbol;
|
|
std::map<std::string, std::vector<NodeTree<ASTData>*>> scope;
|
|
std::set<NodeTree<ASTData>*> closedVariables;
|
|
*/
|
|
fun ast_node_ptr(node: ast_node): *ast_node {
|
|
var to_ret = new<ast_node>()
|
|
to_ret->copy_construct(&node)
|
|
return to_ret
|
|
}
|
|
fun ast_translation_unit_ptr(name: string): *ast_node {
|
|
var obj_var.construct(name): translation_unit
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::translation_unit(obj_var))
|
|
return ptr
|
|
}
|
|
fun is_translation_unit(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::translation_unit(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj translation_unit (Object) {
|
|
var scope: map<string, vector<*ast_node>>
|
|
var children: vector<*ast_node>
|
|
var name: string
|
|
fun construct(nameIn: string): *translation_unit {
|
|
scope.construct()
|
|
children.construct()
|
|
name.copy_construct(&nameIn)
|
|
return this
|
|
}
|
|
fun copy_construct(old: *translation_unit) {
|
|
scope.copy_construct(&old->scope)
|
|
children.copy_construct(&old->children)
|
|
name.copy_construct(&old->name)
|
|
}
|
|
fun destruct() {
|
|
scope.destruct()
|
|
children.destruct()
|
|
name.destruct()
|
|
}
|
|
fun operator=(other: ref translation_unit) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref translation_unit): bool {
|
|
return children == other.children && name == other.name
|
|
}
|
|
}
|
|
fun ast_import_ptr(name: string, translation_unit: *ast_node): *ast_node {
|
|
var to_ret.construct(name, translation_unit): import
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::import(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_import(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::import(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj import (Object) {
|
|
var scope: map<string, vector<*ast_node>>
|
|
var imported: set<string>
|
|
var translation_unit: *ast_node
|
|
var name: string
|
|
fun construct(nameIn: string, translation_unit_in: *ast_node): *import {
|
|
scope.construct()
|
|
imported.construct()
|
|
name.copy_construct(&nameIn)
|
|
translation_unit = translation_unit_in
|
|
return this
|
|
}
|
|
fun copy_construct(old: *import) {
|
|
scope.copy_construct(&old->scope)
|
|
imported.copy_construct(&old->imported)
|
|
name.copy_construct(&old->name)
|
|
translation_unit = old->translation_unit
|
|
}
|
|
fun destruct() {
|
|
scope.destruct()
|
|
imported.destruct()
|
|
name.destruct()
|
|
}
|
|
fun operator=(other: ref import) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref import): bool {
|
|
return imported == other.imported && name == other.name && translation_unit == other.translation_unit
|
|
}
|
|
}
|
|
fun ast_identifier_ptr(name: *char, type: *type): *ast_node {
|
|
return ast_identifier_ptr(string(name), type)
|
|
}
|
|
fun ast_identifier_ptr(name: string, type: *type): *ast_node {
|
|
var to_ret.construct(name, type): identifier
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::identifier(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_identifier(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::identifier(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj identifier (Object) {
|
|
var name: string
|
|
var scope: map<string, vector<*ast_node>>
|
|
var type: *type
|
|
fun construct(name_in: string, type_in: *type): *identifier {
|
|
name.copy_construct(&name_in)
|
|
scope.construct()
|
|
type = type_in
|
|
return this
|
|
}
|
|
fun copy_construct(old: *identifier) {
|
|
name.copy_construct(&old->name)
|
|
scope.copy_construct(&old->scope)
|
|
type = old->type
|
|
}
|
|
fun destruct() {
|
|
name.destruct()
|
|
scope.destruct()
|
|
}
|
|
fun operator=(other: ref identifier) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref identifier): bool {
|
|
return name == other.name && type == other.type
|
|
}
|
|
}
|
|
fun ast_type_def_ptr(name: string): *ast_node {
|
|
var to_ret.construct(name): type_def
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::type_def(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_type_def(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::type_def(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj type_def (Object) {
|
|
var scope: map<string, vector<*ast_node>>
|
|
var name: string
|
|
var self_type: *type
|
|
var variables: vector<*ast_node>
|
|
var methods: vector<*ast_node>
|
|
fun construct(nameIn: string): *type_def {
|
|
scope.construct()
|
|
name.copy_construct(&nameIn)
|
|
self_type = null<type>()
|
|
variables.construct()
|
|
methods.construct()
|
|
return this
|
|
}
|
|
fun copy_construct(old: *type_def) {
|
|
self_type = old->self_type
|
|
scope.copy_construct(&old->scope)
|
|
name.copy_construct(&old->name)
|
|
variables.copy_construct(&old->variables)
|
|
methods.copy_construct(&old->methods)
|
|
}
|
|
fun destruct() {
|
|
scope.destruct()
|
|
name.destruct()
|
|
variables.destruct()
|
|
methods.destruct()
|
|
}
|
|
fun operator=(other: ref type_def) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref type_def): bool {
|
|
return name == other.name && self_type == other.self_type && variables == other.variables && methods == other.methods
|
|
}
|
|
}
|
|
fun ast_adt_def_ptr(name: string): *ast_node {
|
|
var to_ret.construct(name): adt_def
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::adt_def(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_adt_def(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::adt_def(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj adt_def (Object) {
|
|
var scope: map<string, vector<*ast_node>>
|
|
var name: string
|
|
fun construct(nameIn: string): *adt_def {
|
|
scope.construct()
|
|
name.copy_construct(&nameIn)
|
|
return this
|
|
}
|
|
fun copy_construct(old: *adt_def) {
|
|
scope.copy_construct(&old->scope)
|
|
name.copy_construct(&old->name)
|
|
}
|
|
fun destruct() {
|
|
scope.destruct()
|
|
name.destruct()
|
|
}
|
|
fun operator=(other: ref adt_def) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref adt_def): bool {
|
|
return name == other.name
|
|
}
|
|
}
|
|
fun ast_function_ptr(name: string, type: *type, parameters: vector<*ast_node>): *ast_node {
|
|
var to_ret.construct(name, type, parameters): function
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::function(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_function(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::function(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj function (Object) {
|
|
var name: string
|
|
var type: *type
|
|
var parameters: vector<*ast_node>
|
|
var body_statement: *ast_node
|
|
var scope: map<string, vector<*ast_node>>
|
|
fun construct(name_in: string, type_in: *type, parameters_in: vector<*ast_node>): *function {
|
|
name.copy_construct(&name_in)
|
|
parameters.copy_construct(¶meters_in)
|
|
scope.construct()
|
|
type = type_in
|
|
body_statement = null<ast_node>()
|
|
return this
|
|
}
|
|
fun copy_construct(old: *function) {
|
|
name.copy_construct(&old->name)
|
|
type = old->type
|
|
body_statement = old->body_statement
|
|
parameters.copy_construct(&old->parameters)
|
|
scope.copy_construct(&old->scope)
|
|
}
|
|
fun destruct() {
|
|
name.destruct()
|
|
parameters.destruct()
|
|
scope.destruct()
|
|
}
|
|
fun operator=(other: ref function) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref function): bool {
|
|
return name == name && type == other.type && parameters == other.parameters && body_statement == other.body_statement
|
|
}
|
|
}
|
|
fun ast_function_template_ptr(name: string, syntax_node: *tree<symbol>, template_types: vector<string>, template_type_replacements: map<string, *type>): *ast_node {
|
|
var to_ret.construct(name, syntax_node, template_types, template_type_replacements): function_template
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::function_template(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_function_template(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::function_template(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj function_template (Object) {
|
|
var name: string
|
|
var syntax_node: *tree<symbol>
|
|
var instantiated: vector<*ast_node>
|
|
var template_types: vector<string>
|
|
var template_type_replacements: map<string, *type>
|
|
var scope: map<string, vector<*ast_node>>
|
|
fun construct(name_in: string, syntax_node_in: *tree<symbol>, template_types_in: vector<string>, template_type_replacements_in: map<string, *type>): *function_template {
|
|
name.copy_construct(&name_in)
|
|
syntax_node = syntax_node_in
|
|
instantiated.construct()
|
|
template_types.copy_construct(&template_types_in)
|
|
template_type_replacements.copy_construct(&template_type_replacements_in)
|
|
scope.construct()
|
|
return this
|
|
}
|
|
fun copy_construct(old: *function_template) {
|
|
name.copy_construct(&old->name)
|
|
syntax_node = old->syntax_node
|
|
instantiated.copy_construct(&old->instantiated)
|
|
template_types.copy_construct(&old->template_types)
|
|
template_type_replacements.copy_construct(&old->template_type_replacements)
|
|
scope.copy_construct(&old->scope)
|
|
}
|
|
fun destruct() {
|
|
name.destruct()
|
|
instantiated.destruct()
|
|
template_types.destruct()
|
|
template_type_replacements.destruct()
|
|
scope.destruct()
|
|
}
|
|
fun operator=(other: ref function_template) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref function_template): bool {
|
|
return name == name && syntax_node == other.syntax_node && instantiated == other.instantiated &&
|
|
scope == other.scope && template_types == other.template_types && template_type_replacements == other.template_type_replacements
|
|
}
|
|
}
|
|
fun ast_code_block_ptr(): *ast_node {
|
|
var to_ret.construct(): code_block
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::code_block(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_code_block(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::code_block(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj code_block (Object) {
|
|
var scope: map<string, vector<*ast_node>>
|
|
var children: vector<*ast_node>
|
|
fun construct(): *code_block {
|
|
scope.construct()
|
|
children.construct()
|
|
return this
|
|
}
|
|
fun copy_construct(old: *code_block) {
|
|
scope.copy_construct(&old->scope)
|
|
children.copy_construct(&old->children)
|
|
}
|
|
fun destruct() {
|
|
scope.destruct()
|
|
children.destruct()
|
|
}
|
|
fun operator=(other: ref code_block) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref code_block): bool {
|
|
return children == other.children && scope == other.scope
|
|
}
|
|
}
|
|
fun ast_statement_ptr(child: *ast_node): *ast_node {
|
|
var to_ret.construct(child): statement
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::statement(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_statement(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::statement(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj statement (Object) {
|
|
var scope: map<string, vector<*ast_node>>
|
|
var child: *ast_node
|
|
fun construct(child_in: *ast_node): *statement {
|
|
child = null<ast_node>()
|
|
scope.construct()
|
|
child = child_in
|
|
return this
|
|
}
|
|
fun copy_construct(old: *statement) {
|
|
scope.copy_construct(&old->scope)
|
|
child = old->child
|
|
}
|
|
fun destruct() {
|
|
scope.destruct()
|
|
}
|
|
fun operator=(other: ref statement) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref statement): bool {
|
|
return child == other.child
|
|
}
|
|
}
|
|
fun ast_if_statement_ptr(condition: *ast_node): *ast_node {
|
|
var to_ret.construct(condition): if_statement
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::if_statement(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_if_statement(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::if_statement(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj if_statement (Object) {
|
|
var condition: *ast_node
|
|
// these are not a part of the constructor because they have to be trnasformed with this as its scope
|
|
var then_part: *ast_node
|
|
var else_part: *ast_node
|
|
var scope: map<string, vector<*ast_node>>
|
|
fun construct(condition_in: *ast_node): *if_statement {
|
|
condition = condition_in
|
|
then_part = null<ast_node>()
|
|
else_part = null<ast_node>()
|
|
scope.construct()
|
|
return this
|
|
}
|
|
fun copy_construct(old: *if_statement) {
|
|
condition = old->condition
|
|
then_part = old->then_part
|
|
else_part = old->else_part
|
|
scope.copy_construct(&old->scope)
|
|
}
|
|
fun destruct() {
|
|
scope.destruct()
|
|
}
|
|
fun operator=(other: ref if_statement) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref if_statement): bool {
|
|
return condition == other.condition && then_part == other.then_part && else_part == other.else_part
|
|
}
|
|
}
|
|
fun ast_match_statement_ptr(): *ast_node {
|
|
var to_ret.construct(): match_statement
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::match_statement(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_match_statement(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::match_statement(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj match_statement (Object) {
|
|
var scope: map<string, vector<*ast_node>>
|
|
fun construct(): *match_statement {
|
|
scope.construct()
|
|
return this
|
|
}
|
|
fun copy_construct(old: *match_statement) {
|
|
scope.copy_construct(&old->scope)
|
|
}
|
|
fun destruct() {
|
|
scope.destruct()
|
|
}
|
|
fun operator=(other: ref match_statement) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref match_statement): bool {
|
|
return true
|
|
}
|
|
}
|
|
fun ast_case_statement_ptr(): *ast_node {
|
|
var to_ret.construct(): case_statement
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::case_statement(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_case_statement(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::case_statement(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj case_statement (Object) {
|
|
var scope: map<string, vector<*ast_node>>
|
|
fun construct(): *case_statement {
|
|
scope.construct()
|
|
return this
|
|
}
|
|
fun copy_construct(old: *case_statement) {
|
|
scope.copy_construct(&old->scope)
|
|
}
|
|
fun destruct() {
|
|
scope.destruct()
|
|
}
|
|
fun operator=(other: ref case_statement) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref case_statement): bool {
|
|
return true
|
|
}
|
|
}
|
|
fun ast_while_loop_ptr(condition: *ast_node): *ast_node {
|
|
var to_ret.construct(condition): while_loop
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::while_loop(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_while_loop(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::while_loop(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj while_loop (Object) {
|
|
var condition: *ast_node
|
|
var statement: *ast_node
|
|
var scope: map<string, vector<*ast_node>>
|
|
fun construct(condition_in: *ast_node): *while_loop {
|
|
condition = condition_in
|
|
statement = null<ast_node>()
|
|
scope.construct()
|
|
return this
|
|
}
|
|
fun copy_construct(old: *while_loop) {
|
|
condition = old->condition
|
|
statement = old->statement
|
|
scope.copy_construct(&old->scope)
|
|
}
|
|
fun destruct() {
|
|
scope.destruct()
|
|
}
|
|
fun operator=(other: ref while_loop) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref while_loop): bool {
|
|
return condition == other.condition && statement == other.statement
|
|
}
|
|
}
|
|
fun ast_for_loop_ptr(): *ast_node {
|
|
var to_ret.construct(): for_loop
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::for_loop(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_for_loop(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::for_loop(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj for_loop (Object) {
|
|
var init: *ast_node
|
|
var condition: *ast_node
|
|
var update: *ast_node
|
|
var body: *ast_node
|
|
var scope: map<string, vector<*ast_node>>
|
|
fun construct(): *for_loop {
|
|
scope.construct()
|
|
init = null<ast_node>()
|
|
condition = null<ast_node>()
|
|
update = null<ast_node>()
|
|
body = null<ast_node>()
|
|
return this
|
|
}
|
|
fun copy_construct(old: *for_loop) {
|
|
init = old->init
|
|
condition = old->condition
|
|
update = old->update
|
|
body = old->body
|
|
scope.copy_construct(&old->scope)
|
|
}
|
|
fun destruct() {
|
|
scope.destruct()
|
|
}
|
|
fun operator=(other: ref for_loop) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref for_loop): bool {
|
|
return init == other.init && condition == other.condition && update == other.update && body == other.body
|
|
}
|
|
}
|
|
fun ast_return_statement_ptr(return_value: *ast_node): *ast_node {
|
|
var to_ret.construct(return_value): return_statement
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::return_statement(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_return_statement(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::return_statement(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj return_statement (Object) {
|
|
var return_value: *ast_node
|
|
var scope: map<string, vector<*ast_node>>
|
|
fun construct(return_value_in: *ast_node): *return_statement {
|
|
return_value = return_value_in
|
|
scope.construct()
|
|
return this
|
|
}
|
|
fun copy_construct(old: *return_statement) {
|
|
return_value = old->return_value
|
|
scope.copy_construct(&old->scope)
|
|
}
|
|
fun destruct() {
|
|
scope.destruct()
|
|
}
|
|
fun operator=(other: ref return_statement) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref return_statement): bool {
|
|
return return_value == other.return_value
|
|
}
|
|
}
|
|
adt branching_type {
|
|
break_stmt,
|
|
continue_stmt
|
|
}
|
|
fun ast_branching_statement_ptr(b_type: branching_type): *ast_node {
|
|
var to_ret.construct(b_type): branching_statement
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::branching_statement(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_branching_statement(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::branching_statement(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj branching_statement (Object) {
|
|
var b_type: branching_type
|
|
fun construct(b_type_in: branching_type): *branching_statement {
|
|
b_type.copy_construct(&b_type_in)
|
|
return this
|
|
}
|
|
fun copy_construct(old: *branching_statement) {
|
|
b_type.copy_construct(&old->b_type)
|
|
}
|
|
fun destruct() {
|
|
b_type.destruct()
|
|
}
|
|
fun operator=(other: ref branching_statement) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref branching_statement): bool {
|
|
return true
|
|
}
|
|
}
|
|
fun ast_defer_statement_ptr(statement_in: *ast_node): *ast_node {
|
|
var to_ret.construct(statement_in): defer_statement
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::defer_statement(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_defer_statement(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::defer_statement(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj defer_statement (Object) {
|
|
var statement: *ast_node
|
|
fun construct(statement_in: *ast_node): *defer_statement {
|
|
statement = statement_in
|
|
return this
|
|
}
|
|
fun copy_construct(old: *defer_statement) {
|
|
statement = old->statement
|
|
}
|
|
fun destruct() {
|
|
}
|
|
fun operator=(other: ref defer_statement) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref defer_statement): bool {
|
|
return true
|
|
}
|
|
}
|
|
fun ast_assignment_statement_ptr(to: *ast_node, from: *ast_node): *ast_node {
|
|
var to_ret.construct(to, from): assignment_statement
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::assignment_statement(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_assignment_statement(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::assignment_statement(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj assignment_statement (Object) {
|
|
var to: *ast_node
|
|
var from: *ast_node
|
|
fun construct(to_in: *ast_node, from_in: *ast_node): *assignment_statement {
|
|
to = to_in
|
|
from = from_in
|
|
return this
|
|
}
|
|
fun copy_construct(old: *assignment_statement) {
|
|
to = old->to
|
|
from = old->from
|
|
}
|
|
fun destruct() {
|
|
}
|
|
fun operator=(other: ref assignment_statement) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref assignment_statement): bool {
|
|
return to == other.to && from == other.from
|
|
}
|
|
}
|
|
fun ast_declaration_statement_ptr(ident: *ast_node, expression: *ast_node): *ast_node {
|
|
var to_ret.construct(ident, expression): declaration_statement
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::declaration_statement(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_declaration_statement(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::declaration_statement(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj declaration_statement (Object) {
|
|
var identifier: *ast_node
|
|
var expression: *ast_node
|
|
var init_method_call: *ast_node
|
|
fun construct(identifier_in: *ast_node, expression_in: *ast_node): *declaration_statement {
|
|
identifier = identifier_in
|
|
expression = expression_in
|
|
init_method_call = null<ast_node>()
|
|
return this
|
|
}
|
|
fun copy_construct(old: *declaration_statement) {
|
|
identifier = old->identifier
|
|
expression = old->expression
|
|
init_method_call = old->init_method_call
|
|
}
|
|
fun destruct() {
|
|
}
|
|
fun operator=(other: ref declaration_statement) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref declaration_statement): bool {
|
|
return identifier == other.identifier && expression == other.expression && init_method_call == other.init_method_call
|
|
}
|
|
}
|
|
fun ast_if_comp_ptr(): *ast_node {
|
|
var to_ret.construct(): if_comp
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::if_comp(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_if_comp(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::if_comp(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj if_comp (Object) {
|
|
var wanted_generator: string
|
|
var statement: *ast_node
|
|
fun construct(): *if_comp {
|
|
wanted_generator.construct()
|
|
return this
|
|
}
|
|
fun copy_construct(old: *if_comp) {
|
|
wanted_generator.copy_construct(&old->wanted_generator)
|
|
statement = old->statement
|
|
}
|
|
fun destruct() {
|
|
wanted_generator.destruct()
|
|
}
|
|
fun operator=(other: if_comp) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: if_comp): bool {
|
|
return wanted_generator == other.wanted_generator && statement == other.statement
|
|
}
|
|
}
|
|
fun ast_simple_passthrough_ptr(): *ast_node {
|
|
var to_ret.construct(): simple_passthrough
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::simple_passthrough(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_simple_passthrough(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::simple_passthrough(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj simple_passthrough (Object) {
|
|
var scope: map<string, vector<*ast_node>>
|
|
var passthrough_str: string
|
|
fun construct(): *simple_passthrough {
|
|
scope.construct()
|
|
passthrough_str.construct()
|
|
return this
|
|
}
|
|
fun copy_construct(old: *simple_passthrough) {
|
|
scope.copy_construct(&old->scope)
|
|
passthrough_str.copy_construct(&old->passthrough_str)
|
|
}
|
|
fun destruct() {
|
|
scope.destruct()
|
|
passthrough_str.destruct()
|
|
}
|
|
fun operator=(other: ref simple_passthrough) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref simple_passthrough): bool {
|
|
return scope == other.scope && passthrough_str == other.passthrough_str
|
|
}
|
|
}
|
|
fun ast_function_call_ptr(func: *ast_node, parameters: vector<*ast_node>): *ast_node {
|
|
var to_ret.construct(func, parameters): function_call
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::function_call(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_function_call(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::function_call(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj function_call (Object) {
|
|
var func: *ast_node
|
|
var parameters: vector<*ast_node>
|
|
fun construct(func_in: *ast_node, parameters_in: vector<*ast_node>): *function_call {
|
|
func = func_in
|
|
parameters.copy_construct(¶meters_in)
|
|
return this
|
|
}
|
|
fun copy_construct(old: *function_call) {
|
|
func = old->func
|
|
parameters.copy_construct(&old->parameters)
|
|
}
|
|
fun destruct() {
|
|
parameters.destruct()
|
|
}
|
|
fun operator=(other: ref function_call) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref function_call): bool {
|
|
return func == func && parameters == other.parameters
|
|
}
|
|
}
|
|
fun ast_value_ptr(string_value: string, value_type: *type): *ast_node {
|
|
var to_ret.construct(string_value, value_type): value
|
|
var ptr = new<ast_node>()
|
|
ptr->copy_construct(&ast_node::value(to_ret))
|
|
return ptr
|
|
}
|
|
fun is_value(node: *ast_node): bool {
|
|
match(*node) {
|
|
ast_node::value(backing) return true
|
|
}
|
|
return false
|
|
}
|
|
obj value (Object) {
|
|
var string_value: string
|
|
var value_type: *type
|
|
var scope: map<string, vector<*ast_node>>
|
|
fun construct(string_value_in: string, value_type_in: *type): *value {
|
|
scope.construct()
|
|
string_value.copy_construct(&string_value_in)
|
|
value_type = value_type_in
|
|
return this
|
|
}
|
|
fun copy_construct(old: *value) {
|
|
scope.copy_construct(&old->scope)
|
|
string_value.copy_construct(&old->string_value)
|
|
value_type = old->value_type
|
|
}
|
|
fun destruct() {
|
|
scope.destruct()
|
|
string_value.destruct()
|
|
}
|
|
fun operator=(other: ref value) {
|
|
destruct()
|
|
copy_construct(&other)
|
|
}
|
|
fun operator==(other: ref value): bool {
|
|
return string_value == other.string_value && value_type == other.value_type
|
|
}
|
|
}
|
|
|
|
fun get_ast_children(node: *ast_node): vector<*ast_node> {
|
|
match (*node) {
|
|
ast_node::translation_unit(backing) return backing.children
|
|
ast_node::import(backing) return vector<*ast_node>()
|
|
ast_node::identifier(backing) return vector<*ast_node>()
|
|
ast_node::type_def(backing) return backing.variables + backing.methods
|
|
ast_node::adt_def(backing) return vector<*ast_node>()
|
|
ast_node::function(backing) return backing.parameters + backing.body_statement
|
|
ast_node::function_template(backing) return backing.instantiated
|
|
ast_node::code_block(backing) return backing.children
|
|
ast_node::statement(backing) return vector<*ast_node>(backing.child)
|
|
ast_node::if_statement(backing) return vector(backing.condition, backing.then_part, backing.else_part)
|
|
ast_node::match_statement(backing) return vector<*ast_node>()
|
|
ast_node::case_statement(backing) return vector<*ast_node>()
|
|
ast_node::while_loop(backing) return vector(backing.condition, backing.statement)
|
|
ast_node::for_loop(backing) return vector(backing.init, backing.condition, backing.update, backing.body)
|
|
ast_node::return_statement(backing) return vector(backing.return_value)
|
|
ast_node::branching_statement(backing) return vector<*ast_node>()
|
|
ast_node::defer_statement(backing) return vector(backing.statement)
|
|
ast_node::assignment_statement(backing) return vector(backing.to, backing.from)
|
|
ast_node::declaration_statement(backing) return vector(backing.identifier, backing.expression, backing.init_method_call)
|
|
ast_node::if_comp(backing) return vector<*ast_node>(backing.statement)
|
|
ast_node::simple_passthrough(backing) return vector<*ast_node>()
|
|
ast_node::function_call(backing) return vector(backing.func) + backing.parameters
|
|
ast_node::value(backing) return vector<*ast_node>()
|
|
}
|
|
}
|
|
fun get_ast_name(node: *ast_node): string {
|
|
match (*node) {
|
|
ast_node::translation_unit(backing) return string("translation_unit: ") + backing.name
|
|
ast_node::import(backing) return string("import: ") + backing.name + "; [" + backing.imported.reduce(fun(name: string, acc: string): string return acc + " " + name;, string()) + " ]"
|
|
ast_node::identifier(backing) return string("identifier: ") + backing.name + ": " + backing.type->to_string()
|
|
ast_node::type_def(backing) return string("type_def: ") + backing.name
|
|
ast_node::adt_def(backing) return string("adt_def: ") + backing.name
|
|
ast_node::function(backing) return string("function: ") + backing.name + ": " + backing.type->to_string()
|
|
ast_node::function_template(backing) return string("function_template: ") + backing.name
|
|
ast_node::code_block(backing) return string("code_block")
|
|
ast_node::statement(backing) return string("statement")
|
|
ast_node::if_statement(backing) return string("if_statement")
|
|
ast_node::match_statement(backing) return string("match_statement")
|
|
ast_node::case_statement(backing) return string("case_statement")
|
|
ast_node::while_loop(backing) return string("while_loop")
|
|
ast_node::for_loop(backing) return string("for_loop")
|
|
ast_node::return_statement(backing) return string("return_statement")
|
|
ast_node::branching_statement(backing) return string("branching_statement")
|
|
ast_node::defer_statement(backing) return string("defer_statement")
|
|
ast_node::assignment_statement(backing) return string("assignment_statement")
|
|
ast_node::declaration_statement(backing) return string("declaration_statement")
|
|
ast_node::if_comp(backing) return string("if_comp: ") + backing.wanted_generator
|
|
ast_node::simple_passthrough(backing) return string("simple_passthrough: , string:") + backing.passthrough_str
|
|
ast_node::function_call(backing) return string("function_call:(") + backing.parameters.size + ")"
|
|
ast_node::value(backing) return string("value: ") + backing.string_value + ": " + backing.value_type->to_string()
|
|
}
|
|
}
|
|
fun get_ast_scope(node: *ast_node): *map<string,vector<*ast_node>> {
|
|
match (*node) {
|
|
ast_node::translation_unit() return &node->translation_unit.scope
|
|
ast_node::import() return &node->import.scope
|
|
ast_node::identifier() return &node->identifier.scope
|
|
ast_node::type_def() return &node->type_def.scope
|
|
ast_node::adt_def() return &node->adt_def.scope
|
|
ast_node::function() return &node->function.scope
|
|
ast_node::function_template() return &node->function_template.scope
|
|
ast_node::code_block() return &node->code_block.scope
|
|
ast_node::statement() return &node->statement.scope
|
|
ast_node::if_statement() return &node->if_statement.scope
|
|
ast_node::match_statement() return &node->match_statement.scope
|
|
ast_node::case_statement() return &node->case_statement.scope
|
|
ast_node::while_loop() return &node->while_loop.scope
|
|
ast_node::for_loop() return &node->for_loop.scope
|
|
ast_node::return_statement() return &node->return_statement.scope
|
|
ast_node::simple_passthrough() return &node->simple_passthrough.scope
|
|
ast_node::value() return &node->value.scope
|
|
}
|
|
return null<map<string,vector<*ast_node>>>()
|
|
}
|
|
fun get_ast_type(node: *ast_node): *type {
|
|
match (*node) {
|
|
ast_node::identifier() return node->identifier.type
|
|
ast_node::function() return node->function.type
|
|
ast_node::function_call() return get_ast_type(node->function_call.func)->return_type
|
|
ast_node::value() return node->value.value_type
|
|
}
|
|
}
|
|
|
|
fun ast_to_dot(root: *ast_node): string {
|
|
var ret = string("digraph Kaken {\n")
|
|
var counter = 0
|
|
var node_name_map = map<*ast_node, string>()
|
|
var get_name = fun(node: *ast_node): string {
|
|
if (node_name_map.contains_key(node))
|
|
return node_name_map[node]
|
|
var escaped = string("")
|
|
get_ast_name(node).data.for_each(fun(c: char) {
|
|
if (c != '"')
|
|
escaped += c
|
|
else
|
|
escaped += "\\\""
|
|
})
|
|
escaped += to_string(counter++)
|
|
node_name_map.set(node, escaped)
|
|
return escaped
|
|
}
|
|
var helper: fun(*ast_node):void = fun(node: *ast_node) {
|
|
get_ast_children(node).for_each(fun(child: *ast_node) {
|
|
if (!child)
|
|
return; // where on earth does the null come from
|
|
ret += string("\"") + get_name(node) + "\" -> \"" + get_name(child) + "\"\n";
|
|
helper(child)
|
|
})
|
|
}
|
|
if (root)
|
|
helper(root)
|
|
return ret + "}"
|
|
}
|
|
|