ネームスペース sc_core

SC_LAMBDA_RAND_LAMBDA
SC_LAMBDA_RAND_SIGNAL_INT
SC_LAMBDA_RAND_SIGNAL_SUL
SC_LAMBDA_RAND_SIGNAL_BOOL
SC_LAMBDA_RAND_INT
SC_LAMBDA_RAND_SUL
SC_LAMBDA_RAND_BOOL

enum sc_core::sc_lambda_rator_e

列挙型の値:

SC_LAMBDA_FALSE
SC_LAMBDA_TRUE
SC_LAMBDA_AND
SC_LAMBDA_OR
SC_LAMBDA_NOT
SC_LAMBDA_BOOL
SC_LAMBDA_BOOL_EQ
SC_LAMBDA_BOOL_NE
SC_LAMBDA_SUL_EQ
SC_LAMBDA_SUL_NE
SC_LAMBDA_INT_EQ
SC_LAMBDA_INT_NE
SC_LAMBDA_INT_LE
SC_LAMBDA_INT_GE
SC_LAMBDA_INT_LT
SC_LAMBDA_INT_GT
SC_LAMBDA_SUL_BITAND
SC_LAMBDA_SUL_BITOR
SC_LAMBDA_SUL_BITNOT
SC_LAMBDA_SUL_BITXOR
SC_LAMBDA_INT_ADD
SC_LAMBDA_INT_SUB
SC_LAMBDA_INT_MUL
SC_LAMBDA_INT_DIV
SC_LAMBDA_INT_REM
SC_LAMBDA_INT_BITAND
SC_LAMBDA_INT_BITOR
SC_LAMBDA_INT_BITNOT
SC_LAMBDA_INT_BITXOR

enum sc_core::sc_severity

列挙型の値:

SC_INFO
SC_WARNING
SC_ERROR
SC_FATAL
SC_MAX_SEVERITY

enum sc_core::sc_stop_mode

列挙型の値:

SC_STOP_FINISH_DELTA
SC_STOP_IMMEDIATE

enum sc_core::sc_time_unit

列挙型の値:

SC_FS
SC_PS
SC_NS
SC_US
SC_MS
SC_SEC

関数

void sc_core::__close_watching ( sc_cthread_handle cthread_h )

void sc_core::__open_watching ( sc_cthread_handle cthread_h )

void sc_core::__reset_watching ( sc_cthread_handle cthread_h )

void sc_core::__sanitycheck_watchlists ( sc_cthread_handle cthread_h )

int sc_core::__watch_level ( sc_cthread_handle cthread_h )

void sc_core::__watching_first ( sc_cthread_handle cthread_h )

static sc_method_handle sc_core::as_method_handle ( sc_process_b * handle_ ) [static]

static sc_thread_handle sc_core::as_thread_handle ( sc_process_b * handle_ ) [static]

void sc_core::at_negedge	(	const sc_signal_in_if< sc_dt::sc_logic > &	s,
		sc_simcontext *	simc
	)

void sc_core::at_negedge	(	const sc_signal_in_if< bool > &	s,
		sc_simcontext *	simc
	)

void sc_core::at_posedge	(	const sc_signal_in_if< sc_dt::sc_logic > &	s,
		sc_simcontext *	simc
	)

void sc_core::at_posedge	(	const sc_signal_in_if< bool > &	s,
		sc_simcontext *	simc
	)

static bool sc_core::compute_use_default_new ( ) [static]

unsigned sc_core::default_int_hash_fn ( const void * p )

unsigned sc_core::default_ptr_hash_fn ( const void * p )

unsigned sc_core::default_str_hash_fn ( const void * p )

void sc_core::double_to_special_int64	(	double	in,
		unsigned *	high,
		unsigned *	low
	)

static char* sc_core::empty_dup ( const char * p ) [inline, static]

void sc_core::halt ( sc_simcontext * simc )

static int sc_core::initialize ( ) [static]

static char sc_core::map_sc_logic_state_to_vcd_state ( char in_char ) [static]

static char sc_core::map_sc_logic_state_to_wif_state ( char in_char ) [static]

static void sc_core::message_function ( const char * s ) [inline, static]

void sc_core::next_trigger	(	double	v,
		sc_time_unit	tu,
		sc_event_and_list &	el,
		sc_simcontext *	simc = `sc_get_curr_simcontext()`
	)			`[inline]`

void sc_core::next_trigger	(	double	v,
		sc_time_unit	tu,
		sc_event_or_list &	el,
		sc_simcontext *	simc = `sc_get_curr_simcontext()`
	)			`[inline]`

void sc_core::next_trigger	(	double	v,
		sc_time_unit	tu,
		const sc_event &	e,
		sc_simcontext *	simc = `sc_get_curr_simcontext()`
	)			`[inline]`

void sc_core::next_trigger	(	double	v,
		sc_time_unit	tu,
		sc_simcontext *	simc = `sc_get_curr_simcontext()`
	)			`[inline]`

void sc_core::next_trigger	(	const sc_time &	t,
		sc_event_and_list &	el,
		sc_simcontext *	simc
	)

void sc_core::next_trigger	(	const sc_time &	t,
		sc_event_or_list &	el,
		sc_simcontext *	simc
	)

void sc_core::next_trigger	(	const sc_time &	t,
		const sc_event &	e,
		sc_simcontext *	simc
	)

void sc_core::next_trigger	(	const sc_time &	t,
		sc_simcontext *	simc
	)

void sc_core::next_trigger	(	sc_event_and_list &	el,
		sc_simcontext *	simc
	)

void sc_core::next_trigger	(	sc_event_or_list &	el,
		sc_simcontext *	simc
	)

void sc_core::next_trigger	(	const sc_event &	e,
		sc_simcontext *	simc
	)

void sc_core::next_trigger ( sc_simcontext * simc )

void sc_core::notify	(	double	v,
		sc_time_unit	tu,
		sc_event &	e
	)			`[inline]`

