| /***************************************************************************** |
| |
| 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 |