systemc-2.3.1/sysc/a00391_source.html

 /*****************************************************************************


   The following code is derived, directly or indirectly, from the SystemC

   source code Copyright (c) 1996-2014 by all Contributors.

   All Rights reserved.


   The contents of this file are subject to the restrictions and limitations

   set forth in the SystemC Open Source License (the "License");

   You may not use this file except in compliance with such restrictions and

   limitations. You may obtain instructions on how to receive a copy of the

   License at http://www.accellera.org/. Software distributed by Contributors

   under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF

   ANY KIND, either express or implied. See the License for the specific

   language governing rights and limitations under the License.


  *****************************************************************************/


 /*****************************************************************************


   systemc.h - Top-level include file for the SystemC library with usings.


   Original Author: Stan Y. Liao, Synopsys, Inc.


  *****************************************************************************/


 /*****************************************************************************


   MODIFICATION LOG - modifiers, enter your name, affiliation, date and

   changes you are making here.


       Name, Affiliation, Date: Andy Goodrich, Forte Design Systems, 31 Mar 2005

   Description of Modification: Changes for namespace support.


  *****************************************************************************/


 #ifndef SYSTEMC_H

 #define SYSTEMC_H


 // INCLUDE SYSTEM (std) DEFINITIONS:


 #include <cassert>

 #include <climits>

 #include <cmath> // math.h?

 #include <cstddef>

 #include <cstdio>

 #include <cstdlib>

 #include <cstring>

 #include <exception>

 #include <fstream>

 #include <iostream>

 #include <memory>

 #include <string>

 #if defined(__sun) || defined(__sun__)

 #   include <inttypes.h>

 #elif !defined(WIN32) && !defined(_WIN32)

 #   include <stdint.h>

 #endif

 #include <typeinfo>

 #include <utility>

 #include <vector>


 // USINGS FOR I/O STREAM SUPPORT:


     using std::ios;

     using std::streambuf;

     using std::streampos;

     using std::streamsize;

     using std::iostream;

     using std::istream;

     using std::ostream;

     using std::cin;

     using std::cout;

     using std::cerr;

     using std::endl;

     using std::flush;

     using std::dec;

     using std::hex;

     using std::oct;

     using std::noshowbase;

     using std::showbase;


     using std::fstream;

     using std::ifstream;

     using std::ofstream;


 //  from <cstdio>:


     using std::size_t;

     using std::FILE;

     using std::fpos_t;

     using std::fclose;

     using std::clearerr;


     using std::remove;

     using std::rename;

     using std::tmpfile;

     using std::tmpnam;

     using std::fflush;

     using std::fopen;

     using std::freopen;

     using std::setbuf;

     using std::setvbuf;

     using std::fprintf;

     using std::fscanf;

     using std::printf;

     using std::scanf;

     using std::sprintf;

     using std::sscanf;

     using std::vfprintf;

     using std::vprintf;

     using std::vsprintf;

     using std::fgetc;

     using std::fgets;

     using std::fputc;

     using std::fputs;

     using std::getc;

     using std::getchar;

     using std::gets;

     using std::putc;

     using std::putchar;

     using std::puts;

     using std::ungetc;

     using std::fread;

     using std::fwrite;

     using std::fgetpos;

     using std::fseek;

     using std::fsetpos;

     using std::ftell;

     using std::rewind;

     using std::feof;

     using std::ferror;

     using std::perror;


 //  from <cstdlib>:


     using std::div_t;

     using std::ldiv_t;


     using std::atof;

     using std::atoi;

     using std::atol;

     using std::strtod;

     using std::strtol;

     using std::strtoul;

     using std::rand;

     using std::srand;

     using std::calloc;

     using std::free;

     using std::malloc;

     using std::realloc;

     using std::abort;

     using std::atexit;

     using std::exit;

     using std::getenv;

     using std::system;

     using std::bsearch;

     using std::qsort;

     using std::abs;

     using std::div;

     using std::labs;

     using std::ldiv;

     using std::mblen;

     using std::mbtowc;

     using std::mbstowcs;

 #if !defined(__CYGWIN__) && !defined(__CYGWIN32)

     using std::wctomb;

     using std::wcstombs;

 #endif


 //  from <cstring>:


     using std::memcpy;

     using std::memmove;

     using std::strcpy;

     using std::strncpy;

     using std::strcat;

     using std::strncat;

     using std::memcmp;

     using std::strcmp;

     using std::strcoll;

     using std::strncmp;

     using std::strxfrm;

     using std::memchr;

     using std::strchr;

     using std::strcspn;

     using std::strpbrk;

     using std::strrchr;

     using std::strspn;

     using std::strstr;

     using std::strtok;

     using std::memset;

     using std::strerror;

     using std::strlen;


 // deprecated strstream support

 #if defined( SC_INCLUDE_STRSTREAM )

 #include <strstream>


     using std::strstream;

     using std::strstreambuf;

     using std::istrstream;

     using std::ostrstream;


 #endif // SC_INCLUDE_STRSTREAM


 // INCLUDE SYSTEMC DEFINITIONS for sc_dt AND sc_core NAMESPACES:


 #include "systemc"


 // USINGS FOR THE sc_dt NAMESPACE:


 using sc_dt::SC_BIN;

 using sc_dt::SC_BIN_SM;

 using sc_dt::SC_BIN_US;

 using sc_dt::SC_CSD;

 using sc_dt::SC_DEC;

 using sc_dt::SC_HEX;

 using sc_dt::SC_HEX_SM;

 using sc_dt::SC_HEX_US;

 using sc_dt::SC_LOGIC_0;

 using sc_dt::SC_LOGIC_1;

 using sc_dt::SC_LOGIC_X;

 using sc_dt::SC_LOGIC_Z;

 using sc_dt::SC_NOBASE;

 using sc_dt::SC_OCT;

 using sc_dt::SC_OCT_SM;

 using sc_dt::SC_OCT_US;

 using sc_dt::int64;

 using sc_dt::sc_abs;

 using sc_dt::sc_bigint;

 using sc_dt::sc_biguint;

 using sc_dt::sc_bit;

 using sc_dt::sc_bv;

 using sc_dt::sc_bv_base;

 using sc_dt::sc_digit;

 using sc_dt::sc_int;

 using sc_dt::sc_int_base;

 using sc_dt::sc_io_show_base;

 using sc_dt::sc_length_context;

 using sc_dt::sc_length_param;

 using sc_dt::sc_logic;

 using sc_dt::sc_lv;

 using sc_dt::sc_lv_base;

 using sc_dt::sc_max;

 using sc_dt::sc_min;

 using sc_dt::sc_numrep;

 using sc_dt::sc_signed;

 using sc_dt::sc_uint;

 using sc_dt::sc_uint_base;

 using sc_dt::sc_unsigned;

 using sc_dt::uint64;

 // #ifdef SC_DT_DEPRECATED

 using sc_dt::sc_logic_0;

 using sc_dt::sc_logic_1;

 using sc_dt::sc_logic_Z;

 using sc_dt::sc_logic_X;

 // #endif


 #ifdef SC_INCLUDE_FX

     using sc_dt::sc_fxnum;

     using sc_dt::sc_fxnum_bitref;

     using sc_dt::sc_fxnum_fast;

     using sc_dt::sc_fix;

     using sc_dt::sc_fix_fast;

     using sc_dt::sc_ufix;

     using sc_dt::sc_ufix_fast;

     using sc_dt::sc_fixed;

     using sc_dt::sc_fixed_fast;

     using sc_dt::sc_ufixed;

     using sc_dt::sc_ufixed_fast;

     using sc_dt::sc_fxval;

     using sc_dt::sc_fxval_fast;

     using sc_dt::sc_fxcast_switch;

     using sc_dt::sc_fxcast_context;

     using sc_dt::sc_fxtype_params;

     using sc_dt::sc_fxtype_context;

     using sc_dt::sc_q_mode;

     using sc_dt::SC_RND;

     using sc_dt::SC_RND_ZERO;

     using sc_dt::SC_RND_MIN_INF;

     using sc_dt::SC_RND_INF;

     using sc_dt::SC_RND_CONV;

     using sc_dt::SC_TRN;

     using sc_dt::SC_TRN_ZERO;

     using sc_dt::sc_o_mode;

     using sc_dt::SC_SAT;

     using sc_dt::SC_SAT_ZERO;

     using sc_dt::SC_SAT_SYM;

     using sc_dt::SC_WRAP;

     using sc_dt::SC_WRAP_SM;

     using sc_dt::sc_switch;

     using sc_dt::SC_OFF;

     using sc_dt::SC_ON;

     using sc_dt::sc_fmt;

     using sc_dt::SC_F;

     using sc_dt::SC_E;

     using sc_dt::sc_context_begin;

     using sc_dt::SC_NOW;

     using sc_dt::SC_LATER;

 #endif // SC_INCLUDE_FX


 #if 0 // defined( _MSC_VER ) // supported versions of MSVC should support ADL


     using sc_dt::equal;

     using sc_dt::not_equal;

     using sc_dt::b_not;

     using sc_dt::b_and;

     using sc_dt::b_or;

     using sc_dt::b_xor;

     using sc_dt::lrotate;

     using sc_dt::rrotate;

     using sc_dt::reverse;

     using sc_dt::concat;

     using sc_dt::and_reduce;

     using sc_dt::or_reduce;

     using sc_dt::xor_reduce;

     using sc_dt::nand_reduce;

     using sc_dt::nor_reduce;

     using sc_dt::xnor_reduce;


 #endif // defined( _MSC_VER )


 // USINGS FOR sc_core:

 //

 // The explicit using for ::sc_core::wait is to remove an ambiguity with

 // the constructor for the system's union wait on Unix and Linux. This

 // causes problems with aCC, so users of aCC should explicitly select

 // the SystemC wait functions using ::sc_core::wait(...). This is actually

 // a good idea for SystemC programmers in general.


 using namespace sc_core;


 #if !defined( __HP_aCC )

     using ::sc_core::wait;

 #endif // !defined( __HP_aCC )


 #ifdef SC_USE_SC_STRING_OLD

         using   sc_dt::sc_string_old;

         typedef sc_dt::sc_string_old sc_string;

 #endif

 #ifdef SC_USE_STD_STRING

         typedef ::std::string sc_string;

 #endif


 #endif

