asm: Rename LiteralNumber to Pound

It was a bit confusing before since this token doesn't have any attached number to it like the hex and binary tokens do.
Granddave · Jul 13, 2024 · bc50a78 · bc50a78
1 parent c090e4c
commit bc50a78
Show file tree

Hide file tree

Showing 3 changed files with 35 additions and 32 deletions.
diff --git a/src/assembler/lexer.rs b/src/assembler/lexer.rs
@@ -136,10 +136,32 @@ impl<'a> Lexer<'a> {
                     self.skip_comment();
                     self.next_token()?
                 }
+                // Single character tokens
                 '.' => {
                     let (text, span) = self.read_one_char();
                     Some(Token::new(TokenType::Dot, text, span))
                 }
+                ':' => {
+                    let (text, span) = self.read_one_char();
+                    Some(Token::new(TokenType::Colon, text, span))
+                }
+                ',' => {
+                    let (text, span) = self.read_one_char();
+                    Some(Token::new(TokenType::Comma, text, span))
+                }
+                '(' => {
+                    let (text, span) = self.read_one_char();
+                    Some(Token::new(TokenType::ParenLeft, text, span))
+                }
+                ')' => {
+                    let (text, span) = self.read_one_char();
+                    Some(Token::new(TokenType::ParenRight, text, span))
+                }
+                '#' => {
+                    let (text, span) = self.read_one_char();
+                    Some(Token::new(TokenType::Pound, text, span))
+                }
+                // Number literals
                 '$' => {
                     let (_, span_1) = self.read_one_char();
                     let (text, span_2) = self.read_hex();
@@ -162,26 +184,7 @@ impl<'a> Lexer<'a> {
                     let (text, span) = self.read_decimal();
                     Some(Token::new(TokenType::DecimalNumber, text, span))
                 }
-                '#' => {
-                    let (text, span) = self.read_one_char();
-                    Some(Token::new(TokenType::LiteralNumber, text, span))
-                }
-                ':' => {
-                    let (text, span) = self.read_one_char();
-                    Some(Token::new(TokenType::Colon, text, span))
-                }
-                ',' => {
-                    let (text, span) = self.read_one_char();
-                    Some(Token::new(TokenType::Comma, text, span))
-                }
-                '(' => {
-                    let (text, span) = self.read_one_char();
-                    Some(Token::new(TokenType::ParenLeft, text, span))
-                }
-                ')' => {
-                    let (text, span) = self.read_one_char();
-                    Some(Token::new(TokenType::ParenRight, text, span))
-                }
+                // Identifiers and keywords
                 'A'..='Z' | 'a'..='z' | '_' => {
                     let (text, span) = self.read_string();
                     if text == "define" {
@@ -299,7 +302,7 @@ mod tests {
                         ),
                     },
                     Token {
-                        token: TokenType::LiteralNumber,
+                        token: TokenType::Pound,
                         lexeme: "#".to_string(),
                         span: SourcePositionSpan::new(
                             SourcePosition::new(1, 5),
@@ -336,7 +339,7 @@ mod tests {
                         ),
                     },
                     Token {
-                        token: TokenType::LiteralNumber,
+                        token: TokenType::Pound,
                         lexeme: "#".to_string(),
                         span: SourcePositionSpan::new(
                             SourcePosition::new(1, 5),
@@ -373,7 +376,7 @@ mod tests {
                         ),
                     },
                     Token {
-                        token: TokenType::LiteralNumber,
+                        token: TokenType::Pound,
                         lexeme: "#".to_string(),
                         span: SourcePositionSpan::new(
                             SourcePosition::new(1, 5),
@@ -512,7 +515,7 @@ LDA #$00 ; Another one
                 span: SourcePositionSpan::new(SourcePosition::new(2, 1), SourcePosition::new(2, 4)),
             },
             Token {
-                token: TokenType::LiteralNumber,
+                token: TokenType::Pound,
                 lexeme: "#".to_string(),
                 span: SourcePositionSpan::new(SourcePosition::new(2, 5), SourcePosition::new(2, 6)),
             },

diff --git a/src/assembler/lexer/token.rs b/src/assembler/lexer/token.rs
@@ -14,15 +14,15 @@ pub enum TokenType {
     ParenLeft,
     /// `)`
     ParenRight,
+    /// `#` Literal number prefix character
+    Pound,
 
     // --- Literals ---
-    /// `#` Literal number prefix character
-    LiteralNumber,
     /// `$` Hex prefix including hex number
     HexNumber,
     /// `%` Binary prefix including binary number
     BinaryNumber,
-    /// Decimal number
+    /// Decimal number (no prefix)
     DecimalNumber,
     /// Instruction mnemonic, label or constant definition.
     ///
@@ -75,7 +75,7 @@ impl Token {
             TokenType::Comma => ",".to_owned(),
             TokenType::ParenLeft => "(".to_owned(),
             TokenType::ParenRight => ")".to_owned(),
-            TokenType::LiteralNumber => self.lexeme.to_owned(),
+            TokenType::Pound => "#".to_owned(),
             TokenType::HexNumber => "$".to_string() + &self.lexeme,
             TokenType::BinaryNumber => "%".to_string() + &self.lexeme,
             TokenType::DecimalNumber => self.lexeme.to_owned(),

diff --git a/src/assembler/parser.rs b/src/assembler/parser.rs
@@ -515,7 +515,7 @@ impl<'a> Parser<'a> {
         self.next_token()?;
 
         match self.current_token.token {
-            TokenType::LiteralNumber => self.parse_literal_number(),
+            TokenType::Pound => self.parse_literal_number(),
             TokenType::HexNumber => self.parse_hex_operand(mnemonic),
             TokenType::BinaryNumber => self.parse_binary_operand(mnemonic),
             TokenType::DecimalNumber => self.parse_decimal_operand(mnemonic),
@@ -673,13 +673,13 @@ mod tests {
 
         // Check that current token and lookahead tokens are loaded correctly
         assert_eq!(parser.current_token.token, TokenType::Identifier);
-        assert_eq!(parser.peek_token(0).token, TokenType::LiteralNumber);
-        assert!(parser.peek_token_is(0, TokenType::LiteralNumber));
+        assert_eq!(parser.peek_token(0).token, TokenType::Pound);
+        assert!(parser.peek_token_is(0, TokenType::Pound));
         assert_eq!(parser.peek_token(1).token, TokenType::HexNumber);
         assert!(parser.peek_token_is(1, TokenType::HexNumber));
 
         parser.next_token()?; // Consume the LDA token
-        assert_eq!(parser.current_token.token, TokenType::LiteralNumber);
+        assert_eq!(parser.current_token.token, TokenType::Pound);
         assert_eq!(parser.peek_token(0).token, TokenType::HexNumber);
         assert_eq!(parser.peek_token(1).token, TokenType::Identifier);