| // |
| //------------------------------------------------------------------------------ |
| // Copyright 2007-2011 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 or the specific language governing |
| // permissions and limitations under the License. |
| //------------------------------------------------------------------------------ |
| |
| |
| typedef class uvm_printer_knobs; |
| |
| parameter UVM_STDOUT = 1; // Writes to standard out and logfile |
| |
| typedef struct { |
| int level; |
| string name; |
| string type_name; |
| string size; |
| string val; |
| } uvm_printer_row_info; |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // Class: uvm_printer |
| // |
| // The uvm_printer class provides an interface for printing <uvm_objects> in |
| // various formats. Subtypes of uvm_printer implement different print formats, |
| // or policies. |
| // |
| // A user-defined printer format can be created, or one of the following four |
| // built-in printers can be used: |
| // |
| // - <uvm_printer> - provides base printer functionality; must be overridden. |
| // |
| // - <uvm_table_printer> - prints the object in a tabular form. |
| // |
| // - <uvm_tree_printer> - prints the object in a tree form. |
| // |
| // - <uvm_line_printer> - prints the information on a single line, but uses the |
| // same object separators as the tree printer. |
| // |
| // Printers have knobs that you use to control what and how information is printed. |
| // These knobs are contained in a separate knob class: |
| // |
| // - <uvm_printer_knobs> - common printer settings |
| // |
| // For convenience, global instances of each printer type are available for |
| // direct reference in your testbenches. |
| // |
| // - <uvm_default_tree_printer> |
| // - <uvm_default_line_printer> |
| // - <uvm_default_table_printer> |
| // - <uvm_default_printer> (set to default_table_printer by default) |
| // |
| // When <uvm_object::print> and <uvm_object::sprint> are called without |
| // specifying a printer, the <uvm_default_printer> is used. |
| // |
| //------------------------------------------------------------------------------ |
| |
| virtual class uvm_printer; |
| |
| // Variable: knobs |
| // |
| // The knob object provides access to the variety of knobs associated with a |
| // specific printer instance. |
| // |
| uvm_printer_knobs knobs = new; |
| |
| |
| // Group: Methods for printer usage |
| |
| // These functions are called from <uvm_object::print>, or they are called |
| // directly on any data to get formatted printing. |
| |
| // Function: print_int |
| // |
| // Prints an integral field. |
| // |
| // name - The name of the field. |
| // value - The value of the field. |
| // size - The number of bits of the field (maximum is 4096). |
| // radix - The radix to use for printing. The printer knob for radix is used |
| // if no radix is specified. |
| // scope_separator - is used to find the leaf name since many printers only |
| // print the leaf name of a field. Typical values for the separator |
| // are . (dot) or [ (open bracket). |
| |
| extern virtual function void print_int (string name, |
| uvm_bitstream_t value, |
| int size, |
| uvm_radix_enum radix=UVM_NORADIX, |
| byte scope_separator=".", |
| string type_name=""); |
| |
| // backward compatibility |
| virtual function void print_field (string name, |
| uvm_bitstream_t value, |
| int size, |
| uvm_radix_enum radix=UVM_NORADIX, |
| byte scope_separator=".", |
| string type_name=""); |
| print_int (name, value, size, radix, scope_separator, type_name); |
| endfunction |
| |
| |
| // Function: print_object |
| // |
| // Prints an object. Whether the object is recursed depends on a variety of |
| // knobs, such as the depth knob; if the current depth is at or below the |
| // depth setting, then the object is not recursed. |
| // |
| // By default, the children of <uvm_components> are printed. To turn this |
| // behavior off, you must set the <uvm_component::print_enabled> bit to 0 for |
| // the specific children you do not want automatically printed. |
| |
| extern virtual function void print_object (string name, |
| uvm_object value, |
| byte scope_separator="."); |
| |
| |
| extern virtual function void print_object_header (string name, |
| uvm_object value, |
| byte scope_separator="."); |
| |
| |
| // Function: print_string |
| // |
| // Prints a string field. |
| |
| extern virtual function void print_string (string name, |
| string value, |
| byte scope_separator="."); |
| |
| |
| // Function: print_time |
| // |
| // Prints a time value. name is the name of the field, and value is the |
| // value to print. |
| // |
| // The print is subject to the ~$timeformat~ system task for formatting time |
| // values. |
| |
| extern virtual function void print_time (string name, |
| time value, |
| byte scope_separator="."); |
| |
| |
| // Function: print_string |
| // |
| // Prints a string field. |
| |
| extern virtual function void print_real (string name, |
| real value, |
| byte scope_separator="."); |
| |
| // Function: print_generic |
| // |
| // Prints a field having the given ~name~, ~type_name~, ~size~, and ~value~. |
| |
| extern virtual function void print_generic (string name, |
| string type_name, |
| int size, |
| string value, |
| byte scope_separator="."); |
| |
| // Group: Methods for printer subtyping |
| |
| // Function: emit |
| // |
| // Emits a string representing the contents of an object |
| // in a format defined by an extension of this object. |
| // |
| extern virtual function string emit (); |
| |
| |
| // Function: format_row |
| // |
| // Hook for producing custom output of a single field (row). |
| // |
| extern virtual function string format_row (uvm_printer_row_info row); |
| |
| |
| // Function: format_row |
| // |
| // Hook to override base header with a custom header. |
| virtual function string format_header(); |
| return ""; |
| endfunction |
| |
| |
| // Function: format_header |
| // |
| // Hook to override base footer with a custom footer. |
| virtual function string format_footer(); |
| return ""; |
| endfunction |
| |
| |
| // Function: adjust_name |
| // |
| // Prints a field's name, or ~id~, which is the full instance name. |
| // |
| // The intent of the separator is to mark where the leaf name starts if the |
| // printer if configured to print only the leaf name of the identifier. |
| |
| extern virtual protected function string adjust_name (string id, |
| byte scope_separator="."); |
| |
| // Function: print_array_header |
| // |
| // Prints the header of an array. This function is called before each |
| // individual element is printed. <print_array_footer> is called to mark the |
| // completion of array printing. |
| |
| extern virtual function void print_array_header(string name, |
| int size, |
| string arraytype="array", |
| byte scope_separator="."); |
| |
| // Function: print_array_range |
| // |
| // Prints a range using ellipses for values. This method is used when honoring |
| // the array knobs for partial printing of large arrays, |
| // <uvm_printer_knobs::begin_elements> and <uvm_printer_knobs::end_elements>. |
| // |
| // This function should be called after begin_elements have been printed |
| // and before end_elements have been printed. |
| |
| extern virtual function void print_array_range (int min, int max); |
| |
| |
| // Function: print_array_footer |
| // |
| // Prints the header of a footer. This function marks the end of an array |
| // print. Generally, there is no output associated with the array footer, but |
| // this method lets the printer know that the array printing is complete. |
| |
| extern virtual function void print_array_footer (int size=0); |
| |
| |
| |
| // Utility methods |
| extern function bit istop (); |
| extern function string index_string (int index, string name=""); |
| |
| protected bit m_array_stack[$]; |
| uvm_scope_stack m_scope = new; |
| string m_string; |
| |
| // holds each cell entry |
| protected uvm_printer_row_info m_rows[$]; |
| |
| endclass |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // Class: uvm_table_printer |
| // |
| // The table printer prints output in a tabular format. |
| // |
| // The following shows sample output from the table printer. |
| // |
| //| --------------------------------------------------- |
| //| Name Type Size Value |
| //| --------------------------------------------------- |
| //| c1 container - @1013 |
| //| d1 mydata - @1022 |
| //| v1 integral 32 'hcb8f1c97 |
| //| e1 enum 32 THREE |
| //| str string 2 hi |
| //| value integral 12 'h2d |
| //| --------------------------------------------------- |
| // |
| //------------------------------------------------------------------------------ |
| |
| class uvm_table_printer extends uvm_printer; |
| |
| // Variable: new |
| // |
| // Creates a new instance of ~uvm_table_printer~. |
| // |
| extern function new(); |
| |
| // Function: emit |
| // |
| // Formats the collected information from prior calls to ~print_*~ |
| // into table format. |
| // |
| extern virtual function string emit(); |
| |
| // Variables- m_max_* |
| // |
| // holds max size of each column, so table columns can be resized dynamically |
| |
| protected int m_max_name; |
| protected int m_max_type; |
| protected int m_max_size; |
| protected int m_max_value; |
| |
| extern function void calculate_max_widths(); |
| |
| endclass |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // Class: uvm_tree_printer |
| // |
| // By overriding various methods of the <uvm_printer> super class, |
| // the tree printer prints output in a tree format. |
| // |
| // The following shows sample output from the tree printer. |
| // |
| //| c1: (container@1013) { |
| //| d1: (mydata@1022) { |
| //| v1: 'hcb8f1c97 |
| //| e1: THREE |
| //| str: hi |
| //| } |
| //| value: 'h2d |
| //| } |
| // |
| //------------------------------------------------------------------------------ |
| |
| class uvm_tree_printer extends uvm_printer; |
| |
| string newline = "\n"; |
| |
| // Variable: new |
| // |
| // Creates a new instance of ~uvm_tree_printer~. |
| |
| extern function new(); |
| |
| // Function: emit |
| // |
| // Formats the collected information from prior calls to ~print_*~ |
| // into hierarchical tree format. |
| // |
| extern virtual function string emit(); |
| |
| endclass |
| |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // Class: uvm_line_printer |
| // |
| // The line printer prints output in a line format. |
| // |
| // The following shows sample output from the line printer. |
| // |
| //| c1: (container@1013) { d1: (mydata@1022) { v1: 'hcb8f1c97 e1: THREE str: hi } value: 'h2d } |
| //------------------------------------------------------------------------------ |
| |
| class uvm_line_printer extends uvm_tree_printer; |
| |
| // Variable: new |
| // |
| // Creates a new instance of ~uvm_line_printer~. It differs from the |
| // <uvm_tree_printer> only in that the output contains no line-feeds |
| // and indentation. |
| |
| function new(); |
| newline = " "; |
| knobs.indent = 0; |
| endfunction |
| |
| endclass |
| |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // Class: uvm_printer_knobs |
| // |
| // The ~uvm_printer_knobs~ class defines the printer settings available to all |
| // printer subtypes. |
| // |
| //------------------------------------------------------------------------------ |
| |
| class uvm_printer_knobs; |
| |
| // Variable: header |
| // |
| // Indicates whether the <print_header> function should be called when |
| // printing an object. |
| |
| bit header = 1; |
| |
| |
| // Variable: footer |
| // |
| // Indicates whether the <print_footer> function should be called when |
| // printing an object. |
| |
| bit footer = 1; |
| |
| |
| // Variable: full_name |
| // |
| // Indicates whether <adjust_name> should print the full name of an identifier |
| // or just the leaf name. |
| |
| bit full_name = 0; |
| |
| |
| // Variable: identifier |
| // |
| // Indicates whether <adjust_name> should print the identifier. This is useful |
| // in cases where you just want the values of an object, but no identifiers. |
| |
| bit identifier = 1; |
| |
| |
| // Variable: type_name |
| // |
| // Controls whether to print a field's type name. |
| |
| bit type_name = 1; |
| |
| |
| // Variable: size |
| // |
| // Controls whether to print a field's size. |
| |
| bit size = 1; |
| |
| |
| // Variable: depth |
| // |
| // Indicates how deep to recurse when printing objects. |
| // A depth of -1 means to print everything. |
| |
| int depth = -1; |
| |
| |
| // Variable: reference |
| // |
| // Controls whether to print a unique reference ID for object handles. |
| // The behavior of this knob is simulator-dependent. |
| |
| bit reference = 1; |
| |
| |
| // Variable: begin_elements |
| // |
| // Defines the number of elements at the head of a list to print. |
| // Use -1 for no max. |
| |
| int begin_elements = 5; |
| |
| |
| // Variable: end_elements |
| // |
| // This defines the number of elements at the end of a list that |
| // should be printed. |
| |
| int end_elements = 5; |
| |
| |
| // Variable: prefix |
| // |
| // Specifies the string prepended to each output line |
| |
| string prefix = ""; |
| |
| |
| // Variable: indent |
| // |
| // This knob specifies the number of spaces to use for level indentation. |
| // The default level indentation is two spaces. |
| |
| int indent = 2; |
| |
| |
| // Variable: show_root |
| // |
| // This setting indicates whether or not the initial object that is printed |
| // (when current depth is 0) prints the full path name. By default, the first |
| // object is treated like all other objects and only the leaf name is printed. |
| |
| bit show_root = 0; |
| |
| |
| // Variable: mcd |
| // |
| // This is a file descriptor, or multi-channel descriptor, that specifies |
| // where the print output should be directed. |
| // |
| // By default, the output goes to the standard output of the simulator. |
| |
| int mcd = UVM_STDOUT; |
| |
| |
| // Variable: separator |
| // |
| // For tree printers only, determines the opening and closing |
| // separators used for nested objects. |
| |
| string separator = "{}"; |
| |
| |
| // Variable: show_radix |
| // |
| // Indicates whether the radix string ('h, and so on) should be prepended to |
| // an integral value when one is printed. |
| |
| bit show_radix = 1; |
| |
| |
| // Variable: default_radix |
| // |
| // This knob sets the default radix to use for integral values when no radix |
| // enum is explicitly supplied to the print_int() method. |
| |
| uvm_radix_enum default_radix = UVM_HEX; |
| |
| |
| // Variable: dec_radix |
| // |
| // This string should be prepended to the value of an integral type when a |
| // radix of <UVM_DEC> is used for the radix of the integral object. |
| // |
| // When a negative number is printed, the radix is not printed since only |
| // signed decimal values can print as negative. |
| |
| string dec_radix = "'d"; |
| |
| |
| // Variable: bin_radix |
| // |
| // This string should be prepended to the value of an integral type when a |
| // radix of <UVM_BIN> is used for the radix of the integral object. |
| |
| string bin_radix = "'b"; |
| |
| |
| // Variable: oct_radix |
| // |
| // This string should be prepended to the value of an integral type when a |
| // radix of <UVM_OCT> is used for the radix of the integral object. |
| |
| string oct_radix = "'o"; |
| |
| |
| // Variable: unsigned_radix |
| // |
| // This is the string which should be prepended to the value of an integral |
| // type when a radix of <UVM_UNSIGNED> is used for the radix of the integral |
| // object. |
| |
| string unsigned_radix = "'d"; |
| |
| |
| // Variable: hex_radix |
| // |
| // This string should be prepended to the value of an integral type when a |
| // radix of <UVM_HEX> is used for the radix of the integral object. |
| |
| string hex_radix = "'h"; |
| |
| |
| // Function: get_radix_str |
| // |
| // Converts the radix from an enumerated to a printable radix according to |
| // the radix printing knobs (bin_radix, and so on). |
| |
| function string get_radix_str(uvm_radix_enum radix); |
| if(show_radix == 0) |
| return ""; |
| if(radix == UVM_NORADIX) |
| radix = default_radix; |
| case(radix) |
| UVM_BIN: return bin_radix; |
| UVM_OCT: return oct_radix; |
| UVM_DEC: return dec_radix; |
| UVM_HEX: return hex_radix; |
| UVM_UNSIGNED: return unsigned_radix; |
| default: return ""; |
| endcase |
| endfunction |
| |
| // Deprecated knobs, hereafter ignored |
| int max_width = 999; |
| string truncation = "+"; |
| int name_width = -1; |
| int type_width = -1; |
| int size_width = -1; |
| int value_width = -1; |
| bit sprint = 1; |
| |
| endclass |
| |
| |
| typedef uvm_printer_knobs uvm_table_printer_knobs; |
| typedef uvm_printer_knobs uvm_tree_printer_knobs; |
| |
| |
| //------------------------------------------------------------------------------ |
| // IMPLEMENTATION |
| //------------------------------------------------------------------------------ |
| |
| // emit |
| // ---- |
| |
| function string uvm_printer::emit (); |
| `uvm_error("NO_OVERRIDE","emit() method not overridden in printer subtype") |
| return ""; |
| endfunction |
| |
| |
| // format_row |
| // ---------- |
| |
| function string uvm_printer::format_row (uvm_printer_row_info row); |
| return ""; |
| endfunction |
| |
| |
| // print_array_header |
| // ------------------ |
| |
| function void uvm_printer::print_array_header (string name, |
| int size, |
| string arraytype="array", |
| byte scope_separator="."); |
| uvm_printer_row_info row_info; |
| |
| if(name != "") |
| m_scope.set_arg(name); |
| |
| row_info.level = m_scope.depth(); |
| row_info.name = adjust_name(m_scope.get(),scope_separator); |
| row_info.type_name = arraytype; |
| row_info.size = $sformatf("%0d",size); |
| row_info.val = "-"; |
| |
| m_rows.push_back(row_info); |
| |
| m_scope.down(name); |
| m_array_stack.push_back(1); |
| endfunction |
| |
| |
| // print_array_footer |
| // ------------------ |
| |
| function void uvm_printer::print_array_footer (int size=0); |
| if(m_array_stack.size()) begin |
| m_scope.up(); |
| void'(m_array_stack.pop_front()); |
| end |
| endfunction |
| |
| |
| // print_array_range |
| // ----------------- |
| |
| function void uvm_printer::print_array_range(int min, int max); |
| string tmpstr; |
| if(min == -1 && max == -1) |
| return; |
| if(min == -1) |
| min = max; |
| if(max == -1) |
| max = min; |
| if(max < min) |
| return; |
| print_generic("...", "...", -2, "..."); |
| endfunction |
| |
| |
| // print_object_header |
| // ------------------- |
| |
| function void uvm_printer::print_object_header (string name, |
| uvm_object value, |
| byte scope_separator="."); |
| uvm_printer_row_info row_info; |
| uvm_component comp; |
| |
| if(name == "") begin |
| if(value!=null) begin |
| if((m_scope.depth()==0) && $cast(comp, value)) begin |
| name = comp.get_full_name(); |
| end |
| else begin |
| name=value.get_name(); |
| end |
| end |
| end |
| |
| if(name == "") |
| name = "<unnamed>"; |
| |
| m_scope.set_arg(name); |
| |
| row_info.level = m_scope.depth(); |
| |
| if(row_info.level == 0 && knobs.show_root==1) |
| row_info.name = value.get_full_name(); |
| else |
| row_info.name = adjust_name(m_scope.get(),scope_separator); |
| |
| row_info.type_name = (value != null) ? value.get_type_name() : "object"; |
| row_info.size = "-"; |
| row_info.val = knobs.reference ? uvm_object_value_str(value) : "-"; |
| |
| m_rows.push_back(row_info); |
| |
| endfunction |
| |
| |
| // print_object |
| // ------------ |
| |
| function void uvm_printer::print_object (string name, uvm_object value, |
| byte scope_separator="."); |
| uvm_component comp, child_comp; |
| |
| print_object_header(name,value,scope_separator); |
| |
| if(value != null) begin |
| if((knobs.depth == -1 || (knobs.depth > m_scope.depth())) && |
| !value.__m_uvm_status_container.cycle_check.exists(value)) begin |
| |
| value.__m_uvm_status_container.cycle_check[value] = 1; |
| if(name=="" && value!=null) |
| m_scope.down(value.get_name()); |
| else |
| m_scope.down(name); |
| |
| //Handle children of the comp |
| if($cast(comp, value)) begin |
| string name; |
| if (comp.get_first_child(name)) |
| do begin |
| child_comp = comp.get_child(name); |
| if(child_comp.print_enabled) |
| this.print_object("",child_comp); |
| end while (comp.get_next_child(name)); |
| end |
| |
| // print members of object |
| void'(value.sprint(this)); |
| |
| if(name != "" && name[0] == "[") |
| m_scope.up("["); |
| else |
| m_scope.up("."); |
| value.__m_uvm_status_container.cycle_check.delete(value); |
| end |
| end |
| |
| endfunction |
| |
| |
| // istop |
| // ----- |
| |
| function bit uvm_printer::istop (); |
| return (m_scope.depth() == 0); |
| endfunction |
| |
| |
| // adjust_name |
| // ----------- |
| |
| function string uvm_printer::adjust_name(string id, byte scope_separator="."); |
| if (knobs.show_root && m_scope.depth()==0 || knobs.full_name || id == "...") |
| return id; |
| return uvm_leaf_scope(id, scope_separator); |
| endfunction |
| |
| |
| // print_generic |
| // ------------- |
| |
| function void uvm_printer::print_generic (string name, |
| string type_name, |
| int size, |
| string value, |
| byte scope_separator="."); |
| |
| uvm_printer_row_info row_info; |
| |
| if (name != "" && name != "...") begin |
| m_scope.set_arg(name); |
| name = m_scope.get(); |
| end |
| |
| row_info.level = m_scope.depth(); |
| row_info.name = adjust_name(name,scope_separator); |
| row_info.type_name = type_name; |
| row_info.size = (size == -2 ? "..." : $sformatf("%0d",size)); |
| row_info.val = (value == "" ? "\"\"" : value); |
| |
| m_rows.push_back(row_info); |
| |
| endfunction |
| |
| |
| // print_int |
| // --------- |
| |
| function void uvm_printer::print_int (string name, |
| uvm_bitstream_t value, |
| int size, |
| uvm_radix_enum radix=UVM_NORADIX, |
| byte scope_separator=".", |
| string type_name=""); |
| |
| uvm_printer_row_info row_info; |
| string sz_str, val_str; |
| |
| if(name != "") begin |
| m_scope.set_arg(name); |
| name = m_scope.get(); |
| end |
| |
| if(type_name == "") begin |
| if(radix == UVM_TIME) |
| type_name ="time"; |
| else if(radix == UVM_STRING) |
| type_name ="string"; |
| else |
| type_name ="integral"; |
| end |
| |
| sz_str.itoa(size); |
| |
| if(radix == UVM_NORADIX) |
| radix = knobs.default_radix; |
| |
| val_str = uvm_vector_to_string (value, size, radix, |
| knobs.get_radix_str(radix)); |
| |
| row_info.level = m_scope.depth(); |
| row_info.name = adjust_name(name,scope_separator); |
| row_info.type_name = type_name; |
| row_info.size = sz_str; |
| row_info.val = val_str; |
| |
| m_rows.push_back(row_info); |
| |
| endfunction |
| |
| |
| // print_time |
| // ---------- |
| |
| function void uvm_printer::print_time (string name, |
| time value, |
| byte scope_separator="."); |
| print_int(name, value, 64, UVM_TIME, scope_separator); |
| endfunction |
| |
| |
| // print_string |
| // ------------ |
| |
| function void uvm_printer::print_string (string name, |
| string value, |
| byte scope_separator="."); |
| |
| uvm_printer_row_info row_info; |
| |
| if(name != "") |
| m_scope.set_arg(name); |
| |
| row_info.level = m_scope.depth(); |
| row_info.name = adjust_name(m_scope.get(),scope_separator); |
| row_info.type_name = "string"; |
| row_info.size = $sformatf("%0d",value.len()); |
| row_info.val = (value == "" ? "\"\"" : value); |
| |
| m_rows.push_back(row_info); |
| |
| endfunction |
| |
| |
| // print_real |
| // ---------- |
| |
| function void uvm_printer::print_real (string name, |
| real value, |
| byte scope_separator="."); |
| |
| uvm_printer_row_info row_info; |
| |
| if (name != "" && name != "...") begin |
| m_scope.set_arg(name); |
| name = m_scope.get(); |
| end |
| |
| row_info.level = m_scope.depth(); |
| row_info.name = adjust_name(m_scope.get(),scope_separator); |
| row_info.type_name = "real"; |
| row_info.size = "64"; |
| row_info.val = $sformatf("%f",value); |
| |
| m_rows.push_back(row_info); |
| |
| endfunction |
| |
| |
| // index_string |
| // ------------ |
| |
| function string uvm_printer::index_string(int index, string name=""); |
| index_string.itoa(index); |
| index_string = { name, "[", index_string, "]" }; |
| endfunction |
| |
| |
| |
| //------------------------------------------------------------------------------ |
| // Class- uvm_table_printer |
| //------------------------------------------------------------------------------ |
| |
| // new |
| // --- |
| |
| function uvm_table_printer::new(); |
| super.new(); |
| endfunction |
| |
| |
| // calculate_max_widths |
| // -------------------- |
| |
| function void uvm_table_printer::calculate_max_widths(); |
| m_max_name=4; |
| m_max_type=4; |
| m_max_size = 4; |
| m_max_value= 5; |
| foreach(m_rows[j]) begin |
| int name_len; |
| uvm_printer_row_info row = m_rows[j]; |
| name_len = knobs.indent*row.level + row.name.len(); |
| if (name_len > m_max_name) |
| m_max_name = name_len; |
| if (row.type_name.len() > m_max_type) |
| m_max_type = row.type_name.len(); |
| if (row.size.len() > m_max_size) |
| m_max_size = row.size.len(); |
| if (row.val.len() > m_max_value) |
| m_max_value = row.val.len(); |
| end |
| endfunction |
| |
| // emit |
| // ---- |
| |
| function string uvm_table_printer::emit(); |
| |
| string s; |
| string user_format; |
| static string dash; // = "---------------------------------------------------------------------------------------------------"; |
| static string space; //= " "; |
| string dashes; |
| |
| string linefeed = {"\n", knobs.prefix}; |
| |
| calculate_max_widths(); |
| |
| begin |
| int q[5]; |
| int m; |
| int qq[$]; |
| |
| q = '{m_max_name,m_max_type,m_max_size,m_max_value,100}; |
| qq = q.max; |
| m = qq[0]; |
| if(dash.len()<m) begin |
| dash = {m{"-"}}; |
| space = {m{" "}}; |
| end |
| end |
| |
| if (knobs.header) begin |
| string header; |
| user_format = format_header(); |
| if (user_format == "") begin |
| string dash_id, dash_typ, dash_sz; |
| string head_id, head_typ, head_sz; |
| if (knobs.identifier) begin |
| dashes = {dash.substr(1,m_max_name+2)}; |
| header = {"Name",space.substr(1,m_max_name-2)}; |
| end |
| if (knobs.type_name) begin |
| dashes = {dashes, dash.substr(1,m_max_type+2)}; |
| header = {header, "Type",space.substr(1,m_max_type-2)}; |
| end |
| if (knobs.size) begin |
| dashes = {dashes, dash.substr(1,m_max_size+2)}; |
| header = {header, "Size",space.substr(1,m_max_size-2)}; |
| end |
| dashes = {dashes, dash.substr(1,m_max_value), linefeed}; |
| header = {header, "Value", space.substr(1,m_max_value-5), linefeed}; |
| |
| s = {s, dashes, header, dashes}; |
| end |
| else begin |
| s = {s, user_format, linefeed}; |
| end |
| end |
| |
| foreach (m_rows[i]) begin |
| uvm_printer_row_info row = m_rows[i]; |
| user_format = format_row(row); |
| if (user_format == "") begin |
| string row_str; |
| if (knobs.identifier) |
| row_str = {space.substr(1,row.level * knobs.indent), row.name, |
| space.substr(1,m_max_name-row.name.len()-(row.level*knobs.indent)+2)}; |
| if (knobs.type_name) |
| row_str = {row_str, row.type_name, space.substr(1,m_max_type-row.type_name.len()+2)}; |
| if (knobs.size) |
| row_str = {row_str, row.size, space.substr(1,m_max_size-row.size.len()+2)}; |
| s = {s, row_str, row.val, space.substr(1,m_max_value-row.val.len()), linefeed}; |
| end |
| else |
| s = {s, user_format, linefeed}; |
| end |
| |
| if (knobs.footer) begin |
| user_format = format_footer(); |
| if (user_format == "") |
| s = {s, dashes}; |
| else |
| s = {s, user_format, linefeed}; |
| end |
| |
| emit = s; |
| m_rows.delete(); |
| endfunction |
| |
| |
| |
| //------------------------------------------------------------------------------ |
| // Class- uvm_tree_printer |
| //------------------------------------------------------------------------------ |
| |
| |
| // new |
| // --- |
| |
| function uvm_tree_printer::new(); |
| super.new(); |
| knobs.size = 0; |
| knobs.type_name = 0; |
| knobs.header = 0; |
| knobs.footer = 0; |
| endfunction |
| |
| |
| // emit |
| // ---- |
| |
| function string uvm_tree_printer::emit(); |
| |
| string s = knobs.prefix; |
| string space= " "; |
| string user_format; |
| |
| string linefeed = newline == "" || newline == " " ? newline : {newline, knobs.prefix}; |
| |
| // Header |
| if (knobs.header) begin |
| user_format = format_header(); |
| if (user_format != "") |
| s = {s, user_format, linefeed}; |
| end |
| |
| foreach (m_rows[i]) begin |
| uvm_printer_row_info row = m_rows[i]; |
| user_format = format_row(row); |
| if (user_format == "") begin |
| string indent_str; |
| indent_str = space.substr(1,row.level * knobs.indent); |
| |
| // Name (id) |
| if (knobs.identifier) begin |
| s = {s,indent_str, row.name}; |
| if (row.name != "" && row.name != "...") |
| s = {s, ": "}; |
| end |
| |
| // Type Name |
| if (row.val[0] == "@") // is an object w/ knobs.reference on |
| s = {s,"(",row.type_name,row.val,") "}; |
| else |
| if (knobs.type_name && |
| (row.type_name != "" || |
| row.type_name != "-" || |
| row.type_name != "...")) |
| s = {s,"(",row.type_name,") "}; |
| |
| // Size |
| if (knobs.size) begin |
| if (row.size != "" || row.size != "-") |
| s = {s,"(",row.size,") "}; |
| end |
| |
| if (i < m_rows.size()-1) begin |
| if (m_rows[i+1].level > row.level) begin |
| s = {s, string'(knobs.separator[0]), linefeed}; |
| continue; |
| end |
| end |
| |
| // Value (unconditional) |
| s = {s, row.val, " ", linefeed}; |
| |
| // Scope handling... |
| if (i <= m_rows.size()-1) begin |
| int end_level; |
| if (i == m_rows.size()-1) |
| end_level = 0; |
| else |
| end_level = m_rows[i+1].level; |
| if (end_level < row.level) begin |
| string indent_str; |
| for (int l=row.level-1; l >= end_level; l--) begin |
| indent_str = space.substr(1,l * knobs.indent); |
| s = {s, indent_str, string'(knobs.separator[1]), linefeed}; |
| end |
| end |
| end |
| |
| end |
| else |
| s = {s, user_format}; |
| end |
| |
| // Footer |
| if (knobs.footer) begin |
| user_format = format_footer(); |
| if (user_format != "") |
| s = {s, user_format, linefeed}; |
| end |
| |
| if (newline == "" || newline == " ") |
| s = {s, "\n"}; |
| |
| emit = s; |
| m_rows.delete(); |
| endfunction |
| |
