---

callNode Class Reference

Function call expression. More...

#include <ast.h>

Inheritance diagram for callNode::

List of all members.

Public Methods
	callNode (exprNode *name, expr_list *args, const Coord coord=Coord::Unknown)
	Create a new function call expression. More...
virtual	~callNode ()
	Destroy a callNode. More...
typeNode *	base_type (bool TdefIndir) const
	Return the base data type of a node. More...
virtual void	eval ()
	Constant expression evaluator. More...
virtual void	dataflow (FlowVal *v, FlowProblem &fp)
	Run the dataflow analyzer. More...
virtual Node *	clone () const
	Clone the input node. More...
virtual void	output_expr (output_context &ct, Node *par, int prec, Assoc assoc)
	Output a expression. More...
Accessors
Methods to get and set fields in the class.
exprNode *	name () const
exprNode *	get_name ()
void	name (exprNode *name)
expr_list &	args ()
const expr_list &	args () const
procNode *	proc () const
void	proc (procNode *proc)
AST Traversal
Methods to uniformly traverse the AST. See the documentation in the Node class.
virtual void	visit (Visitor *the_visitor)
	Dispatch a Visitor. More...
virtual void	walk (Walker &the_walker)
	Dispatch a Walker. More...
virtual Node *	change (Changer &the_changer, bool redispatch=false)
	Dispatch a Changer. More...
Private Attributes
TREE exprNode *	_name
	the expression indicating the function to call. More...
TREE expr_list	_args
	the arguments. More...
REF procNode *	_proc
	the target procedure. More...

---

Detailed Description

Function call expression.

This class represents a function call expression. This includes the actual argument expressions passed into the function, as well as the expression that determines the function to call. Note that this class handles all forms of function call, including calling through a function pointer. That's why the target function is specified as an expression. In most cases, it is simply an identifier whose declaration refers directly to a function definition or declaration (funcNode or the declaration on a procNode).

The callNode object also has a placeholder for a pointer to the target procNode. Initially, this pointer is null. However, we can perform call-graph analysis to determine the target of a callNode. The callgraph_walker does a reasonably job of determining the target, but cannot handle calls through a function pointer.

Currently, no facility exists to make sure that the actual arguments match the number or types of the formal parameters.

The NodeType is Call.

See also:

callgraph_walker , procNode , funcNode

---

Constructor & Destructor Documentation

callNode::callNode (  exprNode *    name, expr_list *    args, const Coord    coord = Coord::Unknown )

Create a new function call expression. The new function call has the given target function expression (name) and the given arguments. The arguments are extracted from the list and the list is deleted. Parameters: name  the expression specifying the target procedure to call args  the list of actual argument expressions coord  the location of the construct in the source file.

callNode::~callNode (    )  [virtual]

Destroy a callNode. Warning: Do not use the destructors to delete AST nodes. Instead, rely on the node garbage collector.

---

Member Function Documentation

const expr_list& callNode::args (    )  const [inline]

expr_list& callNode::args (    )  [inline]

typeNode * callNode::base_type (  bool    TdefIndir )  const [virtual]

Return the base data type of a node. This method differs from the Node::type() method in two respects. First, it follows some of the simple type inferences. For example, calling it on an idNode will return the type of its declaration. Second, the boolean argument indicates whether or not to follow typedef links. Parameters: TdefIndir  pass true to follow typedefs to their definitions. Reimplemented from exprNode.

Node * callNode::change (  Changer &    the_changer, bool    redispatch = false )  [virtual]

Dispatch a Changer. This abstract method works much the walker, but allows the tree to be changed. Parameters: the_changer  the specific Changer object to use. redispatch  pass true to revisit parts of the tree that have changed. Reimplemented from Node.

virtual Node* callNode::clone (    )  const [inline, virtual]

Clone the input node. This is not a "deep" clone, so be careful. For a deep clone, use the clone_changer class. Returns: a shallow copy of the node (no subtrees are copied). Reimplemented from Node.

void callNode::dataflow (  FlowVal *    v, FlowProblem &    fp )  [virtual]

Run the dataflow analyzer. Each subclass overrides this method to define it's semantics for dataflow analysis. It alters the input flow value to reflect the effect of the node within the given flow problem, calling dataflow() on it's subtrees as necessary. See the dataflow analysis documentation for more information. Parameters: v  the flow value to pass through the node. fp  the flow problem (specifying the transfer functions). Reimplemented from Node.

void callNode::eval (    )  [virtual]

Constant expression evaluator. This method attempts to evaluate an expression at compile-time. This only yields a meaningful value when the leaves of the given expression are constants, enums, or other compile-time values (e.g., sizeof). The resulting value is stored on each exprNode, in the _value field. Each exprNode sublcass implements this method, calling it recursively when necessary. Reimplemented from exprNode.

exprNode* callNode::get_name (    )  [inline]

void callNode::name (  exprNode *    name )  [inline]

exprNode* callNode::name (    )  const [inline]

void callNode::output_expr (  output_context &    ct, Node *    parent, int    prec, Assoc    assoc )  [virtual]

Output a expression. Reimplemented from exprNode.

void callNode::proc (  procNode *    proc )  [inline]

procNode* callNode::proc (    )  const [inline]

void callNode::visit (  Visitor *    the_visitor )  [virtual]

Dispatch a Visitor. This abstract method is the entry point for the visitor design pattern. Each node subclass defines a visit() method that calls the appropriate at_ method in the visitor. For more information see the Visitor documentation. Parameters: the_visitor  the specific Visitor object to use. Reimplemented from Node.

void callNode::walk (  Walker &    the_walker )  [virtual]

Dispatch a Walker. This abstract method works much like the visitor, but instead walks the entire underlying subtree calling the appropriate at_ method at each node. For more information see the Walker documentation. Parameters: the_walker  the specific Walker object to use. Reimplemented from Node.

---

Member Data Documentation

TREE expr_list callNode::_args [private]

the arguments. The arguments are maintained in the order they appear in the input source.

TREE exprNode* callNode::_name [private]

the expression indicating the function to call.

REF procNode* callNode::_proc [private]

the target procedure. Initially, this pointer is null, but can be populated by calling one of the call graph facilities. The callgraph_walker works fairly well, but can only handle simple calls where the target function is given explicitly. See also: callgraph_walker

---

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

• ast.h
• callnode.cc

---