vmm_log.sv

Go to the documentation of this file.

// 
// -------------------------------------------------------------
//    Copyright 2004-2008 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.
// -------------------------------------------------------------
// 


`ifdef VCS
(* vmm_private_class, _vcs_vmm_class = 1 *)
`endif
class vmm_log_modifier;
   int       typ;
   int       severity;
   string    pattern;
   int       new_typ;
   int       new_severity;
   int       handling;

   static local vmm_log log;

   function new();
      // Initialize all static properties
      if (log == null) this.log = new("vmm_log_modifier", "class");
   endfunction: new
   
   extern function string psdisplay(string prefix = "");
endclass: vmm_log_modifier
     

typedef class vmm_log_msg;

`ifdef VCS
(* vmm_private_class, _vcs_vmm_class = 1 *)
`endif
class vmm_log_watchpoint;
   int       typ;
   int       severity;
   string    pattern;
   logic     issued;

   event       seen;
   vmm_log_msg msg;

   static local vmm_log log;
   
   function new();
      // Initialize all static properties
      if (log == null) this.log = new("vmm_log_watchpoint", "class");
   endfunction: new

   extern function void   display(string prefix = "");
   extern function string psdisplay(string prefix = "");
endclass:vmm_log_watchpoint


`ifdef VCS
(* vmm_private_class, _vcs_vmm_class = 1 *)
`endif
class vmm_log_msg;
   vmm_log    log;

   bit        invalid;   
   time       timestamp;
   int        original_typ;
   int        original_severity;
   int        effective_typ;
   int        effective_severity;
   string     text[$];
   logic      issued;
   int        handling;

   /*local*/ int flushed;

   function new(vmm_log log);
      this.log     = log;
      this.invalid = 1;
   endfunction: new

   extern function void   display(string prefix = "");
   extern function string psdisplay(string prefix = "");
   extern function vmm_log_msg copy();
endclass: vmm_log_msg


   //
   // vmm_log_modifier
   //

function string vmm_log_modifier::psdisplay(string prefix);
   $sformat(psdisplay, "%s%s [%s] with \"%s\" -> %s [%s] then %s",
          prefix, this.log.typ_image(this.typ),
          this.log.sev_image(this.severity),
          (this.pattern == "") ? "/./" : this.pattern,
          this.log.typ_image(this.new_typ),
          this.log.sev_image(this.new_severity),
          this.log.handling_image(this.handling));
endfunction: psdisplay


  //
  // vmm_log_watchpoint
  //

function void vmm_log_watchpoint::display(string prefix);
   $write("%s\n", this.psdisplay(prefix));
endfunction: display
   
