ネームスペース sc_core


構成

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_write_if
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
class  sc_cthread_process
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_method_process
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_host
class  sc_process_monitor
class  sc_process_b
class  sc_process_handle
class  sc_reset_finder
class  sc_reset
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_spawn_object
class  sc_spawn_object_v
class  sc_spawn_options
class  sc_thread_process
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_ONE_OR_MORE_BOUND > 		sc_event_queue_port
typedef std::vector
< 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 sc_process_b sc_process_b
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_port_policy { SC_ONE_OR_MORE_BOUND, SC_ZERO_OR_MORE_BOUND, SC_ALL_BOUND }
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_warn_port_constructor ()
void sc_signal_invalid_writer (sc_object *target, sc_object *first_writer, sc_object *second_writer)
void sc_deprecated_get_data_ref ()
void sc_deprecated_get_new_value ()
void sc_deprecated_trace ()
template<class T>
inline::std::ostream & operator<< (::std::ostream &os, const sc_signal< T > &a)
void sc_deprecated_add_trace ()
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 sc_cthread_cor_fn (void *arg)
void wait (sc_simcontext *)
void wait (const sc_event &, sc_simcontext *)
void wait (sc_event_or_list &, sc_simcontext *)
void wait (sc_event_and_list &, sc_simcontext *)
void wait (const sc_time &, sc_simcontext *)
void wait (const sc_time &, const sc_event &, sc_simcontext *)
void wait (const sc_time &, sc_event_or_list &, sc_simcontext *)
void wait (const sc_time &, sc_event_and_list &, sc_simcontext *)
void halt (sc_simcontext *)
void wait (int, sc_simcontext *)
static void sc_warn_notify_delayed ()
static void sc_warn_notify ()
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_notify_time_compare (const void *, const void *)
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)
void sc_method_cor_fn (void *)
void sc_cmethod_cor_fn (void *)
void sc_set_stack_size (sc_method_handle, std::size_t)
void next_trigger (sc_simcontext *)
void next_trigger (const sc_event &, sc_simcontext *)
void next_trigger (sc_event_or_list &, sc_simcontext *)
void next_trigger (sc_event_and_list &, sc_simcontext *)
void next_trigger (const sc_time &, sc_simcontext *)
void next_trigger (const sc_time &, const sc_event &, sc_simcontext *)
void next_trigger (const sc_time &, sc_event_or_list &, sc_simcontext *)
void next_trigger (const sc_time &, sc_event_and_list &, sc_simcontext *)
sc_module * sc_module_dynalloc (sc_module *module_)
static void sc_warn_arrow_arrow_bind ()
static char * sc_object_newname (char *name)
static bool object_name_illegal_char (char ch)
sc_object * sc_get_parent (const sc_object *obj_p)
int strcmp_void (const void *a, const void *b)
static int object_name_compare (const void *o1, const void *o2)
const char * sc_gen_unique_name (const char *, bool preserve_first)
sc_process_handle sc_get_current_process_handle ()
void sc_thread_cor_fn (void *arg)
bool timed_out (sc_simcontext *)
void sc_set_stack_size (sc_thread_handle, std::size_t)
bool operator== (const sc_process_handle &left, const sc_process_handle &right)
bool operator!= (const sc_process_handle &left, const sc_process_handle &right)
sc_process_handle sc_get_last_created_process_handle ()
static sc_method_handle as_method_handle (sc_process_b *handle_)
static sc_thread_handle as_thread_handle (sc_process_b *handle_)
static void warn_no_parens ()
static void sc_deprecated_sensitive_pos ()
static void sc_deprecated_sensitive_neg ()
sc_process_b * sc_get_curr_process_handle ()
bool sc_pending_activity_at_current_time ()
void sc_set_random_seed (unsigned int)
void sc_start (const sc_time &duration)
void sc_start ()
void sc_start (double duration)
void sc_stop ()
void sc_initialize ()
void sc_cycle (const sc_time &duration)
sc_object * sc_find_object (const char *name, sc_simcontext *simc_p)
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_dt::uint64 sc_delta_count ()
const std::vector< sc_object * > & sc_get_top_level_objects (const sc_simcontext *simc_p)
bool sc_is_running (const sc_simcontext *simc_p)
bool sc_end_of_simulation_invoked ()
bool sc_start_of_simulation_invoked ()
void sc_set_time_resolution (double, sc_time_unit)
sc_time sc_get_time_resolution ()
void sc_set_default_time_unit (double, sc_time_unit)
sc_time sc_get_default_time_unit ()
sc_simcontext * sc_get_curr_simcontext ()
sc_process_b * sc_get_current_process_b ()
sc_curr_proc_kind sc_get_curr_process_kind ()
int sc_get_simulator_status ()
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)
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)
sc_cor * get_cor_pointer (sc_process_b *process_p)
const sc_time operator+ (const sc_time &, const sc_time &)
const sc_time operator- (const sc_time &, const sc_time &)
const sc_time operator* (const sc_time &, double)
const sc_time operator* (double, const sc_time &)
const sc_time operator/ (const sc_time &, double)
double operator/ (const sc_time &, const sc_time &)
inline::std::ostream & operator<< (::std::ostream &, const sc_time &)
const char * sc_copyright ()
const char * sc_release ()
const char * sc_version ()
void warn_cthread_wait ()
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 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 put_error_message (const char *msg, bool just_warning)
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)
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)
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 void sc_deprecated_report_ids (const char *method)
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 (const char *id, sc_severity severity)
void sc_stop_here (const char *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
sc_event sc_non_event
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_reset_finder * reset_finder_q = 0
sc_stop_mode stop_mode = SC_STOP_FINISH_DELTA
sc_simcontext * sc_curr_simcontext = 0
sc_simcontext * sc_default_global_context = 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()

型定義

typedef int(* sc_core::CFT)(const void *, const void *)

sc_vector.h の 54 行で定義されています。

typedef unsigned sc_core::sc_actions

sc_report.h の 72 行で定義されています。

typedef sc_module sc_core::sc_behavior

sc_module.h の 545 行で定義されています。

typedef sc_module sc_core::sc_channel

sc_module.h の 544 行で定義されています。

typedef void( sc_core::sc_cor_fn)(void *)

sc_cor.h の 62 行で定義されています。

typedef class sc_cthread_process* sc_core::sc_cthread_handle

sc_process.h の 100 行で定義されています。

typedef const sc_curr_proc_info* sc_core::sc_curr_proc_handle

sc_simcontext.h の 139 行で定義されています。

typedef void(sc_process_host::* sc_core::SC_ENTRY_FUNC)()

sc_process.h の 177 行で定義されています。

typedef sc_port<sc_event_queue_if,1,SC_ONE_OR_MORE_BOUND> sc_core::sc_event_queue_port

sc_event_queue.h の 163 行で定義されています。

typedef std::exception sc_core::sc_exception

sc_report.h の 179 行で定義されています。

typedef sc_in<bool> sc_core::sc_in_clk

sc_clock_ports.h の 63 行で定義されています。

typedef sc_inout<bool> sc_core::sc_inout_clk

sc_clock_ports.h の 64 行で定義されています。

typedef class sc_method_process* sc_core::sc_method_handle

sc_process.h の 101 行で定義されています。

typedef sc_out<bool> sc_core::sc_out_clk

sc_clock_ports.h の 65 行で定義されています。

typedef void(* sc_core::sc_plist_map_fn)(void *data, void *arg)

sc_list.h の 54 行で定義されています。

typedef sc_process_b sc_core::sc_process_b

sc_process.h の 379 行で定義されています。

typedef void(* sc_core::sc_report_handler_proc)(const sc_report &, const sc_actions &)

sc_report_handler.h の 72 行で定義されています。

typedef class sc_thread_process* sc_core::sc_thread_handle

sc_process.h の 102 行で定義されています。

typedef std::vector<sc_trace_params*> sc_core::sc_trace_params_vec

sc_signal_ports.h の 59 行で定義されています。

typedef int(* sc_core::STRCMP)(const void *, const void *)

sc_object.cpp の 78 行で定義されています。

typedef vcd_T_trace<sc_dt::sc_bv_base> sc_core::vcd_sc_bv_trace

sc_vcd_trace.cpp の 279 行で定義されています。

typedef vcd_T_trace<sc_dt::sc_lv_base> sc_core::vcd_sc_lv_trace

sc_vcd_trace.cpp の 280 行で定義されています。

typedef wif_T_trace<sc_dt::sc_bv_base> sc_core::wif_sc_bv_trace

sc_wif_trace.cpp の 1555 行で定義されています。

typedef wif_T_trace<sc_dt::sc_lv_base> sc_core::wif_sc_lv_trace

sc_wif_trace.cpp の 1556 行で定義されています。

列挙型

anonymous enum

列挙型の値:
SC_UNSPECIFIED 
SC_DO_NOTHING 
SC_THROW 
SC_LOG 
SC_DISPLAY 
SC_CACHE_REPORT 
SC_INTERRUPT 
SC_STOP 
SC_ABORT 

sc_report.h の 80 行で定義されています。

00080      {
00081     SC_UNSPECIFIED  = 0x0000, // look for lower-priority rule
00082     SC_DO_NOTHING   = 0x0001, // take no action (ignore if other bits set)
00083     SC_THROW        = 0x0002, // throw an exception
00084     SC_LOG          = 0x0004, // add report to report log
00085     SC_DISPLAY      = 0x0008, // display report to screen
00086     SC_CACHE_REPORT = 0x0010, // save report to cache
00087     SC_INTERRUPT    = 0x0020, // call sc_interrupt_here(...)
00088     SC_STOP         = 0x0040, // call sc_stop()
00089     SC_ABORT        = 0x0080  // call abort()
00090 };

enum sc_core::sc_curr_proc_kind

列挙型の値:
SC_NO_PROC_ 
SC_METHOD_PROC_ 
SC_THREAD_PROC_ 
SC_CTHREAD_PROC_ 

sc_process.h の 107 行で定義されています。

00108 {
00109     SC_NO_PROC_,
00110     SC_METHOD_PROC_,
00111     SC_THREAD_PROC_,
00112     SC_CTHREAD_PROC_
00113 };

enum sc_core::sc_port_policy

列挙型の値:
SC_ONE_OR_MORE_BOUND 
SC_ZERO_OR_MORE_BOUND 
SC_ALL_BOUND 

sc_port.h の 95 行で定義されています。

00096 { 
00097     SC_ONE_OR_MORE_BOUND,   // Default 
00098     SC_ZERO_OR_MORE_BOUND, 
00099     SC_ALL_BOUND  
00100 };

enum sc_core::sc_severity

列挙型の値:
SC_INFO 
SC_WARNING 
SC_ERROR 
SC_FATAL 
SC_MAX_SEVERITY 

sc_report.h の 64 行で定義されています。

00064                  {
00065     SC_INFO = 0,        // informative only
00066     SC_WARNING, // indicates potentially incorrect condition
00067     SC_ERROR,   // indicates a definite problem
00068     SC_FATAL,   // indicates a problem from which we cannot recover
00069     SC_MAX_SEVERITY
00070 };

enum sc_core::sc_stop_mode

列挙型の値:
SC_STOP_FINISH_DELTA 
SC_STOP_IMMEDIATE 

sc_simcontext.h の 161 行で定義されています。

00161                   {          // sc_stop modes:
00162     SC_STOP_FINISH_DELTA,
00163     SC_STOP_IMMEDIATE
00164 };

enum sc_core::sc_time_unit

列挙型の値:
SC_FS 
SC_PS 
SC_NS 
SC_US 
SC_MS 
SC_SEC 

sc_time.h の 73 行で定義されています。

00074 {
00075     SC_FS = 0,
00076     SC_PS,
00077     SC_NS,
00078     SC_US,
00079     SC_MS,
00080     SC_SEC
00081 };

関数

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

sc_sensitive.cpp の 86 行で定義されています。

00087 {
00088     return DCAST<sc_method_handle>( handle_ );
00089 }

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

sc_sensitive.cpp の 93 行で定義されています。

00094 {
00095     return DCAST<sc_thread_handle>( handle_ );
00096 }

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

sc_wait_cthread.cpp の 146 行で定義されています。

00147 {
00148     if( s.read() == '0' ) 
00149         do { wait(simc); } while ( s.read() == '0' );
00150     do { wait(simc); } while ( s.read() == '1' );
00151 }

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

sc_wait_cthread.cpp の 138 行で定義されています。

00139 {
00140     if( s.read() == false ) 
00141         do { wait(simc); } while ( s.read() == false );
00142     do { wait(simc); } while ( s.read() == true );
00143 }

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

sc_wait_cthread.cpp の 130 行で定義されています。

00131 {
00132     if( s.read() == '1' ) 
00133         do { wait(simc); } while ( s.read() == '1' );
00134     do { wait(simc); } while ( s.read() == '0' );
00135 }

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

sc_wait_cthread.cpp の 122 行で定義されています。

00123 {
00124     if( s.read() == true ) 
00125         do { wait(simc); } while ( s.read() == true );
00126     do { wait(simc); } while ( s.read() == false );
00127 }

static bool sc_core::compute_use_default_new (  )  [static]

sc_mempool.cpp の 237 行で定義されています。

00238 {
00239     const char* e = getenv(dont_use_envstring);
00240     return (e != 0) && (atoi(e) != 0);
00241 }

unsigned sc_core::default_int_hash_fn ( const void *  p  ) 

sc_hash.cpp の 616 行で定義されています。

00617 {
00618     return (unsigned long)(p) * 3141592661U;
00619 }

unsigned sc_core::default_ptr_hash_fn ( const void *  p  ) 

sc_hash.cpp の 609 行で定義されています。

00610 {
00611     return ((unsigned long)(p) >> 2) * 2654435789U;
00612 
00613 }

unsigned sc_core::default_str_hash_fn ( const void *  p  ) 

sc_hash.cpp の 623 行で定義されています。

00624 {
00625     if (!p) return 0;
00626 
00627     const char* x = (const char*) p;
00628     unsigned int h = 0;
00629     unsigned int g;
00630 
00631     while (*x != 0) {
00632         h = (h << 4) + *x++;
00633         if ((g = h & 0xf0000000) != 0)
00634             h = (h ^ (g >> 24)) ^ g;
00635     }
00636     return h;
00637 }

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

sc_trace.cpp の 224 行で定義されています。

00225 {
00226     double invar = in;
00227     if(invar > 5e17) invar = 5e17; // Saturation limit
00228     if(invar < 0.0) invar = 0.0;
00229     invar += .5;
00230     *high = (unsigned)(invar / 1e9);
00231     double rest = invar - 1e9 * (*high);
00232     if(rest < 0) *low = 0;
00233     else *low = (unsigned)rest;
00234 }

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

sc_report.cpp の 89 行で定義されています。

00090 {
00091     return p && *p ? strdup(p): empty_str;
00092 }

sc_cor * sc_core::get_cor_pointer ( sc_process_b *  process_p  )  [inline]

sc_thread_process.h の 383 行で定義されています。

00384 {
00385     sc_thread_handle thread_p = DCAST<sc_thread_handle>(process_p);
00386     return thread_p->m_cor_p;
00387 }

void sc_core::halt ( sc_simcontext *   ) 

sc_wait_cthread.cpp の 86 行で定義されています。

00087 {
00088     sc_curr_proc_handle cpi = simc->get_curr_proc_info();
00089     switch( cpi->kind ) {
00090     case SC_CTHREAD_PROC_: {
00091         RCAST<sc_cthread_handle>( cpi->process_handle )->wait_halt();
00092         break;
00093     }
00094     default:
00095         SC_REPORT_ERROR( SC_ID_HALT_NOT_ALLOWED_, 0 );
00096         break;
00097     }
00098 }

static int sc_core::initialize (  )  [static]

sc_utils_ids.cpp の 104 行で定義されています。

00105 {
00106     sc_report_handler::add_static_msg_types(&items);
00107 
00108     // PROCESS ANY ENVIRONMENTAL OVERRIDES:
00109 
00110     const char* deprecation_warn = std::getenv("SC_DEPRECATION_WARNINGS");
00111     if ( (deprecation_warn!=0) && !strcmp(deprecation_warn,"DISABLE") )
00112     {
00113         sc_report_handler::set_actions("/IEEE_Std_1666/deprecated", 
00114             SC_DO_NOTHING);
00115     }
00116     return 42;
00117 }

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

sc_vcd_trace.cpp の 2198 行で定義されています。

02199 {
02200     char out_char;
02201 
02202     switch(in_char){
02203         case 'U':
02204         case 'X': 
02205         case 'W':
02206         case 'D':
02207             out_char = 'x';
02208             break;
02209         case '0':
02210         case 'L':
02211             out_char = '0';
02212             break;
02213         case  '1':
02214         case  'H': 
02215             out_char = '1';
02216             break;
02217         case  'Z': 
02218             out_char = 'z';
02219             break;
02220         default:
02221             out_char = '?';
02222     }
02223 
02224     return out_char;
02225 }

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

sc_wif_trace.cpp の 1940 行で定義されています。

01941 {
01942     char out_char;
01943 
01944     switch(in_char){
01945         case 'U':
01946         case 'X': 
01947         case 'W':
01948         case 'D':
01949             out_char = 'X';
01950             break;
01951         case '0':
01952         case 'L':
01953             out_char = '0';
01954             break;
01955         case  '1':
01956         case  'H': 
01957             out_char = '1';
01958             break;
01959         case  'Z': 
01960             out_char = 'Z';
01961             break;
01962         default:
01963             out_char = '?';
01964     }
01965     return out_char;
01966 }

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

sc_main_main.cpp の 65 行で定義されています。

00066 {
00067     ::std::cout << "\n" << s << ::std::endl;
00068 }

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

sc_wait.h の 242 行で定義されています。

00245 {
00246     next_trigger( sc_time( v, tu, simc ), el, simc );
00247 }

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

sc_wait.h の 227 行で定義されています。

00230 {
00231     next_trigger( sc_time( v, tu, simc ), el, simc );
00232 }

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

sc_wait.h の 212 行で定義されています。

00215 {
00216     next_trigger( sc_time( v, tu, simc ), e, simc );
00217 }

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

sc_wait.h の 198 行で定義されています。

00200 {
00201     next_trigger( sc_time( v, tu, simc ), simc );
00202 }

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

sc_wait.cpp の 392 行で定義されています。

00393 {
00394     sc_curr_proc_handle cpi = simc->get_curr_proc_info();
00395     if( cpi->kind == SC_METHOD_PROC_ ) {
00396         RCAST<sc_method_handle>( cpi->process_handle )->next_trigger( t, el );
00397     } else {
00398         SC_REPORT_ERROR( SC_ID_NEXT_TRIGGER_NOT_ALLOWED_, "\n        "
00399                          "in SC_THREADs and SC_CTHREADs use wait() instead" );
00400     }
00401 }

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

sc_wait.cpp の 380 行で定義されています。

00381 {
00382     sc_curr_proc_handle cpi = simc->get_curr_proc_info();
00383     if( cpi->kind == SC_METHOD_PROC_ ) {
00384         RCAST<sc_method_handle>( cpi->process_handle )->next_trigger( t, el );
00385     } else {
00386         SC_REPORT_ERROR( SC_ID_NEXT_TRIGGER_NOT_ALLOWED_, "\n        "
00387                          "in SC_THREADs and SC_CTHREADs use wait() instead" );
00388     }
00389 }

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

sc_wait.cpp の 368 行で定義されています。

00369 {
00370     sc_curr_proc_handle cpi = simc->get_curr_proc_info();
00371     if( cpi->kind == SC_METHOD_PROC_ ) {
00372         RCAST<sc_method_handle>( cpi->process_handle )->next_trigger( t, e );
00373     } else {
00374         SC_REPORT_ERROR( SC_ID_NEXT_TRIGGER_NOT_ALLOWED_, "\n        "
00375                          "in SC_THREADs and SC_CTHREADs use wait() instead" );
00376     }
00377 }

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

sc_wait.cpp の 356 行で定義されています。

00357 {
00358     sc_curr_proc_handle cpi = simc->get_curr_proc_info();
00359     if( cpi->kind == SC_METHOD_PROC_ ) {
00360         RCAST<sc_method_handle>( cpi->process_handle )->next_trigger( t );
00361     } else {
00362         SC_REPORT_ERROR( SC_ID_NEXT_TRIGGER_NOT_ALLOWED_, "\n        "
00363                          "in SC_THREADs and SC_CTHREADs use wait() instead" );
00364     }
00365 }

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

sc_wait.cpp の 344 行で定義されています。

00345 {
00346     sc_curr_proc_handle cpi = simc->get_curr_proc_info();
00347     if( cpi->kind == SC_METHOD_PROC_ ) {
00348         RCAST<sc_method_handle>( cpi->process_handle )->next_trigger( el );
00349     } else {
00350         SC_REPORT_ERROR( SC_ID_NEXT_TRIGGER_NOT_ALLOWED_, "\n        "
00351                          "in SC_THREADs and SC_CTHREADs use wait() instead" );
00352     }
00353 }

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

sc_wait.cpp の 332 行で定義されています。

00333 {
00334     sc_curr_proc_handle cpi = simc->get_curr_proc_info();
00335     if( cpi->kind == SC_METHOD_PROC_ ) {
00336         RCAST<sc_method_handle>( cpi->process_handle )->next_trigger( el );
00337     } else {
00338         SC_REPORT_ERROR( SC_ID_NEXT_TRIGGER_NOT_ALLOWED_, "\n        "
00339                          "in SC_THREADs and SC_CTHREADs use wait() instead" );
00340     }
00341 }

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

sc_wait.cpp の 320 行で定義されています。

00321 {
00322     sc_curr_proc_handle cpi = simc->get_curr_proc_info();
00323     if( cpi->kind == SC_METHOD_PROC_ ) {
00324         RCAST<sc_method_handle>( cpi->process_handle )->next_trigger( e );
00325     } else {
00326         SC_REPORT_ERROR( SC_ID_NEXT_TRIGGER_NOT_ALLOWED_, "\n        "
00327                          "in SC_THREADs and SC_CTHREADs use wait() instead" );
00328     }
00329 }

void sc_core::next_trigger ( sc_simcontext *   ) 

sc_wait.cpp の 305 行で定義されています。

00306 {
00307     sc_curr_proc_handle cpi = simc->get_curr_proc_info();
00308     if( cpi->kind == SC_METHOD_PROC_ ) {
00309         RCAST<sc_method_handle>( cpi->process_handle )->clear_trigger();
00310     } else {
00311         SC_REPORT_ERROR( SC_ID_NEXT_TRIGGER_NOT_ALLOWED_, "\n        "
00312                          "in SC_THREADs and SC_CTHREADs use wait() instead" );
00313     }
00314 }

void sc_core::notify ( double  v,
sc_time_unit  tu,
sc_event &  e 
)

sc_event.cpp の 490 行で定義されています。

00491 {
00492     sc_warn_notify();
00493     e.notify( v, tu );
00494 }

void sc_core::notify ( const sc_time &  t,
sc_event &  e 
)

sc_event.cpp の 483 行で定義されています。

00484 {
00485     sc_warn_notify();
00486     e.notify( t );
00487 }

void sc_core::notify ( sc_event &  e  ) 

sc_event.cpp の 476 行で定義されています。

00477 {
00478     sc_warn_notify();
00479     e.notify();
00480 }

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

sc_object_manager.cpp の 111 行で定義されています。

00112     {
00113       const sc_object* obj1 = *(const sc_object**) o1;
00114       const sc_object* obj2 = *(const sc_object**) o2;
00115       return strcmp(obj1->name(), obj2->name());
00116     }

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

sc_object.cpp の 233 行で定義されています。

00234 {
00235     return (ch == SC_HIERARCHY_CHAR) || isspace(ch);
00236 }

bool sc_core::operator!= ( const sc_process_handle &  left,
const sc_process_handle &  right 
) [inline]

sc_process_handle.h の 134 行で定義されています。

00136 {
00137     return (left.m_target_p == 0) || (right.m_target_p == 0) ||
00138         (left.m_target_p != right.m_target_p);
00139 }

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

sc_time.h の 314 行で定義されています。

00315 {
00316     sc_time tmp( t );
00317     return tmp *= d;
00318 }

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

sc_time.h の 306 行で定義されています。

00307 {
00308     sc_time tmp( t );
00309     return tmp *= d;
00310 }

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

sc_time.h の 270 行で定義されています。

00271 {
00272     return sc_time( t1 ) += t2;
00273 }

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

sc_time.h の 277 行で定義されています。

00278 {
00279     return sc_time( t1 ) -= t2;
00280 }

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

sc_time.h の 330 行で定義されています。

00331 {
00332     return ( t1.to_double() / t2.to_double() );
00333 }

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

sc_time.h の 322 行で定義されています。

00323 {
00324     sc_time tmp( t );
00325     return tmp /= d;
00326 }

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

sc_time.h の 340 行で定義されています。

00341 {
00342     t.print( os );
00343     return os;
00344 }

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

sc_signal_ports.h の 1067 行で定義されています。

01068 {
01069     return os << a->read();
01070 }

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

sc_signal_ports.h の 266 行で定義されています。

00267 {
00268     return os << a->read();
00269 }

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

sc_signal.h の 742 行で定義されています。

00743 {
00744     return ( os << a.read() );
00745 }

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

sc_fifo.h の 441 行で定義されています。

00442 {
00443     a.print( os );
00444     return os;
00445 }

bool sc_core::operator== ( const sc_process_handle &  left,
const sc_process_handle &  right 
) [inline]

sc_process_handle.h の 127 行で定義されています。

00129 {
00130     return (left.m_target_p != 0) && (right.m_target_p != 0) &&
00131         (left.m_target_p == right.m_target_p);
00132 }

void sc_core::pln (  ) 

sc_simcontext.cpp の 371 行で定義されています。

00372 {
00373     static bool lnp = false;
00374     if( ! lnp ) {
00375         ::std::cerr << ::std::endl;
00376         ::std::cerr << sc_version() << ::std::endl;
00377         ::std::cerr << sc_copyright() << ::std::endl;
00378 
00379         //  regressions check point
00380         if( getenv( "SYSTEMC_REGRESSION" ) != 0 ) {
00381             ::std::cerr << "SystemC Simulation" << ::std::endl;
00382         }
00383 
00384         lnp = true;
00385     }
00386 }

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

sc_trace.cpp の 65 行で定義されています。

00066 {
00067     if(just_warning){
00068         ::std::cout << "Trace Warning:\n" << msg << "\n" << ::std::endl;
00069     }
00070     else{
00071         ::std::cout << "Trace ERROR:\n" << msg << "\n" << ::std::endl;
00072     }
00073 }

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

sc_vcd_trace.cpp の 2232 行で定義されています。

02233 {
02234     char message[4000];
02235     static bool warned = false;
02236 
02237     bool braces_removed = false;
02238     for (unsigned int i = 0; i< name.length(); i++) {
02239       if (name[i] == '[') {
02240         name[i] = '(';
02241         braces_removed = true;
02242       }
02243       else if (name[i] == ']') {
02244         name[i] = ')';
02245         braces_removed = true;
02246       }
02247     }
02248 
02249     if(braces_removed && !warned){
02250         std::sprintf(message,
02251                 "Traced objects found with name containing [], which may be\n"
02252                 "interpreted by the waveform viewer in unexpected ways.\n"
02253                 "So the [] is automatically replaced by ().");
02254         put_error_message(message, true);
02255         warned = true;
02256     }
02257 }

int sc_core::sc_argc (  ) 

sc_main_main.cpp の 72 行で定義されています。

00073 {
00074     return argc_copy;
00075 }

const char *const * sc_core::sc_argv (  ) 

sc_main_main.cpp の 77 行で定義されています。

00078 {
00079     return argv_copy;
00080 }

void sc_core::sc_close_vcd_trace_file ( sc_trace_file *  tf  ) 

sc_vcd_trace.cpp の 2271 行で定義されています。

02272 {
02273     vcd_trace_file* vcd_tf = (vcd_trace_file*)tf;
02274     delete vcd_tf; 
02275 }

void sc_core::sc_close_wif_trace_file ( sc_trace_file *  tf  ) 

sc_wif_trace.cpp の 1995 行で定義されています。

01996 {
01997     wif_trace_file* wif_tf = (wif_trace_file*)tf;
01998     delete wif_tf;
01999 }

void sc_core::sc_cmethod_cor_fn ( void *   ) 

const char * sc_core::sc_copyright (  ) 

sc_ver.cpp の 60 行で定義されています。

00061 {
00062     return copyright;
00063 }

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

sc_cor_qt.cpp の 215 行で定義されています。

00216 {
00217     return 0;
00218 }

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

sc_cor_qt.cpp の 167 行で定義されています。

00168 {
00169     curr_cor = RCAST<sc_cor_qt*>( cor );
00170     // invoke the user function
00171     (*(sc_cor_fn*) fn)( arg );
00172     // not reached
00173 }

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

sc_cor_qt.cpp の 195 行で定義されています。

00196 {
00197     RCAST<sc_cor_qt*>( old_cor )->m_sp = sp;
00198     return 0;
00199 }

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

sc_vcd_trace.cpp の 2261 行で定義されています。

02262 {
02263   sc_trace_file *tf;
02264 
02265   tf = new vcd_trace_file(name);
02266   sc_get_curr_simcontext()->add_trace_file(tf);
02267   return tf;
02268 }

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

sc_wif_trace.cpp の 1985 行で定義されています。

01986 {
01987     sc_trace_file *tf;
01988 
01989     tf = new wif_trace_file(name);
01990     sc_get_curr_simcontext()->add_trace_file(tf);
01991     return tf;
01992 }

void sc_core::sc_cthread_cor_fn ( void *  arg  ) 

sc_cthread_process.cpp の 63 行で定義されています。

00064 {
00065     sc_cthread_handle cthread_h = RCAST<sc_cthread_handle>( arg );
00066 
00067     // EXECUTE THE CTHREAD AND PROCESS ANY EXCEPTIONS THAT ARE THROWN:
00068     //
00069     // We set the wait state to unknown before invoking the semantics
00070     // in case we are reset, since the wait state will not be cleared, 
00071     // since that happens only if we are not reset.
00072 
00073     while( true ) {
00074 
00075         try {
00076             cthread_h->semantics();
00077         }
00078         catch( sc_user ) {
00079             continue;
00080         }
00081         catch( sc_halt ) {
00082             ::std::cout << "Terminating process "
00083                       << cthread_h->name() << ::std::endl;
00084         }
00085         catch( const sc_report& ex ) {
00086             ::std::cout << "\n" << ex.what() << ::std::endl;
00087             cthread_h->simcontext()->set_error();
00088         }
00089 
00090         break;
00091     }
00092 
00093     // SCHEDULE THREAD FOR DESTRUCTION:
00094     //
00095     // If control reaches this point the process semantics have returned
00096     // so the process should die.
00097 
00098     cthread_h->kill_process();
00099 
00100 }

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

sc_simcontext.h の 621 行で定義されています。

00622 {
00623     sc_cycle( sc_time( duration, true ) );
00624 }

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

sc_simcontext.h の 613 行で定義されています。

00614 {
00615     sc_cycle( sc_time( duration, time_unit ) );
00616 }

void sc_core::sc_cycle ( const sc_time &  duration  ) 

sc_simcontext.cpp の 1377 行で定義されています。

01378 {
01379     static bool warning_cycle = true;
01380 
01381     if ( warning_cycle )
01382     {
01383         warning_cycle = false;
01384         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
01385             "sc_cycle is deprecated: use sc_start(sc_time)" );
01386     }
01387     sc_get_curr_simcontext()->cycle( duration );
01388 }