sc_dt::SC_HEX_US
Definition: sc_nbdefs.h:102

sc_core::wait
void wait(int, sc_simcontext *)

sc_dt::sc_bit
Definition: sc_bit.h:86

sc_dt::SC_BIN_US
Definition: sc_nbdefs.h:98

sc_dt::rrotate
const sc_lv_base rrotate(const sc_proxy< X > &x, int n)
Definition: sc_lv_base.h:776

sc_dt::nand_reduce
sc_logic_value_t nand_reduce(const sc_proxy< X > &a)
Definition: sc_proxy.h:1546

sc_dt::sc_ufix_fast
Definition: sc_ufix.h:304

sc_dt::sc_lv_base
Definition: sc_lv_base.h:85

sc_dt::sc_fixed
Definition: sc_fixed.h:59

sc_dt::sc_io_show_base
bool sc_io_show_base(systemc_ostream &)
Definition: sc_nbutils.h:112

sc_dt::sc_bv_base
Definition: sc_bv_base.h:74

sc_dt::sc_abs
const T sc_abs(const T &a)
Definition: sc_macros.h:53

sc_dt::SC_BIN_SM
Definition: sc_nbdefs.h:99

sc_dt::b_or
const sc_bit b_or(const sc_bit &a, const sc_bit &b)
Definition: sc_bit.h:347

