---

ast.h

Go to the documentation of this file.

// ----------------------------------------------------------------------
//
//  C-Breeze
//  C Compiler Framework
// 
//  Copyright (c) 2000 University of Texas at Austin
// 
//  Samuel Z. Guyer
//  Daniel A. Jimenez
//  Calvin Lin
// 
//  Permission is hereby granted, free of charge, to any person
//  obtaining a copy of this software and associated documentation
//  files (the "Software"), to deal in the Software without
//  restriction, including without limitation the rights to use, copy,
//  modify, merge, publish, distribute, sublicense, and/or sell copies
//  of the Software, and to permit persons to whom the Software is
//  furnished to do so, subject to the following conditions:
//  
//  The above copyright notice and this permission notice shall be
//  included in all copies or substantial portions of the Software.
//  
//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
//  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
//  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
//  NONINFRINGEMENT.  IN NO EVENT SHALL THE UNIVERSITY OF TEXAS AT
//  AUSTIN BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
//  IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
//  OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
//  THE SOFTWARE.
//
//  We acknowledge the C-to-C Translator from MIT Laboratory for
//  Computer Science for inspiring parts of the C-Breeze design.
//
// ----------------------------------------------------------------------

#ifndef CBZ_AST_H
#define CBZ_AST_H


// -- REF and TREE are empty defines for information only

#define REF
#define TREE

 */

class Node
{

private:

  NodeType     _typ;

  Coord        _coord;

  bool         _parenthesized;

  annote_list  _annotations;

  FlowVal * _gen;

  FlowVal * _kill;


  int _uid;

  static int _count;

  static int _t_count[50];

  static int _uid_count;


public:


  static node_list nodes;

  static map <Node *, bool> deleted_nodes;

  bool mark;


  Node(NodeType typ, const Coord coord, bool parenthesized = false);

  Node(const Node & other);

  virtual ~Node();


  inline NodeType typ() const { return _typ; }

  inline Coord coord() const { return _coord; }

  inline void coord(const Coord coord) { _coord = coord; }

  inline bool parenthesized() const { return _parenthesized; }

  inline void parenthesized(bool paren) { _parenthesized = paren; }

  inline annote_list & annotations() { return _annotations; }

  inline FlowVal * gen() const { return _gen; }

  inline void gen(FlowVal * g) { _gen = g; }

  inline FlowVal * kill() const { return _kill; }

  inline void kill(FlowVal * k) { _kill = k; }


  static void report();

  virtual typeNode * type() const { return 0; }

  virtual typeNode * base_type(bool TdefIndir) const;

  typeNode * datatype() const;

  typeNode * datatype_superior() const;


  virtual void visit(Visitor * the_visitor) =0;

  virtual void walk(Walker & the_walker) =0;

  virtual Node * change(Changer & the_changer, bool redispatch = false) =0;


  virtual void dataflow(FlowVal * v, FlowProblem & fp) =0;

  virtual Node * clone() const =0;

  virtual void output(output_context & ct, Node * par) =0;
};

class unitNode : public Node
{

private:

  TREE def_list _defs;

  int _symbol_level;

  Identifiers_table * _types;

  Tags_table * _tags;

  string _input_file;

  string _output_file;

  int _errors;

  int _warnings;

  TREE decl_list _undef_funcs; 

  // -- Maintain a global list of all struct/enum/union. This means
  // that the spec component of a sueNode is never a part of the TREE.

  TREE suespec_list _suespecs;

  FILE * _open_input_file(str_list * cpp_flags);
  
public:

  unitNode(string input_file, string output_file,
           const Coord coord = Coord::Unknown);

  virtual ~unitNode();

  void parse(str_list * cpp_flags);

  void fixup();
  

  // -- Fields

  inline def_list & defs() { return _defs; }
  inline const def_list & defs() const { return _defs; }

  inline int symbol_level() const { return _symbol_level; }
  inline Identifiers_table * types() const { return _types; }
  inline Tags_table * tags() const { return _tags; }

  inline string & input_file() { return _input_file; }
  inline string & output_file() { return _output_file; }

  inline int errors() const { return _errors; }
  inline void inc_errors() { ++_errors; }

  inline int warnings() const { return _warnings; }
  inline void inc_warnings() { ++_warnings; }

  inline decl_list & undef_funcs() { return _undef_funcs; }

  inline suespec_list & suespecs() { return _suespecs; }


  // -- Merge in definitions...
  // NOTE: the defs is deleted

  void merge_in(def_list * defs) {
   _defs.splice(_defs.end(), * defs); delete defs; }

  void enter_scope();

  void exit_scope();


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


  // -- Dataflow

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

  // -- Clone

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

  // -- Output

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

class defNode : public Node
{
private:

  text_list _pragmas;

public:

  defNode(NodeType typ, const Coord coord);


  inline text_list & pragmas() { return _pragmas; }


  virtual ~defNode();
};

class declNode : public defNode
{

public:

  typedef enum {
    UNKNOWN,  
    TOP,      
    BLOCK,    
    FORMAL,   
    SU,       
    ENUM,     
    PROC      
  } Decl_location;

  typedef enum {
    NONE, AUTO, EXTERN, REGISTER, STATIC, TYPEDEF
  } Storage_class;


  static string storage_class_name(Storage_class sc);

  static string decl_location_name(Decl_location dl);

  // @}

private:

  TREE typeNode * _type;

  string _name;

  Decl_location _decl_location;

  Storage_class _storage_class;

  bool _is_redundant_extern;

  TREE exprNode * _init;

  TREE exprNode * _bitsize;

  int _references;

  TREE attrib_list _attribs;

public:

  declNode(const char * name, Storage_class sc, typeNode * the_type, 
           exprNode * init, exprNode * bitsize,
           const Coord coord = Coord::Unknown);


