ast::ExprEvaluator< T > Class Template Reference

Inheritance diagram for ast::ExprEvaluator< T >:

Public Member Functions
T	Evaluate (Expr *expr)
	Evaluates the given expression. More...
virtual T	EvaluateList (ExprNodeList subexpr)
	Evaluates the given subexpression. More...

Protected Types
using	op_array = std::pmr::vector< T >

Protected Member Functions
virtual T	mapValue (exprnode::ExprValue &node) const =0
virtual T	evalBinaryOp (exprnode::BinaryOp &op, const T lhs, const T rhs) const =0
virtual T	evalUnaryOp (exprnode::UnaryOp &op, const T rhs) const =0
virtual T	evalMemberAccess (exprnode::MemberAccess &op, const T lhs, const T field) const =0
virtual T	evalMethodCall (exprnode::MethodInvocation &op, const T method, const op_array &args) const =0
virtual T	evalNewObject (exprnode::ClassInstanceCreation &op, const T object, const op_array &args) const =0
virtual T	evalNewArray (exprnode::ArrayInstanceCreation &op, const T type, const T size) const =0
virtual T	evalArrayAccess (exprnode::ArrayAccess &op, const T array, const T index) const =0
virtual T	evalCast (exprnode::Cast &op, const T type, const T value) const =0
SourceRange	argLocation (int arg_index)
	Gets the location of the argument at the given index. More...
virtual bool	validate (T const &) const
virtual bool	validatePop (T const &) const
int	opStackSize () const
SourceRange	argLocation (int argno) const
	Gets the location of the argument at the given index. Note the 0th argument is the first argument, not the operator. More...

Detailed Description

template<typename T>
class ast::ExprEvaluator< T >

Definition at line 12 of file ExprEvaluator.h.

Member Function Documentation

argLocation() [1/2]

template<typename T >

SourceRange ast::ExprEvaluator< T >::argLocation ( int  arg_index )

inlineprotected

Gets the location of the argument at the given index.

Parameters

arg_index

The index of the argument.

Returns

SourceLocation

Definition at line 38 of file ExprEvaluator.h.

                                          {
      // FIXME(kevin): Implement this
      (void)arg_index;
      return SourceRange{};
   }

References SourceRange::SourceRange().

argLocation() [2/2]

template<typename T >

SourceRange ast::ExprEvaluator< T >::argLocation ( int  argno ) const

inlineprotected

Gets the location of the argument at the given index. Note the 0th argument is the first argument, not the operator.

Parameters

argno

The index of the argument.

Returns

SourceRange The location of the argument.

Definition at line 139 of file ExprEvaluator.h.

                                            {
      assert(argno < cur_op->nargs() && argno >= 0);
      // Arguments are offset from the top of the stack
      return arg_locs_[arg_locs_.size() - cur_op->nargs() + argno];
   }

Evaluate()

template<typename T >

T ast::ExprEvaluator< T >::Evaluate ( Expr *  expr )

inline

Evaluates the given expression.

Parameters

expr	The expression to evaluate.

Definition at line 49 of file ExprEvaluator.h.

{ return EvaluateList(expr->list()); }

References ast::ExprEvaluator< T >::EvaluateList().

EvaluateList()

template<typename T >

virtual T ast::ExprEvaluator< T >::EvaluateList ( ExprNodeList  subexpr )

inlinevirtual

Evaluates the given subexpression.

Parameters

subexpr

The list of expression nodes to evaluate.

Definition at line 55 of file ExprEvaluator.h.

                                                {
      using namespace ast::exprnode;
 
      std::pmr::vector<T> op_args;
      const auto getArgs = [&op_args, this](int nargs) {
         op_args.clear();
         for(int i = 0; i < nargs; ++i) op_args.push_back(popSafe());
      };
 
      // Clear the stack
      while(!op_stack_.empty()) popSafe();
 
      // Lock all the nodes
      for(auto const* nodes : subexpr.nodes()) {
         nodes->const_lock();
      }
 
      // Evaluate the RPN expression
      auto* node = subexpr.mut_head();
      for(size_t i = 0; i < subexpr.size(); ++i) {
         // Push on the location of the current node if it's a value
         if(dyn_cast<ExprValue*>(node)) arg_locs_.push_back(node->location());
         // We grab the next node because we will unlock the current node
         auto next_node = node->mut_next();
         node->const_unlock();
         cur_op = dyn_cast<ExprOp*>(node);
         if(auto* value = dyn_cast<ExprValue*>(node)) {
            op_stack_.push(mapValue(*value));
         } else if(auto* unary = dyn_cast<UnaryOp*>(node)) {
            auto rhs = popSafe();
            op_stack_.push(evalUnaryOp(*unary, rhs));
         } else if(auto* binary = dyn_cast<BinaryOp*>(node)) {
            auto rhs = popSafe();
            auto lhs = popSafe();
            op_stack_.push(evalBinaryOp(*binary, lhs, rhs));
         } else if(auto op = dyn_cast<MemberAccess*>(node)) {
            auto field = popSafe();
            auto lhs = popSafe();
            op_stack_.push(evalMemberAccess(*op, lhs, field));
         } else if(auto* method = dyn_cast<MethodInvocation*>(node)) {
            op_args.clear();
            if(method->nargs() > 1) getArgs(method->nargs() - 1);
            auto method_name = popSafe();
            op_stack_.push(evalMethodCall(*method, method_name, op_args));
         } else if(auto* newObj = dyn_cast<ClassInstanceCreation*>(node)) {
            op_args.clear();
            if(newObj->nargs() > 1) getArgs(newObj->nargs() - 1);
            auto type = popSafe();
            op_stack_.push(evalNewObject(*newObj, type, op_args));
         } else if(auto op = dyn_cast<ArrayInstanceCreation*>(node)) {
            auto size = popSafe();
            auto type = popSafe();
            op_stack_.push(evalNewArray(*op, type, size));
         } else if(auto op = dyn_cast<ArrayAccess*>(node)) {
            auto index = popSafe();
            auto array = popSafe();
            op_stack_.push(evalArrayAccess(*op, array, index));
         } else if(auto op = dyn_cast<Cast*>(node)) {
            auto value = popSafe();
            auto type = popSafe();
            op_stack_.push(evalCast(*op, type, value));
         }
         assert(validate(op_stack_.top()));
         node = next_node;
         if(cur_op) mergeLocations(cur_op->nargs());
      }
 
      // Return the result
      auto result = popSafe();
      assert(op_stack_.empty() && "Stack not empty after evaluation");
      return result;
   }

References ast::ExprNodeList::nodes(), and ast::ExprNodeList::size().

Referenced by ast::ExprEvaluator< T >::Evaluate().

---

The documentation for this class was generated from the following files:

• include/ast/ExprNode.h
• include/ast/ExprEvaluator.h