captures in gmi parsing

.gitattributes

@@ -0,0 +1,8 @@
+# Check out all text files in UNIX format, with LF as end of line
+# Don't change this file. If you have any ideas about it, please
+# submit a separate issue about it and we'll discuss.
+
+* text=auto eol=lf
+*.java ident
+*.xml ident
+*.png binary

Cargo.toml

@@ -11,6 +11,7 @@ keywords = ["eolang", "compiler", "oop"]
 categories = ["command-line-utilities"]
 
 [dependencies]
+anyhow = "1.0.60"
 regex = "1.5.4"
 rstest = "0.12.0"
 lazy_static = "1.4.0"

eo-tests/org/eolang/reo/fibonacci.eo

@@ -35,3 +35,4 @@
           x.minus 1
         f
           x.minus 2
+

src/data.rs

@@ -27,26 +27,31 @@ impl Data {
         Self::from_bytes(Vec::new())
     }
 
-    // From INT.
+    /// From BYTES.
     pub fn from_bytes(bytes: Vec<u8>) -> Self {
         Data { bytes }
     }
 
-    // From INT.
+    /// From INT.
     pub fn from_int(d: u64) -> Self {
         Self::from_bytes(d.to_be_bytes().to_vec())
     }
 
-    // From FLOAT.
+    /// From FLOAT.
     pub fn from_float(d: f64) -> Self  {
         Self::from_bytes(d.to_be_bytes().to_vec())
     }
 
-    // From STRING.
+    /// From STRING.
     pub fn from_string(d: String) -> Self {
         Self::from_bytes(d.as_bytes().to_vec())
     }
 
+    /// It's empty and no data?
+    pub fn is_empty(&self) -> bool {
+        self.bytes.len() == 0
+    }
+
     pub fn as_int(&self) -> u64 {
         let a : &[u8; 8] = &self.bytes.clone().try_into().unwrap();
         u64::from_be_bytes(*a)
@@ -61,6 +66,11 @@ impl Data {
         String::from_utf8(self.bytes.clone()).unwrap()
     }
 
+    pub fn as_hex(&self) -> String {
+        // TODO this is wrong
+        String::from_utf8(self.bytes.clone()).unwrap()
+    }
+
 }
 
 #[test]

src/gmi.rs

@@ -19,97 +19,126 @@
 // SOFTWARE.
 
 use crate::universe::Universe;
-use std::{fs, io};
+use std::fs;
+use std::collections::HashMap;
+use anyhow::{anyhow, Context, Result};
 use std::str::FromStr;
 use lazy_static::lazy_static;
 use regex::Regex;
 use crate::data::Data;
 