void sc_core::sc_defunct_process_function ( sc_module *   ) 

sc_simcontext.cpp の 1416 行で定義されています。

01417 {
01418     // This function is pointed to by defunct sc_thread_process'es and
01419     // sc_cthread_process'es. In a correctly constructed world, this
01420     // function should never be called; hence the assert.
01421     assert( false );
01422 }

sc_dt::uint64 sc_core::sc_delta_count (  )  [inline]

sc_simcontext.h の 593 行で定義されています。

00594 {
00595     return sc_get_curr_simcontext()->m_delta_count;
00596 }

void sc_core::sc_deprecated_add_trace (  ) 

sc_signal_ports.cpp の 426 行で定義されています。

00427 {
00428     static bool warn_add_trace_deprecated=true;
00429     if ( warn_add_trace_deprecated )
00430     {
00431         warn_add_trace_deprecated=false;
00432         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
00433             "sc_signal<T>::addtrace() is deprecated");
00434     }
00435 }

void sc_core::sc_deprecated_get_data_ref (  ) 

sc_signal.cpp の 177 行で定義されています。

00178 {
00179     static bool warn_get_data_ref_deprecated=true;
00180     if ( warn_get_data_ref_deprecated )
00181     {
00182         warn_get_data_ref_deprecated=false;
00183         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
00184             "get_data_ref() is deprecated, use read() instead" );
00185     }
00186 }

