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;