Subversion Repositories sv_dir_tb

////////////////////////////////////////////////////////////////////////////

//

// Copyright 2014  Ken Campbell

//

//   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.

//

/////////////////////////////////////

//  command list  class

class cmd_lst;

  tb_cmd   lst_cmds;

  lst_item file_lst;

  lst_item var_lst;

  lst_item inst_lst;

  integer lst_sz;

  integer lst_idx;

  integer last_idx;

  integer curr_line_num;

  string  file_name;

  string  include_name;

  integer  call_stack [8:1];

  integer  call_index  = 0;

  integer  loop_cnt   [7:0];

  integer  loop_term  [7:0];

  integer  loop_line  [7:0];

  integer  loop_num    = 0;

  integer  if_state    = 0;

  integer  wh_state    = 0;

  integer  wh_top      = 0;

  //prototypes

  extern function void define_instruction(string inst_txt, int args);

  extern function void define_defaults();

  extern function void load_stm(string stm_file);

  extern function void load_include();

  extern function void add_cmd(tb_cmd cmd);

  extern function void check_cmds();

  extern function tb_trans get(tb_trans inst);

  extern function integer exec_defaults(tb_trans r);

  extern function new();

  extern function void print_cmds();

  extern function void print_str();

  extern function void print_str_wvar();

endclass // cmd_lst

////////////////////////////////////////////////////////////////////////////////////////

// method definitions.

///////////////////////////////////////////////////////////

//   function cmd_lst::new

function cmd_lst::new();

  lst_cmds  =  new();

  file_lst  =  new("Files");

  var_lst   =  new("Variables");

  inst_lst  =  new("Instructions");

  lst_sz  = 0;

  lst_idx  = 0;

  last_idx  = 0;

  curr_line_num = 0;

  file_name  = "";

  include_name  = "";

endfunction // new

///////////////////////////////////////////////////////////

//  function cmd_lst::get

function tb_trans cmd_lst::get(tb_trans inst);

  tb_trans  rtn;

  cmd_lst   tmp_cmd;

  lst_item  tmp_item;

  integer   int_val;

  integer   tmp_int;

  integer   len;

  string    tmp_str;

  rtn  =  inst;

  rtn.rtn_val.par1  = 0;

  rtn.rtn_val.par2  = 0;

  rtn.rtn_val.par3  = 0;

  rtn.rtn_val.par4  = 0;

  rtn.rtn_val.par5  = 0;

  rtn.rtn_val.par6  = 0;

  if(rtn.next > rtn.cmd.lst_cmds.idx) begin

    while (rtn.next > rtn.cmd.lst_cmds.idx  && rtn.cmd.lst_cmds != null) begin

      rtn.cmd.lst_cmds = rtn.cmd.lst_cmds.next;

      check_get_next : assert (rtn.cmd.lst_cmds != null) else begin

        $fatal(0, "cmd_lst::get failed due to attemped access to commands behond the end of the script.");

      end

    end

  end else if (rtn.next < rtn.cmd.lst_cmds.idx) begin

    while (rtn.next < rtn.cmd.lst_cmds.idx  && rtn.cmd.lst_cmds != null) begin

      rtn.cmd.lst_cmds = rtn.cmd.lst_cmds.prev;

      check_get_prev : assert (rtn.cmd.lst_cmds != null) else begin

        $fatal(0, "cmd_lst::get failed due to attemped access to commands before the beginning of the script.");

      end

    end

  end

  rtn.rtn_val.cmd  = rtn.cmd.lst_cmds.cmd;

  for (int i = 1; i <= rtn.cmd.lst_cmds.valid_fld - 1; i++) begin

    case (i)

      1: tmp_str = rtn.cmd.lst_cmds.var1;

      2: tmp_str = rtn.cmd.lst_cmds.var2;

      3: tmp_str = rtn.cmd.lst_cmds.var3;

      4: tmp_str = rtn.cmd.lst_cmds.var4;

      5: tmp_str = rtn.cmd.lst_cmds.var5;

      6: tmp_str = rtn.cmd.lst_cmds.var6;

      default: $display("ERROR:  more than six parameters ????");

    endcase

    tmp_int = is_var(tmp_str);

    if (tmp_int == 0) begin

      tmp_int = stm2_int(tmp_str);

    end else if (tmp_int == 1) begin

      len = tmp_str.len();

      tmp_str = tmp_str.substr(1, len - 1);

      tmp_item = rtn.cmd.var_lst.find(tmp_str);

      tmp_int  = tmp_item.val;

    end else if (tmp_int == 2) begin

      tmp_item = rtn.cmd.var_lst.find(tmp_str);

      tmp_int  = tmp_item.index;

    end else if (tmp_int == 3) begin

      case (tmp_str)

        "==" : tmp_int = 0;

        "!=" : tmp_int = 1;

        ">"  : tmp_int = 2;

        "<"  : tmp_int = 3;

        ">=" : tmp_int = 4;

        "<=" : tmp_int = 5;

        default : $display("Condition text not found ???");

      endcase

    end else begin

      $display("is_var() returned an unknown value???");

    end

    case (i)

      1: rtn.rtn_val.par1 = tmp_int;

      2: rtn.rtn_val.par2 = tmp_int;

      3: rtn.rtn_val.par3 = tmp_int;

      4: rtn.rtn_val.par4 = tmp_int;

      5: rtn.rtn_val.par5 = tmp_int;

      6: rtn.rtn_val.par6 = tmp_int;

      default: $display("ERROR:  more than six parameters ????");

    endcase

  end

  return rtn;