  declNode(idNode * id, Storage_class sc, typeNode * the_type, 
           exprNode * init, exprNode * bitsize);

  declNode(idNode * name, exprNode * value);

  declNode(typeNode * the_type, Storage_class sc);


  virtual ~declNode();


  inline typeNode * type() const { return _type; }

  inline typeNode * get_type() { typeNode * out = _type; _type = 0; return out; }

  inline void type(typeNode * the_type) { _type = the_type; }

  inline string & name() { return _name; }

  inline void name(string name) { _name = name; }

  inline Decl_location decl_location() const { return _decl_location; }
'

  inline void decl_location(Decl_location loc) { _decl_location = loc; }

  inline Storage_class storage_class() const { return _storage_class; }

  inline void storage_class(Storage_class sc) { _storage_class = sc; }

  inline bool is_redundant_extern() const { return _is_redundant_extern; }

  inline void set_redundant_extern(bool v) { _is_redundant_extern = v; }

  inline void inc_references() { _references++; }

  inline exprNode * init() const { return _init; }

  void init(exprNode * init) { _init = init; }

  inline exprNode * bitsize() const { return _bitsize; }

  inline void bitsize(exprNode * bitsize) { _bitsize = bitsize; }

  inline int references() const { return _references; }

  inline void references(int references) { _references = references; }

  inline attrib_list & attribs() { return _attribs; }

  inline const attrib_list & attribs() const { return _attribs; }

  void merge_attribs(attrib_list * attribs);



  //    Was SetDeclType in complex-types.c

  void       set_type(typeNode * the_type, Storage_class sc, ScopeState redeclare);
  declNode * set_type_and(typeNode * the_type, Storage_class sc, ScopeState redeclare);
  declNode * set_type_and(declNode * the_decltype, Storage_class sc, ScopeState redeclare);

  //    Was AppendDecl in complex-types.c

  void       inherit_type(decl_list * others, ScopeState redeclare);
  declNode * inherit_type_and(decl_list * others, ScopeState redeclare);

  //    Was ModifyType in complex-types.c

  void       modify_type(typeNode * the_type);
  declNode * modify_type_and(typeNode * the_type);
  declNode * modify_type_and(declNode * the_type);

  //    Was SetDeclInit in complex-types.c

  void       set_init(exprNode * init);
  declNode * set_init_and(exprNode * init);

  //    Was AddParameterTypes in procedure.c

  void       add_parameter_types(decl_list * types);
  declNode * add_parameter_types_and(decl_list * types);

  //    FinishDecl in complex-types.c

  void       finish(Storage_class sc);
  declNode * finish_and(Storage_class sc);


  // -- Data type base

  typeNode * base_type(bool TdefIndir) const;

  typeNode * no_tdef_type();

  virtual declNode * original() { return this; }


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


  // -- Dataflow

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

  // -- Clone

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

  // -- Output

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

class subdeclNode : public declNode
{
private:

  REF declNode * _original;
  int _index;

public:

  subdeclNode(declNode * orig, int index);

  virtual ~subdeclNode();


  virtual declNode * original() { return _original->original(); }
  int index() const { return _index; }


  string name_with_index();


  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 subdeclNode ( *this ); }

  // -- Output

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

class procNode : public defNode
{

private:

  TREE declNode * _decl;

  TREE blockNode * _body;

  static procNode * _current;



  FlowVal * _at_entry;
  FlowVal * _at_exit;


public:

  procNode(declNode * decl, blockNode * body,
           const Coord coord = Coord::Unknown);

  procNode(bool old_style, declNode * decl);

  virtual ~procNode();



  inline declNode * decl() const { return _decl; }

  inline declNode * get_decl() { declNode * out = _decl; _decl = 0; return out; }

  inline void decl(declNode * decl) { _decl = decl; }

  inline blockNode * body() const { return _body; }

  inline blockNode * get_body() { blockNode * out = _body; _body = 0; return out; }

  inline void body(blockNode * body) { _body = body; }

  // -- Flow values (for IP analyzer)

  inline FlowVal * at_entry() const { return _at_entry; }

  inline void at_entry(FlowVal * ae) { _at_entry = ae; }

  inline FlowVal * at_exit() const { return _at_exit; }

  inline void at_exit(FlowVal * ae) { _at_exit = ae; }



  basicblockNode * entry() const;

  basicblockNode * exit() const;



  // -- DefineProc in procedure.c

  void       define(blockNode * body); 
  procNode * define_and(blockNode * body); 

  static procNode * current() { return _current; }


  // -- Data type base

  typeNode * base_type(bool TdefIndir) const;


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


  // -- Dataflow

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

  // -- Clone

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

  // -- Output

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

class typeNode : public Node
{

public:

  typedef enum {
    NONE     = 0x0,     
    CONST    = 0x1,     
    VOLATILE = 0x2,     
    INLINE   = 0x4,     
    COMPATIBLE = 0x3    
  } Type_qualifiers;

  static string type_qualifiers_name(Type_qualifiers tq);

  static typeNode * integral_promotions(typeNode * old_type);

  static pair<typeNode *, typeNode *> usual_arithmetic_conversions(typeNode * left,
                                                                   typeNode * right);

private:

  TREE typeNode * _type;

  Type_qualifiers _type_qualifiers;

public:

  typeNode(NodeType typ, Type_qualifiers tq, typeNode * subtype,
           const Coord coord);

  virtual ~typeNode();


  inline typeNode * type() const { return _type; }

  inline typeNode * get_type() { typeNode * out = _type; _type = 0; return out; }

  inline void type(typeNode * the_type) { _type = the_type; }

  inline Type_qualifiers type_qualifiers() const { return _type_qualifiers; }

  inline void type_qualifiers(Type_qualifiers the_tq) { _type_qualifiers = the_tq; }

