クラス sc_dt::sc_uint_base

#include <sc_uint_base.h>

sc_dt::sc_uint_baseに対する継承グラフ

すべてのメンバ一覧

Public メソッド

sc_uint_base (int w=sc_length_param().len())

sc_uint_base (uint_type v, int w)

sc_uint_base (const sc_uint_base &a)

sc_uint_base (const sc_uint_subref_r &a)

template<class T>

sc_uint_base (const sc_generic_base< T > &a)

sc_uint_base (const sc_bv_base &v)

sc_uint_base (const sc_lv_base &v)

sc_uint_base (const sc_int_subref_r &v)

sc_uint_base (const sc_signed_subref_r &v)

sc_uint_base (const sc_unsigned_subref_r &v)

sc_uint_base (const sc_signed &a)

sc_uint_base (const sc_unsigned &a)

virtual ~sc_uint_base ()

sc_uint_base & operator= (uint_type v)

sc_uint_base & operator= (const sc_uint_base &a)

sc_uint_base & operator= (const sc_uint_subref_r &a)

template<class T>

sc_uint_base & operator= (const sc_generic_base< T > &a)

sc_uint_base & operator= (const sc_signed &a)

sc_uint_base & operator= (const sc_unsigned &a)

sc_uint_base & operator= (const sc_bv_base &a)

sc_uint_base & operator= (const sc_lv_base &a)

sc_uint_base & operator= (const char *a)

sc_uint_base & operator= (unsigned long a)

sc_uint_base & operator= (long a)

sc_uint_base & operator= (unsigned int a)

sc_uint_base & operator= (int a)

sc_uint_base & operator= (int64 a)

sc_uint_base & operator= (double a)

sc_uint_base & operator+= (uint_type v)

sc_uint_base & operator-= (uint_type v)

sc_uint_base & operator*= (uint_type v)

sc_uint_base & operator/= (uint_type v)

sc_uint_base & operator%= (uint_type v)

sc_uint_base & operator &= (uint_type v)

sc_uint_base & operator|= (uint_type v)

sc_uint_base & operator^= (uint_type v)

sc_uint_base & operator<<= (uint_type v)

sc_uint_base & operator>>= (uint_type v)

sc_uint_base & operator++ ()

const sc_uint_base operator++ (int)

sc_uint_base & operator-- ()

const sc_uint_base operator-- (int)

sc_uint_bitref & operator[] (int i)

const sc_uint_bitref_r & operator[] (int i) const

sc_uint_bitref & bit (int i)

const sc_uint_bitref_r & bit (int i) const

sc_uint_subref & operator() (int left, int right)

const sc_uint_subref_r & operator() (int left, int right) const

sc_uint_subref & range (int left, int right)

const sc_uint_subref_r & range (int left, int right) const

bool test (int i) const

void set (int i)

void set (int i, bool v)

int length () const

virtual int concat_length (bool *xz_present_p) const

virtual bool concat_get_ctrl (sc_digit *dst_p, int low_i) const

virtual bool concat_get_data (sc_digit *dst_p, int low_i) const

virtual uint64 concat_get_uint64 () const

virtual void concat_set (int64 src, int low_i)

virtual void concat_set (const sc_signed &src, int low_i)

virtual void concat_set (const sc_unsigned &src, int low_i)

virtual void concat_set (uint64 src, int low_i)

bool and_reduce () const

bool nand_reduce () const

bool or_reduce () const

bool nor_reduce () const

bool xor_reduce () const

bool xnor_reduce () const

operator uint_type () const

uint_type value () const

int to_int () const

unsigned int to_uint () const

long to_long () const

unsigned long to_ulong () const

int64 to_int64 () const

uint64 to_uint64 () const

double to_double () const

long long_low () const

long long_high () const

const std::string to_string (sc_numrep numrep=SC_DEC) const

const std::string to_string (sc_numrep numrep, bool w_prefix) const

void print (::std::ostream &os=::std::cout) const

void scan (::std::istream &is=::std::cin)

Protected 変数

uint_type m_val

int m_len

int m_ulen

Private メソッド

void invalid_length () const

void invalid_index (int i) const

void invalid_range (int l, int r) const

void check_length () const

void check_index (int i) const

void check_range (int l, int r) const

void check_value () const

void extend_sign ()

フレンド

class sc_uint_bitref_r

class sc_uint_bitref

class sc_uint_subref_r

class sc_uint_subref

bool operator== (const sc_uint_base &a, const sc_uint_base &b)

bool operator!= (const sc_uint_base &a, const sc_uint_base &b)

bool operator< (const sc_uint_base &a, const sc_uint_base &b)

bool operator<= (const sc_uint_base &a, const sc_uint_base &b)

bool operator> (const sc_uint_base &a, const sc_uint_base &b)

bool operator>= (const sc_uint_base &a, const sc_uint_base &b)

説明

sc_uint_base.h の 512 行で定義されています。

コンストラクタとデストラクタ

sc_dt::sc_uint_base::sc_uint_base ( int w = sc_length_param().len() ) [inline, explicit]

