source: sources/src/sc_int.h @ 53

Last change on this file since 53 was 52, checked in by meunier, 12 years ago

Code formatting in all source files.
File size: 8.6 KB
Line 
1/*------------------------------------------------------------\
2|                                                             |
3| Tool    :                  systemcass                       |
4|                                                             |
5| File    :                 sc_int.h                          |
6|                                                             |
7| Author  :                 Buchmann Richard                  |
8|                                                             |
9| Date    :                   09_07_2004                      |
10|                                                             |
11\------------------------------------------------------------*/
12#ifndef __SC_INT_H__
13#define __SC_INT_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_int<W>
24//
25//  Template class sc_int<W> is the interface that the user sees. It is
26//  derived from sc_int_base and most of its methods are just wrappers
27//  that call the corresponding method in the parent class. Note that
28//  the width of sc_int datatype is specified as a template parameter.
29// ----------------------------------------------------------------------------
30
31#include "sc_nbdefs.h"
32
33namespace sc_dt {
34
35typedef sc_int<1> sc_int_bit_ref;
36typedef sc_int<1> sc_int_bit_ref_r;
37
38
39#define MASK32(W) ((~ (const uint32)0) >> (sizeof (uint32) * 8 - W))
40#define MASK64(W) ((~ (const uint64)0) >> (sizeof (uint64) * 8 - W))
41
42template<int W> struct s_int_type { typedef int64 int_type; };
43
44#define DECLAR_INT_TYPE(W) template<> struct s_int_type<W> { typedef smallest_int int_type; } // not declared as in8 because << operator threats like a character
45DECLAR_INT_TYPE(1);
46DECLAR_INT_TYPE(2);
47DECLAR_INT_TYPE(3);
48DECLAR_INT_TYPE(4);
49DECLAR_INT_TYPE(5);
50DECLAR_INT_TYPE(6);
51DECLAR_INT_TYPE(7);
52DECLAR_INT_TYPE(8);
53#undef DECLAR_INT_TYPE
54
55#define DECLAR_INT_TYPE(W) template<> struct s_int_type<W> { typedef int16 int_type; }
56DECLAR_INT_TYPE( 9);
57DECLAR_INT_TYPE(10);
58DECLAR_INT_TYPE(11);
59DECLAR_INT_TYPE(12);
60DECLAR_INT_TYPE(13);
61DECLAR_INT_TYPE(14);
62DECLAR_INT_TYPE(15);
63DECLAR_INT_TYPE(16);
64#undef DECLAR_INT_TYPE
65
66#define DECLAR_INT_TYPE(W) template<> struct s_int_type<W> { typedef int32 int_type; }
67DECLAR_INT_TYPE(17);
68DECLAR_INT_TYPE(18);
69DECLAR_INT_TYPE(19);
70DECLAR_INT_TYPE(20);
71DECLAR_INT_TYPE(21);
72DECLAR_INT_TYPE(22);
73DECLAR_INT_TYPE(23);
74DECLAR_INT_TYPE(24);
75DECLAR_INT_TYPE(25);
76DECLAR_INT_TYPE(26);
77DECLAR_INT_TYPE(27);
78DECLAR_INT_TYPE(28);
79DECLAR_INT_TYPE(29);
80DECLAR_INT_TYPE(30);
81DECLAR_INT_TYPE(31);
82DECLAR_INT_TYPE(32);
83#undef DECLAR_INT_TYPE
84
85// --------------------------------
86// CLASS : sc_int_subref_r
87//
88// Used for range, concat functions
89
90class sc_int_subref_r {
91
92    template <int W> friend class sc_dt::sc_int;
93    int left, right;
94   
95    public :
96    int64 val;
97    sc_int_subref_r(int64 val_, int left_, int right_) {
98        val = val_; left = left_; right = right_;
99    }
100   
101    inline int64 read () const { return val; }
102    inline const sc_int_subref_r& operator | (const sc_int_subref_r &v) const {
103        print_warning ();
104        return *this;
105    }
106
107    private :
108    void print_warning () const;
109
110};
111
112//
113// to fix : propagation of the sign flag
114//
115
116class sc_int_subref_r;
117
118template< int W /* = SC_INTWIDTH */>
119class sc_int {
120
121    /***********************/
122    /* SYSTEMCASS SPECIFIC */
123    /***********************/
124    typedef sc_int<W> this_type;
125    typedef typename s_int_type<W>::int_type data_type;
126
127    typedef data_type sc_int_subref;
128
129    // internal
130    union {
131        val_field<W, (sizeof (data_type) * 8) - W,data_type> vf; /* To compute */
132        data_type val;          /* To return an int reference (read function) */
133    };
134
135
136    /***********************/
137    /*        L R M        */
138    /***********************/
139    public:
140    sc_int()                  { val = 0; }
141    sc_int (const char * a)   { val = 0; write (std::atoi (a)); }
142    sc_int (unsigned short a) { val = 0; write (a); }
143    sc_int (short a)          { val = 0; write (a); }
144    sc_int (unsigned long a)  { val = 0; write (a); }
145    sc_int (long a)           { val = 0; write (a); }
146    sc_int (unsigned int a)   { val = 0; write (a); }
147    sc_int (int a)            { val = 0; write (a); }
148    sc_int (int64 a)          { val = 0; write (a); }
149    sc_int (uint64 a)         { val = 0; write (a); }
150    sc_int (double a)         { val = 0; write (a); }
151
152    template <int W2> sc_int (const sc_int<W2> &val_) { val = 0; write (val_.read());}
153    /* this template doesn't redefine default copy constructor of sc_int.
154     * So, we define by this way
155     */
156
157    sc_int (const sc_int &val_) { val = val_.val; }
158    sc_int (const sc_int_subref_r & a) { val = 0; write (a); } 
159    /* the user needs to cast explicitly result of range () method. */
160
161
162    /***********************/
163    /* SYSTEMCASS SPECIFIC */
164    /***********************/
165
166    // read/write
167    inline const data_type& read() const { return val; }
168    inline void write(data_type val_)    { vf.valW = val_; }
169    template <int W2> inline void write (const sc_int<W2> val_) { write (val_.read ()); }
170    inline void write (const sc_int_subref_r& s) { write (s.read()); }
171
172    /***********************/
173    /*        L R M        */
174    /***********************/
175
176    // operators
177    inline operator const data_type & () const {
178        return read ();
179    }
180
181    template <typename T> inline sc_int& operator = (const T& val_) {
182        write (val_);
183        return *this;
184    }
185
186    inline sc_int & operator = (const sc_int_subref_r& a) {
187        write (a);
188        return *this;
189    }
190
191    // explicit conversions
192    inline uint32 to_uint()   const { return val & MASK32(W); }
193    inline int32  to_int()    const { return val & MASK32(W); }
194    inline uint64 to_uint64() const { return val & MASK64(W); }
195    inline int64  to_int64()  const { return val & MASK64(W); }
196
197    // explicit conversion to character string
198    const sc_string to_string(sc_numrep numrep = SC_DEC) const {
199        return sc_dt::to_string (val, W, numrep);
200    }
201    const sc_string to_dec() const { return to_string (SC_DEC); }
202    const sc_string to_bin() const { return to_string (SC_BIN); }
203    const sc_string to_oct() const { return to_string (SC_OCT); }
204    const sc_string to_hex() const { return to_string (SC_HEX); }
205
206    // arithmetic
207#define DEFINE_OPERATOR(OPER)           \
208    template <typename T>               \
209    inline sc_int & operator OPER (T v) \
210    { vf.valW OPER v; return *this; }
211
212    DEFINE_OPERATOR(<<=)
213    DEFINE_OPERATOR(>>=)
214    DEFINE_OPERATOR(+=)
215    DEFINE_OPERATOR(-=)
216    DEFINE_OPERATOR(*=)
217    DEFINE_OPERATOR(/=)
218    DEFINE_OPERATOR(%=)
219    DEFINE_OPERATOR(&=)
220    DEFINE_OPERATOR(|=)
221    DEFINE_OPERATOR(^=)
222#undef DEFINE_OPERATOR
223
224    inline sc_int_bit_ref & operator [] (int v) {
225        return (vf.valW >> v) & 1;
226    }
227    inline sc_int_bit_ref_r & operator [] (int v) const {
228        return (vf.valW >> v) & 1;
229    }
230
231    template <int W2> 
232    inline sc_int<W + W2> operator , (const sc_int<W2> & b) const {
233        sc_int<W + W2> res = read() << W2; res += b.read();
234        return res;
235    }
236
237    inline sc_int<W + 1> operator , (bool b) const {
238        sc_int<W + 1> res = read(); res <<= 1; res += b;
239        return res;
240    }
241
242    template <int W2>
243    inline sc_int<W2> operator , (const sc_int_subref_r &v) const {
244        std::cerr << "Warning : \n";
245        return sc_int<W2> (v.read());
246    }
247
248    inline sc_int_subref range (int left, int right) {
249        return (data_type)((data_type) (((data_type)~(0)) >> (sizeof (data_type) * 8 - left - 1)) & val) >> right;
250    }
251
252    inline sc_int_subref_r range (int left, int right) const {
253        return sc_int_subref_r (((data_type) (((data_type)~(0)) >> (sizeof (data_type) * 8 - left - 1)) & val) >> right, left, right);
254    }
255#if 0
256    std::cerr << "range(" << left << "," << right << ")\n";
257    std::cerr << "val = " << val << "\n";
258    std::cerr << "~0 >> " << (sizeof (data_type) * 8 - left - 1) << " = " << (data_type) (((data_type)~(0)) >> (sizeof (data_type) * 8 - left - 1)) << "\n";
259    std::cerr <<  ((data_type) ((((data_type)~(0)) >> (sizeof (data_type) * 8 - left - 1)) & val) >> right) << "\n";
260    std::cerr << "data_type = " << sizeof (data_type) << "\n";
261#endif
262
263};
264
265inline std::ostream & operator << (std::ostream &o, const sc_int_subref_r & s) {
266    return o << s.val;
267}
268
269#undef MASK32
270#undef MASK64
271
272} /* end of sc_dt namespace */
273
274#endif /* __SC_INT_H__ */
275
276/*
277# Local Variables:
278# tab-width: 4;
279# c-basic-offset: 4;
280# c-file-offsets:((innamespace . 0)(inline-open . 0));
281# indent-tabs-mode: nil;
282# End:
283#
284# vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
285*/
286
Note: See TracBrowser for help on using the repository browser.