  inline string type_qualifiers_name() { return type_qualifiers_name(type_qualifiers()); }

  inline void add_type_qualifiers(Type_qualifiers the_tq)
  { _type_qualifiers = Type_qualifiers(_type_qualifiers | the_tq); }

  inline typeNode * add_type_qualifiers_and(Type_qualifiers the_tq)
  { add_type_qualifiers(the_tq); return this; }

  inline void remove_type_qualifiers(Type_qualifiers the_tq)
  { _type_qualifiers = Type_qualifiers(_type_qualifiers & ~the_tq); }



  void       finish();
  typeNode * finish_and();

  // -- Set base type
  //    Was SetBaseType from complex-types.c

  void       set_base_type(typeNode * base);
  typeNode * set_base_type_and(typeNode * base);

  // -- SUE complete

  void verify_sue_complete();



  bool operator==(typeNode & second) {
    return equal_to(this, & second, true, true); }

  bool operator<=(typeNode & second) {
    return equal_to(this, & second, false, false); }

  bool operator!=(typeNode & second) {
    return ! ( (*this) == second ); }


  static bool equal_to(typeNode * first, typeNode * second,
                       bool strict_toplevel, bool strict_recursive);

  virtual bool qualified_equal_to(typeNode * other,
                                  bool strict_toplevel, bool strict_recursive);

  typeNode * unwind_tdefs(Type_qualifiers & the_tq);

  typeNode * no_tdef_type();

  typeNode * follow_tdefs();


  virtual bool is_int() const { return false; }
  virtual bool is_char() const { return false; }
  virtual bool is_float() const { return false; }
  virtual bool is_void() const { return false; }
  virtual bool is_ellipsis() const { return false; }

  virtual bool is_integer() const { return false; }
  virtual bool is_arithmetic() const { return false; }
  virtual bool is_scalar() const { return false; }
  virtual bool is_aggregate() const { return false; }
  virtual bool is_derived() const { return false; }
  virtual bool is_pointer() const { return false; }


  virtual typeNode * usual_unary_conversion_type() { return this; }

  // -- Data type base

  virtual typeNode * base_type(bool TdefIndir) const {
    return (typeNode *)this; }

  // -- Deep base type

  typeNode * deep_base_type();

  // -- Dataflow
  //    Note: All type nodes share a no-op dataflow function

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

  // -- Output

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

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

class primNode : public typeNode
{

private:

  basic_type _basic;

public:

  primNode(Type_qualifiers tq, basic_type basic,
           const Coord coord = Coord::Unknown);

  primNode(Type_qualifiers tq,
           const Coord coord = Coord::Unknown);

  primNode(const Coord coord);

  primNode(basic_type basic, const Coord coord = Coord::Unknown);

  virtual ~primNode();


  //    Return a reference so basic_type can be modified...

  inline const basic_type & basic() const { return _basic; }
  inline basic_type & basic() { return _basic; }
  inline void basic(basic_type basic) { _basic = basic; }


  // -- FinishPrimType from type.c

  void       finish();
  primNode * finish_and();

  // -- MergePrimTypes from type.c (other is deleted)

  void       merge_in(primNode * other);
  primNode * merge_in_and(primNode * other);



  virtual bool is_int() const      { return _basic.is_int(); }
  virtual bool is_char() const     { return _basic.is_char(); }
  virtual bool is_float() const    { return _basic.is_float(); }
  virtual bool is_void() const     { return _basic.is_void(); }
  virtual bool is_ellipsis() const { return _basic.is_ellipsis(); }

  virtual bool is_integer() const  { return _basic.is_integer(); }
  virtual bool is_arithmetic() const { return _basic.is_arithmetic(); }
  virtual bool is_scalar() const   { return _basic.is_scalar(); }


  // -- Type equal

  bool qualified_equal_to(typeNode * node2,
                          bool strict_toplevel, bool strict_recursive);


  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 primNode ( *this ); }

  // -- Output

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

class tdefNode : public typeNode
{

private:

  string _name;

  REF typeNode * _def;

public:

  tdefNode(Type_qualifiers tq, const char * name,
           const Coord coord = Coord::Unknown);

  tdefNode(idNode * the_id, Type_qualifiers tq, typeNode * the_type);

  virtual ~tdefNode();


  inline string & name() { return _name; }

  inline void name(string name) { _name = name; }

  inline typeNode * def() const { return _def; }

  inline void def(typeNode * d) { _def = d; }


  // -- Data type base

  typeNode * base_type(bool TdefIndir) const;

  // -- Data type predicates


  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 tdefNode ( *this ); }

  // -- Output

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

class ptrNode : public typeNode
{

private:

public:

  ptrNode(Type_qualifiers tq, typeNode * the_type,
          const Coord coord = Coord::Unknown);

  virtual ~ptrNode();

  // -- Type equal

  bool qualified_equal_to(typeNode * node2,
                          bool strict_toplevel, bool strict_recursive);


  virtual bool is_scalar() const { return true; }
  virtual bool is_derived() const { return true; }
  virtual bool is_pointer() const { return true; }



  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 ptrNode ( *this ); }

  // -- Output

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

class arrayNode : public typeNode
{

private:

  TREE exprNode * _dim;

  int _size;

public:

  arrayNode(Type_qualifiers tq, typeNode * the_type, exprNode * the_dim,
           const Coord coord = Coord::Unknown);

  virtual ~arrayNode();


  inline exprNode * dim() const { return _dim; }
  inline exprNode * get_dim() { exprNode * out = _dim; _dim = 0; return out; }
  inline void dim(exprNode * the_dim) { _dim = the_dim; }

  inline int size() const { return _size; }
  inline void size(int the_size) { _size = the_size; }



  virtual bool is_aggregate() const { return true; }
  virtual bool is_derived() const { return true; }
  virtual bool is_pointer() const { return true; }

