1 files changed, 22 insertions, 24 deletions

diff --git a/src/parsers/syntactic.rs b/src/parsers/syntactic.rs
index 443e47e..c98a592 100644
--- a/src/parsers/syntactic.rs
+++ b/src/parsers/syntactic.rs
@@ -1,4 +1,5 @@
 use crate::*;
+use syntactic::*;
 
 
 pub struct SyntacticParser {
@@ -23,76 +24,73 @@ impl SyntacticParser {
 
 
 impl Iterator for SyntacticParser {
-    type Item = SyntacticToken;
+    type Item = Token;
 
     /// Sequentially parse tokens from the source code.
-    fn next(&mut self) -> Option<SyntacticToken> {
-        use SyntacticTokenVariant as SynVar;
-        use SyntacticParseError as SynErr;
+    fn next(&mut self) -> Option<Token> {
         let t = &mut self.tokeniser;
-
         t.drop_whitespace();
         t.mark_start_position();
 
         let variant = match t.eat_char()? {
             '@' => {
                 self.label_name = t.eat_token();
-                SynVar::LabelDefinition(self.label_name.clone())
+                TokenVariant::LabelDefinition(self.label_name.clone())
             }
             '&' => {
                 let token = t.eat_token();
-                SynVar::LabelDefinition(format!("{}/{token}", self.label_name))
+                TokenVariant::LabelDefinition(format!("{}/{token}", self.label_name))
             }
             '%' => {
                 let macro_name = t.eat_token();
                 self.macro_name = Some(macro_name.clone());
-                SynVar::MacroDefinition(macro_name)
+                TokenVariant::MacroDefinition(macro_name)
             }
             ';' => {
                 self.macro_name = None;
-                SynVar::MacroDefinitionTerminator
+                TokenVariant::MacroDefinitionTerminator
             }
             '[' => match t.eat_to_delimiter(']') {
                 Some(string) => {
                     let constant = ConstantExpression::from_str(&string, t);
-                    SynVar::ConstantExpression(constant)
+                    TokenVariant::ConstantExpression(constant)
                 }
-                None => SynVar::Error(SynErr::UnterminatedConstantExpression),
+                None => TokenVariant::Error(ParseError::UnterminatedConstantExpression),
             }
-            '{' => SynVar::BlockOpen,
-            '}' => SynVar::BlockClose,
+            '{' => TokenVariant::BlockOpen,
+            '}' => TokenVariant::BlockClose,
             '(' => match t.eat_to_delimiter(')') {
-                Some(string) => SynVar::Comment(string),
-                None => SynVar::Error(SynErr::UnterminatedComment),
+                Some(string) => TokenVariant::Comment(string),
+                None => TokenVariant::Error(ParseError::UnterminatedComment),
             }
             '#' => {
                 let token = t.eat_token();
                 let pbl = PackedBinaryLiteral::from_str(&token, t);
-                SynVar::PackedBinaryLiteral(pbl)
+                TokenVariant::PackedBinaryLiteral(pbl)
             },
             '~' => {
                 let token = t.eat_token();
-                SynVar::Symbol(format!("{}/{token}", self.label_name))
+                TokenVariant::Symbol(format!("{}/{token}", self.label_name))
             }
-            ':' => SynVar::Separator,
+            ':' => TokenVariant::Separator,
             c => {
                 let token = format!("{c}{}", t.eat_token());
                 if let Some(hex_string) = token.strip_prefix("0x") {
                     match usize::from_str_radix(hex_string, 16) {
-                        Ok(hex) => SynVar::HexadecimalLiteral(hex),
-                        Err(_) => SynVar::Error(SynErr::InvalidHexadecimalLiteral(token)),
+                        Ok(hex) => TokenVariant::HexadecimalLiteral(hex),
+                        Err(_) => TokenVariant::Error(ParseError::InvalidHexadecimalLiteral(token)),
                     }
                 } else {
                     match usize::from_str_radix(&token, 10) {
-                        Ok(value) => SynVar::DecimalLiteral(value),
-                        Err(_) => SynVar::Symbol(token),
+                        Ok(value) => TokenVariant::DecimalLiteral(value),
+                        Err(_) => TokenVariant::Symbol(token),
                     }
                 }
             }
         };
 
         // Parse source path comments.
-        if let SynVar::Comment(comment) = &variant {
+        if let TokenVariant::Comment(comment) = &variant {
             // Check if the comment fills the entire line.
             if t.start_position.column == 0 && t.end_of_line() {
                 if let Some(path) = comment.strip_prefix(": ") {
@@ -103,6 +101,6 @@ impl Iterator for SyntacticParser {
         }
 
         let source = t.mark_end_position();
-        Some( SyntacticToken { source, variant } )
+        Some( Token { source, variant } )
     }
 }