void sc_core::sc_deprecated_get_new_value (  ) 

sc_signal.cpp の 188 行で定義されています。

00189 {
00190     static bool warn_new_value=true;
00191     if ( warn_new_value )
00192     {
00193         warn_new_value=false;
00194         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
00195             "sc_signal<T>::get_new_value() is deprecated");
00196     }
00197 }

static void sc_core::sc_deprecated_report_ids ( const char *  method  )  [static]

sc_report.cpp の 75 行で定義されています。

00076 {
00077     static bool warn_report_ids_deprecated=true;
00078     if ( warn_report_ids_deprecated )
00079     {
00080         std::string message;
00081         message = "integer report ids are deprecated, use string values: ";
00082         message += method;
00083         warn_report_ids_deprecated=false;
00084         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_, message.c_str());
00085     }
00086 }

static void sc_core::sc_deprecated_sensitive_neg (  )  [static]

sc_sensitive.cpp の 673 行で定義されています。

00674 {
00675     static bool warn_sensitive_neg=true;
00676     if ( warn_sensitive_neg )
00677     {
00678         warn_sensitive_neg=false;
00679         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
00680          "sc_sensitive_neg is deprecated use sc_sensitive << with neg() instead" );
00681     }
00682 }

static void sc_core::sc_deprecated_sensitive_pos (  )  [static]