endfunction

///////////////////////////////////////////////////////////

//  function  cmd_lst::define_instruction

function void cmd_lst::define_instruction(string inst_txt, int args);

  lst_item  tmp_lst;

  lst_item  new_itm;

  integer   stat = 0;

  //  search the list for this instruction

  tmp_lst = new("");

  tmp_lst = this.inst_lst;

  while(tmp_lst != null) begin

    if(tmp_lst.txt != inst_txt) begin

      tmp_lst = tmp_lst.next;

    end else begin

      check_duplicate_inst : assert (0) else begin

        $fatal(0, "Duplicate instruction definition attempted : %s", inst_txt);

      end

      //$display("ERROR: Duplicate instruction definition attempted : %s", inst_txt);

      //stat = 1;

      //return stat;

    end

  end

  // all good lets add this instruction to the list

  new_itm = new("");

  new_itm.txt = inst_txt;

  new_itm.val = args;

  inst_lst.add_itm(new_itm);

  //return stat;

endfunction  //  define_instruction

/////////////////////////////////////////////////////////

//  function cmd_lst::add_cmd

//    INPUT:  tb_cmd   cmd

function void cmd_lst::add_cmd(tb_cmd cmd);

  tb_cmd   tmp_cmd;

  tb_cmd   new_cmd;

  integer  stat  = 0;

  tmp_cmd  =  new();

  tmp_cmd  =  this.lst_cmds;

  // first

  if((this.lst_cmds.next == null) && (this.lst_cmds.cmd == "")) begin

    new_cmd       = new();

    new_cmd       = cmd;

    new_cmd.idx   = 0;

    this.lst_cmds = new_cmd;

  // second

  end else if(this.lst_cmds.next == null) begin

    new_cmd      =  new();

    new_cmd      =  cmd;

    new_cmd.idx  = 1;

    tmp_cmd.next = new_cmd;

    new_cmd.prev = tmp_cmd;

  // rest

  end else begin

    while (tmp_cmd.next != null) begin

       tmp_cmd   = tmp_cmd.next;

    end

    new_cmd      = new();

    new_cmd      = cmd;

    new_cmd.idx  = tmp_cmd.idx + 1;

    tmp_cmd.next = new_cmd;

    new_cmd.prev = tmp_cmd;

  end

  this.lst_sz++;

  this.last_idx  = new_cmd.idx;

endfunction

/////////////////////////////////////////////////////////

//  function  cmd_lst::load stimulus

