diff options
Diffstat (limited to 'ext/systemc/src/sysc/datatypes/bit/sc_logic.h')
-rw-r--r-- | ext/systemc/src/sysc/datatypes/bit/sc_logic.h | 384 |
1 files changed, 384 insertions, 0 deletions
diff --git a/ext/systemc/src/sysc/datatypes/bit/sc_logic.h b/ext/systemc/src/sysc/datatypes/bit/sc_logic.h new file mode 100644 index 000000000..6008e3e2e --- /dev/null +++ b/ext/systemc/src/sysc/datatypes/bit/sc_logic.h @@ -0,0 +1,384 @@ +/***************************************************************************** + + Licensed to Accellera Systems Initiative Inc. (Accellera) under one or + more contributor license agreements. See the NOTICE file distributed + with this work for additional information regarding copyright ownership. + Accellera licenses this file to you under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with the + License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied. See the License for the specific language governing + permissions and limitations under the License. + + *****************************************************************************/ + +/***************************************************************************** + + sc_logic.h -- C++ implementation of logic type. Behaves + pretty much the same way as HDLs except with 4 values. + + Original Author: Stan Y. Liao, Synopsys, Inc. + + *****************************************************************************/ + +/***************************************************************************** + + MODIFICATION LOG - modifiers, enter your name, affiliation, date and + changes you are making here. + + Name, Affiliation, Date: + Description of Modification: + + *****************************************************************************/ + +// $Log: sc_logic.h,v $ +// Revision 1.3 2011/08/07 18:54:19 acg +// Philipp A. Hartmann: remove friend function declarations that implement +// code, and clean up how bit and logic operators are defined in general. +// +// Revision 1.2 2011/01/25 20:50:37 acg +// Andy Goodrich: changes for IEEE 1666 2011. +// +// Revision 1.1.1.1 2006/12/15 20:20:04 acg +// SystemC 2.3 +// +// Revision 1.5 2006/12/02 21:00:57 acg +// Andy Goodrich: fixes for concatenation support. +// +// Revision 1.4 2006/05/08 17:49:59 acg +// Andy Goodrich: Added David Long's declarations for friend operators, +// functions, and methods, to keep the Microsoft compiler happy. +// +// Revision 1.3 2006/01/13 18:53:53 acg +// Andy Goodrich: added $Log command so that CVS comments are reproduced in +// the source. +// + +#ifndef SC_LOGIC_H +#define SC_LOGIC_H + + +#include <cstdio> + +#include "sysc/utils/sc_iostream.h" +#include "sysc/kernel/sc_macros.h" +#include "sysc/utils/sc_mempool.h" +#include "sysc/datatypes/bit/sc_bit.h" + + +namespace sc_dt +{ + +// classes defined in this module +class sc_logic; + + +// ---------------------------------------------------------------------------- +// ENUM : sc_logic_value_t +// +// Enumeration of values for sc_logic. +// ---------------------------------------------------------------------------- + +enum sc_logic_value_t +{ + Log_0 = 0, + Log_1, + Log_Z, + Log_X +}; + +// ---------------------------------------------------------------------------- +// CLASS : sc_logic +// +// Four-valued logic type. +// ---------------------------------------------------------------------------- + +class sc_logic +{ +private: + + // support methods + + static void invalid_value( sc_logic_value_t ); + static void invalid_value( char ); + static void invalid_value( int ); + + static sc_logic_value_t to_value( sc_logic_value_t v ) + { + if( v < Log_0 || v > Log_X ) { + invalid_value( v ); + } + return v; + } + + static sc_logic_value_t to_value( bool b ) + { return ( b ? Log_1 : Log_0 ); } + + static sc_logic_value_t to_value( char c ) + { + sc_logic_value_t v; + unsigned int index = (int)c; + if ( index > 127 ) + { + invalid_value(c); + v = Log_X; + } + else + { + v = char_to_logic[index]; + if( v < Log_0 || v > Log_X ) { + invalid_value( c ); + } + } + return v; + } + + static sc_logic_value_t to_value( int i ) + { + if( i < 0 || i > 3 ) { + invalid_value( i ); + } + return sc_logic_value_t( i ); + } + + + void invalid_01() const; + +public: + + // conversion tables + + static const sc_logic_value_t char_to_logic[128]; + static const char logic_to_char[4]; + static const sc_logic_value_t and_table[4][4]; + static const sc_logic_value_t or_table[4][4]; + static const sc_logic_value_t xor_table[4][4]; + static const sc_logic_value_t not_table[4]; + + + // constructors + + sc_logic() + : m_val( Log_X ) + {} + + sc_logic( const sc_logic& a ) + : m_val( a.m_val ) + {} + + sc_logic( sc_logic_value_t v ) + : m_val( to_value( v ) ) + {} + + explicit sc_logic( bool a ) + : m_val( to_value( a ) ) + {} + + explicit sc_logic( char a ) + : m_val( to_value( a ) ) + {} + + explicit sc_logic( int a ) + : m_val( to_value( a ) ) + {} + + explicit sc_logic( const sc_bit& a ) + : m_val( to_value( a.to_bool() ) ) + {} + + + // destructor + + ~sc_logic() + {} + + + // (bitwise) assignment operators + +#define DEFN_ASN_OP_T(op,tp) \ + sc_logic& operator op ( tp v ) \ + { *this op sc_logic( v ); return *this; } + +#define DEFN_ASN_OP(op) \ + DEFN_ASN_OP_T(op, sc_logic_value_t) \ + DEFN_ASN_OP_T(op, bool) \ + DEFN_ASN_OP_T(op, char) \ + DEFN_ASN_OP_T(op, int ) \ + DEFN_ASN_OP_T(op, const sc_bit& ) + + sc_logic& operator = ( const sc_logic& a ) + { m_val = a.m_val; return *this; } + + sc_logic& operator &= ( const sc_logic& b ) + { m_val = and_table[m_val][b.m_val]; return *this; } + + sc_logic& operator |= ( const sc_logic& b ) + { m_val = or_table[m_val][b.m_val]; return *this; } + + sc_logic& operator ^= ( const sc_logic& b ) + { m_val = xor_table[m_val][b.m_val]; return *this; } + + DEFN_ASN_OP(=) + DEFN_ASN_OP(&=) + DEFN_ASN_OP(|=) + DEFN_ASN_OP(^=) + +#undef DEFN_ASN_OP_T +#undef DEFN_ASN_OP + + + // bitwise operators and functions + + + friend const sc_logic operator & ( const sc_logic&, const sc_logic& ); + friend const sc_logic operator | ( const sc_logic&, const sc_logic& ); + friend const sc_logic operator ^ ( const sc_logic&, const sc_logic& ); + + // relational operators + + friend bool operator == ( const sc_logic&, const sc_logic& ); + friend bool operator != ( const sc_logic&, const sc_logic& ); + + // bitwise complement + + const sc_logic operator ~ () const + { return sc_logic( not_table[m_val] ); } + + sc_logic& b_not() + { m_val = not_table[m_val]; return *this; } + + + // explicit conversions + + sc_logic_value_t value() const + { return m_val; } + + + bool is_01() const + { return ( (int) m_val == Log_0 || (int) m_val == Log_1 ); } + + bool to_bool() const + { if( ! is_01() ) { invalid_01(); } return ( (int) m_val != Log_0 ); } + + char to_char() const + { return logic_to_char[m_val]; } + + + // other methods + + void print( ::std::ostream& os = ::std::cout ) const + { os << to_char(); } + + void scan( ::std::istream& is = ::std::cin ); + + + // memory (de)allocation + + static void* operator new( std::size_t, void* p ) // placement new + { return p; } + + static void* operator new( std::size_t sz ) + { return sc_core::sc_mempool::allocate( sz ); } + + static void operator delete( void* p, std::size_t sz ) + { sc_core::sc_mempool::release( p, sz ); } + + static void* operator new [] ( std::size_t sz ) + { return sc_core::sc_mempool::allocate( sz ); } + + static void operator delete [] ( void* p, std::size_t sz ) + { sc_core::sc_mempool::release( p, sz ); } + +private: + + sc_logic_value_t m_val; + +private: + + // disabled + explicit sc_logic( const char* ); + sc_logic& operator = ( const char* ); +}; + +// ---------------------------------------------------------------------------- + +// bitwise operators + +inline const sc_logic operator & ( const sc_logic& a, const sc_logic& b ) + { return sc_logic( sc_logic::and_table[a.m_val][b.m_val] ); } + +inline const sc_logic operator | ( const sc_logic& a, const sc_logic& b ) + { return sc_logic( sc_logic::or_table[a.m_val][b.m_val] ); } + +inline const sc_logic operator ^ ( const sc_logic& a, const sc_logic& b ) + { return sc_logic( sc_logic::xor_table[a.m_val][b.m_val] ); } + +#define DEFN_BIN_OP_T(ret,op,tp) \ + inline ret operator op ( const sc_logic& a, tp b ) \ + { return ( a op sc_logic( b ) ); } \ + inline ret operator op ( tp a, const sc_logic& b ) \ + { return ( sc_logic( a ) op b ); } + +#define DEFN_BIN_OP(ret,op) \ + DEFN_BIN_OP_T(ret,op,sc_logic_value_t) \ + DEFN_BIN_OP_T(ret,op,bool) \ + DEFN_BIN_OP_T(ret,op,char) \ + DEFN_BIN_OP_T(ret,op,int) + +DEFN_BIN_OP(const sc_logic,&) +DEFN_BIN_OP(const sc_logic,|) +DEFN_BIN_OP(const sc_logic,^) + +// relational operators and functions + +inline bool operator == ( const sc_logic& a, const sc_logic& b ) + { return ( (int) a.m_val == b.m_val ); } + +inline bool operator != ( const sc_logic& a, const sc_logic& b ) + { return ( (int) a.m_val != b.m_val ); } + +DEFN_BIN_OP(bool,==) +DEFN_BIN_OP(bool,!=) + +#undef DEFN_BIN_OP_T +#undef DEFN_BIN_OP + +// ---------------------------------------------------------------------------- + +inline +::std::ostream& +operator << ( ::std::ostream& os, const sc_logic& a ) +{ + a.print( os ); + return os; +} + +inline +::std::istream& +operator >> ( ::std::istream& is, sc_logic& a ) +{ + a.scan( is ); + return is; +} + + +extern const sc_logic SC_LOGIC_0; +extern const sc_logic SC_LOGIC_1; +extern const sc_logic SC_LOGIC_Z; +extern const sc_logic SC_LOGIC_X; + +// #ifdef SC_DT_DEPRECATED +extern const sc_logic sc_logic_0; +extern const sc_logic sc_logic_1; +extern const sc_logic sc_logic_Z; +extern const sc_logic sc_logic_X; +// #endif + +} // namespace sc_dt + +#endif |