Changeset 7527e63 for src/Parser/ParseNode.h

Timestamp:

Aug 16, 2016, 3:20:06 PM (9 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

1f6d4624

Parents:

950f7a7 (diff), 7880579 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/Parser/ParseNode.h (modified) (11 diffs)

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jul 12 20:50:21 2016
-// Update Count     : 261
+// Last Modified On : Tue Aug 16 08:37:47 2016
+// Update Count     : 527
 //
 
@@ -22 +22 @@
 #include <memory>
 
-#include "Common/utility.h"
 #include "Parser/LinkageSpec.h"
 #include "SynTree/Type.h"
 #include "SynTree/Expression.h"
-//#include "SynTree/Declaration.h"
+#include "SynTree/Statement.h"
+#include "SynTree/Label.h"
+#include "Common/utility.h"
 #include "Common/UniqueName.h"
-#include "SynTree/Label.h"
-
-class ExpressionNode;
-class CompositeExprNode;
-class CommaExprNode;
+
 class StatementNode;
 class CompoundStmtNode;
 class DeclarationNode;
+class ExpressionNode;
 class InitializerNode;
 
-// Builder
+//##############################################################################
+
 class ParseNode {
   public:
@@ -45 +44 @@
         ParseNode( const std::string & );                                       // for copy constructing subclasses
         virtual ~ParseNode();
-
-        ParseNode *get_link() const { return next; }
+        virtual ParseNode *clone() const { assert( false ); return nullptr; };
+
+        ParseNode *get_next() const { return next; }
+        ParseNode *set_next( ParseNode *newlink ) { next = newlink; return this; }
         ParseNode *get_last();
-        ParseNode *set_link( ParseNode * );
-        void set_next( ParseNode *newlink ) { next = newlink; }
-
-        virtual ParseNode *clone() const { return 0; };
+        ParseNode *set_last( ParseNode * );
 
         const std::string &get_name() const { return name; }
         void set_name( const std::string &newValue ) { name = newValue; }
 
-        virtual void print( std::ostream &, int indent = 0 ) const;
-        virtual void printList( std::ostream &, int indent = 0 ) const;
-
-        ParseNode &operator,( ParseNode &);
-  protected:
+        virtual void print( std::ostream &os, int indent = 0 ) const {}
+        virtual void printList( std::ostream &os, int indent = 0 ) const;
+  private:
+        static int indent_by;
+
+        ParseNode *next;
         std::string name;
-        static int indent_by;
-        ParseNode *next;
-};
-
-ParseNode *mkList( ParseNode & );
+}; // ParseNode
+
+//##############################################################################
+
+class InitializerNode : public ParseNode {
+  public:
+        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode *des = 0 );
+        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode *des = 0 );
+        ~InitializerNode();
+
+        ExpressionNode *get_expression() const { return expr; }
+
+        InitializerNode *set_designators( ExpressionNode *des ) { designator = des; return this; }
+        ExpressionNode *get_designators() const { return designator; }
+
+        InitializerNode *set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
+        bool get_maybeConstructed() const { return maybeConstructed; }
+
+        InitializerNode *next_init() const { return kids; }
+
+        void print( std::ostream &os, int indent = 0 ) const;
+        void printOneLine( std::ostream & ) const;
+
+        virtual Initializer *build() const;
+  private:
+        ExpressionNode *expr;
+        bool aggregate;
+        ExpressionNode *designator;                                                     // may be list
+        InitializerNode *kids;
+        bool maybeConstructed;
+};
+
+//##############################################################################
 
 class ExpressionNode : public ParseNode {
   public:
-        ExpressionNode();
-        ExpressionNode( const std::string * );
+        ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
+        ExpressionNode( Expression * expr, const std::string *name ) : ParseNode( name ), expr( expr ) {}
         ExpressionNode( const ExpressionNode &other );
-        virtual ~ExpressionNode() { delete argName; } // cannot delete argName because it might be referenced elsewhere
-
-        virtual ExpressionNode *clone() const = 0;
-
-        virtual CommaExprNode *add_to_list( ExpressionNode * );
-
-        ExpressionNode *get_argName() const { return argName; }
-        ExpressionNode *set_argName( const std::string *aName );
-        ExpressionNode *set_argName( ExpressionNode *aDesignator );
+        virtual ~ExpressionNode() {}
+
+        virtual ExpressionNode *clone() const { assert( false ); return nullptr; }
+
         bool get_extension() const { return extension; }
         ExpressionNode *set_extension( bool exten ) { extension = exten; return this; }
 
-        virtual void print( std::ostream &, int indent = 0) const = 0;
-        virtual void printOneLine( std::ostream &, int indent = 0) const = 0;
-
-        virtual Expression *build() const = 0;
-  protected:
-        void printDesignation ( std::ostream &, int indent = 0) const;
-  private:
-        ExpressionNode *argName = 0;
+        virtual void print( std::ostream &os, int indent = 0 ) const {}
+        virtual void printOneLine( std::ostream &os, int indent = 0 ) const {}
+
+        virtual Expression *build() const { return expr; }
+  private:
         bool extension = false;
+        Expression *expr;
 };
 
 template< typename T >