function void cmd_lst::load_stm(string stm_file);

  tb_cmd   new_cmd;

  tb_cmd   tst_cmd;

  integer  in_fh;

  integer  stat = 0;

  integer  fstat = 0;

  integer  idx = 0;

  integer  len;

  integer  i, ilen;

  string   input_str;

  string   tstr;

  lst_item tmp_item;

  // open the file passed and test for existance.

  in_fh  = $fopen(stm_file, "r");

  check_file_open : assert (in_fh != 0) else begin

     $fatal(0, "ERROR: File not found in cmd_lst::load_stm : %s", stm_file);

  end

  this.file_name = stm_file;

  //  this is the main file, add to file list.

  tmp_item = new("");

  tmp_item.txt = stm_file;

  file_lst.add_itm(tmp_item);

  this.curr_line_num  = 0;

  //  new the test results storage ...

  tmp_item = new("");

  while (! $feof(in_fh)) begin

    fstat = $fgets(input_str, in_fh);

    // increment the line number

    this.curr_line_num++;

    tst_cmd = new();

    if (input_str == "\n" || input_str == "")

      continue;

    // check for special commands DEFINE_VAR and INCLUDE

    tst_cmd = tst_cmd.parse_cmd(input_str);

    len = tst_cmd.cmd.len();

    if (tst_cmd.cmd == "DEFINE_VAR") begin

      tmp_item.txt =  tst_cmd.var1;

      tmp_item.val =  stm2_int(tst_cmd.var2);

      var_lst.add_itm(tmp_item);

    //  check for  INCLUDE file def

    end else if (tst_cmd.cmd == "INCLUDE") begin

      if(tst_cmd.var1 != "") begin

        this.include_name = tst_cmd.var1;

      end else if (tst_cmd.cmd_str != "") begin

        tstr  = tst_cmd.cmd_str;

        ilen = tstr.len();

        i  =  ilen-1;

        //  strip any  trailing spaces

        while(tstr[i] == " ") begin

          tstr = tstr.substr(0,i-1);

          i--;

        end

        this.include_name = tstr;

      end else begin

        check_include : assert (0) else begin

          $fatal(0, "No INCLUDE file found in command on\n line:  %4d in file: %s", curr_line_num, stm_file);

        end

      end

      this.load_include();

    //  check for inline variable.

    end else if(tst_cmd.cmd[len-1] == ":") begin

      tmp_item.txt =  tst_cmd.cmd.substr(0, len-2);

      tmp_item.val =  this.last_idx + 1;

      var_lst.add_itm(tmp_item);

    //  else is a standard command

    end else begin

      //  parse out the command

      new_cmd = new();

      new_cmd = new_cmd.parse_cmd(input_str);

      if (new_cmd.valid_fld > 0) begin

        new_cmd.line_num = curr_line_num;

        new_cmd.file_idx =  0;

        this.add_cmd(new_cmd);

      end

    end

  end // while (! $feof(in_fh))

  check_cmds();

endfunction // load_stm

//////////////////////////////////////////////////////

//  function cmd_lst::load_include

function void cmd_lst::load_include();

  tb_cmd   tmp_cmd;

  tb_cmd   new_cmd;

  tb_cmd   tst_cmd;

  integer  inc_fh;

  integer  stat = 0;

  integer  idx = 0;

  string   input_str;

  lst_item tmp_item;

  lst_item var_item;

  integer  file_idx;

  integer  len;

  integer  file_line = 0;

  // open the file passed and test for existance.

  inc_fh  = $fopen(this.include_name, "r");

  check_include_open : assert(inc_fh != 0) else begin

    $fatal(0, "INCLUDE File not found: %s\nFound in file:  %s\nOn line:  %4d", this.include_name, this.file_name, this.curr_line_num);

  end

  //  this is an include file, add to list.

  tmp_item = new("");

  tmp_item.txt = this.include_name;

  file_lst.add_itm(tmp_item);

  tmp_item = file_lst.find(this.include_name);

  file_idx = tmp_item.index;

  //  new the test results storage ...

  var_item = new("");

  while (! $feof(inc_fh)) begin

    file_line++;

    stat = $fgets(input_str, inc_fh);

    tst_cmd = new();

    // skip  blank lines

    if (input_str == "\n" || input_str == "")

      continue;

    // check for special commands DEFINE_VAR, INCLUDE and inline variables

    tst_cmd = tst_cmd.parse_cmd(input_str);

    len = tst_cmd.cmd.len();

    //  DEFINE_VAR

    if (tst_cmd.cmd == "DEFINE_VAR") begin

      var_item.txt =  tst_cmd.var1;

      var_item.val =  stm2_int(tst_cmd.var2);

      var_lst.add_itm(var_item);

      continue;

    //  INCLUDE  Not nested.

    end else if (tst_cmd.cmd == "INCLUDE") begin

        check_nest_include : assert (0) else begin

          $fatal(0, "INCLUDE can not be nested!!\nFound in file:  %s\nOn line:  %4d", this.include_name, file_line);

        end

    //  In line VAR

    end else if (tst_cmd.cmd[len - 1] == ":") begin

      var_item.txt =  tst_cmd.cmd.substr(0, len-2);

      var_item.val =  this.last_idx + 1;

      var_lst.add_itm(var_item);

      continue;

    end

    //  parse out the command

    new_cmd = new();

    new_cmd = new_cmd.parse_cmd(input_str);

    if (new_cmd.valid_fld > 0) begin

      new_cmd.file_idx = file_idx;

      new_cmd.line_num = file_line;

      this.add_cmd(new_cmd);

    end

  end // while (! $feof(inc_fh))