void sc_core::notify	(	const sc_time &	t,
		sc_event &	e
	)			`[inline]`

void sc_core::notify ( sc_event & e ) [inline]

static int sc_core::object_name_compare	(	const void *	o1,
		const void *	o2
	)			`[static]`

static bool sc_core::object_name_illegal_char ( char ch ) [static]

const sc_time sc_core::operator*	(	double	d,
		const sc_time &	t
	)			`[inline]`

const sc_time sc_core::operator*	(	const sc_time &	t,
		double	d
	)			`[inline]`

const sc_time sc_core::operator+	(	const sc_time &	t1,
		const sc_time &	t2
	)			`[inline]`

const sc_time sc_core::operator-	(	const sc_time &	t1,
		const sc_time &	t2
	)			`[inline]`

double sc_core::operator/	(	const sc_time &	t1,
		const sc_time &	t2
	)			`[inline]`

const sc_time sc_core::operator/	(	const sc_time &	t,
		double	d
	)			`[inline]`

std::ostream & sc_core::operator<<	(	::std::ostream &	os,
		const sc_time &	t
	)			`[inline]`

template<typename T>

::std::ostream& sc_core::operator<<	(	::std::ostream &	os,
		const sc_inout< T > &	a
	)			`[inline]`

template<typename T>

::std::ostream& sc_core::operator<<	(	::std::ostream &	os,
		const sc_in< T > &	a
	)			`[inline]`

template<class T>

inline ::std::ostream& sc_core::operator<<	(	::std::ostream &	os,
		const sc_signal< T > &	a
	)			`[inline]`

template<class T>

inline ::std::ostream& sc_core::operator<<	(	::std::ostream &	os,
		const sc_fifo< T > &	a
	)			`[inline]`

void sc_core::pln ( )

static void sc_core::remove_vcd_name_problems ( std::string & name ) [static]

int sc_core::sc_argc ( )

const char *const * sc_core::sc_argv ( )

void sc_core::sc_close_vcd_trace_file ( sc_trace_file * tf )

void sc_core::sc_close_wif_trace_file ( sc_trace_file * tf )

const char * sc_core::sc_copyright ( )

void* sc_core::sc_cor_qt_aborthelp	(	qt_t *	,
		void *	,
		void *
	)

void sc_core::sc_cor_qt_wrapper	(	void *	arg,
		void *	cor,
		qt_userf_t *	fn
	)

void* sc_core::sc_cor_qt_yieldhelp	(	qt_t *	sp,
		void *	old_cor,
		void *
	)

template<class T>

sc_method_handle sc_core::sc_create_dynamic_method	(	const char *	name,
		T *	host_p,
		void(T::*)()	method_p,
		bool	dont_initialize = `false`
	)			`[inline]`

template<class T>

sc_thread_handle sc_core::sc_create_dynamic_thread	(	const char *	name,
		T *	host_p,
		void(T::*)()	method_p,
		int	stk_size = `0`,
		bool	dont_initialize = `false`
	)			`[inline]`

sc_trace_file * sc_core::sc_create_vcd_trace_file ( const char * name )

sc_trace_file * sc_core::sc_create_wif_trace_file ( const char * name )

void sc_core::sc_cthread_cor_fn ( void * arg )

void sc_core::sc_cycle ( double duration ) [inline]

void sc_core::sc_cycle	(	double	duration,
		sc_time_unit	time_unit
	)			`[inline]`

void sc_core::sc_cycle ( const sc_time & duration )

void sc_core::sc_defunct_process_function ( sc_module * )

sc_dt::uint64 sc_core::sc_delta_count ( )

int sc_core::sc_elab_and_sim	(	int	argc,
		char *	argv[]
	)

bool sc_core::sc_end_of_simulation_invoked ( ) [inline]

const char * sc_core::sc_gen_unique_name	(	const char *	basename_,
		bool	preserve_first
	)

sc_process_b* sc_core::sc_get_curr_process_handle ( ) [inline]

sc_curr_proc_kind sc_core::sc_get_curr_process_kind ( ) [inline]

sc_simcontext * sc_core::sc_get_curr_simcontext ( )

sc_time sc_core::sc_get_default_time_unit ( )

sc_process_b * sc_core::sc_get_last_created_process_handle ( )

sc_stop_mode sc_core::sc_get_stop_mode ( )

sc_time sc_core::sc_get_time_resolution ( )

void sc_core::sc_initialize ( )

void sc_core::sc_interrupt_here	(	int	id,
		sc_severity	severity
	)

sc_module * sc_core::sc_module_dynalloc ( sc_module * module_ )

int sc_core::sc_notify_time_compare	(	const void *	p1,
		const void *	p2
	)

static char* sc_core::sc_object_newname ( char * name ) [static]

const char * sc_core::sc_release ( )

bool sc_core::sc_report_close_default_log ( )

const std::string sc_core::sc_report_compose_message ( const sc_report & rep )

void sc_core::sc_set_default_time_unit	(	double	v,
		sc_time_unit	tu
	)

void sc_core::sc_set_location	(	const char *	file,
		int	lineno,
		sc_simcontext *	simc
	)

void sc_core::sc_set_random_seed ( unsigned int )

void sc_core::sc_set_stack_size	(	sc_thread_handle	thread_h,
		size_t	size
	)

void sc_core::sc_set_stop_mode ( sc_stop_mode mode )

void sc_core::sc_set_time_resolution	(	double	v,
		sc_time_unit	tu
	)

void sc_core::sc_signal_invalid_writer	(	const char *	name,
		const char *	kind,
		const char *	first_writer,
		const char *	second_writer
	)

double sc_core::sc_simulation_time ( )

template<typename T>

sc_process_handle sc_core::sc_spawn	(	typename T::result_type *	r_p,
		T	object,
		const char *	name_p = `0`,
		const sc_spawn_options *	opt_p = `0`
	)			`[inline]`

template<typename T>

