Symbols have a wrapper with positional data now.

It required some weird changes, I'm not sure I'm happy with them all
yet, but I"m getting closer. It parses all basics, now we need to build
an AST so it's actually useful :-P

1 files changed, 34 insertions, 22 deletions

diff --git a/src/parser.rs b/src/parser.rs
index 54b77ac..e5ea1f5 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -6,8 +6,7 @@ use std::fmt;
 
 #[derive(Debug)]
 struct ParseError {
-    line: u32,
-    row: u32,
+    position: Position,
     what: String,
 }
 
@@ -138,15 +137,15 @@ impl Parser {
     }
 
     fn lex_error(&self, error: &Symbol) -> Result<(),Box<dyn Error>> {
-        if let Symbol::Error{line,row,what} = error {
+        if let SymbolType::Error{what} = error.symbol() {
             Err(Box::new(ParseError {
-                line: *line,
-                row: *row,
+                position: error.start().clone(),
                 what: format!("What: {:?}", *what)
             }))
         } else {
             Err(Box::new(ParseError {
-                line: 0, row: 0, what: "Not an error?".to_string()
+                position: Position::new(0,0),
+                what: "Not an error?".to_string(),
             }))
         }
     }
@@ -166,12 +165,12 @@ impl Parser {
             if ctx.cur().is_none() {
                 break;
             }
-            match ctx.cur() {
-                Some(Symbol::Text(_)) => { /* Skip top level text */ }
-                Some(Symbol::StartFlat) => {
+            match ctx.cur().unwrap().symbol() {
+                SymbolType::Text(_) => { /* Skip top level text */ }
+                SymbolType::StartFlat => {
                     self.parse_tag( ctx );
                 }
-                Some(Symbol::Error{..}) => {
+                SymbolType::Error{..} => {
                     return self.lex_error( &ctx.cur().unwrap() );
                 }
                 _ => {
@@ -188,10 +187,14 @@ impl Parser {
 
         let start_sym = ctx.cur().unwrap();
 
-        if let Some(Symbol::Token(s)) = ctx.next() {
-            tb.set_name( s.to_string() );
+        if ctx.next().is_some() {
+            if let SymbolType::Token(s) = ctx.next().unwrap().symbol() {
+                tb.set_name( s.to_string() );
+            } else {
+                return Err(Box::new(ParseError{position: ctx.cur().unwrap().start().clone(), what: "Unexpecetd symbol".to_string()}));
+            }
         } else {
-            return Err(Box::new(ParseError{line: 0, row: 0, what: "Unexpecetd symbol".to_string()}));
+            return Err(Box::new(ParseError{position: Position::new(0,0), what: "Unexpecetd end of stream".to_string()}));
         }
 
         self.parse_tag_params( ctx, &mut tb )?;
@@ -202,10 +205,15 @@ impl Parser {
 
     fn parse_tag_params(&mut self, ctx: &mut Context, tb: &mut TagBuilder ) -> Result<(), Box<dyn Error>> {
         loop {
-            if let Some(Symbol::Token(s)) = ctx.cur() {
-                if matches!(ctx.peek(), Some(Symbol::Equals)) {
-                    // Done with parameters
-                    break;
+            if ctx.cur().is_none() {
+
+                return Err(Box::new(ParseError{position: Position::new(0,0), what: "Unexpecetd end of stream".to_string()}));
+            }
+            if let SymbolType::Token(s) = ctx.cur().unwrap().symbol() {
+                if let Some(p) = ctx.peek() {
+                    if p.check_type(|t| matches!(t, SymbolType::Equals)) {
+                        break;
+                    }
                 }
                 else {
                     tb.add_param( s.to_string() );
@@ -218,16 +226,20 @@ impl Parser {
     
     fn parse_tag_props(&mut self, ctx: &mut Context, tb: &mut TagBuilder ) -> Result<(), Box<dyn Error>> {
         loop {
-            if let Some(Symbol::Token(s)) = ctx.cur() {
-                if matches!(ctx.peek(), Some(Symbol::Equals)) {
+            if ctx.cur().is_none() {
+                return Err(Box::new(ParseError{position: Position::new(0,0), what: "Unexpecetd end of stream".to_string()}));
+            }
+            if let SymbolType::Token(s) = ctx.cur().unwrap().symbol() {
+                if ctx.peek().is_some_and(|s|s.check_type(|t| matches!(t,SymbolType::Equals))) {
                     ctx.next();
-                    if let Some(Symbol::Literal(lv)) = ctx.next() {
+                    if let Some(sym) = ctx.next() &&
+                        let SymbolType::Literal(lv) = sym.symbol() {
                         tb.add_prop( s.to_string(), lv.to_string() );
                     } else {
-                        return Err(Box::new(ParseError{line: 0, row: 0, what: "Expected quoted literal string".to_string()}));
+                        return Err(Box::new(ParseError{position: Position::new(0,0), what: "Expected quoted literal string".to_string()}));
                     }
                 } else {
-                    return Err(Box::new(ParseError{line: 0, row: 0, what: "Expected = ".to_string()}));
+                    return Err(Box::new(ParseError{position:Position::new(0,0), what: "Expected = ".to_string()}));
                 }
             } else {
                 break;