endfunction // load_include

////////////////////////////////////////////////////////////

//  function  check_cmds

//    checks that the commands loaded exist, have correct # params and

//    variable names exist

function void cmd_lst::check_cmds();

  tb_cmd   tmp_cmd;

  tb_cmd   dum;

  int      found;

  string   cname;

  string   fname;

  string   t_var;

  byte     c;

  int      num_params;

  lst_item tmp_lst;

  lst_item flst;

  lst_item tmp_item;

  integer  stat = 0;

  integer  file_idx;

  integer  len;

  integer  vtype;

  tmp_cmd = this.lst_cmds;

  //  go through all the commands from the stimulus file.

  while(tmp_cmd != null) begin

    cname      = tmp_cmd.cmd;

    num_params = tmp_cmd.valid_fld;

    tmp_lst    = this.inst_lst;

    found      = 0;

    //  get the file name from this command

    file_idx   = tmp_cmd.file_idx;

    flst       = this.file_lst;

    while (flst != null) begin

      if(flst.index == file_idx) begin

        fname = flst.txt;

      end

      flst  = flst.next;

    end

    //  go through the  list of valid commands

    while (tmp_lst != null  &&  found == 0) begin

      if (tmp_lst.txt == cname) begin

              found = 1;

              check_num_params : assert ((tmp_lst.val == num_params - 1) || (tmp_lst.val >= 7)) else begin

                $fatal(0, "Incorrect number of parameters found in command on\n        line: %4d   in file: %s", tmp_cmd.line_num, fname);

              end

      end

      tmp_lst = tmp_lst.next;

    end

    //  if we did not find a command

    check_valid_instruction : assert (found != 0) else begin

      $fatal(0, "Command  %s  was not found in the list of valid commands on\n        line: %4d   in file: %s", cname, tmp_cmd.line_num, fname);

    end

    //  Check the line for invalid variable names

    if(num_params != 0) begin

      tmp_lst = this.var_lst;

      for (int i = 1; i <= num_params - 1; i++) begin

        case (i)

          1: t_var = tmp_cmd.var1;

          2: t_var = tmp_cmd.var2;

          3: t_var = tmp_cmd.var3;

          4: t_var = tmp_cmd.var4;

          5: t_var = tmp_cmd.var5;

          6: t_var = tmp_cmd.var6;

          default: $display("ERROR: num_params greater than six???");

        endcase

        c = t_var[0];

        vtype = is_var(t_var);

        if(vtype) begin

          if(c == "$") begin

            len   = t_var.len();

            t_var = t_var.substr(1, len - 1);

          end

          //  if condition operator skip

          if(vtype == 3) begin

            continue;

          end

        end else begin

          continue;

        end

        tmp_item  =  var_lst.find(t_var);

        check_valid_variable : assert (tmp_item != null) else begin

          $fatal(0, "Variable number: %2d >>> %s <<< on line %4d   in file: %s   Is NOT defined!!", i, t_var, tmp_cmd.line_num, fname);

        end

      end

    end

    tmp_cmd = tmp_cmd.next;

  end

endfunction   //  cmd_lst::check_cmds

/////////////////////////////////////////////////////////////