sc_sensitive.cpp の 398 行で定義されています。

00399 {
00400     static bool warn_sensitive_pos=true;
00401     if ( warn_sensitive_pos )
00402     {
00403         warn_sensitive_pos=false;
00404         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
00405          "sc_sensitive_pos is deprecated use sc_sensitive << with pos() instead" );
00406     }
00407 }

void sc_core::sc_deprecated_trace (  ) 

sc_signal.cpp の 199 行で定義されています。

00200 {
00201     static bool warn_trace_deprecated=true;
00202     if ( warn_trace_deprecated )
00203     {
00204         warn_trace_deprecated=false;
00205         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
00206             "sc_signal<T>::trace() is deprecated");
00207     }
00208 }

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

sc_main_main.cpp の 84 行で定義されています。

00085 {
00086     int status = 0;
00087     argc_copy = argc;
00088     argv_copy = new char*[argc];
00089     for ( int i = 0; i < argc; i++ ) 
00090     argv_copy[i] = argv[i];
00091 
00092     try
00093     {
00094         pln();
00095 
00096         // Perform initialization here
00097         sc_in_action = true;
00098 
00099         status = sc_main( argc, argv );
00100 
00101         // Perform cleanup here
00102         sc_in_action = false;
00103     }
00104     catch( const sc_report& x )
00105     {
00106         message_function( x.what() );
00107     }
00108     catch( const char* s )
00109     {
00110         message_function( s );
00111     }
00112     catch( ... )
00113     {
00114         message_function( "UNKNOWN EXCEPTION OCCURED" );
00115     }
00116 
00117     // IF DEPRECATION WARNINGS WERE ISSUED TELL THE USER HOW TO TURN THEM OFF 
00118 
00119     if ( sc_report_handler::get_count("/IEEE_Std_1666/deprecated") > 0 )
00120     {
00121         SC_REPORT_INFO("/IEEE_Std_1666/deprecated",
00122           "You can turn off warnings about\n" \
00123                   "             IEEE 1666 deprecated features by placing this method " \
00124                   "call as the\n" \
00125                   "             first statement in your sc_main() function:\n" \
00126           "\n  sc_report_handler::set_actions(\"/IEEE_Std_1666/deprecated\", " \
00127           "SC_DO_NOTHING);\n\n" );
00128     }
00129 
00130     delete [] argv_copy;
00131     return status;
00132 }

bool sc_core::sc_end_of_simulation_invoked (  )  [inline]

sc_simcontext.h の 628 行で定義されています。

00629 {
00630         return sc_get_curr_simcontext()->m_end_of_simulation_called;
00631 }

sc_object * sc_core::sc_find_object ( const char *  name,
sc_simcontext *  simc_p 
)

sc_simcontext.cpp の 1390 行で定義されています。

01391 {
01392     return simc_p->get_object_manager()->find_object( name );
01393 }

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

sc_simcontext.cpp の 1231 行で定義されています。

01232 {
01233     sc_simcontext* simc = sc_get_curr_simcontext();
01234     sc_module* curr_module = simc->hierarchy_curr();
01235     if( curr_module != 0 ) {
01236         return curr_module->gen_unique_name( basename_, preserve_first );
01237     } else {
01238         sc_process_b* curr_proc_p = sc_get_current_process_b();
01239         if ( curr_proc_p )
01240         {
01241             return curr_proc_p->gen_unique_name( basename_, preserve_first );
01242         }
01243         else
01244         {
01245             return simc->gen_unique_name( basename_, preserve_first );
01246         }
01247     }
01248 }

sc_process_b * sc_core::sc_get_curr_process_handle (  ) 

sc_simcontext.cpp の 1268 行で定義されています。

01269 {
01270     static bool warn=true;
01271     if ( warn )
01272     {
01273         warn = false;
01274         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
01275        "sc_get_curr_process_handle deprecated use sc_get_current_process_handle"
01276        );
01277     }
01278 
01279     return sc_get_curr_simcontext()->get_curr_proc_info()->process_handle;
01280 }

sc_curr_proc_kind sc_core::sc_get_curr_process_kind (  )  [inline]

sc_simcontext.h の 547 行で定義されています。

00548 {
00549     return sc_get_curr_simcontext()->get_curr_proc_info()->kind;
00550 }

sc_simcontext * sc_core::sc_get_curr_simcontext (  )  [inline]

sc_simcontext.h の 377 行で定義されています。

00378 {
00379     if( sc_curr_simcontext == 0 ) {
00380         sc_default_global_context = new sc_simcontext;
00381         sc_curr_simcontext = sc_default_global_context;
00382     }
00383     return sc_curr_simcontext;
00384 }

sc_process_b* sc_core::sc_get_current_process_b (  )  [inline]

sc_simcontext.h の 537 行で定義されています。

00538 {
00539     return sc_get_curr_simcontext()->get_curr_proc_info()->process_handle;
00540 }

sc_process_handle sc_core::sc_get_current_process_handle (  ) 

sc_simcontext.cpp の 1259 行で定義されています。

01260 {
01261     return ( sc_is_running() ) ?
01262         sc_process_handle(sc_get_current_process_b()) : 
01263         sc_get_last_created_process_handle();
01264 }

sc_time sc_core::sc_get_default_time_unit (  ) 

sc_time.cpp の 381 行で定義されています。

00382 {
00383     bool warn_get_default_time_unit = true;
00384     if ( warn_get_default_time_unit )
00385     {
00386         warn_get_default_time_unit=false;
00387         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
00388             "deprecated function: sc_get_default_time_unit");
00389     }
00390     return sc_time( sc_get_curr_simcontext()->m_time_params->default_time_unit,
00391                     false );
00392 }

sc_process_handle sc_core::sc_get_last_created_process_handle (  )  [inline]

sc_process_handle.h の 280 行で定義されています。

00281 {
00282     return sc_process_b::last_created_process_handle();
00283 }

sc_object* sc_core::sc_get_parent ( const sc_object *  obj_p  )  [inline]

sc_object.h の 148 行で定義されています。

00149 { 
00150         return obj_p->get_parent_object(); 
00151 }

int sc_core::sc_get_simulator_status (  )  [inline]

sc_simcontext.h の 553 行で定義されています。

00554 {
00555     return sc_get_curr_simcontext()->sim_status();
00556 }

sc_stop_mode sc_core::sc_get_stop_mode (  ) 

sc_simcontext.cpp の 1451 行で定義されています。

01452 {
01453     return stop_mode;
01454 }

sc_time sc_core::sc_get_time_resolution (  ) 

sc_time.cpp の 317 行で定義されています。

00318 {
00319     return sc_time( sc_dt::UINT64_ONE, false );
00320 }

const std::vector< sc_object * > & sc_core::sc_get_top_level_objects ( const sc_simcontext *  simc_p = sc_get_curr_simcontext()  )  [inline]

