クラス sc_core::sc_report_handler

#include <sc_report_handler.h>

すべてのメンバ一覧

Static Public メソッド
static void	report (sc_severity, const char *msg_type, const char *msg, const char *file, int line)
static sc_actions	set_actions (sc_severity, sc_actions=SC_UNSPECIFIED)
static sc_actions	set_actions (const char *msg_type, sc_actions=SC_UNSPECIFIED)
static sc_actions	set_actions (const char *msg_type, sc_severity, sc_actions=SC_UNSPECIFIED)
static int	stop_after (sc_severity, int limit=-1)
static int	stop_after (const char *msg_type, int limit=-1)
static int	stop_after (const char *msg_type, sc_severity, int limit=-1)
static sc_actions	suppress (sc_actions)
static sc_actions	suppress ()
static sc_actions	force (sc_actions)
static sc_actions	force ()
static int	get_count (sc_severity severity_)
static int	get_count (const char *msg_type_)
static int	get_count (const char *msg_type_, sc_severity severity_)
static void	initialize ()
static void	release ()
static void	set_handler (sc_report_handler_proc)
static void	default_handler (const sc_report &, const sc_actions &)
static sc_actions	get_new_action_id ()
static sc_report *	get_cached_report ()
static void	clear_cached_report ()
static bool	set_log_file_name (const char *filename)
static const char *	get_log_file_name ()
static void	add_static_msg_types (msg_def_items *)
static sc_msg_def *	add_msg_type (const char *msg_type)
static void	report (sc_severity, int id, const char *add_msg, const char *file, int line)
Static Protected メソッド
static void	cache_report (const sc_report &)
static sc_actions	execute (sc_msg_def *, sc_severity)
static sc_msg_def *	mdlookup (const char *msg_type)
Static Protected 変数
static sc_actions	suppress_mask = 0
static sc_actions	force_mask = 0
static sc_actions	sev_actions [SC_MAX_SEVERITY]
static unsigned	sev_limit [SC_MAX_SEVERITY]
static unsigned	sev_call_count [SC_MAX_SEVERITY] = { 0, 0, 0, 0 }
static sc_report *	last_global_report = NULL
static sc_actions	available_actions
static char *	log_file_name = 0
static msg_def_items *	messages
static msg_def_items	msg_terminator
static sc_report_handler_proc	handler
Static Private メソッド
static sc_msg_def *	mdlookup (int id)
フレンド
class	sc_report
構成
struct	msg_def_items

---

説明

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

---

関数

void sc_core::sc_report_handler::report	(	sc_severity	severity_,
		const char *	msg_type,
		const char *	msg,
		const char *	file,
		int	line
	)			[static]

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

{
    sc_msg_def * md = mdlookup(msg_type_);

    if ( !md )
        md = add_msg_type(msg_type_);

    sc_actions actions = execute(md, severity_);
    sc_report rep(severity_, md, msg_, file_, line_);

    if ( actions & SC_CACHE_REPORT )
        cache_report(rep);

    handler(rep, actions);
}

sc_actions sc_core::sc_report_handler::set_actions	(	sc_severity	severity_,
		sc_actions	actions_ = SC_UNSPECIFIED
	)			[static]

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

{
    sc_actions old = sev_actions[severity_];
    sev_actions[severity_] = actions_;
    return old;
}

sc_actions sc_core::sc_report_handler::set_actions	(	const char *	msg_type,
		sc_actions	actions_ = SC_UNSPECIFIED
	)			[static]

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

{
    sc_msg_def * md = mdlookup(msg_type_);

    if ( !md )
        md = add_msg_type(msg_type_);

    sc_actions old = md->actions;
    md->actions = actions_;

    return old;
}

sc_actions sc_core::sc_report_handler::set_actions	(	const char *	msg_type,
		sc_severity	severity_,
		sc_actions	actions_ = SC_UNSPECIFIED
	)			[static]

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

{
    sc_msg_def * md = mdlookup(msg_type_);

    if ( !md )
        md = add_msg_type(msg_type_);

    sc_actions old = md->sev_actions[severity_];
    md->sev_actions[severity_] = actions_;

    return old;
}

int sc_core::sc_report_handler::stop_after	(	sc_severity	severity_,
		int	limit = -1
	)			[static]

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

{
    int old = sev_limit[severity_];

    sev_limit[severity_] = limit < 0 ? UINT_MAX: limit;

    return old;
}

int sc_core::sc_report_handler::stop_after	(	const char *	msg_type,
		int	limit = -1
	)			[static]

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