function string vmm_log_watchpoint::psdisplay(string prefix);
   $sformat(psdisplay, "%s%s [%s] with \"%s\"%s",
            prefix, this.log.typ_image(this.typ),
            this.log.sev_image(this.severity),
            (this.pattern == "") ? "/./" : this.pattern,
            (this.issued === 1'bx) ? "" : (this.issued) ? "if issued" : "if not issued");
endfunction: psdisplay


  //
  // vmm_log_msg
  //
  
function void   vmm_log_msg::display(string prefix);
   $write("%s\n", this.psdisplay(prefix));
endfunction: display

function string vmm_log_msg::psdisplay(string prefix);
   $sformat(psdisplay, "%s%s [%s] at %0t", prefix,
            this.log.typ_image(this.effective_typ),
            this.log.sev_image(this.effective_severity),
            this.timestamp);
   foreach(this.text[i]) begin
      $sformat(psdisplay, "%s\n%s    %s", psdisplay, prefix,
               this.text[i]);
   end
endfunction: psdisplay

function vmm_log_msg vmm_log_msg::copy();
   copy = new(this.log);

   copy.timestamp          = this.timestamp;
   copy.original_typ       = this.original_typ;
   copy.original_severity  = this.original_severity;
   copy.effective_typ      = this.effective_typ;
   copy.effective_severity = this.effective_severity;
   copy.text               = this.text;
   copy.issued             = this.issued;
   copy.handling           = this.handling;

   copy.flushed = this.flushed;
endfunction: copy


  //
  // vmm_log;
  //

function void vmm_log::reset(string name,
                             string inst,
                             bit    recurse);
   this.is_self = 0;
   this.is_all  = 0;

   this.known_idx = 0;
   this.recurse = recurse;
   this.recurse_id++;
`ifdef VCS2006_06
   // Work-around for NYI feature in 2006.06
   // *NOT* IEEE compliant :-(
   this.recurse_stack.delete();
`else
   // Works in VCS 2008.03
   this.recurse_stack = '{};
`endif

   // Trivial iterators?
   if (name == "" && inst == "") begin
      this.is_self = 1;
      return;
   end
   if (name == "/./" && inst == "/./") begin
      this.is_all = 1;
      this.recurse = 0; // No point in recursion
      return;
   end
   
   if (name == "") name = this.name;
   if (inst == "") inst = this.inst;
 
   this.pattern[0] = name;
   this.is_pattern[0] = `vmm_str_match(this.pattern[0], "^/(.*)/$");
   if (is_pattern[0]) begin
      this.pattern[0] = `vmm_str_backref(this.pattern[0], 0);
   end

   this.pattern[1] = inst;
   this.is_pattern[1] = `vmm_str_match(this.pattern[1], "^/(.*)/$");
   if (is_pattern[1]) begin
      this.pattern[1] = `vmm_str_backref(this.pattern[1], 0);
   end
endfunction: reset
   

`ifdef VCS
(* vmm_private_class, _vcs_vmm_class = 1 *)
`endif
class vmm_log_below_iter;
   local vmm_log log;
   local int idx;

   function new(vmm_log log);
      this.log = log;
      this.idx = 0;
   endfunction

   function vmm_log data();
      if (this.idx >= this.log.below.size()) data = null;
      else data = this.log.below[idx];
   endfunction

   function vmm_log start();
      this.idx = 0;
      start = this.data();
   endfunction

   function vmm_log next();
      if (idx < this.log.below.size()) idx++;
      next = this.data();
   endfunction
endclass


function vmm_log vmm_log::for_each();
   if (this.is_self) begin
      if (this.is_self == 1) begin
         this.is_self = 2;
         if (this.recurse) begin
            vmm_log_below_iter j = new(this);
            this.visited = this.recurse_id;
            this.recurse_stack.push_back(j);
         end
         return this;
      end else if (!this.recurse) begin
         return null;
      end
   end

   while (this.recurse && this.recurse_stack.size() > 0) begin
      vmm_log_below_iter i = recurse_stack[$];

      while (i.data() != null) begin
         vmm_log that = i.data();
         i.next();
         if (that.visited != this.recurse_id) begin
            vmm_log_below_iter j = new(that);
            that.visited = this.recurse_id;
            this.recurse_stack.push_back(j);
            return that;
         end
      end
      this.recurse_stack.pop_back();
   end

   if (this.is_self) begin
      return null;
   end

   while (this.known_idx < this.known.size()) begin
      vmm_log that = this.known[this.known_idx++];
      bit name_ok;
      bit inst_ok;

      if (this.is_all) begin
         return that;
      end

      if (is_pattern[0]) name_ok = `vmm_str_match(that.name, this.pattern[0]);
      else               name_ok = (that.name == this.pattern[0]);

      if (is_pattern[1]) inst_ok = `vmm_str_match(that.inst, this.pattern[1]);
      else               inst_ok = (that.inst == this.pattern[1]);

      if (name_ok && inst_ok) begin
         if (that.visited != this.recurse_id) begin
            that.visited = this.recurse_id;
            if (this.recurse) begin
               vmm_log_below_iter j = new(that);
               this.recurse_stack.push_back(j);
            end
            return that;
         end
      end
   end
   for_each = null;
endfunction: for_each

   
function vmm_log::new(string  name,
                      string  inst,
                      vmm_log under);
`ifdef VMM_LOG_BASE_NEW_CALL
   super.new(`VMM_LOG_BASE_NEW_CALL);
`endif

   this.name = name;
   this.inst = inst;
   if (under != null) under.is_above(this);

   this.msg   = new(this);

   this.n_msg[FATAL_SEV]   = 0;
   this.n_msg[ERROR_SEV]   = 0;
   this.n_msg[WARNING_SEV] = 0;
   this.n_msg[NORMAL_SEV] = 0;
   this.n_msg[TRACE_SEV] = 0;
   this.n_msg[DEBUG_SEV] = 0;
   this.n_msg[VERBOSE_SEV] = 0;
   this.n_msg[HIDDEN_SEV] = 0;
   this.n_msg[IGNORE_SEV] = 0;

   this.has_text_modifiers = 0;
   this.n_demoted[ERROR_SEV] = 0;
   this.n_demoted[WARNING_SEV] = 0;

   this.known.push_back(this);

   this.enabled_typs = ALL_TYPS;

   if (this.known.size() == 1) begin
      this.type_list.push_back(FAILURE_TYP);
      this.type_list.push_back(NOTE_TYP);
      this.type_list.push_back(DEBUG_TYP);
      this.type_list.push_back(REPORT_TYP);
      this.type_list.push_back(NOTIFY_TYP);
      this.type_list.push_back(TIMING_TYP);
      this.type_list.push_back(XHANDLING_TYP);
      this.type_list.push_back(PROTOCOL_TYP);
      this.type_list.push_back(TRANSACTION_TYP);
      this.type_list.push_back(COMMAND_TYP);
      this.type_list.push_back(CYCLE_TYP);
      this.type_list.push_back(USER_TYP_0);
      this.type_list.push_back(USER_TYP_1);
      this.type_list.push_back(USER_TYP_2);
      this.type_list.push_back(INTERNAL_TYP);

      this.sev_list.push_back(FATAL_SEV);
      this.sev_list.push_back(ERROR_SEV);
      this.sev_list.push_back(WARNING_SEV);
      this.sev_list.push_back(NORMAL_SEV);
      this.sev_list.push_back(TRACE_SEV);
      this.sev_list.push_back(DEBUG_SEV);
      this.sev_list.push_back(VERBOSE_SEV);

      // Define default images
      this.type_images[FAILURE_TYP    ] = "FAILURE";
      this.type_images[NOTE_TYP       ] = "NOTE";
      this.type_images[DEBUG_TYP      ] = "DEBUG";
      this.type_images[REPORT_TYP     ] = "REPORT";
      this.type_images[NOTIFY_TYP     ] = "NOTIFY";
      this.type_images[TIMING_TYP     ] = "TIMING";
      this.type_images[XHANDLING_TYP  ] = "XHANDLING";
      this.type_images[PROTOCOL_TYP   ] = "PROTOCOL";
      this.type_images[TRANSACTION_TYP] = "XACTION";
      this.type_images[COMMAND_TYP    ] = "COMMAND";
      this.type_images[CYCLE_TYP      ] = "CYCLE";
      this.type_images[USER_TYP_0     ] = "USER_0";
      this.type_images[USER_TYP_1     ] = "USER_1";
      this.type_images[USER_TYP_2     ] = "USER_2";
      this.type_images[INTERNAL_TYP   ] = "INTERNAL";

`ifdef VMM_LOG_ANSI_COLOR
      this.sev_images[FATAL_SEV  ] = "\033[41m*FATAL*\033[0m";
      this.sev_images[ERROR_SEV  ] = "\033[31m!ERROR!\033[0m";
      this.sev_images[WARNING_SEV] = "\033[33mWARNING\033[0m";
`else
      this.sev_images[FATAL_SEV  ] = "*FATAL*";
      this.sev_images[ERROR_SEV  ] = "!ERROR!";
      this.sev_images[WARNING_SEV] = "WARNING";
`endif
      this.sev_images[NORMAL_SEV ] = "Normal";
      this.sev_images[TRACE_SEV  ] = "Trace";
      this.sev_images[DEBUG_SEV  ] = "Debug";
      this.sev_images[VERBOSE_SEV] = "Verbose";


      // Process command-line options
      if ($test$plusargs("rvm_log_debug")) begin
         this.plus_debug = 1;
      end

      begin
         bit    plusarg;
         string arg;
         string level;

         plusarg = $value$plusargs("rvm_log_default=%s", arg);
         if (!plusarg) begin
            plusarg = $value$plusargs("vmm_log_default=%s", arg);
         end
         if (plusarg) begin
            level = arg.substr(0, 1); // Only look at the 1st 2 chars

            level = level.tolower();
            if (level == "er")
               this.dflt_lvl = ERROR_SEV;
            else if (level == "wa")
               this.dflt_lvl = WARNING_SEV;
            else if (level == "no")
               this.dflt_lvl = NORMAL_SEV;
            else if (level == "tr")
               this.dflt_lvl = TRACE_SEV;
            else if (level == "de")
               this.dflt_lvl = DEBUG_SEV;
            else if (level == "ve")
               this.dflt_lvl = VERBOSE_SEV;
            else if (level == "hi")
               this.dflt_lvl = HIDDEN_SEV;
            else
               $write("Warning: Invalid +rvm_log_default specification: \"%s\"\n",
                      arg);
         end
         // Sometimes, VCS screws up static initialization order
         else this.dflt_lvl = NORMAL_SEV;

         plusarg = $value$plusargs("rvm_force_verbosity=%s", arg);
         if (!plusarg) begin
            plusarg = $value$plusargs("vmm_force_verbosity=%s", arg);
         end
         if (plusarg) begin
            level = arg.substr(0, 1); // Only look at the 1st 2 chars

            level = level.tolower();
            if (level == "er")
              this.force_lvl = ERROR_SEV;
            else if (level == "wa")
              this.force_lvl = WARNING_SEV;
            else if (level == "no")
              this.force_lvl = NORMAL_SEV;
            else if (level == "tr")
              this.force_lvl = TRACE_SEV;
            else if (level == "de")
              this.force_lvl = DEBUG_SEV;
            else if (level == "ve")
              this.force_lvl = VERBOSE_SEV;
            else if (level == "hi")
              this.force_lvl = HIDDEN_SEV;
            else
              $write("Warning: Invalid +rvm_force_verbosity level: \"%s\"\n",
                     arg);
         end
      end



   end

   this.log_lvl = this.dflt_lvl;
   this.log_start(STDOUT);

   //
   // Catch a common usage error
   if (this.known.size() == 200) begin
      if (!$test$plusargs("vmm_log_nowarn_at_200") &&
          !$test$plusargs("rvm_log_nowarn_at_200")) begin
         if (this.start_msg(FAILURE_TYP, WARNING_SEV)) begin
            this.text("Over 200 vmm_log instances have been created.");
            this.text("Check that all vmm_data extensions use a static instance");
            this.text("or use +vmm_log_nowarn_at_200 to disable this warning.");
            this.end_msg();
         end
      end
   end
      
   if (this.known.size() == 1000) begin
      if (!$test$plusargs("vmm_log_nofatal_at_1000") &&
          !$test$plusargs("rvm_log_nofatal_at_1000")) begin
         if (this.start_msg(FAILURE_TYP, FATAL_SEV)) begin
            this.text("Over 1000 vmm_log instances have been created.");
            this.text("Check that all vmm_data extensions use a static instance");
            this.text("or use +vmm_log_nofatal_at_1000 to disable this failure.");
            this.end_msg();
         end
      end
   end



endfunction: new


function void vmm_log::is_above(vmm_log log);
   if (log == null) return;
   this.below.push_back(log);


endfunction: is_above

  
function vmm_log vmm_log::copy(vmm_log to);
   if (to == null) to = new(this.name, this.inst);
   else begin
      to.name = this.name;
      to.inst = this.inst;
   end

   to.enabled_typs = this.enabled_typs;
   to.log_lvl      = this.log_lvl;
   to.fp           = this.fp;

   copy = to;
endfunction: copy


function void vmm_log::set_name(string name);
   this.name = name;
endfunction: set_name

  
function string vmm_log::get_name();
   get_name = this.name;
endfunction: get_name

  
function void vmm_log::set_instance(string inst);
   this.inst = inst;
endfunction: set_instance
   

function string vmm_log::get_instance();
   get_instance = this.inst;
endfunction: get_instance
   

function void vmm_log::list(string name,
                            string inst,
                            bit    recurse);
   this.reset(name, inst, recurse);
   for (vmm_log log = this.for_each(); log != null; log = this.for_each()) begin   
      $write("%s(%s) [%s] F/E/W/e/w=%0d/%0d/%0d/%0d/%0d\n", log.name, log.inst, this.sev_image(log.log_lvl), log.n_msg[FATAL_SEV], log.n_msg[ERROR_SEV], log.n_msg[WARNING_SEV], log.n_demoted[ERROR_SEV], log.n_demoted[WARNING_SEV]);
      for(int i = 0; i < log.below.size(); i++) begin
         $write("  +--- %s(%s)\n", log.below[i].name, log.below[i].inst);
      end
   end
endfunction: list
   

function void vmm_log::display(string prefix);
   $display("%s", this.psdisplay(prefix));
endfunction


function string vmm_log::psdisplay(string prefix);
   $sformat(psdisplay, "%s%s(%s) [%s]", prefix, this.name, this.inst,
            this.sev_image(this.log_lvl));
   for (int i = 0; i < this.below.size(); i++) begin
      $sformat(psdisplay, "%s\n%s   +--- %s(%s)", psdisplay, prefix,
               this.below[i].name, this.below[i].inst);
   end
   for (int i = 0; i < this.modifier_ids.size(); i++) begin
      $sformat(psdisplay, "%s\n%s", psdisplay, this.modifier_cache[this.modifier_ids[i]].psdisplay({prefix, "   "}));
   end
endfunction


function void vmm_log::kill();
   foreach(this.known[i]) begin
      if (this.known[i] == this) this.known.delete(i);
   end
endfunction: kill


function vmm_log_format vmm_log::set_format(vmm_log_format fmt);
   if (fmt == null) begin
      `vmm_error(this, "Cannot use NULL formatter in vmm_log::set_format(). Unchanged");
      return null;
   end

   set_format = this.fmt;
   this.fmt = fmt;
endfunction: set_format

  
function string vmm_log::set_typ_image(int    typ,
                                       string image);
   if (!this.type_images.exists(typ)) begin
      `vmm_error(this, "Invalid message type specified to vmm_log::set_typ_image()");
      return "";
   end

   set_typ_image = this.type_images[typ];
   this.type_images[typ] = image;



endfunction: set_typ_image
   

function string vmm_log::typ_image(int typ);
   string sep = "";

   if (this.type_images.exists(typ)) begin
      return this.type_images[typ];
   end

   // Special types
   if (typ == DEFAULT) begin
      return "(default)";
   end
   if (typ == UNCHANGED) begin
      return "(unchanged)";
   end

   // Composite type?
   typ_image = "";
   foreach(this.type_list[i]) begin
      if (typ & this.type_list[i]) begin
         typ_image = {typ_image, sep, this.type_images[this.type_list[i]]};
         sep = "/";
      end
   end
   if (typ_image == "") typ_image = "?MSG_TYP?";
endfunction: typ_image
   

function string vmm_log::set_sev_image(int    severity,
                                       string image);
   if (!this.sev_images.exists(severity)) begin
      `vmm_error(this, "Invalid message severity specified to vmm_log::set_sev_image()");
      return "";
   end

   set_sev_image = this.sev_images[severity];
   this.sev_images[severity] = image;



endfunction: set_sev_image

  
function string vmm_log::sev_image(int severity);
   string sep = "";

   if (this.sev_images.exists(severity)) begin
      return this.sev_images[severity];
   end

   // Special severities
   if (severity == DEFAULT) begin
      return "(default)";
   end
   if (severity == UNCHANGED) begin
      return "(unchanged)";
   end
   if (severity == IGNORE_SEV) begin
      return "(ignored)";
   end

   // Composite severity?
   sev_image = "";
   foreach(this.sev_list[i]) begin
      if (severity & this.sev_list[i]) begin
         sev_image = {sev_image, sep, this.sev_images[this.sev_list[i]]};
         sep = "/";
      end
   end
   if (sev_image == "") sev_image = "?SEV_TYP?";
endfunction: sev_image


function string vmm_log::handling_image(int handling);
   case (handling)
      ABORT_SIM        : handling_image = "ABORT";
      COUNT_ERROR      : handling_image = "ERROR";
      STOP_PROMPT      : handling_image = "STOP";
      DEBUGGER         : handling_image = "DEBUGGER";
      DUMP_STACK       : handling_image = "DUMPSTACK";
      CONTINUE         : handling_image = "CONTINUE";
      IGNORE           : handling_image = "IGNORE";
      DEFAULT          : handling_image = "(default)";
      UNCHANGED        : handling_image = "(unchanged)";
      default          : handling_image = "?HANDLING?";
   endcase
endfunction: handling_image

   
function int vmm_log::default_handling(int severity);
   case (severity)
      FATAL_SEV   : default_handling = ABORT_SIM;
      ERROR_SEV   : default_handling = COUNT_ERROR;
      default     : default_handling = CONTINUE;
   endcase
endfunction: default_handling
   

function void vmm_log::report(string name,
                              string inst,
                              bit    recurse);
   vmm_log log;
   int    n_fatals = 0;
   int    n_errs   = 0;
   int    n_warns  = 0;
   int    n_derrs  = 0;
   int    n_dwarns = 0;
   string msg;

   this.reset(name, inst, recurse);
   for(log = this.for_each(); log != null; log = this.for_each()) begin

      n_fatals += log.n_msg[FATAL_SEV];
      n_errs   += log.n_msg[ERROR_SEV];
      n_warns  += log.n_msg[WARNING_SEV];
      n_derrs  += log.n_demoted[ERROR_SEV];
      n_dwarns += log.n_demoted[WARNING_SEV];
   end

   msg = this.fmt.pass_or_fail(n_fatals == 0 && n_errs == 0,
                               name, inst, n_fatals, n_errs, n_warns,
                               n_derrs, n_dwarns);
   if (msg != "") $display("%s", msg);
endfunction: report
   

function bit vmm_log::start_msg(int typ,
                                int severity);

   if (this.msg != null && !this.msg.invalid && this.msg.issued !== 1'b0) this.end_msg();

   // Provide a default severity if none specified
   if (severity < 0) begin
      case (typ)
         FAILURE_TYP    :  severity = ERROR_SEV;
         NOTE_TYP       :  severity = NORMAL_SEV;
         DEBUG_TYP      :  severity = DEBUG_SEV;
         REPORT_TYP     :  severity = DEBUG_SEV;
         NOTIFY_TYP     :  severity = HIDDEN_SEV;
         TIMING_TYP     :  severity = WARNING_SEV;
         XHANDLING_TYP  :  severity = WARNING_SEV;
         PROTOCOL_TYP   :  severity = DEBUG_SEV;
         TRANSACTION_TYP:  severity = TRACE_SEV;
         COMMAND_TYP    :  severity = TRACE_SEV;
         CYCLE_TYP      :  severity = VERBOSE_SEV;
         default        :  severity = NORMAL_SEV;
      endcase
   end

   // Perform a quick, less expensive filtering here for loggers without
   // promotion/demotion or watchpoints.  Return immediately if the
   // message is not printed based on severity and enabled categories
   if (this.modifier_ids.size() == 0 &&
       this.watchpoint_ids.size() == 0) begin

      if ((this.force_lvl != DEFAULT_SEV && severity > this.force_lvl) || // Forced?
          (this.force_lvl == DEFAULT_SEV && severity > this.log_lvl) ||   // Above?
          (!(typ & this.enabled_typs) && (severity >= WARNING_SEV)) // Disabled?
          ) begin
         this.msg.invalid = 1;
         return 0;
      end
   end

   this.msg.invalid = 0;
   this.msg.original_typ = typ;
   this.msg.original_severity = severity;
   this.msg.effective_typ = typ;
   this.msg.effective_severity = severity;
   this.msg.flushed = 0;
`ifdef VCS2006_06
   // Work-around for NYI feature in 2006.06
   // *NOT* IEEE compliant :-(
   this.msg.text.delete();
`else
   // Works in VCS 2008.03
   this.msg.text = '{};
`endif
   this.msg.handling = DEFAULT;
   this.msg.issued = 1'bx;

   start_msg = 1;

   // Do property-based promotion and filtering
   // if there are no text-based filters
   if (!this.has_text_modifiers) begin
      this.promote();
      this.filter();

      if (this.msg.issued === 1'b0) begin
         start_msg = 0;

         // Record risky demotions
         if (this.msg.effective_severity > this.msg.original_severity) begin
            case (this.msg.original_severity)
               ERROR_SEV  : this.n_demoted[ERROR_SEV]++;
               WARNING_SEV: this.n_demoted[WARNING_SEV]++;
            endcase
         end

         this.msg.invalid = 1;
      end
   end
endfunction: start_msg
   

function bit vmm_log::text(string msg);
   if (this.msg.invalid)
   begin
      `vmm_error(this, "Malformed message: vmm_log::text() called before vmm_log::start_msg()");
      return 0;
   end

   text = 1;

   if (msg == "")
   begin
      this.flush_msg();
      return 1;
   end

   this.msg.text.push_back(msg);

endfunction: text
   

function void vmm_log::end_msg();
   int handling;

   if (this.msg.invalid)
   begin
      `vmm_error(this, "Malformed message: vmm_log::end_msg() called before vmm_log::start_msg()");
      return;
   end

   this.flush_msg();




   handling = this.msg.handling;
   if (handling == DEFAULT) handling = default_handling(this.msg.effective_severity);

   // Avoid recursive handling in callbacks
   if (this.in_callbacks) handling = CONTINUE;

   case (handling)

     ABORT_SIM: begin
        this.in_callbacks = 1;
        `vmm_callback(vmm_log_callbacks, pre_abort(this));
        this.in_callbacks = 0;
        $finish;
     end

     DUMP_STACK,
     DEBUGGER: begin
        this.in_callbacks = 1;
        `vmm_callback(vmm_log_callbacks, pre_debug(this));
        this.in_callbacks = 0;
        $stop;
     end

     STOP_PROMPT: begin
        this.in_callbacks = 1;
        `vmm_callback(vmm_log_callbacks, pre_stop(this));
        this.in_callbacks = 0;
        $stop;
     end

     COUNT_ERROR: begin
        this.error_count++;
        if (this.error_limit > 0 && this.error_count >= this.error_limit) begin
           string msg = this.fmt.abort_on_error(this.error_count,
                                                this.error_limit);
           if (msg != "") $display("%s", msg);
           this.in_callbacks = 1;
           //`vmm_callback(vmm_log_callbacks, pre_abort(this));
           do for (int i = 0; i < this.callbacks.size(); i++) begin
              vmm_log_callbacks cb;
              if (!$cast(cb, this.callbacks[i])) continue;
              cb.pre_abort(this);
           end while (0);
           this.in_callbacks = 0;
           $finish;
        end                                          
     end
   endcase

   this.msg.invalid = 1;
endfunction: end_msg


function void vmm_log::flush_msg();
   string msg;

   if (this.msg.flushed == 0) begin

      // Perform promotion/demotion if there are text filters
      // (it will have been done in start_msg() if there were none)
      if (this.has_text_modifiers) begin
         this.promote();
         this.filter();
      end
      this.notify();

      // Record risky demotions
      if (this.msg.effective_severity > this.msg.original_severity) begin
         case (this.msg.original_severity)
            ERROR_SEV  : this.n_demoted[ERROR_SEV]++;
            WARNING_SEV: this.n_demoted[WARNING_SEV]++;
         endcase
      end

      if (this.msg.issued === 1'b0) return;




      msg = this.fmt.format_msg(this.name, this.inst, 
                                this.typ_image(this.msg.effective_typ),
                                this.sev_image(this.msg.effective_severity),
                                this.msg.text);
      foreach(this.fp[i]) begin
         $fdisplay(this.fp[i], "%s", msg);
      end
      // Did we just send an ERROR or FATAL message to /dev/null??
      if (this.fp.size() == 0 && this.msg.effective_severity <= ERROR_SEV) begin
         // Force it to appear on STDOUT
         $display("%s", msg);
      end
      this.msg.flushed++;
`ifdef VCS2006_06
      // Work-around for NYI feature in 2006.06
      // *NOT* IEEE compliant :-(
      this.msg.text.delete();
`else
      // Works in VCS 2008.03
      this.msg.text = '{};
`endif
   end
   else begin
      if (this.msg.text.size() > 0) begin
         msg = this.fmt.continue_msg(this.name, this.inst, 
                                     this.typ_image(this.msg.effective_typ),
                                     this.sev_image(this.msg.effective_severity),
                                     this.msg.text);
         foreach(this.fp[i]) begin
            $fdisplay(this.fp[i], "%s", msg);
         end
         // Did we just send an ERROR or FATAL message to /dev/null??
         if (this.fp.size() == 0 && this.msg.effective_severity <= ERROR_SEV) begin
            // Force it to appear on STDOUT
            $display("%s", msg);
         end
         this.msg.flushed++;
`ifdef VCS2006_06
         // Work-around for NYI feature in 2006.06
         // *NOT* IEEE compliant :-(
         this.msg.text.delete();
`else
         // Works in VCS 2008.03
         this.msg.text = '{};
`endif
      end
      return;
   end

   this.n_msg[this.msg.effective_severity]++;
endfunction: flush_msg


function void vmm_log::enable_types(int    typs,
                                    string name,
                                    string inst,
                                    bit    recursive);
   if (typs == DEFAULT_TYP ) typs = ALL_TYPS ;
   if (typs < 0) begin
      `vmm_error(this, "Invalid message type specified to vmm_log::enable_types");
      return;
   end

   //
   // Enable specified types in all specified log insts
   //
   this.reset(name, inst, recursive);
   for(vmm_log log = this.for_each(); log != null; log = this.for_each()) begin
      log.enabled_typs |= typs;
   end
endfunction: enable_types


function void vmm_log::disable_types(int    typs,
                                     string name,
                                     string inst,
                                     bit    recursive);
   if (typs < 0) begin
      `vmm_error(this, "Invalid message type specified to vmm_log::disable_types");
      return;
   end
   // Cannot disable failure messages
   if (typs & FAILURE_TYP) begin
      `vmm_warning(this, "Cannot disable FAILURE_TYP messages");
      typs -= FAILURE_TYP;
   end

   //
   // Disable specified types in all specified log insts
   //
   this.reset(name, inst, recursive);
   for(vmm_log log = this.for_each(); log != null; log = this.for_each()) begin
      log.enabled_typs &= ~(typs);
   end
endfunction: disable_types

   
function int vmm_log::modify(string name,
                             string inst,
                             bit    recursive,
                             int    typ,
                             int    severity,
                             string text,
                             int    new_typ,
                             int    new_severity,
                             int    handling);
   vmm_log_modifier modifier;
   int          mod_id;

   // Some severities cannot be demoted too far
   if (severity == FATAL_SEV &&
       new_severity > ERROR_SEV) begin
      `vmm_error(this, "Cannot demote FATAL_SEV severity to less than ERROR_SEV");
      return -2;
   end
   if (severity == ERROR_SEV &&
       new_severity > WARNING_SEV) begin
      `vmm_error(this, "Cannot demote ERROR severity to less than WARNING");
      return -2;
   end

   //
   // Add a description of the modification to the cache
   //
   modifier = new;
   modifier.typ          = typ;
   modifier.severity     = severity;
   modifier.pattern      = text;
   modifier.new_typ      = new_typ;
   modifier.new_severity = new_severity;
   modifier.handling     = handling;

   // Remove "/" surrounding the pattern, if any
   if (`vmm_str_match(modifier.pattern, "^/(.*)/$")) begin
      modifier.pattern = `vmm_str_backref(modifier.pattern, 0);
   end

   mod_id = this.modifier_cache.num();
   this.modifier_cache[mod_id] = modifier;

   //
   // Link all affected log instances
   //
   this.reset(name, inst, recursive);
   for(vmm_log log = this.for_each(); log != null; log = this.for_each()) begin
      log.modifier_ids.push_back(mod_id);
      if (modifier.pattern != "") log.has_text_modifiers++;
   end

   modify = mod_id;
endfunction: modify


function void vmm_log::unmodify(int    modification_id,
                                string name,
                                string inst,
                                bit    recursive);
   if (modification_id < -1) begin
      `vmm_error(this, `vmm_sformatf("Invalid modification ID %0d specified to vmm_log::unmodify()",
                                     modification_id));
      return;
   end

   // Does it exist?
   if (modification_id >= 0) begin
      if (!this.modifier_cache.exists(modification_id)) begin
         `vmm_error(this, `vmm_sformatf("Unknown modification ID %0d specified to vmm_log::unmodify()",
                                        modification_id));
         return;
      end
   end
   
   //
   // Unlink all affected log instances
   //
   this.reset(name, inst, recursive);
   for(vmm_log log = this.for_each(); log != null; log = this.for_each()) begin

      // Find the specified modifier...
      foreach(log.modifier_ids[i]) begin
         if (modification_id >= 0 && log.modifier_ids[i] != modification_id) continue;

         if (this.modifier_cache[log.modifier_ids[i]].pattern != "") begin
            log.has_text_modifiers--;
            if (log.has_text_modifiers < 0) begin
               $write("***** vmm_log Internal ERROR: has_text_modifiers < 0\n");
               log.has_text_modifiers = 0;
            end
         end
         if (modification_id >= 0) begin
            log.modifier_ids.delete(i);
            break;
         end
      end
      if (modification_id < 0) begin
`ifdef VCS2006_06
         // Work-around for NYI feature in 2006.06
         // *NOT* IEEE compliant :-(
         log.modifier_ids.delete();
`else
         // Works in VCS 2008.03
         log.modifier_ids = '{};
`endif
      end
   end
endfunction: unmodify


function void vmm_log::promote();

   // Apply modifiers in the order they were created
   foreach(this.modifier_ids[i]) begin
      vmm_log_modifier mod;
      
      mod = this.modifier_cache[this.modifier_ids[i]];

      // Does it apply to this message?

      // Message type must be included
      if (!(mod.typ & this.msg.effective_typ)) continue;

      // Message severity must be included
      if (!(mod.severity & this.msg.effective_severity)) continue;

      // If specified, the text pattern must match
      if (mod.pattern != "") begin
         bit matched = 0;
         int idx;
         foreach (this.msg.text[idx]) begin
            if (`vmm_str_match(this.msg.text[idx], mod.pattern)) begin
               matched = 1;
               break;
            end
         end
         if (!matched) continue;
      end

      // Promote message!
      if (mod.new_typ != UNCHANGED) begin
         if (mod.new_typ == DEFAULT) begin
            this.msg.effective_typ = this.msg.original_typ;
         end else begin
            this.msg.effective_typ = mod.new_typ;
         end
      end

      if (mod.new_severity != UNCHANGED) begin
         if (mod.new_severity == DEFAULT) begin
            this.msg.effective_severity = this.msg.original_severity;
         end else begin
            this.msg.effective_severity = mod.new_severity;
         end
         // Some severities cannot be demoted too far
         if (this.msg.original_severity == FATAL_SEV &&
             this.msg.effective_severity > ERROR_SEV) begin
            this.msg.effective_severity = ERROR_SEV ;
         end
         if (this.msg.original_severity == ERROR_SEV &&
             this.msg.effective_severity > WARNING_SEV) begin
            this.msg.effective_severity = WARNING_SEV;
         end
      end

      if (mod.handling != UNCHANGED) begin
         this.msg.handling = mod.handling;
      end
   end
endfunction: promote
   

function void vmm_log::filter();

   if (this.msg.issued === 1'b0 ||  // Already filtered out
       this.msg.effective_severity == IGNORE_SEV ||  // Demoted to be ignored
       // Cannot disable any types with severity FATAL or ERROR
       (!(this.msg.effective_typ & this.enabled_typs) &&     // Disabled
        (this.msg.effective_severity >= WARNING_SEV)) ||
       (this.force_lvl != DEFAULT_SEV && this.msg.effective_severity > this.force_lvl) ||
       (this.force_lvl == DEFAULT_SEV && this.log_lvl < this.msg.effective_severity)) begin
      this.msg.issued = 1'b0;

      return;
   end

   this.msg.issued = 1'b1;
endfunction: filter
   

function void vmm_log::notify();
   // Check notifiers in the order they were created
   foreach(this.watchpoint_ids[i]) begin
      vmm_log_watchpoint wp;

      wp = this.watchpoint_cache[this.watchpoint_ids[i]];

      // Does it apply to this message?

      // Message type must be included
      if (!(wp.typ & this.msg.effective_typ)) continue;

      // Message severity must be included
      if (!(wp.severity & this.msg.effective_severity)) continue;

      // The message must be issued or not
      if (wp.issued !== 1'bx && wp.issued !== this.msg.issued) begin
         continue;
      end

      // If specified, the text pattern must match
      if (wp.pattern != "") begin
         bit matched = 0;
         integer idx;
         foreach(this.msg.text[idx]) begin
            if (`vmm_str_match(this.msg.text[idx], wp.pattern)) begin
               matched = 1;
               break;
            end
         end
         if (!matched) continue; // to the next watchpt
      end

      // This is a watched message
      wp.msg = this.msg.copy();
      -> wp.seen;
   end
endfunction: notify


function void vmm_log::set_verbosity(int    severity,
                                     string name,
                                     string inst,
                                     bit    recursive);
   if (!this.sev_images.exists(severity) ||
       severity < ERROR_SEV ||
       severity > VERBOSE_SEV) begin
      `vmm_error(this, "Invalid severity specified to vmm_log::set_verbosity()");
      return;
   end

   this.reset(name, inst, recursive);
   for(vmm_log log = this.for_each(); log != null; log = this.for_each()) begin
      log.log_lvl = severity;
   end
endfunction: set_verbosity
   

function int vmm_log::get_verbosity();
   get_verbosity = this.log_lvl;
endfunction: get_verbosity


function void vmm_log::log_start(int    file,
                                 string name,
                                 string inst,
                                 bit    recurse);
   // Find the loggers in question
   vmm_log log;
      
   this.reset(name, inst, recurse);
   for(log = this.for_each(); log != null; log = this.for_each()) begin
      
      // Check that we are not already logging to this file
      foreach(log.fp[i]) begin
         if (log.fp[i] == file) return;
      end
      log.fp.push_back(file);


   end
endfunction: log_start


function void vmm_log::log_stop(int    file,
                                string name,
                                string inst,
                                bit    recurse);
   // Find the loggers in question
   vmm_log log;
      
   this.reset(name, inst, recurse);
   for(log = this.for_each(); log != null; log = this.for_each()) begin
      
      // Check that we are indeed logging to this file
      foreach(log.fp[i]) begin
         if (log.fp[i] == file) log.fp.delete(i);
         // Cannot close this file because it may still be used by other loggers
      end
   end
endfunction: log_stop


function void vmm_log::stop_after_n_errors(int n);
   this.error_count = 0;
   this.error_limit = n;
endfunction: stop_after_n_errors
   
function int vmm_log::get_message_count(int    severity,
                                        string name,
                                        string inst,
                                        bit    recurse);
   get_message_count = 0;

   this.reset(name, inst, recurse);
   for(vmm_log log = this.for_each(); log != null; log = this.for_each()) begin

      if (severity & FATAL_SEV)   get_message_count += log.n_msg[FATAL_SEV];
      if (severity & ERROR_SEV)   get_message_count += log.n_msg[ERROR_SEV];
      if (severity & WARNING_SEV) get_message_count += log.n_msg[WARNING_SEV];
      if (severity & NORMAL_SEV)  get_message_count += log.n_msg[NORMAL_SEV];
      if (severity & TRACE_SEV)   get_message_count += log.n_msg[TRACE_SEV];
      if (severity & DEBUG_SEV)   get_message_count += log.n_msg[DEBUG_SEV];
      if (severity & VERBOSE_SEV) get_message_count += log.n_msg[VERBOSE_SEV];
      if (severity & HIDDEN_SEV)  get_message_count += log.n_msg[HIDDEN_SEV];
      if (severity & IGNORE_SEV)  get_message_count += log.n_msg[IGNORE_SEV];
   end
endfunction: get_message_count


task vmm_log::wait_for_msg(string          name,
                           string          inst,
                           bit             recurse,
                           int             typs,
                           int             severity,
                           string          text,
                           logic           issued,
                           ref vmm_log_msg msg);
   int wp_id;

   wp_id = this.create_watchpoint(typs, severity, text, issued);
   this.add_watchpoint(wp_id, name, inst, recurse);
   this.wait_for_watchpoint(wp_id, msg);
   this.remove_watchpoint(wp_id, name, inst, recurse);
endtask: wait_for_msg


function int vmm_log::create_watchpoint(int     typs,