From 3dd9ca69340512e42867b43db689e494bada2000 Mon Sep 17 00:00:00 2001
From: Mike Buland <mike@xagasoft.com>
Date: Fri, 5 Jun 2026 14:46:35 -0700
Subject: 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
---
 src/parser.rs | 56 ++++++++++++++++++++++++++++++++++----------------------
 1 file changed, 34 insertions(+), 22 deletions(-)

(limited to 'src/parser.rs')

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;
-- 
cgit v1.2.3