In Specman, how can I tell if a reference to a unit has the do-not-generate modifier in front of it?

Question

In Specman, how can I tell if a reference to a unit has the do-not-generate modifier, '!', at the reference's definition?

e.g.

unit foo_u {
}; 

extend sys {
   foo : foo_u is instance;
   foo_ptr_generated : foo_u;
   keep foo_ptr_generated == foo;
   !foo_ptr_notgenerated : foo_u;
   connect_pointers() is also {
      foo_ptr_notgenerated = foo;
   };
};

Without inspecting the code or relying on a naming convention, how can I tell that foo_ptr_generated went through Specman's constraint solver and foo_ptr_notgenerated was procedurally set?

Answer 1

Finally figured this out. This code will determine which references are generated and which aren't in Specman 6 via the reflection interface:

<'
type my_t : [ A,B,C];
unit foo_u {
   sub_typiness : my_t;
   other_sub_typiness : my_t;


   when A'sub_typiness foo_u {
      !bar_ptr : bar_u;
   };

   when B'other_sub_typiness foo_u {
      in_b_sub_type : int;
   };

   when A'sub_typiness B'other_sub_typiness foo_u {
      in_a_b_subtype :int;
   };
   b : bah_u is instance;
};


unit bar_u {
   sub_typiness : my_t;
   other_sub_typiness :my_t;

   when B'sub_typiness bar_u {
      !foo_ptr : foo_u;
   };
   when C'other_sub_typiness bar_u {
      inc_sub_type : int;
   };

   when A'other_sub_typiness bar_u {
      !you_shouldnt_see_this_field : bah_u;
   };

   when B'sub_typiness C'other_sub_typiness bar_u{
      in_b_c_subtype :int;
   };
   !b : bah_u;
   b2 : bah_u;
};

unit bah_u {

};


extend any_unit {

   !path_to_parent :string;
   !my_e_path : string;


   post_generate() is also {
      if not me is a sys { 
         path_to_parent = get_parent_unit().e_path();
      };
      my_e_path = e_path();
   };

   print_pointers() is {
      for each ( wf ) in rf_manager.get_struct_of_instance(me).as_a(rf_like_struct).sd_.all_when_fields {
         if not str_match(wf.name,"/___/"){

         };
      };
      for each (sub_unit) in get_all_units(any_unit) {
         sub_unit.print_pointers();
      };
   };
};