  // an array will be seen as a pointer (thus a scalar)
  // if it has no dimension, e.g., is a parameter

  virtual bool is_scalar() const { return _dim == NULL; }
  
  bool is_string() const;


  // -- Type equal

  bool qualified_equal_to(typeNode * node2,
                          bool strict_toplevel, bool strict_recursive);


  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 arrayNode ( *this ); }

  // -- Output

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

class funcNode : public typeNode
{

private:

  TREE decl_list _args;

  bool _is_knr;

public:

  funcNode(Type_qualifiers tq, decl_list * args, typeNode * returns,
           const Coord coord = Coord::Unknown);

  virtual ~funcNode();


  inline decl_list & args() { return _args; }
  inline const decl_list & args() const { return _args; }

  inline typeNode * returns() const { return type(); }
  inline void returns(typeNode * returns) { type(returns); }

  inline bool is_knr() const { return _is_knr; }
  inline void is_knr (bool v) { _is_knr = v; }


  // -- Type equal

  bool qualified_equal_to(typeNode * node2,
                          bool strict_toplevel, bool strict_recursive);


  virtual bool is_derived() const { return true; }
  virtual bool is_pointer() const { return true; }


  bool is_void_args();

  bool check_conversions();

  bool is_compatible_with(funcNode * nfunc);

  void add_parameter_types(decl_list * types);


  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 funcNode ( *this ); }

  // -- Output

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

class sueNode : public typeNode
{

private:

  REF suespecNode * _spec;

  bool _elaborated;

public:

  sueNode(NodeType typ, const Coord coord);

  virtual ~sueNode();


  inline bool elaborated() const { return _elaborated; }
  inline void elaborated(bool elab) { _elaborated = elab; }

  inline suespecNode * spec() const { return _spec; }
  inline void spec(suespecNode * s) { _spec = s; }



  // --- Was SetSUdclNameFields from sue.c

  void      set_name_fields(idNode *id, decl_list * fields, 
                            const Coord left_coord,
                            const Coord the_right_coord);

  sueNode * set_name_fields_and(idNode *id, decl_list * fields, 
                                const Coord left_coord,
                                const Coord the_right_coord);

  // -- Was SetSUdclName in sue.c

  void      set_name(idNode * id, const Coord coord);
  sueNode * set_name_and(idNode * id, const Coord coord);

  // -- ForceNewSU in sue.c

  void      force_new(const Coord coord);
  sueNode * force_new_and(const Coord coord);

  // -- Tags

  bool same_tag_as(sueNode * other);
  void tag_conflict(sueNode * new_sue); // from sue.c


  // -- Type equal

  bool qualified_equal_to(typeNode * node2,
                          bool strict_toplevel, bool strict_recursive);

  // -- Data type predicates

  // -- Output

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

class structNode : public sueNode
{

private:

public:

  structNode(const Coord coord = Coord::Unknown);

  virtual ~structNode();


  virtual bool is_aggregate() const { return true; }



  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 structNode ( *this ); }
};

class unionNode : public sueNode
{

private:

public:

  unionNode(const Coord coord = Coord::Unknown);

  virtual ~unionNode();


  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 unionNode ( *this ); }
};

class enumNode : public sueNode
{

private:

public:

  enumNode(const Coord coord = Coord::Unknown);

  enumNode(idNode *id, decl_list * values, 
           const Coord enum_coord, const Coord left_coord,
           const Coord right_coord);

  virtual ~enumNode();


  virtual bool is_int() const { return true; }
  virtual bool is_integer() const { return true; }
  virtual bool is_arithmetic() const { return true; }
  virtual bool is_scalar() const { return true; }



  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 enumNode ( *this ); }
};

class suespecNode : public typeNode
{

private:

  string _name;

  TREE decl_list _fields;

  bool _complete;

  bool _visited;

  bool _already_output;

  int _scope_output;

  int _size;

  int _align;

  NodeType _owner;

public:

  suespecNode(const char * name, decl_list * fields, NodeType owner,
              unitNode * the_unit,
              const Coord coord);

  virtual ~suespecNode();


  inline bool complete() const { return _complete; }
  inline void complete(bool comp) { _complete = comp; }

  inline bool visited() const { return _visited; }
  inline void visited(bool v) { _visited = v; }

  inline bool already_output() const { return _already_output; }
  inline void already_output(bool v) { _already_output = v; }

  inline bool scope_output() const { return _scope_output; }
  inline void scope_output(int v) { _scope_output = v; }

  inline int size() const { return _size; }
  inline void size(int size) { _size = size; }

  inline int align() const { return _align; }
  inline void align(int align) { _align = align; }

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

  inline decl_list & fields() { return _fields; }
  inline const decl_list & fields() const { return _fields; }

  inline NodeType owner() const { return _owner; }


  // -- Tags and fields

  bool same_tag_as(suespecNode * other);

  void update(decl_list * fields, sueNode * sue, const Coord right);

  declNode * find_field(const string & name);


  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 suespecNode ( *this ); }

  // -- Output

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


class exprNode : public Node
{
public:

  static exprNode * integral_promotions(exprNode * old_expr);

  static pair<exprNode *, exprNode *>
    usual_arithmetic_conversions(exprNode * left,
                                 exprNode * right);

private:

  TREE typeNode * _type;

  constant _value;

public:

  exprNode(NodeType typ, typeNode * type, const Coord coord);

  virtual ~exprNode();


  inline typeNode * type() const { return _type; }
  inline typeNode * get_type() { typeNode * out = _type; _type = 0; return out; }
  inline void type(typeNode *type) { _type = type; }

  inline const constant & value() const { return _value; }
  inline constant & value() { return _value; }
  inline void value(const constant & newval) { _value = newval; }


  // -- Data type base