sc_uint_base.h の 549 行で定義されています。

00550         : m_val( 0 ), m_len( w ), m_ulen( SC_INTWIDTH - m_len )
00551         { check_length(); }

sc_dt::sc_uint_base::sc_uint_base	(	uint_type	v,
		int	w
	)			`[inline]`

sc_uint_base.h の 553 行で定義されています。

00554         : m_val( v ), m_len( w ), m_ulen( SC_INTWIDTH - m_len )
00555         { check_length(); extend_sign(); }

sc_dt::sc_uint_base::sc_uint_base ( const sc_uint_base & a ) [inline]

sc_uint_base.h の 557 行で定義されています。

00558         : m_val( a.m_val ), m_len( a.m_len ), m_ulen( a.m_ulen )
00559         {}

sc_dt::sc_uint_base::sc_uint_base ( const sc_uint_subref_r & a ) [inline, explicit]

sc_uint_base.h の 561 行で定義されています。

00562         : m_val( a ), m_len( a.length() ), m_ulen( SC_INTWIDTH - m_len )
00563         { extend_sign(); }

template<class T>

sc_dt::sc_uint_base::sc_uint_base ( const sc_generic_base< T > & a ) [inline, explicit]

sc_uint_base.h の 566 行で定義されています。

00567         : m_val( a->to_uint64() ), m_len( a->length() ),
00568           m_ulen( SC_INTWIDTH - m_len )
00569         { check_length(); extend_sign(); }

sc_dt::sc_uint_base::sc_uint_base ( const sc_bv_base & v ) [explicit]

sc_uint_base.cpp の 367 行で定義されています。

00368     : m_val(0), m_len( v.length() ), m_ulen( SC_INTWIDTH - m_len )
00369 {
00370     check_length();
00371     *this = v;
00372 }

sc_dt::sc_uint_base::sc_uint_base ( const sc_lv_base & v ) [explicit]

sc_uint_base.cpp の 373 行で定義されています。

00374     : m_val(0), m_len( v.length() ), m_ulen( SC_INTWIDTH - m_len )
00375 {
00376     check_length();
00377     *this = v;
00378 }

sc_dt::sc_uint_base::sc_uint_base ( const sc_int_subref_r & v ) [explicit]

sc_uint_base.cpp の 379 行で定義されています。

00380     : m_val(0), m_len( v.length() ), m_ulen( SC_INTWIDTH - m_len )
00381 {
00382     check_length();
00383     *this = v.to_uint64();
00384 }

sc_dt::sc_uint_base::sc_uint_base ( const sc_signed_subref_r & v ) [explicit]

sc_uint_base.cpp の 385 行で定義されています。

00386     : m_val(0), m_len( v.length() ), m_ulen( SC_INTWIDTH - m_len )
00387 {
00388     check_length();
00389     *this = v.to_uint64();
00390 }

sc_dt::sc_uint_base::sc_uint_base ( const sc_unsigned_subref_r & v ) [explicit]

sc_uint_base.cpp の 391 行で定義されています。

00392     : m_val(0), m_len( v.length() ), m_ulen( SC_INTWIDTH - m_len )
00393 {
00394     check_length();
00395     *this = v.to_uint64();
00396 }

sc_dt::sc_uint_base::sc_uint_base ( const sc_signed & a ) [explicit]

sc_uint_base.cpp の 398 行で定義されています。

00399     : m_val( 0 ), m_len( a.length() ), m_ulen( SC_INTWIDTH - m_len )
00400 {
00401     check_length();
00402 #if 0
00403     for( int i = m_len - 1; i >= 0; -- i ) {
00404         set( i, a.test( i ) );
00405     }
00406     extend_sign();
00407 #else
00408     *this = a.to_uint64();
00409 #endif
00410 }

sc_dt::sc_uint_base::sc_uint_base ( const sc_unsigned & a ) [explicit]

sc_uint_base.cpp の 412 行で定義されています。

00413     : m_val( 0 ), m_len( a.length() ), m_ulen( SC_INTWIDTH - m_len )
00414 {
00415     check_length();
00416 #if 0
00417     for( int i = m_len - 1; i >= 0; -- i ) {
00418         set( i, a.test( i ) );
00419     }
00420     extend_sign();
00421 #else
00422     *this = a.to_uint64();
00423 #endif
00424 }

virtual sc_dt::sc_uint_base::~sc_uint_base ( ) [inline, virtual]

sc_uint_base.h の 582 行で定義されています。

00583         {}

関数

void sc_dt::sc_uint_base::invalid_length ( ) const [private]

sc_uint_base.cpp の 319 行で定義されています。

00320 {
00321     char msg[BUFSIZ];
00322     std::sprintf( msg,
00323              "sc_uint[_base] initialization: length = %d violates "
00324              "1 <= length <= %d",
00325              m_len, SC_INTWIDTH );
00326     SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
00327 }

void sc_dt::sc_uint_base::invalid_index ( int i ) const [private]

sc_uint_base.cpp の 330 行で定義されています。

