frith/lexer.hpp

   1 #pragma once
   2
   3 #include <string>
   4 #include <vector>
   5 #include <ail/types.hpp>
   6 #include <frith/variable.hpp>
   7
   8 namespace frith
   9 {
  10         enum lexeme_type
  11         {
  12                 lexeme_type_name,
  13
  14                 lexeme_type_signed_integer,
  15                 lexeme_type_unsigned_integer,
  16                 lexeme_type_floating_point_value,
  17                 lexeme_type_string,
  18
  19                 lexeme_type_addition,
  20                 lexeme_type_subtraction,
  21                 lexeme_type_multiplication,
  22                 lexeme_type_division,
  23                 lexeme_type_modulo,
  24
  25                 lexeme_type_less_than,
  26                 lexeme_type_less_than_or_equal,
  27                 lexeme_type_greater_than,
  28                 lexeme_type_greater_than_or_equal,
  29                 lexeme_type_unequal,
  30                 lexeme_type_equal,
  31
  32                 lexeme_type_logical_not,
  33
  34                 lexeme_type_logical_and,
  35                 lexeme_type_logical_or,
  36
  37                 lexeme_type_shift_left,
  38                 lexeme_type_shift_right,
  39
  40                 lexeme_type_binary_and,
  41                 lexeme_type_binary_or,
  42                 lexeme_type_binary_xor,
  43
  44                 lexeme_type_binary_not,
  45
  46                 lexeme_type_bracket_left,
  47                 lexeme_type_bracket_right,
  48
  49                 lexeme_type_array_left,
  50                 lexeme_type_array_right,
  51         };
  52
  53         struct lexeme
  54         {
  55                 lexeme_type type;
  56                 union
  57                 {
  58                         types::signed_integer signed_integer;
  59                         types::unsigned_integer unsigned_integer;
  60                         types::floating_point_value floating_point_value;
  61                         std::string * string;
  62                 };
  63
  64                 lexeme();
  65                 lexeme(lexeme_type type);
  66                 explicit lexeme(types::signed_integer signed_integer);
  67                 explicit lexeme(types::unsigned_integer unsigned_integer);
  68                 explicit lexeme(types::floating_point_value floating_point_value);
  69                 explicit lexeme(lexeme_type type, std::string const & string);
  70         };
  71
  72         struct line_of_code
  73         {
  74                 uword line;
  75                 uword indentation_level;
  76                 std::vector<lexeme> lexemes;
  77
  78                 line_of_code();
  79         };
  80
  81         struct operator_lexeme
  82         {
  83                 lexeme_type lexeme;
  84                 std::string string;
  85
  86                 operator_lexeme(lexeme_type lexeme, std::string const & string);
  87                 bool operator<(operator_lexeme const & other) const;
  88         };
  89
  90         bool parse_lexemes(std::string const & input, std::vector<line_of_code> & lines, std::string & error);
  91 }