| //---------------------------------------------------------------------- | |
| // Copyright 2013 Cadence Design Systems, 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. | |
| //---------------------------------------------------------------------- | |
| //------------------------------------------------------------------------------ | |
| // | |
| // CLASS: uvm_visitor #(NODE) | |
| // | |
| // The uvm_visitor class provides an abstract base class for a visitor. The visitor | |
| // visits instances of type NODE. For general information regarding the visitor pattern | |
| // see http://en.wikipedia.org/wiki/Visitor_pattern | |
| // | |
| //------------------------------------------------------------------------------ | |
| virtual class uvm_visitor#(type NODE=uvm_component) extends uvm_object; | |
| function new (string name = ""); | |
| super.new(name); | |
| endfunction | |
| // Function: begin_v | |
| // | |
| // This method will be invoked by the visitor before the first NODE is visited | |
| virtual function void begin_v(); endfunction | |
| // Function: end_v | |
| // | |
| // This method will be invoked by the visitor after the last NODE is visited | |
| virtual function void end_v(); endfunction | |
| // Function: visit | |
| // | |
| // This method will be invoked by the visitor for every visited ~node~ of the provided structure. | |
| // The user is expected to provide the own functionality in this function. | |
| // | |
| //| class count_nodes_visitor#(type T=uvm_component) extends uvm_visitor#(T); | |
| //| function new (string name = ""); | |
| //| super.new(name); | |
| //| endfunction | |
| //| local int cnt; | |
| //| virtual function void begin_v(); cnt = 0; endfunction | |
| //| virtual function void end_v(); `uvm_info("TEXT",$sformatf("%d elements",cnt),UVM_NONE) endfunction | |
| //| virtual function void visit(T node); cnt++; endfunction | |
| //| endclass | |
| pure virtual function void visit(NODE node); | |
| endclass | |
| //------------------------------------------------------------------------------ | |
| // | |
| // CLASS: uvm_structure_proxy #(STRUCTURE) | |
| // | |
| // The uvm_structure_proxy is a wrapper and provides a set of elements | |
| // of the STRUCTURE to the caller on demand. This is to decouple the retrieval of | |
| // the STRUCTUREs subelements from the actual function being invoked on STRUCTURE | |
| // | |
| //------------------------------------------------------------------------------ | |
| virtual class uvm_structure_proxy#(type STRUCTURE=uvm_component) extends uvm_object; | |
| function new (string name = ""); | |
| super.new(name); | |
| endfunction | |
| // Function: get_immediate_children | |
| // | |
| // This method will be return in ~children~ a set of the direct subelements of ~s~ | |
| pure virtual function void get_immediate_children(STRUCTURE s, ref STRUCTURE children[$]); | |
| endclass | |
| //------------------------------------------------------------------------------ | |
| // | |
| // CLASS: uvm_visitor_adapter #(STRUCTURE,uvm_visitor#(STRUCTURE)) | |
| // | |
| // The visitor adaptor traverses all nodes of the STRUCTURE and will invoke visitor.visit() on every node. | |
| // | |
| //------------------------------------------------------------------------------ | |
| virtual class uvm_visitor_adapter#(type STRUCTURE=uvm_component,VISITOR=uvm_visitor#(STRUCTURE)) extends uvm_object; | |
| // Function: accept() | |
| // | |
| // Calling this function will traverse through ~s~ (and every subnode of ~s~). For each node found | |
| // ~v~.visit(node) will be invoked. The children of ~s~ are recursively determined | |
| // by invoking ~p~.get_immediate_children().~invoke_begin_end~ determines whether the visitors begin/end functions | |
| // should be invoked prior to traversal. | |
| pure virtual function void accept(STRUCTURE s, VISITOR v,uvm_structure_proxy#(STRUCTURE) p, bit invoke_begin_end=1); | |
| function new (string name = ""); | |
| super.new(name); | |
| endfunction | |
| endclass | |
| //------------------------------------------------------------------------------ | |
| // | |
| // CLASS: uvm_top_down_visitor_adapter | |
| // | |
| // This uvm_top_down_visitor_adapter traverses the STRUCTURE ~s~ (and will invoke the visitor) in a hierarchical fashion. | |
| // During traversal ~s~ will be visited before all subnodes of ~s~ will be visited. | |
| // | |
| //------------------------------------------------------------------------------ | |
| class uvm_top_down_visitor_adapter#(type STRUCTURE=uvm_component,VISITOR=uvm_visitor#(STRUCTURE)) extends | |
| uvm_visitor_adapter#(STRUCTURE,VISITOR); | |
| function new (string name = ""); | |
| super.new(name); | |
| endfunction | |
| virtual function void accept(STRUCTURE s, VISITOR v,uvm_structure_proxy#(STRUCTURE) p, bit invoke_begin_end=1); | |
| STRUCTURE c[$]; | |
| if(invoke_begin_end) | |
| v.begin_v(); | |
| v.visit(s); | |
| p.get_immediate_children(s, c); | |
| foreach(c[idx]) | |
| accept(c[idx],v,p,0); | |
| if(invoke_begin_end) | |
| v.end_v(); | |
| endfunction | |
| endclass | |
| //------------------------------------------------------------------------------ | |
| // | |
| // CLASS: uvm_bottom_up_visitor_adapter | |
| // | |
| // This uvm_bottom_up_visitor_adapter traverses the STRUCTURE ~s~ (and will invoke the visitor) in a hierarchical fashion. | |
| // During traversal all children of node ~s~ will be visited ~s~ will be visited. | |
| // | |
| //------------------------------------------------------------------------------ | |
| class uvm_bottom_up_visitor_adapter#(type STRUCTURE=uvm_component,VISITOR=uvm_visitor#(STRUCTURE)) extends | |
| uvm_visitor_adapter#(STRUCTURE,VISITOR); | |
| function new (string name = ""); | |
| super.new(name); | |
| endfunction | |
| virtual function void accept(STRUCTURE s, VISITOR v,uvm_structure_proxy#(STRUCTURE) p, bit invoke_begin_end=1); | |
| STRUCTURE c[$]; | |
| if(invoke_begin_end) | |
| v.begin_v(); | |
| p.get_immediate_children(s, c); | |
| foreach(c[idx]) | |
| accept(c[idx],v,p,0); | |
| v.visit(s); | |
| if(invoke_begin_end) | |
| v.end_v(); | |
| endfunction | |
| endclass | |
| //------------------------------------------------------------------------------ | |
| // | |
| // CLASS: uvm_by_level_visitor_adapter | |
| // | |
| // This uvm_by_level_visitor_adapter traverses the STRUCTURE ~s~ (and will invoke the visitor) in a hierarchical fashion. | |
| // During traversal will visit all direct children of ~s~ before all grand-children are visited. | |
| //------------------------------------------------------------------------------ | |
| class uvm_by_level_visitor_adapter#(type STRUCTURE=uvm_component,VISITOR=uvm_visitor#(STRUCTURE)) extends | |
| uvm_visitor_adapter#(STRUCTURE,VISITOR); | |
| function new (string name = ""); | |
| super.new(name); | |
| endfunction | |
| virtual function void accept(STRUCTURE s, VISITOR v,uvm_structure_proxy#(STRUCTURE) p, bit invoke_begin_end=1); | |
| STRUCTURE c[$]; | |
| c.push_back(s); | |
| if(invoke_begin_end) | |
| v.begin_v(); | |
| while(c.size() > 0) begin | |
| STRUCTURE q[$]; | |
| foreach(c[idx]) begin | |
| STRUCTURE t[$]; | |
| v.visit(c[idx]); | |
| p.get_immediate_children(c[idx], t); | |
| q = {q,t}; | |
| end | |
| c=q; | |
| end | |
| if(invoke_begin_end) | |
| v.end_v(); | |
| endfunction | |
| endclass | |
| //------------------------------------------------------------------------------ | |
| // | |
| // CLASS: uvm_component_proxy | |
| // | |
| // The class is providing the proxy to extract the direct subcomponents of ~s~ | |
| //------------------------------------------------------------------------------ | |
| class uvm_component_proxy extends uvm_structure_proxy#(uvm_component); | |
| virtual function void get_immediate_children(STRUCTURE s, ref STRUCTURE children[$]); | |
| s.get_children(children); | |
| endfunction | |
| function new (string name = ""); | |
| super.new(name); | |
| endfunction | |
| endclass | |
| //------------------------------------------------------------------------------ | |
| // | |
| // CLASS: uvm_component_name_check_visitor | |
| // | |
| // This specialized visitor analyze the naming of the current component. The established rule set | |
| // ensures that a component.get_full_name() is parsable, unique, printable to order to avoid any ambiguities | |
| // when messages are being emitted. | |
| // | |
| // ruleset a legal name is composed of | |
| // - allowed charset "A-z:_0-9[](){}-: " | |
| // - whitespace-as-is, no-balancing delimiter semantic, no escape sequences | |
| // - path delimiter not allowed anywhere in the name | |
| // | |
| // the check is coded here as a function to complete it in a single function call | |
| // otherwise save/restore issues with the used dpi could occur | |
| //------------------------------------------------------------------------------ | |
| class uvm_component_name_check_visitor extends uvm_visitor#(uvm_component); | |
| local uvm_root _root; | |
| // Function: get_name_constraint | |
| // | |
| // This method should return a regex for what is being considered a valid/good component name. | |
| // The visitor will check all component names using this regex and report failing names | |
| virtual function string get_name_constraint(); | |
| return "^[][[:alnum:](){}_:-]([][[:alnum:](){} _:-]*[][[:alnum:](){}_:-])?$"; | |
| endfunction | |
| virtual function void visit(NODE node); | |
| `ifndef UVM_NO_DPI | |
| static chandle compiled_regex; | |
| if(compiled_regex==null) | |
| compiled_regex=uvm_dpi_regcomp(get_name_constraint()); | |
| assert(compiled_regex!=null); | |
| // dont check the root component | |
| if(_root != node) | |
| if(uvm_dpi_regexec(compiled_regex, node.get_name())) | |
| `uvm_warning("UVM/COMP/NAME",$sformatf("the name \"%s\" of the component \"%s\" violates the uvm component name constraints",node.get_name(),node.get_full_name())) | |
| `endif | |
| endfunction | |
| function new (string name = ""); | |
| super.new(name); | |
| endfunction | |
| virtual function void begin_v(); | |
| uvm_coreservice_t cs = uvm_coreservice_t::get(); | |
| _root = cs.get_root(); | |
| `ifdef UVM_NO_DPI | |
| `uvm_info("UVM/COMP/NAMECHECK","This implementation of the component name checks requires DPI to be enabled",UVM_NONE) | |
| `endif | |
| endfunction | |
| virtual function void end_v(); | |
| `ifndef UVM_NO_DPI | |
| uvm_dpi_regfree(visit.compiled_regex); | |
| visit.compiled_regex=null; | |
| `endif | |
| endfunction | |
| endclass |