struct wank_s {
   oh_joy: int;
};
extend sys {
   foo : A'sub_typiness B'other_sub_typiness foo_u is instance;
   bar : B'sub_typiness C'other_sub_typiness bar_u is instance;
   keep bar.b2 == foo.b;

   wank : wank_s;

   connect_pointers() is also {
      foo.bar_ptr = bar;
      bar.foo_ptr = foo;
      bar.b = foo.b;
   };

   !possible_ptr : any_unit;
   !is_a_unit : bool;
   !an_e_path : string;
   !a_unit : any_unit;
   !a_field : field;
   -- 
   -- rf_manager.get_all_unit_instances
   my_specman( cmd : string ) : bool is {
      try {
         --out(cmd);
         specman(cmd);
      } else {
         return FALSE;
      };
      return TRUE;
   };

   check_generation() is also {
      out("PRINT OUT FIELDS");
      var all_units : list of any_unit;
      for each any_unit(u) in get_all_units(any_unit) {
         for each ( wf ) in rf_manager.get_struct_of_instance(u).as_a(rf_like_struct).sd_.all_when_fields {
            --print wf.source_ref;
            --print wf.source_ref.to_string().as_a(uint);
            --if wf.source_ref.to_string().as_a(uint) > 1000 and not str_match(wf.name,"/___/"){
            if not str_match(wf.name,"/___|driver_trans/"){
               an_e_path = append(u.e_path(),".",wf.name);
               an_e_path = append(an_e_path, " - marked_as_reachable=",wf.fgi.marked_as_reachable);
               if wf.base_type is a struct_descriptor (s){
                  an_e_path = append(an_e_path, " - instantiated == ", s.instantiated);
               };

               if wf.base_type is a struct_descriptor (s) and not s is a list_descriptor and not s is a long_descriptor {

                  sys.is_a_unit = FALSE;
                  if not my_specman(append("sys.is_a_unit = ( ",u.e_path(),".",wf.name,
                     " != NULL)")) {
                     sys.is_a_unit = FALSE;
                  };
                  if sys.is_a_unit {
                     if not my_specman(append(" sys.is_a_unit = (",u.e_path(),".",wf.name,
                        ".as_a(any_struct) == ",u.e_path(),".",wf.name,".get_enclosing_unit(any_unit).as_a(any_struct))")) {
                        sys.is_a_unit = FALSE;
                     };
                  };

                  if sys.is_a_unit and str_match(wf.name,"/([\w_]+'+[\w_']*)[\w_]+/") {
                     if not my_specman( append( "sys.is_a_unit = ( ",u.e_path(),
                           " is a ", $1, " ", 
                           rf_manager.get_struct_of_instance(u).as_a(rf_like_struct).sd_.name,
                           ")")) {
                        sys.is_a_unit = FALSE;
                     };
                  };


                  if is_a_unit {
                     sys.a_unit = NULL;
                     if not my_specman(append("sys.a_unit = (",u.e_path(),".",wf.name,
                        ".as_a(any_unit))")) {
                        sys.a_unit = NULL;
                     };

                     if sys.a_unit != NULL {

                        sys.an_e_path = NULL;
                        var printout := append(":: ",u.e_path(), ".", wf.name);
                        compute my_specman(append( "sys.an_e_path = ",u.e_path(),".",wf.name,
                           ".my_e_path"));
                        if append(u.e_path(),".",wf.name) != sys.an_e_path {
                           printout = append(printout, " -> ");

                           printout = append(printout, sys.an_e_path);
                           if wf.fgi != NULL and wf.fgi.gcs.size() > 0 and (
                              wf.fgi.gcs[0].last_reduction != UNDEF or
                              wf.fgi.gcs[0].gcois.size() > 0 ) {


                              printout = append(printout, " GENERATED POINTER");
                           };
                        };
                        out(printout);

                     };
                  };
               };


               --out( "    ",an_e_path);

               --specman(append("print ",u.e_path(),".",wf.name));
            };
         };

         --for each ( m ) in rf_manager.get_struct_of_instance(u).as_a(rf_like_struct).sd_.methods {
         --   if m != NULL {
         --      out(m.md.name);
         --   };
         --};
         --print u.get_all_attribute_names();
         --print u.get_attribute("agent");
         --print u.agent_kind();

         -- for each (m) in rf_manager.get_struct_of_instance(u).get_declared_methods() {
         --    print m;
         -- };
         -- out("fields at '",u.e_path(),"'s struct level:");
         -- for each (f) in rf_manager.get_struct_of_instance(u).get_declared_fields() {
         --    out( "    ",u.e_path()," -> ",f.f_.short_name);
         -- };
         -- out("fields at '",u.e_path(),"'s exact sub-type level:");
         -- for each (f) in rf_manager.get_exact_subtype_of_instance(u).get_declared_fields() {
         --    out( "    ",u.e_path()," -> ",f.f_.short_name);
         -- };
         -- out("");
      };

      -- out("\nPRINT OUT UNIT INSTANCES");
      -- for each any_unit(u) in {sys;foo;bar} {
      --    for each (i) in rf_manager.get_all_unit_instances(u) {
      --       if i != u {
      --          out(u.e_path(), " has unit ", i.e_path());
      --       };
      --    };
      -- };

   };

};

'>

Running with:

specman -c 'load rf_test.e; gen'

Produces:

Generating the test using seed 1...
PRINT OUT FIELDS
:: sys.bar.B'sub_typiness'foo_ptr -> sys.foo
:: sys.bar.b -> sys.foo.b
:: sys.bar.b2 -> sys.foo.b GENERATED POINTER
:: sys.foo.A'sub_typiness'bar_ptr -> sys.bar
:: sys.foo.b
:: sys.logger.base_unit -> sys
:: sys.logger
:: sys.foo
:: sys.bar

Starting the test ...
Running the test ...