{
    sc_msg_def * md = mdlookup(msg_type_);

    if ( !md )
        md = add_msg_type(msg_type_);

    int old = md->limit_mask & 1 ? md->limit: UINT_MAX;

    if ( limit < 0 )
        md->limit_mask &= ~1;
    else
    {
        md->limit_mask |= 1;
        md->limit = limit;
    }
    return old;
}

int sc_core::sc_report_handler::stop_after	(	const char *	msg_type,
		sc_severity	severity_,
		int	limit = -1
	)			[static]

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

{
    sc_msg_def * md = mdlookup(msg_type_);

    if ( !md )
        md = add_msg_type(msg_type_);

    int mask = 1 << (severity_ + 1);
    int old = md->limit_mask & mask ?  md->sev_limit[severity_]: UINT_MAX;

    if ( limit < 0 )
        md->limit_mask &= ~mask;
    else
    {
        md->limit_mask |= mask;
        md->sev_limit[severity_] = limit;
    }
    return old;
}

sc_actions sc_core::sc_report_handler::suppress

(

sc_actions

mask

)

[static]

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

{
    sc_actions old = suppress_mask;
    suppress_mask = mask;
    return old;
}

sc_actions sc_core::sc_report_handler::suppress

(

)

[static]

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

{
    return suppress(0);
}

sc_actions sc_core::sc_report_handler::force

(

sc_actions

mask

)

[static]

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

{
    sc_actions old = force_mask;
    force_mask = mask;
    return old;
}

sc_actions sc_core::sc_report_handler::force

(

)

[static]

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

{
    return force(0);
}

int sc_core::sc_report_handler::get_count

(

sc_severity

severity_

)

[static]

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

{ 
   return sev_call_count[severity_]; 
} 

int sc_core::sc_report_handler::get_count

(

const char *

msg_type_

)

[static]

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

{ 
    sc_msg_def * md = mdlookup(msg_type_); 

    if ( !md ) 
        md = add_msg_type(msg_type_); 

    return md->call_count; 
} 

int sc_core::sc_report_handler::get_count	(	const char *	msg_type_,
		sc_severity	severity_
	)			[static]

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

{ 
    sc_msg_def * md = mdlookup(msg_type_); 

    if ( !md ) 
        md = add_msg_type(msg_type_); 

    return md->sev_call_count[severity_]; 
} 

void sc_core::sc_report_handler::initialize

(

)

[static]

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

{
#if 0 // actually, i do not know whether we have to reset these.
    suppress();
    force();
    set_actions(SC_INFO,    SC_DEFAULT_INFO_ACTIONS);
    set_actions(SC_WARNING, SC_DEFAULT_WARNING_ACTIONS);
    set_actions(SC_ERROR,   SC_DEFAULT_ERROR_ACTIONS);
    set_actions(SC_FATAL,   SC_DEFAULT_FATAL_ACTIONS);
#endif

    sev_call_count[SC_INFO]    = 0;
    sev_call_count[SC_WARNING] = 0;
    sev_call_count[SC_ERROR]   = 0;
    sev_call_count[SC_FATAL]   = 0;

    msg_def_items * items = messages;

    while ( items != &msg_terminator )
    {
        for ( int i = 0; i < items->count; ++i )
        {
            items->md[i].call_count = 0;
            items->md[i].sev_call_count[SC_INFO]    = 0;
            items->md[i].sev_call_count[SC_WARNING] = 0;
            items->md[i].sev_call_count[SC_ERROR]   = 0;
            items->md[i].sev_call_count[SC_FATAL]   = 0;
        }
        items = items->next;
    }

    // PROCESS ANY ENVIRONMENTAL OVERRIDES:

    const char* deprecation_warn = std::getenv("SC_DEPRECATION_WARNINGS");
    if ( (deprecation_warn!=0) && !strcmp(deprecation_warn,"DISABLE") )
    {
        set_actions("/IEEE_Std_1666/deprecated", SC_DO_NOTHING);
    }
}

void sc_core::sc_report_handler::release

(

)

[static]

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

{
    if ( last_global_report )
        delete last_global_report;
    last_global_report = 0;
    sc_report_close_default_log();

    msg_def_items * items = messages, * newitems = &msg_terminator;
    messages = &msg_terminator;

    while ( items != &msg_terminator )
    {
        for ( int i = 0; i < items->count; ++i )
            if ( items->md[i].msg_type == items->md[i].msg_type_data )
                free(items->md[i].msg_type_data);

        msg_def_items * prev = items;
        items = items->next;

        if ( prev->allocated )
        {
            delete [] prev->md;
            delete prev;
        }
        else
        {
            prev->next = newitems;
            newitems = prev;
        }
    }
    messages = newitems;
}

void sc_core::sc_report_handler::set_handler

