add server and client value passing

client.gpsl

@@ -0,0 +1,4 @@
+fn main() {
+    send("test");
+    println(receive());
+}

server.gpsl

@@ -0,0 +1,3 @@
+fn main() {
+    send(receive());
+}

src/gpsl/external_function.rs

@@ -2,7 +2,7 @@ use serde::Deserializer;
 
 use crate::gpsl::{permission::Permission, variable::Variable};
 use std::{
-    io::Read,
+    io::{BufRead, BufReader, Read, Write},
     net::TcpStream,
     sync::{Arc, Mutex},
 };
@@ -71,6 +71,7 @@ pub const STD_FUNC: fn(
             }
         }
         "receive" => {
+            println!("Waiting for client...");
             let mut buffer = String::default();
             let data = data.unwrap();
             let mut stream = data.stream.lock().unwrap();
@@ -79,12 +80,31 @@ pub const STD_FUNC: fn(
                 Some(stream) => stream,
                 None => panic!("Cannot access to tcp stream"),
             };
-            stream.read_to_string(&mut buffer).unwrap();
+            let mut reader = BufReader::new(stream);
+            reader.read_line(&mut buffer).unwrap();
             ExternalFuncReturn {
                 status: ExternalFuncStatus::SUCCESS,
                 value: Some(serde_json::from_str(&buffer).unwrap()),
             }
         }
+        "send" => {
+            let data = data.unwrap();
+            let mut stream = data.stream.lock().unwrap();
+
+            let stream = match &mut *stream {
+                Some(stream) => stream,
+                None => panic!("Cannot access to tcp stream"),
+            };
+
+            let value = serde_json::to_string(&args[0]).unwrap();
+
+            stream.write_fmt(format_args!("{}\n", value)).unwrap();
+
+            ExternalFuncReturn {
+                status: ExternalFuncStatus::SUCCESS,
+                value: None,
+            }
+        }
         _ => ExternalFuncReturn {
             status: ExternalFuncStatus::NOTFOUND,
             value: None,

src/main.rs

@@ -56,6 +56,9 @@ struct Args {
 
     #[clap(short, long, value_parser)]
     file: String,
+
+    #[clap(short, long, value_parser)]
+    ip: Option<String>,
 }
 
 fn listen_tcp_server(port: u16) -> TcpStream {
@@ -63,7 +66,6 @@ fn listen_tcp_server(port: u16) -> TcpStream {
     for stream in listener.incoming() {
         match stream {
             Ok(stream) => {
-                println!("New connection: {}", stream.peer_addr().unwrap());
                 return stream;
             }
             Err(e) => {
@@ -76,34 +78,31 @@ fn listen_tcp_server(port: u16) -> TcpStream {
 
 fn main() {
     let args = Args::parse();
-    let s = serde_json::to_string(&Variable::Number { value: 0 });
-    println!("{}", s.unwrap());
 
-    match &*args.mode {
+    let mut source = Source::new(fs::read_to_string(&(args.file)).expect("Cannot read file."));
-        "gpsl" => {
-            let mut source =
-                Source::new(fs::read_to_string(&(args.file)).expect("Cannot read file."));
 
-            let mut tokenizer = Tokenizer::new();
+    let mut tokenizer = Tokenizer::new();
-            tokenizer.tokenize(&mut source).unwrap();
+    tokenizer.tokenize(&mut source).unwrap();
 
-            let mut parser = gpsl::parser::Parser {
+    let mut parser = gpsl::parser::Parser {
-                tokenizer,
+        tokenizer,
-                local_vars: HashMap::new(),
+        local_vars: HashMap::new(),
-            };
+    };
 
-            let stream = listen_tcp_server(8080);
+    let stream = match &*args.mode {
-            let mut gpsl = GPSL::new(
+        "server" => listen_tcp_server(8080),
-                source,
+        "client" => TcpStream::connect(args.ip.unwrap()).unwrap(),
-                Some(parser.functions().unwrap()),
+        _ => panic!("Cannot start tcp stream."),
-                Arc::new(Mutex::new(Some(stream))),
+    };
-                vec![STD_FUNC],
+
-            );
+    let mut gpsl = GPSL::new(
-            let res = gpsl.run("main".to_string(), vec![]);
+        source,
-            if let Err(err) = res {
+        Some(parser.functions().unwrap()),
-                println!("Error: {:?}", err);
+        Arc::new(Mutex::new(Some(stream))),
-            }
+        vec![STD_FUNC],
-        }
+    );
-        _ => {}
+    let res = gpsl.run("main".to_string(), vec![]);
+    if let Err(err) = res {
+        println!("Error: {:?}", err);
     }
 }

test.gpsl

@@ -1,3 +1,8 @@
 fn main() #server {
     println(receive());
+    let str: String;
+    str = "hello from server.";
+    send(str);
+
+    send(receive());
 }