parser/precedence.cpp

   1 #include <map>
   2 #include <fridh/parser.hpp>
   3 #include <fridh/symbol.hpp>
   4
   5 namespace fridh
   6 {
   7         namespace
   8         {
   9                 std::set<binary_operator_type::type> binary_right_to_left_operators;
  10
  11                 bool initialised_data = false;
  12         }
  13
  14         void initialise_data()
  15         {
  16                 if(initialised_data)
  17                         return;
  18
  19                 {
  20                         using namespace binary_operator_type;
  21                         for(int i = static_cast<int>(assignment); i <= static_cast<int>(exponentiation_assignment); i++)
  22                                 binary_right_to_left_operators.insert(static_cast<binary_operator_type::type>(i));
  23                 }
  24
  25                 initialised_data = true;
  26         }
  27
  28         word get_unary_operator_precedence(unary_operator_type::type input)
  29         {
  30                 using namespace unary_operator_type;
  31
  32                 switch(input)
  33                 {
  34                         case negation:
  35                         case logical_not:
  36                         case binary_not:
  37                                 return 3;
  38
  39                         case increment:
  40                         case decrement:
  41                                 return 2;
  42                 }
  43
  44                 throw ail::exception("Invalid unary operator type");
  45         }
  46
  47         word get_binary_operator_precedence(binary_operator_type::type input)
  48         {
  49                 using namespace binary_operator_type;
  50
  51                 switch(input)
  52                 {
  53                         case addition:
  54                         case subtraction:
  55                                 return 6;
  56
  57                         case multiplication:
  58                         case division:
  59                         case modulo:
  60                                 return 5;
  61
  62                         case exponentiation:
  63                                 //improvised, not from the C++ operators article as such
  64                                 return 4;
  65
  66                         case less_than:
  67                         case less_than_or_equal:
  68                         case greater_than:
  69                         case greater_than_or_equal:
  70                                 return 8;
  71
  72                         case not_equal:
  73                         case equal:
  74                                 return 9;
  75
  76                         case logical_and:
  77                                 return 13;
  78
  79                         case logical_or:
  80                                 return 14;
  81
  82                         case shift_left:
  83                         case shift_right:
  84                                 return 7;
  85
  86                         case binary_and:
  87                                 return 10;
  88
  89                         case binary_or:
  90                                 return 12;
  91
  92                         case binary_xor:
  93                                 return 11;
  94
  95                         case selection:
  96                                 return 2;
  97
  98                         case assignment:
  99                         case addition_assignment:
 100                         case subtraction_assignment:
 101                         case multiplication_assignment:
 102                         case division_assignment:
 103                         case modulo_assignment:
 104                         case exponentiation_assignment:
 105                                 return 16;
 106                 }
 107
 108                 throw ail::exception("Invalid binary operator type");
 109         }
 110
 111         bool get_parse_tree_node_precedence(parse_tree_node & input, word & output)
 112         {
 113                 switch(input.type)
 114                 {
 115                         case parse_tree_node_type::call:
 116                         case parse_tree_node_type::call_operator:
 117                                 output = 2;
 118                                 break;
 119
 120                         case parse_tree_node_type::unary_operator_node:
 121                                 output = get_unary_operator_precedence(input.unary_operator_pointer->type);
 122                                 break;
 123
 124                         case parse_tree_node_type::binary_operator_node:
 125                                 output = get_binary_operator_precedence(input.binary_operator_pointer->type);
 126                                 break;
 127
 128                         default:
 129                                 return false;
 130                 }
 131
 132                 return true;
 133         }
 134
 135         bool is_right_to_left_operator(parse_tree_node & input)
 136         {
 137                 initialise_data();
 138
 139                 if(input.type == parse_tree_node_type::unary_operator_node)
 140                         return true;
 141
 142                 if
 143                 (
 144                         input.type == parse_tree_node_type::binary_operator_node &&
 145                         binary_right_to_left_operators.find(input.binary_operator_pointer->type) != binary_right_to_left_operators.end()
 146                 )
 147                                 return true;
 148
 149                 return false;
 150         }
 151 }