source: branches/with_autoconf/src/sc_uint.h @ 34

Last change on this file since 34 was 24, checked in by nipo, 16 years ago

Sync with trunk, avoid warning about pointer soup
File size: 8.9 KB
Line 
1/*------------------------------------------------------------\
2|                                                             |
3| Tool    :                  systemcass                       |
4|                                                             |
5| File    :                 sc_uint.h                         |
6|                                                             |
7| Author  :                 Buchmann Richard                  |
8|                                                             |
9| Date    :                   09_07_2004                      |
10|                                                             |
11\------------------------------------------------------------*/
12#ifndef __SC_UINT_H__
13#define __SC_UINT_H__
14
15#include <data_field.h>
16#include <sc_numrep.h>
17#include <sc_bit.h>
18#include <sc_logic.h>
19#include <sc_bv.h>
20#include <cstdlib>
21
22// ----------------------------------------------------------------------------
23//  CLASS : sc_uint<W>
24//
25// ----------------------------------------------------------------------------
26
27#include "sc_nbdefs.h"
28
29namespace sc_dt {
30
31typedef sc_uint<1> sc_uint_bit_ref;
32typedef sc_uint<1> sc_uint_bit_ref_r;
33
34// --------------------------------
35// CLASS : sc_uint_subref_r
36//
37// Used for range, concat functions
38class sc_uint_subref_r
39{
40  template <int W> friend class sc_dt::sc_uint;
41  int       left, right;
42  public : uint64    val;
43  sc_uint_subref_r (uint64 val_, int left_, int right_)
44  {
45    val = val_; left = left_; right = right_;
46  }
47  public:
48  inline uint64 read () const { return val; }
49  inline const sc_uint_subref_r& operator | (const sc_uint_subref_r &v) const
50  { print_warning (); return *this; }
51
52  private :void print_warning () const;
53};
54
55//
56#define MASK32(W) ((~ (const uint32)0) >> (sizeof (uint32) * 8 - W))
57#define MASK64(W) ((~ (const uint64)0) >> (sizeof (uint64) * 8 - W))
58//
59
60template<int W> struct s_uint_type { typedef uint64 uint_type;};
61#define DECLAR_UINT_TYPE(W) template<> struct s_uint_type<W> { typedef smallest_uint uint_type; }// not declared as uint16 because << operator threats like a character
62DECLAR_UINT_TYPE( 1);
63DECLAR_UINT_TYPE( 2);
64DECLAR_UINT_TYPE( 3);
65DECLAR_UINT_TYPE( 4);
66DECLAR_UINT_TYPE( 5);
67DECLAR_UINT_TYPE( 6);
68DECLAR_UINT_TYPE( 7);
69DECLAR_UINT_TYPE( 8);
70#undef DECLAR_UINT_TYPE
71#define DECLAR_UINT_TYPE(W) template<> struct s_uint_type<W> { typedef uint16 uint_type; }
72DECLAR_UINT_TYPE( 9);
73DECLAR_UINT_TYPE(10);
74DECLAR_UINT_TYPE(11);
75DECLAR_UINT_TYPE(12);
76DECLAR_UINT_TYPE(13);
77DECLAR_UINT_TYPE(14);
78DECLAR_UINT_TYPE(15);
79DECLAR_UINT_TYPE(16);
80#undef DECLAR_UINT_TYPE
81#define DECLAR_UINT_TYPE(W) template<> struct s_uint_type<W> { typedef uint32 uint_type; }
82DECLAR_UINT_TYPE(17);
83DECLAR_UINT_TYPE(18);
84DECLAR_UINT_TYPE(19);
85DECLAR_UINT_TYPE(20);
86DECLAR_UINT_TYPE(21);
87DECLAR_UINT_TYPE(22);
88DECLAR_UINT_TYPE(23);
89DECLAR_UINT_TYPE(24);
90DECLAR_UINT_TYPE(25);
91DECLAR_UINT_TYPE(26);
92DECLAR_UINT_TYPE(27);
93DECLAR_UINT_TYPE(28);
94DECLAR_UINT_TYPE(29);
95DECLAR_UINT_TYPE(30);
96DECLAR_UINT_TYPE(31);
97DECLAR_UINT_TYPE(32);
98#undef DECLAR_UINT_TYPE
99
100class sc_uint_subref_r;
101
102template<int W>     /* width of data type = SC_INTWIDTH */
103class sc_uint
104{
105  /***********************/
106  /* SYSTEMCASS SPECIFIC */
107  /***********************/
108  typedef sc_uint<W>                         this_type;
109  typedef typename s_uint_type<W>::uint_type data_type;
110
111  typedef data_type sc_uint_subref;
112//typedef data_type sc_uint_subref_r;
113    /* removed since "operator ," was going wrong */
114
115// internal
116        union {
117    val_field<W,(sizeof (data_type) * 8) - W,data_type> vf; /* To compute */
118                data_type val;          /* To return an int reference (read function) */
119//        data_type valW:W; /* works with little endianess only */
120//  bool      valB[W]; /* removed since 1 bool takes 1 byte */
121        };
122
123  /***********************/
124  /*        L R M        */
125  /***********************/
126public:
127  sc_uint ()                { val = 0; }
128//  sc_uint (data_type val_)  { val = 0; write (val_); }
129  sc_uint (const char *a)   { val = 0; write (std::atoi (a)); }
130  sc_uint (unsigned short a){ val = 0; write (a); }
131  sc_uint (short a)         { val = 0; write (a); }
132  sc_uint (unsigned long a) { val = 0; write (a); }
133  sc_uint (long a)          { val = 0; write (a); }
134  sc_uint (unsigned int a)  { val = 0; write (a); }
135  sc_uint (int a)           { val = 0; write (a); }
136  sc_uint (int64 a)         { val = 0; write (a); }
137  sc_uint (uint64 a)        { val = 0; write (a); }
138  sc_uint (double a)        { val = 0; write (a); }
139
140  template <int W2> sc_uint (const sc_uint<W2> &val_) { val = 0; write (val_.read());}
141  /* this template doesn't redefine default copy constructor of sc_uint.
142   * So, we define by this way
143   */
144  sc_uint (const sc_uint &val_)          { val = 0; write (val_.read()); }
145  sc_uint (const sc_uint_subref_r &val_) { val = 0; write (val_.read()); } 
146    /* the user needs to cast explicitly result of range () method. */
147
148  /***********************/
149  /* SYSTEMCASS SPECIFIC */
150  /***********************/
151  // read/write
152  inline const data_type& read() const { return val; }
153  inline void write(data_type val_)    { vf.valW = val_; }
154  template <int W2> inline void write (const sc_uint<W2> val_) { write (val_.read()); }
155//inline void write (const sc_uint<W> val_) { write (val_.read()); }
156  inline void write (const sc_uint_subref_r& s) { write (s.read()); }
157
158  /***********************/
159  /*        L R M        */
160  /***********************/
161  // operators
162  inline operator const data_type& () const { return read (); }
163//  inline void write(uint64 val_) { val = val_ & MASK64(W); }
164//  inline void write(unsigned int val_)   { val = val_ & MASK32(W); }
165        template <typename T> inline sc_uint& operator = (const T& val_) 
166  { write (val_); return *this; }
167        inline sc_uint& operator = (const sc_uint_subref_r& a) 
168  { write (a);    return *this; }
169
170  // explicit conversions
171  inline uint32         to_uint   () const {return val & MASK32(W);}
172  inline int32          to_int    () const {return val & MASK32(W);}
173  inline uint64         to_uint64 () const {return val & MASK64(W);}
174  inline int64          to_int64  () const {return val & MASK64(W);}
175 
176  // explicit conversion to character string
177  const sc_string to_string       ( sc_numrep numrep = SC_DEC ) const 
178  { return sc_dt::to_string (val, W, numrep); }
179  const sc_string to_dec() const  { return to_string (SC_DEC); }
180  const sc_string to_bin() const  { return to_string (SC_BIN); }
181  const sc_string to_oct() const  { return to_string (SC_OCT); }
182  const sc_string to_hex() const  { return to_string (SC_HEX); }
183
184  // arithmetic
185#define DEFINE_OPERATOR(OPER)        \
186  template <typename T>              \
187  inline sc_uint& operator OPER (T v)\
188  { vf.valW OPER v; return *this; }
189
190  DEFINE_OPERATOR(<<=)
191  DEFINE_OPERATOR(>>=)
192  DEFINE_OPERATOR(+=)
193  DEFINE_OPERATOR(-=)
194  DEFINE_OPERATOR(*=)
195  DEFINE_OPERATOR(/=)
196  DEFINE_OPERATOR(%=)
197  DEFINE_OPERATOR(&=)
198  DEFINE_OPERATOR(|=)
199  DEFINE_OPERATOR(^=)
200#undef DEFINE_OPERATOR
201
202#if 0
203#define DEFINE_OPERATOR(OPER)                                              \
204  friend bool operator OPER (const data_type& a, const data_type& b);
205//  { return (a.valW) OPER (b.valW); }
206
207  DEFINE_OPERATOR(==)
208  DEFINE_OPERATOR(!=)
209  DEFINE_OPERATOR(>=)
210  DEFINE_OPERATOR(<=)
211#undef DEFINE_OPERATOR
212#endif
213  inline sc_uint_bit_ref operator [] (int v)
214  { return (vf.valW >> v) & 1; }
215  inline sc_uint_bit_ref_r operator [] (int v) const
216  { return (vf.valW >> v) & 1; }
217
218  template <int W2> 
219  inline sc_uint<W+W2> operator , (const sc_uint<W2> &b) const
220  { sc_uint<W+W2> res = read() << W2; res += b.read(); return res; }
221#if 0 
222std::cerr << "[" << to_bin() << "," << b.to_bin() << " = " << res.to_bin() << "]\n";
223#endif
224
225  inline sc_uint<W+1> operator , (bool b) const
226  { sc_uint<W+1> res = read(); res <<= 1; res += b; return res; }
227#if 0 
228std::cerr << "[" << to_bin() << "," << b.to_bin() << " = " << res.to_bin() << "]\n";
229#endif
230
231  template <int W2>
232  inline sc_uint<W2> operator , (const sc_uint_subref_r &v) const
233  { std::cerr << "Warning : \n"; return sc_uint<W2> (v.read()); }
234
235  inline sc_uint_subref range (int left, int right)
236  { return (data_type)((data_type) (((data_type)~(0)) >> (sizeof (data_type) * 8 - left - 1)) & val) >> right; }
237
238  inline sc_uint_subref_r range (int left, int right) const
239  { return sc_uint_subref_r (((data_type) (((data_type)~(0)) >> (sizeof (data_type) * 8 - left - 1)) & val) >> right, left, right); }
240#if 0
241std::cerr << "range(" << left << "," << right << ")\n";
242std::cerr << "val = " << val << "\n";
243std::cerr << "~0 >> " << (sizeof (data_type) * 8 - left - 1) << " = " << (data_type) (((data_type)~(0)) >> (sizeof (data_type) * 8 - left - 1)) << "\n";
244std::cerr <<  ((data_type) ((((data_type)~(0)) >> (sizeof (data_type) * 8 - left - 1)) & val) >> right) << "\n";
245std::cerr << "data_type = " << sizeof (data_type) << "\n";
246#endif
247
248}; 
249
250//
251// no sign flag to threat
252//
253
254inline std::ostream& operator << (std::ostream &o, const sc_uint_subref_r& s)
255{ return o << s.val; }
256
257} /* end of sc_dt namespace */
258
259#endif /* __SC_UINT_H__ */
260
Note: See TracBrowser for help on using the repository browser.