/net/fileserver/nas/home/mdh/vrq/src/cfref.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
 *****************************************************************************
 */
/******************************************************************************
 *
 *
 *         cfref.hpp
 *              - class definition of forward reference 
 *                definition nodes
 *
 ******************************************************************************
 */

#ifndef CFREF_HPP
#define CFREF_HPP

#include <stdio.h>
#include <set>
#include <list>
#include <algorithm>
#include "glue.h"
#include "cnode.h"
#include "cdecl.h"


class CNode;

class CFref : public CDecl
{
private:
        CDecl*      decl;             
        Decl_t      direction;        
        int         constrained;      
        set<Decl_t> typeConstraints;  
        CNode*      msb;              
        CNode*      lsb;              
        int         lval;             

        int         isArray;          
        int         lsbVolatile;      
        int         msbVolatile;      
        int         lsbConstant;      
        int         msbConstant;      
        int         isInconsistant;   

        int         currentDirection; 

        int         refCount;         
public:
        CFref( CSymbol* symbol, Coord_t* aLoc );
        virtual CDecl* Clone( CObstack* heap ) { MASSERT(FALSE); }
        void SetDecl( CDecl* aDecl );
        CDecl* GetDecl( void );
        void    SetRangeInfo( int isArray, CNode* range );
        CNode*  GetMsb( void );
        CNode*  GetLsb( void );
        void DisableWidthInferencing() { isInconsistant = TRUE; } 
         virtual int  IsWidthConstant( void );
         virtual int  IsWidthVolatile( void );
        virtual int  IsWidthEvaluateable( void );
        virtual INT32 GetWidth( void );
        virtual CNode* GetRange();
        Decl_t Direction() { return direction; }
        void  Direction( Decl_t d ) { direction = d; }
        void    Lval( int aLval ) { lval = aLval; }
        int     Lval() { return lval; }
        void    IsArray( int v ) { isArray = v; }
        int     IsArray() { return isArray; }
        int     IndicesRangeValid();
        void   ConstrainTypes( list<Decl_t>& aTypes ) {
            list<Decl_t> types(aTypes);
            
            list<Decl_t>::iterator ptr;
            for( ptr = aTypes.begin(); ptr != aTypes.end(); ++ptr ) {
                CDecl::GetMembers( *ptr, types );
            }
            if( typeConstraints.size() == 0 ) {
                MASSERT( !constrained );
                set_union( types.begin(), types.end(),
                            typeConstraints.begin(), typeConstraints.end(),
                            inserter( typeConstraints, 
                                      typeConstraints.begin() ) );
            } else {
                set_intersection( types.begin(), types.end(),
                            typeConstraints.begin(), typeConstraints.end(),
                            inserter( typeConstraints, 
                                      typeConstraints.begin() ) );
            }
            constrained = TRUE;
        } 
        int    IsTypeValid( Decl_t t ) {
                if( !constrained ) {
                        MASSERT( typeConstraints.size() == 0 );
                        return TRUE;
                }
                list<Decl_t> searchList;
                CDecl::GetMembers( t, searchList );
                list<Decl_t>::iterator ptr;
                if( typeConstraints.count( t ) != 0 ) {
                    return TRUE;
                }
                for( ptr = searchList.begin(); 
                                        ptr != searchList.end(); ++ptr ) {
                    if( typeConstraints.count( *ptr ) != 0 ) {
                        return TRUE;
                    }
                }
                return FALSE;   
        }
        virtual void Dump( FILE* f );
private:
        void SetRange( CNode* ) { MASSERT( FALSE ); }
        CFref( const CFref& );
};

#endif // CFREF_HPP