-// Collection of GMIs, which can be deployed to a `Universe`.
+/// Collection of GMIs, which can be deployed to a `Universe`.
 pub struct Gmi {
+    vars: HashMap<String, u32>,
     text: String,
 }
 
 impl Gmi {
-    // Read them from a file.
-    pub fn from_file(file: &str) -> io::Result<Gmi> {
+    /// Read them from a file.
+    pub fn from_file(file: &str) -> Result<Gmi> {
         return Gmi::from_string(fs::read_to_string(file)?);
     }
 
-    // Read them from a string.
-    pub fn from_string(text: String) -> io::Result<Gmi> {
+    /// Read them from a string.
+    pub fn from_string(text: String) -> Result<Gmi> {
         return Ok(
             Gmi {
-                text
+                text,
+                vars: HashMap::new()
             }
         );
     }
 
-    pub fn deploy_to(&self, uni: &mut Universe) {
+    pub fn deploy_to(&mut self, uni: &mut Universe) -> Result<()> {
         lazy_static! {
             static ref RE: Regex = Regex::new(
                 "^([A-Z]+)\\((?:(?: *, *)?\"([^\"]+)\")*\\);.*$"
             ).unwrap();
         }
-        self.text.split("\n").for_each(|t| {
-            if let Some(cap) = RE.captures(t) {
-                println!("cmd: {} {}", &cap[1], &cap[2]);
-                match &cap[1] {
-                    "ADD" => {
-                        let v = Self::parse(&cap[2]);
-                        uni.add(v);
-                    },
-                    "BIND" => {
-                        let e = Self::parse(&cap[2]);
-                        let v1 = Self::parse(&cap[3]);
-                        let v2 = Self::parse(&cap[4]);
-                        let a = &cap[5];
-                        uni.bind(e, v1, v2, a);
-                    },
-                    "REF" => {
-                        let e1 = Self::parse(&cap[2]);
-                        let v1 = Self::parse(&cap[3]);
-                        let l = &cap[4];
-                        let a = &cap[5];
-                        uni.reff(e1, v1, l, a);
-                    },
-                    "COPY" => {
-                        let e1 = Self::parse(&cap[2]);
-                        let v3 = Self::parse(&cap[3]);
-                        let e2 = Self::parse(&cap[4]);
-                        uni.copy(e1, v3, e2);
-                    },
-                    "DATA" => {
-                        let v = Self::parse(&cap[2]);
-                        let d : &str = &cap[3];
-                        let bytes : Vec<u8> = (0..d.len())
-                            .step_by(2)
-                            .map(|i| u8::from_str_radix(&d[i..i + 2], 16).unwrap())
-                            .collect();
-                        uni.data(v, Data::from_bytes(bytes));
-                    },
-                    _ => {
-                        panic!("Unknown GMI: {}", &cap[1])
-                    }
-                };
-            } else {
-                panic!("Can't parse GMI line: \"{}\"", t);
+        let txt = &self.text.clone();
+        for (pos, t) in txt.split("\n").enumerate() {
+            self.deploy_one(t, uni).context(
+                format!("Failure at the line no.{}: \"{}\"", pos, t)
+            )?;
+        }
+        Ok(())
+    }
+
+    fn deploy_one(&mut self, line: &str, uni: &mut Universe) -> Result<()> {
+        lazy_static! {
+            static ref LINE: Regex = Regex::new(
+                "^([A-Z]+)\\(((?:(?: *, *)?\"(?:[^\"]+)\")*\\)); *(?:#.*)$"
+            ).unwrap();
+            static ref ARGS: Regex = Regex::new(
+                "(?: *, *)?\"([^\"]+)\""
+            ).unwrap();
+            static ref LOC: Regex = Regex::new(
+                "(^|\\.)\\$"
+            ).unwrap();
+        }
+        let cap = LINE.captures(line).context(format!("Can't parse \"{}\"", line))?;
+        let args : Vec<&str> = ARGS.captures_iter(&cap[2])
+            .map(|c| c.get(1).unwrap().as_str())
+            .collect();
+        match &cap[1] {
+            "ADD" => {
+                let v = self.parse(&args[0], uni)?;
+                uni.add(v);
+            },
+            "BIND" => {
+                let e = self.parse(&args[0], uni)?;
+                let v1 = self.parse(&args[1], uni)?;
+                let v2 = self.parse(&args[2], uni)?;
+                let a = &args[3];
+                uni.bind(e, v1, v2, a);
+            },
+            "REF" => {
+                let e1 = self.parse(&args[0], uni)?;
+                let v1 = self.parse(&args[1], uni)?;
+                let k = LOC.replace_all(&args[2], "$1");
+                println!("k: {}", &k);
+                let a = &args[3];
+                uni.reff(e1, v1, &k, a);
+            },
+            "COPY" => {
+                let e1 = self.parse(&args[0], uni)?;
+                let v3 = self.parse(&args[1], uni)?;
+                let e2 = self.parse(&args[2], uni)?;
+                uni.copy(e1, v3, e2);
+            },
+            "DATA" => {
+                let v = self.parse(&args[0], uni)?;
+                let d : &str = &args[1];
+                let bytes : Vec<u8> = (0..d.len())
+                    .step_by(2)
+                    .map(|i| u8::from_str_radix(&d[i..i + 2], 16).unwrap())
+                    .collect();
+                uni.data(v, Data::from_bytes(bytes));
+            },
+            _cmd => {
+                return Err(anyhow!("Unknown GMI: {}", _cmd))
             }
-        });
+        }
+        Ok(())
     }
 
-    // Parses `v2` or `e5` into 2 and 5.
-    fn parse(s: &str) -> u32{
+    /// Parses `v2` or `e5` into 2 and 5.
+    fn parse(&mut self, s: &str, uni: &mut Universe) -> Result<u32> {
         let tail = &s[1..];
-        u32::from_str(tail).unwrap()
+        if &s[0..1] == "$" {
+            Ok(*self.vars.entry(tail.to_string()).or_insert(uni.next_id()))
+        } else {
+            Ok(u32::from_str(tail).context(format!("Parsing of \"{}\" failed", s))?)
+        }
     }
 }
 
 #[test]
-fn deploys_fibonacci() {
+fn deploys_fibonacci() -> Result<()> {
     let uni : &mut Universe = &mut Universe::empty();
-    Gmi::from_file("target/eo/gmi/org/eolang/reo/fibonacci.gmi")
-        .unwrap()
-        .deploy_to(uni);
+    uni.add(0);
+    Gmi::from_file("target/eo/gmi/org/eolang/reo/fibonacci.gmi")?
+        .deploy_to(uni)?;
     assert_eq!(8, uni.dataize(0, "fibonacci.f").unwrap().as_int());
+    Ok(())
 }