parser/control_flow.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         bool parser::is_if_statement()
   9         {
  10                 return lines[line_offset].lexemes[0].type == lexeme_type::division;
  11         }
  12
  13         bool parser::process_if(executable_unit & output)
  14         {
  15                 lexeme_container & lexemes = get_lexemes();
  16                 if(!is_if_statement())
  17                         return false;
  18
  19                 parse_tree_node conditional;
  20                 process_composite_term(conditional);
  21
  22                 executable_units if_body;
  23                 process_body(&if_body);
  24
  25                 bool is_if_else = false;
  26
  27                 if(line_offset < line_end)
  28                 {
  29                         lexeme_container & lexemes = get_lexemes();
  30                         if(is_if_statement() && lexemes.size() == 1)
  31                         {
  32                                 is_if_else = true;
  33
  34                                 executable_units else_body;
  35                                 process_body(&else_body);
  36
  37                                 output.type = executable_unit_type::if_else_statement;
  38                                 if_else_statement * & if_else_pointer = output.if_else_pointer;
  39                                 if_else_pointer = new if_else_statement;
  40                                 if_else_pointer->conditional_term = conditional;
  41                                 if_else_pointer->if_body = if_body;
  42                                 if_else_pointer->else_body = else_body;
  43                         }
  44                 }
  45
  46                 if(!is_if_else)
  47                 {
  48                         output.type = executable_unit_type::if_statement;
  49                         if_statement * & if_pointer = output.if_pointer;
  50                         if_pointer = new if_statement;
  51                         if_pointer->conditional_term = conditional;
  52                         if_pointer->body = if_body;
  53                 }
  54
  55                 return true;
  56         }
  57
  58         bool parser::process_while(executable_unit & output)
  59         {
  60                 lexeme_container & lexemes = get_lexemes();
  61                 if(lexemes[0].type != lexeme_type::while_operator)
  62                         return false;
  63
  64                 parse_tree_node conditional;
  65                 process_composite_term(conditional);
  66
  67                 output.type = executable_unit_type::while_statement;
  68                 while_statement * & while_pointer = output.while_pointer;
  69                 while_pointer = new while_statement;
  70                 while_pointer->conditional_term = conditional;
  71
  72                 process_body(&while_pointer->body);
  73
  74                 return true;
  75         }
  76
  77         bool parser::process_for(executable_unit & output)
  78         {
  79                 lexeme_container & lexemes = get_lexemes();
  80                 if(lexemes[0].type != lexeme_type::iteration)
  81                         return false;
  82
  83                 if(lexemes.size() == 1)
  84                 {
  85                         //three part for
  86
  87                         if(lines.size() - line_offset < 4)
  88                                 throw ail::exception("Incomplete for statement");
  89
  90                         line_offset++;
  91
  92                         for(std::size_t i = line_offset, end = i + 3; i < end; i++)
  93                         {
  94                                 if(lines[i].indentation_level != indentation_level)
  95                                         throw ail::exception("Invalid indentation level in a for statement");
  96                         }
  97
  98                         output.type = executable_unit_type::for_statement;
  99                         for_statement * & for_pointer = output.for_pointer;
 100                         for_pointer = new for_statement;
 101                         process_offset_atomic_statement(for_pointer->initialisation);
 102                         process_offset_atomic_statement(for_pointer->conditional);
 103                         process_offset_atomic_statement(for_pointer->iteration);
 104                 }
 105                 else
 106                 {
 107                         //for each statement
 108
 109                         output.type = executable_unit_type::for_each_statement;
 110                         for_each_statement * & for_each_pointer = output.for_each_pointer;
 111                         for_each_pointer = new for_each_statement;
 112                         process_composite_term(for_each_pointer->container);
 113
 114                         process_body(&for_each_pointer->body);
 115                 }
 116
 117                 return true;
 118         }
 119
 120         bool parser::process_return(executable_unit & output)
 121         {
 122                 lexeme_container & lexemes = get_lexemes();
 123                 if(lexemes[0].type != lexeme_type::selection_operator)
 124                         return false;
 125
 126                 output.type = executable_unit_type::return_statement;
 127                 parse_tree_node * & statement_pointer = output.statement_pointer;
 128                 statement_pointer = new parse_tree_node;
 129                 process_composite_term(*statement_pointer);
 130
 131                 return true;
 132         }
 133
 134         void parser::process_statement(executable_unit & output)
 135         {
 136                 if
 137                 (
 138                         !
 139                         (
 140                                 process_if(output) ||
 141                                 process_while(output) ||
 142                                 process_for(output) ||
 143                                 process_return(output)
 144                         )
 145                 )
 146                 {
 147                         output.type = executable_unit_type::statement;
 148                         parse_tree_node * & node = output.statement_pointer;
 149                         node = new parse_tree_node;
 150                         process_offset_atomic_statement(*node);
 151
 152                         /*
 153                         line_offset++;
 154                         std::cout << "process_statement" << std::endl;
 155                         */
 156                 }
 157         }
 158 }