-struct maybeBuild_t<Expression, T> {
+struct maybeBuild_t< Expression, T > {
         static inline Expression * doit( const T *orig ) {
                 if ( orig ) {
@@ -104 +124 @@
                         return p;
                 } else {
-                        return 0;
+                        return nullptr;
                 } // if
         }
 };
 
-// NullExprNode is used in tuples as a place-holder where a tuple component is omitted e.g., [ 2, , 3 ]
-class NullExprNode : public ExpressionNode {
-  public:
-        NullExprNode();
-
-        virtual NullExprNode *clone() const;
-
-        virtual void print( std::ostream &, int indent = 0) const;
-        virtual void printOneLine( std::ostream &, int indent = 0) const;
-
-        virtual Expression *build() const;
-};
-
-class ConstantNode : public ExpressionNode {
-  public:
-        enum Type { Integer, Float, Character, String };
-
-        ConstantNode( ConstantExpr * );
-        ConstantNode( const ConstantNode &other ) : expr( other.expr->clone() ) {};
-        ~ConstantNode() { delete expr; }
-
-        virtual ConstantNode *clone() const { return new ConstantNode( *this ); }
-        virtual void print( std::ostream &, int indent = 0) const;
-        virtual void printOneLine( std::ostream &, int indent = 0) const;
-
-        ConstantNode *appendstr( const std::string *newValue );
-
-        Expression *build() const;
-  private:
-        ConstantExpr *expr;
-};
-
-ConstantNode *makeConstant( ConstantNode::Type, std::string * );
-ConstantNode *makeConstantStr( ConstantNode::Type type, std::string *str );
-
-class VarRefNode : public ExpressionNode {
-  public:
-        VarRefNode();
-        VarRefNode( const std::string *, bool isLabel = false );
-        VarRefNode( const VarRefNode &other );
-
-        virtual Expression *build() const ;
-
-        virtual VarRefNode *clone() const { return new VarRefNode( *this ); }
-
-        virtual void print( std::ostream &, int indent = 0 ) const;
-        virtual void printOneLine( std::ostream &, int indent = 0 ) const;
-  private:
-        bool isLabel;
-};
-
-class DesignatorNode : public ExpressionNode {
-  public:
-        DesignatorNode( ExpressionNode *expr, bool isArrayIndex = false );
-        DesignatorNode( const DesignatorNode &other );
-
-        virtual Expression *build() const ;
-        virtual DesignatorNode *clone() const { return new DesignatorNode( *this ); }
-
-        virtual void print( std::ostream &, int indent = 0 ) const;
-        virtual void printOneLine( std::ostream &, int indent = 0 ) const;
-  private:
-        bool isArrayIndex;
-};
-
-class TypeValueNode : public ExpressionNode {
-  public:
-        TypeValueNode( DeclarationNode * );
-        TypeValueNode( const TypeValueNode &other );
-
-        DeclarationNode *get_decl() const { return decl; }
-
-        virtual Expression *build() const ;
-
-        virtual TypeValueNode *clone() const { return new TypeValueNode( *this ); }
-
-        virtual void print( std::ostream &, int indent = 0) const;
-        virtual void printOneLine( std::ostream &, int indent = 0) const;
-  private:
-        DeclarationNode *decl;
-};
-
-class OperatorNode : public ExpressionNode {
-  public:
-        enum Type { TupleC, Comma, TupleFieldSel, // n-adic
-                                // triadic
-                                Cond, NCond,
-                                // diadic
-                                SizeOf, AlignOf, OffsetOf, Attr, Plus, Minus, Mul, Div, Mod, Or, And,
-                                BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
-                                Assign, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
-                                Index, FieldSel, PFieldSel, Range,
-                                // monadic
-                                UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
-                                Ctor, Dtor,
-        };
-
-        OperatorNode( Type t );
-        OperatorNode( const OperatorNode &other );
-        virtual ~OperatorNode();
-
-        virtual OperatorNode *clone() const { return new OperatorNode( *this ); }
-
-        Type get_type() const;
-        const char *get_typename() const;
-
-        virtual void print( std::ostream &, int indent = 0) const;
-        virtual void printOneLine( std::ostream &, int indent = 0) const;
-
-        virtual Expression *build() const { return 0; }
-  private:
-        Type type;
-};
-
-class CompositeExprNode : public ExpressionNode {
-  public:
-        CompositeExprNode();
-        CompositeExprNode( const std::string * );
-        CompositeExprNode( ExpressionNode *f, ExpressionNode *args = 0 );
-        CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2 );
-        CompositeExprNode( const CompositeExprNode &other );
-        virtual ~CompositeExprNode();
-
-        virtual CompositeExprNode *clone() const { return new CompositeExprNode( *this ); }
-        virtual Expression *build() const;
-
-        virtual void print( std::ostream &, int indent = 0) const;
-        virtual void printOneLine( std::ostream &, int indent = 0) const;
-
-        void set_function( ExpressionNode * );
-        void set_args( ExpressionNode * );
-
-        void add_arg( ExpressionNode * );
-
-        ExpressionNode *get_function() const;
-        ExpressionNode *get_args() const;
-  private:
-        ExpressionNode *function;
-        ExpressionNode *arguments;
-};
-
-class AsmExprNode : public ExpressionNode {
-  public:
-        AsmExprNode();
-        AsmExprNode( ExpressionNode *inout, ConstantNode *constraint, ExpressionNode *operand ) : inout( inout ), constraint( constraint ), operand( operand ) {}
-        virtual ~AsmExprNode() { delete inout; delete constraint; delete operand; }
-
-        virtual AsmExprNode *clone() const { return new AsmExprNode( *this ); }
-        virtual Expression *build() const;
-
-        virtual void print( std::ostream &, int indent = 0) const;
-        virtual void printOneLine( std::ostream &, int indent = 0) const;
-
-        ExpressionNode *get_inout() const { return inout; };
-        void set_inout( ExpressionNode *newValue ) { inout = newValue; }
-
-        ConstantNode *get_constraint() const { return constraint; };
-        void set_constraint( ConstantNode *newValue ) { constraint = newValue; }
-
-        ExpressionNode *get_operand() const { return operand; };
-        void set_operand( ExpressionNode *newValue ) { operand = newValue; }
-  private:
-        ExpressionNode *inout;
-        ConstantNode *constraint;
-        ExpressionNode *operand;
-};
-
-class LabelNode : public ExpressionNode {
-  public:
-        virtual Expression *build() const { return NULL; }
-        virtual LabelNode *clone() const { return new LabelNode( *this ); }
-
-        virtual void print( std::ostream &, int indent = 0) const;
-        virtual void printOneLine( std::ostream &, int indent = 0) const;
-
-        const std::list< Label > &get_labels() const { return labels; };
-        void append_label( std::string *label ) { labels.push_back( *label ); delete label; }
-  private:
+enum class OperKinds {
+        // diadic
+        SizeOf, AlignOf, OffsetOf, Plus, Minus, Mul, Div, Mod, Or, And,
+        BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
+        Assign, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
+        Index, Range,
+        // monadic
+        UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
+        Ctor, Dtor,
+};
+
+struct LabelNode {
         std::list< Label > labels;
 };
 
-class CommaExprNode : public CompositeExprNode {
-  public:
-        CommaExprNode();
-        CommaExprNode( ExpressionNode * );
-        CommaExprNode( ExpressionNode *, ExpressionNode * );
-        CommaExprNode( const CommaExprNode &other );
-
-        virtual CommaExprNode *add_to_list( ExpressionNode * );
-        virtual CommaExprNode *clone() const { return new CommaExprNode( *this ); }
-};
-
-class ForCtlExprNode : public ExpressionNode {
-  public:
-        ForCtlExprNode( ParseNode *, ExpressionNode *, ExpressionNode * ) throw ( SemanticError );
-        ForCtlExprNode( const ForCtlExprNode &other );
-        ~ForCtlExprNode();
-
-        StatementNode *get_init() const { return init; }
-        ExpressionNode *get_condition() const { return condition; }
-        ExpressionNode *get_change() const { return change; }
-
-        virtual ForCtlExprNode *clone() const { return new ForCtlExprNode( *this ); }
-        virtual Expression *build() const;
-
-        virtual void print( std::ostream &, int indent = 0 ) const;
-        virtual void printOneLine( std::ostream &, int indent = 0 ) const;
-  private:
-        StatementNode *init;
-        ExpressionNode *condition;
-        ExpressionNode *change;
-};
-
-class ValofExprNode : public ExpressionNode {
-  public:
-        ValofExprNode();
-        ValofExprNode( StatementNode *s = 0 );
-        ValofExprNode( const ValofExprNode &other );
-        ~ValofExprNode();
-
-        virtual ValofExprNode *clone() const { return new ValofExprNode( *this ); }
-
-        StatementNode *get_body() const { return body; }
-        void print( std::ostream &, int indent = 0 ) const;
-        void printOneLine( std::ostream &, int indent = 0 ) const;
-        Expression *build() const;
-
-  private:
-        StatementNode *body;
-};
+Expression *build_constantInteger( std::string &str );
+Expression *build_constantFloat( std::string &str );
+Expression *build_constantChar( std::string &str );
+ConstantExpr *build_constantStr( std::string &str );
+
+NameExpr *build_varref( const std::string *name, bool labelp = false );
+Expression *build_typevalue( DeclarationNode *decl );
+
+Expression *build_cast( DeclarationNode * decl_node, ExpressionNode *expr_node );
+Expression *build_fieldSel( ExpressionNode *expr_node, NameExpr *member );
+Expression *build_pfieldSel( ExpressionNode *expr_node, NameExpr *member );
+Expression *build_addressOf( ExpressionNode *expr_node );
+Expression *build_sizeOfexpr( ExpressionNode *expr_node );
+Expression *build_sizeOftype( DeclarationNode *decl_node );
+Expression *build_alignOfexpr( ExpressionNode *expr_node );
+Expression *build_alignOftype( DeclarationNode *decl_node );
+Expression *build_offsetOf( DeclarationNode *decl_node, NameExpr *member );
+Expression *build_and( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
+Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind );
+Expression *build_unary_val( OperKinds op, ExpressionNode *expr_node );
+Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node );
+Expression *build_binary_val( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
+Expression *build_binary_ptr( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
+Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 );
+Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
+Expression *build_attrexpr( NameExpr *var, ExpressionNode * expr_node );
+Expression *build_attrtype( NameExpr *var, DeclarationNode * decl_node );
+Expression *build_tuple( ExpressionNode * expr_node = 0 );
+Expression *build_func( ExpressionNode * function, ExpressionNode * expr_node );
+Expression *build_range( ExpressionNode * low, ExpressionNode *high );
+Expression *build_asmexpr( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand );
+Expression *build_valexpr( StatementNode *s );
+Expression *build_compoundLiteral( DeclarationNode *decl_node, InitializerNode *kids );
+
+//##############################################################################
 
 class TypeData;
@@ -386 +226 @@
         static DeclarationNode *newBuiltinType( BuiltinType );
 
+        DeclarationNode();
+        ~DeclarationNode();
+        DeclarationNode *clone() const;
+
         DeclarationNode *addQualifiers( DeclarationNode *);
         DeclarationNode *copyStorageClasses( DeclarationNode *);
@@ -401 +245 @@
         DeclarationNode *addNewArray( DeclarationNode *array );
         DeclarationNode *addParamList( DeclarationNode *list );
-        DeclarationNode *addIdList( DeclarationNode *list );       // old-style functions
+        DeclarationNode *addIdList( DeclarationNode *list ); // old-style functions
         DeclarationNode *addInitializer( InitializerNode *init );
 
@@ -412 +256 @@
         DeclarationNode *appendList( DeclarationNode * );
 
-        DeclarationNode *clone() const;
-        void print( std::ostream &, int indent = 0 ) const;
-        void printList( std::ostream &, int indent = 0 ) const;
+        void print( std::ostream &os, int indent = 0 ) const;
+        void printList( std::ostream &os, int indent = 0 ) const;
 
         Declaration *build() const;
@@ -427 +270 @@
         bool get_extension() const { return extension; }
         DeclarationNode *set_extension( bool exten ) { extension = exten; return this; }
-
-        DeclarationNode();
-        ~DeclarationNode();
   private:
         StorageClass buildStorageClass() const;
@@ -448 +288 @@
 }; // DeclarationNode
 