sc_simcontext.h の 583 行で定義されています。

00585 {
00586     return simc_p->m_child_objects;
00587 }

void sc_core::sc_initialize (  ) 

sc_simcontext.cpp の 1361 行で定義されています。

01362 {
01363     static bool warning_initialize = true;
01364 
01365     if ( warning_initialize )
01366     {
01367         warning_initialize = false;
01368         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
01369             "sc_initialize() is deprecated: use sc_start(SC_ZERO_TIME)" );
01370     }
01371     sc_get_curr_simcontext()->initialize();
01372 }

void sc_core::sc_interrupt_here ( const char *  id,
sc_severity  severity 
)

sc_stop_here.cpp の 62 行で定義されています。

00063 {
00064     // you can set a breakpoint at some of the lines below, either to
00065     // interrupt with any severity, or to interrupt with a specific severity
00066 
00067     switch( severity ) {
00068       case SC_INFO: 
00069         static const char* info_id;
00070         info_id = id;
00071         break;
00072       case SC_WARNING: 
00073         static const char* warning_id;
00074         warning_id = id;
00075         break;
00076       case SC_ERROR: 
00077         static const char* error_id;
00078         error_id = id;
00079         break;
00080       default:
00081       case SC_FATAL: 
00082         static const char* fatal_id;
00083         fatal_id = id;
00084         break;
00085     }
00086 }

bool sc_core::sc_is_running ( const sc_simcontext *  simc_p = sc_get_curr_simcontext()  )  [inline]

sc_simcontext.h の 599 行で定義されています。

00600 {
00601     return simc_p->m_ready_to_simulate;
00602 }

void sc_core::sc_method_cor_fn ( void *   ) 

sc_module * sc_core::sc_module_dynalloc ( sc_module *  module_  ) 

sc_module.cpp の 178 行で定義されています。

00179 {
00180     static sc_module_dynalloc_list dynalloc_list;
00181     dynalloc_list.add( module_ );
00182     return module_;
00183 }

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

sc_simcontext.cpp の 390 行で定義されています。

00391 {
00392     const sc_event_timed* et1 = static_cast<const sc_event_timed*>( p1 );
00393     const sc_event_timed* et2 = static_cast<const sc_event_timed*>( p2 );
00394 
00395     const sc_time& t1 = et1->notify_time();
00396     const sc_time& t2 = et2->notify_time();
00397     
00398     if( t1 < t2 ) {
00399         return 1;
00400     } else if( t1 > t2 ) {
00401         return -1;
00402     } else {
00403         return 0;
00404     }
00405 }

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

sc_object.cpp の 117 行で定義されています。

00118 {
00119     std::sprintf(name, "{%d}", sc_object_num);
00120     sc_object_num++;
00121     return name;
00122 }

bool sc_core::sc_pending_activity_at_current_time (  ) 

sc_simcontext.cpp の 1285 行で定義されています。

01286 {
01287     sc_simcontext* c_p = sc_get_curr_simcontext();
01288     return (c_p->m_delta_events.size() != 0) ||
01289             !c_p->m_runnable->is_empty() ||
01290             c_p->m_prim_channel_registry->pending_updates();
01291 }

const char * sc_core::sc_release (  ) 

sc_ver.cpp の 67 行で定義されています。

00068 {
00069     return SC_RELEASE_STRING "-OSCI";
00070 }

bool sc_core::sc_report_close_default_log (  ) 

sc_report_handler.cpp の 173 行で定義されています。

00174 {
00175     delete log_stream;
00176     sc_report_handler::set_log_file_name(NULL);
00177 
00178     if ( !log_stream )
00179         return false;
00180 
00181     log_stream = 0;
00182     return true;
00183 }

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

sc_report_handler.cpp の 70 行で定義されています。

00071 {
00072     static const char * severity_names[] = {
00073         "Info", "Warning", "Error", "Fatal"
00074     };
00075     std::string str;
00076 
00077     str += severity_names[rep.get_severity()];
00078     str += ": ";
00079 
00080     if ( rep.get_id() >= 0 ) // backward compatibility with 2.0+
00081     {
00082         char idstr[64];
00083         std::sprintf(idstr, "(%c%d) ",
00084                 "IWEF"[rep.get_severity()], rep.get_id());
00085         str += idstr;
00086     }
00087     str += rep.get_msg_type();
00088 
00089     if( *rep.get_msg() )
00090     {
00091         str += ": ";
00092         str += rep.get_msg();
00093     }
00094     if( rep.get_severity() > SC_INFO )
00095     {
00096         char line_number_str[16];
00097         str += "\nIn file: ";
00098         str += rep.get_file_name();
00099         str += ":";
00100         std::sprintf(line_number_str, "%d", rep.get_line_number());
00101         str += line_number_str;
00102         sc_simcontext* simc = sc_get_curr_simcontext();
00103 
00104         if( simc && sc_is_running() )
00105         {
00106             const char* proc_name = rep.get_process_name();
00107 
00108             if( proc_name )
00109             {
00110                 str += "\nIn process: ";
00111                 str += proc_name;
00112                 str += " @ ";
00113                 str += rep.get_time().to_string();
00114             }
00115         }
00116     }
00117 
00118     return str;
00119 }

void sc_core::sc_set_default_time_unit ( double  ,
sc_time_unit   
)

sc_time.cpp の 324 行で定義されています。

00325 {
00326     static bool warn_default_time_unit=true;
00327     if ( warn_default_time_unit )
00328     {
00329         warn_default_time_unit=false;
00330         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
00331             "deprecated function: sc_set_default_time_unit");
00332     }
00333     
00334     // first perform the necessary checks
00335 
00336     // must be positive
00337     if( v < 0.0 ) {
00338         SC_REPORT_ERROR( SC_ID_SET_DEFAULT_TIME_UNIT_, "value not positive" );
00339     }
00340 
00341     // must be a power of ten
00342     double dummy;
00343     if( modf( log10( v ), &dummy ) != 0.0 ) {
00344         SC_REPORT_ERROR( SC_ID_SET_DEFAULT_TIME_UNIT_,
00345                          "value not a power of ten" );
00346     }
00347 
00348     sc_simcontext* simc = sc_get_curr_simcontext();
00349 
00350     // can only be specified during elaboration
00351     if( sc_is_running() ) {
00352         SC_REPORT_ERROR( SC_ID_SET_DEFAULT_TIME_UNIT_, "simulation running" );
00353     }
00354 
00355     sc_time_params* time_params = simc->m_time_params;
00356 
00357     // can only be specified before any sc_time is constructed
00358     if( time_params->time_resolution_fixed ) {
00359         SC_REPORT_ERROR( SC_ID_SET_DEFAULT_TIME_UNIT_,
00360                          "sc_time object(s) constructed" );
00361     }
00362 
00363     // can be specified only once
00364     if( time_params->default_time_unit_specified ) {
00365         SC_REPORT_ERROR( SC_ID_SET_DEFAULT_TIME_UNIT_, "already specified" );
00366     }
00367 
00368     // must be larger than or equal to the time resolution
00369     volatile double time_unit = ( v * time_values[tu] ) /
00370                                 time_params->time_resolution;
00371     if( time_unit < 1.0 ) {
00372         SC_REPORT_ERROR( SC_ID_SET_DEFAULT_TIME_UNIT_,
00373                          "value smaller than time resolution" );
00374     }
00375 
00376     time_params->default_time_unit = SCAST<sc_dt::int64>( time_unit );
00377     time_params->default_time_unit_specified = true;
00378 }

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

sc_wait.cpp の 426 行で定義されています。

00427 {
00428     sc_curr_proc_handle cpi = simc->get_curr_proc_info();
00429     sc_process_b* handle = cpi->process_handle;
00430     handle->file = file;
00431     handle->lineno = lineno;
00432 }

void sc_core::sc_set_random_seed ( unsigned  int  ) 

sc_simcontext.cpp の 1296 行で定義されています。

01297 {
01298     SC_REPORT_WARNING( SC_ID_NOT_IMPLEMENTED_,
01299                        "void sc_set_random_seed( unsigned int )" );
01300 }

void sc_core::sc_set_stack_size ( sc_thread_handle  ,
std::size_t   
)

sc_thread_process.cpp の 364 行で定義されています。

00365 {
00366     thread_h->set_stack_size( size );
00367 }

void sc_core::sc_set_stack_size ( sc_method_handle  ,
std::size_t   
)

void sc_core::sc_set_stop_mode ( sc_stop_mode  mode  ) 

sc_simcontext.cpp の 1430 行で定義されています。

01431 {
01432     if ( sc_is_running() )
01433     {
01434         SC_REPORT_WARNING(SC_ID_STOP_MODE_AFTER_START_,"");
01435     }
01436     else
01437     {
01438         switch( mode )
01439         {
01440           case SC_STOP_IMMEDIATE:
01441           case SC_STOP_FINISH_DELTA:
01442               stop_mode = mode;
01443               break;
01444           default:
01445               break;
01446         }
01447     }
01448 }

void sc_core::sc_set_time_resolution ( double  ,
sc_time_unit   
)

sc_time.cpp の 253 行で定義されています。