  virtual typeNode * base_type(bool TdefIndir) const;

  // -- Symbol lookup
  // LookupPostfixExpression in type.c

  // virtual void lookup() {  } // -- Default; do nothing

  // -- Type conversions
  // THESE ARE NOT USED
  // exprNode * assignment_conversions(typeNode * to_type);
  // exprNode * call_conversions(typeNode * to_type);
  // exprNode * return_conversions(typeNode * to_type);
  // exprNode * cast_conversions(typeNode * to_type);
  // exprNode * usual_unary_conversions(typeNode * to_type, bool f_to_d);
  // exprNode * usual_binary_conversions(typeNode * to_type);

  virtual void eval() =0;

  virtual bool is_lvalue() { return true; } // THIS IS A TBD

  typeNode * no_tdef_type() { return type()->follow_tdefs(); }

  // -- Output

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

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

  virtual int precedence(Assoc & assoc);

  bool parens(int outer_prec, Assoc outer_assoc);
};

class constNode : public exprNode
{

private:

  string _text;

public:

  constNode(constant value, const char * text = "",
            const Coord coord = Coord::Unknown);

  virtual ~constNode();


  inline string & text() { return _text; }


  typeNode * usual_unary_conversion_type() 
      { return type()->usual_unary_conversion_type(); }

  // -- Constant folding

  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

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

  // -- Clone

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

  // -- Output

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

class idNode : public exprNode
{

private:

  string _name;

  REF declNode * _decl;

public:

  idNode(const char * text, const Coord coord = Coord::Unknown);

  idNode(declNode * the_decl, const Coord coord = Coord::Unknown);

  virtual ~idNode();


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

  inline declNode * decl() const { return _decl; }
  inline void decl(declNode *decl) { _decl = decl; }


  // -- Data type base

  typeNode * base_type(bool TdefIndir) const;

  // -- Symbol lookup

  // virtual void lookup();
  // idNode * lookup_and();

  // -- Constant folding

  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

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

  // -- Clone

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

  // -- Output

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

class binaryNode : public exprNode
{

private:

  Operator * _op;

  TREE exprNode * _left;

  TREE exprNode * _right;

public:

  binaryNode(unsigned int op_id, exprNode * left, exprNode * right,
             const Coord coord = Coord::Unknown);

  virtual ~binaryNode();


  inline Operator * op() const { return _op; }
  inline void op(Operator * op) { _op = op; }

  inline exprNode * left() const { return _left; }
  inline exprNode * get_left() { exprNode * out = _left; _left = 0; return out; }
  inline void left(exprNode * left) { _left = left; }

  inline exprNode * right() const { return _right; }
  inline exprNode * get_right() { exprNode * out = _right; _right = 0; return out; }
  inline void right(exprNode * right) { _right = right; }


  // -- Symbol lookup

  // virtual void lookup();

  // -- Constant folding

  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

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

  // -- Clone

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

  // -- Output

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

class unaryNode : public exprNode
{

private:

  Operator * _op;

  TREE exprNode * _expr;

  TREE typeNode * _sizeof_type;

public:

  unaryNode(unsigned int op_id, exprNode * expr,
            const Coord coord = Coord::Unknown);

  unaryNode(unsigned int op_id, typeNode * the_type,
            const Coord coord = Coord::Unknown);

  virtual ~unaryNode();


  inline Operator * op() const { return _op; }
  inline void op(Operator * op) { _op = op; }

  inline exprNode * expr() const { return _expr; }
  inline exprNode * get_expr() { exprNode * out = _expr; _expr = 0; return out; }
  inline void expr(exprNode * expr) { _expr = expr; }

  //    sizeof_type is only used if the operation is "sizeof()"

  inline typeNode * sizeof_type() const { return _sizeof_type; }
  inline typeNode * get_sizeof_type() 
  { typeNode * out = _sizeof_type; _sizeof_type = 0; return out; }
  inline void sizeof_type(typeNode *sizeof_type)
  { _sizeof_type = sizeof_type; }


  // -- Symbol lookup

  // virtual void lookup();

  // -- Constant folding

  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

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

  // -- Clone

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

  // -- Output

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

class castNode : public exprNode
{

private:

  TREE exprNode * _expr;

  bool _implicit;

public:

  castNode(typeNode * type, exprNode * expr, bool implicit = false,
           const Coord coord = Coord::Unknown);

  virtual ~castNode();


  inline exprNode * expr() const { return _expr; }
  inline exprNode * get_expr() { exprNode * out = _expr; _expr = 0; return out; }
  inline void expr(exprNode * expr) { _expr = expr; }

  inline bool is_implicit() const { return _implicit; }

  // -- Constant folding

  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

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

  // -- Clone

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

  // -- Output

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


class commaNode : public exprNode
{

private:

  TREE expr_list _exprs;

public:

  commaNode(expr_list * exprs, const Coord coord = Coord::Unknown);

  commaNode(const Coord coord = Coord::Unknown);

  virtual ~commaNode();


  inline expr_list & exprs() { return _exprs; }
  inline const expr_list & exprs() const { return _exprs; }


  // -- Data type base

  typeNode * base_type(bool TdefIndir) const;

  // -- Constant folding

  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

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

  // -- Clone

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

  // -- Output

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

class ternaryNode : public exprNode
{

private:

  TREE exprNode * _cond;

  TREE exprNode * _true_br;

  TREE exprNode * _false_br;

  Coord _colon_coord;

public:

  ternaryNode(exprNode * cond, exprNode * true_br, exprNode * false_br,
              const Coord qmark_coord = Coord::Unknown,
              const Coord colon_coord = Coord::Unknown);

  virtual ~ternaryNode();


  inline exprNode * cond() const { return _cond; }
  inline exprNode * get_cond() { exprNode * out = _cond; _cond = 0; return out; }
  inline void cond(exprNode * cond) { _cond = cond; }