sc_process_handle sc_core::sc_spawn	(	T	object,
		const char *	name_p = `0`,
		const sc_spawn_options *	opt_p = `0`
	)			`[inline]`

void sc_core::sc_start	(	double	duration,
		sc_time_unit	time_unit
	)			`[inline]`

void sc_core::sc_start ( double duration )

void sc_core::sc_start ( const sc_time & duration )

void sc_core::sc_start	(	sc_clock &	clock,
		double	duration = `-1`
	)			`[inline]`

void sc_core::sc_start	(	sc_clock &	clock,
		double	v,
		sc_time_unit	tu
	)			`[inline]`

void sc_core::sc_start	(	sc_clock &	clock,
		const sc_time &	duration
	)			`[inline]`

bool sc_core::sc_start_of_simulation_invoked ( ) [inline]

void sc_core::sc_stop ( )

void sc_core::sc_stop_here	(	int	id,
		sc_severity	severity
	)

int sc_core::sc_strhash_cmp	(	const void *	a,
		const void *	b
	)

void * sc_core::sc_strhash_kdup ( const void * k )

void sc_core::sc_strhash_kfree ( void * k )

void sc_core::sc_switch_thread ( sc_simcontext * simc ) [inline]

void sc_core::sc_thread_cor_fn ( void * arg )

static int sc_core::sc_time_compare	(	const void *	p1,
		const void *	p2
	)			`[static]`

const sc_time & sc_core::sc_time_stamp ( )

template<class T>

void sc_core::sc_trace	(	sc_trace_file *	tf,
		const sc_signal_in_if< T > &	object,
		const char *	name
	)			`[inline]`

template<class T>

void sc_core::sc_trace	(	sc_trace_file *	tf,
		const sc_signal_in_if< T > &	object,
		const std::string &	name
	)			`[inline]`

void sc_core::sc_trace	(	sc_trace_file *	tf,
		const unsigned int &	object,
		const std::string &	name,
		const char **	enum_literals
	)

void sc_core::sc_trace	(	sc_trace_file *	,
		const void *	,
		const std::string &	name
	)

void sc_core::sc_trace	(	sc_trace_file *	tf,
		const sc_signal_in_if< long > &	object,
		const std::string &	name,
		int	width
	)

void sc_core::sc_trace	(	sc_trace_file *	tf,
		const sc_signal_in_if< int > &	object,
		const std::string &	name,
		int	width
	)

void sc_core::sc_trace	(	sc_trace_file *	tf,
		const sc_signal_in_if< short > &	object,
		const std::string &	name,
		int	width
	)

void sc_core::sc_trace	(	sc_trace_file *	tf,
		const sc_signal_in_if< char > &	object,
		const std::string &	name,
		int	width
	)

template<class T>

void sc_core::sc_trace	(	sc_trace_file *	tf,
		const sc_inout< T > &	port,
		const std::string &	name
	)			`[inline]`

template<class T>

void sc_core::sc_trace	(	sc_trace_file *	tf,
		const sc_in< T > &	port,
		const std::string &	name
	)			`[inline]`

void sc_core::sc_trace_delta_cycles	(	sc_trace_file *	tf,
		bool	on = `true`
	)			`[inline]`

const char * sc_core::sc_version ( )

void sc_core::sc_write_comment	(	sc_trace_file *	tf,
		const std::string &	comment
	)			`[inline]`

void* sc_core::stack_align	(	void *	sp,
		int	alignment,
		std::size_t *	stack_size
	)			`[inline]`

int sc_core::strcmp_void	(	const void *	a,
		const void *	b
	)

bool sc_core::timed_out ( sc_simcontext * simc )

void sc_core::tprintf	(	sc_trace_file *	tf,
		const char *	format,
			...
	)

void sc_core::vcd_put_error_message	(	const char *	msg,
		bool	just_warning
	)

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

void sc_core::wait	(	double	v,
		sc_time_unit	tu,
		sc_event_and_list &	el,
		sc_simcontext *	simc = `sc_get_curr_simcontext()`
	)			`[inline]`

void sc_core::wait	(	double	v,
		sc_time_unit	tu,
		sc_event_or_list &	el,
		sc_simcontext *	simc = `sc_get_curr_simcontext()`
	)			`[inline]`

void sc_core::wait	(	double	v,
		sc_time_unit	tu,
		const sc_event &	e,
		sc_simcontext *	simc = `sc_get_curr_simcontext()`
	)			`[inline]`

void sc_core::wait	(	double	v,
		sc_time_unit	tu,
		sc_simcontext *	simc = `sc_get_curr_simcontext()`
	)			`[inline]`

void sc_core::wait	(	const sc_time &	t,
		sc_event_and_list &	el,
		sc_simcontext *	simc
	)

void sc_core::wait	(	const sc_time &	t,
		sc_event_or_list &	el,
		sc_simcontext *	simc
	)

void sc_core::wait	(	const sc_time &	t,
		const sc_event &	e,
		sc_simcontext *	simc
	)

void sc_core::wait	(	const sc_time &	t,
		sc_simcontext *	simc
	)

void sc_core::wait	(	sc_event_and_list &	el,
		sc_simcontext *	simc
	)

void sc_core::wait	(	sc_event_or_list &	el,
		sc_simcontext *	simc
	)

void sc_core::wait	(	const sc_event &	e,
		sc_simcontext *	simc
	)

void sc_core::wait ( sc_simcontext * simc )

void sc_core::wait_until	(	const sc_signal_bool_deval &	s,
		sc_simcontext *	simc = `sc_get_curr_simcontext()`
	)			`[inline]`

void sc_core::wait_until	(	const sc_lambda_ptr &	lambda,
		sc_simcontext *	simc
	)

void sc_core::watching	(	const sc_signal_bool_deval &	s,
		sc_simcontext *	simc = `sc_get_curr_simcontext()`
	)			`[inline]`

void sc_core::watching	(	const sc_lambda_ptr &	lambda,
		sc_simcontext *	simc = `sc_get_curr_simcontext()`
	)			`[inline]`

