// $Id: uvm_report_catcher.svh,v 1.1.2.10 2010/04/09 15:03:25 janick Exp $
//------------------------------------------------------------------------------
//   Copyright 2007-2010 Mentor Graphics Corporation
//   Copyright 2007-2009 Cadence Design Systems, Inc.
//   Copyright 2010 Synopsys, Inc.
//   All Rights Reserved Worldwide
//
//   Licensed under the Apache License, Version 2.0 (the
//   "License"); you may not use this file except in
//   compliance with the License.  You may obtain a copy of
//   the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in
//   writing, software distributed under the License is
//   distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
//   CONDITIONS OF ANY KIND, either express or implied.  See
//   the License for the specific language governing
//   permissions and limitations under the License.
//------------------------------------------------------------------------------

`ifndef UVM_REPORT_CATCHER_SVH
`define UVM_REPORT_CATCHER_SVH

typedef class uvm_report_object;
typedef class uvm_report_handler;
typedef class uvm_report_server;
typedef class uvm_report_catcher;

typedef uvm_callbacks    #(uvm_report_object, uvm_report_catcher) uvm_report_cb;
typedef uvm_callback_iter#(uvm_report_object, uvm_report_catcher) uvm_report_cb_iter;

class sev_id_struct;
  bit sev_specified ;
  bit id_specified ;
  uvm_severity sev ;
  string  id ;
  bit is_on ;
endclass

//------------------------------------------------------------------------------
//
// CLASS: uvm_report_catcher
//
// The uvm_report_catcher is used to catch messages issued by the uvm report
// server. Catchers are
// uvm_callbacks#(<uvm_report_object>,uvm_report_catcher) objects,
// so all factilities in the <uvm_callback> and <uvm_callbacks#(T,CB)>
// classes are available for registering catchers and controlling catcher
// state.
// The uvm_callbacks#(<uvm_report_object>,uvm_report_catcher) class is
// aliased to ~uvm_report_cb~ to make it easier to use.
// Multiple report catchers can be 
// registered with a report object. The catchers can be registered as default 
// catchers which catch all reports on all <uvm_report_object> reporters,
// or catchers can be attached to specific report objects (i.e. components). 
//
// User extensions of <uvm_report_catcher> must implement the <catch> method in 
// which the action to be taken on catching the report is specified. The catch 
// method can return ~CAUGHT~, in which case further processing of the report is 
// immediately stopped, or return ~THROW~ in which case the (possibly modified) report 
// is passed on to other registered catchers. The catchers are processed in the order 
// in which they are registered.
//
// On catching a report, the <catch> method can modify the severity, id, action,
// verbosity or the report string itself before the report is finally issued by
// the report server. The report can be immediately issued from within the catcher 
// class by calling the <issue> method.
//
// The catcher maintains a count of all reports with FATAL,ERROR or WARNING severity
// and a count of all reports with FATAL, ERROR or WARNING severity whose severity
// was lowered. These statistics are reported in the summary of the <uvm_report_server>.
//
// This example shows the basic concept of creating a report catching
// callback and attaching it to all messages that get emitted:
//
//| class my_error_demoter extends uvm_report_catcher;
//|   function new(string name="my_error_demoter");
//|     super.new(name);
//|   endfunction
//|   //This example demotes "MY_ID" errors to an info message
//|   function action_e catch();
//|     if(get_severity() == UVM_ERROR && get_id() == "MY_ID")
//|       set_severity(UVM_INFO);
//|     return THROW;
//|   endfunction
//| endclass
//|
//| my_error_demoter demoter = new;
//| initial begin
//|  // Catchers are callbacks on report objects (components are report 
//|  // objects, so catchers can be attached to components).
//|
//|  // To affect all reporters, use null for the object
//|  uvm_report_cb::add(null, demoter); 
//|
//|  // To affect some specific object use the specific reporter
//|  uvm_report_cb::add(mytest.myenv.myagent.mydriver, demoter);
//|
//|  // To affect some set of components using the component name
//|  uvm_report_cb::add_by_name("*.*driver", demoter);
//| end
//
//
//------------------------------------------------------------------------------