  inline exprNode * true_br() const { return _true_br; }
  inline exprNode * get_true_br() { exprNode * out = _true_br; _true_br = 0; return out; }
  inline void true_br(exprNode * true_br) { _true_br = true_br; }

  inline exprNode * false_br() const { return _false_br; }
  inline exprNode * get_false_br() { exprNode * out = _false_br; _false_br = 0; return out; }
  inline void false_br(exprNode * false_br) { _false_br = false_br; }


  // -- Constant folding

  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

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

  // -- Clone

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

  // -- Output

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

class callNode : public exprNode
{

private:

  TREE exprNode * _name;

  TREE expr_list _args;

  REF procNode * _proc;

public:

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

  virtual ~callNode();


  inline exprNode * name() const { return _name; }
  inline exprNode * get_name() { exprNode * out = _name; _name = 0; return out; }
  inline void name(exprNode * name) { _name = name; }

  inline expr_list & args() { return _args; }
  inline const expr_list & args() const { return _args; }

  inline procNode * proc() const { return _proc; }
  inline void proc(procNode * proc) { _proc = proc; }


  // -- Data type base

  typeNode * base_type(bool TdefIndir) const;

  // -- Symbol lookup

  // virtual void lookup();

  // -- Constant folding

  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

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

  // -- Clone

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

  // -- Output

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

class initializerNode : public exprNode
{

private:

  TREE expr_list _exprs;

public:

  // -- Constructors

  initializerNode(expr_list * exprs, const Coord coord = Coord::Unknown);

  virtual ~initializerNode();


  inline expr_list & exprs() { return _exprs; }
  inline const expr_list & exprs() const { return _exprs; }
  inline void add_expr(exprNode * the_expr) { _exprs.push_back(the_expr); }


  // -- Constant folding

  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

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

  // -- Clone

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

  // -- Output

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

class stmtNode : public Node
{

private:

  FlowVal * _at_exit;

  string _comment;

  text_list _pragmas;

public:

  stmtNode(NodeType typ, const Coord coord);

  virtual ~stmtNode();


  inline string & comment() { return _comment; }

  // -- Dataflow

  inline FlowVal * at_exit() const { return _at_exit; }
  inline void at_exit(FlowVal * ae) { _at_exit = ae; }

  // -- Pragmas

  inline text_list & pragmas() { return _pragmas; }


  // -- Output

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

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

  void output_comment(output_context & ct);
};

class blockNode : public stmtNode
{

public:

  static blockNode * toBlock(stmtNode * stmt, Coord coord);

private:

  TREE decl_list _decls;

  TREE stmt_list _stmts;

  Coord _right_brace;
  // TREE typeNode * _type; Why does block have a type?

public:

  blockNode(decl_list * decls, stmt_list * stmts,
            const Coord left_coord = Coord::Unknown,
            const Coord right_brace = Coord::Unknown);

  virtual ~blockNode();


  inline decl_list & decls() { return _decls; }
  inline const decl_list & decls() const { return _decls; }

  inline stmt_list & stmts() { return _stmts; }
  inline const stmt_list & stmts() const { return _stmts; }

  inline Coord right_brace() const { return _right_brace; }
  inline void right_brace(const Coord right_brace) { _right_brace = right_brace; }


  // -- Data type base

  typeNode * base_type(bool TdefIndir) const;


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


  // -- Dataflow

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

  // -- Clone

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

  // -- Output 
  virtual void output_stmt(output_context & ct, Node * par);

};

class algorithm_info
{
};

class basicblockNode : public blockNode {

private:

  basicblock_list _preds;

  basicblock_list _succs;

  basicblockNode * _parent;

  basicblock_list _children;

  algorithm_info * _info;

  int _dfn;

  FlowVal * _at_entry;

  FlowVal * _at_exit;

public:

  basicblockNode(decl_list * decls, stmt_list * stmts,
            const Coord left_coord = Coord::Unknown,
            const Coord right_brace = Coord::Unknown);

  virtual ~basicblockNode();


  inline basicblock_list & preds() { return _preds; }
  inline const basicblock_list & preds() const { return _preds; }

  inline basicblock_list & succs() { return _succs; }
  inline const basicblock_list & succs() const { return _succs; }

  inline basicblockNode * parent() const { return _parent; }
  inline void parent(basicblockNode *par) { _parent = par; }

  inline basicblock_list & children() { return _children; }
  inline const basicblock_list & children() const { return _children; }

  inline algorithm_info * info() const { return _info; }
  inline void info(algorithm_info * i) { _info = i; }

  inline int dfn() const { return _dfn; }
  inline void dfn(int d) { _dfn = d; }

  // -- Flow values (for IP analyzer)

  inline FlowVal * at_entry() const { return _at_entry; }
  inline void at_entry(FlowVal * ae) { _at_entry = ae; }

  inline FlowVal * at_exit() const { return _at_exit; }
  inline void at_exit(FlowVal * ae) { _at_exit = ae; }



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


  // Dataflow is inherited from blockNode

  // -- Clone

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

};
 
  

class exprstmtNode : public stmtNode
{

private:

  TREE exprNode * _expr;

public:

  exprstmtNode(exprNode * expr);

  virtual ~exprstmtNode();


  inline exprNode * expr() const { return _expr; }
  inline exprNode * get_expr() { exprNode * out = _expr; _expr = 0; return out; }
  inline void expr(exprNode * expr) { _expr = expr; }


  // -- Data type base

  typeNode * base_type(bool TdefIndir) const;



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


  // -- Dataflow

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

  // -- Clone

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

  // -- Output

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

class targetNode : public stmtNode
{

private:

  TREE blockNode * _stmt;

  FlowVal * _at_entry;

public:

