fridh/function.hpp

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