void sc_core::watching_before_simulation	(	const sc_lambda_ptr &	lambda,
		sc_simcontext *	simc
	)

void sc_core::watching_during_simulation	(	const sc_lambda_ptr &	lambda,
		sc_simcontext *	simc
	)

void sc_core::wif_put_error_message	(	const char *	msg,
		bool	just_warning
	)

変数

SC_API_VERSION_STRING sc_core::api_version_check [static]

int sc_core::argc_copy [static]

char** sc_core::argv_copy [static]

struct sc_core::auto_close_log sc_core::auto_close [static]

const int sc_core::cell_size_to_allocator[] [static]

初期値:

const int sc_core::cell_sizes[] [static]

初期値:

const char sc_core::copyright[] [static]

初期値:

    "        Copyright (c) 1996-2005 by all Contributors\n"
    "                    ALL RIGHTS RESERVED"

sc_cor_qt* sc_core::curr_cor = 0 [static]

sc_thread_handle sc_core::dead_thread_h = 0 [static]

sc_msg_def sc_core::default_msgs[] [static]

初期値:

 {
    DEFINE_MSG(SC_ID_REGISTER_ID_FAILED_, 800),
    DEFINE_MSG(SC_ID_UNKNOWN_ERROR_, 0),
    DEFINE_MSG(SC_ID_WITHOUT_MESSAGE_, 1),
    DEFINE_MSG(SC_ID_NOT_IMPLEMENTED_, 2),
    DEFINE_MSG(SC_ID_INTERNAL_ERROR_, 3),
    DEFINE_MSG(SC_ID_ASSERTION_FAILED_, 4),

}

char sc_core::empty_str[] = "" [static]

int sc_core::forty_two = initialize() [static]

sc_event_timed_u* sc_core::free_list = 0 [static]

sc_report_handler::msg_def_items sc_core::items [static]

初期値:

 {
    texts, sizeof(texts)/sizeof(*texts), false, 0
}

::std::ofstream* sc_core::log_stream = 0 [static]

sc_cor_qt sc_core::main_cor [static]

const double sc_core::PHASH_DEFAULT_GROW_FACTOR = 2.0

const int sc_core::PHASH_DEFAULT_INIT_TABLE_SIZE = 11

const int sc_core::PHASH_DEFAULT_MAX_DENSITY = 5

const bool sc_core::PHASH_DEFAULT_REORDER_FLAG = true

static bool sc_core::running_regression = false [static]

const sc_bind_proxy sc_core::SC_BIND_PROXY_NIL

sc_simcontext* sc_core::sc_curr_simcontext = 0 [static]

const int sc_core::SC_DEFAULT_STACK_SIZE = 0x10000

bool sc_core::sc_enable_name_checking = true

const char sc_core::SC_HIERARCHY_CHAR = '.'

const char sc_core::SC_ID_ASSERTION_FAILED_ = "assertion failed"

const char sc_core::SC_ID_INTERNAL_ERROR_ = "internal error"

const char sc_core::SC_ID_NOT_IMPLEMENTED_ = "not implemented"

const char sc_core::SC_ID_OUT_OF_BOUNDS_ = "out of bounds"

const char sc_core::SC_ID_REGISTER_ID_FAILED_ = "register_id failed"

const char sc_core::SC_ID_UNKNOWN_ERROR_ = "unknown error"

const char sc_core::SC_ID_WITHOUT_MESSAGE_ = ""

bool sc_core::sc_in_action = false

const char* sc_core::sc_lambda_rand_names[] [static]

初期値:

 {
    "SC_LAMBDA_RAND_LAMBDA",
    "SC_LAMBDA_RAND_SIGNAL_INT",
    "SC_LAMBDA_RAND_SIGNAL_SUL",
    "SC_LAMBDA_RAND_SIGNAL_BOOL",
    "SC_LAMBDA_RAND_INT",
    "SC_LAMBDA_RAND_SUL",
    "SC_LAMBDA_RAND_BOOL"
}

const sc_dt::sc_logic_value_t sc_core::sc_logic_resolution_tbl

初期値:

{   
    { sc_dt::Log_0, sc_dt::Log_X, sc_dt::Log_0, sc_dt::Log_X }, 
    { sc_dt::Log_X, sc_dt::Log_1, sc_dt::Log_1, sc_dt::Log_X }, 
    { sc_dt::Log_0, sc_dt::Log_1, sc_dt::Log_Z, sc_dt::Log_X }, 
    { sc_dt::Log_X, sc_dt::Log_X, sc_dt::Log_X, sc_dt::Log_X }  
}

const int sc_core::SC_MAX_WATCH_LEVEL = 16

int sc_core::sc_object_num = 0 [static]

sc_process_call_base sc_core::sc_process_defunct

const int sc_core::SC_SIM_ERROR = 1

const int sc_core::SC_SIM_OK = 0

const int sc_core::SC_SIM_USER_STOP = 2

sc_byte_heap sc_core::sc_temp_heap

const sc_time sc_core::SC_ZERO_TIME

sc_stop_mode sc_core::stop_mode = SC_STOP_FINISH_DELTA

const char sc_core::systemc_version[] [static]

初期値:

    "             SystemC " SC_RELEASE_STRING " --- " __DATE__ " " __TIME__

sc_msg_def sc_core::texts[] [static]

初期値:

 {
#define SC_DEFINE_MESSAGE(id,n,unused) 





















}

sc_mempool_int* sc_core::the_mempool = 0 [static]

const char* sc_core::time_units[] [static]

初期値:

 {
    "fs",
    "ps",
    "ns",
    "us",
    "ms",
    "s"
}

double sc_core::time_values[] [static]

初期値:

const char sc_core::unknown_id[] = "unknown id" [static]

const char* sc_core::vcd_types[vcd_trace_file::VCD_LAST] = {"wire","real"}

bool sc_core::warnings_are_errors = false [static]

const char* sc_core::wif_names[wif_trace_file::WIF_LAST] = {"BIT","MVL","real"}


