Remove uses of std::endl, which imply a flush

lefticus · lefticus · commit 63a083b47b88 · 2014-11-13T10:13:51.000-07:00
diff --git a/include/chaiscript/dispatchkit/bootstrap.hpp b/include/chaiscript/dispatchkit/bootstrap.hpp
@@ -207,7 +207,7 @@ namespace chaiscript
 
       static void println(const std::string &s)
       {
-        std::cout << s << std::endl;
+        std::cout << s << '\n';
       }
 
 
diff --git a/include/chaiscript/dispatchkit/boxed_cast.hpp b/include/chaiscript/dispatchkit/boxed_cast.hpp
@@ -89,13 +89,13 @@ namespace chaiscript
       if (t_conversions && t_conversions->convertable_type<Type>())
       {
         try {
-          // std::cout << "trying an up conversion " << typeid(Type).name() << std::endl;
+          // std::cout << "trying an up conversion " << typeid(Type).name() << '\n';
           // We will not catch any bad_boxed_dynamic_cast that is thrown, let the user get it
           // either way, we are not responsible if it doesn't work
           return detail::Cast_Helper<Type>::cast(t_conversions->boxed_type_conversion<Type>(bv), t_conversions);
         } catch (...) {
           try {
-          //  std::cout << "trying a down conversion " << typeid(Type).name() << std::endl;
+          //  std::cout << "trying a down conversion " << typeid(Type).name() << '\n';
             // try going the other way - down the inheritance graph
             return detail::Cast_Helper<Type>::cast(t_conversions->boxed_type_down_conversion<Type>(bv), t_conversions);
           } catch (const chaiscript::detail::exception::bad_any_cast &) {
diff --git a/include/chaiscript/dispatchkit/dispatchkit.hpp b/include/chaiscript/dispatchkit/dispatchkit.hpp
@@ -796,7 +796,7 @@ namespace chaiscript
         /// Dump object info to stdout
         void dump_object(const Boxed_Value &o) const
         {
-          std::cout << (o.is_const()?"const ":"") << type_name(o) << std::endl;
+          std::cout << (o.is_const()?"const ":"") << type_name(o) << '\n';
         }
 
         /// Dump type info to stdout
@@ -830,7 +830,7 @@ namespace chaiscript
             }
           }
 
-          std::cout << ") " << std::endl;
+          std::cout << ") \n";
         }
 
         /// Returns true if a call can be made that consists of the first parameter
@@ -850,28 +850,28 @@ namespace chaiscript
         /// Dump all system info to stdout
         void dump_system() const
         {
-          std::cout << "Registered Types: " << std::endl;
+          std::cout << "Registered Types: \n";
           std::vector<std::pair<std::string, Type_Info> > types = get_types();
           for (std::vector<std::pair<std::string, Type_Info> >::const_iterator itr = types.begin();
               itr != types.end();
               ++itr)
           {
             std::cout << itr->first << ": ";
             std::cout << itr->second.bare_name();
-            std::cout << std::endl;
+            std::cout << '\n';
           }
 
-          std::cout << std::endl;  
+          std::cout << '\n';  
           std::vector<std::pair<std::string, Proxy_Function > > funcs = get_functions();
 
-          std::cout << "Functions: " << std::endl;
+          std::cout << "Functions: \n";
           for (std::vector<std::pair<std::string, Proxy_Function > >::const_iterator itr = funcs.begin();
               itr != funcs.end();
               ++itr)
           {
             dump_function(*itr);
           }
-          std::cout << std::endl;
+          std::cout << '\n';
         }
 
         /// return true if the Boxed_Value matches the registered type by name
diff --git a/include/chaiscript/dispatchkit/type_conversions.hpp b/include/chaiscript/dispatchkit/type_conversions.hpp
@@ -429,11 +429,7 @@ namespace chaiscript
       static_assert(std::is_convertible<From, To>::value, "Types are not automatically convertible");
       auto func = [](const Boxed_Value &t_bv) -> Boxed_Value {
             // not even attempting to call boxed_cast so that we don't get caught in some call recursion
-            std::cout << " Type conversion to : " << typeid(To).name() << " from " << typeid(From).name() << std::endl;
             auto &&from =  detail::Cast_Helper<From>::cast(t_bv, nullptr);
-            std::cout << "Ptr" << static_cast<const void *>(from) << std::endl;
-            std::cout << "Ptr" << from << std::endl;
-
             To to(from);
             return chaiscript::Boxed_Value(to);
           };
