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