  targetNode(NodeType typ, stmtNode * stmt, const Coord coord);

  virtual ~targetNode();


  inline blockNode * stmt() const { return _stmt; }
  inline blockNode * get_stmt() { blockNode * out = _stmt; _stmt = 0; return out; }
  inline void stmt(blockNode * stmt) { _stmt = stmt; }

  // -- Dataflow

  inline FlowVal * at_entry() const { return _at_entry; }
  inline void at_entry(FlowVal * ae) { _at_entry = ae; }

};

class labelNode : public targetNode
{

private:

  string _name;

  REF goto_list _references;

public:

  labelNode(const char * name, stmtNode * stmt,
            const Coord coord = Coord::Unknown);


  labelNode(idNode * ident, stmtNode * stmt);

  labelNode(idNode * ident);


  virtual ~labelNode();


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

  inline goto_list & references() { return _references; }
  inline const goto_list & references() const { return _references; }


  // -- Undeclared

  bool is_undeclared() const;


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


  // -- Dataflow

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

  // -- Clone

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

  // -- Output

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

class caseNode : public targetNode
{

private:

  TREE exprNode * _expr;

  REF switchNode * _container;

public:

  caseNode(exprNode * expr, stmtNode * stmt, switchNode * container,
           const Coord coord = Coord::Unknown);

  caseNode(exprNode * expr, stmtNode * stmt,
           const Coord coord = Coord::Unknown);

  virtual ~caseNode();


  inline exprNode * expr() const { return _expr; }
  inline exprNode * get_expr() { exprNode * out = _expr; _expr = 0; return out; }
  inline void expr(exprNode * expr) { _expr = expr; }

  inline switchNode * container() const { return _container; }
  inline void container(switchNode * container) { _container = container; }



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


  // -- Dataflow

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

  // -- Clone

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

  // -- Output

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

class selectionNode : public stmtNode
{

private:

  TREE exprNode * _expr;

  TREE blockNode * _stmt;

public:

  selectionNode(NodeType typ, exprNode * expr, stmtNode * stmt,
                const Coord coord);

  virtual ~selectionNode();


  inline exprNode * expr() const { return _expr; }
  inline exprNode * get_expr() { exprNode * out = _expr; _expr = 0; return out; }
  inline void expr(exprNode * expr) { _expr = expr; }

  inline blockNode * stmt() const { return _stmt; }
  inline blockNode * get_stmt() { blockNode * out = _stmt; _stmt = 0; return out; }
  inline void stmt(blockNode * stmt) { _stmt = stmt; }

};

class ifNode : public selectionNode
{

private:

  TREE blockNode * _false_br;

  Coord _else_coord;

public:

  ifNode(exprNode * expr, stmtNode * true_br, stmtNode * false_br,
             const Coord if_coord = Coord::Unknown, 
             const Coord else_coord = Coord::Unknown);

  virtual ~ifNode();


  inline blockNode * true_br() const { return selectionNode::stmt(); }
  inline blockNode * get_true_br() { return selectionNode::get_stmt(); }
  inline void true_br(blockNode * true_br) { selectionNode::stmt(true_br); }

  inline blockNode * false_br() const { return _false_br; }
  inline blockNode * get_false_br() { blockNode * out = _false_br; _false_br = 0; return out; }
  inline void false_br(blockNode * false_br) { _false_br = false_br; }

  inline Coord else_coord() const { return _else_coord; }
  inline void else_coord(const Coord the_coord) { _else_coord = the_coord; }



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


  // -- Dataflow

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

  // -- Clone

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

  // -- Output

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

class switchNode : public selectionNode
{

private:

  REF target_list _cases;

  bool _has_default;

  FlowVal * _at_top;

public:

  switchNode(exprNode * expr, stmtNode * stmt,
             const Coord coord = Coord::Unknown);

  virtual ~switchNode();


  inline target_list & cases() { return _cases; }
  inline const target_list & cases() const { return _cases; }

  inline bool has_default() const { return _has_default; }
  inline void has_default(bool has_default) { _has_default = has_default; }

  inline FlowVal * at_top() const { return _at_top; }
  inline void at_top(FlowVal * at) { _at_top = at; }



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


  // -- Dataflow

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

  // -- Clone

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

  // -- Output

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

class loopNode : public stmtNode
{

private:  

  TREE exprNode * _cond;

  TREE blockNode * _body;

  FlowVal * _at_loop_head;

  FlowVal * _at_loop_tail;

public:

  loopNode(NodeType typ, exprNode * cond, stmtNode * body, const Coord coord);

  loopNode(NodeType typ, const Coord coord);

  virtual ~loopNode();


  inline exprNode * cond() const { return _cond; }
  inline exprNode * get_cond() { exprNode * out = _cond; _cond = 0; return out; }
  inline void cond(exprNode * cond) { _cond = cond; }

  inline blockNode * body() const { return _body; }
  inline blockNode * get_body() { blockNode * out = _body; _body = 0; return out; }
  inline void body(blockNode * body) { _body = body; }

  // -- Dataflow

  inline FlowVal * at_loop_head() const { return _at_loop_head; }
  inline void at_loop_head(FlowVal * ae) { _at_loop_head = ae; }

  inline FlowVal * at_loop_tail() const { return _at_loop_tail; }
  inline void at_loop_tail(FlowVal * ae) { _at_loop_tail = ae; }

};

class whileNode : public loopNode
{

private:

public:

  whileNode(exprNode * cond, stmtNode * body,
            const Coord coord = Coord::Unknown);

  virtual ~whileNode();


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


  // -- Dataflow

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

  // -- Clone

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

  // -- Output

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

class doNode : public loopNode
{

private:

  Coord _while_coord;

public:

  doNode(stmtNode * body, exprNode * cond,
         const Coord coord = Coord::Unknown,
         const Coord while_coord = Coord::Unknown);