00254 {
00255     // first perform the necessary checks
00256 
00257     // must be positive
00258     if( v < 0.0 ) {
00259         SC_REPORT_ERROR( SC_ID_SET_TIME_RESOLUTION_, "value not positive" );
00260     }
00261 
00262     // must be a power of ten
00263     double dummy;
00264 #if defined( __HP_aCC ) || defined(__ppc__)
00265     // aCC seems to have a bug in modf()
00266     if( modf( log10( v < 1.0 ? 1.0/v : v ), &dummy ) != 0.0 ) {
00267 #else
00268     if( modf( log10( v ), &dummy ) != 0.0 ) {
00269 #endif
00270         SC_REPORT_ERROR( SC_ID_SET_TIME_RESOLUTION_,
00271                          "value not a power of ten" );
00272     }
00273 
00274     sc_simcontext* simc = sc_get_curr_simcontext();
00275 
00276     // can only be specified during elaboration
00277     if( sc_is_running() ) {
00278         SC_REPORT_ERROR( SC_ID_SET_TIME_RESOLUTION_, "simulation running" );
00279     }
00280 
00281     sc_time_params* time_params = simc->m_time_params;
00282 
00283     // can be specified only once
00284     if( time_params->time_resolution_specified ) {
00285         SC_REPORT_ERROR( SC_ID_SET_TIME_RESOLUTION_, "already specified" );
00286     }
00287 
00288     // can only be specified before any sc_time is constructed
00289     if( time_params->time_resolution_fixed ) {
00290         SC_REPORT_ERROR( SC_ID_SET_TIME_RESOLUTION_,
00291                          "sc_time object(s) constructed" );
00292     }
00293 
00294     // must be larger than or equal to 1 fs
00295     volatile double resolution = v * time_values[tu];
00296     if( resolution < 1.0 ) {
00297         SC_REPORT_ERROR( SC_ID_SET_TIME_RESOLUTION_,
00298                          "value smaller than 1 fs" );
00299     }
00300 
00301     // recalculate the default time unit
00302     volatile double time_unit = sc_dt::uint64_to_double(
00303         time_params->default_time_unit ) *
00304         ( time_params->time_resolution / resolution );
00305     if( time_unit < 1.0 ) {
00306         SC_REPORT_WARNING( SC_ID_DEFAULT_TIME_UNIT_CHANGED_, 0 );
00307         time_params->default_time_unit = 1;
00308     } else {
00309         time_params->default_time_unit = SCAST<sc_dt::int64>( time_unit );
00310     }
00311 
00312     time_params->time_resolution = resolution;
00313     time_params->time_resolution_specified = true;
00314 }

void sc_core::sc_signal_invalid_writer ( sc_object *  target,
sc_object *  first_writer,
sc_object *  second_writer 
)

sc_signal.cpp の 116 行で定義されています。

00118 {
00119     char msg[BUFSIZ];
00120     const char* target_name = target->name();
00121     const char* target_kind = target->kind();
00122     const char* writer1_name = first_writer->name();
00123     const char* writer1_kind = first_writer->kind();
00124     const char* writer2_name;
00125     const char* writer2_kind;
00126     if ( second_writer )
00127     {
00128         writer2_name = second_writer->name();
00129         writer2_kind = second_writer->kind();
00130 
00131         std::sprintf( msg, "\n signal `%s' (%s)"
00132              "\n first driver `%s' (%s)"
00133              "\n second driver `%s' (%s)",
00134              target_name, target_kind, 
00135              writer1_name, writer1_kind, 
00136              writer2_name, writer2_kind );
00137         SC_REPORT_ERROR( SC_ID_MORE_THAN_ONE_SIGNAL_DRIVER_, msg );
00138     }
00139 }

double sc_core::sc_simulation_time (  ) 

sc_simcontext.cpp の 1403 行で定義されています。

01404 {
01405     static bool warn_simulation_time=true;
01406     if ( warn_simulation_time )
01407     {
01408         warn_simulation_time=false;
01409         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
01410             "sc_simulation_time() is deprecated use sc_time_stamp()" );
01411     }
01412     return sc_get_curr_simcontext()->time_stamp().to_default_time_units();
01413 }

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]

sc_spawn.h の 223 行で定義されています。

00228 {
00229         sc_simcontext*      context_p;
00230         sc_spawn_object_v<T>* spawn_p;
00231         
00232         context_p = sc_get_curr_simcontext();
00233         
00234         spawn_p = new sc_spawn_object_v<T>(r_p, object);
00235         if ( !opt_p || !opt_p->is_method() )
00236         {
00237             sc_process_handle thread_handle = context_p->create_thread_process( 
00238                     name_p, true,
00239                     SC_MAKE_FUNC_PTR(sc_spawn_object_v<T>,semantics), 
00240                     spawn_p, opt_p 
00241             );
00242             return thread_handle;
00243         }
00244         else
00245         {
00246             sc_process_handle method_handle = context_p->create_method_process( 
00247                     name_p, true,
00248                     SC_MAKE_FUNC_PTR(sc_spawn_object_v<T>,semantics), 
00249                     spawn_p, opt_p 
00250             );
00251             return method_handle;
00252     }
00253 }

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]

sc_spawn.h の 123 行で定義されています。

00127 {
00128         sc_simcontext*      context_p;
00129         sc_spawn_object<T>* spawn_p;
00130         
00131         context_p = sc_get_curr_simcontext();
00132         spawn_p = new sc_spawn_object<T>(object);
00133         if ( !opt_p || !opt_p->is_method() )
00134         {
00135             sc_process_handle thread_handle = context_p->create_thread_process( 
00136                     name_p, true,
00137                     SC_MAKE_FUNC_PTR(sc_spawn_object<T>,semantics), 
00138                     spawn_p, opt_p 
00139             );
00140             return thread_handle;
00141     }
00142         else
00143         {
00144             sc_process_handle method_handle = context_p->create_method_process( 
00145                     name_p, true,
00146                     SC_MAKE_FUNC_PTR(sc_spawn_object<T>,semantics), 
00147                     spawn_p, opt_p 
00148             );
00149             return method_handle;
00150     }
00151 }

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

sc_simcontext.h の 606 行で定義されています。

00607 {
00608     sc_start( sc_time( duration, time_unit ) );
00609 }

void sc_core::sc_start ( double  duration  ) 

sc_simcontext.cpp の 1330 行で定義されています。

01331 {
01332     static bool warn_sc_start=true;
01333     if ( warn_sc_start )
01334     {
01335         warn_sc_start = false;
01336         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
01337             "sc_start(double) deprecated, use sc_start(sc_time) or sc_start()");
01338     }
01339 
01340     if( duration == -1 )  // simulate forever
01341     {
01342         sc_start( 
01343             sc_time(~sc_dt::UINT64_ZERO, false) - sc_time_stamp() );
01344     }
01345     else
01346     {
01347         sc_start( sc_time( duration, true ) );
01348     }
01349 }

void sc_core::sc_start (  ) 

sc_simcontext.cpp の 1323 行で定義されています。

01324 {
01325         sc_start( sc_time(~sc_dt::UINT64_ZERO, false) - sc_time_stamp() );
01326 }

void sc_core::sc_start ( const sc_time &  duration  ) 

sc_simcontext.cpp の 1304 行で定義されています。

01305 {
01306     sc_simcontext* context;
01307     int status;
01308 
01309     context = sc_get_curr_simcontext();
01310     status = context->sim_status();
01311     if( status != SC_SIM_OK ) 
01312     {
01313         if ( status == SC_SIM_USER_STOP )
01314         {
01315             SC_REPORT_ERROR(SC_ID_SIMULATION_START_AFTER_STOP_, "");        
01316         }
01317         return;
01318     }
01319     context->simulate( duration );
01320 }

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

sc_clock.h の 253 行で定義されています。

00254 {
00255     clock.start( duration );
00256 }

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

sc_clock.h の 246 行で定義されています。

00247 {
00248     clock.start( v, tu );
00249 }

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

sc_clock.h の 239 行で定義されています。

00240 {
00241     clock.start( duration );
00242 }

bool sc_core::sc_start_of_simulation_invoked (  )  [inline]

sc_simcontext.h の 636 行で定義されています。

00637 {
00638         return sc_get_curr_simcontext()->m_start_of_simulation_called;
00639 }

void sc_core::sc_stop (  ) 

sc_simcontext.cpp の 1352 行で定義されています。

01353 {
01354     sc_get_curr_simcontext()->stop();
01355 }

void sc_core::sc_stop_here ( const char *  id,
sc_severity  severity 
)

sc_stop_here.cpp の 97 行で定義されています。

00098 {
00099     // you can set a breakpoint at some of the lines below, either to
00100     // stop with any severity, or to stop with a specific severity
00101 
00102     switch( severity ) {
00103       case SC_INFO: 
00104         static const char* info_id;
00105         info_id = id;
00106         break;
00107       case SC_WARNING: 
00108         static const char* warning_id;
00109         warning_id = id;
00110         break;
00111       case SC_ERROR: 
00112         static const char* error_id;
00113         error_id = id;
00114         break;
00115       default:
00116       case SC_FATAL: 
00117         static const char* fatal_id;
00118         fatal_id = id;
00119         break;
00120     }
00121 }

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

sc_hash.cpp の 640 行で定義されています。

00641 {
00642     return strcmp( (const char*) a, (const char*) b );
00643 }

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

sc_hash.cpp の 646 行で定義されています。

00647 {
00648     return strdup((const char*) k);
00649 }

void sc_core::sc_strhash_kfree ( void *  k  ) 

sc_hash.cpp の 652 行で定義されています。

00653 {
00654     if (k) free((char*) k);
00655 }

void sc_core::sc_thread_cor_fn ( void *  arg  ) 

sc_thread_process.cpp の 73 行で定義されています。

00074 {
00075     sc_thread_handle thread_h = RCAST<sc_thread_handle>( arg );
00076 
00077     // PROCESS THE THREAD AND PROCESS ANY EXCEPTIONS THAT ARE THROWN:
00078 
00079     while( true ) {
00080 
00081         try {
00082             thread_h->semantics();
00083         }
00084         catch( sc_user ) {
00085             continue;
00086         }
00087         catch( sc_halt ) {
00088             ::std::cout << "Terminating process "
00089                       << thread_h->name() << ::std::endl;
00090         }
00091         catch( const sc_report& ex ) {
00092             std::cout << "\n" << ex.what() << std::endl;
00093             thread_h->simcontext()->set_error();
00094         }
00095         break;
00096     }
00097 
00098     // SCHEDULE THREAD PACKAGE FOR DESTRUCTION:
00099     //
00100     // If control reaches this point the process semantics have returned
00101     // so the process should die.
00102 
00103     thread_h->kill_process();
00104 }

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

sc_event_queue.cpp の 55 行で定義されています。

00056 {
00057     const sc_time* t1 = static_cast<const sc_time*>( p1 );
00058     const sc_time* t2 = static_cast<const sc_time*>( p2 );
00059 
00060     if( *t1 < *t2 ) {
00061         return 1;
00062     } else if( *t1 > *t2 ) {
00063         return -1;
00064     } else {
00065         return 0;
00066     }  
00067 }

const sc_time & sc_core::sc_time_stamp (  ) 

sc_simcontext.cpp の 1397 行で定義されています。

01398 {
01399     return sc_get_curr_simcontext()->time_stamp();
01400 }

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

sc_trace.h の 312 行で定義されています。

00315 {
00316     sc_trace( tf, object.read(), name );
00317 }

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

sc_trace.h の 302 行で定義されています。

00305 {
00306     sc_trace( tf, object.read(), name );
00307 }

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

