source: src/InitTweak/BasicInit.h@ 83dccdd

//
// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// BasicInit.h -- 
//
// Author           : Rodolfo G. Esteves
// Created On       : Mon May 18 07:44:20 2015
// Last Modified By : Peter A. Buhr
// Last Modified On : Tue May 19 16:32:21 2015
// Update Count     : 3
//

#ifndef _BASINIT_H_
#define _BASINIT_H_

#include <list>

#include "SynTree/Visitor.h"
#include "SymTab/Indexer.h"

#include "SynTree/Type.h"
#include "SynTree/Initializer.h"
#include "SynTree/Expression.h"
#include "NameInCollection.h"
#include "NameAssociation.h"

namespace InitTweak {
        bool isDeclStmtP(Statement *stmt);

        class BreakInitializer;
        class BreakDesignator;

        class BasicInit: public Mutator {
          public:
                BasicInit() : bindings( 0 ) {}
                BasicInit( SymTab::Indexer &_index ) : bindings( 0 ), index( _index ) {}
                BasicInit( const BasicInit &other ) {
                        bindings = other.get_bindings();
                        index = other.index;
                }

                ~BasicInit() { /* delete bindings; bindings = 0; */ }

                NameAssociation< Expression *, BreakInitializer > *get_bindings() const { return bindings; }
                void set_bindings( NameAssociation< Expression *, BreakInitializer > *newValue ) {
                        bindings = newValue;
                }

                bool has_bindings() {
                        return ( get_bindings() != 0 || ! stmts.empty() );
                }

                virtual ObjectDecl     *mutate( ObjectDecl *objectDecl )
                        { index.visit( objectDecl ); return objectDecl; }
                virtual TypeDecl       *mutate( TypeDecl *typeDecl )
                        { index.visit( typeDecl ); return typeDecl; }
                virtual TypedefDecl    *mutate( TypedefDecl *typeDecl )
                        { index.visit( typeDecl ); return typeDecl; }
                virtual StructDecl     *mutate( StructDecl *aggregateDecl )
                        { index.visit( aggregateDecl ); return aggregateDecl; }
                virtual UnionDecl      *mutate( UnionDecl *aggregateDecl )
                        { index.visit( aggregateDecl ); return aggregateDecl; }
                virtual EnumDecl       *mutate( EnumDecl *aggregateDecl )
                        { index.visit( aggregateDecl ); return aggregateDecl; }

                virtual Type           *mutate( StructInstType *aggrInst )
                        { index.visit( aggrInst ); return aggrInst; }
                virtual Type           *mutate( UnionInstType *aggrInst )
                        { index.visit( aggrInst ); return aggrInst; }

                virtual CompoundStmt   *mutate(CompoundStmt *compoundStmt);
                virtual Statement *mutate(DeclStmt *declStmt);

                std::list< Statement *> get_statements() const { return stmts;  }

                static void build_statements( NameAssociation< Expression *, BreakInitializer > *assoc, std::string aggName, std::list< Statement *> &stmts );
          private:
                NameAssociation< Expression *, BreakInitializer > *bindings;
                Statement *assignFromDecl( DeclStmt *declStmt );
                SymTab::Indexer index;
                std::list< Statement *> stmts;

                class Classify {
                  public:
                        enum TypeKind { NULL_T, SINGLE_T, COMPOUND_T };
                        enum InitKind { NULL_I, SINGLE_I, COMPOUND_I };

                        static TypeKind type( Type * );
                        static InitKind initializer( Initializer *);

                        static NameInCollection *declaration( ObjectDecl *objdecl, SymTab::Indexer *index );
                        static std::list< Statement * >
                        matchInit( NameInCollection *, ObjectDecl *, Initializer * );
                        static Statement *constructAssgn( std::string membname, ObjectDecl *toInit, SingleInit *sinit );

                        // static std::list< Statement * > constructListAssgn( NameAssociation<Expression *, BreakDesignator > assoc );
                };
        };

        class BreakInitializer {
                enum InitKind { EMPTY, SINGLE, COMPOUND };

                class BreakDesignator;
                typedef BreakDesignator NameSplitter;

          public:
                typedef std::list<Initializer *>::iterator element_iterator;
                typedef std::list< NameSplitter >::iterator name_iterator;

                BreakInitializer ( Initializer *_init ) : kind( EMPTY ), sinit(0), cinit(0) {
                        std::list<Expression *> temp;

                        if ( ( sinit=dynamic_cast< SingleInit * >(_init) ) != 0 ) {
                                kind = SINGLE;
                                temp = sinit->get_designators();
                        } else if ( ( cinit=dynamic_cast< ListInit * >(_init) ) != 0 ) {
                                kind = COMPOUND;
                                temp = cinit->get_designators();
                        } // if

                        std::transform( temp.begin(), temp.end(), std::back_inserter( designators ), ctor_noptr<NameSplitter, Expression *> );
                }

                //BreakInitializer( const BreakInitializer &other ) { this.col = other.col; }
                ~BreakInitializer () {}

                BreakInitializer set_name( NameSplitter &name ) {
                        designators.clear();
                        designators.push_back( name );

                        return *this;
                }

                element_iterator element_begin() {
                        assert( cinit != 0 );
                        return cinit->begin_initializers();
                }
                element_iterator element_end() {
                        assert( cinit != 0 );
                        return cinit->end_initializers();
                }

                name_iterator names_begin() { return designators.begin(); }
                name_iterator names_end() { return designators.end(); }

                int names_size() const { return designators.size(); }

                bool has_index() const { return ! designators.empty(); }
                bool is_single() const { return kind == SINGLE; }
                bool is_composite() const { return kind == COMPOUND;  }

                Expression *get_value() {
                        switch ( kind ) {
                          case EMPTY:
                                return 0;
                                break;
                          case SINGLE:
                                return sinit->get_value();
                                break;
                          case COMPOUND:
                                assert(false);
                                break;
                          default:
                                assert(false);
                        } // switch
                        return 0;
                }
                // attributes
          private:
                InitKind kind;
                SingleInit *sinit;
                ListInit *cinit;
                std::list< BreakDesignator > designators;
                // helper classes
          public:
                class BreakDesignator {
                  public:
                        BreakDesignator( Expression *exp ) {
                                Expression *prfx = exp;
                                UntypedMemberExpr *me = 0;

                                do {
                                        if ( (me=dynamic_cast< UntypedMemberExpr * >( prfx )) == 0 ) break;
                                        blown_struct.push_front( me->get_member() );
                                        prfx = me->get_aggregate();
                                } while ( prfx != 0 );

                                NameExpr *ne;
                                if ( (ne=dynamic_cast< NameExpr * >( prfx )) != 0 ) 
                                        blown_struct.push_front( ne->get_name() );
                        }

                        BreakDesignator( std::string name ) {
                                blown_struct.push_front( name );
                        }

                        bool is_flat() const { return blown_struct.size() == 1; }
                        bool is_nested() const { return blown_struct.size() > 1; }

                        std::string get_name() { return blown_struct.front(); }

                        BreakDesignator &name_remainder() {
                                blown_struct.pop_front();
                                return *this;
                        }

                  private:
                        std::list< std::string > blown_struct;
                };
        };
} // namespace InitTweak

#endif // _BASINIT_H_

// Local Variables: //
// tab-width: 4 //
// mode: c++ //
// compile-command: "make install" //
// End: //