sc_dt::SC_DEC
Definition: sc_nbdefs.h:96

sc_dt::SC_OCT_SM
Definition: sc_nbdefs.h:101

sc_dt::sc_numrep
sc_numrep
Definition: sc_nbdefs.h:91

sc_dt::sc_digit
unsigned int sc_digit
Definition: sc_nbdefs.h:173

sc_dt::or_reduce
sc_logic_value_t or_reduce(const sc_proxy< X > &a)
Definition: sc_proxy.h:1554

sc_dt::SC_RND_MIN_INF
Definition: sc_fxdefs.h:91

sc_dt::sc_length_context
sc_context< sc_length_param > sc_length_context
Definition: sc_length_param.h:117

sc_dt::uint64
uint64_t uint64
Definition: sc_nbdefs.h:183

sc_dt::SC_SAT
Definition: sc_fxdefs.h:118

sc_dt::concat
sc_concref_r< sc_bitref_r< T1 >, sc_bitref_r< T2 > > concat(sc_bitref_r< T1 >, sc_bitref_r< T2 >)
Definition: sc_bit_proxies.h:2025

sc_dt::SC_HEX
Definition: sc_nbdefs.h:97

sc_dt::sc_logic_0
const sc_logic sc_logic_0

sc_dt::sc_fxtype_params
Definition: sc_fxtype_params.h:68