sc_trace.cpp の 280 行で定義されています。

00284 {
00285     static bool warn_sc_trace_literals=true;
00286     if ( warn_sc_trace_literals )
00287     {
00288         warn_sc_trace_literals=false;
00289         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
00290             "tracing of enumerated literals is deprecated" );
00291     }
00292 
00293     if( tf ) tf->trace( object, name, enum_literals );
00294 }

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

sc_trace.cpp の 215 行で定義されています。

00218 {
00219     ::std::cout << "Object " << name << " will not be traced" << ::std::endl;
00220 }

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

sc_trace.cpp の 203 行で定義されています。

00207 {
00208     if( tf ) {
00209         tf->trace( object.read(), name, width );
00210     }
00211 }

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

sc_trace.cpp の 192 行で定義されています。

00196 {
00197     if( tf ) {
00198         tf->trace( object.read(), name, width );
00199     }
00200 }

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

sc_trace.cpp の 181 行で定義されています。

00185 {
00186     if( tf ) {
00187         tf->trace( object.read(), name, width );
00188     }
00189 }

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

sc_trace.cpp の 170 行で定義されています。

00174 {
00175     if( tf ) {
00176         tf->trace( object.read(), name, width );
00177     }
00178 }

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

sc_signal_ports.h の 1767 行で定義されています。

01769 {
01770     const sc_signal_in_if<T>* iface = 0;
01771     if (sc_get_curr_simcontext()->elaboration_done() )
01772     {
01773         iface =DCAST<const sc_signal_in_if<T>*>( port.get_interface() );
01774     }
01775 
01776     if ( iface )
01777         sc_trace( tf, iface->read(), name );
01778     else
01779         port.add_trace_internal( tf, name );
01780 }

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

sc_signal_ports.h の 1750 行で定義されています。

01751 {
01752     const sc_signal_in_if<T>* iface = 0;
01753     if (sc_get_curr_simcontext()->elaboration_done() )
01754     {
01755         iface = DCAST<const sc_signal_in_if<T>*>( port.get_interface() );
01756     }
01757 
01758     if ( iface )
01759         sc_trace( tf, iface->read(), name );
01760     else
01761         port.add_trace_internal( tf, name );
01762 }

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

sc_trace.h の 371 行で定義されています。

00372 {
00373     if( tf ) tf->delta_cycles( on );
00374 }

const char * sc_core::sc_version (  ) 

sc_ver.cpp の 74 行で定義されています。

00075 {
00076     return systemc_version;
00077 }

static void sc_core::sc_warn_arrow_arrow_bind (  )  [static]

sc_module.cpp の 503 行で定義されています。

00504 {
00505     static bool warn_arrow_arrow_bind=true;
00506     if ( warn_arrow_arrow_bind )
00507     {
00508         warn_arrow_arrow_bind = false;
00509         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
00510             "positional binding using << or , is deprecated, use () instead.");
00511     }
00512 }

static void sc_core::sc_warn_notify (  )  [static]

sc_event.cpp の 464 行で定義されています。

00465 {
00466     static bool warn_notify=true;
00467     if ( warn_notify )
00468     {
00469   SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
00470       "the notify() function is deprecated use sc_event::notify()" );
00471   warn_notify = false;
00472     }
00473 }

static void sc_core::sc_warn_notify_delayed (  )  [static]

sc_event.cpp の 146 行で定義されています。

00147 {
00148     static bool warn_notify_delayed=true;
00149     if ( warn_notify_delayed )
00150     {
00151         warn_notify_delayed = false;
00152         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
00153       "notify_delayed(...) is deprecated, use notify(sc_time) instead" );
00154     }
00155 }

void sc_core::sc_warn_port_constructor (  ) 

sc_port.cpp の 744 行で定義されています。

00745 {
00746     static bool warn_port_constructor=true;
00747     if ( warn_port_constructor )
00748     {
00749         warn_port_constructor = false;
00750         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_, 
00751             "interface and/or port binding in port constructors is deprecated" 
00752         );
00753     }
00754 }

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

sc_trace.h の 381 行で定義されています。

00382 {
00383     if( tf ) tf->write_comment( comment );
00384 }

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

sc_cor_qt.cpp の 131 行で定義されています。

00132 {
00133     int round_up_mask = alignment - 1;
00134     *stack_size = (*stack_size + round_up_mask) & ~round_up_mask;
00135     return ( (void*)(((qt_word_t) sp + round_up_mask) & ~round_up_mask) );
00136 }

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

sc_object_manager.cpp の 62 行で定義されています。

00063 {
00064   return strcmp(static_cast<const char*>(a),static_cast<const char*>(b));
00065 }

bool sc_core::timed_out ( sc_simcontext *   ) 

sc_wait.cpp の 407 行で定義されています。

00408 {
00409     static bool warn_timed_out=true; 
00410     if ( warn_timed_out )
00411     {
00412         warn_timed_out = false;
00413         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
00414             "timed_out() function is deprecated" );
00415     }
00416 
00417     sc_curr_proc_handle cpi = simc->get_curr_proc_info();
00418     return cpi->process_handle->timed_out();
00419 }

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

sc_trace.cpp の 148 行で定義されています。

00149 {
00150     static char buffer[4096];
00151     va_list ap;
00152     va_start(ap, format);
00153     (void) vsprintf(buffer, format, ap);
00154     va_end(ap);
00155     if (tf) tf->write_comment(buffer);
00156 }

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

sc_wait.h の 159 行で定義されています。

00162 {
00163     wait( sc_time( v, tu, simc ), el, simc );
00164 }

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

sc_wait.h の 144 行で定義されています。

00147 {
00148     wait( sc_time( v, tu, simc ), el, simc );
00149 }

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

sc_wait.h の 129 行で定義されています。

00132 {
00133     wait( sc_time( v, tu, simc ), e, simc );
00134 }

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

sc_wait.h の 115 行で定義されています。

00117 {
00118     wait( sc_time( v, tu, simc ), simc );
00119 }

void sc_core::wait ( int  ,
sc_simcontext *   
)

sc_wait_cthread.cpp の 102 行で定義されています。

00103 {
00104     sc_curr_proc_handle cpi = simc->get_curr_proc_info();
00105     if( n <= 0 ) {
00106         char msg[BUFSIZ];
00107         std::sprintf( msg, "n = %d", n );
00108         SC_REPORT_ERROR( SC_ID_WAIT_N_INVALID_, msg );
00109     }
00110     switch( cpi->kind ) {
00111       case SC_THREAD_PROC_: 
00112       case SC_CTHREAD_PROC_: 
00113         RCAST<sc_cthread_handle>( cpi->process_handle )->wait_cycles( n );
00114         break;
00115       default:
00116         break;
00117     }
00118 }

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

sc_wait.cpp の 278 行で定義されています。

00279 {
00280     sc_curr_proc_handle cpi = simc->get_curr_proc_info();
00281     switch( cpi->kind ) {
00282     case SC_THREAD_PROC_: {
00283         RCAST<sc_thread_handle>( cpi->process_handle )->wait( t, el );
00284         break;
00285     }
00286     case SC_CTHREAD_PROC_: {
00287         warn_cthread_wait();
00288         sc_cthread_handle cthread_h =
00289             RCAST<sc_cthread_handle>( cpi->process_handle );
00290         cthread_h->wait( t, el );
00291         cthread_h->wait_cycles();
00292         break;
00293     }
00294     default:
00295         SC_REPORT_ERROR( SC_ID_WAIT_NOT_ALLOWED_, "\n        "
00296                          "in SC_METHODs use next_trigger() instead" );
00297         break;
00298     }
00299 }

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

sc_wait.cpp の 254 行で定義されています。

00255 {
00256     sc_curr_proc_handle cpi = simc->get_curr_proc_info();
00257     switch( cpi->kind ) {
00258     case SC_THREAD_PROC_: {
00259         RCAST<sc_thread_handle>( cpi->process_handle )->wait( t, el );
00260         break;
00261     }
00262     case SC_CTHREAD_PROC_: {
00263         warn_cthread_wait();
00264         sc_cthread_handle cthread_h =
00265             RCAST<sc_cthread_handle>( cpi->process_handle );
00266         cthread_h->wait( t, el );
00267         cthread_h->wait_cycles();
00268         break;
00269     }
00270     default:
00271         SC_REPORT_ERROR( SC_ID_WAIT_NOT_ALLOWED_, "\n        "
00272                          "in SC_METHODs use next_trigger() instead" );
00273         break;
00274     }
00275 }

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

sc_wait.cpp の 230 行で定義されています。

00231 {
00232     sc_curr_proc_handle cpi = simc->get_curr_proc_info();
00233     switch( cpi->kind ) {
00234     case SC_THREAD_PROC_: {
00235         RCAST<sc_thread_handle>( cpi->process_handle )->wait( t, e );
00236         break;
00237     }
00238     case SC_CTHREAD_PROC_: {
00239         warn_cthread_wait();
00240         sc_cthread_handle cthread_h =
00241             RCAST<sc_cthread_handle>( cpi->process_handle );
00242         cthread_h->wait( t, e );
00243         cthread_h->wait_cycles();
00244         break;
00245     }
00246     default:
00247         SC_REPORT_ERROR( SC_ID_WAIT_NOT_ALLOWED_, "\n        "
00248                          "in SC_METHODs use next_trigger() instead" );
00249         break;
00250     }
00251 }

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

sc_wait.cpp の 206 行で定義されています。

00207 {
00208     sc_curr_proc_handle cpi = simc->get_curr_proc_info();
00209     switch( cpi->kind ) {
00210     case SC_THREAD_PROC_: {
00211         RCAST<sc_thread_handle>( cpi->process_handle )->wait( t );
00212         break;
00213     }
00214     case SC_CTHREAD_PROC_: {
00215         warn_cthread_wait();
00216         sc_cthread_handle cthread_h =
00217             RCAST<sc_cthread_handle>( cpi->process_handle );
00218         cthread_h->wait( t );
00219         cthread_h->wait_cycles();
00220         break;
00221     }
00222     default:
00223         SC_REPORT_ERROR( SC_ID_WAIT_NOT_ALLOWED_, "\n        "
00224                          "in SC_METHODs use next_trigger() instead" );
00225         break;
00226     }
00227 }

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

sc_wait.cpp の 182 行で定義されています。