diff --git a/include/chaiscript/language/chaiscript_common.hpp b/include/chaiscript/language/chaiscript_common.hpp
@@ -118,19 +118,19 @@ namespace chaiscript
 
         ss << what();
         if (call_stack.size() > 0) {
-          ss << "during evaluation at (" << fname(call_stack[0]) << " " << startpos(call_stack[0]) << ")" << std::endl;
-          ss << std::endl << detail << std::endl;
+          ss << "during evaluation at (" << fname(call_stack[0]) << " " << startpos(call_stack[0]) << ")\n";
+          ss << '\n' << detail << '\n';
           ss << "  " << fname(call_stack[0]) << " (" << startpos(call_stack[0]) << ") '" << pretty(call_stack[0]) << "'";
           for (size_t j = 1; j < call_stack.size(); ++j) {
             if (id(call_stack[j]) != chaiscript::AST_Node_Type::Block
                 && id(call_stack[j]) != chaiscript::AST_Node_Type::File)
             {
-              ss << std::endl;
+              ss << '\n';
               ss << "  from " << fname(call_stack[j]) << " (" << startpos(call_stack[j]) << ") '" << pretty(call_stack[j]) << "'";
             }
           }
         }
-        ss << std::endl;
+        ss << '\n';
         return ss.str();
       }
 
@@ -264,13 +264,13 @@ namespace chaiscript
         std::stringstream ss;
         if (t_functions.size() == 1)
         {
-          ss << "  Expected: " << format_types(t_functions[0], t_dot_notation, t_ss) << std::endl;
+          ss << "  Expected: " << format_types(t_functions[0], t_dot_notation, t_ss) << '\n';
         } else {
-          ss << "  " << t_functions.size() << " overloads available:" << std::endl;
+          ss << "  " << t_functions.size() << " overloads available:\n";
 
           for (const auto & t_function : t_functions)
           {
-            ss << "      " << format_types((t_function), t_dot_notation, t_ss) << std::endl;
+            ss << "      " << format_types((t_function), t_dot_notation, t_ss) << '\n';
           }
 
         }
@@ -430,7 +430,7 @@ namespace chaiscript
         std::ostringstream oss;
 
         oss << t_prepend << "(" << ast_node_type_to_string(this->identifier) << ") "
