Guest User

Untitled

a guest
Jan 16th, 2017
81
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1.     static double minprec = -1;
  2.     static Operator* minrator = new Operator("<minimum-precedence-operator>", minprec, FixityT::Infix, AssocT::Noassoc);
  3.  
  4.     Operator* Parser::get_op(Token t)
  5.     {
  6.         auto it = m_Operators.find(t.Value);
  7.         if (it == m_Operators.end())
  8.             return nullptr;
  9.  
  10.         return it->second;
  11.     }
  12.  
  13.     Operator* Parser::srator(ExprStack& stack)
  14.     {
  15.         if (stack.empty())
  16.         {
  17.             return minrator;
  18.         }
  19.  
  20.         return std::get<0>(stack.top());
  21.     }
  22.  
  23.     bool Parser::is_prefix(Operator* op)
  24.     {
  25.         return op->Fixity == FixityT::Prefix;
  26.     }
  27.  
  28.     bool Parser::noparens(Operator* a, Operator* b, AssocT side)
  29.     {
  30.         auto pi = a->Precedence;
  31.         auto fi = a->Fixity;
  32.         auto ai = a->Assoc;
  33.         auto po = b->Precedence;
  34.         auto fo = b->Fixity;
  35.         auto ao = b->Assoc;
  36.  
  37.         if (pi > po) return true;
  38.         if (side == AssocT::Left)
  39.         {
  40.             if (fi == FixityT::Postfix) return true;
  41.             if (fi == FixityT::Infix && ai == AssocT::Left) return (fo == FixityT::Infix && ao == AssocT::Left);
  42.         }
  43.         else if (side == AssocT::Right)
  44.         {
  45.             if (fi == FixityT::Postfix) return true;
  46.             if (fi == FixityT::Infix && ai == AssocT::Right) return (fo == FixityT::Infix && ao == AssocT::Right);
  47.         }
  48.         else if (side == AssocT::Noassoc)
  49.         {
  50.             if (fi == FixityT::Infix && fo == FixityT::Infix) return ai == ao;
  51.             return fi == fo;
  52.         }
  53.  
  54.         return false;
  55.     }
  56.  
  57.     Expr* Parser::parse_prefix(ExprStack& stack, OpList& prefixes)
  58.     {
  59.         Operator* op;
  60.         if (!(op = get_op(Peek())))
  61.         {
  62.             Expr* atom = ParseAtom();
  63.             if (!atom)
  64.             {
  65.                 std::cout << "Atom expected" << std::endl;
  66.                 return nullptr;
  67.             }
  68.             return parse_postfix(stack, atom, prefixes);
  69.         }
  70.         else
  71.         {
  72.             if (is_prefix(op))
  73.             {
  74.                 Next();
  75.                 prefixes.push_back(op);
  76.                 return parse_prefix(stack, prefixes);
  77.             }
  78.             else
  79.             {
  80.                 std::cout << "Not prefix op!" << std::endl;
  81.             }
  82.         }
  83.         if (Peek().Value == " Epsilon ")
  84.         {
  85.             std::cout << "Premature EOE" << std::endl;
  86.         }
  87.         return nullptr;
  88.     }
  89.  
  90.     Expr* Parser::parse_postfix(ExprStack& stack, Expr* exp, OpList& ls)
  91.     {
  92.         Operator* irator = get_op(Peek());
  93.         if (irator)
  94.         {
  95.             if (irator->Fixity == FixityT::Postfix)
  96.             {
  97.                 if (noparens(srator(stack), irator, AssocT::Left))
  98.                 {
  99.                     if (stack.empty())
  100.                     {
  101.                         std::cout << "IMPOSSIBLE" << std::endl;
  102.                         return nullptr;
  103.                     }
  104.                     else
  105.                     {
  106.                         auto& tpl = stack.top();
  107.                         stack.pop();
  108.                         Operator* op = std::get<0>(tpl);
  109.                         Expr* e2 = std::get<1>(tpl);
  110.                         auto prefxes = std::get<2>(tpl);
  111.                         return parse_postfix(stack, new BinExpr(e2, exp, op), irator);
  112.                     }
  113.                 }
  114.                 else if (noparens(irator, srator(stack), AssocT::Right))
  115.                 {
  116.                     return parse_postfix(stack, new UryExpr(exp, irator), ls);
  117.                 }
  118.                 else
  119.                 {
  120.                     std::cout << "NON assoc!" << std::endl;
  121.                     return nullptr;
  122.                 }
  123.             }
  124.             else if (irator->Fixity == FixityT::Infix)
  125.             {
  126.                 if (noparens(srator(stack), irator, AssocT::Left))
  127.                 {
  128.                     if (stack.empty())
  129.                     {
  130.                         std::cout << "IMPOSSIBLE" << std::endl;
  131.                         return nullptr;
  132.                     }
  133.                     else
  134.                     {
  135.                         auto& tpl = stack.top();
  136.                         stack.pop();
  137.                         Operator* op = std::get<0>(tpl);
  138.                         Expr* e2 = std::get<1>(tpl);
  139.                         return parse_postfix(stack, new BinExpr(e2, exp, op), irator);
  140.                     }
  141.                 }
  142.             }
  143.         }
  144.     }
RAW Paste Data