sc_bv_base.hh revision 13160:1e959d3afc64
1/***************************************************************************** 2 3 Licensed to Accellera Systems Initiative Inc. (Accellera) under one or 4 more contributor license agreements. See the NOTICE file distributed 5 with this work for additional information regarding copyright ownership. 6 Accellera licenses this file to you under the Apache License, Version 2.0 7 (the "License"); you may not use this file except in compliance with the 8 License. You may obtain a copy of the License at 9 10 http://www.apache.org/licenses/LICENSE-2.0 11 12 Unless required by applicable law or agreed to in writing, software 13 distributed under the License is distributed on an "AS IS" BASIS, 14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 15 implied. See the License for the specific language governing 16 permissions and limitations under the License. 17 18 *****************************************************************************/ 19 20/***************************************************************************** 21 22 sc_bv_base.h -- Arbitrary size bit vector class. 23 24 Original Author: Gene Bushuyev, Synopsys, Inc. 25 26 *****************************************************************************/ 27 28/***************************************************************************** 29 30 MODIFICATION LOG - modifiers, enter your name, affiliation, date and 31 changes you are making here. 32 33 Name, Affiliation, Date: 34 Description of Modification: 35 36 *****************************************************************************/ 37 38// $Log: sc_bv_base.h,v $ 39// Revision 1.3 2011/08/26 22:32:00 acg 40// Torsten Maehne: added parentheses to make opearator ordering more obvious. 41// 42// Revision 1.2 2011/08/15 16:43:24 acg 43// Torsten Maehne: changes to remove unused argument warnings. 44// 45// Revision 1.1.1.1 2006/12/15 20:20:04 acg 46// SystemC 2.3 47// 48// Revision 1.3 2006/01/13 18:53:53 acg 49// Andy Goodrich: added $Log command so that CVS comments are reproduced in 50// the source. 51// 52 53#ifndef __SYSTEMC_EXT_DT_BIT_SC_BV_BASE_HH__ 54#define __SYSTEMC_EXT_DT_BIT_SC_BV_BASE_HH__ 55 56#include "../int/sc_length_param.hh" 57#include "sc_bit_proxies.hh" 58#include "sc_proxy.hh" 59 60namespace sc_dt 61{ 62 63// classes defined in this module 64class sc_bv_base; 65 66 67// ---------------------------------------------------------------------------- 68// CLASS : sc_bv_base 69// 70// Arbitrary size bit vector base class. 71// ---------------------------------------------------------------------------- 72 73class sc_bv_base : public sc_proxy<sc_bv_base> 74{ 75 friend class sc_lv_base; 76 77 void init(int length_, bool init_value=false); 78 void assign_from_string(const std::string &); 79 80 public: 81 // typedefs 82 typedef sc_proxy<sc_bv_base> base_type; 83 typedef base_type::value_type value_type; 84 85 // constructors 86 explicit sc_bv_base(int length_=sc_length_param().len()) : 87 m_len(0), m_size(0), m_data(0) 88 { 89 init(length_); 90 } 91 92 explicit sc_bv_base(bool a, int length_=sc_length_param().len()) : 93 m_len(0), m_size(0), m_data(0) 94 { 95 init(length_, a); 96 } 97 98 sc_bv_base(const char *a); 99 sc_bv_base(const char *a, int length_); 100 101 template <class X> 102 sc_bv_base(const sc_proxy<X> &a) : m_len(0), m_size(0), m_data(0) 103 { 104 init(a.back_cast().length()); 105 base_type::assign_(a); 106 } 107 108 sc_bv_base(const sc_bv_base &a); 109 110 // destructor 111 virtual ~sc_bv_base() { delete [] m_data; } 112 113 // assignment operators 114 template <class X> 115 sc_bv_base & 116 operator = (const sc_proxy<X> &a) 117 { 118 assign_p_(*this, a); 119 return *this; 120 } 121 122 sc_bv_base & 123 operator = (const sc_bv_base &a) 124 { 125 assign_p_(*this, a); 126 return *this; 127 } 128 129 sc_bv_base &operator = (const char *a); 130 131 sc_bv_base & 132 operator = (const bool *a) 133 { 134 base_type::assign_(a); 135 return *this; 136 } 137 138 sc_bv_base & 139 operator = (const sc_logic *a) 140 { 141 base_type::assign_(a); 142 return *this; 143 } 144 145 sc_bv_base & 146 operator = (const sc_unsigned &a) 147 { 148 base_type::assign_(a); 149 return *this; 150 } 151 152 sc_bv_base & 153 operator = (const sc_signed &a) 154 { 155 base_type::assign_(a); 156 return *this; 157 } 158 159 sc_bv_base & 160 operator = (const sc_uint_base &a) 161 { 162 base_type::assign_(a); 163 return *this; 164 } 165 166 sc_bv_base & 167 operator = (const sc_int_base &a) 168 { 169 base_type::assign_(a); 170 return *this; 171 } 172 173 sc_bv_base & 174 operator = (unsigned long a) 175 { 176 base_type::assign_(a); 177 return *this; 178 } 179 180 sc_bv_base & 181 operator = (long a) 182 { 183 base_type::assign_(a); 184 return *this; 185 } 186 187 sc_bv_base & 188 operator = (unsigned int a) 189 { 190 base_type::assign_(a); 191 return *this; 192 } 193 194 sc_bv_base & 195 operator = (int a) 196 { 197 base_type::assign_(a); 198 return *this; 199 } 200 201 sc_bv_base & 202 operator = (uint64 a) 203 { 204 base_type::assign_(a); 205 return *this; 206 } 207 208 sc_bv_base & 209 operator = (int64 a) 210 { 211 base_type::assign_(a); 212 return *this; 213 } 214 215 // common methods 216 int length() const { return m_len; } 217 int size() const { return m_size; } 218 219 value_type get_bit(int i) const; 220 void set_bit(int i, value_type value); 221 222 sc_digit get_word(int i) const { return m_data[i]; } 223 224 void set_word(int i, sc_digit w) { m_data[i] = w; } 225 226 sc_digit get_cword(int /*i*/) const { return SC_DIGIT_ZERO; } 227 228 void set_cword(int i, sc_digit w); 229 230 void clean_tail(); 231 232 // other methods 233 bool is_01() const { return true; } 234 235 protected: 236 int m_len; // length in bits 237 int m_size; // size of data array 238 sc_digit *m_data; // data array 239}; 240 241 242// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII 243 244// common methods 245inline sc_bv_base::value_type 246sc_bv_base::get_bit(int i) const 247{ 248 int wi = i / SC_DIGIT_SIZE; 249 int bi = i % SC_DIGIT_SIZE; 250 return value_type((m_data[wi] >> bi) & SC_DIGIT_ONE); 251} 252 253inline void 254sc_bv_base::set_bit(int i, value_type value) 255{ 256 int wi = i / SC_DIGIT_SIZE; 257 int bi = i % SC_DIGIT_SIZE; 258 sc_digit mask = SC_DIGIT_ONE << bi; 259 m_data[wi] |= mask; // set bit to 1 260 m_data[wi] &= value << bi | ~mask; 261} 262 263inline void 264sc_bv_base::set_cword(int /*i*/, sc_digit w) 265{ 266 if (w) { 267 SC_REPORT_WARNING("(W207) sc_bv cannot contain values X and Z", 0); 268 } 269} 270 271inline void 272sc_bv_base::clean_tail() 273{ 274 int wi = m_size - 1; 275 int bi = m_len % SC_DIGIT_SIZE; 276 if (bi != 0) 277 m_data[wi] &= ~SC_DIGIT_ZERO >> (SC_DIGIT_SIZE - bi); 278} 279 280} // namespace sc_dt 281 282#endif // __SYSTEMC_EXT_DT_BIT_SC_BV_BASE_HH__ 283