fix comments (?)

Author: YuzuTheNeko

README.md

@@ -129,4 +129,22 @@ Native data types do have native methods, for example int conversion:
 neko s = 1;
 log(s->to_string()) @ You won't notice any difference, but if you use typeof you'll see magic.
 ```
-Note that not all data types have methods yet, this can be found [here](https://github.com/Rubenennj/nekoscript/tree/dev/src/native/prototypes)
+Note that not all data types have methods yet, this can be found [here](https://github.com/Rubenennj/nekoscript/tree/dev/src/native/prototypes)
+
+# Loading other files
+A new method was added in 1.1.0, named `load_file`, this method loads code specified at path.
+Give next structure:
+index.neko
+```
+neko util = load_file("./util.neko");
+
+log(util->join("me", "this")); @ Outputs "me this"
+```
+
+util.neko
+```
+public->join = dyn (x, y) {
+    @ this will join x with y.
+    return x + " " + y 
+};
+```

src/core/interpreter.rs

@@ -26,11 +26,15 @@ pub struct Interpreter {
 pub type IReturn = Result<Rc<RefCell<DataTypes>>, ReturnTypes>;
 
 impl Interpreter {
-    pub fn run(&self) {
-        let scope = Scope::new();
+    pub fn run(&self, scope: Option<&Scope>) {
+        if !scope.is_some() {
+            return self.run(Some(&Scope::new()))
+        }
+
+        let scope = scope.unwrap();
 
         for node in self.nodes.iter() {
-            match self.execute(&scope, node) {
+            match self.execute(scope, node) {
                 Err(err) => match err {
                     ReturnTypes::RuntimeError(str) => {
                         println!("RuntimeError: {}\nFile: {}", str, self.path);

src/core/token_stream.rs

@@ -166,7 +166,7 @@ impl<'a> TokenStream<'a> {
 
         if is_comment(char) {
             self.skip_comment();
-            return self.read_next()
+            return parse_expression(self)
         } else if is_op(char) {
             return parse_op(self);
         } else if char.eq(&b'[') {

src/main.rs

@@ -46,5 +46,5 @@ fn main() {
 
     let itr = Interpreter::new(stream.nodes, path.to_str().unwrap().to_string());
 
-    itr.run();
+    itr.run(None);
 }

src/native/load_file.rs

@@ -0,0 +1,57 @@
+
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::fs::{canonicalize, File};
+use std::io::Read;
+use std::path::Path;
+use std::rc::Rc;
+use std::sync::RwLock;
+use crate::core::native_function::NativeFunction;
+use crate::core::return_types::ReturnTypes::RuntimeError;
+use crate::{Interpreter, TokenStream};
+use crate::core::data_types::DataTypes;
+use crate::core::scope::Scope;
+
+pub fn load_file() -> NativeFunction {
+    NativeFunction {
+        name: String::from("load_file"),
+        body: Box::new(| scope, args | {
+            let path: &Rc<RefCell<DataTypes>> = args.get(0).unwrap();
+            let path = path.borrow();
+            let path = path.to_string();
+
+            match canonicalize(&path) {
+                Ok(got) => {
+                    let path = got.to_str().unwrap();
+
+                    let mut s = String::new();
+
+                    File::open(&path).unwrap().read_to_string(&mut s);
+
+                    let mut stream = TokenStream::new(&s, path.to_owned());
+
+                    stream.start();
+
+                    let itr = Interpreter::new(stream.nodes, path.to_owned());
+
+                    let scope = Scope::new();
+
+                    {
+                        let mut writer = scope.variables.write().unwrap();
+                        writer.insert("public".to_owned(), Rc::new(RefCell::new(DataTypes::Object(Rc::new(RwLock::new(HashMap::new()))))));
+                    }
+
+                    {
+                        itr.run(Some(&scope));
+                    }
+
+                    let reader = scope.variables.read().unwrap();
+                    let reader = reader.get("public").unwrap();
+
+                    Ok(reader.clone())
+                },
+                Err(e) => Err(RuntimeError(e.to_string()))
+            }
+        })
+    }
+}

src/native/loader.rs

@@ -1,8 +1,9 @@
 use crate::core::native_function::NativeFunction;
 use crate::native::_typeof::_typeof;
+use crate::native::load_file::load_file;
 use crate::native::log::log;
 use crate::native::system_time::system_time;
 
 pub fn load_native_functions() -> Vec<NativeFunction> {
-    vec![log(), _typeof(), system_time()]
+    vec![log(), _typeof(), system_time(), load_file()]
 }

src/native/mod.rs

@@ -4,3 +4,4 @@ mod _typeof;
 pub mod loader;
 pub mod prototypes;
 mod system_time;
+mod load_file;

tests/example.neko

@@ -0,0 +1,3 @@
+neko util = load_file("./tests/util.neko");
+
+log(util->join("me", "this")); @ Outputs "me this"

tests/example.nksc

@@ -0,0 +1,4 @@
+public->join = dyn (x, y) {
+    @ tmr
+    return x + " " + y;
+};