cpattern.h

Go to the documentation of this file.

#ifndef BDWY_CPATTERN_H
#define BDWY_CPATTERN_H

class exprPatternNode;
class stmtPatternNode;
class typePatternNode;

// ----------------------------------------------------------------------
//  Expression pattern node
// ----------------------------------------------------------------------

class exprPatternNode : public exprNode
{
private:

  string _name;

  REF annVariable * _variable;

public:

  exprPatternNode(const parserID * var);


  inline string & name() { return _name; }
  inline const string & name() const { return _name; }
  inline void name(string nm) { _name = nm; }

  inline annVariable * variable() const { return _variable; }
  inline void variable(annVariable *variable) { _variable = variable; }


  void lookup(procedureAnn * procedure,
              Annotations * annotations);

  virtual void eval() {}


  virtual void visit(Visitor * the_visitor);
  virtual void walk(Walker & the_walker);
  virtual Node * change(Changer & the_changer, bool redispatch = false);


  // -- Dataflow (No-op)

  virtual void dataflow(FlowVal * v, FlowProblem & fp) {}

  // -- Clone

  virtual Node * clone() const { return new exprPatternNode ( *this ); }

  // -- Output

  virtual void output_expr(output_context & ct, Node * par, int prec, Assoc assoc);
};

// ----------------------------------------------------------------------
//  Statement pattern node
// ----------------------------------------------------------------------

class stmtPatternNode : public stmtNode
{
private:

  string _name;

  REF annVariable * _variable;

public:

  stmtPatternNode(const parserID * var);


  inline string & name() { return _name; }
  inline const string & name() const { return _name; }
  inline void name(string nm) { _name = nm; }

  inline annVariable * variable() const { return _variable; }
  inline void variable(annVariable *variable) { _variable = variable; }


  void lookup(procedureAnn * procedure,
              Annotations * annotations);


  virtual void visit(Visitor * the_visitor);
  virtual void walk(Walker & the_walker);
  virtual Node * change(Changer & the_changer, bool redispatch = false);


  // -- Dataflow (No-op)

  virtual void dataflow(FlowVal * v, FlowProblem & fp) {}

  // -- Clone

  virtual Node * clone() const { return new stmtPatternNode ( *this ); }

  // -- Output 

  virtual void output_stmt(output_context & ct, Node * par);
};

// ----------------------------------------------------------------------
//  Type pattern node
// ----------------------------------------------------------------------

class typePatternNode : public typeNode
{
private:

  string _name;

  REF annVariable * _variable;

public:

  typePatternNode(const parserID * var);


  inline string & name() { return _name; }
  inline const string & name() const { return _name; }
  inline void name(string nm) { _name = nm; }

  inline annVariable * variable() const { return _variable; }
  inline void variable(annVariable *variable) { _variable = variable; }


  void lookup(procedureAnn * procedure,
              Annotations * annotations);

  bool qualified_equal_to(typeNode * node2,
                          bool strict_toplevel, bool strict_recursive)
  { return false; }


  virtual void visit(Visitor * the_visitor);
  virtual void walk(Walker & the_walker);
  virtual Node * change(Changer & the_changer, bool redispatch = false);


  // -- Clone

  virtual Node * clone() const { return new typePatternNode ( *this ); }

  // -- Output

  virtual void output_type(output_context & ct, Node * par, Assoc context, Type_qualifiers q);

};

// ----------------------------------------------------------------------
//  Pattern expander
// ----------------------------------------------------------------------

class callsiteEntry;

class patternExpander : public Changer
{
private:

  callsiteEntry * _callsite;

  propertyAnalyzer * _analyzer;

  Annotations * _annotations;

public:

  patternExpander(callsiteEntry * callsite,
                  propertyAnalyzer * analyzer,
                  Annotations * annotations);

  virtual Node * at_expr(exprNode * the_expr, Order ord);
  virtual Node * at_stmt(stmtNode * the_stmt, Order ord);
  virtual Node * at_type(typeNode * the_type, Order ord);
};

#endif /* BDWY_CPATTERN_H */