C-Breeze C Compiler Infrastructure [ Project home page]

ast.h Go to the documentation of this file. // $Id: ast.h,v 1.29 2003/08/11 17:13:41 abrown Exp $ // ---------------------------------------------------------------------- // // C-Breeze // C Compiler Framework // // Copyright (c) 2000 University of Texas at Austin // // Samuel Z. Guyer // Daniel A. Jimenez // Calvin Lin // Adam Brown // // 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 #include "register.h" 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; instruction_list _instructions; 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, bool abortOnError = true); 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 instruction_list & instructions() { return _instructions; } 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; struct Storage_location { Storage_location() { // init values _type = storageloc_unknown; _stack_offset = 0; } enum { storageloc_unknown, storageloc_register, storageloc_stack, storageloc_mem_global, storageloc_advanced, } _type; Register _register; int _stack_offset; }; 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; Storage_location _storage_location; bool _is_redundant_extern; TREE exprNode * _init; TREE exprNode * _bitsize; int _references; REF id_list _ref_list; 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 id_list & ref_list() { return _ref_list; } inline const id_list & ref_list() const { return _ref_list; } inline attrib_list & attribs() { return _attribs; } inline const attrib_list & attribs() const { return _attribs; } void merge_attribs(attrib_list * attribs); inline Storage_location & storage_location() { return _storage_location; } // 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; instruction_list _instructions; LirBlockList _lir_blocks; int _last_stack_local; unsigned int _stack_frame_size; static procNode * _current; FlowVal * _at_entry; FlowVal * _at_exit; /* These fields are set by the ThreeAddrReturnDismantle. * They are only valid in dismantled code */ labelNode * _return_label; declNode * _return_decl; 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; } inline instruction_list & instructions() { return _instructions; } inline LirBlockList & lir_blocks() { return _lir_blocks; } void set_initial_stack_local_offset( int offset ); int alloc_stack_local( declNode * decl ); int get_locals_size() { return abs( _last_stack_local ); } unsigned int stack_frame_size() { return _stack_frame_size; } void stack_frame_size( unsigned int size ) { _stack_frame_size = size; } // -- 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; } void return_label(labelNode * label) { _return_label = label; } labelNode * return_label() { return _return_label; } void return_decl(declNode * decl) { _return_decl = decl; } declNode * return_decl() { return _return_decl; } 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; int _alloc_size; int _alloc_align; 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); } inline int alloc_size(void) const { return _alloc_size; } inline void alloc_size(int size) { _alloc_size = size; } inline int alloc_align(void) const { return _alloc_align; } inline void alloc_align(int align) { _alloc_align = align; } 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_char() const { return false; } virtual bool is_int() 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; 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 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(); virtual typeNode * type() const { return _type; } inline typeNode * get_type() { typeNode * out = _type; _type = 0; return out; } virtual 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 indexNode : public exprNode { public: indexNode(NodeType typ, typeNode * type, const Coord coord); }; class constNode : public indexNode { 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 indexNode { 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; } void decl(declNode *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 * the_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; } void container(switchNode * 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, NodeType typ = Goto); gotoNode(idNode * ident, const Coord coord); virtual ~gotoNode(); inline labelNode * label() const { return _label; } void label(labelNode * 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; bool _is_proc_exit; public: returnNode(exprNode * expr, procNode * proc, const Coord coord = Coord::Unknown); returnNode(exprNode * expr, procNode * proc, bool proc_exit, 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; } bool proc_exit() { return _is_proc_exit; } private: void proc_exit(bool proc_exit) { _is_proc_exit = proc_exit; } public: 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; // -- 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 operandNode : public exprNode { private: bool _star; // *foo bool _addr; // &foo typeNode * _cast; indexNode * _var; id_list _fields; // for var.foo.bar.baz indexNode * _index; // this field is intended for array indices. public: operandNode(indexNode * the_var, const Coord coord = Coord::Unknown); operandNode(indexNode * the_var, bool star, bool addr, const Coord coord = Coord::Unknown); operandNode(indexNode * the_var, bool star, bool addr, id_list * fields, indexNode * array_index, const Coord coord = Coord::Unknown); void addr(bool addr) { _addr = addr; } bool addr() const { return _addr; } void star(bool star) { _star = star; } bool star() const { return _star; } void cast(typeNode * cast) { _cast = cast; } typeNode * cast(void) { return _cast; } const typeNode * cast(void) const { return _cast; } inline id_list & fields() { return _fields; } inline const id_list & fields() const { return _fields; } void index(indexNode * index) { _index = index; } indexNode * index(void) { return _index; } const indexNode * index(void) const { return _index; } void var(indexNode * var) { _var = var; } indexNode * var(void) { return _var; } const indexNode * var(void) const { return _var; } // TODO: do we want these? /* virtual typeNode * base_type(bool TdefIndir) const; */ virtual typeNode * type() const; virtual void type(typeNode *); virtual typeNode * noncast_type(bool convertArrays = true) const; virtual void eval(); virtual void visit(Visitor * the_visitor); virtual void walk(Walker & the_walker); virtual Node * change(Changer & the_changer, bool redispatch = false); virtual void dataflow(FlowVal * v, FlowProblem & fp); virtual Node * clone() const { return new operandNode(*this); } virtual void output_expr(output_context & ct, Node * parent, int prec, Assoc assoc); }; class conditiongotoNode : public gotoNode { private: indexNode * _oper1; indexNode * _oper2; Operator * _op; // must be a relational operator public: // if ( left <op_id> right ) goto label conditiongotoNode(labelNode * label, indexNode * left, unsigned int op_id, indexNode * right, const Coord coord = Coord::Unknown); void left(indexNode * left) { _oper1 = left; } indexNode * left(void) { return _oper1; } void right(indexNode * right) { _oper2 = right; } indexNode * right(void) { return _oper2; } void op(Operator * op); // TODO: is this safe? can't code change the op_id directly with this? Operator * op(void) { return _op; } virtual void visit(Visitor * the_visitor); virtual void walk(Walker & the_walker); virtual Node * change(Changer & the_changer, bool redispatch = false); virtual void dataflow(FlowVal * v, FlowProblem & fp); virtual Node * clone() const { return new conditiongotoNode(*this); } virtual void output_stmt(output_context & ct, Node * par); }; class threeAddrNode : public stmtNode { private: operandNode * _lhs; operandNode * _rhs1; // if op == FUNC_CALL, this is the function "name" Operator * _op; // TODO: need to add operator for FUNC_CALL operandNode * _rhs2; // NULL if op == FUNC_CALL typeNode * _sizeof_type; // if op == SIZEOF operand_list _arg_list; // for function calls public: // a = b; threeAddrNode(operandNode * lhs, operandNode * rhs, const Coord coord = Coord::Unknown); // a = -b; threeAddrNode(operandNode * lhs, unsigned int op_id, operandNode * rhs, const Coord coord = Coord::Unknown); // a = sizeof(<type>) threeAddrNode(operandNode * lhs, typeNode * type, const Coord coord = Coord::Unknown); // a = b (op) c; threeAddrNode(operandNode * lhs, operandNode * rhs1, unsigned int op_id, operandNode * rhs2, const Coord coord = Coord::Unknown); // a = b(...); threeAddrNode(operandNode * lhs, operandNode * func, operand_list * arg_list, const Coord coord = Coord::Unknown); // a(...); threeAddrNode(operandNode * func, operand_list * arg_list, const Coord coord = Coord::Unknown); void lhs(operandNode * lhs) { _lhs = lhs; } operandNode * lhs(void) { return _lhs; } void rhs1(operandNode * rhs1) { _rhs1 = rhs1; } operandNode * rhs1(void) { return _rhs1; } void op(Operator * op) { _op = op; } // TODO: is this safe? can't code change the op_id directly with this? Operator * op(void) { return _op; } // TODO: is this safe? if _op is FUNC_CALL, this shouldn't be allowed void rhs2(operandNode * rhs2) { _rhs2 = rhs2; } operandNode * rhs2(void) { return _rhs2; } void sizeof_type(typeNode * type) { _sizeof_type = type; } typeNode * sizeof_type(void) { return _sizeof_type; } inline operand_list & arg_list() { return _arg_list; } inline const operand_list & arg_list() const { return _arg_list; } virtual void visit(Visitor * the_visitor); virtual void walk(Walker & the_walker); virtual Node * change(Changer & the_changer, bool redispatch = false); virtual void dataflow(FlowVal * v, FlowProblem & fp); virtual Node * clone() const { return new threeAddrNode(*this); } 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 (typename 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 (typename 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 (typename 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 (typename 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 (typename list< T >::iterator p = l.begin(); p != l.end(); ++p) delete (*p); } #endif // CBZ_AST_H

Generated on August 27, 2003
Back to the C-Breeze home page