//

 function void cmd_lst::define_defaults();

    this.define_instruction("ABORT", 0);

    this.define_instruction("FINISH", 0);

    this.define_instruction("EQU_VAR", 2);

    this.define_instruction("ADD_VAR", 2);

    this.define_instruction("SUB_VAR", 2);

    this.define_instruction("CALL", 1);

    this.define_instruction("RETURN_CALL", 0);

    this.define_instruction("JUMP", 1);

    this.define_instruction("LOOP", 1);

    this.define_instruction("END_LOOP", 0);

    this.define_instruction("IF", 3);

    this.define_instruction("ELSEIF", 3);

    this.define_instruction("ELSE", 0);

    this.define_instruction("END_IF", 0);

    this.define_instruction("WHILE", 3);

    this.define_instruction("END_WHILE", 0);

endfunction  //  define_defaults

///////////////////////////////////////////////////////////////////

//

function integer cmd_lst::exec_defaults(tb_trans r);

  integer rtn  = 0;

  lst_item tmp_item;

  integer  idx = 0;

  string   cmd_string;

  // get the command string

  cmd_string = r.cmd.lst_cmds.cmd;

  //  output the dynamic text if there is some. (Note:  before command runs.)

  r.cmd.print_str_wvar();

  ///  The Main  else if chain  /////////////////////////////////////////////////

  //  ABORT

  if(cmd_string == "ABORT") begin

    $display("The test has aborted due to an error!!");

    $finish(2);

    rtn = 1;

  ///////////////////////////////////////////////////////////////////////////

  //  FINISH

  end else if (cmd_string == "FINISH") begin

    $display("Test Finished with NO error!!");

    $finish();

    rtn = 1;

  ///////////////////////////////////////////////////////////////////////////

  //  ADD_VAR

  end else if (cmd_string == "ADD_VAR") begin

    tmp_item = this.var_lst.get(r.rtn_val.par1);

    idx      = tmp_item.index;

    tmp_item.val = tmp_item.val + r.rtn_val.par2;

    r.cmd.var_lst.set(idx, tmp_item.val);

    rtn = 1;

  ///////////////////////////////////////////////////////////////////////////

  //  SUB_VAR

  end else if (cmd_string == "SUB_VAR") begin

    tmp_item = this.var_lst.get(r.rtn_val.par1);

    idx      = tmp_item.index;

    tmp_item.val = tmp_item.val - r.rtn_val.par2;

    r.cmd.var_lst.set(idx, tmp_item.val);

    rtn = 1;

  ///////////////////////////////////////////////////////////////////////////

  //  EQU_VAR

  end else if (cmd_string == "EQU_VAR") begin

    tmp_item = this.var_lst.get(r.rtn_val.par1);

    idx      = tmp_item.index;

    tmp_item.val = r.rtn_val.par2;

    r.cmd.var_lst.set(idx, tmp_item.val);

    rtn = 1;

  ///////////////////////////////////////////////////////////////////////////

  //  CALL

  end else if (cmd_string == "CALL") begin

    call_index++;

    check_call_depth : assert(call_index <= 8) else begin

        $fatal(0,"CALL nesting depth maximum is 7.  On Line: %4d",  r.cmd.lst_cmds.line_num);

    end

    call_stack[call_index] = r.cmd.lst_cmds.idx + 1;

    r.next = r.rtn_val.par1;

    rtn = 1;

  ///////////////////////////////////////////////////////////////////////////

  //  RETURN_CALL

  end else if (cmd_string == "RETURN_CALL") begin

    check_call_under_run : assert(call_index > 0) else begin

        $fatal(0,"RETURN_CALL causing nesting underflow?.  On Line: %4d",  r.cmd.lst_cmds.line_num);

    end

    r.next = call_stack[call_index];

    call_index--;

    rtn = 1;

  ///////////////////////////////////////////////////////////////////////////

  //  JUMP

  end else if (cmd_string == "JUMP") begin

    r.next  =  r.rtn_val.par1;

    call_index = 0;

    rtn = 1;

  ///////////////////////////////////////////////////////////////////////////

  //  LOOP

  end else if (cmd_string == "LOOP") begin

    loop_num++;

    loop_line[loop_num] = r.cmd.lst_cmds.idx + 1;

    loop_cnt[loop_num]  = 0;

    loop_term[loop_num] = r.rtn_val.par1;

    rtn = 1;

  ///////////////////////////////////////////////////////////////////////////

  //  END_LOOP

  end else if (cmd_string == "END_LOOP") begin

    loop_cnt[loop_num]++;

    if(loop_cnt[loop_num] == loop_term[loop_num]) begin

      loop_num--;

      r.next = r.cmd.lst_cmds.idx + 1;

    end else begin

      r.next = loop_line[loop_num];

    end

    rtn = 1;

  ///////////////////////////////////////////////////////////////////////////

  //  IF

  end else if (cmd_string == "IF") begin

    if_state = 0;

    case (r.rtn_val.par2)

      0: if(r.rtn_val.par1 == r.rtn_val.par3) if_state = 1;

      1: if(r.rtn_val.par1 != r.rtn_val.par3) if_state = 1;

      2: if(r.rtn_val.par1 >  r.rtn_val.par3) if_state = 1;

      3: if(r.rtn_val.par1 <  r.rtn_val.par3) if_state = 1;

      4: if(r.rtn_val.par1 >= r.rtn_val.par3) if_state = 1;

      5: if(r.rtn_val.par1 <= r.rtn_val.par3) if_state = 1;

      default:  if_op_error : assert (0) else begin

        $fatal(0, "IF statement had unknown operator in par2.  On Line: %4d", r.cmd.lst_cmds.line_num);

      end

    endcase

    if (!if_state) begin

      r          = r.cmd.get(r);

      cmd_string = r.cmd.lst_cmds.cmd;

      r.next++;

      while(cmd_string != "ELSE" && cmd_string != "ELSEIF" && cmd_string != "END_IF") begin

        r          = r.cmd.get(r);

        cmd_string = r.cmd.lst_cmds.cmd;

        r.next++;

        check_if_end : assert (r.cmd.lst_cmds.next != null) else begin

          $fatal(0,"Unable to find terminating element for IF statement!!");

        end

      end

      r.next--;

    end

    rtn = 1;

  ///////////////////////////////////////////////////////////////////////////

  //  ELSEIF

  end else if (cmd_string == "ELSEIF") begin

    if(if_state) begin

      r          = r.cmd.get(r);

      cmd_string = r.cmd.lst_cmds.cmd;

      r.next++;

      while(cmd_string != "END_IF") begin

        r          = r.cmd.get(r);

        cmd_string = r.cmd.lst_cmds.cmd;

        r.next++;

        check_elseif_statement : assert (r.cmd.lst_cmds.next != null) else begin

          $fatal(0,"Unable to find terminating element for ESLEIF statement!!");

        end

      end

      r.next--;

    end else begin

      case (r.rtn_val.par2)

        0: if(r.rtn_val.par1 == r.rtn_val.par3) if_state = 1;

        1: if(r.rtn_val.par1 != r.rtn_val.par3) if_state = 1;

        2: if(r.rtn_val.par1 >  r.rtn_val.par3) if_state = 1;

        3: if(r.rtn_val.par1 <  r.rtn_val.par3) if_state = 1;

        4: if(r.rtn_val.par1 >= r.rtn_val.par3) if_state = 1;

        5: if(r.rtn_val.par1 <= r.rtn_val.par3) if_state = 1;

        default:  elseif_op_error : assert (0) else begin

          $fatal(0, "ELSEIF statement had unknown operator in par2.  On Line: %4d", r.cmd.lst_cmds.line_num);

        end

      endcase

      if (!if_state) begin

        r          = r.cmd.get(r);

        cmd_string = r.cmd.lst_cmds.cmd;

        r.next++;

        while(cmd_string != "ELSE" && cmd_string != "ELSEIF" && cmd_string != "END_IF") begin

          r          = r.cmd.get(r);

          cmd_string = r.cmd.lst_cmds.cmd;

          r.next++;

          check_elseif_end : assert (r.cmd.lst_cmds.next != null) else begin

            $fatal(0,"Unable to find terminating element for IF statement!!");

          end

        end

        r.next--;

      end

    end

    rtn = 1;

  ///////////////////////////////////////////////////////////////////////////

  //  ELSEIF

  end else if (cmd_string == "ELSE") begin

    if(if_state) begin

      r          = r.cmd.get(r);

      cmd_string = r.cmd.lst_cmds.cmd;

      r.next++;

      while(cmd_string != "END_IF") begin

        r          = r.cmd.get(r);

        cmd_string = r.cmd.lst_cmds.cmd;

        r.next++;

        check_else_statement : assert (r.cmd.lst_cmds.next != null) else begin

          $fatal(0,"Unable to find terminating element for ELSE statement!!");

        end

      end

      r.next--;

    end

    rtn = 1;

  ///////////////////////////////////////////////////////////////////////////

  //  END_IF

  end else if (cmd_string == "END_IF") begin

    rtn = 1;

    //  This command is just a place holder, skip to next instruction.

  ///////////////////////////////////////////////////////////////////////////

  //  WHILE   non-nested implementation

  end else if (cmd_string == "WHILE") begin

    wh_state = 0;

    wh_top =  r.cmd.lst_cmds.idx;

    case (r.rtn_val.par2)

      0: if(r.rtn_val.par1 == r.rtn_val.par3) wh_state = 1;

      1: if(r.rtn_val.par1 != r.rtn_val.par3) wh_state = 1;

      2: if(r.rtn_val.par1 >  r.rtn_val.par3) wh_state = 1;

      3: if(r.rtn_val.par1 <  r.rtn_val.par3) wh_state = 1;

      4: if(r.rtn_val.par1 >= r.rtn_val.par3) wh_state = 1;

      5: if(r.rtn_val.par1 <= r.rtn_val.par3) wh_state = 1;

      default:  while_op_error : assert (0) else begin

        $fatal(0, "WHILE statement had unknown operator in par2.  On Line: %4d", r.cmd.lst_cmds.line_num);

      end

    endcase

    if(!wh_state) begin

      while(cmd_string != "END_WHILE") begin

        r          = r.cmd.get(r);

        cmd_string = r.cmd.lst_cmds.cmd;

        r.next++;

        check_while_statement : assert (r.cmd.lst_cmds.next != null) else begin

          $fatal(0,"Unable to find terminating element for WHILE statement!!");

        end

      end

    end

    rtn = 1;

  ///////////////////////////////////////////////////////////////////////////

  //  END_WHILE

  end else if (cmd_string == "END_WHILE") begin

    r.next  = wh_top;

    rtn = 1;

  end

  return rtn;

