frith/function.hpp

   1 #pragma once
   2
   3 #include <vector>
   4 #include <string>
   5
   6 #include <ail/types.hpp>
   7
   8 namespace frith
   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         }
  81
  82         namespace parse_tree_node_type
  83         {
  84                 enum type
  85                 {
  86                         symbol,
  87                         unary_operator_node,
  88                         binary_operator_node,
  89                         call,
  90                         array,
  91                 };
  92         }
  93
  94         struct
  95                 parse_tree_node,
  96                 parse_tree_symbol,
  97                 executable_units;
  98
  99         typedef std::vector<parse_tree_node> parse_tree_nodes;
 100         typedef std::vector<parse_tree_symbol> parse_tree_symbols;
 101         typedef std::vector<executable_unit> executable_units;
 102         typedef std::vector<binary_operator_type::type> binary_operator_container;
 103
 104         struct parse_tree_symbol
 105         {
 106                 std::string name;
 107         };
 108
 109         struct parse_tree_unary_operator_node
 110         {
 111                 unary_operator_type type;
 112                 parse_tree_node argument;
 113         };
 114
 115         struct parse_tree_binary_operator_node
 116         {
 117                 binary_operator_type type;
 118                 parse_tree_node
 119                         left_argument,
 120                         right_argument;
 121         };
 122
 123         struct parse_tree_call
 124         {
 125                 parse_tree_node function;
 126                 parse_tree_nodes arguments;
 127         };
 128
 129         struct parse_tree_array
 130         {
 131                 parse_tree_node elements;
 132         };
 133
 134         struct parse_tree_node
 135         {
 136                 parse_tree_node_type::type type;
 137                 union
 138                 {
 139                         parse_tree_symbol * symbol_pointer;
 140                         parse_tree_unary_operator_node * unary_operator_pointer;
 141                         parse_tree_binary_operator_node * binary_operator_pointer;
 142                         parse_tree_call * call_pointer;
 143                         parse_tree_array * array_pointer;
 144                 }
 145         };
 146
 147         struct assignment_statement
 148         {
 149                 assignment_type::type type;
 150                 parse_tree_symbols symbols;
 151                 parse_tree_node term;
 152         };
 153
 154         struct if_statement
 155         {
 156                 parse_tree_node conditional_term;
 157                 parse_tree_nodes body;
 158         };
 159
 160         struct if_else_statement
 161         {
 162                 parse_tree_node conditional_term;
 163                 parse_tree_nodes
 164                         if_body,
 165                         else_body;
 166         };
 167
 168         struct for_each_statement
 169         {
 170                 parse_tree_symbol container;
 171                 parse_tree_nodes body;
 172         };
 173
 174         struct for_statement
 175         {
 176                 parse_tree_node
 177                         initialisation,
 178                         conditional,
 179                         iteration;
 180                 parse_tree_nodes body;
 181         };
 182
 183         struct while_statement
 184         {
 185                 parse_tree_node conditional_term;
 186                 parse_tree_nodes body;
 187         };
 188
 189         struct executable_unit
 190         {
 191                 executable_unit_type::type type;
 192
 193                 union
 194                 {
 195                         parse_tree_node * statement_pointer;
 196                         if_statement * if_pointer;
 197                         if_else_statement * if_else_pointer;
 198                         for_each_statement * for_each_pointer;
 199                         for_statement * for_pointer;
 200                         while_statement * while_pointer;
 201                 }
 202         };
 203
 204         struct function
 205         {
 206                 string_vector arguments;
 207                 executable_units units;
 208         };
 209 }