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