Use custom macro for tokens enum+names

2 files changed, 75 insertions, 81 deletions

diff --git a/cup/tokens.c b/cup/tokens.c
index 95a0700..e562e16 100644
--- a/cup/tokens.c
+++ b/cup/tokens.c
@@ -42,44 +42,29 @@ void Location_print(FILE *f, Location loc)
     fprintf(f, "%s:%d:%d", loc.filename, loc.line+1, loc.col+1);
 }
 
-void Token_print(FILE *f, Token *token)
+char *token_type_to_str(TokenType type)
 {
-    Location_print(f, token->loc);
-    fprintf(f, ": ");
-    switch (token->type)
+    // Otherwise, just print the token type
+    switch (type)
     {
-        case TOKEN_OPEN_PAREN: fprintf(f, "("); break;
-        case TOKEN_CLOSE_PAREN: fprintf(f, ")"); break;
-        case TOKEN_OPEN_BRACE: fprintf(f, "{"); break;
-        case TOKEN_CLOSE_BRACE: fprintf(f, "}"); break;
-
-        case TOKEN_LT: fprintf(f, "<"); break;
-        case TOKEN_GT: fprintf(f, ">"); break;
-        case TOKEN_EQ: fprintf(f, "=="); break;
-        case TOKEN_NEQ: fprintf(f, "!="); break;
-        case TOKEN_LEQ: fprintf(f, "<="); break;
-        case TOKEN_GEQ: fprintf(f, ">="); break;
-
-        case TOKEN_ASSIGN: fprintf(f, "="); break; // =
-        case TOKEN_AMPERSAND: fprintf(f, "&"); break;
+    #define ENUM_TOKEN(name, str) case name: return str;
+        ENUM_TOKENS(ENUM_TOKEN)
+    #undef ENUM_TOKEN
+    default: assert(false && "Unreachable");
+    }
+}
 
-        case TOKEN_PLUS: fprintf(f, "+"); break;
-        case TOKEN_MINUS: fprintf(f, "-"); break;
-        case TOKEN_STAR: fprintf(f, "*"); break;
-        case TOKEN_SLASH: fprintf(f, "/"); break;
-        case TOKEN_PERCENT: fprintf(f, "%%"); break;
-        case TOKEN_PLUSPLUS: fprintf(f, "++"); break;
-        case TOKEN_MINUSMINUS: fprintf(f, "--"); break;
 
-        case TOKEN_COLON: fprintf(f, ":"); break;
-        case TOKEN_SEMICOLON: fprintf(f, ";"); break;
-        case TOKEN_FN: fprintf(f, "<fn>"); break;
-        case TOKEN_RETURN: fprintf(f, "<return>"); break;
-        case TOKEN_INT: fprintf(f, "<int>"); break;
-        case TOKEN_EOF: fprintf(f, "<EOF>"); break;
-        case TOKEN_INTLIT: fprintf(f, "%lld", token->value.as_int); break;
-        case TOKEN_STRINGLIT: fprintf(f, "\"%s\"", token->value.as_string); break;
-        case TOKEN_IDENTIFIER: fprintf(f, "%s", token->value.as_string); break;
-        default: assert(false && "Unknown token type");
+void Token_print(FILE *f, Token *token)
+{
+    // Handle the different literals manually
+    switch (token->type)
+    {
+        case TOKEN_INTLIT:      fprintf(f, "%lld", token->value.as_int); return;
+        case TOKEN_STRINGLIT:   fprintf(f, "\"%s\"", token->value.as_string); return;
+        case TOKEN_IDENTIFIER:  fprintf(f, "%s", token->value.as_string); return;
+        default: break;
     }
+
+    fprintf(f, "%s", token_type_to_str(token->type));
 }
\ No newline at end of file
diff --git a/cup/tokens.h b/cup/tokens.h
index d087845..56ad40c 100644
--- a/cup/tokens.h
+++ b/cup/tokens.h
@@ -1,67 +1,76 @@
 #pragma once
 
-#include <stdint.h>
 #include <stdbool.h>
+#include <stdint.h>
 #include <stdio.h>
 
 typedef int64_t i64;
 
