frith/lexer.hpp

   1 #pragma once
   2
   3 #include <string>
   4 #include <vector>
   5 #include <ail/types.hpp>
   6 #include <frith/symbol.hpp>
   7 #include <boost/thread/mutex.hpp>
   8
   9 namespace frith
  10 {
  11         namespace lexeme_type
  12         {
  13                 enum type
  14                 {
  15                         name,
  16
  17                         boolean,
  18                         signed_integer,
  19                         unsigned_integer,
  20                         floating_point_value,
  21                         string,
  22
  23                         addition,
  24                         subtraction,
  25                         multiplication,
  26                         division,
  27                         modulo,
  28                         exponentiation,
  29
  30                         assignment,
  31                         addition_assignment,
  32                         subtraction_assignment,
  33                         multiplication_assignment,
  34                         division_assignment,
  35                         modulo_assignment,
  36                         exponentiation_assignment,
  37
  38                         increment,
  39                         decrement,
  40
  41                         less_than,
  42                         less_than_or_equal,
  43                         greater_than,
  44                         greater_than_or_equal,
  45                         unequal,
  46                         equal,
  47
  48                         logical_not,
  49
  50                         logical_and,
  51                         logical_or,
  52
  53                         shift_left,
  54                         shift_right,
  55
  56                         binary_and,
  57                         binary_or,
  58                         binary_xor,
  59
  60                         binary_not,
  61
  62                         bracket_start,
  63                         bracket_start_call,
  64                         bracket_end,
  65
  66                         array_start,
  67                         array_end,
  68
  69                         scope_start,
  70                         scope_end,
  71
  72                         iteration,
  73                         iterator,
  74
  75                         function_declaration,
  76                         anonymous_function_declaration,
  77
  78                         class_operator,
  79                         selection_operator,
  80                         call_operator,
  81                         scope_operator,
  82                 };
  83         }
  84
  85         struct lexeme
  86         {
  87                 lexeme_type::type type;
  88                 union
  89                 {
  90                         bool boolean;
  91                         types::signed_integer signed_integer;
  92                         types::unsigned_integer unsigned_integer;
  93                         types::floating_point_value floating_point_value;
  94                         std::string * string;
  95                 };
  96
  97                 lexeme();
  98                 lexeme(lexeme_type::type type);
  99                 explicit lexeme(types::boolean boolean);
 100                 explicit lexeme(types::signed_integer signed_integer);
 101                 explicit lexeme(types::unsigned_integer unsigned_integer);
 102                 explicit lexeme(types::floating_point_value floating_point_value);
 103                 explicit lexeme(lexeme_type::type type, std::string const & string);
 104                 std::string to_string() const;
 105         };
 106
 107         struct line_of_code
 108         {
 109                 uword line;
 110                 uword indentation_level;
 111                 std::vector<lexeme> lexemes;
 112
 113                 line_of_code();
 114         };
 115
 116         struct operator_lexeme
 117         {
 118                 lexeme_type::type lexeme;
 119                 std::string string;
 120
 121                 operator_lexeme(lexeme_type::type lexeme, std::string const & string);
 122                 bool operator<(operator_lexeme const & other) const;
 123         };
 124
 125         class lexer
 126         {
 127         public:
 128                 lexer(std::string const & input, std::vector<line_of_code> & lines, std::string & error);
 129
 130                 bool parse();
 131
 132         private:
 133                 std::string const & input;
 134                 std::vector<line_of_code> & lines;
 135                 std::string & error;
 136
 137                 uword line;
 138                 std::size_t
 139                         i,
 140                         end,
 141                         line_offset;
 142                 line_of_code current_line;
 143                 bool is_call_bracket;
 144
 145                 bool parse_operator(line_of_code & output);
 146                 bool parse_string(line_of_code & output, std::string & error_message, std::string error_prefix = "");
 147                 bool parse_number(line_of_code & output, bool & error_occured);
 148                 void parse_name(line_of_code & output);
 149                 bool parse_comment(std::string & error_message);
 150
 151                 std::string lexer_error(std::string const & message, uword error_line = 0);
 152                 std::string number_parsing_error(std::string const & message, bool & error_occured);
 153
 154                 bool is_name_char(char input);
 155                 bool string_match(std::string const & target);
 156                 void process_newline();
 157         };
 158
 159         std::string visualise_lexemes(std::vector<line_of_code> & lines);
 160
 161         void initialise_tables();
 162
 163         extern boost::mutex table_mutex;
 164         extern std::vector<operator_lexeme> operator_lexeme_data;
 165 }