-            << this->text << " : " << this->start.line << ", " << this->start.column << std::endl;
+            << this->text << " : " << this->start.line << ", " << this->start.column << '\n';
 
         for (size_t j = 0; j < this->children.size(); ++j) {
           oss << this->children[j]->to_string(t_prepend + "  ");
diff --git a/include/chaiscript/language/chaiscript_engine.hpp b/include/chaiscript/language/chaiscript_engine.hpp
@@ -735,11 +735,11 @@ namespace chaiscript
           {
             try {
               const auto name = elem + prefix + t_module_name + postfix;
-              // std::cerr << "trying location: " << name << std::endl;
+              // std::cerr << "trying location: " << name << '\n';
               load_module(version_stripped_name, name);
               return name;
             } catch (const chaiscript::exception::load_module_error &e) {
-              // std::cerr << "error: " << e.what() << std::endl;
+              // std::cerr << "error: " << e.what() << '\n';
               errors.push_back(e);
               // Try next set
             }
diff --git a/include/chaiscript/language/chaiscript_parser.hpp b/include/chaiscript/language/chaiscript_parser.hpp
@@ -171,7 +171,7 @@ namespace chaiscript
       /// Prints the parsed ast_nodes as a tree
       /*
          void debug_print(AST_NodePtr t, std::string prepend = "") {
-         std::cout << prepend << "(" << ast_node_type_to_string(t->identifier) << ") " << t->text << " : " << t->start.line << ", " << t->start.column << std::endl;
+         std::cout << prepend << "(" << ast_node_type_to_string(t->identifier) << ") " << t->text << " : " << t->start.line << ", " << t->start.column << '\n';
          for (unsigned int j = 0; j < t->children.size(); ++j) {
          debug_print(t->children[j], prepend + "  ");
          }
diff --git a/samples/example.cpp b/samples/example.cpp
@@ -13,12 +13,12 @@
 
 void log(const std::string &msg)
 {
-  std::cout << "[" << time(nullptr) << "] " << msg << std::endl;
+  std::cout << "[" << time(nullptr) << "] " << msg << '\n';
 }
 
 void log(const std::string &module, const std::string &msg)
 {
-  std::cout << "[" << time(nullptr) << "] <" << module << "> " << msg << std::endl;
+  std::cout << "[" << time(nullptr) << "] <" << module << "> " << msg << '\n';
 }
 
 void bound_log(const std::string &msg)
@@ -28,12 +28,12 @@ void bound_log(const std::string &msg)
 
 void hello_world(const chaiscript::Boxed_Value & /*o*/)
 {
-  std::cout << "Hello World" << std::endl;
+  std::cout << "Hello World\n";
 }
 
 void hello_constructor(const chaiscript::Boxed_Value & /*o*/)
 {
-  std::cout << "Hello Constructor" << std::endl;
+  std::cout << "Hello Constructor\n";
 }
 
 
@@ -62,7 +62,7 @@ struct System
 
 void take_shared_ptr(const std::shared_ptr<const std::string> &p)
 {
-  std::cout << *p << std::endl;
+  std::cout << *p << '\n';
 }
 
 int main(int /*argc*/, char * /*argv*/[]) {
@@ -122,17 +122,17 @@ int main(int /*argc*/, char * /*argv*/[]) {
   //the templated version of eval:
   int i = chai.eval<int>("5+5");
 
-  std::cout << "5+5: " << i << std::endl;
+  std::cout << "5+5: " << i << '\n';
 
   //Add a new variable
   chai("var scripti = 15");
 
   //We can even get a handle to the variables in the system
   int &scripti = chai.eval<int &>("scripti");
 
-  std::cout << "scripti: " << scripti << std::endl;
+  std::cout << "scripti: " << scripti << '\n';
   scripti *= 2;
-  std::cout << "scripti (updated): " << scripti << std::endl;
+  std::cout << "scripti (updated): " << scripti << '\n';
   chai("print(\"Scripti from chai: \" + to_string(scripti))");
 
   //To do: Add examples of handling Boxed_Values directly when needed
diff --git a/samples/memory_leak_test.cpp b/samples/memory_leak_test.cpp
@@ -54,7 +54,7 @@ class test
       chaiscript::Boxed_Value val = chai.eval_file(sFile);
     }
     catch (std::exception &e) {
-      std::cout << e.what() << std::endl;
+      std::cout << e.what() << '\n';
     }
   }
 
diff --git a/src/main.cpp b/src/main.cpp
@@ -136,24 +136,24 @@ std::vector<std::string> default_search_paths()
 
 void help(int n) {
   if ( n >= 0 ) {
-    std::cout << "ChaiScript evaluator.  To evaluate an expression, type it and press <enter>." << std::endl;
-    std::cout << "Additionally, you can inspect the runtime system using:" << std::endl;
-    std::cout << "  dump_system() - outputs all functions registered to the system" << std::endl;
-    std::cout << "  dump_object(x) - dumps information about the given symbol" << std::endl;
+    std::cout << "ChaiScript evaluator.  To evaluate an expression, type it and press <enter>.\n";
+    std::cout << "Additionally, you can inspect the runtime system using:\n";
+    std::cout << "  dump_system() - outputs all functions registered to the system\n";
+    std::cout << "  dump_object(x) - dumps information about the given symbol\n";
   } else {
-    std::cout << "usage : chai [option]+" << std::endl;
-    std::cout << "option:"                << std::endl;
-    std::cout << "   -h | --help"         << std::endl;
-    std::cout << "   -i | --interactive"  << std::endl;
-    std::cout << "   -c | --command cmd"  << std::endl;
-    std::cout << "   -v | --version"      << std::endl;
-    std::cout << "   -    --stdin"        << std::endl;
-    std::cout << "   filepath"            << std::endl;
+    std::cout << "usage : chai [option]+\n";
+    std::cout << "option:"                << '\n';
+    std::cout << "   -h | --help"         << '\n';
+    std::cout << "   -i | --interactive"  << '\n';
+    std::cout << "   -c | --command cmd"  << '\n';
+    std::cout << "   -v | --version"      << '\n';
+    std::cout << "   -    --stdin"        << '\n';
+    std::cout << "   filepath"            << '\n';
   }
 }
 
 void version(int){
-  std::cout << "chai: compiled " << __TIME__ << " " << __DATE__ << std::endl;
+  std::cout << "chai: compiled " << __TIME__ << " " << __DATE__ << '\n';
 }
 
 bool throws_exception(const std::function<void ()> &f)
@@ -231,7 +231,7 @@ void interactive(chaiscript::ChaiScript& chai)
       //Then, we try to print the result of the evaluation to the user
       if (!val.get_type_info().bare_equal(chaiscript::user_type<void>())) {
         try {
-          std::cout << chai.eval<std::function<std::string (const chaiscript::Boxed_Value &bv)> >("to_string")(val) << std::endl;
+          std::cout << chai.eval<std::function<std::string (const chaiscript::Boxed_Value &bv)> >("to_string")(val) << '\n';
         }
         catch (...) {} //If we can't, do nothing
       }
@@ -241,11 +241,11 @@ void interactive(chaiscript::ChaiScript& chai)
       if (ee.call_stack.size() > 0) {
         std::cout << "during evaluation at (" << ee.call_stack[0]->start.line << ", " << ee.call_stack[0]->start.column << ")";
       }
-      std::cout << std::endl;
+      std::cout << '\n';
     }
     catch (const std::exception &e) {
       std::cout << e.what();
-      std::cout << std::endl;
+      std::cout << '\n';
     }
   }
 }
