Changeset 52 for sources/src/sc_uint.h


Ignore:
Timestamp:
Jan 22, 2013, 4:23:22 PM (11 years ago)
Author:
meunier
Message:

Code formatting in all source files.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • sources/src/sc_uint.h

    r27 r52  
    1010|                                                             |
    1111\------------------------------------------------------------*/
     12
    1213#ifndef __SC_UINT_H__
    1314#define __SC_UINT_H__
    … …  
    3233typedef sc_uint<1> sc_uint_bit_ref_r;
    3334
     35
    3436// --------------------------------
    3537// CLASS : sc_uint_subref_r
    3638//
    3739// Used for range, concat functions
    38 class 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;
     40// --------------------------------
     41
     42class sc_uint_subref_r {
     43    template <int W> friend class sc_dt::sc_uint;
     44    int left, right;
     45    public :
     46    uint64 val;
     47    sc_uint_subref_r(uint64 val_, int left_, int right_) {
     48        val = val_;
     49        left = left_;
     50        right = right_;
     51    }
     52
     53    public:
     54    inline uint64 read() const {
     55        return val;
     56    }
     57
     58    inline const sc_uint_subref_r & operator | (const sc_uint_subref_r & v) const {
     59        print_warning();
     60        return *this;
     61    }
     62
     63    private:
     64    void print_warning() const;
     65
    5366};
    5467
    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 
    60 template<int W> struct s_uint_type { typedef uint64 uint_type;};
     68
     69#define MASK32(W) ((~ (const uint32)0) >> (sizeof(uint32) * 8 - W))
     70#define MASK64(W) ((~ (const uint64)0) >> (sizeof(uint64) * 8 - W))
     71
     72
     73template<int W> struct s_uint_type {
     74    typedef uint64 uint_type;
     75};
     76
    6177#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
    62 DECLAR_UINT_TYPE( 1);
    63 DECLAR_UINT_TYPE( 2);
    64 DECLAR_UINT_TYPE( 3);
    65 DECLAR_UINT_TYPE( 4);
    66 DECLAR_UINT_TYPE( 5);
    67 DECLAR_UINT_TYPE( 6);
    68 DECLAR_UINT_TYPE( 7);
    69 DECLAR_UINT_TYPE( 8);
     78DECLAR_UINT_TYPE(1);
     79DECLAR_UINT_TYPE(2);
     80DECLAR_UINT_TYPE(3);
     81DECLAR_UINT_TYPE(4);
     82DECLAR_UINT_TYPE(5);
     83DECLAR_UINT_TYPE(6);
     84DECLAR_UINT_TYPE(7);
     85DECLAR_UINT_TYPE(8);
    7086#undef DECLAR_UINT_TYPE
     87
    7188#define DECLAR_UINT_TYPE(W) template<> struct s_uint_type<W> { typedef uint16 uint_type; }
    72 DECLAR_UINT_TYPE( 9);
     89DECLAR_UINT_TYPE(9);
    7390DECLAR_UINT_TYPE(10);
    7491DECLAR_UINT_TYPE(11);
    … …  
    7996DECLAR_UINT_TYPE(16);
    8097#undef DECLAR_UINT_TYPE
     98
    8199#define DECLAR_UINT_TYPE(W) template<> struct s_uint_type<W> { typedef uint32 uint_type; }
    82100DECLAR_UINT_TYPE(17);
    … …  
    98116#undef DECLAR_UINT_TYPE
    99117
     118
    100119class sc_uint_subref_r;
    101120
    102 template<int W>     /* width of data type = SC_INTWIDTH */
    103 class 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   /***********************/
    126 public:
    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()); }
     121
     122/* width of data type = SC_INTWIDTH */
     123template<int W>
     124class sc_uint {
     125
     126    /***********************/
     127    /* SYSTEMCASS SPECIFIC */
     128    /***********************/
     129    typedef sc_uint<W> this_type;
     130    typedef typename s_uint_type<W>::uint_type data_type;
     131    typedef data_type sc_uint_subref;
     132    //typedef data_type sc_uint_subref_r; /* removed since "operator ," was going wrong */
     133
     134
     135    // internal
     136    union {
     137        val_field<W, (sizeof(data_type) * 8) - W, data_type> vf; /* To compute */
     138        data_type val;          /* To return an int reference (read function) */
     139        // data_type valW: W; /* works with little endianess only */
     140        // bool valB[W];  /* removed since 1 bool takes 1 byte */
     141    };
     142
     143    /***********************/
     144    /*        L R M        */
     145    /***********************/
     146    public:
     147    sc_uint()                 { val = 0; }
     148    //  sc_uint(data_type val_)  { val = 0; write (val_); }
     149    sc_uint(const char * a)   { val = 0; write(std::atoi(a)); }
     150    sc_uint(unsigned short a) { val = 0; write(a); }
     151    sc_uint(short a)          { val = 0; write(a); }
     152    sc_uint(unsigned long a)  { val = 0; write(a); }
     153    sc_uint(long a)           { val = 0; write(a); }
     154    sc_uint(unsigned int a)   { val = 0; write(a); }
     155    sc_uint(int a)            { val = 0; write(a); }
     156    sc_uint(int64 a)          { val = 0; write(a); }
     157    sc_uint(uint64 a)         { val = 0; write(a); }
     158    sc_uint(double a)         { val = 0; write(a); }
     159
     160
     161    template <int W2> sc_uint(const sc_uint<W2> & val_) {
     162        val = 0;
     163        write(val_.read());
     164    }
     165   
     166    /* this template doesn't redefine default copy constructor of sc_uint.
     167     * So, we define by this way
     168     */
     169    sc_uint(const sc_uint & val_)          { val = 0; write(val_.read()); }
     170    sc_uint(const sc_uint_subref_r & val_) { val = 0; write(val_.read()); }
    146171    /* the user needs to cast explicitly result of range () method. */
    147172
    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(^=)
     173    /***********************/
     174    /* SYSTEMCASS SPECIFIC */
     175    /***********************/
     176    // read/write
     177    inline const data_type & read() const {
     178        return val;
     179    }
     180
     181    inline void write(data_type val_) {
     182        vf.valW = val_;
     183    }
     184
     185    template <int W2> inline void write(const sc_uint<W2> val_) {
     186        write(val_.read());
     187    }
     188
     189    // inline void write(const sc_uint<W> val_) {
     190    //     write(val_.read());
     191    // }
     192   
     193    inline void write(const sc_uint_subref_r & s) {
     194        write(s.read());
     195    }
     196
     197
     198    /***********************/
     199    /*        L R M        */
     200    /***********************/
     201    // operators
     202    inline operator const data_type & () const {
     203        return read();
     204    }
     205
     206    // inline void write(uint64 val_) {
     207    //     val = val_ & MASK64(W);
     208    // }
     209    // inline void write(unsigned int val_) {
     210    //     val = val_ & MASK32(W);
     211    // }
     212   
     213    template < typename T > inline sc_uint & operator = (const T & val_) {
     214        write(val_);
     215        return *this;
     216    }
     217
     218    inline sc_uint & operator = (const sc_uint_subref_r & a) {
     219        write(a);
     220        return *this;
     221    }
     222
     223    // explicit conversions
     224    inline uint32 to_uint()   const { return val & MASK32(W); }
     225    inline int32  to_int()    const { return val & MASK32(W); }
     226    inline uint64 to_uint64() const { return val & MASK64(W); }
     227    inline int64  to_int64()  const { return val & MASK64(W); }
     228
     229    // explicit conversion to character string
     230    const sc_string to_string(sc_numrep numrep = SC_DEC) const {
     231        return sc_dt::to_string(val, W, numrep);
     232    }
     233    const sc_string to_dec() const { return to_string(SC_DEC); }
     234    const sc_string to_bin() const { return to_string(SC_BIN); }
     235    const sc_string to_oct() const { return to_string(SC_OCT); }
     236    const sc_string to_hex() const { return to_string(SC_HEX); }
     237
     238
     239    // arithmetic
     240#define DEFINE_OPERATOR(OPER)            \
     241    template < typename T >              \
     242    inline sc_uint & operator OPER (T v) \
     243    { vf.valW OPER v; return *this; }
     244
     245    DEFINE_OPERATOR(<<=)
     246    DEFINE_OPERATOR(>>=)
     247    DEFINE_OPERATOR(+=)
     248    DEFINE_OPERATOR(-=)
     249    DEFINE_OPERATOR(*=)
     250    DEFINE_OPERATOR(/=)
     251    DEFINE_OPERATOR(%=)
     252    DEFINE_OPERATOR(&=)
     253    DEFINE_OPERATOR(|=)
     254    DEFINE_OPERATOR(^=)
    200255#undef DEFINE_OPERATOR
    201256
     257
     258    inline sc_uint_bit_ref operator [] (int v) {
     259        return (vf.valW >> v) & 1;
     260    }
     261
     262    inline sc_uint_bit_ref_r operator [] (int v) const {
     263        return (vf.valW >> v) & 1;
     264    }
     265
     266    template <int W2>
     267    inline sc_uint<W + W2> operator , (const sc_uint<W2> & b) const {
     268        sc_uint<W + W2> res = read() << W2;
     269        res += b.read();
     270        return res;
     271    }
     272
     273    inline sc_uint<W + 1> operator , (bool b) const {
     274        sc_uint<W + 1> res = read();
     275        res <<= 1;
     276        res += b;
     277        return res;
     278    }
     279
     280    template <int W2>
     281    inline sc_uint<W2> operator , (const sc_uint_subref_r & v) const {
     282        std::cerr << "Warning : \n"; // ??
     283        return sc_uint<W2> (v.read());
     284    }
     285
     286    inline sc_uint_subref range(int left, int right) {
     287        return (data_type) ((data_type) (((data_type) ~(0)) >> (sizeof(data_type) * 8 - left - 1)) & val) >> right;
     288    }
     289
     290    inline sc_uint_subref_r range(int left, int right) const {
     291        return sc_uint_subref_r (((data_type) (((data_type) ~(0)) >> (sizeof(data_type) * 8 - left - 1)) & val) >> right, left, right);
     292    }
     293
    202294#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
     295    std::cerr << "range(" << left << "," << right << ")\n";
     296    std::cerr << "val = " << val << "\n";
     297    std::cerr << "~0 >> " << (sizeof (data_type) * 8 - left - 1) << " = " << (data_type) (((data_type)~(0)) >> (sizeof (data_type) * 8 - left - 1)) << "\n";
     298    std::cerr <<  ((data_type) ((((data_type)~(0)) >> (sizeof (data_type) * 8 - left - 1)) & val) >> right) << "\n";
     299    std::cerr << "data_type = " << sizeof (data_type) << "\n";
    212300#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
    222 std::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
    228 std::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
    241 std::cerr << "range(" << left << "," << right << ")\n";
    242 std::cerr << "val = " << val << "\n";
    243 std::cerr << "~0 >> " << (sizeof (data_type) * 8 - left - 1) << " = " << (data_type) (((data_type)~(0)) >> (sizeof (data_type) * 8 - left - 1)) << "\n";
    244 std::cerr <<  ((data_type) ((((data_type)~(0)) >> (sizeof (data_type) * 8 - left - 1)) & val) >> right) << "\n";
    245 std::cerr << "data_type = " << sizeof (data_type) << "\n";
    246 #endif
     301   
     302#undef MASK32
     303#undef MASK64
    247304
    248305};
    … …  
    250307//
    251308// no sign flag to threat
    252 //
    253 
    254 inline std::ostream& operator << (std::ostream &o, const sc_uint_subref_r& s)
    255 { return o << s.val; }
     309
     310inline std::ostream & operator << (std::ostream & o, const sc_uint_subref_r & s) {
     311    return o << s.val;
     312}
     313
    256314
    257315} /* end of sc_dt namespace */
    … …  
    259317#endif /* __SC_UINT_H__ */
    260318
     319/*
     320# Local Variables:
     321# tab-width: 4;
     322# c-basic-offset: 4;
     323# c-file-offsets:((innamespace . 0)(inline-open . 0));
     324# indent-tabs-mode: nil;
     325# End:
     326#
     327# vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
     328*/
     329
Note: See TracChangeset for help on using the changeset viewer.