Specman/e constraint (for each in) iteration

Can I iterate through only a part of a list in e, in a constraint. For example, this code will go through the whole layer_l list:

<'

struct layer_s {
  a : int;
    keep soft a == 3;
};

struct layer_gen_s {
  n_layers : int;
    keep soft n_layers == 8;
  layer_l  : list of layer_s;
    keep layer_l.size() == read_only(n_layers);
};

extend sys {
  layer_gen : layer_gen_s;     

  run() is also {
    messagef(LOW, "n_layers = %0d", layer_gen.n_layers);
    for each in layer_gen.layer_l{
      messagef(LOW, "layer[%2d]: a = %0d", index, it.a);
    };
  };
};

-- this will go through all layer_l
extend layer_gen_s {    
  keep for each (layer) using index (i) in layer_l {
    layer.a == 7;
  };
};

But, I would like to only iterate the for each in through, for example, 2 items. I tried the code below, but it doesn't work:

-- this produces an error
extend layer_gen_s {    
  keep for each (layer) using index (i) in [layer_l.all(index < 2)] {
    layer.a == 7;
  };
};

Also I don't want to use implication, so this is not what I want:

-- not what I want, I want to specify directly in iterated list
extend layer_gen_s {    
  keep for each (layer) using index (i) in layer_l {
    (i < 2) => {
      layer.a == 7;
    };
  };
};

Using the list slicing operator doesn't work either, because the path in a for..each constraint is limited to a simple path (e.g. a list variable). The following doesn't work either:

keep for each (layer) using index (i) in layer_l[0..2] {
  //...
};

This is a Specman limitation.

To force looping over a sub-list your only bet is to create that sub-list as a separate variable:

layer_subl: list of layer_s;
keep layer_subl.size() == 3;
keep for each (layer) using index (i) in layer_subl {
  layer == layer_l[i];
};

Now you can loop on only the first 3 elements within your for..each constraint:

keep for each (layer) in layer_subl {
  layer.a == 7;
};

This avoids using implication inside the constraint. Whether this is worth is for you to decide. Also note that the lists will contain the same objects (this is good). No extra struct objects get created.

Creation of the sub-list like this is boilerplate code that could be handled by the tool itself. This would make the code much more concise and readable. You could contact your vendor and request this feature.