+#define ENUM_TOKENS(F)                                                         \
+  F(TOKEN_AMPERSAND, "&")                                                      \
+  F(TOKEN_AND, "&&")                                                           \
+  F(TOKEN_ASSIGN, "=")                                                         \
+  F(TOKEN_BAR, "|")                                                            \
+  F(TOKEN_CLOSE_BRACE, "}")                                                    \
+  F(TOKEN_CLOSE_PAREN, ")")                                                    \
+  F(TOKEN_COLON, ":")                                                          \
+  F(TOKEN_EOF, "EOF")                                                          \
+  F(TOKEN_EQ, "==")                                                            \
+  F(TOKEN_FN, "fn")                                                            \
+  F(TOKEN_GEQ, ">=")                                                           \
+  F(TOKEN_GT, ">")                                                             \
+  F(TOKEN_IDENTIFIER, "identifier")                                            \
+  F(TOKEN_INT, "int")                                                          \
+  F(TOKEN_INTLIT, "integer literal")                                           \
+  F(TOKEN_LEQ, "<=")                                                           \
+  F(TOKEN_LSHIFT, "<<")                                                        \
+  F(TOKEN_LT, "<")                                                             \
+  F(TOKEN_MINUS, "-")                                                          \
+  F(TOKEN_MINUSEQUALS, "-=")                                                   \
+  F(TOKEN_MINUSMINUS, "--")                                                    \
+  F(TOKEN_NEQ, "!=")                                                           \
+  F(TOKEN_OPEN_BRACE, "{")                                                     \
+  F(TOKEN_OPEN_PAREN, "(")                                                     \
+  F(TOKEN_OR, "||")                                                            \
+  F(TOKEN_PERCENT, "%")                                                        \
+  F(TOKEN_PLUS, "+")                                                           \
+  F(TOKEN_PLUSEQUALS, "+=")                                                    \
+  F(TOKEN_PLUSPLUS, "++")                                                      \
+  F(TOKEN_QUESTION, "?")                                                       \
+  F(TOKEN_RETURN, "return")                                                    \
+  F(TOKEN_RSHIFT, ">>")                                                        \
+  F(TOKEN_SEMICOLON, ";")                                                      \
+  F(TOKEN_SLASH, "/")                                                          \
+  F(TOKEN_STAR, "*")                                                           \
+  F(TOKEN_STRINGLIT, "string literal")                                         \
+  F(TOKEN_XOR, "^")
+
 typedef enum {
-    TOKEN_AMPERSAND,    // &
-    TOKEN_AND,          // &&
-    TOKEN_ASSIGN,       // =
-    TOKEN_BAR,          // |
-    TOKEN_CLOSE_BRACE,  // }
-    TOKEN_CLOSE_PAREN,  // )
-    TOKEN_COLON,        // :
-    TOKEN_EOF,          // EOF
-    TOKEN_EQ,           // ==
-    TOKEN_FN,           // fn
-    TOKEN_GEQ,          // >=
-    TOKEN_GT,           // >
-    TOKEN_IDENTIFIER,   // identifier
-    TOKEN_INT,          // int
-    TOKEN_INTLIT,       // integer literal
-    TOKEN_LEQ,          // <=
-    TOKEN_LSHIFT,       // <<
-    TOKEN_LT,           // <
-    TOKEN_MINUS,        // -
-    TOKEN_MINUSMINUS,   // --
-    TOKEN_NEQ,          // !=
-    TOKEN_OPEN_BRACE,   // {
-    TOKEN_OPEN_PAREN,   // (
-    TOKEN_OR,           // ||
-    TOKEN_PERCENT,      // %
-    TOKEN_PLUS,         // +
-    TOKEN_PLUSPLUS,     // ++
-    TOKEN_QUESTION,     // ?
-    TOKEN_RETURN,       // return
-    TOKEN_RSHIFT,       // >>
-    TOKEN_SEMICOLON,    // ;
-    TOKEN_SLASH,        // /
-    TOKEN_STAR,         // *
-    TOKEN_STRINGLIT,    // string literal
-    TOKEN_XOR,          // ^
+#define ENUM_TOKEN(name, str) name,
+  ENUM_TOKENS(ENUM_TOKEN)
+#undef ENUM_TOKEN
 } TokenType;
 
 typedef struct {
-    char *filename;
-    int line;
-    int col;
+  char *filename;
+  int line;
+  int col;
 } Location;
 
 void Location_print(FILE *f, Location loc);
 
 typedef struct {
-    TokenType type;
-    Location loc;
-    union tokens {
-        i64 as_int;
-        char *as_string;
-        char as_char;
-    } value;
+  TokenType type;
+  Location loc;
+  union tokens {
+    i64 as_int;
+    char *as_string;
+    char as_char;
+  } value;
 } Token;
 
+char *token_type_to_str(TokenType type);
+
 Token Token_from_type(TokenType type, Location loc);
 Token Token_from_int(i64 value, Location loc);
 Token Token_from_string(char *value, Location loc);