virtual class uvm_report_catcher extends uvm_callback;

  `uvm_register_cb(uvm_report_object,uvm_report_catcher)

  typedef enum { UNKNOWN_ACTION, THROW, CAUGHT} action_e;

  local static uvm_severity m_modified_severity;
  local static int m_modified_verbosity;
  local static string m_modified_id;
  local static string m_modified_message;
  local static string m_file_name;
  local static int m_line_number;
  local static uvm_report_object m_client;
  local static uvm_action m_modified_action;
  local static bit m_set_action_called;
  local static uvm_report_server m_server;
  local static string m_name;
  
  local static int m_demoted_fatal;
  local static int m_demoted_error;
  local static int m_demoted_warning;
  local static int m_caught_fatal;
  local static int m_caught_error;
  local static int m_caught_warning;

  const static int DO_NOT_CATCH      = 1; 
  const static int DO_NOT_MODIFY     = 2; 
  local static int m_debug_flags;

  local static  uvm_severity  m_orig_severity;
  local static  uvm_action    m_orig_action;
  local static  string        m_orig_id;
  local static  int           m_orig_verbosity;
  local static  string        m_orig_message;

  local static  bit do_report;
  
  // Function: new
  //
  // Create a new report catcher. The name argument is optional, but
  // should generally be provided to aid in debugging.

  function new(string name = "uvm_report_catcher");
    super.new(name);
    do_report = 1;
  endfunction    

  // Group: Current Message State

  // Function: get_client
  //
  // Returns the <uvm_report_object> that has generated the message that
  // is currently being processes.

  function uvm_report_object get_client();
    return this.m_client; 
  endfunction

  // Function: get_severity
  //
  // Returns the <uvm_severity> of the message that is currently being
  // processed. If the severity was modified by a previously executed
  // catcher object (which re-threw the message), then the returned 
  // severity is the modified value.

  function uvm_severity get_severity();
    return this.m_modified_severity;
  endfunction
  
  // Function: get_context
  //
  // Returns the context (source) of the message that is currently being
  // processed. This is typically the full hierarchical name of the component
  // that issued the message. However, when the message comes via a report
  // handler that is not associated with a component, the context is
  // user-defined.

  function string get_context();
    return this.m_name;
  endfunction
  
  // Function: get_verbosity
  //
  // Returns the verbosity of the message that is currently being
  // processed. If the verbosity was modified by a previously executed
  // catcher (which re-threw the message), then the returned 
  // verbosity is the modified value.
  
  function int get_verbosity();
    return this.m_modified_verbosity;
  endfunction
  
  // Function: get_id
  //
  // Returns the string id of the message that is currently being
  // processed. If the id was modified by a previously executed
  // catcher (which re-threw the message), then the returned 
  // id is the modified value.
  
  function string get_id();
    return this.m_modified_id;
  endfunction
  
  // Function: get_message
  //
  // Returns the string message of the message that is currently being
  // processed. If the message was modified by a previously executed
  // catcher (which re-threw the message), then the returned 
  // message is the modified value.
  
  function string get_message();
     return this.m_modified_message;
  endfunction
  
  // Function: get_action
  //
  // Returns the <uvm_action> of the message that is currently being
  // processed. If the action was modified by a previously executed
  // catcher (which re-threw the message), then the returned 
  // action is the modified value.
  
  function uvm_action get_action();
    return this.m_modified_action;
  endfunction
  
  // Function: get_fname
  //
  // Returns the file name of the message.
  
  function string get_fname();
    return this.m_file_name;
  endfunction             

  // Function: get_line
  //
  // Returns the line number of the message.

  function int get_line();
    return this.m_line_number;
  endfunction
  
  // Group: Change Message State

  // Function: set_severity
  //
  // Change the severity of the message to ~severity~. Any other
  // report catchers will see the modified value.
  
  protected function void set_severity(uvm_severity severity);
    this.m_modified_severity = severity;
  endfunction
  
  // Function: set_verbosity
  //
  // Change the verbosity of the message to ~verbosity~. Any other
  // report catchers will see the modified value.

  protected function void set_verbosity(int verbosity);
    this.m_modified_verbosity = verbosity;
  endfunction      

  // Function: set_id
  //
  // Change the id of the message to ~id~. Any other
  // report catchers will see the modified value.

  protected function void set_id(string id);
    this.m_modified_id = id;
  endfunction
  
  // Function: set_message
  //
  // Change the text of the message to ~message~. Any other
  // report catchers will see the modified value.

  protected function void set_message(string message);
    this.m_modified_message = message;
  endfunction
  
  // Function: set_action
  //
  // Change the action of the message to ~action~. Any other
  // report catchers will see the modified value.
  
  protected function void set_action(uvm_action action);
    this.m_modified_action = action;
    this.m_set_action_called = 1;
  endfunction
  
  // Group: Debug
     
  // Function: get_report_catcher
  //
  // Returns the first report catcher that has ~name~. 
  
  static function uvm_report_catcher get_report_catcher(string name);
    static uvm_report_cb_iter iter = new(null);
    get_report_catcher = iter.first();
    while(get_report_catcher != null) begin
      if(get_report_catcher.get_name() == name)
        return get_report_catcher;
      get_report_catcher = iter.next();
    end
    return null;
  endfunction


  // Function: print_catcher
  //
  // Prints information about all of the report catchers that are 
  // registered. For finer grained detail, the <uvm_callbacks #(T,CB)::display>
  // method can be used by calling uvm_report_cb::display(<uvm_report_object>).

  static function void print_catcher(UVM_FILE file=0);
    string msg;
    string enabled;
    uvm_report_catcher catcher;
    static uvm_report_cb_iter iter = new(null);

    f_display(file, "-------------UVM REPORT CATCHERS----------------------------");

    catcher = iter.first();
    while(catcher != null) begin
       if(catcher.callback_mode())
        enabled = "ON";        
       else
        enabled = "OFF";        
      
      $swrite(msg, "%20s : %s", catcher.get_name(),
              enabled);
      f_display(file, msg);
      catcher = iter.next();
    end
    f_display(file, "--------------------------------------------------------------");
  endfunction
  
  // Funciton: debug_report_catcher
  //
  // Turn on report catching debug information. ~what~ is a bitwise and of
  // * DO_NOT_CATCH  -- forces catch to be ignored so that all catchers see the
  //   the reports.
  // * DO_NOT_MODIFY -- forces the message to remain unchanged

  static function void debug_report_catcher(int what= 0);
    m_debug_flags = what;
  endfunction        
  
  // Group: Callback Interface
 
  // Function: catch
  //
  // This is the method that is called for each registered report catcher.
  // There are no arguments to this function. The <Current Message State>
  // interface methods can be used to access information about the 
  // current message being processed.

  pure virtual function action_e catch();
     

  // Group: Reporting

   // Function: uvm_report_fatal
   //
   // Issues a fatal message using the current message's report object.
   // This message will bypass any message catching callbacks.
   
   protected function void uvm_report_fatal(string id, string message, int verbosity, string fname = "", int line = 0 );
     string m;
     uvm_action a;
     UVM_FILE f;
     uvm_report_handler rh;
     
     rh   = this.m_client.get_report_handler();
     a    = rh.get_action(UVM_FATAL,id);
     f    = rh.get_file_handle(UVM_FATAL,id);
     
     m    = this.m_server.compose_message(UVM_FATAL,this.m_name, id, message, fname, line);
     this.m_server.process_report(UVM_FATAL, this.m_name, id, message, a, f, fname, line,
                                  m, verbosity, this.m_client);
   endfunction  


   // Function: uvm_report_error
   //
   // Issues a error message using the current message's report object.
   // This message will bypass any message catching callbacks.
   
   
   protected function void uvm_report_error(string id, string message, int verbosity, string fname = "", int line = 0 );
     string m;
     uvm_action a;
     UVM_FILE f;
     uvm_report_handler rh;
     
     rh   = this.m_client.get_report_handler();
     a    = rh.get_action(UVM_ERROR,id);
     f    = rh.get_file_handle(UVM_ERROR,id);
     
     m    = this.m_server.compose_message(UVM_ERROR,this.m_name, id, message, fname, line);
     this.m_server.process_report(UVM_ERROR, this.m_name, id, message, a, f, fname, line,
                                  m, verbosity, this.m_client);
   endfunction  


   // Function: uvm_report_warning
   //
   // Issues a warning message using the current message's report object.
   // This message will bypass any message catching callbacks.
   
   protected function void uvm_report_warning(string id, string message, int verbosity, string fname = "", int line = 0 );
     string m;
     uvm_action a;
     UVM_FILE f;
     uvm_report_handler rh;
     
     rh   = this.m_client.get_report_handler();
     a    = rh.get_action(UVM_WARNING,id);
     f    = rh.get_file_handle(UVM_WARNING,id);
     
     m    = this.m_server.compose_message(UVM_WARNING,this.m_name, id, message, fname, line);
     this.m_server.process_report(UVM_WARNING, this.m_name, id, message, a, f, fname, line,
                                  m, verbosity, this.m_client);
   endfunction  


   // Function: uvm_report_info
   //
   // Issues a info message using the current message's report object.
   // This message will bypass any message catching callbacks.
   
   protected function void uvm_report_info(string id, string message, int verbosity, string fname = "", int line = 0 );
     string m;
     uvm_action a;
     UVM_FILE f;
     uvm_report_handler rh;
     rh    = this.m_client.get_report_handler();
     a    = rh.get_action(UVM_INFO,id);
     f     = rh.get_file_handle(UVM_INFO,id);
     
     m     = this.m_server.compose_message(UVM_INFO,this.m_name, id, message, fname, line);
     this.m_server.process_report(UVM_INFO, this.m_name, id, message, a, f, fname, line,
                                  m, verbosity, this.m_client);
   endfunction // uvm_report_info

    // Function: uvm_report
    //
    // Issues a message using the current message's report object.
    // This message will bypass any message catching callbacks.

    protected function void uvm_report(uvm_severity severity, string id, string message, int verbosity, string fname="", int line = 0);
        string m;
        uvm_action a;
        UVM_FILE f;
        uvm_report_handler rh;
        rh = this.m_client.get_report_handler();
        a = rh.get_action(severity, id);
        f = rh.get_file_handle(severity, id);

        m = this.m_server.compose_message(severity, this.m_name, id, message, fname, line);
        this.m_server.process_report(severity, this.m_name, id, message, a , f, fname, line,
                                     m, verbosity, this.m_client);
    endfunction // uvm_report

  // Function: issue
  // Immediately issues the message which is currently being processed. This
  // is useful if the message is being ~CAUGHT~ but should still be emitted.
  //
  // Issuing a message will update the report_server stats, possibly multiple 
  // times if the message is not ~CAUGHT~.

  protected function void issue();
     string m;
     uvm_action a;
     UVM_FILE f;
     uvm_report_handler rh;
     
     rh = this.m_client.get_report_handler();
     a  =  this.m_modified_action;
     f  = rh.get_file_handle(this.m_modified_severity,this.m_modified_id);
     
     m  = this.m_server.compose_message(this.m_modified_severity, this.m_name,
                                        this.m_modified_id,
                                        this.m_modified_message,
                                        this.m_file_name, this.m_line_number);
     this.m_server.process_report(this.m_modified_severity, this.m_name,
                                  this.m_modified_id, this.m_modified_message,
                                  a, f, this.m_file_name, this.m_line_number,
                                  m, this.m_modified_verbosity,this.m_client);
  endfunction


  //process_all_report_catchers
  //method called by report_server.report to process catchers
  //

  static function int process_all_report_catchers( 
    input uvm_report_server server,
    input uvm_report_object client,
    ref uvm_severity severity, 
    input string name, 
    ref string id,
    ref string message,
    ref int verbosity_level,
    ref uvm_action action,
    input string filename,
    input int line 
  );
    int iter;
    uvm_report_catcher catcher;
    int thrown = 1;
    uvm_severity orig_severity;
    static bit in_catcher;

    if(in_catcher == 1) begin
        return 1;
    end
    in_catcher = 1;    
    uvm_callbacks_base::m_tracing = 0;  //turn off cb tracing so catcher stuff doesn't print

    m_server             = server;
    m_client             = client;
    orig_severity        = severity;
    m_name               = name;
    m_file_name          = filename;
    m_line_number        = line;
    m_modified_id        = id;
    m_modified_severity  = severity;
    m_modified_message   = message;
    m_modified_verbosity = verbosity_level;
    m_modified_action    = action;

    m_orig_severity  = severity;
    m_orig_id        = id;
    m_orig_verbosity = verbosity_level;
    m_orig_action    = action;
    m_orig_message   = message;      

    catcher = uvm_report_cb::get_first(iter,client);
    while(catcher != null) begin
      uvm_severity prev_sev;

      if (!catcher.callback_mode()) begin
        catcher = uvm_report_cb::get_next(iter,client);
        continue;
      end

      prev_sev = m_modified_severity;
      m_set_action_called = 0;
      thrown = catcher.process_report_catcher();

      // Set the action to the default action for the new severity
      // if it is still at the default for the previous severity,
      // unless it was explicitly set.
      if (!m_set_action_called &&
          m_modified_severity != prev_sev &&
          m_modified_action == m_client.get_report_action(prev_sev, "*@&*^*^*#")) begin
         m_modified_action = m_client.get_report_action(m_modified_severity, "*@&*^*^*#");
      end

      if(thrown == 0) begin 
        case(orig_severity)
          UVM_FATAL:   m_caught_fatal++;
          UVM_ERROR:   m_caught_error++;
          UVM_WARNING: m_caught_warning++;
         endcase   
         break;
      end 
      catcher = uvm_report_cb::get_next(iter,client);
    end //while

    //update counters if message was returned with demoted severity
    case(orig_severity)
      UVM_FATAL:    
        if(m_modified_severity < orig_severity)
          m_demoted_fatal++;
      UVM_ERROR:
        if(m_modified_severity < orig_severity)
          m_demoted_error++;
      UVM_WARNING:
        if(m_modified_severity < orig_severity)
          m_demoted_warning++;
    endcase
   
    in_catcher = 0;
    uvm_callbacks_base::m_tracing = 1;  //turn tracing stuff back on

    severity        = m_modified_severity;
    id              = m_modified_id;
    message         = m_modified_message;
    verbosity_level = m_modified_verbosity;
    action          = m_modified_action;

    return thrown; 
  endfunction


  //process_report_catcher
  //internal method to call user catch() method
  //

  local function int process_report_catcher();

    action_e act;

    act = this.catch();

    if(act == UNKNOWN_ACTION)
      this.uvm_report_error("RPTCTHR", {"uvm_report_this.catch() in catcher instance ", this.get_name(), " must return THROW or CAUGHT"}, UVM_NONE, `uvm_file, `uvm_line);

    if(m_debug_flags & DO_NOT_MODIFY) begin
      m_modified_severity    = m_orig_severity;
      m_modified_id          = m_orig_id;
      m_modified_verbosity   = m_orig_verbosity;
      m_modified_action      = m_orig_action;
      m_modified_message     = m_orig_message;
    end     

    if(act == CAUGHT  && !(m_debug_flags & DO_NOT_CATCH)) begin
      return 0;
    end  

    return 1;

  endfunction

  //f_display
  //internal method to check if file is open
  //
  
  local static function void f_display(UVM_FILE file, string str);
    if (file == 0)
      $display("%s", str);
    else
      $fdisplay(file, "%s", str);
  endfunction

  // Function: summarize_report_catcher
  //
  // This function is called automatically by <uvm_report_server::summarize()>.
  // It prints the statistics for the active catchers.

  static function void summarize_report_catcher(UVM_FILE file);
    string s;
    if(do_report) begin
      f_display(file, "");   
      f_display(file, "--- UVM Report catcher Summary ---");
      f_display(file, "");   
      f_display(file, "");
  
      $sformat(s, "Number of demoted UVM_FATAL reports  :%5d", m_demoted_fatal);
      f_display(file,s);
  
      $sformat(s, "Number of demoted UVM_ERROR reports  :%5d", m_demoted_error);
      f_display(file,s);
  
      $sformat(s, "Number of demoted UVM_WARNING reports:%5d", m_demoted_warning);
      f_display(file,s);

      $sformat(s, "Number of caught UVM_FATAL reports   :%5d", m_caught_fatal);
      f_display(file,s);
  
      $sformat(s, "Number of caught UVM_ERROR reports   :%5d", m_caught_error);
      f_display(file,s);
  
      $sformat(s, "Number of caught UVM_WARNING reports :%5d", m_caught_warning);
      f_display(file,s);
    end
  endfunction

endclass

`endif // UVM_REPORT_CATCHER_SVH