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