@@ -305,7 +305,7 @@ int main(int argc, char *argv[])
 
     if  ( arg == "-c" || arg == "--command" ) {
       if ( (i+1) >= argc ) {
-        std::cout << "insufficient input following " << arg << std::endl;
+        std::cout << "insufficient input following " << arg << '\n';
         return EXIT_FAILURE;
       } else {
         arg = argv[++i];
@@ -323,7 +323,7 @@ int main(int argc, char *argv[])
     } else if ( arg == "-i" || arg == "--interactive" ) {
       mode = eInteractive ;
     } else if ( arg.find('-') == 0 ) {
-      std::cout << "unrecognised argument " << arg << std::endl;
+      std::cout << "unrecognised argument " << arg << '\n';
       return EXIT_FAILURE;
     } else {
       mode = eFile;
@@ -335,16 +335,16 @@ int main(int argc, char *argv[])
         case eInteractive : interactive(chai); break;
         case eCommand     : val = chai.eval(arg); break;
         case eFile        : val = chai.eval_file(arg); break;
-        default           : std::cout << "Unrecognized execution mode" << std::endl; return EXIT_FAILURE;
+        default           : std::cout << "Unrecognized execution mode\n"; return EXIT_FAILURE;
       }
     }
     catch (const chaiscript::exception::eval_error &ee) {
       std::cout << ee.pretty_print();
-      std::cout << std::endl;
+      std::cout << '\n';
       return EXIT_FAILURE;
     }
     catch (std::exception &e) {
-      std::cout << e.what() << std::endl;
+      std::cout << e.what() << '\n';
       return EXIT_FAILURE;
     }
   }
diff --git a/unittests/boxed_cast_test.cpp b/unittests/boxed_cast_test.cpp
@@ -15,16 +15,16 @@ bool run_test_type_conversion(const Boxed_Value &bv, bool expectedpass)
     use(ret);
   } catch (const chaiscript::exception::bad_boxed_cast &/*e*/) {
     if (expectedpass) {
-//      std::cerr << "Failure in run_test_type_conversion: " << e.what() << std::endl;
+//      std::cerr << "Failure in run_test_type_conversion: " << e.what() << '\n';
       return false;
     } else {
       return true;
     }
   } catch (const std::exception &e) {
-    std::cerr << "Unexpected standard exception when attempting cast_conversion: " << e.what() << std::endl;
+    std::cerr << "Unexpected standard exception when attempting cast_conversion: " << e.what() << '\n';
     return false;
   } catch (...) {
-    std::cerr << "Unexpected unknown exception when attempting cast_conversion." << std::endl;
+    std::cerr << "Unexpected unknown exception when attempting cast_conversion.\n";
     return false;
   }
  
@@ -47,7 +47,7 @@ bool test_type_conversion(const Boxed_Value &bv, bool expectedpass)
       << (bv.is_const()?(std::string("const ")):(std::string())) << bv.get_type_info().name() 
       << " To: "  
       << (std::is_const<To>::value?(std::string("const ")):(std::string())) << typeid(To).name() 
-      << " test was expected to " << ((expectedpass)?(std::string("succeed")):(std::string("fail"))) << " but did not" << std::endl;
+      << " test was expected to " << ((expectedpass)?(std::string("succeed")):(std::string("fail"))) << " but did not\n";
   }
 
   return ret;