sc_dt::SC_E
Definition: sc_fxdefs.h:172

sc_dt::sc_fix_fast
Definition: sc_fix.h:304

sc_dt::sc_fxtype_context
sc_context< sc_fxtype_params > sc_fxtype_context
Definition: sc_fxtype_params.h:126

sc_dt::SC_LOGIC_Z
const sc_logic SC_LOGIC_Z

sc_dt::nor_reduce
sc_logic_value_t nor_reduce(const sc_proxy< X > &a)
Definition: sc_proxy.h:1562

sc_dt::SC_LOGIC_X
const sc_logic SC_LOGIC_X

sc_dt::SC_BIN
Definition: sc_nbdefs.h:94

sc_dt::SC_NOBASE
Definition: sc_nbdefs.h:93

sc_dt::lrotate
const sc_lv_base lrotate(const sc_proxy< X > &x, int n)
Definition: sc_lv_base.h:737

sc_dt::sc_fxcast_switch
Definition: sc_fxcast_switch.h:68

sc_dt::sc_logic_X
const sc_logic sc_logic_X

sc_dt::sc_fmt
sc_fmt
Definition: sc_fxdefs.h:169

sc_dt::SC_HEX_SM
Definition: sc_nbdefs.h:103

sc_dt::int64
int64_t int64
Definition: sc_nbdefs.h:182

sc_dt::sc_int_base
Definition: sc_int_base.h:537

sc_dt::sc_logic_Z
const sc_logic sc_logic_Z

sc_dt::SC_TRN
Definition: sc_fxdefs.h:94

sc_dt::SC_RND_ZERO
Definition: sc_fxdefs.h:90

sc_dt::sc_o_mode
sc_o_mode
Definition: sc_fxdefs.h:116

sc_dt::sc_min
const T sc_min(const T &a, const T &b)
Definition: sc_macros.h:37

sc_dt::SC_NOW
Definition: sc_context.h:127

sc_dt::SC_CSD
Definition: sc_nbdefs.h:104

sc_dt::sc_ufix
Definition: sc_ufix.h:69

sc_dt::sc_lv
Definition: sc_lv.h:56

sc_dt::sc_bv
Definition: sc_bv.h:56

sc_dt::and_reduce
sc_logic_value_t and_reduce(const sc_proxy< X > &a)
Definition: sc_proxy.h:1538

systemc

sc_dt::sc_fxcast_context
sc_context< sc_fxcast_switch > sc_fxcast_context
Definition: sc_fxcast_switch.h:103

sc_dt::sc_uint_base
Definition: sc_uint_base.h:523

sc_dt::SC_LATER
Definition: sc_context.h:128

sc_dt::SC_RND_INF
Definition: sc_fxdefs.h:92