+Type *buildType( TypeData *type );
+
+//##############################################################################
+
 class StatementNode : public ParseNode {
   public:
-        enum Type { Exp,   If,        Switch,  Case,    Default,  Choose,   Fallthru,
-                                While, Do,        For,
-                                Goto,  Continue,  Break,   Return,  Throw,
-                                Try,   Catch,     Finally, Asm,
-                                Decl
-        };
-
-        StatementNode();
-        StatementNode( const std::string *name );
-        StatementNode( Type t, ExpressionNode *control = 0, StatementNode *block = 0 );
-        StatementNode( Type t, std::string *target );
+        StatementNode() { stmt = nullptr; }
+        StatementNode( Statement *stmt ) : stmt( stmt ) {}
         StatementNode( DeclarationNode *decl );
-
-        ~StatementNode();
-
-        static StatementNode *newCatchStmt( DeclarationNode *d = 0, StatementNode *s = 0, bool catchRestP = false );
-
-        StatementNode *set_block( StatementNode *b ) {  block = b; return this; }
-        StatementNode *get_block() const { return block; }
-
-        void set_control( ExpressionNode *c ) { control = c; }
-        ExpressionNode *get_control() const { return control; }
-
-        StatementNode::Type get_type() const { return type; }
-
-        StatementNode *add_label( const std::string * );
-        const std::list<std::string> &get_labels() const { return labels; }
-
-        void addDeclaration( DeclarationNode *newDecl ) { decl = newDecl; }
-        void setCatchRest( bool newVal ) { isCatchRest = newVal; }
-
-        std::string get_target() const;
-
-        StatementNode *add_controlexp( ExpressionNode * );
-        StatementNode *append_block( StatementNode * );
-        StatementNode *append_last_case( StatementNode * );
-
-        void print( std::ostream &, int indent = 0) const;
-        virtual StatementNode *clone() const;
-        virtual Statement *build() const;
-  private:
-        static const char *StType[];
-        Type type;
-        ExpressionNode *control;
-        StatementNode *block;
-        std::list<std::string> labels;
-        std::string *target;                            // target label for jump statements
-        DeclarationNode *decl;
-        bool isCatchRest;
+        virtual ~StatementNode() {}
+
+        virtual StatementNode *clone() const { assert( false ); return nullptr; }
+        virtual Statement *build() const { return stmt; }
+
+        virtual StatementNode *add_label( const std::string * name ) {
+                stmt->get_labels().emplace_back( *name );
+                return this;
+        }
+
+        virtual StatementNode *append_last_case( StatementNode * );
+
+        virtual void print( std::ostream &os, int indent = 0 ) {}
+        virtual void printList( std::ostream &os, int indent = 0 ) {}
+  private:
+        Statement *stmt;
 }; // StatementNode
 
