CompositeLiteral.hh

Go to the documentation of this file.

#ifndef COMPOSITE_LITERAL_HH
#define COMPOSITE_LITERAL_HH

//---------------------------------------------------------------------------
// Copyright (c) 1995-2005 Ohio Board of Regents and the University of
// Cincinnati.  All Rights Reserved.

// You may modify, distribute, and use the software contained in this package
// under the terms of the "GNU LIBRARY GENERAL PUBLIC LICENSE" version 2,
// June 1991. A copy of this license agreement can be found in the file
// "LGPL", distributed with this archive.
//---------------------------------------------------------------------------

#include "tyvis/LValue.hh"
#include "tyvis/UniversalInteger.hh"

class TyvisVarArgs;
class CompositeTypeInfo;
class SubElementFactory;
class ArrayTypeInfo;
class RecordTypeInfo;
class ScalarTypeInfo;

class CompositeLiteral : public LValue {
public:
  CompositeLiteral();
  CompositeLiteral( const CompositeTypeInfo &initTypeInfo );

  CompositeLiteral( const TypeInfo &initTypeInfo,
                    const RValue &initValue );

  CompositeLiteral( const CompositeTypeInfo &initTypeInfo,
                    TyvisVarArgs &initValue );
  
  CompositeLiteral( TyvisVarArgs &initValue );


  CompositeLiteral( const SubElementFactory &subElementFactory );
  CompositeLiteral( const ArrayTypeInfo &typeInfo,
                    const string &initValue );
  CompositeLiteral( const ArrayTypeInfo &typeInfo,
                    const RValue &initValue );
  CompositeLiteral( const CompositeLiteral &that );

  CompositeLiteral( CompositeLiteral &that,
                    const ScalarTypeInfo &sliceSpecifier );

  ~CompositeLiteral();

  int getIntValue() const;
  LONG getInt64Value() const;
  double getDoubleValue() const;

  bool isScalarType() const { return false; }
  bool isCompositeType() const { return true; }

  RValue &operator=( const RValue &that );
  CompositeLiteral &operator=( const CompositeLiteral &that );

  bool operator==( const RValue & ) const;
  bool operator!= (const RValue & ) const;
  bool operator> (const RValue &) const;
  bool operator>= (const RValue &) const;
  bool operator< (const RValue &) const;
  bool operator<= (const RValue &) const;

  const TypeInfo &getTypeInfo() const;
  const TypeInfo &getElementTypeInfo( const RValue &index = defaultIndex() ) const;
  const ScalarTypeInfo &getIndexTypeInfo( const RValue &index = defaultIndex() ) const;

  const RValue &operator[]( int index ) const;
  RValue &operator[]( int index );
  const RValue &operator[]( const RValue &index ) const;
  RValue &operator[]( const RValue &index );

  RValue &getField( int index );
  const RValue &getField( int index ) const;
  const RValue &getField( const RValue &index ) const;
  RValue &getField( const RValue &index );

  void append( const RValue &newElement );

  Value vhdlPlus( const RValue & ) const;
  Value vhdlMinus( const RValue & ) const;
  Value vhdlMultiply( const RValue & ) const;
  Value vhdlDivide( const RValue & ) const;
  Value vhdlMod( const RValue & ) const;
  Value vhdlRem( const RValue & ) const;
  Value vhdlPow( const RValue & ) const;
  Value vhdlAnd( const RValue &rhs) const; 
  Value vhdlOr( const RValue &rhs) const; 
  Value vhdlNand( const RValue &rhs) const; 
  Value vhdlNor( const RValue &rhs) const;
  Value vhdlXor( const RValue &rhs) const; 
  Value vhdlXnor( const RValue &rhs) const; 
  Value vhdlNot() const; 
  Value vhdlSll( const RValue &rhs ) const;
  Value vhdlSrl( const RValue &rhs ) const;
  Value vhdlSla( const RValue &rhs ) const;
  Value vhdlSra( const RValue &rhs ) const;
  Value vhdlRol( const RValue &rhs ) const;
  Value vhdlRor( const RValue &rhs ) const;
  Value vhdlConcatenate( const RValue &rhs ) const;

  const RValue &readVal() const;
  RValue &readVal();

  bool isPhysicalType() const { return false; }
  const string &getUnit() const;
  LONG getValue() const;
  int getUnits() const;
  const EnumerationLiteral &vhdlEqual( const RValue & ) const;
  const EnumerationLiteral &vhdlNotEqual( const RValue & ) const;
  const EnumerationLiteral &vhdlGreaterThan( const RValue & ) const;
  const EnumerationLiteral &vhdlGreaterThanEqual( const RValue & ) const;
  const EnumerationLiteral &vhdlLessThan( const RValue & ) const;
  const EnumerationLiteral &vhdlLessThanEqual( const RValue & ) const;

  RValue &all();
  const RValue &all() const;
  void updateVal( const RValue & );

  SignalNetinfo &addToFanOut( VHDLKernel * );
  //DRH
  SignalNetinfo &addChild( SignalNetinfo &, VHDLKernel * );
  

  Value left( const RValue &param = defaultIndex() ) const;
  Value right( const RValue &param = defaultIndex() ) const;
  Value high( const RValue &param = defaultIndex() ) const;
  Value low( const RValue &param = defaultIndex() ) const;
  const ScalarTypeInfo &range( const RValue &index = defaultIndex() ) const;
  const ScalarTypeInfo &reverse_range( const RValue &index = defaultIndex() ) const;
  Value length( const RValue &index = defaultIndex() ) const;
  Value ascending( const RValue &index = defaultIndex() ) const;

protected:
  void append( RValue *newElement );

  void shiftLogical( int shiftAmount );

  static const UniversalInteger &defaultIndex();

private:
  const ScalarTypeInfo &CompositeLiteral::divineIndexTypeInfo() const;

  int storageIndex( int elementIndex ) const;

  void cloneElements( const vector<RValue *> &thatElements );

  static void buildElements( const CompositeTypeInfo &arrayTypeInfo,
                             vector<RValue *> &elements,
                             const SubElementFactory *subElementFactory,
                             int numElements = -1 );

  void destroyElements();

  void insertElements( const string &initElements );

  void insertElements( const RValue &initElements );

  void sliceElements( CompositeLiteral &that );

  static CompositeTypeInfo *buildSliceTypeInfo( CompositeLiteral &that,
                                                const ScalarTypeInfo &sliceSpecifier );

  const CompositeTypeInfo *myTypeInfo;
  mutable const ScalarTypeInfo *indexTypeInfo;

  vector<RValue *> myElements;
  bool deleteMembers;
  const SubElementFactory *myFactory;

  Value bitOperation( const RValue &rhs,
                      Value (EnumerationLiteral::*operation)(const RValue &) const
                      ) const;
};

#endif

---