00183 {
00184     sc_curr_proc_handle cpi = simc->get_curr_proc_info();
00185     switch( cpi->kind ) {
00186     case SC_THREAD_PROC_: {
00187         RCAST<sc_thread_handle>( cpi->process_handle )->wait( el );
00188         break;
00189     }
00190     case SC_CTHREAD_PROC_: {
00191         warn_cthread_wait();
00192         sc_cthread_handle cthread_h =
00193             RCAST<sc_cthread_handle>( cpi->process_handle );
00194         cthread_h->wait( el );
00195         cthread_h->wait_cycles();
00196         break;
00197     }
00198     default:
00199         SC_REPORT_ERROR( SC_ID_WAIT_NOT_ALLOWED_, "\n        "
00200                          "in SC_METHODs use next_trigger() instead" );
00201         break;
00202     }
00203 }

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

sc_wait.cpp の 156 行で定義されています。

00157 {
00158     sc_curr_proc_handle cpi = simc->get_curr_proc_info();
00159     switch( cpi->kind ) {
00160     case SC_THREAD_PROC_: {
00161         RCAST<sc_thread_handle>( cpi->process_handle )->wait( el );
00162         break;
00163     }
00164     case SC_CTHREAD_PROC_: {
00165         warn_cthread_wait();
00166         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
00167             "wait(event_list) is deprecated for SC_CTHREAD, use SC_THREAD");
00168         sc_cthread_handle cthread_h =
00169             RCAST<sc_cthread_handle>( cpi->process_handle );
00170         cthread_h->wait( el );
00171         cthread_h->wait_cycles();
00172         break;
00173     }
00174     default:
00175         SC_REPORT_ERROR( SC_ID_WAIT_NOT_ALLOWED_, "\n        "
00176                          "in SC_METHODs use next_trigger() instead" );
00177         break;
00178     }
00179 }

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

sc_wait.cpp の 132 行で定義されています。

00133 {
00134     sc_curr_proc_handle cpi = simc->get_curr_proc_info();
00135     switch( cpi->kind ) {
00136     case SC_THREAD_PROC_: {
00137         RCAST<sc_thread_handle>( cpi->process_handle )->wait( e );
00138         break;
00139     }
00140     case SC_CTHREAD_PROC_: {
00141         warn_cthread_wait();
00142         sc_cthread_handle cthread_h =
00143             RCAST<sc_cthread_handle>( cpi->process_handle );
00144         cthread_h->wait( e );
00145         cthread_h->wait_cycles();
00146         break;
00147     }
00148     default:
00149         SC_REPORT_ERROR( SC_ID_WAIT_NOT_ALLOWED_, "\n        "
00150                          "in SC_METHODs use next_trigger() instead" );
00151         break;
00152     }
00153 }

void sc_core::wait ( sc_simcontext *   ) 

sc_wait.cpp の 113 行で定義されています。

00114 {
00115     sc_curr_proc_handle cpi = simc->get_curr_proc_info();
00116     switch( cpi->kind ) {
00117     case SC_THREAD_PROC_: 
00118     case SC_CTHREAD_PROC_: {
00119         RCAST<sc_cthread_handle>( cpi->process_handle )->wait_cycles();
00120         break;
00121     }
00122     default:
00123         SC_REPORT_ERROR( SC_ID_WAIT_NOT_ALLOWED_, "\n        "
00124                          "in SC_METHODs use next_trigger() instead" );
00125         break;
00126     }
00127 }

void sc_core::warn_cthread_wait (  ) 

sc_wait.cpp の 99 行で定義されています。

00100 {
00101     static bool warn_wait = true;
00102     if ( warn_wait )
00103     {
00104         warn_wait = false;
00105         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
00106             "all waits except wait() and wait(N)\n" \
00107             "             are deprecated for SC_CTHREAD, " \
00108             "use an SC_THREAD instead");
00109     }
00110 }

static void sc_core::warn_no_parens (  )  [static]

sc_sensitive.cpp の 100 行で定義されています。

00101 {
00102     static bool warn_no_parentheses=true;
00103     if ( warn_no_parentheses )
00104     {
00105         warn_no_parentheses=false;
00106         SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
00107             "use of () to specify sensitivity is deprecated, use << instead" );
00108     }
00109 }

変数

static SC_API_VERSION_STRING sc_core::api_version_check [static]

sc_ver.h の 66 行で定義されています。

int sc_core::argc_copy [static]

sc_main_main.cpp の 59 行で定義されています。

char** sc_core::argv_copy [static]

sc_main_main.cpp の 60 行で定義されています。

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

const int sc_core::cell_size_to_allocator[] [static]

初期値:

 {
    0,
    1,
    2,
    3,
    4,
    5,
    5,
    6,
    6,
    7,
    7,
    8,
    8,
    9,
    9,
    9,
    9
}

sc_mempool.cpp の 196 行で定義されています。

const int sc_core::cell_sizes[] [static]

初期値:

 {
   0,
   8,
  16,
  24,
  32,
  48,
  64,
  80,
  96,
 128
}

sc_mempool.cpp の 183 行で定義されています。

const char sc_core::copyright[] [static]

初期値:

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

sc_ver.cpp の 51 行で定義されています。

sc_cor_qt* sc_core::curr_cor = 0 [static]

sc_cor_qt.cpp の 65 行で定義されています。

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),

}

sc_report_handler.cpp の 687 行で定義されています。

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

sc_report.cpp の 88 行で定義されています。

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

sc_utils_ids.cpp の 119 行で定義されています。

sc_event_timed_u* sc_core::free_list = 0 [static]

sc_event.cpp の 352 行で定義されています。

sc_report_handler::msg_def_items sc_core::items [static]

初期値:

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

sc_utils_ids.cpp の 99 行で定義されています。

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

sc_report_handler.cpp の 122 行で定義されています。

sc_cor_qt sc_core::main_cor [static]

sc_cor_qt.cpp の 61 行で定義されています。

const double sc_core::PHASH_DEFAULT_GROW_FACTOR = 2.0

sc_hash.cpp の 56 行で定義されています。

const int sc_core::PHASH_DEFAULT_INIT_TABLE_SIZE = 11

sc_hash.h の 62 行で定義されています。

const int sc_core::PHASH_DEFAULT_MAX_DENSITY = 5

sc_hash.h の 61 行で定義されています。

const bool sc_core::PHASH_DEFAULT_REORDER_FLAG = true

sc_hash.h の 64 行で定義されています。

sc_reset_finder* sc_core::reset_finder_q = 0 [static]

sc_reset.cpp の 53 行で定義されています。

static bool sc_core::running_regression = false [static]

sc_vcd_trace.cpp の 70 行で定義されています。

const sc_bind_proxy sc_core::SC_BIND_PROXY_NIL

sc_module.cpp の 209 行で定義されています。

sc_simcontext * sc_core::sc_curr_simcontext = 0

sc_simcontext.cpp の 1204 行で定義されています。

sc_simcontext * sc_core::sc_default_global_context = 0

sc_simcontext.cpp の 1205 行で定義されています。

const int sc_core::SC_DEFAULT_STACK_SIZE = 0x10000

sc_constants.h の 57 行で定義されています。

bool sc_core::sc_enable_name_checking = true

sc_object.cpp の 85 行で定義されています。

const char sc_core::SC_HIERARCHY_CHAR = '.'

sc_object.cpp の 80 行で定義されています。

const char sc_core::SC_ID_ASSERTION_FAILED_ = "assertion failed"

sc_report_handler.cpp の 675 行で定義されています。

const char sc_core::SC_ID_INTERNAL_ERROR_ = "internal error"

sc_report_handler.cpp の 674 行で定義されています。

const char sc_core::SC_ID_NOT_IMPLEMENTED_ = "not implemented"

sc_report_handler.cpp の 673 行で定義されています。

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

sc_report_handler.cpp の 676 行で定義されています。

const char sc_core::SC_ID_REGISTER_ID_FAILED_ = "register_id failed"

sc_bit_ids.h の 70 行で定義されています。

const char sc_core::SC_ID_UNKNOWN_ERROR_ = "unknown error"

sc_report_handler.cpp の 671 行で定義されています。

const char sc_core::SC_ID_WITHOUT_MESSAGE_ = ""

sc_report_handler.cpp の 672 行で定義されています。

bool sc_core::sc_in_action = false

sc_main_main.cpp の 70 行で定義されています。

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 }  
}

sc_signal_resolved.cpp の 58 行で定義されています。

const int sc_core::SC_MAX_WATCH_LEVEL = 16

sc_constants.h の 58 行で定義されています。

sc_event sc_core::sc_non_event

int sc_core::sc_object_num = 0 [static]

sc_object.cpp の 114 行で定義されています。

const int sc_core::SC_SIM_ERROR = 1

sc_simcontext.h の 158 行で定義されています。

const int sc_core::SC_SIM_OK = 0

sc_simcontext.h の 157 行で定義されています。

const int sc_core::SC_SIM_USER_STOP = 2

sc_simcontext.h の 159 行で定義されています。

sc_byte_heap sc_core::sc_temp_heap

sc_concatref.h の 67 行で定義されています。

const sc_time sc_core::SC_ZERO_TIME

sc_time.cpp の 397 行で定義されています。

sc_stop_mode sc_core::stop_mode = SC_STOP_FINISH_DELTA

sc_simcontext.cpp の 165 行で定義されています。

const char sc_core::systemc_version[] [static]

初期値:

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

sc_ver.cpp の 56 行で定義されています。

sc_msg_def sc_core::texts[] [static]

初期値:

 {
#define SC_DEFINE_MESSAGE(id,n,unused) 





















}

sc_utils_ids.cpp の 75 行で定義されています。

sc_mempool_int* sc_core::the_mempool = 0 [static]

sc_mempool.cpp の 264 行で定義されています。

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

初期値:

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

sc_time.cpp の 77 行で定義されています。

double sc_core::time_values[] [static]

初期値:

 {
    1,       
    1e3,     
    1e6,     
    1e9,     
    1e12,    
    1e15     
}

sc_time.cpp の 67 行で定義されています。

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

sc_report.cpp の 177 行で定義されています。

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

sc_vcd_trace.cpp の 79 行で定義されています。

bool sc_core::warnings_are_errors = false [static]

sc_report.cpp の 176 行で定義されています。

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

sc_wif_trace.cpp の 85 行で定義されています。

SystemCに対してFri Jun 6 20:11:39 2008に生成されました。  doxygen 1.5.6