fridh/function.hpp

   1 #pragma once
   2
   3 #include <vector>
   4 #include <string>
   5
   6 #include <ail/types.hpp>
   7
   8 namespace fridh
   9 {
  10         namespace executable_unit_type
  11         {
  12                 enum type
  13                 {
  14                         uninitialised,
  15
  16                         statement,
  17                         return_statement,
  18                         if_statement,
  19                         if_else_statement,
  20                         for_each_statement,
  21                         for_statement,
  22                         while_statement,
  23                 };
  24         }
  25
  26         namespace unary_operator_type
  27         {
  28                 enum type
  29                 {
  30                         negation,
  31                         logical_not,
  32                         binary_not,
  33
  34                         increment,
  35                         decrement,
  36                 };
  37         }
  38
  39         namespace binary_operator_type
  40         {
  41                 enum type
  42                 {
  43                         addition,
  44                         subtraction,
  45                         multiplication,
  46                         division,
  47                         modulo,
  48                         exponentiation,
  49
  50                         less_than,
  51                         less_than_or_equal,
  52                         greater_than,
  53                         greater_than_or_equal,
  54                         not_equal,
  55                         equal,
  56
  57                         logical_and,
  58                         logical_or,
  59
  60                         shift_left,
  61                         shift_right,
  62
  63                         binary_and,
  64                         binary_or,
  65                         binary_xor,
  66
  67                         selection,
  68
  69                         assignment,
  70                         addition_assignment,
  71                         subtraction_assignment,
  72                         multiplication_assignment,
  73                         division_assignment,
  74                         modulo_assignment,
  75                         exponentiation_assignment,
  76                 };
  77         }
  78
  79         namespace parse_tree_node_type
  80         {
  81                 enum type
  82                 {
  83                         uninitialised,
  84
  85                         variable,
  86                         symbol,
  87                         unary_operator_node,
  88                         binary_operator_node,
  89                         call,
  90                         array,
  91
  92                         call_operator,
  93                         spaced_call_operator,
  94
  95                         iterator,
  96                 };
  97         }
  98
  99         namespace symbol_prefix
 100         {
 101                 enum type
 102                 {
 103                         none,
 104                         scope_operator,
 105                         class_operator,
 106                 };
 107         }
 108
 109         struct parse_tree_node;
 110         struct parse_tree_symbol;
 111         struct executable_unit;
 112
 113         typedef std::vector<parse_tree_node> parse_tree_nodes;
 114         typedef std::vector<parse_tree_symbol> parse_tree_symbols;
 115         typedef std::vector<executable_unit> executable_units;
 116
 117         struct parse_tree_symbol;
 118         struct parse_tree_unary_operator_node;
 119         struct parse_tree_binary_operator_node;
 120         struct parse_tree_call;
 121         struct parse_tree_array;
 122
 123         struct parse_tree_node
 124         {
 125                 parse_tree_node_type::type type;
 126                 union
 127                 {
 128                         variable * variable_pointer;
 129                         parse_tree_symbol * symbol_pointer;
 130                         parse_tree_unary_operator_node * unary_operator_pointer;
 131                         parse_tree_binary_operator_node * binary_operator_pointer;
 132                         parse_tree_call * call_pointer;
 133                         parse_tree_array * array_pointer;
 134                 };
 135
 136                 parse_tree_node();
 137                 parse_tree_node(parse_tree_node const & other);
 138                 ~parse_tree_node();
 139
 140                 parse_tree_node(parse_tree_node_type::type type);
 141                 parse_tree_node(variable * variable_pointer);
 142                 parse_tree_node(unary_operator_type::type unary_operator);
 143                 parse_tree_node(binary_operator_type::type binary_operator);
 144                 parse_tree_node(parse_tree_nodes & elements);
 145
 146                 void is_call();
 147
 148                 bool is_post_fix() const;
 149         };
 150
 151         struct parse_tree_symbol
 152         {
 153                 std::string name;
 154                 symbol_prefix::type type;
 155
 156                 parse_tree_symbol();
 157         };
 158
 159         struct parse_tree_unary_operator_node
 160         {
 161                 unary_operator_type::type type;
 162                 parse_tree_node argument;
 163         };
 164
 165         struct parse_tree_binary_operator_node
 166         {
 167                 binary_operator_type::type type;
 168                 parse_tree_node
 169                         left_argument,
 170                         right_argument;
 171         };
 172
 173         struct parse_tree_call
 174         {
 175                 parse_tree_node function;
 176                 parse_tree_nodes arguments;
 177         };
 178
 179         struct parse_tree_array
 180         {
 181                 parse_tree_nodes elements;
 182         };
 183
 184         struct if_statement
 185         {
 186                 parse_tree_node conditional_term;
 187                 executable_units body;
 188         };
 189
 190         struct if_else_statement
 191         {
 192                 parse_tree_node conditional_term;
 193                 executable_units
 194                         if_body,
 195                         else_body;
 196         };
 197
 198         struct for_each_statement
 199         {
 200                 parse_tree_node container;
 201                 executable_units body;
 202         };
 203
 204         struct for_statement
 205         {
 206                 parse_tree_node
 207                         initialisation,
 208                         conditional,
 209                         iteration;
 210                 executable_units body;
 211         };
 212
 213         struct while_statement
 214         {
 215                 parse_tree_node conditional_term;
 216                 executable_units body;
 217         };
 218
 219         struct executable_unit
 220         {
 221                 executable_unit_type::type type;
 222
 223                 union
 224                 {
 225                         parse_tree_node * statement_pointer;
 226                         if_statement * if_pointer;
 227                         if_else_statement * if_else_pointer;
 228                         for_each_statement * for_each_pointer;
 229                         for_statement * for_pointer;
 230                         while_statement * while_pointer;
 231                 };
 232
 233                 executable_unit();
 234                 executable_unit(executable_unit const & other);
 235                 ~executable_unit();
 236         };
 237
 238         struct function
 239         {
 240                 string_vector arguments;
 241                 executable_units body;
 242         };
 243 }