00331 {
00332     char msg[BUFSIZ];
00333     std::sprintf( msg,
00334              "sc_uint[_base] bit selection: index = %d violates "
00335              "0 <= index <= %d",
00336              i, m_len - 1 );
00337     SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
00338 }

void sc_dt::sc_uint_base::invalid_range	(	int	l,
		int	r
	)			const `[private]`

sc_uint_base.cpp の 341 行で定義されています。

00342 {
00343     char msg[BUFSIZ];
00344     std::sprintf( msg,
00345              "sc_uint[_base] part selection: left = %d, right = %d violates "
00346              "0 <= right <= left <= %d",
00347              l, r, m_len - 1 );
00348     SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
00349 }

void sc_dt::sc_uint_base::check_length ( ) const [inline, private]

sc_uint_base.h の 526 行で定義されています。

00527         { if( m_len <= 0 || m_len > SC_INTWIDTH ) { invalid_length(); } }

void sc_dt::sc_uint_base::check_index ( int i ) const [inline, private]

sc_uint_base.h の 529 行で定義されています。

00530         { if( i < 0 || i >= m_len ) { invalid_index( i ); } }

void sc_dt::sc_uint_base::check_range	(	int	l,
		int	r
	)			const `[inline, private]`

sc_uint_base.h の 532 行で定義されています。

00533         { if( r < 0 || l >= m_len || l < r ) { invalid_range( l, r ); } }

void sc_dt::sc_uint_base::check_value ( ) const [private]

sc_uint_base.cpp の 353 行で定義されています。