@@ -264,21 +264,21 @@ bool pointer_test(const T& default_value, const T& new_value)
 
 
     if (p != (*result) ) { 
-      std::cerr << "Pointer passed in different than one returned" << std::endl;
+      std::cerr << "Pointer passed in different than one returned\n";
       return false;
     }
 
     if (*p != *(*result) ) {
-      std::cerr << "Somehow dereferenced pointer values are not the same?" << std::endl;
+      std::cerr << "Somehow dereferenced pointer values are not the same?\n";
       return false;
     }
 
     return true;
   } catch (const exception::bad_boxed_cast &) {
-    std::cerr << "Bad boxed cast performing ** to ** test" << std::endl;
+    std::cerr << "Bad boxed cast performing ** to ** test\n";
     return false;
   } catch (...) {
-    std::cerr << "Unknown exception performing ** to ** test" << std::endl;
+    std::cerr << "Unknown exception performing ** to ** test\n";
     return false;
   }
 
diff --git a/unittests/dynamic_object_test.cpp b/unittests/dynamic_object_test.cpp
@@ -8,7 +8,7 @@ void assert_equal(const LHS &lhs, const RHS &rhs)
   {
     return;
   } else {
-    std::cout << "Got: " << lhs << " expected " << rhs << std::endl;
+    std::cout << "Got: " << lhs << " expected " << rhs << '\n';
     exit(EXIT_FAILURE);
   }
 }
diff --git a/unittests/eval_catch_exception_test.cpp b/unittests/eval_catch_exception_test.cpp
diff --git a/unittests/integer_literal_test.cpp b/unittests/integer_literal_test.cpp
diff --git a/unittests/type_info_test.cpp b/unittests/type_info_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -207,7 +207,7 @@ namespace chaiscript`
`207`	`207`
`208`	`208`	`static void println(const std::string &s)`
`209`	`209`	`{`
`210`		`- std::cout << s << std::endl;`
	`210`	`+ std::cout << s << '\n';`
`211`	`211`	`}`
`212`	`212`
`213`	`213`
Original file line number	Diff line number	Diff line change
`@@ -796,7 +796,7 @@ namespace chaiscript`
`796`	`796`	`/// Dump object info to stdout`
`797`	`797`	`void dump_object(const Boxed_Value &o) const`
`798`	`798`	`{`
`799`		`- std::cout << (o.is_const()?"const ":"") << type_name(o) << std::endl;`
	`799`	`+ std::cout << (o.is_const()?"const ":"") << type_name(o) << '\n';`
`800`	`800`	`}`
`801`	`801`
`802`	`802`	`/// Dump type info to stdout`
`@@ -830,7 +830,7 @@ namespace chaiscript`
`830`	`830`	`}`
`831`	`831`	`}`
`832`	`832`
`833`		`- std::cout << ") " << std::endl;`
	`833`	`+ std::cout << ") \n";`
`834`	`834`	`}`
`835`	`835`
`836`	`836`	`/// Returns true if a call can be made that consists of the first parameter`
`@@ -850,28 +850,28 @@ namespace chaiscript`
`850`	`850`	`/// Dump all system info to stdout`
`851`	`851`	`void dump_system() const`
`852`	`852`	`{`
`853`		`- std::cout << "Registered Types: " << std::endl;`
	`853`	`+ std::cout << "Registered Types: \n";`
`854`	`854`	`std::vector<std::pair<std::string, Type_Info> > types = get_types();`
`855`	`855`	`for (std::vector<std::pair<std::string, Type_Info> >::const_iterator itr = types.begin();`
`856`	`856`	`itr != types.end();`
`857`	`857`	`++itr)`
`858`	`858`	`{`
`859`	`859`	`std::cout << itr->first << ": ";`
`860`	`860`	`std::cout << itr->second.bare_name();`
`861`		`- std::cout << std::endl;`
	`861`	`+ std::cout << '\n';`
`862`	`862`	`}`
`863`	`863`
`864`		`- std::cout << std::endl;`
	`864`	`+ std::cout << '\n';`
`865`	`865`	`std::vector<std::pair<std::string, Proxy_Function > > funcs = get_functions();`
`866`	`866`
`867`		`- std::cout << "Functions: " << std::endl;`
	`867`	`+ std::cout << "Functions: \n";`
