frith/intermediary.hpp

   1 #pragma once
   2
   3 #include <string>
   4 #include <vector>
   5 #include <frith/symbol.hpp>
   6
   7 namespace frith
   8 {
   9         namespace match_result
  10         {
  11                 enum type
  12                 {
  13                         no_match,
  14                         match,
  15                         error,
  16                 };
  17         }
  18
  19         namespace process_line_result
  20         {
  21                 enum type
  22                 {
  23                         ok,
  24                         end_of_block,
  25                         error,
  26                 };
  27         }
  28
  29         namespace operator_precedence
  30         {
  31                 enum type
  32                 {
  33                         selection,
  34
  35                         negation,
  36                         logical_not,
  37                         binary_not,
  38
  39                         exponentiation,
  40
  41                         multiplication,
  42                         division,
  43                         modulo,
  44
  45                         addition,
  46                         subtraction,
  47
  48                         shift_left,
  49                         shift_right,
  50
  51                         less_than,
  52                         less_than_or_equal,
  53
  54                         greater_than,
  55                         greater_than_or_equal,
  56
  57                         equal,
  58                         not_equal,
  59
  60                         binary_and,
  61                         binary_or,
  62
  63                         logical_and,
  64                         logical_or,
  65                 };
  66         }
  67
  68         struct sorted_binary_operator_entry
  69         {
  70
  71                 std::size_t index;
  72         };
  73
  74         class intermediary_translator
  75         {
  76         public:
  77                 intermediary_translator();
  78                 bool load_module(std::string const & path, std::string const & name, std::string & error_message);
  79
  80         private:
  81                 bool running;
  82
  83                 module main_module;
  84                 std::vector<module> modules;
  85
  86                 std::size_t
  87                         line_offset,
  88                         line_end;
  89
  90                 uword indentation_level;
  91
  92                 std::size_t
  93                         lexeme_offset,
  94                         lexeme_end;
  95
  96                 std::string error_message;
  97
  98                 uword nested_class_level;
  99
 100                 std::vector<line_of_code> lines;
 101
 102                 symbol_tree_node * current_node;
 103
 104                 bool name_is_used(std::string const & name);
 105                 std::string const & get_declaration_name();
 106                 bool name_collision_check();
 107                 symbol_tree_node & add_name(symbol::type symbol_type);
 108                 match_result::type process_body(function * current_function = 0);
 109
 110                 bool parse_statement(lexeme_container & lexemes, std::size_t offset, std::size_t end, symbol_tree_node & output);
 111
 112                 match_result::type process_class();
 113                 match_result::type process_function();
 114                 bool process_statement(function & current_function);
 115                 process_line_result::type process_line(function * active_function = 0);
 116
 117                 bool translate_data(module & target_module, std::string const & data, std::string const & module_name, std::string & error_message_output);
 118
 119                 bool error(std::string const & message);
 120         };
 121
 122         void lexeme_to_argument_node(lexeme & input, parse_tree_node & output);
 123         void lexeme_to_unary_operator_node(lexeme & input, parse_tree_node & output, parse_tree_node & argument);
 124         void lexeme_to_binary_operator_node(lexeme & input, parse_tree_node & output, parse_tree_node & left_argument, parse_tree_node & right_argument);
 125 }