Namespace the lexer module

Future proofing any name collisions.

src/lexer.hpp

@@ -18,87 +18,90 @@
 #include <tuple>
 #include <vector>
 
-struct Token
+namespace Lexer
 {
-  enum class Type
+  struct Token
   {
-    PP_CONST,     // %const(<symbol>)...
+    enum class Type
-    PP_USE,       // %use <string>
+    {
-    PP_END,       // %end
+      PP_CONST,     // %const(<symbol>)...
-    PP_REFERENCE, // $<symbol>
+      PP_USE,       // %use <string>
-    GLOBAL,
+      PP_END,       // %end
-    STAR,
+      PP_REFERENCE, // $<symbol>
-    LITERAL_NUMBER,
+      GLOBAL,
-    LITERAL_CHAR,
+      STAR,
-    LITERAL_STRING,
+      LITERAL_NUMBER,
-    NOOP,
+      LITERAL_CHAR,
-    HALT,
+      LITERAL_STRING,
-    PUSH,
+      NOOP,
-    POP,
+      HALT,
-    PUSH_REG,
+      PUSH,
-    MOV,
+      POP,
-    DUP,
+      PUSH_REG,
-    MALLOC,
+      MOV,
-    MALLOC_STACK,
+      DUP,
-    MSET,
+      MALLOC,
-    MSET_STACK,
+      MALLOC_STACK,
-    MGET,
+      MSET,
-    MGET_STACK,
+      MSET_STACK,
-    MDELETE,
+      MGET,
-    MSIZE,
+      MGET_STACK,
-    NOT,
+      MDELETE,
-    OR,
+      MSIZE,
-    AND,
+      NOT,
-    XOR,
+      OR,
-    EQ,
+      AND,
-    LT,
+      XOR,
-    LTE,
+      EQ,
-    GT,
+      LT,
-    GTE,
+      LTE,
-    PLUS,
+      GT,
-    SUB,
+      GTE,
-    MULT,
+      PLUS,
-    PRINT,
+      SUB,
-    JUMP_ABS,
+      MULT,
-    JUMP_STACK,
+      PRINT,
-    JUMP_IF,
+      JUMP_ABS,
-    CALL,
+      JUMP_STACK,
-    CALL_STACK,
+      JUMP_IF,
-    RET,
+      CALL,
-    SYMBOL,
+      CALL_STACK,
-  } type;
+      RET,
-  size_t column, line;
+      SYMBOL,
-  std::string content;
+    } type;
+    size_t column, line;
+    std::string content;
 
-  Token();
+    Token();
-  Token(Token::Type, std::string, size_t col = 0, size_t line = 0);
+    Token(Token::Type, std::string, size_t col = 0, size_t line = 0);
-};
+  };
 
-const char *token_type_as_cstr(Token::Type type);
+  const char *token_type_as_cstr(Token::Type type);
 
-std::ostream &operator<<(std::ostream &, Token &);
+  std::ostream &operator<<(std::ostream &, Token &);
 
-enum class lerr_type_t
+  enum class lerr_type_t
-{
+  {
-  OK = 0,
+    OK = 0,
-  INVALID_CHAR_LITERAL,
+    INVALID_CHAR_LITERAL,
-  INVALID_CHAR_LITERAL_ESCAPE_SEQUENCE,
+    INVALID_CHAR_LITERAL_ESCAPE_SEQUENCE,
-  INVALID_STRING_LITERAL,
+    INVALID_STRING_LITERAL,
-  INVALID_NUMBER_LITERAL,
+    INVALID_NUMBER_LITERAL,
-  INVALID_PREPROCESSOR_DIRECTIVE,
+    INVALID_PREPROCESSOR_DIRECTIVE,
-  UNKNOWN_LEXEME,
+    UNKNOWN_LEXEME,
-};
+  };
 
-struct lerr_t
+  struct lerr_t
-{
+  {
-  size_t col, line;
+    size_t col, line;
-  lerr_type_t type;
+    lerr_type_t type;
 
-  lerr_t(lerr_type_t type = lerr_type_t::OK, size_t col = 0, size_t line = 0);
+    lerr_t(lerr_type_t type = lerr_type_t::OK, size_t col = 0, size_t line = 0);
-};
+  };
 
-std::ostream &operator<<(std::ostream &, lerr_t &);
+  std::ostream &operator<<(std::ostream &, lerr_t &);
 
-lerr_t tokenise_buffer(std::string_view, std::vector<Token *> &);
+  lerr_t tokenise_buffer(std::string_view, std::vector<Token *> &);
+} // namespace Lexer
 
 #endif

src/main.cpp

@@ -30,6 +30,8 @@ extern "C"
 using std::cout, std::cerr, std::endl;
 using std::pair, std::string, std::string_view, std::vector;
 
+using Lexer::Token, Lexer::lerr_t, Lexer::lerr_type_t;
+
 void usage(const char *program_name, FILE *fp)
 {
   fprintf(fp,

src/preprocesser.cpp

@@ -18,6 +18,8 @@
 
 using std::pair, std::vector, std::make_pair, std::string, std::string_view;
 
+using Lexer::Token, Lexer::lerr_t, Lexer::lerr_type_t;
+
 #define VCLEAR(V)                       \
   std::for_each((V).begin(), (V).end(), \
                 [](Token *t)            \

src/preprocesser.hpp

@@ -30,33 +30,34 @@ enum pp_err_type_t
 
 struct pp_err_t
 {
-  const Token *reference;
+  const Lexer::Token *reference;
   pp_err_type_t type;
-  lerr_t lerr;
+  Lexer::lerr_t lerr;
 
   pp_err_t();
   pp_err_t(pp_err_type_t);
-  pp_err_t(pp_err_type_t, const Token *);
+  pp_err_t(pp_err_type_t, const Lexer::Token *);
-  pp_err_t(pp_err_type_t, const Token *, lerr_t);
+  pp_err_t(pp_err_type_t, const Lexer::Token *, Lexer::lerr_t);
 };
 
 std::ostream &operator<<(std::ostream &, pp_err_t &);
 
 struct pp_unit_t
 {
-  const Token *const token;
+  const Lexer::Token *const token;
   struct
   {
     std::string_view name;
     std::vector<pp_unit_t> elements;
   } container;
 
-  pp_unit_t(const Token *const);
+  pp_unit_t(const Lexer::Token *const);
   pp_unit_t(std::string_view, std::vector<pp_unit_t>);
 };
 
-std::vector<pp_unit_t> tokens_to_units(const std::vector<Token *> &);
+std::vector<pp_unit_t> tokens_to_units(const std::vector<Lexer::Token *> &);
 pp_err_t preprocess_use(std::vector<pp_unit_t> &);
-pp_err_t preprocesser(const std::vector<Token *> &, std::vector<Token *> &);
+pp_err_t preprocesser(const std::vector<Lexer::Token *> &,
+                      std::vector<Lexer::Token *> &);
 
 #endif