Fix c++11 compatibility.

src/gmachine.hpp

@@ -15,12 +15,12 @@ namespace lily {
 
     struct instruction_slide : instruction {
         int amount;
-        
+
         instruction_slide(int a) : amount(a) {}
         std::ostream& to_stream(std::ostream& os);
         void gen_llvm(llvm_context& ctx);
     };
-    
+
     struct instruction_alloc : instruction {
         int amount;
 
@@ -44,7 +44,7 @@ namespace lily {
 
     struct instruction_push_global : instruction {
         std::string name;
-        
+
         instruction_push_global(std::string n) : name(std::move(n)) {}
         std::ostream& to_stream(std::ostream& os);
         void gen_llvm(llvm_context& ctx);
@@ -145,7 +145,7 @@ namespace lily {
         public:
             template <typename T, typename ... Ts>
             T* add_instruction(Ts ... ts) {
-                auto new_inst = std::make_unique<T>(ts...);
+                auto new_inst = std::unique_ptr<T>(new T(ts...));
                 T* raw = new_inst.get();
                 instructions.push_back(std::move(new_inst));
                 return raw;

src/parser.cpp

@@ -117,7 +117,7 @@ namespace lily {
         ast_case* new_case = new ast_case();
         ast_ptr case_ptr = ast_ptr(new_case);
         new_case->of = expr_tree(PGS_TREE_NT_CHILD(*c, 1), source);
-        
+
         pgs_tree* branches = PGS_TREE_NT_CHILD(*c, 4);
         while(PGS_TREE_NT_COUNT(*branches) == 2) {
             pgs_tree* branch = PGS_TREE_NT_CHILD(*branches, 0);
@@ -216,7 +216,7 @@ namespace lily {
     }
 
     static program_ptr build_program(pgs_tree* tree, const char* source) {
-        program_ptr prog = std::make_unique<program>();
+        program_ptr prog = std::unique_ptr<program>(new program);
         pgs_tree* program = PGS_TREE_NT_CHILD(*tree, 0);
 
         do {
@@ -239,7 +239,7 @@ namespace lily {
         if((err = pgs_do_all(&state, &into, s.c_str())) != PGS_NONE) {
             throw error("failed to parse input string");
         }
-        
+
         program_ptr prog = build_program(into, s.c_str());
         prog->check();
         pgs_free_tree(into);

src/type.cpp

@@ -4,7 +4,7 @@
 namespace lily {
     type_data::constructor* type_data::create_constructor(const std::string& name,
             std::vector<type*>&& params) {
-        auto new_constructor = std::make_unique<constructor>();
+        auto new_constructor = std::unique_ptr<constructor>(new constructor());
         new_constructor->id = constructors.size();
         new_constructor->parent = this;
         new_constructor->params = std::move(params);

src/type.hpp

@@ -2,6 +2,7 @@
 #include <string>
 #include <vector>
 #include <map>
+#include <memory>
 
 namespace lily {
     enum reserved_types {

src/type_checker.hpp

@@ -1,5 +1,6 @@
 #pragma once
 #include <map>
+#include <memory>
 #include "type.hpp"
 #include "ast.hpp"
 

src/type_manager.cpp

@@ -12,7 +12,7 @@ namespace lily {
     }
 
     type_internal* type_manager::create_int_type() {
-        auto new_type = std::make_unique<type_internal>(next_id++);
+        auto new_type = std::unique_ptr<type_internal>(new type_internal(next_id++));
         type_internal* raw_ptr = new_type.get();
         types.push_back(std::move(new_type));
         type_names["Int"] = raw_ptr;
@@ -20,7 +20,7 @@ namespace lily {
     }
 
     type_internal* type_manager::create_str_type() {
-        auto new_type = std::make_unique<type_internal>(next_id++);
+        auto new_type = std::unique_ptr<type_internal>(new type_internal(next_id++));
         type_internal* raw_ptr = new_type.get();
         types.push_back(std::move(new_type));
         type_names["Str"] = raw_ptr;
@@ -29,7 +29,7 @@ namespace lily {
 
     type_data* type_manager::create_data_type(const std::string& name) {
         if(type_names.count(name)) throw error("redefinition of type");
-        auto new_type = std::make_unique<type_data>(next_id++);
+        auto new_type = std::unique_ptr<type_data>(new type_data(next_id++));
         type_data* raw_ptr = new_type.get();
         types.push_back(std::move(new_type));
         type_names[name] = raw_ptr;

src/type_manager.hpp

@@ -21,7 +21,7 @@ namespace lily {
             type_data* create_data_type(const std::string& name);
             template <typename T, typename ... Args>
             T* create_type(Args...as) {
-                auto new_type = std::make_unique<T>(as...);
+                auto new_type = std::unique_ptr<T>(new T(as...));
                 T* raw_ptr = new_type.get();
                 types.push_back(std::move(new_type));
                 return raw_ptr;