`868`	`868`	`for (std::vector<std::pair<std::string, Proxy_Function > >::const_iterator itr = funcs.begin();`
`869`	`869`	`itr != funcs.end();`
`870`	`870`	`++itr)`
`871`	`871`	`{`
`872`	`872`	`dump_function(*itr);`
`873`	`873`	`}`
`874`		`- std::cout << std::endl;`
	`874`	`+ std::cout << '\n';`
`875`	`875`	`}`
`876`	`876`
`877`	`877`	`/// return true if the Boxed_Value matches the registered type by name`
Original file line number	Diff line number	Diff line change
`@@ -118,19 +118,19 @@ namespace chaiscript`
`118`	`118`
`119`	`119`	`ss << what();`
`120`	`120`	`if (call_stack.size() > 0) {`
`121`		`- ss << "during evaluation at (" << fname(call_stack[0]) << " " << startpos(call_stack[0]) << ")" << std::endl;`
`122`		`- ss << std::endl << detail << std::endl;`
	`121`	`+ ss << "during evaluation at (" << fname(call_stack[0]) << " " << startpos(call_stack[0]) << ")\n";`
	`122`	`+ ss << '\n' << detail << '\n';`
`123`	`123`	`ss << " " << fname(call_stack[0]) << " (" << startpos(call_stack[0]) << ") '" << pretty(call_stack[0]) << "'";`
`124`	`124`	`for (size_t j = 1; j < call_stack.size(); ++j) {`
`125`	`125`	`if (id(call_stack[j]) != chaiscript::AST_Node_Type::Block`
`126`	`126`	`&& id(call_stack[j]) != chaiscript::AST_Node_Type::File)`
`127`	`127`	`{`
`128`		`- ss << std::endl;`
	`128`	`+ ss << '\n';`
`129`	`129`	`ss << " from " << fname(call_stack[j]) << " (" << startpos(call_stack[j]) << ") '" << pretty(call_stack[j]) << "'";`
`130`	`130`	`}`
`131`	`131`	`}`
`132`	`132`	`}`
`133`		`- ss << std::endl;`
	`133`	`+ ss << '\n';`
`134`	`134`	`return ss.str();`
`135`	`135`	`}`
`136`	`136`
`@@ -264,13 +264,13 @@ namespace chaiscript`
`264`	`264`	`std::stringstream ss;`
`265`	`265`	`if (t_functions.size() == 1)`
`266`	`266`	`{`
`267`		`- ss << " Expected: " << format_types(t_functions[0], t_dot_notation, t_ss) << std::endl;`
	`267`	`+ ss << " Expected: " << format_types(t_functions[0], t_dot_notation, t_ss) << '\n';`
`268`	`268`	`} else {`
`269`		`- ss << " " << t_functions.size() << " overloads available:" << std::endl;`
	`269`	`+ ss << " " << t_functions.size() << " overloads available:\n";`
`270`	`270`
`271`	`271`	`for (const auto & t_function : t_functions)`
`272`	`272`	`{`
`273`		`- ss << " " << format_types((t_function), t_dot_notation, t_ss) << std::endl;`
	`273`	`+ ss << " " << format_types((t_function), t_dot_notation, t_ss) << '\n';`
`274`	`274`	`}`
`275`	`275`
`276`	`276`	`}`
`@@ -430,7 +430,7 @@ namespace chaiscript`
`430`	`430`	`std::ostringstream oss;`
`431`	`431`
`432`	`432`	`oss << t_prepend << "(" << ast_node_type_to_string(this->identifier) << ") "`
`433`		`- << this->text << " : " << this->start.line << ", " << this->start.column << std::endl;`
	`433`	`+ << this->text << " : " << this->start.line << ", " << this->start.column << '\n';`
`434`	`434`
`435`	`435`	`for (size_t j = 0; j < this->children.size(); ++j) {`
`436`	`436`	`oss << this->children[j]->to_string(t_prepend + " ");`
Original file line number	Diff line number	Diff line change
`@@ -735,11 +735,11 @@ namespace chaiscript`
`735`	`735`	`{`
`736`	`736`	`try {`
`737`	`737`	`const auto name = elem + prefix + t_module_name + postfix;`
`738`		`- // std::cerr << "trying location: " << name << std::endl;`
	`738`	`+ // std::cerr << "trying location: " << name << '\n';`