00354 {
00355     uint_type limit = (~UINT_ZERO >> m_ulen);
00356     if( m_val > limit ) {
00357         char msg[BUFSIZ];
00358         std::sprintf( msg, "sc_uint[_base]: value does not fit into a length of %d",
00359                  m_len );
00360         SC_REPORT_WARNING( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
00361     }
00362 }

void sc_dt::sc_uint_base::extend_sign ( ) [inline, private]

sc_uint_base.h の 537 行で定義されています。

00538         {
00539 #ifdef DEBUG_SYSTEMC
00540             check_value();
00541 #endif
00542             m_val &= ( ~UINT_ZERO >> m_ulen );
00543         }

sc_uint_base& sc_dt::sc_uint_base::operator= ( uint_type v ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 588 行で定義されています。

00589         { m_val = v; extend_sign(); return *this; }

sc_uint_base& sc_dt::sc_uint_base::operator= ( const sc_uint_base & a ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 591 行で定義されています。

00592         { m_val = a.m_val; extend_sign(); return *this; }

sc_uint_base& sc_dt::sc_uint_base::operator= ( const sc_uint_subref_r & a ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 594 行で定義されています。

00595         { m_val = a; extend_sign(); return *this; }

template<class T>

sc_uint_base& sc_dt::sc_uint_base::operator= ( const sc_generic_base< T > & a ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 598 行で定義されています。

00599         { m_val = a->to_uint64(); extend_sign(); return *this; }

sc_uint_base & sc_dt::sc_uint_base::operator= ( const sc_signed & a )

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.cpp の 429 行で定義されています。

00430 {
00431     int minlen = sc_min( m_len, a.length() );
00432     int i = 0;
00433     for( ; i < minlen; ++ i ) {
00434         set( i, a.test( i ) );
00435     }
00436     bool sgn = a.sign();
00437     for( ; i < m_len; ++ i ) {
00438         // sign extension
00439         set( i, sgn );
00440     }
00441     extend_sign();
00442     return *this;
00443 }

sc_uint_base & sc_dt::sc_uint_base::operator= ( const sc_unsigned & a )

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.cpp の 446 行で定義されています。

00447 {
00448     int minlen = sc_min( m_len, a.length() );
00449     int i = 0;
00450     for( ; i < minlen; ++ i ) {
00451         set( i, a.test( i ) );
00452     }
00453     for( ; i < m_len; ++ i ) {
00454         // zero extension
00455         set( i, 0 );
00456     }
00457     extend_sign();
00458     return *this;
00459 }

sc_uint_base & sc_dt::sc_uint_base::operator= ( const sc_bv_base & a )

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.cpp の 463 行で定義されています。

00464 {
00465     int minlen = sc_min( m_len, a.length() );
00466     int i = 0;
00467     for( ; i < minlen; ++ i ) {
00468         set( i, a.get_bit( i ) );
00469     }
00470     for( ; i < m_len; ++ i ) {
00471         // zero extension
00472         set( i, 0 );
00473     }
00474     extend_sign();
00475     return *this;
00476 }

sc_uint_base & sc_dt::sc_uint_base::operator= ( const sc_lv_base & a )

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.cpp の 479 行で定義されています。

00480 {
00481     int minlen = sc_min( m_len, a.length() );
00482     int i = 0;
00483     for( ; i < minlen; ++ i ) {
00484         set( i, sc_logic( a.get_bit( i ) ).to_bool() );
00485     }
00486     for( ; i < m_len; ++ i ) {
00487         // zero extension
00488         set( i, 0 );
00489     }
00490     extend_sign();
00491     return *this;
00492 }

sc_uint_base & sc_dt::sc_uint_base::operator= ( const char * a )

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.cpp の 495 行で定義されています。

00496 {
00497     if( a == 0 ) {
00498         SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_,
00499                          "character string is zero" );
00500     }
00501     if( *a == 0 ) {
00502         SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_,
00503                          "character string is empty" );
00504     }
00505     try {
00506         int len = m_len;
00507         sc_ufix aa( a, len, len, SC_TRN, SC_WRAP, 0, SC_ON );
00508         return this->operator = ( aa );
00509     } catch( sc_core::sc_report ) {
00510         char msg[BUFSIZ];
00511         std::sprintf( msg, "character string '%s' is not valid", a );
00512         SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_, msg );
00513         // never reached
00514         return *this;
00515     }
00516 }

sc_uint_base& sc_dt::sc_uint_base::operator= ( unsigned long a ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 616 行で定義されています。

00617         { m_val = a; extend_sign(); return *this; }

sc_uint_base& sc_dt::sc_uint_base::operator= ( long a ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 619 行で定義されています。

00620         { m_val = a; extend_sign(); return *this; }

sc_uint_base& sc_dt::sc_uint_base::operator= ( unsigned int a ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 622 行で定義されています。

00623         { m_val = a; extend_sign(); return *this; }

sc_uint_base& sc_dt::sc_uint_base::operator= ( int a ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 625 行で定義されています。

00626         { m_val = a; extend_sign(); return *this; }

sc_uint_base& sc_dt::sc_uint_base::operator= ( int64 a ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 628 行で定義されています。

00629         { m_val = a; extend_sign(); return *this; }

sc_uint_base& sc_dt::sc_uint_base::operator= ( double a ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 631 行で定義されています。

00632         { m_val = (uint_type) a; extend_sign(); return *this; }

sc_uint_base& sc_dt::sc_uint_base::operator+= ( uint_type v ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 637 行で定義されています。

00638         { m_val += v; extend_sign(); return *this; }

sc_uint_base& sc_dt::sc_uint_base::operator-= ( uint_type v ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 640 行で定義されています。

00641         { m_val -= v; extend_sign(); return *this; }

sc_uint_base& sc_dt::sc_uint_base::operator*= ( uint_type v ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 643 行で定義されています。

00644         { m_val *= v; extend_sign(); return *this; }

sc_uint_base& sc_dt::sc_uint_base::operator/= ( uint_type v ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 646 行で定義されています。

00647         { m_val /= v; extend_sign(); return *this; }

sc_uint_base& sc_dt::sc_uint_base::operator%= ( uint_type v ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 649 行で定義されています。

00650         { m_val %= v; extend_sign(); return *this; }

sc_uint_base& sc_dt::sc_uint_base::operator &= ( uint_type v ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 655 行で定義されています。

00656         { m_val &= v; extend_sign(); return *this; }

sc_uint_base& sc_dt::sc_uint_base::operator|= ( uint_type v ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 658 行で定義されています。

00659         { m_val |= v; extend_sign(); return *this; }

sc_uint_base& sc_dt::sc_uint_base::operator^= ( uint_type v ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 661 行で定義されています。

00662         { m_val ^= v; extend_sign(); return *this; }

sc_uint_base& sc_dt::sc_uint_base::operator<<= ( uint_type v ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 665 行で定義されています。

00666         { m_val <<= v; extend_sign(); return *this; }

sc_uint_base& sc_dt::sc_uint_base::operator>>= ( uint_type v ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 668 行で定義されています。

00669         { m_val >>= v; /* no sign extension needed */ return *this; }

sc_uint_base& sc_dt::sc_uint_base::operator++ ( ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 674 行で定義されています。

00675         { ++ m_val; extend_sign(); return *this; }

const sc_uint_base sc_dt::sc_uint_base::operator++ ( int ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 677 行で定義されています。

00678         { sc_uint_base tmp( *this ); ++ m_val; extend_sign(); return tmp; }

sc_uint_base& sc_dt::sc_uint_base::operator-- ( ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 680 行で定義されています。

00681         { -- m_val; extend_sign(); return *this; }

const sc_uint_base sc_dt::sc_uint_base::operator-- ( int ) [inline]

sc_dt::sc_uint< W >で再定義されています。

sc_uint_base.h の 683 行で定義されています。

00684         { sc_uint_base tmp( *this ); -- m_val; extend_sign(); return tmp; }

sc_uint_bitref & sc_dt::sc_uint_base::operator[] ( int i ) [inline]

sc_uint_base.h の 1188 行で定義されています。

01189 {
01190     check_index( i );
01191     sc_uint_bitref* result_p = sc_uint_bitref::m_pool.allocate();
01192     result_p->initialize(this, i);
01193     return *result_p;
01194 }

const sc_uint_bitref_r & sc_dt::sc_uint_base::operator[] ( int i ) const [inline]

sc_uint_base.h の 1198 行で定義されています。

01199 {
01200     check_index( i );
01201     sc_uint_bitref* result_p = sc_uint_bitref::m_pool.allocate();
01202     result_p->initialize(this, i);
01203     return *result_p;
01204 }

sc_uint_bitref & sc_dt::sc_uint_base::bit ( int i ) [inline]

sc_uint_base.h の 1209 行で定義されています。

01210 {
01211     check_index( i );
01212     sc_uint_bitref* result_p = sc_uint_bitref::m_pool.allocate();
01213     result_p->initialize(this, i);
01214     return *result_p;
01215 }

const sc_uint_bitref_r & sc_dt::sc_uint_base::bit ( int i ) const [inline]

sc_uint_base.h の 1219 行で定義されています。

01220 {
01221     check_index( i );
01222     sc_uint_bitref* result_p = sc_uint_bitref::m_pool.allocate();
01223     result_p->initialize(this, i);
01224     return *result_p;
01225 }

sc_uint_subref & sc_dt::sc_uint_base::operator()	(	int	left,
		int	right
	)			`[inline]`

sc_uint_base.h の 1232 行で定義されています。

01233 {
01234     check_range( left, right );
01235     sc_uint_subref* result_p = sc_uint_subref::m_pool.allocate();
01236     result_p->initialize(this, left, right);
01237     return *result_p;
01238 }

const sc_uint_subref_r & sc_dt::sc_uint_base::operator()	(	int	left,
		int	right
	)			const `[inline]`

sc_uint_base.h の 1242 行で定義されています。

01243 {
01244     check_range( left, right );
01245     sc_uint_subref* result_p = sc_uint_subref::m_pool.allocate();
01246     result_p->initialize(this, left, right);
01247     return *result_p;
01248 }

sc_uint_subref & sc_dt::sc_uint_base::range	(	int	left,
		int	right
	)			`[inline]`

sc_uint_base.h の 1253 行で定義されています。

01254 {
01255     check_range( left, right );
01256     sc_uint_subref* result_p = sc_uint_subref::m_pool.allocate();
01257     result_p->initialize(this, left, right);
01258     return *result_p;
01259 }

const sc_uint_subref_r & sc_dt::sc_uint_base::range	(	int	left,
		int	right
	)			const `[inline]`

sc_uint_base.h の 1263 行で定義されています。

01264 {
01265     check_range( left, right );
01266     sc_uint_subref* result_p = sc_uint_subref::m_pool.allocate();
01267     result_p->initialize(this, left, right);
01268     return *result_p;
01269 }

bool sc_dt::sc_uint_base::test ( int i ) const [inline]

sc_uint_base.h の 728 行で定義されています。

00729         { return ( 0 != (m_val & (UINT_ONE << i)) ); }

void sc_dt::sc_uint_base::set ( int i ) [inline]

sc_uint_base.h の 731 行で定義されています。

00732         { m_val |= (UINT_ONE << i); }

void sc_dt::sc_uint_base::set	(	int	i,
		bool	v
	)			`[inline]`

sc_uint_base.h の 734 行で定義されています。

00735         { v ? m_val |= (UINT_ONE << i) : m_val &= ~(UINT_ONE << i); }

int sc_dt::sc_uint_base::length ( ) const [inline]

sc_uint_base.h の 740 行で定義されています。

00741         { return m_len; }

virtual int sc_dt::sc_uint_base::concat_length ( bool * xz_present_p ) const [inline, virtual]

sc_dt::sc_value_baseを再定義しています。

sc_uint_base.h の 750 行で定義されています。

00751         { if ( xz_present_p ) *xz_present_p = false; return length(); }

bool sc_dt::sc_uint_base::concat_get_ctrl	(	sc_digit *	dst_p,
		int	low_i
	)			const `[virtual]`

sc_dt::sc_value_baseを再定義しています。

sc_uint_base.cpp の 567 行で定義されています。

00568 {    
00569     int       dst_i;       // Word in dst_p now processing.
00570     int       end_i;       // Highest order word in dst_p to process.
00571     int       left_shift;  // Left shift for val.
00572     sc_digit  mask;        // Mask for bits to extract or keep.
00573 
00574     dst_i = low_i / BITS_PER_DIGIT;
00575     left_shift = low_i % BITS_PER_DIGIT;
00576     end_i = (low_i + (m_len-1)) / BITS_PER_DIGIT;
00577 
00578     // PROCESS THE FIRST WORD:
00579 
00580     mask = ~((uint_type)-1 << left_shift);
00581     dst_p[dst_i] = (unsigned long)((dst_p[dst_i] & mask));
00582 
00583     dst_i++;
00584     for ( ; dst_i <= end_i; dst_i++ ) dst_p[dst_i] = 0;
00585     return false;
00586 }

bool sc_dt::sc_uint_base::concat_get_data	(	sc_digit *	dst_p,
		int	low_i
	)			const `[virtual]`

sc_dt::sc_value_baseを再定義しています。

sc_uint_base.cpp の 588 行で定義されています。

00589 {    
00590     int       dst_i;       // Word in dst_p now processing.
00591     int       end_i;       // Highest order word in dst_p to process.
00592     int       high_i;      // Index of high order bit in dst_p to set.
00593     int       left_shift;  // Left shift for val.
00594     sc_digit  mask;        // Mask for bits to extract or keep.
00595     bool      result;      // True if inserting non-zero value.
00596     sc_digit  val;         // Value for this object.
00597 
00598     dst_i = low_i / BITS_PER_DIGIT;
00599     left_shift = low_i % BITS_PER_DIGIT;
00600     high_i = low_i + (m_len-1);
00601     end_i = high_i / BITS_PER_DIGIT;
00602     val = m_val;
00603     result = val != 0;
00604 
00605     // PROCESS THE FIRST WORD:
00606 
00607     mask = ~((uint_type)-1 << left_shift);
00608     dst_p[dst_i] = (unsigned long)(((dst_p[dst_i] & mask)) | 
00609         ((val << left_shift) & DIGIT_MASK));
00610 
00611     switch ( end_i - dst_i )
00612     {
00613      // BITS ARE ACROSS TWO WORDS:
00614 
00615      case 1:
00616         dst_i++;
00617         val >>= (BITS_PER_DIGIT-left_shift);
00618         dst_p[dst_i] = (unsigned long)val;
00619         break;
00620 
00621      // BITS ARE ACROSS THREE WORDS:
00622 
00623      case 2:
00624         dst_i++;
00625         val >>= (BITS_PER_DIGIT-left_shift);
00626         dst_p[dst_i] = (unsigned long)(val & DIGIT_MASK);
00627         dst_i++;
00628         val >>= (BITS_PER_DIGIT-left_shift);
00629         dst_p[dst_i] = (unsigned long)val;
00630         break;
00631     }
00632     return result;
00633 }

virtual uint64 sc_dt::sc_uint_base::concat_get_uint64 ( ) const [inline, virtual]

sc_dt::sc_value_baseを再定義しています。

sc_uint_base.h の 754 行で定義されています。

00755         { return m_val; }

void sc_dt::sc_uint_base::concat_set	(	int64	src,
		int	low_i
	)			`[virtual]`

sc_dt::sc_value_baseを再定義しています。

sc_uint_base.cpp の 636 行で定義されています。

00637 {
00638     *this = (low_i < 64) ? src >> low_i : src >> 63;
00639 }

void sc_dt::sc_uint_base::concat_set	(	const sc_signed &	src,
		int	low_i
	)			`[virtual]`

sc_dt::sc_value_baseを再定義しています。

sc_uint_base.cpp の 641 行で定義されています。

00642 {
00643     if ( low_i < src.length() )
00644         *this = src >> low_i;                             
00645     else
00646         *this = (src < 0) ? (int_type)-1 : 0; 
00647 }

void sc_dt::sc_uint_base::concat_set	(	const sc_unsigned &	src,
		int	low_i
	)			`[virtual]`

sc_dt::sc_value_baseを再定義しています。

sc_uint_base.cpp の 649 行で定義されています。

00650 {
00651     if ( low_i < src.length() )
00652         *this = src >> low_i;
00653     else
00654         *this = 0;
00655 }

void sc_dt::sc_uint_base::concat_set	(	uint64	src,
		int	low_i
	)			`[virtual]`

sc_dt::sc_value_baseを再定義しています。

sc_uint_base.cpp の 657 行で定義されています。

00658 {
00659     *this = (low_i < 64) ? src >> low_i : 0;
00660 }

bool sc_dt::sc_uint_base::and_reduce ( ) const

sc_uint_base.cpp の 541 行で定義されています。

00542 {
00543     return ( m_val == (~UINT_ZERO >> m_ulen) );
00544 }

bool sc_dt::sc_uint_base::nand_reduce ( ) const [inline]

sc_uint_base.h の 766 行で定義されています。

00767         { return ( ! and_reduce() ); }

bool sc_dt::sc_uint_base::or_reduce ( ) const

sc_uint_base.cpp の 547 行で定義されています。

00548 {
00549     return ( m_val != uint_type( 0 ) );
00550 }

bool sc_dt::sc_uint_base::nor_reduce ( ) const [inline]

sc_uint_base.h の 771 行で定義されています。

00772         { return ( ! or_reduce() ); }

bool sc_dt::sc_uint_base::xor_reduce ( ) const

sc_uint_base.cpp の 553 行で定義されています。

00554 {
00555     uint_type mask = ~UINT_ZERO;
00556     uint_type val = m_val;
00557     int n = SC_INTWIDTH;
00558     do {
00559         n >>= 1;
00560         mask >>= n;
00561         val = ((val & (mask << n)) >> n) ^ (val & mask);
00562     } while( n != 1 );
00563     return ( val != uint_type( 0 ) );
00564 }

bool sc_dt::sc_uint_base::xnor_reduce ( ) const [inline]

sc_uint_base.h の 776 行で定義されています。

00777         { return ( ! xor_reduce() ); }

sc_dt::sc_uint_base::operator uint_type ( ) const [inline]

sc_uint_base.h の 782 行で定義されています。

00783         { return m_val; }

uint_type sc_dt::sc_uint_base::value ( ) const [inline]

sc_uint_base.h の 788 行で定義されています。

00789         { return operator uint_type(); }

int sc_dt::sc_uint_base::to_int ( ) const [inline]

sc_uint_base.h の 792 行で定義されています。

00793         { return (int) m_val; }

unsigned int sc_dt::sc_uint_base::to_uint ( ) const [inline]

sc_uint_base.h の 795 行で定義されています。

00796         { return (unsigned int) m_val; }

long sc_dt::sc_uint_base::to_long ( ) const [inline]

sc_uint_base.h の 798 行で定義されています。

00799         { return (long) m_val; }

unsigned long sc_dt::sc_uint_base::to_ulong ( ) const [inline]

sc_uint_base.h の 801 行で定義されています。

00802         { return (unsigned long) m_val; }

int64 sc_dt::sc_uint_base::to_int64 ( ) const [inline]

sc_uint_base.h の 804 行で定義されています。

00805         { return (int64) m_val; }

uint64 sc_dt::sc_uint_base::to_uint64 ( ) const [inline]

sc_uint_base.h の 807 行で定義されています。

00808         { return (uint64) m_val; }

double sc_dt::sc_uint_base::to_double ( ) const [inline]

sc_uint_base.h の 810 行で定義されています。

00811         { return uint64_to_double( m_val ); }

long sc_dt::sc_uint_base::long_low ( ) const [inline]

sc_uint_base.h の 815 行で定義されています。

00816         { return (long) (m_val & UINT64_32ONES); }

long sc_dt::sc_uint_base::long_high ( ) const [inline]

sc_uint_base.h の 818 行で定義されています。

00819         { return (long) ((m_val >> 32) & UINT64_32ONES); }

const std::string sc_dt::sc_uint_base::to_string ( sc_numrep numrep = SC_DEC ) const

sc_uint_base.cpp の 522 行で定義されています。

00523 {
00524     int len = m_len;
00525     sc_ufix aa( *this, len, len, SC_TRN, SC_WRAP, 0, SC_ON );
00526     return aa.to_string( numrep );
00527 }

const std::string sc_dt::sc_uint_base::to_string	(	sc_numrep	numrep,
		bool	w_prefix
	)			const

sc_uint_base.cpp の 530 行で定義されています。

00531 {
00532     int len = m_len;
00533     sc_ufix aa( *this, len, len, SC_TRN, SC_WRAP, 0, SC_ON );
00534     return aa.to_string( numrep, w_prefix );
00535 }

void sc_dt::sc_uint_base::print ( ::std::ostream & os = ::std::cout ) const [inline]

sc_uint_base.h の 830 行で定義されています。

00831         { os << to_string(sc_io_base(os,SC_DEC),sc_io_show_base(os)); }

void sc_dt::sc_uint_base::scan ( ::std::istream & is = ::std::cin )

sc_uint_base.cpp の 666 行で定義されています。

00667 {
00668     std::string s;
00669     is >> s;
00670     *this = s.c_str();
00671 }

フレンドと関連する関数

friend class sc_uint_bitref_r [friend]

sc_uint_base.h の 514 行で定義されています。

friend class sc_uint_bitref [friend]

sc_uint_base.h の 515 行で定義されています。

friend class sc_uint_subref_r [friend]

sc_uint_base.h の 516 行で定義されています。

friend class sc_uint_subref [friend]

sc_uint_base.h の 517 行で定義されています。

bool operator==	(	const sc_uint_base &	a,
		const sc_uint_base &	b
	)			`[friend]`

sc_uint_base.h の 689 行で定義されています。

00690         { return a.m_val == b.m_val; }

bool operator!=	(	const sc_uint_base &	a,
		const sc_uint_base &	b
	)			`[friend]`

sc_uint_base.h の 692 行で定義されています。

00693         { return a.m_val != b.m_val; }

bool operator<	(	const sc_uint_base &	a,
		const sc_uint_base &	b
	)			`[friend]`

sc_uint_base.h の 695 行で定義されています。

00696         { return a.m_val < b.m_val; }

bool operator<=	(	const sc_uint_base &	a,
		const sc_uint_base &	b
	)			`[friend]`

sc_uint_base.h の 698 行で定義されています。

00699         { return a.m_val <= b.m_val; }

bool operator>	(	const sc_uint_base &	a,
		const sc_uint_base &	b
	)			`[friend]`

sc_uint_base.h の 701 行で定義されています。

00702         { return a.m_val > b.m_val; }

bool operator>=	(	const sc_uint_base &	a,
		const sc_uint_base &	b
	)			`[friend]`

sc_uint_base.h の 704 行で定義されています。

00705         { return a.m_val >= b.m_val; }

変数

uint_type sc_dt::sc_uint_base::m_val [protected]

sc_uint_base.h の 837 行で定義されています。

int sc_dt::sc_uint_base::m_len [protected]

sc_uint_base.h の 838 行で定義されています。

int sc_dt::sc_uint_base::m_ulen [protected]

sc_uint_base.h の 839 行で定義されています。

このクラスの説明は次のファイルから生成されました:

C:/systemc-2.2.0/systemc-2.2.0/src/sysc/datatypes/int/sc_uint_base.h
C:/systemc-2.2.0/systemc-2.2.0/src/sysc/datatypes/int/sc_uint_base.cpp


Public メソッド
	sc_uint_base (int w=sc_length_param().len())
	sc_uint_base (uint_type v, int w)
	sc_uint_base (const sc_uint_base &a)
	sc_uint_base (const sc_uint_subref_r &a)
template<class T>
	sc_uint_base (const sc_generic_base< T > &a)
	sc_uint_base (const sc_bv_base &v)
	sc_uint_base (const sc_lv_base &v)
	sc_uint_base (const sc_int_subref_r &v)
	sc_uint_base (const sc_signed_subref_r &v)
	sc_uint_base (const sc_unsigned_subref_r &v)
	sc_uint_base (const sc_signed &a)
	sc_uint_base (const sc_unsigned &a)
virtual	~sc_uint_base ()
sc_uint_base &	operator= (uint_type v)
sc_uint_base &	operator= (const sc_uint_base &a)
sc_uint_base &	operator= (const sc_uint_subref_r &a)
template<class T>
sc_uint_base &	operator= (const sc_generic_base< T > &a)
sc_uint_base &	operator= (const sc_signed &a)
sc_uint_base &	operator= (const sc_unsigned &a)
sc_uint_base &	operator= (const sc_bv_base &a)
sc_uint_base &	operator= (const sc_lv_base &a)
sc_uint_base &	operator= (const char *a)
sc_uint_base &	operator= (unsigned long a)
sc_uint_base &	operator= (long a)
sc_uint_base &	operator= (unsigned int a)
sc_uint_base &	operator= (int a)
sc_uint_base &	operator= (int64 a)
sc_uint_base &	operator= (double a)
sc_uint_base &	operator+= (uint_type v)
sc_uint_base &	operator-= (uint_type v)
sc_uint_base &	operator*= (uint_type v)
sc_uint_base &	operator/= (uint_type v)
sc_uint_base &	operator%= (uint_type v)
sc_uint_base &	operator &= (uint_type v)
sc_uint_base &	operator\|= (uint_type v)
sc_uint_base &	operator^= (uint_type v)
sc_uint_base &	operator<<= (uint_type v)
sc_uint_base &	operator>>= (uint_type v)
sc_uint_base &	operator++ ()
const sc_uint_base	operator++ (int)
sc_uint_base &	operator-- ()
const sc_uint_base	operator-- (int)
sc_uint_bitref &	operator[] (int i)
const sc_uint_bitref_r &	operator[] (int i) const
sc_uint_bitref &	bit (int i)
const sc_uint_bitref_r &	bit (int i) const
sc_uint_subref &	operator() (int left, int right)
const sc_uint_subref_r &	operator() (int left, int right) const
sc_uint_subref &	range (int left, int right)
const sc_uint_subref_r &	range (int left, int right) const
bool	test (int i) const
void	set (int i)
void	set (int i, bool v)
int	length () const
virtual int	concat_length (bool *xz_present_p) const
virtual bool	concat_get_ctrl (sc_digit *dst_p, int low_i) const
virtual bool	concat_get_data (sc_digit *dst_p, int low_i) const
virtual uint64	concat_get_uint64 () const
virtual void	concat_set (int64 src, int low_i)
virtual void	concat_set (const sc_signed &src, int low_i)
virtual void	concat_set (const sc_unsigned &src, int low_i)
virtual void	concat_set (uint64 src, int low_i)
bool	and_reduce () const
bool	nand_reduce () const
bool	or_reduce () const
bool	nor_reduce () const
bool	xor_reduce () const
bool	xnor_reduce () const
	operator uint_type () const
uint_type	value () const
int	to_int () const
unsigned int	to_uint () const
long	to_long () const
unsigned long	to_ulong () const
int64	to_int64 () const
uint64	to_uint64 () const
double	to_double () const
long	long_low () const
long	long_high () const
const std::string	to_string (sc_numrep numrep=SC_DEC) const
const std::string	to_string (sc_numrep numrep, bool w_prefix) const
void	print (::std::ostream &os=::std::cout) const
void	scan (::std::istream &is=::std::cin)
Protected 変数
uint_type	m_val
int	m_len
int	m_ulen
Private メソッド
void	invalid_length () const
void	invalid_index (int i) const
void	invalid_range (int l, int r) const
void	check_length () const
void	check_index (int i) const
void	check_range (int l, int r) const
void	check_value () const
void	extend_sign ()
フレンド
class	sc_uint_bitref_r
class	sc_uint_bitref
class	sc_uint_subref_r
class	sc_uint_subref
bool	operator== (const sc_uint_base &a, const sc_uint_base &b)
bool	operator!= (const sc_uint_base &a, const sc_uint_base &b)
bool	operator< (const sc_uint_base &a, const sc_uint_base &b)
bool	operator<= (const sc_uint_base &a, const sc_uint_base &b)
bool	operator> (const sc_uint_base &a, const sc_uint_base &b)
bool	operator>= (const sc_uint_base &a, const sc_uint_base &b)