parser/precedence.cpp

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