`739`	`739`	`load_module(version_stripped_name, name);`
`740`	`740`	`return name;`
`741`	`741`	`} catch (const chaiscript::exception::load_module_error &e) {`
`742`		`- // std::cerr << "error: " << e.what() << std::endl;`
	`742`	`+ // std::cerr << "error: " << e.what() << '\n';`
`743`	`743`	`errors.push_back(e);`
`744`	`744`	`// Try next set`
`745`	`745`	`}`
Original file line number	Diff line number	Diff line change
`@@ -171,7 +171,7 @@ namespace chaiscript`
`171`	`171`	`/// Prints the parsed ast_nodes as a tree`
`172`	`172`	`/*`
`173`	`173`	`void debug_print(AST_NodePtr t, std::string prepend = "") {`
`174`		`- std::cout << prepend << "(" << ast_node_type_to_string(t->identifier) << ") " << t->text << " : " << t->start.line << ", " << t->start.column << std::endl;`
	`174`	`+ std::cout << prepend << "(" << ast_node_type_to_string(t->identifier) << ") " << t->text << " : " << t->start.line << ", " << t->start.column << '\n';`
`175`	`175`	`for (unsigned int j = 0; j < t->children.size(); ++j) {`
`176`	`176`	`debug_print(t->children[j], prepend + " ");`
`177`	`177`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,12 +13,12 @@`
`13`	`13`
`14`	`14`	`void log(const std::string &msg)`
`15`	`15`	`{`
`16`		`- std::cout << "[" << time(nullptr) << "] " << msg << std::endl;`
	`16`	`+ std::cout << "[" << time(nullptr) << "] " << msg << '\n';`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`void log(const std::string &module, const std::string &msg)`
`20`	`20`	`{`
`21`		`- std::cout << "[" << time(nullptr) << "] <" << module << "> " << msg << std::endl;`
	`21`	`+ std::cout << "[" << time(nullptr) << "] <" << module << "> " << msg << '\n';`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`void bound_log(const std::string &msg)`
`@@ -28,12 +28,12 @@ void bound_log(const std::string &msg)`
`28`	`28`
`29`	`29`	`void hello_world(const chaiscript::Boxed_Value & /o/)`
`30`	`30`	`{`
`31`		`- std::cout << "Hello World" << std::endl;`
	`31`	`+ std::cout << "Hello World\n";`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`void hello_constructor(const chaiscript::Boxed_Value & /o/)`
`35`	`35`	`{`
`36`		`- std::cout << "Hello Constructor" << std::endl;`
	`36`	`+ std::cout << "Hello Constructor\n";`
`37`	`37`	`}`
`38`	`38`
`39`	`39`
`@@ -62,7 +62,7 @@ struct System`
`62`	`62`
`63`	`63`	`void take_shared_ptr(const std::shared_ptr<const std::string> &p)`
`64`	`64`	`{`
`65`		`- std::cout << *p << std::endl;`
	`65`	`+ std::cout << *p << '\n';`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`int main(int /argc/, char * /argv/[]) {`
`@@ -122,17 +122,17 @@ int main(int /argc/, char * /argv/[]) {`
`122`	`122`	`//the templated version of eval:`
`123`	`123`	`int i = chai.eval<int>("5+5");`
`124`	`124`
`125`		`- std::cout << "5+5: " << i << std::endl;`
	`125`	`+ std::cout << "5+5: " << i << '\n';`
`126`	`126`
`127`	`127`	`//Add a new variable`
`128`	`128`	`chai("var scripti = 15");`
`129`	`129`
`130`	`130`	`//We can even get a handle to the variables in the system`
`131`	`131`	`int &scripti = chai.eval<int &>("scripti");`
`132`	`132`
`133`		`- std::cout << "scripti: " << scripti << std::endl;`
	`133`	`+ std::cout << "scripti: " << scripti << '\n';`
`134`	`134`	`scripti *= 2;`
`135`		`- std::cout << "scripti (updated): " << scripti << std::endl;`
	`135`	`+ std::cout << "scripti (updated): " << scripti << '\n';`
`136`	`136`	`chai("print(\"Scripti from chai: \" + to_string(scripti))");`
`137`	`137`
`138`	`138`	`//To do: Add examples of handling Boxed_Values directly when needed`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ class test`
`54`	`54`	`chaiscript::Boxed_Value val = chai.eval_file(sFile);`
`55`	`55`	`}`
`56`	`56`	`catch (std::exception &e) {`
`57`		`- std::cout << e.what() << std::endl;`
	`57`	`+ std::cout << e.what() << '\n';`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`