(

sc_report_handler_proc

handler_

)

[static]

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

{
    handler = handler_ ? handler_: &sc_report_handler::default_handler;
}

void sc_core::sc_report_handler::default_handler	(	const sc_report &	rep,
		const sc_actions &	actions
	)			[static]

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

{
    if ( actions & SC_DISPLAY )
        ::std::cout << ::std::endl << sc_report_compose_message(rep) << 
                ::std::endl;

    if ( (actions & SC_LOG) && get_log_file_name() )
    {
        if ( !log_stream )
            log_stream = new ::std::ofstream(get_log_file_name()); // ios::trunc

        *log_stream << rep.get_time() << ": "
            << sc_report_compose_message(rep) << ::std::endl;
    }
    if ( actions & SC_STOP )
    {
        sc_stop_here(rep.get_msg_type(), rep.get_severity());
        sc_stop();
    }
    if ( actions & SC_INTERRUPT )
        sc_interrupt_here(rep.get_msg_type(), rep.get_severity());

    if ( actions & SC_ABORT )
        abort();

    if ( actions & SC_THROW )
        throw rep; 
}

sc_actions sc_core::sc_report_handler::get_new_action_id

(

)

[static]

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

{
    for ( sc_actions p = 1; p; p <<= 1 )
    {
        if ( !(p & available_actions) ) // free
        {
            available_actions |= p;
            return p;
        }
    }
    return SC_UNSPECIFIED;
}

sc_report * sc_core::sc_report_handler::get_cached_report

(

)

[static]

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

{
    sc_process_b * proc = sc_get_current_process_b();

    if ( proc )
        return proc->get_last_report();

    return last_global_report;
}

void sc_core::sc_report_handler::clear_cached_report

(

)

[static]

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

{
    sc_process_b * proc = sc_get_current_process_b();

    if ( proc )
        proc->set_last_report(0);
    else
    {
        if ( last_global_report )
            delete last_global_report;
        last_global_report = 0;
    }
}

bool sc_core::sc_report_handler::set_log_file_name

(

const char *

filename

)

[static]

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

{
    if ( !name_ )
    {
        free(log_file_name);
        log_file_name = 0;
        return false;
    }
    if ( log_file_name )
        return false;

    log_file_name = strdup(name_);
    return true;
}

const char * sc_core::sc_report_handler::get_log_file_name

(

)

[static]

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

{
    return log_file_name;
}

void sc_core::sc_report_handler::add_static_msg_types

(

msg_def_items *

items

)

[static]

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

{
    items->allocated = false;
    items->next = messages;
    messages = items;
}

sc_msg_def * sc_core::sc_report_handler::add_msg_type

(

const char *

msg_type

)

[static]

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

{
    sc_msg_def * md = mdlookup(msg_type_);

    if ( md )
        return md;

    msg_def_items * items = new msg_def_items;

    if ( !items )
        return 0;

    items->count = 1;
    items->md = new sc_msg_def[items->count];

    if ( !items->md )
    {
        delete items;
        return 0;
    }
    memset(items->md, 0, sizeof(sc_msg_def) * items->count);
    items->md->msg_type_data = strdup(msg_type_);
    items->md->id = -1; // backward compatibility with 2.0+

    if ( !items->md->msg_type_data )
    {
        delete items->md;
        delete items;
        return 0;
    }
    items->md->msg_type = items->md->msg_type_data;
    add_static_msg_types(items);
    items->allocated = true;

    return items->md;
}

void sc_core::sc_report_handler::cache_report

(

const sc_report &

rep

)

[static, protected]

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

{
    sc_process_b * proc = sc_get_current_process_b();
    if ( proc )
        proc->set_last_report(new sc_report(rep));
    else
    {
        if ( last_global_report )
            delete last_global_report;
        last_global_report = new sc_report(rep);
    }
}

sc_actions sc_core::sc_report_handler::execute	(	sc_msg_def *	md,
		sc_severity	severity_
	)			[static, protected]

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

