Use split_from_includes

Author: anutosh491

src/xinterpreter.cpp

@@ -137,9 +137,6 @@ __get_cxx_version ()
     {
         nl::json kernel_res;
 
-
-        auto input_guard = input_redirection(config.allow_stdin);
-
         // Check for magics
         for (auto& pre : preamble_manager.preamble)
         {
@@ -151,7 +148,11 @@ __get_cxx_version ()
             }
         }
 
+        // Split code from includes
+        auto blocks = split_from_includes(code.c_str());
+
         auto errorlevel = 0;
+
         std::string ename;
         std::string evalue;
         //bool compilation_result = false;
@@ -173,30 +174,36 @@ __get_cxx_version ()
 
         std::string err;
 
-        // Attempt normal evaluation
-        try
-        {
-            StreamRedirectRAII R(err);
-            output_value = Cpp::Evaluate(code.c_str(), &hadError);
-        }
-        catch (std::exception& e)
-        {
-            errorlevel = 1;
-            ename = "Standard Exception: ";
-            evalue = e.what();
-        }
-        catch (...)
-        {
-            errorlevel = 1;
-            ename = "Error: ";
-        }
+        // Scope guard performing the temporary redirection of input requests.
+        auto input_guard = input_redirection(config.allow_stdin);
 
-        if (hadError)
+        for (const auto& block : blocks)
         {
-            errorlevel = 1;
-            ename = "Error: ";
-            evalue = "Compilation error! " + err;
-            std::cerr << err;
+            // Attempt normal evaluation
+            try
+            {
+                StreamRedirectRAII R(err);
+                output_value = Cpp::Evaluate(block.c_str(), &hadError);
+            }
+            catch (std::exception& e)
+            {
+                errorlevel = 1;
+                ename = "Standard Exception: ";
+                evalue = e.what();
+            }
+            catch (...)
+            {
+                errorlevel = 1;
+                ename = "Error: ";
+            }
+
+            if (hadError)
+            {
+                errorlevel = 1;
+                ename = "Error: ";
+                evalue = "Compilation error! " + err;
+                std::cerr << err;
+            }
         }
 
         // Flush streams
@@ -238,7 +245,7 @@ __get_cxx_version ()
         {
             // Publish a mime bundle for the last return value if
             // the semicolon was omitted.
-            if (!config.silent && !hadError && trim(code).back() != ';') {
+            if (!config.silent && !hadError && trim(blocks.back()).back() != ';') {
                 nl::json pub_data = mime_repr(output_value);
                 publish_execution_result(execution_counter, std::move(pub_data), nl::json::object());
             }

src/xparser.cpp

@@ -54,4 +54,80 @@ namespace xcpp
 
         return result;
     }
+
+    std::vector<std::string> get_lines(const std::string& input)
+    {
+        std::vector<std::string> lines;
+        std::regex re("\\n");
+
+        std::copy(
+            std::sregex_token_iterator(input.begin(), input.end(), re, -1),
+            std::sregex_token_iterator(),
+            std::back_inserter(lines)
+        );
+        return lines;
+    }
+
+    std::vector<std::string> split_from_includes(const std::string& input)
+    {
+        // this function split the input into part where we have only #include.
+
+        // split input into lines
+        std::vector<std::string> lines = get_lines(input);
+
+        // check if each line contains #include and concatenate the result in the good part of the result
+        std::regex incl_re("\\#include.*");
+        std::regex magic_re("^\\%\\w+");
+        std::vector<std::string> result;
+        result.push_back("");
+        std::size_t current = 0;  // 0 include, 1 other
+        std::size_t rindex = 0;   // current index of result vector
+        for (std::size_t i = 0; i < lines.size(); ++i)
+        {
+            if (!lines[i].empty())
+            {
+                if (std::regex_search(lines[i], magic_re))
+                {
+                    result.push_back(lines[i] + "\n");
+                    result.push_back("");
+                    rindex += 2;
+                }
+                else
+                {
+                    if (std::regex_match(lines[i], incl_re))
+                    {
+                        // if we have #include in this line
+                        // but the current item of result vector contains
+                        // other things
+                        if (current != 0)
+                        {
+                            current = 0;
+                            result.push_back("");
+                            rindex++;
+                        }
+                    }
+                    else
+                    {
+                        // if we don't have #include in this line
+                        // but the current item of result vector contains
+                        // the include parts
+                        if (current != 1)
+                        {
+                            current = 1;
+                            result.push_back("");
+                            rindex++;
+                        }
+                    }
+                    // if we have multiple lines, we add a semicolon at the end of the lines that not contain
+                    // #include keyword (except for the last line)
+                    result[rindex] += lines[i];
+                    if (i != lines.size() - 1)
+                    {
+                        result[rindex] += "\n";
+                    }
+                }
+            }
+        }
+        return result;
+    }
 }

src/xparser.hpp

@@ -22,5 +22,11 @@ namespace xcpp
 
     XEUS_CPP_API std::vector<std::string>
     split_line(const std::string& input, const std::string& delims, std::size_t cursor_pos);
+
+    XEUS_CPP_API
+    std::vector<std::string> get_lines(const std::string& input);
+
+    XEUS_CPP_API
+    std::vector<std::string> split_from_includes(const std::string& input);
 }
 #endif