summaryrefslogtreecommitdiff
path: root/ext/systemc/src/sysc/datatypes/bit/sc_logic.h
diff options
context:
space:
mode:
Diffstat (limited to 'ext/systemc/src/sysc/datatypes/bit/sc_logic.h')
-rw-r--r--ext/systemc/src/sysc/datatypes/bit/sc_logic.h384
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
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-07 12:30:32 +0000