{
    sc_actions actions = md->sev_actions[severity_]; // high prio

    if ( SC_UNSPECIFIED == actions ) // middle prio
        actions = md->actions;

    if ( SC_UNSPECIFIED == actions ) // the lowest prio
        actions = sev_actions[severity_];

    actions &= ~suppress_mask; // higher than the high prio
    actions |= force_mask; // higher than above, and the limit is the highest

    unsigned * limit = 0;
    unsigned * call_count = 0;

    // just increment counters and check for overflow
    if ( md->sev_call_count[severity_] < UINT_MAX )
        md->sev_call_count[severity_]++;
    if ( md->call_count < UINT_MAX )
        md->call_count++;
    if ( sev_call_count[severity_] < UINT_MAX )
        sev_call_count[severity_]++;

    if ( md->limit_mask & (1 << (severity_ + 1)) )
    {
        limit = md->sev_limit + severity_;
        call_count = md->sev_call_count + severity_;
    }
    if ( !limit && (md->limit_mask & 1) )
    {
        limit = &md->limit;
        call_count = &md->call_count;
    }
    if ( !limit )
    {
        limit = sev_limit + severity_;
        call_count = sev_call_count + severity_;
    }
    if ( *limit == 0 )
    {
        // stop limit disabled
    }
    else if ( *limit != UINT_MAX )
    {
        if ( *call_count >= *limit )
            actions |= SC_STOP; // force sc_stop()
    }
    return actions;
}

sc_msg_def * sc_core::sc_report_handler::mdlookup

(

const char *

msg_type

)

[static, protected]

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

{
    for ( msg_def_items * item = messages; item; item = item->next )
    {
        for ( int i = 0; i < item->count; ++i )
            if ( !strcmp(msg_type_, item->md[i].msg_type) )
                return item->md + i;
    }
    return 0;
}

sc_msg_def * sc_core::sc_report_handler::mdlookup

(

int

id

)

[static, private]

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

{
    for ( msg_def_items * item = messages; item; item = item->next )
    {
        for ( int i = 0; i < item->count; ++i )
            if ( id == item->md[i].id )
                return item->md + i;
    }
    return 0;
}

void sc_core::sc_report_handler::report	(	sc_severity	severity_,
		int	id,
		const char *	add_msg,
		const char *	file,
		int	line
	)			[static]

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

{
    sc_msg_def * md = sc_report_handler::mdlookup(id_);

    if ( !md )
    {
        md = sc_report_handler::add_msg_type(unknown_id);
        md->id = id_;
    }

    if ( severity_ == SC_WARNING && warnings_are_errors )
        severity_ = SC_ERROR;

    sc_actions actions = execute(md, severity_);
    sc_report rep(severity_, md, msg_, file_, line_);

    if ( actions & SC_CACHE_REPORT )
        cache_report(rep);

    if ( severity_ == SC_ERROR )
        actions |= SC_THROW;
    else if ( severity_ == SC_FATAL )
        actions |= SC_ABORT;

    handler(rep, actions);
}

---

フレンドと関連する関数

friend class sc_report [friend]

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

---

変数

sc_actions sc_core::sc_report_handler::suppress_mask = 0 [static, protected]

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

sc_actions sc_core::sc_report_handler::force_mask = 0 [static, protected]

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

sc_actions sc_core::sc_report_handler::sev_actions [static, protected]

初期値:

{
     SC_DEFAULT_INFO_ACTIONS,
     SC_DEFAULT_WARNING_ACTIONS,
     SC_DEFAULT_ERROR_ACTIONS,
     SC_DEFAULT_FATAL_ACTIONS
}

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

sc_actions sc_core::sc_report_handler::sev_limit [static, protected]

初期値:

{
    UINT_MAX, UINT_MAX, UINT_MAX, UINT_MAX
}

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

sc_actions sc_core::sc_report_handler::sev_call_count = { 0, 0, 0, 0 } [static, protected]

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

sc_report * sc_core::sc_report_handler::last_global_report = NULL [static, protected]

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

sc_actions sc_core::sc_report_handler::available_actions [static, protected]

初期値:

    SC_DO_NOTHING |
    SC_THROW |
    SC_LOG |
    SC_DISPLAY |
    SC_CACHE_REPORT |
    SC_INTERRUPT |
    SC_STOP |
    SC_ABORT

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

char * sc_core::sc_report_handler::log_file_name = 0 [static, protected]

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

sc_report_handler::msg_def_items * sc_core::sc_report_handler::messages [static, protected]

初期値:

    &sc_report_handler::msg_terminator

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

sc_report_handler::msg_def_items sc_core::sc_report_handler::msg_terminator [static, protected]

初期値:

{
    default_msgs,
    sizeof(default_msgs)/sizeof(*default_msgs),
    false,
    NULL
}

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

sc_report_handler_proc sc_core::sc_report_handler::handler [static, protected]

初期値:

    &sc_report_handler::default_handler

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

---

このクラスの説明は次のファイルから生成されました:

• C:/systemc-2.2.0/systemc-2.2.0/src/sysc/utils/sc_report_handler.h
• C:/systemc-2.2.0/systemc-2.2.0/src/sysc/utils/sc_report.cpp
• C:/systemc-2.2.0/systemc-2.2.0/src/sysc/utils/sc_report_handler.cpp