sc_dt::sc_ufixed_fast
Definition: sc_ufixed.h:60

sc_dt::sc_context_begin
sc_context_begin
Definition: sc_context.h:125

sc_dt::b_and
const sc_bit b_and(const sc_bit &a, const sc_bit &b)
Definition: sc_bit.h:344

sc_dt::SC_ON
Definition: sc_fxdefs.h:148

sc_dt::sc_fxval_fast
Definition: sc_fxval.h:437

sc_dt::SC_SAT_SYM
Definition: sc_fxdefs.h:120

sc_dt::sc_logic_1
const sc_logic sc_logic_1

sc_dt::SC_OCT_US
Definition: sc_nbdefs.h:100

sc_dt::div
div
Definition: sc_fxval.h:988

sc_dt::SC_LOGIC_0
const sc_logic SC_LOGIC_0

sc_dt::sc_switch
sc_switch
Definition: sc_fxdefs.h:145

sc_dt::sc_biguint
Definition: sc_biguint.h:63

sc_dt::reverse
const sc_lv_base reverse(const sc_proxy< X > &x)
Definition: sc_lv_base.h:788

sc_dt::SC_WRAP
Definition: sc_fxdefs.h:121

sc_dt::b_xor
const sc_bit b_xor(const sc_bit &a, const sc_bit &b)
Definition: sc_bit.h:350

sc_dt::sc_fix
Definition: sc_fix.h:69

sc_dt::xnor_reduce
sc_logic_value_t xnor_reduce(const sc_proxy< X > &a)
Definition: sc_proxy.h:1578

sc_dt::SC_TRN_ZERO
Definition: sc_fxdefs.h:95

sc_dt::sc_uint
Definition: sc_uint.h:74

sc_dt::SC_OFF
Definition: sc_fxdefs.h:147

sc_dt::sc_max
const T sc_max(const T &a, const T &b)
Definition: sc_macros.h:45

sc_dt::sc_ufixed
Definition: sc_ufixed.h:59

sc_dt::sc_int
Definition: sc_int.h:75

sc_dt::sc_fixed_fast
Definition: sc_fixed.h:60

sc_dt::sc_string_old
Definition: sc_string.h:65

sc_dt::b_not
const sc_bit b_not(const sc_bit &a)
Definition: sc_bit.h:316

sc_dt::sc_signed
Definition: sc_signed.h:1085

sc_dt::SC_F
Definition: sc_fxdefs.h:171

sc_dt::SC_RND_CONV
Definition: sc_fxdefs.h:93

sc_dt::SC_LOGIC_1
const sc_logic SC_LOGIC_1

sc_dt::sc_fxnum_bitref
Definition: sc_fxnum.h:93

sc_dt::sc_logic
Definition: sc_logic.h:99

sc_dt::SC_OCT
Definition: sc_nbdefs.h:95

sc_dt::sc_q_mode
sc_q_mode
Definition: sc_fxdefs.h:87

sc_dt::SC_RND
Definition: sc_fxdefs.h:89

sc_dt::sc_fxval
Definition: sc_fxval.h:93

sc_dt::SC_SAT_ZERO
Definition: sc_fxdefs.h:119

sc_dt::xor_reduce
sc_logic_value_t xor_reduce(const sc_proxy< X > &a)
Definition: sc_proxy.h:1570

sc_dt::SC_WRAP_SM
Definition: sc_fxdefs.h:122

sc_dt::equal
bool equal(const sc_bit &a, const sc_bit &b)
Definition: sc_bit.h:294

sc_dt::sc_fxnum_fast
Definition: sc_fxnum.h:988

sc_dt::sc_bigint
Definition: sc_bigint.h:63

sc_dt::sc_unsigned
Definition: sc_unsigned.h:985

sc_dt::sc_fxnum
Definition: sc_fxnum.h:561

sc_dt::not_equal
bool not_equal(const sc_bit &a, const sc_bit &b)
Definition: sc_bit.h:297

sc_dt::sc_length_param
Definition: sc_length_param.h:81