  virtual ~doNode();


  inline Coord while_coord() const { return _while_coord; }
  inline void while_coord(const Coord while_coord) { _while_coord = while_coord; }



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


  // -- Dataflow

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

  // -- Clone

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

  // -- Output

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

class forNode : public loopNode
{

private:

  TREE exprNode * _init;

  TREE exprNode * _next;

  // FlowVal * _loop_val;
  // FlowVal * _break_val;
  // FlowVal * _continue_val;

public:

  forNode(exprNode * init, exprNode * cond, exprNode * next,
          stmtNode * body, const Coord coord = Coord::Unknown);

  virtual ~forNode();


  inline exprNode * init() const { return _init; }
  inline exprNode * get_init() { exprNode * out = _init; _init = 0; return out; }
  inline void init(exprNode * init) { _init = init; }

  inline exprNode * next() const { return _next; }
  inline exprNode * get_next() { exprNode * out = _next; _next = 0; return out; }
  inline void next(exprNode * next) { _next = next; }



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


  // -- Dataflow

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

  // -- Clone

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

  // -- Output

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

class jumpNode : public stmtNode
{

private:

public:

  jumpNode(NodeType typ, const Coord coord);

  virtual ~jumpNode();

};

class gotoNode : public jumpNode
{

private:

  REF labelNode * _label;

  string _name;

public:

  gotoNode(labelNode * label, const Coord coord = Coord::Unknown);

  gotoNode(idNode * ident, const Coord coord);

  virtual ~gotoNode();


  inline labelNode * label() const { return _label; }
  inline void label(labelNode * label) { _label = label; }

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



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


  // -- Dataflow

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

  // -- Clone

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

  // -- Output

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

class continueNode : public jumpNode
{

private:

  REF loopNode * _container;

public:

  continueNode(loopNode * container, const Coord coord = Coord::Unknown);

  continueNode(const Coord coord = Coord::Unknown);

  virtual ~continueNode();


  inline loopNode * container() const { return _container; }
  inline void container(loopNode * container) { _container = container; }



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


  // -- Dataflow

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

  // -- Clone

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

  // -- Output

  virtual void output_stmt(output_context & ct, Node * par);
};
  
class breakNode : public jumpNode
{

private:

  REF stmtNode * _container;

public:

  breakNode(stmtNode * container, const Coord coord = Coord::Unknown);

  breakNode(const Coord coord = Coord::Unknown);

  virtual ~breakNode();


  inline stmtNode * container() const { return _container; }
  inline void container(stmtNode * container) { _container = container; }



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


  // -- Dataflow

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

  // -- Clone

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

  // -- Output

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

class returnNode : public jumpNode
{

private:

  TREE exprNode * _expr;

  REF procNode * _proc;

public:

  returnNode(exprNode * expr, procNode * proc,
             const Coord coord = Coord::Unknown);

  virtual ~returnNode();


  inline exprNode * expr() const { return _expr; }
  inline exprNode * get_expr() { exprNode * out = _expr; _expr = 0; return out; }
  inline void expr(exprNode * expr) { _expr = expr; }

  inline procNode * proc() const { return _proc; }
  inline void proc(procNode * proc) { _proc = proc; }



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


  // -- Dataflow

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

  // -- Clone

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

  // -- Output

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

class attribNode : public stmtNode
{

private:

  TREE exprNode * _arg;
  string _name;

public:

  // -- Constructors

  attribNode(const char * name, exprNode * arg,
             const Coord coord = Coord::Unknown);

  //    Was ConvertIdToAttrib in ast.c

  attribNode(idNode * id, exprNode * arg);

  virtual ~attribNode();


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

  inline exprNode * arg() const { return _arg; }
  inline exprNode * get_arg() { exprNode * out = _arg; _arg = 0; return out; }
  inline void arg(exprNode * arg) { _arg = arg; }



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


  // -- Dataflow

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

  // -- Clone

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

  // -- Output

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

class textNode : public Node
{

private:

  string _text;
  bool _start_new_line;

public:

  // -- Constructors

  textNode(const char * text, bool start_new_line,
           const Coord coord = Coord::Unknown);

  virtual ~textNode();


  inline string & text() { return _text; }
  inline void text(string text) { _text = text; }

  inline bool start_new_line() const { return _start_new_line; }
  inline void start_new_line(bool start_new_line) { _start_new_line = start_new_line; }



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


  // -- Dataflow

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

  // -- Clone

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

  // -- Output

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

// ------------------------------------------------------------
//   Template functions
// ------------------------------------------------------------

template< class T >
void dataflow_forward_list(list< T > & l, FlowVal * v, FlowProblem & fp)
{
  for (list< T >::iterator p = l.begin();
       p != l.end();
       ++p)
    (*p)->dataflow(v, fp);
}

template< class T >
void dataflow_reverse_list(list< T > & l, FlowVal * v, FlowProblem & fp)
{
  for (list< T >::reverse_iterator p = l.rbegin();
       p != l.rend();
       ++p)
    (*p)->dataflow(v, fp);
}

template< class T >
void output_list(list< T > & l, output_context & ct, Node * par)
{
  for (list< T >::iterator p = l.begin();
       p != l.end();
       ++p)
    (*p)->output(ct, par);
}

template< class T >
void output_delim_list(list< T > & l, output_context & ct, Node * par, char delim)
{
  for (list< T >::iterator p = l.begin();
       p != l.end();
       ++p)
    {
      if (p != l.begin()) {
        ct << delim;
        ct.space();
        ct.continue_line();
      }
      (*p)->output(ct, par);
    }
}

template< class T >
void delete_list(list< T > & l)
{
  for (list< T >::iterator p = l.begin();
       p != l.end();
       ++p)
    delete (*p);
}

#endif // CBZ_AST_H

---