parser/parser.cpp

   1 #include <ail/file.hpp>
   2 #include <ail/string.hpp>
   3 #include <fridh/parser.hpp>
   4 #include <fridh/lexer.hpp>
   5
   6 namespace fridh
   7 {
   8         parser::parser():
   9                 running(false)
  10         {
  11         }
  12
  13         bool parser::process_module(std::string const & path, std::string const & name, module & output, std::string & error_message)
  14         {
  15                 std::string content;
  16                 if(!ail::read_file(path, content))
  17                 {
  18                         error_message = "Unable to read file \"" + path + "\"";
  19                         return false;
  20                 }
  21
  22                 module module_output;
  23                 bool success = translate_data(module_output, content, name, error_message);
  24                 if(!success)
  25                         return false;
  26
  27                 return true;
  28         }
  29
  30         bool parser::name_is_used(std::string const & name)
  31         {
  32                 return current_node->exists(name);
  33         }
  34
  35         std::string const & parser::get_declaration_name()
  36         {
  37                 return *lines[line_offset].lexemes[1].string;
  38         }
  39
  40         void parser::name_collision_check()
  41         {
  42                 std::string const & name = get_declaration_name();
  43                 if(name_is_used(name))
  44                         error("Name \"" + name + "\" has already been used by another function or class in the current scope");
  45         }
  46
  47         symbol_tree_node & parser::add_name(symbol::type symbol_type)
  48         {
  49                 std::string const & name = get_declaration_name();
  50                 symbol_tree_node * & new_node_pointer = current_node->children[name];
  51                 new_node_pointer = new symbol_tree_node(symbol_type);
  52                 symbol_tree_node & new_node = *new_node_pointer;
  53                 std::cout << "Its parent is " << (void *)current_node << std::endl;
  54                 new_node.parent = current_node;
  55                 current_node = new_node_pointer;
  56                 std::cout << "current_node = " << (void *)new_node_pointer << std::endl;
  57                 return new_node;
  58         }
  59
  60         void parser::process_body(executable_units * output, bool increment)
  61         {
  62                 if(increment)
  63                 {
  64                         line_offset++;
  65                         indentation_level++;
  66
  67                         std::cout << "process_body" << std::endl;
  68                 }
  69
  70                 bool is_class = (output == 0);
  71
  72                 if(is_class)
  73                         nested_class_level++;
  74
  75                 while(line_offset < line_end)
  76                 {
  77                         bool end;
  78                         if(is_class)
  79                                 end = process_line(0);
  80                         else
  81                         {
  82                                 executable_unit new_unit;
  83                                 end = process_line(&new_unit);
  84                                 output->push_back(new_unit);
  85                         }
  86                         if(end)
  87                         {
  88                                 if(indentation_level == 0 && line_offset != line_end - 1)
  89                                         error("Internal error: Invalid indentation level calculated");
  90
  91                                 indentation_level--;
  92
  93                                 if(is_class)
  94                                         nested_class_level--;
  95
  96                                 break;
  97                         }
  98                 }
  99         }
 100
 101         bool parser::process_class()
 102         {
 103                 lexeme_container & lexemes = get_lexemes();
 104                 if(!(lexemes.size() == 2 && lexemes[0].type == lexeme_type::class_operator && lexemes[1].type == lexeme_type::name))
 105                         return false;
 106
 107                 name_collision_check();
 108
 109                 add_name(symbol::class_symbol);
 110
 111                 process_body(0);
 112
 113                 scope_up();
 114
 115                 return true;
 116         }
 117
 118         bool parser::process_function(function * output)
 119         {
 120                 lexeme_container & lexemes = get_lexemes();
 121                 if(!(lexemes.size() >= 2 && lexemes[0].type == lexeme_type::function_declaration))
 122                         return false;
 123
 124                 for(std::size_t i = 1, end = lexemes.size(); i < end; i++)
 125                         if(lexemes[i].type != lexeme_type::name)
 126                                 error("Encountered an invalid lexeme type in a function declaration - at this point only names are permitted");
 127
 128                 name_collision_check();
 129
 130                 function * current_function;
 131                 if(output)
 132                         current_function = output;
 133                 else
 134                         current_function = add_name(symbol::function).function_pointer;
 135
 136                 for(std::size_t i = 2, end = lexemes.size(); i < end; i++)
 137                         current_function->arguments.push_back(*lexemes[i].string);
 138
 139                 process_body(&current_function->body);
 140
 141                 scope_up();
 142
 143                 return true;
 144         }
 145
 146         void parser::process_offset_atomic_statement(parse_tree_node & output, std::size_t offset)
 147         {
 148                 lexeme_container & lexemes = get_lexemes();
 149                 parse_tree_nodes nodes;
 150                 process_atomic_statement(lexemes, offset, nodes);
 151                 output = nodes[0];
 152
 153                 line_offset++;
 154                 std::cout << "process_offset_atomic_statement" << std::endl;
 155         }
 156
 157         void parser::process_composite_term(parse_tree_node & output)
 158         {
 159                 process_offset_atomic_statement(output, 1);
 160         }
 161
 162         bool parser::process_line(executable_unit * output)
 163         {
 164                 line_of_code & current_line = lines[line_offset];
 165                 std::cout << "Line " << current_line.line << ": " << current_line.indentation_level << std::endl;
 166
 167                 if(current_line.indentation_level > indentation_level)
 168                         error("Unexpected increase in the indentation level (" + ail::number_to_string(indentation_level) + " to " + ail::number_to_string(current_line.indentation_level) + ")");
 169
 170                 if(!process_class() && !process_function())
 171                 {
 172                         if(output)
 173                                 process_statement(*output);
 174                         else
 175                                 error("Regular statements need to be placed within functions");
 176                 }
 177
 178                 if(line_offset == line_end)
 179                 {
 180                         //end of file -> end of the module entry function block
 181                         return true;
 182                 }
 183
 184                 line_of_code & next_line = lines[line_offset];
 185
 186                 //end of block?
 187                 return next_line.indentation_level < indentation_level;
 188         }
 189
 190         bool parser::translate_data(module & target_module, std::string const & data, std::string const & module_name, std::string & error_message_output)
 191         {
 192                 try
 193                 {
 194                         lines = lines_of_code();
 195                         lexer current_lexer(data, lines);
 196
 197                         if(!current_lexer.parse(error_message_output))
 198                                 return false;
 199
 200                         current_node = &target_module.symbols;
 201                         indentation_level = 0;
 202                         nested_class_level = 0;
 203                         line_offset = 0;
 204                         line_end = lines.size();
 205
 206                         process_body(&target_module.entry_function.body, false);
 207
 208                         return true;
 209                 }
 210                 catch(ail::exception & exception)
 211                 {
 212                         error_message_output = module_name + ": " + exception.get_message();
 213                         return false;
 214                 }
 215         }
 216
 217         lexeme_container & parser::get_lexemes()
 218         {
 219                 return lines[line_offset].lexemes;
 220         }
 221
 222         void parser::error(std::string const & message)
 223         {
 224                 throw ail::exception("Line " + ail::number_to_string(lines[line_offset].line) + ": " + message);
 225         }
 226
 227         void parser::single_lexeme_error(std::string const & message, std::size_t offset)
 228         {
 229                 lexeme_container & lexemes = get_lexemes();
 230                 error(message + " (\"" + lexemes[offset].to_string() + "\")");
 231         }
 232
 233         void parser::double_lexeme_error(std::string const & message, std::size_t offset)
 234         {
 235                 lexeme_container & lexemes = get_lexemes();
 236                 error(message + " (\"" + lexemes[offset - 1].to_string() + "\", \"" + lexemes[offset].to_string() + "\")");
 237         }
 238
 239         void parser::scope_up()
 240         {
 241                 std::cout << "current_node: " << (void *)current_node << " -> " << current_node->parent << std::endl;
 242                 current_node = current_node->parent;
 243         }
 244 }