-class CompoundStmtNode : public StatementNode {
-  public:
-        CompoundStmtNode();
-        CompoundStmtNode( const std::string * );
-        CompoundStmtNode( StatementNode * );
-        ~CompoundStmtNode();
-
-        void add_statement( StatementNode * );
-
-        void print( std::ostream &, int indent = 0 ) const;
-        virtual Statement *build() const;
-  private:
-        StatementNode *first, *last;
-};
-
-class AsmStmtNode : public StatementNode {
-  public:
-        AsmStmtNode( Type, bool voltile, ConstantNode *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ConstantNode *clobber = 0, LabelNode *gotolabels = 0 );
-        ~AsmStmtNode();
-
-        void print( std::ostream &, int indent = 0 ) const;
-        Statement *build() const;
-  private:
-        bool voltile;
-        ConstantNode *instruction;
-        ExpressionNode *output, *input;
-        ConstantNode *clobber;
-        std::list< Label > gotolabels;
-};
-
-class NullStmtNode : public CompoundStmtNode {
-  public:
-        Statement *build() const;
-        void print( std::ostream &, int indent = 0 ) const;
-};
-
-class InitializerNode : public ParseNode {
-  public:
-        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode *des = 0 );
-        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode *des = 0 );
-        ~InitializerNode();
-
-        ExpressionNode *get_expression() const { return expr; }
-
-        InitializerNode *set_designators( ExpressionNode *des ) { designator = des; return this; }
-        ExpressionNode *get_designators() const { return designator; }
-
-        InitializerNode *set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
-        bool get_maybeConstructed() const { return maybeConstructed; }
-
-        InitializerNode *next_init() const { return kids; }
-
-        void print( std::ostream &, int indent = 0 ) const;
-        void printOneLine( std::ostream & ) const;
-
-        virtual Initializer *build() const;
-  private:
-        ExpressionNode *expr;
-        bool aggregate;
-        ExpressionNode *designator; // may be list
-        InitializerNode *kids;
-        bool maybeConstructed;
-};
-
-class CompoundLiteralNode : public ExpressionNode {
-  public:
-        CompoundLiteralNode( DeclarationNode *type, InitializerNode *kids );
-        CompoundLiteralNode( const CompoundLiteralNode &type );
-        ~CompoundLiteralNode();
-
-        virtual CompoundLiteralNode *clone() const;
-
-        DeclarationNode *get_type() const { return type; }
-        CompoundLiteralNode *set_type( DeclarationNode *t ) { type = t; return this; }
-
-        InitializerNode *get_initializer() const { return kids; }
-        CompoundLiteralNode *set_initializer( InitializerNode *k ) { kids = k; return this; }
-
-        void print( std::ostream &, int indent = 0 ) const;
-        void printOneLine( std::ostream &, int indent = 0 ) const;
-
-        virtual Expression *build() const;
-  private:
-        DeclarationNode *type;
-        InitializerNode *kids;
-};
+Statement *build_expr( ExpressionNode *ctl );
+
+struct ForCtl {
+        ForCtl( ExpressionNode *expr, ExpressionNode *condition, ExpressionNode *change ) :
+                init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
+        ForCtl( DeclarationNode *decl, ExpressionNode *condition, ExpressionNode *change ) :
+                init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
+
+        StatementNode *init;
+        ExpressionNode *condition;
+        ExpressionNode *change;
+};
+
+Statement *build_if( ExpressionNode *ctl, StatementNode *then_stmt, StatementNode *else_stmt );
+Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt );
+Statement *build_case( ExpressionNode *ctl );
+Statement *build_default();
+Statement *build_while( ExpressionNode *ctl, StatementNode *stmt, bool kind = false );
+Statement *build_for( ForCtl *forctl, StatementNode *stmt );
+Statement *build_branch( std::string identifier, BranchStmt::Type kind );
+Statement *build_computedgoto( ExpressionNode *ctl );
+Statement *build_return( ExpressionNode *ctl );
+Statement *build_throw( ExpressionNode *ctl );
+Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt );
+Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny = false );
+Statement *build_finally( StatementNode *stmt );
+Statement *build_compound( StatementNode *first );
+Statement *build_asmstmt( bool voltile, ConstantExpr *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ExpressionNode *clobber = 0, LabelNode *gotolabels = 0 );
+
+//##############################################################################
 
 template< typename SynTreeType, typename NodeType >
