Browse Source

Replace throw 0 with real exceptions or assertions.

search
Danila Fedorin 1 year ago
parent
commit
9769b3e396
  1. 9
      code/compiler/13/definition.cpp
  2. 9
      code/compiler/13/env.cpp
  3. 17
      code/compiler/13/main.cpp
  4. 5
      code/compiler/13/parse_driver.hpp
  5. 20
      code/compiler/13/parsed_type.cpp
  6. 8
      code/compiler/13/type_env.cpp

9
code/compiler/13/definition.cpp

@ -1,4 +1,5 @@
#include "definition.hpp"
#include <cassert>
#include "error.hpp"
#include "ast.hpp"
#include "instruction.hpp"
@ -62,7 +63,10 @@ void definition_data::insert_constructors() const {
type_app* return_app = new type_app(std::move(this_type_ptr));
type_ptr return_type(return_app);
for(auto& var : vars) {
if(var_set.find(var) != var_set.end()) throw 0;
if(var_set.find(var) != var_set.end())
throw std::runtime_error(
std::string("type variable ") +
var + std::string(" used twice in data type definition."));
var_set.insert(var);
return_app->arguments.push_back(type_ptr(new type_var(var)));
}
@ -121,8 +125,7 @@ void definition_group::typecheck(type_mgr& mgr, type_env_ptr& env) {
dependency_graph.add_function(def_defn.second->name);
for(auto& dependency : def_defn.second->nearby_variables) {
if(defs_defn.find(dependency) == defs_defn.end())
throw 0;
assert(defs_defn.find(dependency) != defs_defn.end());
dependency_graph.add_edge(def_defn.second->name, dependency);
}
}

9
code/compiler/13/env.cpp

@ -1,9 +1,10 @@
#include "env.hpp"
#include <cassert>
int env_var::get_offset(const std::string& name) const {
if(name == this->name) return 0;
if(parent) return parent->get_offset(name) + 1;
throw 0;
assert(parent);
return parent->get_offset(name) + 1;
}
bool env_var::has_variable(const std::string& name) const {
@ -13,8 +14,8 @@ bool env_var::has_variable(const std::string& name) const {
}
int env_offset::get_offset(const std::string& name) const {
if(parent) return parent->get_offset(name) + offset;
throw 0;
assert(parent);
return parent->get_offset(name) + offset;
}
bool env_offset::has_variable(const std::string& name) const {

17
code/compiler/13/main.cpp

@ -103,12 +103,12 @@ void output_llvm(llvm_context& ctx, const std::string& filename) {
std::error_code ec;
llvm::raw_fd_ostream file(filename, ec, llvm::sys::fs::F_None);
if (ec) {
throw 0;
throw std::runtime_error("failed to open object file for writing");
} else {
llvm::CodeGenFileType type = llvm::CGFT_ObjectFile;
llvm::legacy::PassManager pm;
if (targetMachine->addPassesToEmitFile(pm, file, NULL, type)) {
throw 0;
throw std::runtime_error("failed to add passes to pass manager");
} else {
pm.run(ctx.module);
file.close();
@ -132,10 +132,13 @@ void gen_llvm(global_scope& scope) {
int main(int argc, char** argv) {
if(argc != 2) {
std::cout << "please enter a file to compile." << std::endl;
std::cerr << "please enter a file to compile." << std::endl;
}
parse_driver driver(argv[1]);
driver.run_parse();
if(!driver.run_parse()) {
std::cerr << "failed to open file " << argv[1] << std::endl;
exit(1);
}
type_mgr mgr;
type_env_ptr env(new type_env);
@ -154,8 +157,10 @@ int main(int argc, char** argv) {
scope.compile();
gen_llvm(scope);
} catch(unification_error& err) {
err.pretty_print(std::cout, driver, mgr);
err.pretty_print(std::cerr, driver, mgr);
} catch(type_error& err) {
err.pretty_print(std::cout, driver);
err.pretty_print(std::cerr, driver);
} catch(std::runtime_error& err) {
std::cerr << err.what() << std::endl;
}
}

5
code/compiler/13/parse_driver.hpp

@ -26,9 +26,9 @@ struct parse_driver {
parse_driver(const std::string& file)
: file_name(file), file_offset(0) {}
void run_parse() {
bool run_parse() {
file_stream.open(file_name);
if(!file_stream.good()) throw 0;
if(!file_stream.good()) return false;
line_offsets.push_back(0);
yyscan_t scanner;
scanner_init(this, &scanner);
@ -36,6 +36,7 @@ struct parse_driver {
parser();
scanner_destroy(&scanner);
read_file = string_stream.str();
return true;
}
int get() {

20
code/compiler/13/parsed_type.cpp

@ -1,15 +1,26 @@
#include "parsed_type.hpp"
#include <sstream>
#include "type.hpp"
#include "type_env.hpp"
#include "error.hpp"
type_ptr parsed_type_app::to_type(
const std::set<std::string>& vars,
const type_env& e) const {
auto parent_type = e.lookup_type(name);
if(parent_type == nullptr) throw 0;
if(parent_type == nullptr)
throw type_error(std::string("no such type or type constructor ") + name);
type_base* base_type;
if(!(base_type = dynamic_cast<type_base*>(parent_type.get()))) throw 0;
if(base_type->arity != arguments.size()) throw 0;
if(!(base_type = dynamic_cast<type_base*>(parent_type.get())))
throw type_error(std::string("invalid type ") + name);
if(base_type->arity != arguments.size()) {
std::ostringstream error_stream;
error_stream << "invalid application of type ";
error_stream << name;
error_stream << "(" << base_type->arity << " arguments expected, ";
error_stream << "but " << arguments.size() << " were provided)";
throw type_error(error_stream.str());
}
type_app* new_app = new type_app(std::move(parent_type));
type_ptr to_return(new_app);
@ -22,7 +33,8 @@ type_ptr parsed_type_app::to_type(
type_ptr parsed_type_var::to_type(
const std::set<std::string>& vars,
const type_env& e) const {
if(vars.find(var) == vars.end()) throw 0;
if(vars.find(var) == vars.end())
throw type_error(std::string("the type variable ") + var + std::string(" was not explicitly declared."));
return type_ptr(new type_var(var));
}

8
code/compiler/13/type_env.cpp

@ -1,5 +1,6 @@
#include "type_env.hpp"
#include "type.hpp"
#include "error.hpp"
void type_env::find_free(const type_mgr& mgr, std::set<std::string>& into) const {
if(parent != nullptr) parent->find_free(mgr, into);
@ -61,14 +62,15 @@ void type_env::bind(const std::string& name, type_scheme_ptr t, visibility v) {
}
void type_env::bind_type(const std::string& type_name, type_ptr t) {
if(lookup_type(type_name) != nullptr) throw 0;
if(lookup_type(type_name) != nullptr)
throw type_error("redefinition of type");
type_names[type_name] = t;
}
void type_env::generalize(const std::string& name, const group& grp, type_mgr& mgr) {
auto names_it = names.find(name);
if(names_it == names.end()) throw 0;
if(names_it->second.type->forall.size() > 0) throw 0;
assert(names_it != names.end());
assert(names_it->second.type->forall.size() == 0);
std::set<std::string> free_in_type;
std::set<std::string> free_in_env;

Loading…
Cancel
Save