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;
  52                 symbol_tree_node & new_node = *new_node_pointer;
  53                 new_node = symbol_tree_node(symbol_type);
  54                 new_node.parent = current_node;
  55                 current_node = &new_node;
  56                 return new_node;
  57         }
  58
  59         void parser::process_body(executable_units * output)
  60         {
  61                 line_offset++;
  62                 indentation_level++;
  63
  64                 bool is_class = (output == 0);
  65
  66                 if(is_class)
  67                         nested_class_level++;
  68
  69                 while(line_offset < line_end)
  70                 {
  71                         bool end;
  72                         if(is_class)
  73                                 end = process_line(0);
  74                         else
  75                         {
  76                                 executable_unit new_unit;
  77                                 process_line(&new_unit);
  78                                 output->push_back(new_unit);
  79                         }
  80                         if(end)
  81                         {
  82                                 if(indentation_level > 0)
  83                                         indentation_level--;
  84                                 if(is_class)
  85                                         nested_class_level--;
  86                                 current_node = current_node->parent;
  87                                 break;
  88                         }
  89                 }
  90         }
  91
  92         bool parser::process_class()
  93         {
  94                 lexeme_container & lexemes = lines[line_offset].lexemes;
  95                 if(!(lexemes.size() == 2 && lexemes[0].type == lexeme_type::class_operator && lexemes[1].type == lexeme_type::name))
  96                         return false;
  97
  98                 name_collision_check();
  99
 100                 add_name(symbol::class_symbol);
 101
 102                 process_body(0);
 103                 return true;
 104         }
 105
 106         bool parser::process_function(function * output)
 107         {
 108                 lexeme_container & lexemes = lines[line_offset].lexemes;
 109                 if(!(lexemes.size() >= 2 && lexemes[0].type == lexeme_type::function_declaration))
 110                         return false;
 111
 112                 for(std::size_t i = 1, end = lexemes.size(); i < end; i++)
 113                         if(lexemes[i].type != lexeme_type::name)
 114                                 error("Encountered an invalid lexeme type in a function declaration - at this point only names are permitted");
 115
 116                 name_collision_check();
 117
 118                 function * current_function;
 119                 if(output)
 120                         current_function = output;
 121                 else
 122                         current_function = add_name(symbol::class_symbol).function_pointer;
 123
 124                 for(std::size_t i = 2, end = lexemes.size(); i < end; i++)
 125                         current_function->arguments.push_back(*lexemes[i].string);
 126
 127                 process_body(&current_function->body);
 128                 return true;
 129         }
 130
 131         void parser::process_offset_atomic_statement(parse_tree_node & output, std::size_t offset)
 132         {
 133                 lexeme_container & lexemes = lines[line_offset].lexemes;
 134                 parse_tree_nodes nodes;
 135                 process_atomic_statement(lexemes, offset, nodes);
 136                 output = nodes[0];
 137                 line_offset++;
 138         }
 139
 140         void parser::process_composite_term(parse_tree_node & output)
 141         {
 142                 process_offset_atomic_statement(output, 1);
 143         }
 144
 145         bool parser::process_line(executable_unit * output)
 146         {
 147                 line_of_code & current_line = lines[line_offset];
 148                 if(current_line.indentation_level > indentation_level)
 149                         error("Unexpected increase in the indentation level");
 150
 151                 if(!process_class())
 152                 {
 153                         if(output)
 154                         {
 155                                 if(!process_function())
 156                                         process_statement(*output);
 157                         }
 158                         else
 159                                 error("Regular statements and assignments need to be placed within functions");
 160                 }
 161
 162                 line_offset++;
 163
 164                 if(line_offset == line_end)
 165                 {
 166                         //end of file -> end of the module entry function block
 167                         return true;
 168                 }
 169
 170                 line_of_code & next_line = lines[line_offset];
 171
 172                 //end of block?
 173                 return next_line.indentation_level < indentation_level;
 174         }
 175
 176         bool parser::translate_data(module & target_module, std::string const & data, std::string const & module_name, std::string & error_message_output)
 177         {
 178                 try
 179                 {
 180                         lines = lines_of_code();
 181                         lexer current_lexer(data, lines);
 182
 183                         if(!current_lexer.parse(error_message_output))
 184                                 return false;
 185
 186                         current_node = &target_module.symbols;
 187                         indentation_level = 0;
 188                         nested_class_level = 0;
 189                         line_offset = 0;
 190
 191                         process_body(&target_module.entry_function.body);
 192
 193                         return true;
 194                 }
 195                 catch(ail::exception & exception)
 196                 {
 197                         error_message_output = exception.get_message();
 198                         return false;
 199                 }
 200         }
 201
 202         void parser::error(std::string const & message)
 203         {
 204                 throw ail::exception("Line " + ail::number_to_string(lines[line_offset].line) + ": " + message);
 205         }
 206 }