構成
class	sc_buffer
class	sc_clock
class	sc_clock_posedge_callback
class	sc_clock_negedge_callback
class	sc_event_finder
class	sc_event_finder_t
class	sc_event_queue_if
class	sc_event_queue
class	sc_export_base
class	sc_export
class	sc_export_registry
class	sc_fifo
class	sc_fifo_nonblocking_in_if
class	sc_fifo_blocking_in_if
class	sc_fifo_in_if
class	sc_fifo_nonblocking_out_if
class	sc_fifo_blocking_out_if
class	sc_fifo_out_if
class	sc_fifo_in
class	sc_fifo_out
class	sc_interface
class	sc_mutex
class	sc_mutex_if
struct	sc_bind_elem
struct	sc_bind_ef
struct	sc_bind_info
class	sc_port_base
class	sc_port_registry
class	sc_port_b
class	sc_port
class	sc_prim_channel
class	sc_prim_channel_registry
class	sc_semaphore
class	sc_semaphore_if
class	sc_signal
class	sc_signal< bool >
class	sc_signal< sc_dt::sc_logic >
class	sc_signal_in_if
class	sc_signal_in_if< bool >
class	sc_signal_in_if< sc_dt::sc_logic >
class	sc_signal_inout_if
struct	sc_trace_params
class	sc_in
class	sc_in< bool >
class	sc_in< sc_dt::sc_logic >
class	sc_inout
class	sc_inout< bool >
class	sc_inout< sc_dt::sc_logic >
class	sc_out
class	sc_logic_resolve
class	sc_signal_resolved
class	sc_in_resolved
class	sc_inout_resolved
class	sc_out_resolved
class	sc_lv_resolve
class	sc_signal_rv
class	sc_in_rv
class	sc_inout_rv
class	sc_out_rv
class	sc_attr_base
class	sc_attr_cltn
class	sc_attribute
class	sc_cor
class	sc_cor_pkg
class	sc_cor_qt
class	sc_cor_pkg_qt
union	sc_event_timed_u
class	sc_event
class	sc_event_timed
class	sc_event_list
class	sc_event_or_list
class	sc_event_and_list
class	sc_user
class	sc_halt
class	sc_join
class	sc_lambda
class	sc_lambda_ptr
class	sc_lambda_rand
class	sc_module_dynalloc_list
struct	sc_bind_proxy
class	sc_module
class	sc_module_name
class	sc_module_registry
class	sc_name_gen
class	sc_object
class	sc_object_manager
class	sc_process_b
class	sc_spawn_options
class	sc_process_base
class	sc_process_handle
class	sc_spawn_object
class	sc_spawn_object_v
class	sc_process_host
class	sc_process_monitor
class	sc_method_process
class	sc_thread_process
class	sc_cthread_process
class	sc_runnable
class	sc_sensitive
class	sc_sensitive_pos
class	sc_sensitive_neg
class	sc_process_table
struct	sc_curr_proc_info
class	sc_simcontext
class	sc_time
struct	sc_time_params
class	SC_API_VERSION_STRING
class	sc_watch
class	sc_trace_file
class	vcd_trace
class	vcd_T_trace
class	vcd_bool_trace
class	vcd_sc_bit_trace
class	vcd_sc_logic_trace
class	vcd_sc_unsigned_trace
class	vcd_sc_signed_trace
class	vcd_sc_uint_base_trace
class	vcd_sc_int_base_trace
class	vcd_sc_fxval_trace
class	vcd_sc_fxval_fast_trace
class	vcd_sc_fxnum_trace
class	vcd_sc_fxnum_fast_trace
class	vcd_unsigned_int_trace
class	vcd_unsigned_short_trace
class	vcd_unsigned_char_trace
class	vcd_unsigned_long_trace
class	vcd_signed_int_trace
class	vcd_signed_short_trace
class	vcd_signed_char_trace
class	vcd_int64_trace
class	vcd_uint64_trace
class	vcd_signed_long_trace
class	vcd_float_trace
class	vcd_double_trace
class	vcd_enum_trace
class	vcd_trace_file
class	wif_trace
class	wif_uint64_trace
class	wif_int64_trace
class	wif_bool_trace
class	wif_sc_bit_trace
class	wif_sc_logic_trace
class	wif_sc_unsigned_trace
class	wif_sc_signed_trace
class	wif_sc_uint_base_trace
class	wif_sc_int_base_trace
class	wif_sc_fxval_trace
class	wif_sc_fxval_fast_trace
class	wif_sc_fxnum_trace
class	wif_sc_fxnum_fast_trace
class	wif_unsigned_int_trace
class	wif_unsigned_short_trace
class	wif_unsigned_char_trace
class	wif_unsigned_long_trace
class	wif_signed_int_trace
class	wif_signed_short_trace
class	wif_signed_char_trace
class	wif_signed_long_trace
class	wif_float_trace
class	wif_double_trace
class	wif_enum_trace
class	wif_T_trace
class	wif_trace_file
class	sc_phash_elem
class	sc_phash_base
class	sc_phash_base_iter
class	sc_phash
class	sc_phash_iter
class	sc_pdhash
class	sc_pdhash_iter
class	sc_strhash
class	sc_strhash_iter
class	sc_plist_elem
class	sc_plist_base
class	sc_plist_base_iter
class	sc_plist
class	sc_plist_iter
class	sc_allocator
class	sc_mempool_int
class	sc_mempool
class	sc_mpobject
class	sc_ppq_base
class	sc_ppq
class	sc_report
struct	auto_close_log
struct	sc_msg_def
class	sc_report_handler
class	sc_byte_heap
class	sc_vpool
class	sc_pvector
型定義
typedef sc_in< bool >	sc_in_clk
typedef sc_inout< bool >	sc_inout_clk
typedef sc_out< bool >	sc_out_clk
typedef sc_port < sc_event_queue_if, 1 >	sc_event_queue_port
typedef sc_pvector < sc_trace_params * >	sc_trace_params_vec
typedef void(	sc_cor_fn )(void *)
typedef sc_module	sc_channel
typedef sc_module	sc_behavior
typedef int(*	STRCMP )(const void , const void )
typedef class sc_cthread_process *	sc_cthread_handle
typedef class sc_method_process *	sc_method_handle
typedef class sc_thread_process *	sc_thread_handle
typedef void(sc_process_host::*	SC_ENTRY_FUNC )()
typedef const sc_curr_proc_info *	sc_curr_proc_handle
typedef vcd_T_trace < sc_dt::sc_bv_base >	vcd_sc_bv_trace
typedef vcd_T_trace < sc_dt::sc_lv_base >	vcd_sc_lv_trace
typedef wif_T_trace < sc_dt::sc_bv_base >	wif_sc_bv_trace
typedef wif_T_trace < sc_dt::sc_lv_base >	wif_sc_lv_trace
typedef void(*	sc_plist_map_fn )(void data, void arg)
typedef unsigned	sc_actions
typedef std::exception	sc_exception
typedef void(*	sc_report_handler_proc )(const sc_report &, const sc_actions &)
typedef int(*	CFT )(const void , const void )
列挙型
enum	sc_lambda_rator_e { SC_LAMBDA_FALSE = 0x00000000, SC_LAMBDA_TRUE, SC_LAMBDA_AND, SC_LAMBDA_OR, SC_LAMBDA_NOT, SC_LAMBDA_BOOL, SC_LAMBDA_BOOL_EQ, SC_LAMBDA_BOOL_NE, SC_LAMBDA_SUL_EQ, SC_LAMBDA_SUL_NE, SC_LAMBDA_INT_EQ, SC_LAMBDA_INT_NE, SC_LAMBDA_INT_LE, SC_LAMBDA_INT_GE, SC_LAMBDA_INT_LT, SC_LAMBDA_INT_GT, SC_LAMBDA_SUL_BITAND, SC_LAMBDA_SUL_BITOR, SC_LAMBDA_SUL_BITNOT, SC_LAMBDA_SUL_BITXOR, SC_LAMBDA_INT_ADD, SC_LAMBDA_INT_SUB, SC_LAMBDA_INT_MUL, SC_LAMBDA_INT_DIV, SC_LAMBDA_INT_REM, SC_LAMBDA_INT_BITAND, SC_LAMBDA_INT_BITOR, SC_LAMBDA_INT_BITNOT, SC_LAMBDA_INT_BITXOR }
enum	sc_lambda_rand_e { SC_LAMBDA_RAND_LAMBDA, SC_LAMBDA_RAND_SIGNAL_INT, SC_LAMBDA_RAND_SIGNAL_SUL, SC_LAMBDA_RAND_SIGNAL_BOOL, SC_LAMBDA_RAND_INT, SC_LAMBDA_RAND_SUL, SC_LAMBDA_RAND_BOOL }
enum	sc_curr_proc_kind { SC_NO_PROC_, SC_METHOD_PROC_, SC_THREAD_PROC_, SC_CTHREAD_PROC_ }
enum	sc_stop_mode { SC_STOP_FINISH_DELTA, SC_STOP_IMMEDIATE }
enum	sc_time_unit { SC_FS = 0, SC_PS, SC_NS, SC_US, SC_MS, SC_SEC }
enum	sc_severity { SC_INFO = 0, SC_WARNING, SC_ERROR, SC_FATAL, SC_MAX_SEVERITY }
enum	{ SC_UNSPECIFIED = 0x0000, SC_DO_NOTHING = 0x0001, SC_THROW = 0x0002, SC_LOG = 0x0004, SC_DISPLAY = 0x0008, SC_CACHE_REPORT = 0x0010, SC_INTERRUPT = 0x0020, SC_STOP = 0x0040, SC_ABORT = 0x0080 }
関数
void	sc_start (sc_clock &clock, const sc_time &duration)
void	sc_start (sc_clock &clock, double v, sc_time_unit tu)
void	sc_start (sc_clock &clock, double duration=-1)
static int	sc_time_compare (const void p1, const void p2)
template<class T>
inline::std::ostream &	operator<< (::std::ostream &os, const sc_fifo< T > &a)
void	sc_signal_invalid_writer (const char name, const char kind, const char first_writer, const char second_writer)
template<class T>
inline::std::ostream &	operator<< (::std::ostream &os, const sc_signal< T > &a)
template<typename T>
::std::ostream &	operator<< (::std::ostream &os, const sc_in< T > &a)
template<typename T>
::std::ostream &	operator<< (::std::ostream &os, const sc_inout< T > &a)
template<class T>
void	sc_trace (sc_trace_file *tf, const sc_in< T > &port, const std::string &name)
template<class T>
void	sc_trace (sc_trace_file *tf, const sc_inout< T > &port, const std::string &name)
void *	stack_align (void sp, int alignment, std::size_t stack_size)
void	sc_cor_qt_wrapper (void arg, void cor, qt_userf_t *fn)
void *	sc_cor_qt_yieldhelp (qt_t sp, void old_cor, void *)
void *	sc_cor_qt_aborthelp (qt_t , void , void *)
void	notify (sc_event &e)
void	notify (const sc_time &t, sc_event &e)
void	notify (double v, sc_time_unit tu, sc_event &e)
int	sc_elab_and_sim (int argc, char *argv[])
int	sc_argc ()
const char const	sc_argv ()
void	pln ()
static void	message_function (const char *s)
sc_module *	sc_module_dynalloc (sc_module *module_)
static char *	sc_object_newname (char *name)
static bool	object_name_illegal_char (char ch)
int	strcmp_void (const void a, const void b)
static int	object_name_compare (const void o1, const void o2)
void	sc_set_stack_size (sc_thread_handle, size_t)
template<typename T>
sc_process_handle	sc_spawn (T object, const char name_p=0, const sc_spawn_options opt_p=0)
template<typename T>
sc_process_handle	sc_spawn (typename T::result_type r_p, T object, const char name_p=0, const sc_spawn_options *opt_p=0)
template<class T>
sc_method_handle	sc_create_dynamic_method (const char name, T host_p, void(T::*method_p)(), bool dont_initialize=false)
template<class T>
sc_thread_handle	sc_create_dynamic_thread (const char name, T host_p, void(T::*method_p)(), int stk_size=0, bool dont_initialize=false)
void	sc_thread_cor_fn (void *arg)
void	sc_cthread_cor_fn (void *arg)
void	sc_switch_thread (sc_simcontext *simc)
static sc_method_handle	as_method_handle (sc_process_b *handle_)
static sc_thread_handle	as_thread_handle (sc_process_b *handle_)
int	sc_notify_time_compare (const void p1, const void p2)
sc_simcontext *	sc_get_curr_simcontext ()
sc_process_b *	sc_get_last_created_process_handle ()
const char *	sc_gen_unique_name (const char *basename_, bool preserve_first)
void	sc_set_random_seed (unsigned int)
void	sc_start (const sc_time &duration)
void	sc_start (double duration)
void	sc_stop ()
void	sc_initialize ()
void	sc_cycle (const sc_time &duration)
sc_dt::uint64	sc_delta_count ()
const sc_time &	sc_time_stamp ()
double	sc_simulation_time ()
void	sc_defunct_process_function (sc_module *)
void	sc_set_stop_mode (sc_stop_mode mode)
sc_stop_mode	sc_get_stop_mode ()
sc_process_b *	sc_get_curr_process_handle ()
sc_curr_proc_kind	sc_get_curr_process_kind ()
void	sc_start (double duration, sc_time_unit time_unit)
void	sc_cycle (double duration, sc_time_unit time_unit)
void	sc_cycle (double duration)
bool	sc_end_of_simulation_invoked ()
bool	sc_start_of_simulation_invoked ()
void	watching_before_simulation (const sc_lambda_ptr &, sc_simcontext *)
void	watching_during_simulation (const sc_lambda_ptr &, sc_simcontext *)
void	sc_set_time_resolution (double v, sc_time_unit tu)
sc_time	sc_get_time_resolution ()
void	sc_set_default_time_unit (double v, sc_time_unit tu)
sc_time	sc_get_default_time_unit ()
inline::std::ostream &	operator<< (::std::ostream &, const sc_time &)
const sc_time	operator+ (const sc_time &t1, const sc_time &t2)
const sc_time	operator- (const sc_time &t1, const sc_time &t2)
const sc_time	operator* (const sc_time &t, double d)
const sc_time	operator* (double d, const sc_time &t)
const sc_time	operator/ (const sc_time &t, double d)
double	operator/ (const sc_time &t1, const sc_time &t2)
const char *	sc_copyright ()
const char *	sc_release ()
const char *	sc_version ()
void	wait (sc_simcontext *simc)
void	wait (const sc_event &e, sc_simcontext *simc)
void	wait (sc_event_or_list &el, sc_simcontext *simc)
void	wait (sc_event_and_list &el, sc_simcontext *simc)
void	wait (const sc_time &t, sc_simcontext *simc)
void	wait (const sc_time &t, const sc_event &e, sc_simcontext *simc)
void	wait (const sc_time &t, sc_event_or_list &el, sc_simcontext *simc)
void	wait (const sc_time &t, sc_event_and_list &el, sc_simcontext *simc)
void	next_trigger (sc_simcontext *simc)
void	next_trigger (const sc_event &e, sc_simcontext *simc)
void	next_trigger (sc_event_or_list &el, sc_simcontext *simc)
void	next_trigger (sc_event_and_list &el, sc_simcontext *simc)
void	next_trigger (const sc_time &t, sc_simcontext *simc)
void	next_trigger (const sc_time &t, const sc_event &e, sc_simcontext *simc)
void	next_trigger (const sc_time &t, sc_event_or_list &el, sc_simcontext *simc)
void	next_trigger (const sc_time &t, sc_event_and_list &el, sc_simcontext *simc)
bool	timed_out (sc_simcontext *simc)
void	sc_set_location (const char file, int lineno, sc_simcontext simc)
void	wait (double v, sc_time_unit tu, sc_simcontext *simc=sc_get_curr_simcontext())
void	wait (double v, sc_time_unit tu, const sc_event &e, sc_simcontext *simc=sc_get_curr_simcontext())
void	wait (double v, sc_time_unit tu, sc_event_or_list &el, sc_simcontext *simc=sc_get_curr_simcontext())
void	wait (double v, sc_time_unit tu, sc_event_and_list &el, sc_simcontext *simc=sc_get_curr_simcontext())
void	next_trigger (double v, sc_time_unit tu, sc_simcontext *simc=sc_get_curr_simcontext())
void	next_trigger (double v, sc_time_unit tu, const sc_event &e, sc_simcontext *simc=sc_get_curr_simcontext())
void	next_trigger (double v, sc_time_unit tu, sc_event_or_list &el, sc_simcontext *simc=sc_get_curr_simcontext())
void	next_trigger (double v, sc_time_unit tu, sc_event_and_list &el, sc_simcontext *simc=sc_get_curr_simcontext())
void	halt (sc_simcontext *simc)
void	wait (int n, sc_simcontext *simc)
void	wait_until (const sc_lambda_ptr &lambda, sc_simcontext *simc)
void	at_posedge (const sc_signal_in_if< bool > &s, sc_simcontext *simc)
void	at_posedge (const sc_signal_in_if< sc_dt::sc_logic > &s, sc_simcontext *simc)
void	at_negedge (const sc_signal_in_if< bool > &s, sc_simcontext *simc)
void	at_negedge (const sc_signal_in_if< sc_dt::sc_logic > &s, sc_simcontext *simc)
void	__reset_watching (sc_cthread_handle cthread_h)
void	__open_watching (sc_cthread_handle cthread_h)
void	__close_watching (sc_cthread_handle cthread_h)
int	__watch_level (sc_cthread_handle cthread_h)
void	__watching_first (sc_cthread_handle cthread_h)
void	__sanitycheck_watchlists (sc_cthread_handle cthread_h)
void	wait_until (const sc_signal_bool_deval &s, sc_simcontext *simc=sc_get_curr_simcontext())
void	watching (const sc_lambda_ptr &lambda, sc_simcontext *simc=sc_get_curr_simcontext())
void	watching (const sc_signal_bool_deval &s, sc_simcontext *simc=sc_get_curr_simcontext())
void	tprintf (sc_trace_file tf, const char format,...)
void	sc_trace (sc_trace_file *tf, const sc_signal_in_if< char > &object, const std::string &name, int width)
void	sc_trace (sc_trace_file *tf, const sc_signal_in_if< short > &object, const std::string &name, int width)
void	sc_trace (sc_trace_file *tf, const sc_signal_in_if< int > &object, const std::string &name, int width)
void	sc_trace (sc_trace_file *tf, const sc_signal_in_if< long > &object, const std::string &name, int width)
void	sc_trace (sc_trace_file , const void , const std::string &name)
void	double_to_special_int64 (double in, unsigned high, unsigned low)
void	sc_trace (sc_trace_file tf, const unsigned int &object, const std::string &name, const char *enum_literals)
template<class T>
void	sc_trace (sc_trace_file *tf, const sc_signal_in_if< T > &object, const std::string &name)
template<class T>
void	sc_trace (sc_trace_file tf, const sc_signal_in_if< T > &object, const char name)
void	sc_trace_delta_cycles (sc_trace_file *tf, bool on=true)
void	sc_write_comment (sc_trace_file *tf, const std::string &comment)
static char	map_sc_logic_state_to_vcd_state (char in_char)
static void	remove_vcd_name_problems (std::string &name)
void	vcd_put_error_message (const char *msg, bool just_warning)
sc_trace_file *	sc_create_vcd_trace_file (const char *name)
void	sc_close_vcd_trace_file (sc_trace_file *tf)
static char	map_sc_logic_state_to_wif_state (char in_char)
void	wif_put_error_message (const char *msg, bool just_warning)
sc_trace_file *	sc_create_wif_trace_file (const char *name)
void	sc_close_wif_trace_file (sc_trace_file *tf)
unsigned	default_ptr_hash_fn (const void *p)
unsigned	default_int_hash_fn (const void *p)
unsigned	default_str_hash_fn (const void *p)
int	sc_strhash_cmp (const void a, const void b)
void *	sc_strhash_kdup (const void *k)
void	sc_strhash_kfree (void *k)
static bool	compute_use_default_new ()
static char *	empty_dup (const char *p)
const std::string	sc_report_compose_message (const sc_report &)
bool	sc_report_close_default_log ()
void	sc_interrupt_here (int id, sc_severity severity)
void	sc_stop_here (int id, sc_severity severity)
static int	initialize ()
変数
const char	SC_ID_REGISTER_ID_FAILED_ [] = "register_id failed"
const sc_dt::sc_logic_value_t	sc_logic_resolution_tbl [4][4]
sc_byte_heap	sc_temp_heap (0x300000)
const int	SC_DEFAULT_STACK_SIZE = 0x10000
const int	SC_MAX_WATCH_LEVEL = 16
static sc_cor_qt	main_cor
static sc_cor_qt *	curr_cor = 0
static sc_event_timed_u *	free_list = 0
static const char *	sc_lambda_rand_names []
static int	argc_copy
static char **	argv_copy
bool	sc_in_action = false
const sc_bind_proxy	SC_BIND_PROXY_NIL
const char	SC_HIERARCHY_CHAR = '.'
bool	sc_enable_name_checking = true
static int	sc_object_num = 0
static sc_thread_handle	dead_thread_h = 0
sc_process_call_base	sc_process_defunct
sc_stop_mode	stop_mode = SC_STOP_FINISH_DELTA
static sc_simcontext *	sc_curr_simcontext = 0
const int	SC_SIM_OK = 0
const int	SC_SIM_ERROR = 1
const int	SC_SIM_USER_STOP = 2
static double	time_values []
static const char *	time_units []
const sc_time	SC_ZERO_TIME
static const char	copyright []
static const char	systemc_version []
static SC_API_VERSION_STRING	api_version_check
static bool	running_regression = false
const char *	vcd_types [vcd_trace_file::VCD_LAST] = {"wire","real"}
const char *	wif_names [wif_trace_file::WIF_LAST] = {"BIT","MVL","real"}
const double	PHASH_DEFAULT_GROW_FACTOR = 2.0
const int	PHASH_DEFAULT_MAX_DENSITY = 5
const int	PHASH_DEFAULT_INIT_TABLE_SIZE = 11
const bool	PHASH_DEFAULT_REORDER_FLAG = true
static const int	cell_sizes []
static const int	cell_size_to_allocator []
static sc_mempool_int *	the_mempool = 0
static char	empty_str [] = ""
static bool	warnings_are_errors = false
static const char	unknown_id [] = "unknown id"
const char	SC_ID_UNKNOWN_ERROR_ [] = "unknown error"
const char	SC_ID_WITHOUT_MESSAGE_ [] = ""
const char	SC_ID_NOT_IMPLEMENTED_ [] = "not implemented"
const char	SC_ID_INTERNAL_ERROR_ [] = "internal error"
const char	SC_ID_ASSERTION_FAILED_ [] = "assertion failed"
const char	SC_ID_OUT_OF_BOUNDS_ [] = "out of bounds"
::std::ofstream *	log_stream = 0
static struct sc_core::auto_close_log	auto_close
static sc_msg_def	default_msgs []
static sc_msg_def	texts []
static sc_report_handler::msg_def_items	items
static int	forty_two = initialize()

ネームスペース sc_core

構成

型定義

列挙型

関数

変数

型定義

列挙型

関数

変数