oaverilogparserstype.inl

openaccess与verilog互相转化时所用的源代码

// *****************************************************************************
// *****************************************************************************
// oaVerilogParserStype.inl
//
// This file contains the implementation for inline and template member
// functions of classes defined in oaVerilogParserStype.h file.
//
// *****************************************************************************
// Except as specified in the OpenAccess terms of use of Cadence or Silicon
// Integration Initiative, this material may not be copied, modified,
// re-published, uploaded, executed, or distributed in any way, in any medium,
// in whole or in part, without prior written permission from Cadence.
//
//		  Copyright 2003-2005 Cadence Design Systems, Inc.
//                           All Rights Reserved.
//
//  $Author: sailajad $
//  $Revision: 1.1 $
//  $Date: 2005/08/05 21:48:55 $
//  $State: Exp $
// *****************************************************************************
// *****************************************************************************



#if !defined(oaVerilogParserStype_I)
#define oaVerilogParserStype_I

BEGIN_VERILOG_NAMESPACE



// *****************************************************************************
// ParserStypeWrapper::ParserStypeWrapper()
//
// These are the constructors of the ParserStypeWrapper class.  Each constructor
// sets the type of the value stored as well as the initial value.
// *****************************************************************************
inline
ParserStypeWrapper::ParserStypeWrapper()
: type(UnknownType)
{
    value.id = 0;
}



// *****************************************************************************
// ParserStypeWrapper::~ParserStypeWrapper()
//
// This is the destructor of the ParserStypeWrapper class.
// *****************************************************************************
inline
ParserStypeWrapper::~ParserStypeWrapper()
{
}



// *****************************************************************************
// ParserStypeWrapper::clear()
//
// This is the destructors of the ParserStypeWrapper class.
// *****************************************************************************
inline void
ParserStypeWrapper::clear()
{
    type = UnknownType;
    value.id = 0;
}



// *****************************************************************************
// ParserStypeWrapper::operator=()
//
// This is the assignment operator for the ParserStypeWrapper.
// *****************************************************************************
inline ParserStypeWrapper&
ParserStypeWrapper::operator=(const ParserStypeWrapper	&rhs)
{
    if (&rhs == this) {
	return *this;
    }

    type = rhs.type;

    switch (type) {
      case UnknownType:
	  value.id = 0;
	  break;

      case SigTypeEnumType:
	  value.oaSigTypeMember = rhs.value.oaSigTypeMember;
	  break;

      case StringType:
	  value.oaStringMember = rhs.value.oaStringMember;
	  break;

      case ParamType:
	  value.oaParamMember = rhs.value.oaParamMember;
	  break;

      case ParamArrayType:
	  value.ParamListMember = rhs.value.ParamListMember;
	  break;

      case VerilogValueType:
	  value.verilogValueMember = rhs.value.verilogValueMember;
	  break;

      case VerilogRangeType:
	  value.verilogRangeMember = rhs.value.verilogRangeMember;
	  break;

      case VerilogNameListType:
	  value.verilogNameListMember = rhs.value.verilogNameListMember;
	  break;

      case VerilogValueListType:
	  value.verilogValueListMember = rhs.value.verilogValueListMember;
	  break;

      case VerilogRangeListType:
	  value.verilogRangeListMember = rhs.value.verilogRangeListMember;
	  break;
    }

    return *this;
}



// *****************************************************************************
// ParserStypeWrapper::deleteValue()
//
// This function deletes the value stored in the wrapper.  It assumes that the
// value was allocated with "new" and that neither managed types nor base types
// should be deleted.
// *****************************************************************************
inline void
ParserStypeWrapper::deleteValue()
{
    switch (type) {
      case UnknownType:
	  break;

      case StringType:
	  delete value.oaStringMember;
	  break;

      case ParamType:
	  delete value.oaParamMember;
	  break;

      case ParamArrayType:
	  delete value.ParamListMember;
	  break;

      case VerilogValueType:
	  delete value.verilogValueMember;
	  break;

      case VerilogRangeType:
	  delete value.verilogRangeMember;
	  break;

      case VerilogNameListType:
	  delete value.verilogNameListMember;
	  break;

      case VerilogValueListType:
	  delete value.verilogValueListMember;
	  break;

      case VerilogRangeListType:
	  delete value.verilogRangeListMember;
	  break;
    }

    clear();
}



// *****************************************************************************
// ParserStypeWrapper::oaStringStype()
// ParserStypeWrapper::oaSigTypeStype()
// ParserStypeWrapper::oaDesignStype()
// ParserStypeWrapper::oaParamStype()
// ParserStypeWrapper::ParamListStype()
// ParserStypeWrapper::verilogValueStype()
// ParserStypeWrapper::verilogRangeStype()
// ParserStypeWrapper::verilogNameListStype()
// ParserStypeWrapper::verilogValueListStype()
// ParserStypeWrapper::verilogRangeListStype()
//
// These are the data member access functions.  They track the type of the
// data being accessed as well as the data value.  The types defined in the 
// Parser.ypp file all end with the characters "()" which will cause
// Bison to generate code that will access the data members through these 
// functions.  Bison does not distingush between dereferencing a data member and
// assigning to the data member so we must return a writable reference to the
// data member and set the type, even if the the data member is not being
// assigned to.  This implies a certain degree of trust in Bison to properly
// manage the types.
// *****************************************************************************
inline oaString*&
ParserStypeWrapper::oaStringStype()
{
    type = StringType;
    return value.oaStringMember;
}

inline oaSigTypeEnum&
ParserStypeWrapper::oaSigTypeStype()
{
    type = SigTypeEnumType;
    return value.oaSigTypeMember;
}

inline oaParam*&
ParserStypeWrapper::oaParamStype()
{
    type = ParamType;
    return value.oaParamMember;
}

inline ParamList*&
ParserStypeWrapper::ParamListStype()
{
    type = ParamArrayType;
    return value.ParamListMember;
}

inline Value*&
ParserStypeWrapper::verilogValueStype()
{
    type = VerilogValueType;
    return value.verilogValueMember;
}

inline Range*&
ParserStypeWrapper::verilogRangeStype()
{
    type = VerilogRangeType;
    return value.verilogRangeMember;
}

inline NameList*&
ParserStypeWrapper::verilogNameListStype()
{
    type = VerilogNameListType;
    return value.verilogNameListMember;
}

inline ValueList*&
ParserStypeWrapper::verilogValueListStype()
{
    type = VerilogValueListType;
    return value.verilogValueListMember;
}

inline RangeList*&
ParserStypeWrapper::verilogRangeListStype()
{
    type = VerilogRangeListType;
    return value.verilogRangeListMember;
}



// *****************************************************************************
// ParserStypeCmp::operator()
//
// This is the comparison operator for the ParserStypeWrapper class.  It returns
// true if the left argument is "less" than the right argument, otherwise it
// returns false.  Since the value of the ParserStypeWrapper is a union of 
// pointers and other elements, this operator will only compare the id field of 
// the value union.
// *****************************************************************************
inline bool
ParserStypeCmp::operator()(const ParserStypeWrapper *left,
			   const ParserStypeWrapper *right) const
{
    return left->value.id < right->value.id;
}



END_VERILOG_NAMESPACE

#endif