/net/fileserver/nas/home/mdh/vrq/src/cblock.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (C) 1997-2007, Mark Hummel
 * This file is part of Vrq.
 *
 * Vrq is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * Vrq is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, 
 * Boston, MA  02110-1301  USA
 *****************************************************************************
 */
/******************************************************************************
 *
 *
 *         cblock.hpp
 *              - class definition of blocks 
 *
 ******************************************************************************
 */

#ifndef CBLOCK_HPP
#define CBLOCK_HPP

#include <vector>
#include "glue.h"
#include "cdecl.h"
#include "csymtab.h"


class CParam;
class CVar;
class CNode;
class CNet;
class CFref;
class CInstance;
class CGenvar;
class CPortDir;


class CBlock: public CDecl
{
protected:
        vector<CParam*>   paramList;
        vector<CVar*>     varList;
        vector<CGenvar*>  genvarList;
        vector<CFref*>    frefList;
        vector<CNet*>     netList;
        CBlock*           parent;
        vector<CBlock*>   children;
        CSymtab<CDecl>    symtab; 
private:
        CNode*            codeList;
        int               rebalance;
public:
        CBlock( CSymbol* name, Coord_t* aLoc );
        CBlock( CSymbol* name, Coord_t* aLoc, Decl_t dtype );
        virtual ~CBlock() {}
        virtual CDecl* Clone( CObstack* heap ) { MASSERT(FALSE); }
        virtual void Add( CInstance* instance );
        virtual void Add( CParam* param );
        virtual void Add( CNet* net );
        virtual void Add( CVar* var );
        virtual void Add( CBlock* child );
        virtual void Add( CFref* fref );
        virtual void Add( CGenvar* genvar );
        virtual void Add( CNode* code  );
        void    SetParent( CBlock* parent );
        CBlock* GetParent( void );
        virtual void Dump( FILE* f );
        vector<CNet*>*  GetNetList();
        vector<CVar*>*  GetVarList();
        vector<CParam*>* GetParamList();
        vector<CGenvar*>* GetGenvarList();
        virtual CNode*  GetCodeList();
        virtual void    SetCodeList( CNode* list );
        vector<CBlock*>* GetChildList();
        virtual vector<CPortDir*>*  GetPortDirList() 
                { static vector<CPortDir*> nullList; return &nullList;}
        virtual void    SetSymtab( CSymtab<CDecl>& symtab );
        virtual CSymtab<CDecl>& GetSymtab() { return symtab; }
        void    PreVisit1( int (*func)(CNode*,void*), void* data );
        void    PostVisit1( void (*func)(CNode*, void*), void* data );
        void    PostSubVisit1( CNode* (*func)(CNode*, void*), void* data );
protected:
        static void Reconnect( CNode *n );
        void RedeclarePorts();
        void LinkFrefs( CSymtab<CDecl>& portSymtab,
                        CSymtab<CDecl>& moduleSymtab,
                        vector<CFref*>& frefList, 
                        int inferVectors );
        virtual void CodeListChanged() {}
private:
        void LinkPortFref( CSymtab<CDecl>* symtab1,
                       CSymtab<CDecl>* symtab2,
                       CFref* fref  );
        void InferFref( CSymtab<CDecl>* symtab1,
                       CFref* fref,
                       int inferVector );
        void LinkFref( CSymtab<CDecl>* symtab,
                       CFref* fref, int inferVector );
        CBlock( const CBlock& );
};

typedef CBlock CScope;


#endif // CBLOCK_HPP