const.h

Go to the documentation of this file.

#ifndef CONST_H
#define CONST_H


/*===============================<o>=====================================

Copyright 1996, 1997, 2004 Ian Kaplan, Bear Products International,
www.bearcave.com.

All Rights Reserved

You may use this software in software components for which you do
not collect money (e.g., non-commercial software).  All commercial
use is reserved.

===============================<o>=====================================*/


#include <assert.h>

#include "type.h"


#ifndef NULL
#define NULL 0
#endif

enum { bad_constant,
       cn_sign,          // a signed scalar constant
       cn_unsign,        // an unsigned scalar constant
       cn_real,          // a real constant
       cn_aggregate      // an "aggragate" constant for either
                         // an array or a record. 
     };


class vhdl_const {
public:
    vhdl_const(void) { }

  void *operator new( unsigned int num_bytes )
  {
    assert( FALSE );
    return NULL;
  }

  void *operator new( unsigned int num_bytes, pool *mem_pool )
  {
    return mem_pool->GetMem( num_bytes );
  }

  virtual const uint get_cn_kind( void ) { return bad_constant; }

    // virtual functions specific to a class
    virtual void set_val( int i )
    {
        assert( FALSE );
    }
    virtual const int get_val(void)
    {
        assert( FALSE );
        return 0;
    }
    virtual void set_uval( uint u )
    {
        assert( FALSE );
    }
    virtual const uint get_uval(void)
    {
        assert( FALSE );
        return 0;
    }
    virtual void set_real( float f )
    {
        assert( FALSE );
    }
    virtual const float get_real(void)
    {
        assert( FALSE );
        return (float)0.0;
    }
    //
    //
    //
    virtual void set_agg_ty( pType ty ) 
    {
        assert( FALSE );
    }    
    virtual const pType get_agg_ty(void)
    {
        return NULL;
    }
    //
    // const_agg 
    //
    virtual void set_tree( NODE *tree ) 
    {
        assert( FALSE );
    }
    virtual const NODE *get_tree(void)
    {
        return NULL;
    }
};  // vhdl_const




class const_range_signed : public vhdl_const {
private:
    int val;
public:
    const_range_signed(void) { val = 0; }
    const_range_signed(int i) { val = i; }
    void set_val( int i )
    {
        val = i;
    }
    const int get_val(void)
    {
        return val;
    }

    const uint get_cn_kind( void ) { return cn_sign; }
}; // const_range_signed



/*
 * const_range_unsigned
 *
 */
class const_range_unsigned : public vhdl_const {
private:
    uint val;
public:
    const_range_unsigned() { val = 0; }
    const_range_unsigned( uint u ) { val = u; }
    void set_uval( uint u )
    {
        val = u;
    }
    const uint get_uval(void)
    {
        return val;
    }
    const uint get_cn_kind( void ) { return cn_unsign; }
}; // const_range_unsigned


class const_real : public vhdl_const {
private:
    float real_val;

public:
    const_real(void) { real_val = 0.0; }
    void set_real( float f )
    {
        real_val = f;
    }
    const float get_real(void)
    {
        return real_val;
    }
    const uint get_cn_kind( void ) { return cn_real; }
}; // const_real



class const_agg : public vhdl_const {
private:
    pType ty_aggragate;
    NODE *agg_tree;
public:
    const_agg(void) 
    { 
        ty_aggragate = NULL;
        agg_tree = NULL;
    }
    
    void set_agg_ty( pType ty ) 
    {
        ty_aggragate = ty;
    }    
    const pType get_agg_ty(void)
    {
        return ty_aggragate;
    }

    void set_tree( NODE *tree ) 
    {
        assert( tree != NULL );
        agg_tree = tree;
    }
    const NODE *get_tree(void)
    {
        return agg_tree;
    }
    const uint get_cn_kind( void ) { return cn_aggregate; }
}; // const_agg


#endif

---