| // |
| //------------------------------------------------------------------------------ |
| // Copyright 2007-2010 Mentor Graphics Corporation |
| // Copyright 2007-2011 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_MESSAGE_SVH |
| `define UVM_REPORT_MESSAGE_SVH |
| |
| |
| typedef class uvm_report_server; |
| typedef class uvm_report_handler; |
| typedef class uvm_root; |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // CLASS: uvm_report_message_element_base |
| // |
| // Base class for report message element. Defines common interface. |
| // |
| //------------------------------------------------------------------------------ |
| |
| virtual class uvm_report_message_element_base; |
| protected uvm_action _action; |
| protected string _name; |
| |
| |
| // Function: get_name |
| // |
| |
| virtual function string get_name(); |
| return _name; |
| endfunction |
| |
| // Function: set_name |
| // |
| // Get or set the name of the element |
| // |
| |
| virtual function void set_name(string name); |
| _name = name; |
| endfunction |
| |
| |
| // Function: get_action |
| // |
| |
| virtual function uvm_action get_action(); |
| return _action; |
| endfunction |
| |
| // Function: set_action |
| // |
| // Get or set the authorized action for the element |
| // |
| |
| virtual function void set_action(uvm_action action); |
| _action = action; |
| endfunction |
| |
| |
| function void print(uvm_printer printer); |
| if (_action & (UVM_LOG | UVM_DISPLAY)) |
| do_print(printer); |
| endfunction : print |
| function void record(uvm_recorder recorder); |
| if (_action & UVM_RM_RECORD) |
| do_record(recorder); |
| endfunction : record |
| function void copy(uvm_report_message_element_base rhs); |
| do_copy(rhs); |
| endfunction : copy |
| function uvm_report_message_element_base clone(); |
| return do_clone(); |
| endfunction : clone |
| |
| pure virtual function void do_print(uvm_printer printer); |
| pure virtual function void do_record(uvm_recorder recorder); |
| pure virtual function void do_copy(uvm_report_message_element_base rhs); |
| pure virtual function uvm_report_message_element_base do_clone(); |
| |
| endclass : uvm_report_message_element_base |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // CLASS: uvm_report_message_int_element |
| // |
| // Message element class for integral type |
| // |
| //------------------------------------------------------------------------------ |
| |
| class uvm_report_message_int_element extends uvm_report_message_element_base; |
| typedef uvm_report_message_int_element this_type; |
| |
| protected uvm_bitstream_t _val; |
| protected int _size; |
| protected uvm_radix_enum _radix; |
| |
| // Function: get_value |
| // |
| |
| virtual function uvm_bitstream_t get_value(output int size, |
| output uvm_radix_enum radix); |
| size = _size; |
| radix = _radix; |
| return _val; |
| endfunction |
| |
| |
| // Function: set_value |
| // |
| // Get or set the value (integral type) of the element, with size and radix |
| // |
| |
| virtual function void set_value(uvm_bitstream_t value, |
| int size, |
| uvm_radix_enum radix); |
| _size = size; |
| _radix = radix; |
| _val = value; |
| endfunction |
| |
| |
| virtual function void do_print(uvm_printer printer); |
| printer.print_int(_name, _val, _size, _radix); |
| endfunction : do_print |
| |
| virtual function void do_record(uvm_recorder recorder); |
| recorder.record_field(_name, _val, _size, _radix); |
| endfunction : do_record |
| |
| virtual function void do_copy(uvm_report_message_element_base rhs); |
| this_type _rhs; |
| $cast(_rhs, rhs); |
| _name = _rhs._name; |
| _val = _rhs._val; |
| _size = _rhs._size; |
| _radix = _rhs._radix; |
| _action = rhs._action; |
| endfunction : do_copy |
| |
| virtual function uvm_report_message_element_base do_clone(); |
| this_type tmp = new; |
| tmp.copy(this); |
| return tmp; |
| endfunction : do_clone |
| endclass : uvm_report_message_int_element |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // CLASS: uvm_report_message_string_element |
| // |
| // Message element class for string type |
| // |
| //------------------------------------------------------------------------------ |
| |
| class uvm_report_message_string_element extends uvm_report_message_element_base; |
| typedef uvm_report_message_string_element this_type; |
| protected string _val; |
| |
| |
| // Function: get_value |
| // |
| |
| virtual function string get_value(); |
| return _val; |
| endfunction |
| |
| // Function: set_value |
| // |
| // Get or set the value (string type) of the element |
| // |
| |
| virtual function void set_value(string value); |
| _val = value; |
| endfunction |
| |
| |
| virtual function void do_print(uvm_printer printer); |
| printer.print_string(_name, _val); |
| endfunction : do_print |
| |
| virtual function void do_record(uvm_recorder recorder); |
| recorder.record_string(_name, _val); |
| endfunction : do_record |
| |
| virtual function void do_copy(uvm_report_message_element_base rhs); |
| this_type _rhs; |
| $cast(_rhs, rhs); |
| _name = _rhs._name; |
| _val = _rhs._val; |
| _action = rhs._action; |
| endfunction : do_copy |
| |
| virtual function uvm_report_message_element_base do_clone(); |
| this_type tmp = new; |
| tmp.copy(this); |
| return tmp; |
| endfunction : do_clone |
| endclass : uvm_report_message_string_element |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // CLASS: uvm_report_message_object_element |
| // |
| // Message element class for object type |
| // |
| //------------------------------------------------------------------------------ |
| |
| class uvm_report_message_object_element extends uvm_report_message_element_base; |
| typedef uvm_report_message_object_element this_type; |
| protected uvm_object _val; |
| |
| |
| // Function: get_value |
| // |
| // Get the value (object reference) of the element |
| // |
| |
| virtual function uvm_object get_value(); |
| return _val; |
| endfunction |
| |
| // Function: set_value |
| // |
| // Get or set the value (object reference) of the element |
| // |
| |
| virtual function void set_value(uvm_object value); |
| _val = value; |
| endfunction |
| |
| |
| virtual function void do_print(uvm_printer printer); |
| printer.print_object(_name, _val); |
| endfunction : do_print |
| |
| virtual function void do_record(uvm_recorder recorder); |
| recorder.record_object(_name, _val); |
| endfunction : do_record |
| |
| virtual function void do_copy(uvm_report_message_element_base rhs); |
| this_type _rhs; |
| $cast(_rhs, rhs); |
| _name = _rhs._name; |
| _val = _rhs._val; |
| _action = rhs._action; |
| endfunction : do_copy |
| |
| virtual function uvm_report_message_element_base do_clone(); |
| this_type tmp = new; |
| tmp.copy(this); |
| return tmp; |
| endfunction : do_clone |
| endclass : uvm_report_message_object_element |
| |
| //------------------------------------------------------------------------------ |
| // |
| // CLASS: uvm_report_message_element_container |
| // |
| // A container used by report message to contain the dynamically added elements, |
| // with APIs to add and delete the elements. |
| // |
| //------------------------------------------------------------------------------ |
| |
| class uvm_report_message_element_container extends uvm_object; |
| |
| protected uvm_report_message_element_base elements[$]; |
| |
| `uvm_object_utils(uvm_report_message_element_container) |
| |
| // Function: new |
| // |
| // Create a new uvm_report_message_element_container object |
| // |
| |
| function new(string name = "element_container"); |
| super.new(name); |
| endfunction |
| |
| |
| // Function: size |
| // |
| // Returns the size of the container, i.e. the number of elements |
| // |
| |
| virtual function int size(); |
| return elements.size(); |
| endfunction |
| |
| |
| // Function: delete |
| // |
| // Delete the ~index~-th element in the container |
| // |
| |
| virtual function void delete(int index); |
| elements.delete(index); |
| endfunction |
| |
| |
| // Function: delete_elements |
| // |
| // Delete all the elements in the container |
| // |
| |
| virtual function void delete_elements(); |
| elements.delete(); |
| endfunction |
| |
| |
| // Function: get_elements |
| // |
| // Get all the elements from the container and put them in a queue |
| // |
| |
| typedef uvm_report_message_element_base queue_of_element[$]; |
| virtual function queue_of_element get_elements(); |
| return elements; |
| endfunction |
| |
| |
| // Function: add_int |
| // |
| // This method adds an integral type of the name ~name~ and value ~value~ to |
| // the container. The required ~size~ field indicates the size of ~value~. |
| // The required ~radix~ field determines how to display and |
| // record the field. The optional print/record bit is to specify whether |
| // the element will be printed/recorded. |
| // |
| |
| virtual function void add_int(string name, uvm_bitstream_t value, |
| int size, uvm_radix_enum radix, |
| uvm_action action = (UVM_LOG|UVM_RM_RECORD)); |
| process p; |
| string rand_state; |
| uvm_report_message_int_element urme; |
| |
| p = process::self(); |
| if (p != null) |
| rand_state = p.get_randstate(); |
| urme = new(); |
| if (p != null) |
| p.set_randstate(rand_state); |
| |
| urme.set_name(name); |
| urme.set_value(value, size, radix); |
| urme.set_action(action); |
| elements.push_back(urme); |
| endfunction |
| |
| |
| // Function: add_string |
| // |
| // This method adds a string of the name ~name~ and value ~value~ to the |
| // message. The optional print/record bit is to specify whether |
| // the element will be printed/recorded. |
| // |
| |
| virtual function void add_string(string name, string value, |
| uvm_action action = (UVM_LOG|UVM_RM_RECORD)); |
| process p; |
| string rand_state; |
| uvm_report_message_string_element urme; |
| |
| p = process::self(); |
| if (p != null) |
| rand_state = p.get_randstate(); |
| urme = new(); |
| if (p != null) |
| p.set_randstate(rand_state); |
| |
| urme.set_name(name); |
| urme.set_value(value); |
| urme.set_action(action); |
| elements.push_back(urme); |
| endfunction |
| |
| |
| // Function: add_object |
| // |
| // This method adds a uvm_object of the name ~name~ and reference ~obj~ to |
| // the message. The optional print/record bit is to specify whether |
| // the element will be printed/recorded. |
| // |
| |
| virtual function void add_object(string name, uvm_object obj, |
| uvm_action action = (UVM_LOG|UVM_RM_RECORD)); |
| process p; |
| string rand_state; |
| uvm_report_message_object_element urme; |
| |
| p = process::self(); |
| if (p != null) |
| rand_state = p.get_randstate(); |
| urme = new(); |
| if (p != null) |
| p.set_randstate(rand_state); |
| |
| urme.set_name(name); |
| urme.set_value(obj); |
| urme.set_action(action); |
| elements.push_back(urme); |
| endfunction |
| |
| virtual function void do_print(uvm_printer printer); |
| super.do_print(printer); |
| for(int i = 0; i < elements.size(); i++) begin |
| elements[i].print(printer); |
| end |
| endfunction |
| |
| virtual function void do_record(uvm_recorder recorder); |
| super.do_record(recorder); |
| for(int i = 0; i < elements.size(); i++) begin |
| elements[i].record(recorder); |
| end |
| endfunction |
| |
| virtual function void do_copy(uvm_object rhs); |
| uvm_report_message_element_container urme_container; |
| |
| super.do_copy(rhs); |
| |
| if(!$cast(urme_container, rhs) || (rhs==null)) |
| return; |
| |
| delete_elements(); |
| foreach (urme_container.elements[i]) |
| elements.push_back(urme_container.elements[i].clone()); |
| |
| endfunction |
| |
| endclass |
| |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // CLASS: uvm_report_message |
| // |
| // The uvm_report_message is the basic UVM object message class. It provides |
| // the fields that are common to all messages. It also has a message element |
| // container and provides the APIs necessary to add integral types, strings and |
| // uvm_objects to the container. The report message object can be initialized |
| // with the common fields, and passes through the whole reporting system (i.e. |
| // report object, report handler, report server, report catcher, etc) as an |
| // object. The additional elements can be added/deleted to/from the message |
| // object anywhere in the reporting system, and can be printed or recorded |
| // along with the common fields. |
| // |
| //------------------------------------------------------------------------------ |
| |
| class uvm_report_message extends uvm_object; |
| |
| protected uvm_report_object _report_object; |
| protected uvm_report_handler _report_handler; |
| protected uvm_report_server _report_server; |
| |
| protected uvm_severity _severity; |
| protected string _id; |
| protected string _message; |
| protected int _verbosity; |
| protected string _filename; |
| protected int _line; |
| protected string _context_name; |
| protected uvm_action _action; |
| protected UVM_FILE _file; |
| |
| // Not documented. |
| protected uvm_report_message_element_container _report_message_element_container; |
| |
| |
| // Function: new |
| // |
| // Creates a new uvm_report_message object. |
| // |
| |
| function new(string name = "uvm_report_message"); |
| super.new(name); |
| _report_message_element_container = new(); |
| endfunction |
| |
| |
| // Function: new_report_message |
| // |
| // Creates a new uvm_report_message object. |
| // This function is the same as new(), but keeps the random stability. |
| // |
| |
| static function uvm_report_message new_report_message(string name = "uvm_report_message"); |
| process p; |
| string rand_state; |
| |
| p = process::self(); |
| |
| if (p != null) |
| rand_state = p.get_randstate(); |
| new_report_message = new(name); |
| if (p != null) |
| p.set_randstate(rand_state); |
| |
| endfunction |
| |
| |
| // Function: print |
| // |
| // The uvm_report_message implements <uvm_object::do_print()> such that |
| // ~print~ method provides UVM printer formatted output |
| // of the message. A snippet of example output is shown here: |
| // |
| //| -------------------------------------------------------- |
| //| Name Type Size Value |
| //| -------------------------------------------------------- |
| //| uvm_report_message uvm_report_message - @532 |
| //| severity uvm_severity 2 UVM_INFO |
| //| id string 10 TEST_ID |
| //| message string 12 A message... |
| //| verbosity uvm_verbosity 32 UVM_LOW |
| //| filename string 7 test.sv |
| //| line integral 32 'd58 |
| //| context_name string 0 "" |
| //| color string 3 red |
| //| my_int integral 32 'd5 |
| //| my_string string 3 foo |
| //| my_obj my_class - @531 |
| //| foo integral 32 'd3 |
| //| bar string 8 hi there |
| |
| |
| virtual function void do_print(uvm_printer printer); |
| uvm_verbosity l_verbosity; |
| |
| super.do_print(printer); |
| |
| printer.print_generic("severity", "uvm_severity", |
| $bits(_severity), _severity.name()); |
| printer.print_string("id", _id); |
| printer.print_string("message",_message); |
| if ($cast(l_verbosity, _verbosity)) |
| printer.print_generic("verbosity", "uvm_verbosity", |
| $bits(l_verbosity), l_verbosity.name()); |
| else |
| printer.print_int("verbosity", _verbosity, $bits(_verbosity), UVM_HEX); |
| printer.print_string("filename", _filename); |
| printer.print_int("line", _line, $bits(_line), UVM_UNSIGNED); |
| printer.print_string("context_name", _context_name); |
| |
| if (_report_message_element_container.size() != 0) |
| _report_message_element_container.print(printer); |
| endfunction |
| |
| |
| `uvm_object_utils(uvm_report_message) |
| |
| |
| |
| // do_pack() not needed |
| // do_unpack() not needed |
| // do_compare() not needed |
| |
| |
| // Not documented. |
| virtual function void do_copy (uvm_object rhs); |
| uvm_report_message report_message; |
| |
| super.do_copy(rhs); |
| |
| if(!$cast(report_message, rhs) || (rhs==null)) |
| return; |
| |
| _report_object = report_message.get_report_object(); |
| _report_handler = report_message.get_report_handler(); |
| _report_server = report_message.get_report_server(); |
| _context_name = report_message.get_context(); |
| _file = report_message.get_file(); |
| _filename = report_message.get_filename(); |
| _line = report_message.get_line(); |
| _action = report_message.get_action(); |
| _severity = report_message.get_severity(); |
| _id = report_message.get_id(); |
| _message = report_message.get_message(); |
| _verbosity = report_message.get_verbosity(); |
| |
| _report_message_element_container.copy(report_message._report_message_element_container); |
| endfunction |
| |
| |
| //---------------------------------------------------------------------------- |
| // Group: Infrastructure References |
| //---------------------------------------------------------------------------- |
| |
| |
| // Function: get_report_object |
| |
| virtual function uvm_report_object get_report_object(); |
| return _report_object; |
| endfunction |
| |
| // Function: set_report_object |
| // |
| // Get or set the uvm_report_object that originated the message. |
| |
| virtual function void set_report_object(uvm_report_object ro); |
| _report_object = ro; |
| endfunction |
| |
| |
| // Function: get_report_handler |
| |
| virtual function uvm_report_handler get_report_handler(); |
| return _report_handler; |
| endfunction |
| |
| // Function: set_report_handler |
| // |
| // Get or set the uvm_report_handler that is responsible for checking |
| // whether the message is enabled, should be upgraded/downgraded, etc. |
| |
| virtual function void set_report_handler(uvm_report_handler rh); |
| _report_handler = rh; |
| endfunction |
| |
| |
| // Function: get_report_server |
| |
| virtual function uvm_report_server get_report_server(); |
| return _report_server; |
| endfunction |
| |
| // Function: set_report_server |
| // |
| // Get or set the uvm_report_server that is responsible for servicing |
| // the message's actions. |
| |
| virtual function void set_report_server(uvm_report_server rs); |
| _report_server = rs; |
| endfunction |
| |
| |
| //---------------------------------------------------------------------------- |
| // Group: Message Fields |
| //---------------------------------------------------------------------------- |
| |
| |
| // Function: get_severity |
| |
| virtual function uvm_severity get_severity(); |
| return _severity; |
| endfunction |
| |
| // Function: set_severity |
| // |
| // Get or set the severity (UVM_INFO, UVM_WARNING, UVM_ERROR or |
| // UVM_FATAL) of the message. The value of this field is determined via |
| // the API used (`uvm_info(), `uvm_waring(), etc.) and populated for the user. |
| |
| virtual function void set_severity(uvm_severity sev); |
| _severity = sev; |
| endfunction |
| |
| |
| // Function: get_id |
| |
| virtual function string get_id(); |
| return _id; |
| endfunction |
| |
| // Function: set_id |
| // |
| // Get or set the id of the message. The value of this field is |
| // completely under user discretion. Users are recommended to follow a |
| // consistent convention. Settings in the uvm_report_handler allow various |
| // messaging controls based on this field. See <uvm_report_handler>. |
| |
| virtual function void set_id(string id); |
| _id = id; |
| endfunction |
| |
| |
| // Function: get_message |
| |
| virtual function string get_message(); |
| return _message; |
| endfunction |
| |
| // Function: set_message |
| // |
| // Get or set the user message content string. |
| |
| virtual function void set_message(string msg); |
| _message = msg; |
| endfunction |
| |
| |
| // Function: get_verbosity |
| |
| virtual function int get_verbosity(); |
| return _verbosity; |
| endfunction |
| |
| // Function: set_verbosity |
| // |
| // Get or set the message threshold value. This value is compared |
| // against settings in the <uvm_report_handler> to determine whether this |
| // message should be executed. |
| |
| virtual function void set_verbosity(int ver); |
| _verbosity = ver; |
| endfunction |
| |
| |
| // Function: get_filename |
| |
| virtual function string get_filename(); |
| return _filename; |
| endfunction |
| |
| // Function: set_filename |
| // |
| // Get or set the file from which the message originates. This value |
| // is automatically populated by the messaging macros. |
| |
| virtual function void set_filename(string fname); |
| _filename = fname; |
| endfunction |
| |
| |
| // Function: get_line |
| |
| virtual function int get_line(); |
| return _line; |
| endfunction |
| |
| // Function: set_line |
| // |
| // Get or set the line in the ~file~ from which the message originates. |
| // This value is automatically populate by the messaging macros. |
| |
| virtual function void set_line(int ln); |
| _line = ln; |
| endfunction |
| |
| |
| // Function: get_context |
| |
| virtual function string get_context(); |
| return _context_name; |
| endfunction |
| |
| // Function: set_context |
| // |
| // Get or set the optional user-supplied string that is meant to convey |
| // the context of the message. It can be useful in scopes that are not |
| // inherently UVM like modules, interfaces, etc. |
| |
| virtual function void set_context(string cn); |
| _context_name = cn; |
| endfunction |
| |
| |
| // Function: get_action |
| |
| virtual function uvm_action get_action(); |
| return _action; |
| endfunction |
| |
| // Function: set_action |
| // |
| // Get or set the action(s) that the uvm_report_server should perform |
| // for this message. This field is populated by the uvm_report_handler during |
| // message execution flow. |
| |
| virtual function void set_action(uvm_action act); |
| _action = act; |
| endfunction |
| |
| |
| // Function: get_file |
| |
| virtual function UVM_FILE get_file(); |
| return _file; |
| endfunction |
| |
| // Function: set_file |
| // |
| // Get or set the file that the message is to be written to when the |
| // message's action is UVM_LOG. This field is populated by the |
| // uvm_report_handler during message execution flow. |
| |
| virtual function void set_file(UVM_FILE fl); |
| _file = fl; |
| endfunction |
| |
| |
| // Function: get_element_container |
| // |
| // Get the element_container of the message |
| |
| virtual function uvm_report_message_element_container get_element_container(); |
| return _report_message_element_container; |
| endfunction |
| |
| |
| // Function: set_report_message |
| // |
| // Set all the common fields of the report message in one shot. |
| // |
| |
| virtual function void set_report_message(uvm_severity severity, |
| string id, |
| string message, |
| int verbosity, |
| string filename, |
| int line, |
| string context_name); |
| this._context_name = context_name; |
| this._filename = filename; |
| this._line = line; |
| this._severity = severity; |
| this._id = id; |
| this._message = message; |
| this._verbosity = verbosity; |
| endfunction |
| |
| |
| //---------------------------------------------------------------------------- |
| // Group- Message Recording |
| //---------------------------------------------------------------------------- |
| |
| // Not documented. |
| virtual function void m_record_message(uvm_recorder recorder); |
| recorder.record_string("message", _message); |
| endfunction |
| |
| |
| // Not documented. |
| virtual function void m_record_core_properties(uvm_recorder recorder); |
| |
| string l_string; |
| uvm_verbosity l_verbosity; |
| |
| if (_context_name != "") |
| recorder.record_string("context_name", _context_name); |
| recorder.record_string("filename", _filename); |
| recorder.record_field("line", _line, $bits(_line), UVM_UNSIGNED); |
| recorder.record_string("severity", _severity.name()); |
| if ($cast(l_verbosity, _verbosity)) |
| recorder.record_string("verbosity", l_verbosity.name()); |
| else begin |
| l_string.itoa(_verbosity); |
| recorder.record_string("verbosity", l_string); |
| end |
| |
| recorder.record_string("id", _id); |
| m_record_message(recorder); |
| endfunction |
| |
| // Not documented. |
| virtual function void do_record(uvm_recorder recorder); |
| |
| super.do_record(recorder); |
| |
| m_record_core_properties(recorder); |
| _report_message_element_container.record(recorder); |
| |
| endfunction |
| |
| |
| //---------------------------------------------------------------------------- |
| // Group: Message Element APIs |
| //---------------------------------------------------------------------------- |
| |
| |
| // Function: add_int |
| // |
| // This method adds an integral type of the name ~name~ and value ~value~ to |
| // the message. The required ~size~ field indicates the size of ~value~. |
| // The required ~radix~ field determines how to display and |
| // record the field. The optional print/record bit is to specify whether |
| // the element will be printed/recorded. |
| // |
| |
| virtual function void add_int(string name, uvm_bitstream_t value, |
| int size, uvm_radix_enum radix, |
| uvm_action action = (UVM_LOG|UVM_RM_RECORD)); |
| _report_message_element_container.add_int(name, value, size, radix, action); |
| endfunction |
| |
| |
| // Function: add_string |
| // |
| // This method adds a string of the name ~name~ and value ~value~ to the |
| // message. The optional print/record bit is to specify whether |
| // the element will be printed/recorded. |
| // |
| |
| virtual function void add_string(string name, string value, |
| uvm_action action = (UVM_LOG|UVM_RM_RECORD)); |
| _report_message_element_container.add_string(name, value, action); |
| endfunction |
| |
| |
| // Function: add_object |
| // |
| // This method adds a uvm_object of the name ~name~ and reference ~obj~ to |
| // the message. The optional print/record bit is to specify whether |
| // the element will be printed/recorded. |
| // |
| |
| virtual function void add_object(string name, uvm_object obj, |
| uvm_action action = (UVM_LOG|UVM_RM_RECORD)); |
| _report_message_element_container.add_object(name, obj, action); |
| endfunction |
| |
| endclass |
| |
| |
| `endif |
