From d1e78b4a3454984db74ebf2a302a64b985ce6de4 Mon Sep 17 00:00:00 2001
From: Mike Buland <mike@xagasoft.com>
Date: Wed, 19 Aug 2026 13:05:01 -0700
Subject: Rearranged and renamed some bits.

---
 deepcrow/src/lexer.rs | 48 ++++++++++++++++++++++++------------------------
 1 file changed, 24 insertions(+), 24 deletions(-)

(limited to 'deepcrow/src/lexer.rs')

diff --git a/deepcrow/src/lexer.rs b/deepcrow/src/lexer.rs
index d4d39e9..2528cb6 100644
--- a/deepcrow/src/lexer.rs
+++ b/deepcrow/src/lexer.rs
@@ -11,7 +11,7 @@ pub enum ErrorType {
 }
 
 #[derive(Debug,Copy,Clone,PartialEq,Eq)]
-pub enum SymbolType<'a> {
+pub enum TokenType<'a> {
     StartFlat,
     StartPoint,
     EndFlat,
@@ -28,7 +28,7 @@ pub enum SymbolType<'a> {
     Sharp,
     Equals,
     Period,
-    Token(&'a str),
+    Identifier(&'a str),
     Literal(&'a str),
     Text(&'a str),
     Error{ what: ErrorType },
@@ -36,7 +36,7 @@ pub enum SymbolType<'a> {
 
 #[derive(Copy,Clone)]
 pub struct Symbol<'a> {
-    symbol: SymbolType<'a>,
+    symbol: TokenType<'a>,
     start: Position,
     end: Position,
 }
@@ -48,17 +48,17 @@ impl<'a> fmt::Debug for Symbol<'a> {
 }
 
 impl<'a> Symbol<'a> {
-    pub fn new( symbol: SymbolType<'a>, start: Position, end: Position ) -> Self {
+    pub fn new( symbol: TokenType<'a>, start: Position, end: Position ) -> Self {
         Self {
             symbol, start, end,
         }
     }
 
-    pub fn check_type<T: Fn( &SymbolType ) -> bool>(&self, f: T ) -> bool {
+    pub fn check_type<T: Fn( &TokenType ) -> bool>(&self, f: T ) -> bool {
         f( &self.symbol )
     }
 
-    pub fn symbol(&self) -> &SymbolType<'a> {
+    pub fn symbol(&self) -> &TokenType<'a> {
         &self.symbol
     }
 
@@ -171,7 +171,7 @@ impl<'a> Lexer<'a> {
     }
 
     fn error( &self, what: ErrorType ) -> Option<Symbol<'a>> {
-        Some(Symbol::new( SymbolType::Error {
+        Some(Symbol::new( TokenType::Error {
             what: what
         }, self.pos, self.pos ))
     }
@@ -217,7 +217,7 @@ impl<'a> Lexer<'a> {
         if start == end {
             None
         } else {
-            Some(Symbol::new( SymbolType::Text(s), start_pos, end_pos ))
+            Some(Symbol::new( TokenType::Text(s), start_pos, end_pos ))
         }
     }
 
@@ -229,15 +229,15 @@ impl<'a> Lexer<'a> {
             }
             Some('#') => {
                 self.next();
-                return Some(Symbol::new(SymbolType::Sharp, self.pos, self.pos));
+                return Some(Symbol::new(TokenType::Sharp, self.pos, self.pos));
             }
             Some('=') => {
                 self.next();
-                return Some(Symbol::new(SymbolType::Equals, self.pos, self.pos));
+                return Some(Symbol::new(TokenType::Equals, self.pos, self.pos));
             }
             Some('.') => {
                 self.next();
-                return Some(Symbol::new(SymbolType::Period, self.pos, self.pos));
+                return Some(Symbol::new(TokenType::Period, self.pos, self.pos));
             }
             _ => {}
         }
@@ -254,14 +254,14 @@ impl<'a> Lexer<'a> {
             None
         } else {
             Some(Symbol::new( match s {
-                "view" => SymbolType::View,
-                "show" => SymbolType::Show,
-                "output" => SymbolType::Output,
-                "loop" => SymbolType::Loop,
-                "if" => SymbolType::If,
-                "elif" => SymbolType::ElIf,
-                "else" => SymbolType::Else,
-                _ => SymbolType::Token(s)
+                "view" => TokenType::View,
+                "show" => TokenType::Show,
+                "output" => TokenType::Output,
+                "loop" => TokenType::Loop,
+                "if" => TokenType::If,
+                "elif" => TokenType::ElIf,
+                "else" => TokenType::Else,
+                _ => TokenType::Identifier(s)
             }, start_pos, end_pos ))
         }
     }
@@ -277,7 +277,7 @@ impl<'a> Lexer<'a> {
         let end_pos = self.pos.clone();
         self.next();
         let s = &self.data[start..end];
-        Some(Symbol::new(SymbolType::Literal(s), start_pos, end_pos ))
+        Some(Symbol::new(TokenType::Literal(s), start_pos, end_pos ))
     }
 
     fn is_start_tag(&mut self) -> bool {
@@ -298,7 +298,7 @@ impl<'a> Lexer<'a> {
                     let end_pos = self.pos.clone();
                     self.next();
                     self.mode = Mode::InTag;
-                    Some(Symbol::new( SymbolType::StartFlat, start_pos, end_pos ) )
+                    Some(Symbol::new( TokenType::StartFlat, start_pos, end_pos ) )
                 } else {
                     None
                 }
@@ -309,7 +309,7 @@ impl<'a> Lexer<'a> {
                     let end_pos = self.pos.clone();
                     self.next();
                     self.mode = Mode::InTag;
-                    Some(Symbol::new(SymbolType::StartPoint, start_pos, end_pos ) )
+                    Some(Symbol::new(TokenType::StartPoint, start_pos, end_pos ) )
                 } else {
                     None
                 }
@@ -339,14 +339,14 @@ impl<'a> Lexer<'a> {
                     let end_pos = self.pos.clone();
                     self.next();
                     self.mode = Mode::Text;
-                    Some(Symbol::new( SymbolType::EndFlat, start_pos, end_pos))
+                    Some(Symbol::new( TokenType::EndFlat, start_pos, end_pos))
                 }
                 Some('>') => {
                     self.next();
                     let end_pos = self.pos.clone();
                     self.next();
                     self.mode = Mode::Text;
-                    Some(Symbol::new( SymbolType::EndPoint, start_pos, end_pos))
+                    Some(Symbol::new( TokenType::EndPoint, start_pos, end_pos))
                 }
                 _ => {
                     None
-- 
cgit v1.2.3