-void buildList( const NodeType *firstNode, std::list< SynTreeType *> &outputList ) {
+void buildList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) {
         SemanticError errors;
-        std::back_insert_iterator< std::list< SynTreeType *> > out( outputList );
+        std::back_insert_iterator< std::list< SynTreeType * > > out( outputList );
         const NodeType *cur = firstNode;
 
         while ( cur ) {
                 try {
-//                      SynTreeType *result = dynamic_cast< SynTreeType *>( maybeBuild<typename std::result_of<decltype(&NodeType::build)(NodeType)>::type>( cur ) );
-                        SynTreeType *result = dynamic_cast< SynTreeType *>( maybeBuild<typename std::pointer_traits<decltype(cur->build())>::element_type>( cur ) );
+//                      SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::result_of< decltype(&NodeType::build)(NodeType)>::type >( cur ) );
+                        SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
                         if ( result ) {
                                 *out++ = result;
@@ -605 +363 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< NodeType *>( cur->get_link() );
+                cur = dynamic_cast< NodeType * >( cur->get_next() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -614 +372 @@
 // in DeclarationNode.cc
 void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList );
-void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType *> &outputList );
+void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType * > &outputList );
 void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList );
-
-// in ExpressionNode.cc
-ExpressionNode *flattenCommas( ExpressionNode *list );
-ExpressionNode *tupleContents( ExpressionNode *tuple );
 
 #endif // PARSENODE_H