endfunction  //  exec_defaults

//  dynamic print function.

function void cmd_lst::print_str();

  if (this.lst_cmds.cmd_str != "") begin

    $display("%s", this.lst_cmds.cmd_str);

  end

endfunction

//  dynamic print function with variable sub

//    output var in HEX.

function void cmd_lst::print_str_wvar();

  integer len;

  integer vlen;

  integer v;

  integer i = 0;

  integer j = 0;

  integer val;

  string  sval;

  string  tmp;

  string  tmpv;

  string  vari;

  string  varv;

  lst_item  lvar;

  if (this.lst_cmds.cmd_str == "") begin

    return;

  end

  len = this.lst_cmds.cmd_str.len();

  tmp = this.lst_cmds.cmd_str;

  while (i < len) begin

    if (tmp[i] == "$") begin

      i++;

      j = 0;

      vari = "";

      while (tmp[i] != " " && i < len) begin

        vari = {vari,tmp[i]};

        i++;

        j++;

      end

      lvar = this.var_lst.find(vari);

      val  = lvar.val;

      //  convert var to str

      $sformat(varv,"%x",val);

      j = 0;

      vlen = varv.len();

      tmpv = varv;

      //  strip pre-padding

      while(varv[j] == "0" && j < vlen) begin

        j++;

        v = tmpv.len();

        tmpv = tmpv.substr(1, v-1);

      end

      sval = {sval, "0x", tmpv};

    end else begin

      sval = {sval,tmp[i]};

      i++;

    end

  end

  $display(sval);

endfunction

////////////////////////////////////////////////////////////

//  print commands function: intened for debug and dev

function void cmd_lst::print_cmds();

  tb_cmd   tmp_cmd;

  tmp_cmd = this.lst_cmds;

  while(tmp_cmd != null) begin

    tmp_cmd.print();

    tmp_cmd = tmp_cmd.next;

  end

  //tmp_cmd.print();

  $display("List Size:  %s", this.lst_sz);

  $display();

  $display();

endfunction // print_cmds